Part 3 - (Structured Programming)
-------------------------------

The academics in computer science have gotten into the 'structured programming' rut over the past several
years. They claim that programs are more easily understood if the programmer uses some special language
constructs and techniques. They don't all agree on exactly which constructs, of course, and the examples
they use to show their particular point of view invariably fit on a single page of some obscure journal or the
other - clearly not enough of an example to convince anyone. When I got out of school, I thought I was the
best programmer in the world. I could write an unbeatable tic-tac-toe program, use five different
programming languages, and create 1000-line programs that WORKED. (Really!) Then I got out into the Real
World. My first assignment in the Real World was to read and understand a 200,000-line FORTRAN program,
then speed it up by a factor of two. Any Real Programmer will tell you that all the Structured Coding in the
world won't help you solve a problem like that - it takes actual talent. Some quick observations on Real
Programmers and Structured Programming:

- Real Programmers aren't afraid to use GOTO's.

- Real Programmers can write five-page-long DO loops without getting confused.

- Real Programmers like Arithmetic IF statements - they make the code more interesting.

- Real Programmers write self-modifying code, especially if they can save 20 nanoseconds in the middle of
a tight loop.

- Real Programmers don't need comments - the code is obvious.

- Since FORTRAN doesn't have a structured IF, REPEAT ... UNTIL, or CASE statement, Real Programmers
don't have to worry about not using them. Besides, they can be simulated when necessary using assigned
GOTO's.

Data Structures have also gotten a lot of press lately. Abstract Data Types, Structures, Pointers, Lists, and
Strings have become popular in certain circles. Wirth (the above-mentioned Quiche Eater) actually wrote an
entire book [2] contending that you could write a program based on data structures, instead of the other way
around. As all Real Programmers know, the only useful data structure is the Array. Strings, lists, structures,
sets - these are all special cases of arrays and can be treated that way just as easily without messing up
your programming language with all sorts of complications. The worst thing about fancy data types is that you
have to declare them, and Real Programming Languages, as we all know, have implicit typing based on the first
letter of the (six character) variable name.

-to be continued -