Ask HN: Why Are Conditionals Important?

Conditionals allow a program to react to the data it is presented with. This can be data from the outside world, or data from some other module internal to a program composed out of modules (i.e. subroutines, for example). Without conditionals - or their moral equivalent - programs would not be able to react to their inputs or to changes in their internal state.

--

There are Turing-complete languages without conditionals, though - even without data, as such! An example is the lambda calculus. If you want to learn more about this, read up on "Church encoding" and "Scott encoding".

The basic idea is to use functions and the visitor pattern to encode a kind of conditional behaviour that varies with the input supplied to it.

  True = (lambda (t f) (t))
  False = (lambda (t f) (f))
  If = (lambda (b tr fa) (b tr fa))

  (lambda (x)
    (If x
        (lambda () (display "It was true!"))
        (lambda () (display "It was false!"))))

There are styles of programming with no conditionals, especially in purely functional languages.

A common technique inside compilers is to separate out which code gets run, and which result gets used. If everything is side-effect-free, then there's no harm in running the code whose result won't get used. In highly parallel systems, you can just run both versions and select at the end. So you can rewrite:

  if foo < 2:
    a = foo
  else
    a = 2

  a = phi(foo<2, 2, foo)

Some operations are basic enough that theoretically you can build any other operation out of them. “NAND” is commonly used as an example but in practice “nand” doesn’t really map to how people think. Conditionals are another one. They are a bit more complicated in a sense (three inputs rather than two) but they map better to how people think so people actually use them in practice.

So Turing completeness is basically two things. 1: the ability to compose an arbitrary number of conditional statements. 2: the ability to keep computing recursively, until some output is true.

Without conditionals, every program either terminates after a pre-specified amount of computation or never terminates. That leaves you extremely limited in what you can accomplish (less powerful than a DFA).

A DFA or maybe a 2DFA (which are equally powerful) is basically what you get when all you have is conditionals.

Without that, what you have is a box that can read finite input and compute a value. Equivalent to a finite lookup table.

Conditionals actually destroy information. The way they are written does not even matter; Consider the evaluation of this functional pseudocode:

   min(a,b) := if(a < b, a, b)

Interestingly (but I think there is no deeper connection), vectorization uses masks to avoid branching. Programmatically, one implements then both branches at the same time, and on a per-data level different operations are performed. A simple pseudo-numpy example would be

   B[where(A < B)] = A
   which should actually read component by component, for
   instance, having A and B being matrices,

      B_{ij} = A_{ij}  if A_{ij} < B_{ij}
               B_{ij}  else  ("no-op")

Are you not approaching it a bit too much from a high level perspective?

From assembly(x86), most conditionals and loops break down to cmp/test and jmp,jx,jnx type instructions.

Computers need to make decisions based on comparisons of data or program state. You can abstract decision making however you want (e.g.: switch statements in place of if/else or usage of goto's) but the computer needs to test or compare and decide on what instruction to execute based on the result.

Let me invent a new condtional 'alot':

for i in range(0,100): alot i: exit(1)

instead of testing for boolean true/false. My conditional "alot" tests the result of the evaluation against the value range of the type,if the result is over half of the value range it executes the conditional statement (exit())

Of course I am being a bit silly but my point is my silly conditional much like if/else breaks down to comparing and jumping based on evaluation (i.e: instead of a jz/jnz it will break down to jge)

To simplify, software (generally) does this:

    input >>> output

Isn't this really basic stuff? Or am I missing something?

In a trivial way, logical gates (AND, OR, etc) are conditionals. So, we need these gates to build any logical expressions. And many problems can be reduced to satisfiability, etc.

Taking in input, and making decisions based on that input, are what computers are for. And conditionals are the simplest version of "making a decision".

Most computer programs are, in practice, difference amplifiers. Conditionals are how they achieve that.

("Most" because you have programs like image classifiers that are trying to be similarity amplifiers. That turns out to be hard to do with the standard building blocks, which want to be difference amplifiers. Perhaps different building blocks would be more useful.)

It is possible to approximate logical expressions without conditionals. This is an old problem in neural networks. See more here: https://towardsdatascience.com/emulating-logical-gates-with-...

I apologize, but I really am having a hard time understanding your question at all. Every non-trivial computation requires some kind of conditional.

The first computers were literally people, they computed. There wasn't really a lot of "conditional" work to what they did, they did math (principally numerical work) like generating tables of data and compiling the results. They still needed some conditionals, like if a value was over a certain threshold, use a particular formula or change some parameter.

The early mechanical computers were largely tabulators of the same sort, but machines and not people. But as you want to express more complicated computations, you need the ability to branch. Conditionals are just a means for executing such a branch. Even the simplest of computational machines (in the theory sense) like regular expressions and deterministic finite automata include a branch or conditional element: Given input C while in state S go to state S'. A simple way to visualize this decision matrix is with a table:

  Input | S_0 | S_1
  -----------------
    0   | S_0 | S_0
    1   | S_1 | S_1
  Accepting states = {S_0}

Even trying to compute taxes or payroll depended on conditionals (income level determines which tax brackets you pay into, over a certain amount of income you've maxed out Social Security). And that was one of the earliest (commercial) uses for computational devices.

Now, the way we express conditionals may change from one language or system to another. In Erlang, you can remove a lot of `if` expressions using pattern matching, consider the simple computation of the Fibonacci numbers as an example:

  fib(0) -> 1;
  fib(1) -> 1;
  fib(N) -> fib(N-1) + fib(N-2).

  fib(0) -> 1;
  fib(1) -> 1;
  fib(N) when N > 1, is_integer(N) -> fib(N-1) + fib(N-2).