The Problem Space

3 min read
Suggest an edit

Modern software engineering has comfortably solved the problem of "how to compute a value." We have excellent functional and imperative languages for pure algorithms, data processing, and highly optimized CPU-bound mathematics.

However, the industry struggles immensely with a different category of problem: long-lived, stateful orchestration in distributed environments.

When we try to manage cloud infrastructure, orchestrate complex deployment pipelines, or build highly reliable backend control planes, traditional programming languages and paradigms fall short.

Imperative Orchestration is Fragile

When engineers write imperative scripts (in Python, Go, or shell) to manage infrastructure or orchestrate services, they are manually describing how a machine should transition from point A to point B.

  1. Do X
  2. Check if Y is ready
  3. If Y is ready, do Z
  4. (What if the network fails here?)
  5. (What if X was successful, but the database says no?)

Every network call, every API response, and every external state mutation introduces branching chaos. Maintaining an accurate mental model of failure recovery quickly becomes impossible.

"Works on My Machine" at Scale

Because execution often depends on wall-clock time, randomized retry jitter, arbitrary preemption, and external API latency, almost all imperative orchestration logic is non-deterministic.

When a deployment script fails halfway in production, it is agonizingly difficult to replay the exact same sequence of events locally. The failure may have been caused by an arbitrary thread scheduling blip that you can never reproduce.

The Gap Between Intent and Execution

Tools like Terraform or Kubernetes manifests allow developers to declare what they want (e.g., "I want 5 replicas"), but they use domain-specific configuration languages mapping to hidden, hard-coded backend controllers written in Go. They are not highly expressive general-purpose programming languages.

When you exceed the boundaries of a YAML configuration file, you are forced to retreat to writing imperative orchestrators that lack built-in persistence, crash recovery, and convergence guarantees.

The Ved Thesis

We need a general-purpose language where:

  1. Convergence and declarative goals are native syntax constructs, not just YAML configurations.
  2. Determinism is guaranteed at the lowest runtime level, so an orchestration failure is perfectly mathematically replayable.
  3. Programs are treated as persistent living systems that automatically pause and resume their state if the execution node crashes, rather than ephemeral loops that lose track of their context.

The problem space of Ved is the taming of chaotic operational logic into safe, predictable system evolution.