9

The easily readable structure of having an if keyword which controls execution of a following block of code is so prevalent in programming that it seems to just be part of it.

However, programming started out with machine code that was far away from the easy to understand

if condition
    do thing

What was the first time a programmer was able to use this simple and intuitive way of executing code based on a condition?

This excludes IF...GOTO statements, as that - in the sense of this question - only allows to execute a GOTO statement, opposed to arbitrary code. Also condition and code to execute are split up there and not together anymore. This is more about the "usability for programmers" perspective than about the technical ability to support this feature.

As user Raffzahn mentioned, this can be called "the first (block) structured language".

R. Schmitz
  • 393
  • 2
  • 8
  • 1
    IF-THEN-ELSE is just the compiler helping you with the two GOTO statements. – Thorbjørn Ravn Andersen Apr 18 '19 at 16:08
  • @ThorbjørnRavnAndersen Well... most of modern programming languages is just the compiler helping me with the low level stuff. Programming languages are not made for the computer, but for humans to read - otherwise we would still be using machine code. That's the perspective to apply here. – R. Schmitz Apr 18 '19 at 16:14
  • 1
    How many of these very specific programming language history questions do you plan on asking? – Robert Harvey Apr 18 '19 at 16:27
  • @RobertHarvey I was thinking of 2 first, one for if, one for structured programming. It turns out for the "if" one, I asked something different than I wanted to initially, hence this third one in order not to invalidate all the nice answers given there. I have no further plans at the moment, but of course I won't forbid myself to ask questions in the future. – R. Schmitz Apr 18 '19 at 16:31
  • 1
    @R.Schmitz As every programming language compiles down to something closer to machine language (also goes for interpretation) that is trivially true. The point I was trying to make is that the abstraction level for an IF-THEN-ELSE is not very much above for IF-GOTO-GOTO (I would guess that the non-nested version could be easily implemented as assembler macros), and therefore this is a rather small stepping stone. And no, we would not use assembly code. We would probably use a modern Lisp dialect. – Thorbjørn Ravn Andersen Apr 18 '19 at 16:51
  • 2
    if(condition) begin code; end is exactly the if(not condition) goto end_of_block; code; end_of_block: so this readability could even be achieved in assembler using appropriate macros. – lvd Apr 18 '19 at 20:10
  • I think you'll find flowcharting relevant to this discussion. History dates back to 1920's. One fundamental problem with unstructured programming is that requirement for unique labels, that preclude copy & paste. Another problem is visualizing control flow. Flowcharting addresses both of these issues, without necessarily using the indentation we find now in structured programming. Therefore, I view flowcharting as a more of precursor to indentation and structured programming. – Erik Eidt Apr 18 '19 at 20:27
  • If you're making a distinction between an if statement that controls a" single line" of code versus a "block" of code (a distinction that is a bit artificial), any functional programming language will allow blocks of code. Simply define my_function as the block of code, then say if condition then my_function(). – Acccumulation Apr 18 '19 at 21:48
  • @Acccumulation: Sorta, but generally not without a speed penalty that would have been unacceptable in that era. – supercat Apr 19 '19 at 02:42
  • @Acccumulation I agree, but I don't want to make that distinction single line vs block. Number of lines doesn't matter, only that condition and executed code are together. So if condition then my_function() is as acceptable as if condition then a+=3;. if condition goto is not acceptable because it directs you somewhere else. – R. Schmitz Apr 19 '19 at 08:57
  • @R.Schmitz I think you're looking for the first (block) structured language. If this is the case, then it might help to rewrite the question saying so. Having an IF/THEN example ant then excluding jumps does make it less clear. – Raffzahn Apr 19 '19 at 10:52
  • I did it in Turbo or Borland Pascal around in 1992. I found the concept useful, although at this time I knew the IF ... THEN (GOTO) x construct of the C64 Basicv2 well and I did not find it very important. – peterh Apr 21 '19 at 00:48
  • The term "block structured" is about identifier scope and lifetime, not about whether simple statements can be grouped into compound statements. – dave Apr 23 '19 at 15:31

4 Answers4

6

ALGOL-60 is the obvious candidate; it and its predecessor ALGOL-58 (for which I can find no code samples!) are credited with inventing the BEGIN/END block structure.

pjc50
  • 1,015
  • 7
  • 9
  • My first programming language ;-) –  Apr 19 '19 at 13:19
  • IAL (Algol 58) had the compound statement, but Algol 60 added the precise notion that declared identifiers were scoped to the smallest enclosing block. I believe only the latter deserves the name "block structured"; we today always imply scope rules when we use the term. Still, it's not really clear whether the OP is asking about compound statements or block structure; the focus on if statements suggests interest in compound statements. – dave Apr 23 '19 at 18:18
5

With the rather vague wording the question does leave us with several options:

  • If it's just about conditional execution of non control transfer instructions, then Freiburger Code for Zuse's Z22 of 1955 will do it.
  • If it's about conditional execution of one or more instruction then any language with conditioned control transfer (IF cond THEN label) will do it, as by negating the condition any code can be inserted between both occurences of label.
  • But if this is about block structured code, then the ALGOL Family will fit all your criteria - and the Z22 was the first machine to operate one in 1958 (and the transistorized Z23 being the first machine to be delivered with an Algol compiler by default (1961))
Raffzahn
  • 222,541
  • 22
  • 631
  • 918
3

Autocode had the equivalent of an if...then, but written backwards:

j1,11 ≥ n

This means "if n <= 11 then jump to label 1". FORTRAN of course had a more conventional if, but with it's own oddities:

IF N-11 10,20,30

Which means goto 10 if the result is negative (N<11), 20 if its zero (equal) and 30 if it's positive (N>11). This syntax appears to be a side-effect of a particular instruction on the IBM machine it was written on.

Update: I'm not sure either really hits without that last proviso in your statement though. But Autocode's solution is essentially the ELSE clause. That was weird...

Maury Markowitz
  • 19,803
  • 1
  • 47
  • 138
  • I'm afraid it doesn't hit the nail on the head, in short because the only thing it can do is send you somewhere else in the source code. I admit it's quite a fine line to tread. I actually posted this on softwareengineering first, because I am interested in the "usability for programmers" perspective. Retrocomputing seems to have more hardware- and low level code experts, and i agree that it's not that much of a difference in that context. I do enjoy getting all this info though, so thank you either way! – R. Schmitz Apr 19 '19 at 09:11
0

In my first position as a professional programmer in 1982, the small mom-and-pop software shop I worked for used MS BASIC compiler to develop a point-of-sale, inventory control, and mail merge system. The MS BASIC was extremely vanilla, and had no IF ... END IF type structure, which apparently bugged the hell out of the main programmer and co-founder of the company. So much so that he wrote a pre-processor program, which I think he called XSEL or something beginning with "X" (company was XtraSoft) that allowed us to code with IF and END IF and not have to use line numbers or worry about those messy GOTO's, and would create a line-numbered output with the necessary GOTO's (ugh) to branch out at the appropriate places. It at least made the "source" code look nice, if not executable on their own through an interpreter anymore, and required the extra step of the pre-processor before compile and link, but we grew to like it.

Bill Hileman
  • 1,206
  • 7
  • 12