Was any indentation-sensitive language ever used with a teletype or punch cards?

Question

Most programming languages delimit block structure with punctuation e.g. { ... } or keywords e.g. begin ... end. However, some languages such as Python and Haskell delimit it with indentation (sometimes called the 'offside rule') on the theory that this is how the human visual cortex recognizes block structure, so if the compiler does likewise, then we prevent a class of errors where we think the code says one thing and the compiler thinks it says another.

I found myself thinking 'of course that works great when you're editing code on screen, but it wouldn't have worked so well before that' and then 'wait, why not?'

Why not, indeed? Thinking about it more carefully for a few minutes, I cannot put my finger on any solid reason why something like an ASR-33 teletype, or a deck of punch cards, would have difficulty with indenting lines to delimit block structure, and the advantage of not spending an extra line on the closing delimiter would be worth more.

So:

Historically, was any indentation-based language ever used with pre-screen code entry technology like teletype or punch cards?

Answer 1

I agree to an extent that COBOL was "indentation-sensitive", but it really wasn't "indentation-sensitive" but rather "column-sensitive". The original COBOL coding format had specific requirements of where source code elements had to begin or the compiler would spit it back out as an error.

• Column 1-6 was a sequence number
• Column 7 was an indicator
• Column 8-11 was "Area A" and certain elements had to start there
• Column 12-72 was "Area B" and certain elements had to start and be contained there
• Column 73 - 80 was a system generated number when printing - this area was ignored by the compiler

In modern COBOL (to the extent there is such a thing) there are other formats allowed that eliminate these requirements.

When programs were entered on punched cards (before my time) coding was done by paper and pencil first on coding forms that adhered to this layout - once it was laid out, you could get someone else to keypunch your program.

Column 1-6 was a sequence number - I think the original theory was that if you for example, dropped your card deck, it could use this to sort the cards (and your program) back into the correct order. In practice, this got used for a variety of purposes because the sequence number was not enforced. For example, we would use it to tag lines with a ticket number or version number for bug fixes.

Column 7 was used for indicators:

• * meant it was a comment
• - meant it was a continuation of the previous line
• / meant that when printing your code listing, it would page break
• D meant that the line would only compile if WITH DEBUGGING MODE is used

Column 8-11 was Area A and division, section, and paragraph names had to start there, as did things like FD (file declarations) and level numbers. If you tried to put a level number or paragraph name in column 12, it would cause a compiler error (or be recognized as something else). You could indent within the Area, but those elements had to start within there.

Column 12-72 was Area B and all code went here. If your code extended past column 72, that part would be ignored and likely cause a compiler error - or it could be the source of a bug if the line was syntactically correct without the part that was in column 73. (I've experienced this over the years.)

There was no indentation requirements within that area - your entire program could be entered there with no indents at all within the code.

So within Area B, it doesn't matter if I use:

PERFORM 0200-MOVE-DATA
       VARYING SUB-VAR FROM 1 BY 1
       UNTIL SUB-VAR > 20

or

PERFORM 0200-MOVE-DATA
VARYING SUB-VAR FROM 1 BY 1
UNTIL SUB-VAR > 20

Answer 2

COBOL and FORTRAN are both (or were) highly indentation-sensitive, precisely because they were created at a time when punch-cards were the most common data-entry medium. Modern editors and compilers are less restrictive.

COBOL standards

FORTRAN standards

Answer 3

Historically, was any indentation-based language ever used with pre-screen code entry technology like teletype or punch cards?

Of course, even the very first: Assembler

And it still does:

• Any element starting in column 1 is a label/symbol definition, while
• any element starting after at 2 or later must be a instruction/macro/control word

Note that there is a fundamental difference between Assembler being indent based (*1) vs fixed column notation used by data entry (and thus languages) in general. Formats like using column 1..4/6/8, or 73..80 for numbering, or 72 for line continuation (*2) are fixed column formats.

---

On a sidenote:

The question falls for the usual problem of asking for a certain behaviour before that behaviour was canonised as today. So any answer will include examples which may strictly not apply to the question made in hindsight, as any artefact will be an example of development prior.

---

*1 - Except some very early ones.

*2 - And were usually used with Assembly as well - as a fixed column layer around the indent based language structure

Answer 4

The earliest programming language that I am aware of that was implemented using the "off-side rule" as referenced in the question (or any similar rule) is SASL (1972). It derives from a description of a 1966 language called ISWIM, which also appears to have been designed with such a rule in mind, but which was never actually implemented -- it was intended more as an example of what future languages might look like that than as a useful language itself. SASL is a direct ancestor of Haskell, one of the more common languages using this system today (SASL was later redesigned by its author to create Miranda, and Haskell originally began as an open source replacement for Miranda). IIRC SASL was also a direct inspiration for Python.

Teletypes were still in common use in 1972, so it seems likely that SASL was used with them. Punched cards seem less likely to have been used with it, however.

Answer 5

Don't forget about RPG (Report Program Generator, not Role Playing Game). The original versions before 2001 required data and instruction to be placed into certain columns for correct operation.

Answer 6

Early languages were 'Fixed Format'. The meaning of different columns was fixed and defined. "a C in the first column means a comment". Those rules were later relaxed allowing "Free Format" rules like "all white space before the first text is ignored"

There was no reason why multiple indentation couldn't be assigned a meaning: card punches, like typewriters, were designed to support tabulation, and it was used for Fixed Format data entry: it could just as well have been used for significant white space, like in python.

But early languages didn't even have the concept of sub-scopes. You had global code, then you had a single level of subroutines. That was it. The idea of indented scope comes from the idea of sub-logic, which comes from the idea of structured programming, which replaced goto-loops with structures like While-Wend or Repeat-Until or For(){}.

Early language research projects, and functional languages, could have used indentation to mark scope, but in general, they didn't. They used (),[],{}, and syntax elements like 'begin'/'end'

My hypothesis is that (1) people were not used to using indentation to mark scope in hand-written math and philosophical proofs, and (2) the 80 column limitation was already causing too much problem with line length for early programmers.

Answer 7

Makefiles are indentation-sensitive: each rule starts with an unindented dependency line followed by indented lines with the commands (indented with a tab!). I think makefiles are old enough to have been used on teletypes or punch cards, but I'm not 100% sure on that.

We're talking here about a configuration language rather than a programming language, but I think that falls within the scope of the question.