Chomik: A Programming Language Without Conditional Instructions

One of the most common features in programming languages is the conditional instruction. In C, for example, we write:
if (our_condition)
{
printf("it is TRUE!\n");
}
else
{
printf("it is FALSE!\n"); *
}
This is so familiar that many programmers treat it as an inevitable part of programming. But is it really necessary?

In Chomik, the answer is no.
Thanks to two core features of the language — the evaluation operator (<...>) and compound variable names — combined with the built-in code type, we can eliminate conditional instructions entirely. The result is a cleaner and more uniform design.

The Three Ingredients

1. Evaluation Operator <...>
   In Chomik, you can dynamically construct the name of a variable and then evaluate it. This means that the program can decide which variable to use based on the value of another variable.

2. Compound Variable Names
   Variable names in Chomik can be sequences of identifiers and/or literals. This allows you to have an entire family of variables like:

   • do something on true

   • do something on false

and then select among them simply by evaluating <do something on <our condition>>.

3. The code Type
   Chomik has a built-in code type, which means that code itself is a value. You can store it in a variable, pass it around, and execute it just like any other value.

Putting It All Together

Instead of writing an if statement, we define two code variables:

variable do something on true:code, do something on false:code;
let do something on true = value code { <print "it is TRUE!">; };
let do something on false = value code { <print "it is FALSE!">; };

Now we define our condition:

variable our condition:boolean;
let our condition = value boolean true;
<do something on <our condition>>;
let our condition = value boolean false;
<do something on <our condition>>;
No special syntax for if is needed — just consistent use of variables, values, and evaluation.

Why This is Cleaner

Traditional conditional instructions like if are special cases in the language. They require dedicated syntax, parsing rules, and semantics. In Chomik, we don’t need them because the same mechanism that handles all variable evaluations can also handle conditional branching.

This makes Chomik:

• Simpler — fewer ad-hoc constructs in the language.

• More uniform — conditions, loops, and code execution are all handled by the same evaluation logic.

• More powerful — since variable names and code values can be constructed dynamically, you can create highly flexible behavior without introducing new syntax.

---

In short, Chomik doesn’t have a conditional instruction — and it doesn’t need one.
It’s not a limitation — it’s a design choice that keeps the language elegant and consistent.

---