The Philosophy Behind

Now that you understand how Be Framework works in practice, let’s explore the deep philosophical principles that make it possible.

Wu Wei: The Art of Non-Doing

Wu Wei (無為) is the ancient Chinese principle of “actionless action”—achieving through being rather than forcing through doing.

In Be Framework, this manifests as:

// Not this (imperative doing):
$validator->validate($email);
$formatter->format($name);
$user->save();

// But this (natural becoming):
$user = $becoming(new UserInput($email, $name));
// The user simply becomes what it's meant to be

Objects don’t “do” anything—they become what they are through natural transformation. Like water flowing downhill, the path emerges from the nature of things, not from external commands.

Immanent and Transcendent: The Dance of Existence

These terms come from philosophy, describing how beings come into meaningful existence:

Immanent: What something already is—its inherent nature, identity, essence. The “self” that persists through change.

Transcendent: What comes from beyond the self—context, capabilities, meaning provided by the world.

// Philosophical example in code:
final readonly class Greeting
{
    public function __construct(
        #[Input] string $name,                // Immanent: who you are
        #[Inject] CultureService $culture     // Transcendent: how the world greets
    ) {
        $this->message = $culture->formatGreeting($name);  // New being emerges
    }
}

This mirrors how humans become who they are—not through internal properties alone, but through encountering others, culture, and world beyond themselves.

BE = Be, Everything

BE represents the universal scope of this principle:

Be: Focus on existence, not action
Everything: This principle applies to all programming domains

Whether you’re processing:

Database records → Domain objects
HTTP requests → API responses
User input → Validated commands
Raw data → Business insights

The pattern remains the same: Immanent + Transcendent → New Immanent

Ontological Programming

Ontology is the philosophical study of existence—what it means for something “to be.”

Ontological Programming asks: “What can exist?” rather than “What should happen?”

// Traditional: "How do I validate this email?"
if ($email->isValid()) {
    $user = new User($email);
    $user->save();
}

// Ontological: "What exists when email meets validation?"
#[Be(ValidatedUser::class)]
final readonly class EmailInput { /* ... */ }

final readonly class ValidatedUser { /* ... */ }  // This simply exists or doesn't

We design by declaring what forms of existence are possible, then let objects naturally become those forms.

Subject-Object Unity

In traditional programming, there’s always a “controller” that commands objects. In Be Framework, objects are their own subjects—they determine their own transformation.

// The object decides its own destiny
public SuccessfulPayment|FailedPayment $being;

public function __construct(/* ... */) {
    $this->being = $this->isValid 
        ? new SuccessfulPayment(/* ... */)
        : new FailedPayment(/* ... */);  // Self-determination
}

No external orchestrator tells the object what to become. The transformation emerges from the object’s own nature meeting the world’s capabilities.

Temporal Being

Objects in Be Framework exist in time—they have memory of their past (Immanent) and knowledge of their potential futures (Being Property with union types).

final readonly class UserProfile
{
    // Memory of past
    #[Input] string $originalEmail;
    
    // Present being  
    public string $displayName;
    
    // Potential futures
    public ActiveUser|SuspendedUser $being;
}

This creates temporal awareness—objects understand their place in the flow of transformation.

The Beauty of Natural Law

Just as physics describes how matter naturally transforms under different forces, Be Framework describes how data naturally transforms through constructor injection.

The laws are simple:

Immutable existence: Each stage is complete and unchanging
Constructor metamorphosis: All transformation happens at the moment of becoming
Self-determination: Objects choose their own destiny based on their nature
Transparent state: Everything is public and readable

These simple laws create infinite possibility for complex, natural transformation—just like how simple physical laws create the infinite complexity of the universe.

“Be Framework is not just a way to write code—it’s a way to think about existence, transformation, and the natural flow of becoming in digital realms.”

The Paradigm Shift

Understanding this philosophy changes how you approach programming:

From commanding objects → creating conditions for becoming
From managing state → enabling natural transformation
From controlling flow → declaring possibilities
From doing → being

This is the essence of Ontological Programming—programming that aligns with the natural principles of existence and transformation.