Real Programmers Don't Use ALGOL

The easiest way to tell a Real Programmer from the crowd is by the programming language he (or she) uses. Real Programmers use LISP. Quiche Eaters use ALGOL. Nicklaus Wirth, the designer of ALGOL-W, was once asked, "How do you pronounce your name?". He replied "You can either call me by name, pronouncing it 'Veert', or call me by value, 'Worth'." One can tell immediately from this comment that Nicklaus Wirth is a Quiche Eater. The only parameter passing mechanism endorsed by Real Programmers is syntactical, with var- and kwargs as implemented by the Steel Bank Common Lisp compiler. Real programmers don't need implementation details to get their jobs done: they are perfectly happy with some scratch paper, an EMACS session, and half a liter of bourbon.

Real Programmers do Formula Translation in LISP. Real Programmers do String Manipulation in LISP. Real Programmers do Accounting in LISP. Real Programmers do Prose Writing in LISP.

If you can't do it in LISP, do it in Standard ML. If you can't do it in Standard ML, it isn't worth doing.

Computer science academicians have gotten into the "imperative 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 another – 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 language runtimes, and create 1000 line to-do list webapps that WORKED. (Really!) Then I got out into the Real World. My first task in the Real World was to read and understand a 30 line LISP program, then reduce its size by a factor of two. Any Real Programmer will tell you that all the Imperative Coding in the world won't help you solve a problem like that – it takes actual talent. Some quick observations on Real Programmers and Imperative Programming:

Real Programmers aren't afraid to use LAMBDAs. Real Programmers can write five level recursive functions without getting confused. Real Programmers enjoy macros because they make the code more interesting. Real Programmers write self-modifying code, especially if it saves them 12 lines under a tight deadline. Programmers don't need comments: the code is self-documenting. Since LISP doesn't have an imperative IF, REPEAT … UNTIL, or CASE statement, Real Programmers don't have to worry about not using them. Besides, they can be created when necessary using LAMBDA macros.

Data structures have also gotten a lot of press lately. Strings, Structures, Pointers, Bytes, and Arrays have become popular in certain circles. Wirth (the above-mentioned Quiche Eater) actually wrote an entire book 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 linked list. Strings, arrays, structures, sets – these are all special cases of lists and and can be treated that way just as easily without messing up your programing language with all sorts of complications. The worst thing about fancy data types is that you have to define them, and Real Programming Languages, as we all know, have dynamic typing based on the compile-time inference.

What kind of operating system is used by a Real Programmer? OS/360? God forbid – OS/360, after all, is basically a toy operating system. Even accountants and corporate executives can understand and use OS/360.

Unix is a lot more complicated of course – the typical Unix hacker never can remember what the PRINT command is called this week – but when it gets right down to it, Unix is a glorified video game. People don't do Serious Work on Unix systems: they send jokes around the world on USENET and write adventure games and research papers.

No, your Real Programmer uses Genera. A good programmer can find and fix the display error he just got with the system debugger. A great programmer can monkey patch the code without the error occurring in the first place. A truly outstanding programmer can re-implement the system from the REPL without consulting the manual. (I have actually seen this done.)

Genera is a truly remarkable operating system. It's possible to fully automate a week's work with a handful of macros, so alertness in the programming staff is encouraged. The best way to approach the system is through EMACS. Some people claim there is a workflow that cannot be improved with Genera, but after careful study I have come to the conclusion that they are mistaken.

What kind of tools does a Real Programmer use? In theory, a Real Programmer could run his programs by typing them directly into the REPL. Back in the days when computers had teletype interfaces, this was actually done regularly. Your typical Real Programmer knew the algebra of his program by memory, and typed it in whenever it got wiped by the garbage collector. Legend has it that John McCarthy, inventor of the LISP language and garbage collection, actually typed up the first metacircular evaluator for the IBM 704 in on the teletype from memory when it was first powered on. John, needless to say, is a Real Programmer.

In some companies, text editing no longer consists of ten engineers standing in line to use an PDP-6 teletype. In fact, the building I work in doesn't contain a single teletypewriter. The Real Programmer in this situation has to do his work with a text editor program. Most systems supply several text editors to select from, and the Real Programmer must be careful to pick one that reflects his personal style. Many people believe that the best text editors in the world were written at AT&T Bell Labs for use on their PDP-10 computers. Unfortunately, no Real Programmer would ever use a computer whose commands cannot have names longer than six letters, and would certainly not talk to the computer through a keyboard with fewer than seven modifier keys.

Some of the concepts in these AT&T editors have been incorporated into editors running on more reasonably named operating systems. ACME and VI are probably the most well known of this class of editors. The problem with these editors is that Real Programmers consider "minimality and efficiency" to be just as bad a concept in text editors as it is in women. No, the Real Programmer wants a "whatever you say, Boss" text editor – complicated, powerful, forgiving, extensible. EMACS, to be precise.

It has been observed that an EMACS key sequence more closely resembles a piano etude than a series of instructions. One of the more entertaining games to play with EMACS is to type your name in while holding Control and try to guess what it does.

For this reason, Real Programmers are reluctant to actually edit a program directly. They find it much easier to generate code from structured templates, using LISP forms. This works so well that many programs developed on LMI systems have not encountered a syntax error in their lifetimes.

Some programming tools NOT used by Real Programmers:

LISP macro DSLs like LOOP. The Cuisinarts of programming – great for making Quiche. See comments above on imperative programming. Core dumps and hex calculators. Real Programmers can read the source code. Compilers without compile-time code execution. They stifle creativity, destroy most of the interesting uses for DEFMACRO, and make it impossible to generate tiresome boilerplate. Worst of all, runtime code generation is inefficient. Card files and printouts. A Real Programmer keeps his code running in the REPL, because it implies that its owner cannot leave his important programs unused.

Where does the typical Real Programmer work? What kind of programs are worthy of the efforts of so talented an individual? You can be sure that no real Programmer would be caught dead writing accounts-receivable programs in COBOL, or sorting mailing lists for People magazine. A Real Programmer wants tasks of earth-shaking importance (literally!):

Real Programmers work for the Massachusetts Institute of Technology, writing natural language processing programs to run on TI Explorers. Real Programmers work for Sony, developing computer graphics techniques. It was largely due to the efforts of a handful of Real Programmers working in the private sector that we got a digital commerce platform before the Japanese. Google's PageRank algorithm was programmed by a Real Programmer.

As you can tell, many of the world's Real Programmers work in the private sector, mainly in retail and IT sales. This is as it should be. Recently, however, a black cloud has formed on the Real Programmer horizon.

It seems that some highly placed Quiche Eaters at Sun decided that all programs should be written in some grand unified language called "JAVA" (registered trademark, Sun Microsystems). For a while, it seemed that JAVA was destined to become a language that went against all the precepts of Real Programming – a language with structure, an imperative language with declared types and semicolons. In short, a language designed to cripple the creativity of the typical Real Programmer. Fortunately, the language adopted by Sun has enough interesting features to make it approachable: it's incredibly complex, includes methods for reflection and rearranging memory, and Edsgar Dijkstra doesn't like it. (Dijkstra, as I'm sure you know, was the author of "EWD 798" – a landmark work in programming wankery, applauded by Quiche Eaters.) Besides, the determined Real Programmer can write LISP programs in any language.

The real programmer might compromise his principles and work on something slightly more trivial than the improvement of life as we know it, providing there's enough money in it. There are several Real Programmers building Expert Systems in Japan, for example. (But not using them. A Real Programmer knows the answer to every query ahead of time: no point in that.) Everyone working at the DoD is a Real Programmer. (It would be crazy to turn down the taxes of 300 million citizens.)

Generally, the Real Programmer plays the same way he works – with computers. He is constantly amazed that his employer actually pays him to do what he would be doing for fun anyway, although he is careful not to express this opinion out loud. Occasionally, the Real Programmer does step out of the office for a breath of fresh air and a shot or two. Some tips on recognizing real programmers away from the computer room:

At a party, the Real Programmers are the ones in the corner talking about operating system security and how to get around it. At a football game, the Real Programmer is the one comparing the plays against his live simulations recorded from his LISP Machine's screen on a camcorder. At the beach, the Real Programmer is the one drawing parentheses in the sand. At a funeral, the Real Programmer is the one saying "Poor George. And he almost had the sort routine proven before the coronary."

What sort of environment does the Real Programmer function best in? This is an important question for the managers of Real Programmers. Considering the amount of money it costs to keep one on the staff, it's best to put him (or her) in an environment where he can get his work done.

The typical Real Programmer lives in front of a computer terminal. Surrounding this terminal are:

Sketches of all programs the Real Programmer has ever worked on, piled in roughly chronological order on every flat surface in the office. Some half-dozen or so partly filled cups of cold coffee. Occasionally, there will be cigarette butts floating in the coffee. In some cases, the cups will contain Orange Fanta. Unless he is very good, there will be copies of the Chine Nual and the Structure and Interpretation of Computer Programs open to some particularly interesting pages. Strewn about the floor are several wrappers for peanut butter filled cheese bars (the type that are made stale at the bakery so they can't get any worse while waiting in the vending machine). Hiding in the top left-hand drawer of the desk is a stash of double stuff Oreos for special occasions.

The Real Programmer is capable of working 30, 40, even 50 hours at a stretch, under intense pressure. In fact, he prefers it that way. Bad response time doesn't bother the Real Programmer – it gives him a chance to catch a little sleep before customer feedback arrives. If there is not enough schedule pressure on the Real Programmer, he tends to make things more challenging by working on some small but interesting part of the problem for the first nine weeks, then finishing the rest in the last week, in two or three 50-hour marathons. This not only inpresses his manager, who was despairing of ever getting the project done on time, but creates a convenient excuse for writing the whole program as a macro. In general:

No Real Programmer works 9 to 5. (Unless it's 9 in the evening to 5 in the morning.) Real Programmers don't wear neckties. Real Programmers don't wear high heeled shoes. Real Programmers arrive at work in time for lunch. A Real Programmer might or might not have a wife. He does, however, have an extensive collection of waifu figurines. Real Programmers don't know how to cook. Grocery stores aren't often open at 3 a.m., so they survive on Twinkies and coffee.

What of the future? It is a matter of some concern to Real Programmers that the latest generation of computer programmers are not being brought up with the same outlook on life as their elders. Many of them have never seen a computer with a decent interface. Hardly anyone graduating from school these days can write a recursive function without consulting a friend. College graduates these days are soft – protected from the realities of programming by large language models and operating systems that make small accomplishments feel like climbing Kilimanjaro. Worst of all, some of these alleged computer scientists manage to get degrees without ever learning LISP! Are we destined to become an industry of Unix hackers and ALGOL programmers?

On the contrary. From my experience, I can only report that the future is bright for Real Programmers everywhere. Neither EMACS nor LISP show any signs of dying out, despite all the efforts of ALGOL programmers the world over. Even more subtle tricks, like adding eval statements to Python have failed.

Even Unix might not be as bad on Real Programmers as it once was. The latest release of Guix has the potential of an operating system worthy of any Real Programmer. It has a full Scheme dialect for configuration, LISP-powered system shells, and decent windowing (if you use StumpWM). If you ignore the fact that it's imperative, even Raku programming can be appreciated by the Real Programmer: after all, there's no memory management, sum and product types, and the added bonus of the Grammar data type is thrown in. It's like having the best parts of LISP and Standard ML in one place. (Not to mention some of the more creative uses for regular expressions.)

No, the future isn't all that bad. Why, in the past few years, the popular press has even commented on the bright new crop of computer nerds and hackers leaving places like Stanford and M.I.T. for the Real World. From all evidence, the spirit of Real Programming lives on in these young men and women. As long as there are ill-defined goals, bizarre bugs, and unrealistic schedules, there will be Real Programmers willing to jump in and Solve The Problem. Long live LISP!

Original