11 Years after posting the original article, I feel the obligation to add the information I was missing at the time I posted it. Here you are:
"Real Programmers Don't Use Pascal" is an essay about computer programming written by Ed Post of Tektronix, Inc., and published in July 1983 as a letter to the editor in Datamation.
If you want to know more, please refer to the Wikipedia Article about the original text. And now enjoy the original text.
Disclaimer from the Original 2001 Version
I have no idea who wrote the original version of this text. The first time I saw this
article was in 1986 but other people told me that it was already old at that time.
In 1986 we found it really funny but I suppose that young
developers have never read it. So enjoy this really nice text.
Back in the good old days --
the Golden Era
of computers, it was easy to separate the men from the boys
(sometimes called "Real Men"
and "Quiche Eaters"
in the literature). During this
period, the Real Men were the ones that understood computer programming, and the
Quiche Eaters were the ones that didn't. A real computer programmer said things
like "DO 10 I=1,10"
(they actually talked in capital letters, you
understand), and the rest of the world said things like "computers are too
complicated for me"
and "I can't relate to computers -- they're so impersonal"
(A previous work [1
out that Real Men don't "relate" to anything, and aren't afraid of being
But, as usual, times change. We are faced today with a world in which little
old ladies can get computers in their microwave ovens, 12-year-old kids can blow
Real Men out of the water playing Asteroids and Pac-Man, and anyone can buy and
even understand their very own Personal Computer. The Real Programmer is in
danger of becoming extinct, of being replaced by high-school students with
There is a clear need to point out the differences between the typical
high-school junior Pac-Man player and a Real Programmer. If this difference is
made clear, it will give these kids something to aspire to -- a role model, a
Father Figure. It will also help explain to the employers of Real Programmers
why it would be a mistake to replace the Real Programmers on their staff with
12-year-old Pac-Man players (at a considerable salary savings).
The easiest way to tell a Real Programmer from the
crowd is by the programming language he (or she) uses. Real Programmers use
. Quiche Eaters use PASCAL
. Nicklaus Wirth, the designer of PASCAL, gave
a talk once at which he was asked "How do you pronounce your name?"
. He replied,
"You can either call me by name, pronouncing it 'Veert', or call me by value,
One can tell immediately from this comment that Nicklaus Wirth is a
Quiche Eater. The only parameter passing mechanism endorsed by Real Programmers
is call-by-value-return, as implemented in the IBM\370 FORTRAN-G and H
compilers. Real programmers don't need all these abstract concepts to get their
jobs done -- they are perfectly happy with a keypunch, a FORTRAN IV compiler,
and a beer.
- Real Programmers do List Processing in FORTRAN.
- Real Programmers do String Manipulation in FORTRAN.
- Real Programmers do Accounting (if they do it at all) in FORTRAN.
- Real Programmers do Artificial Intelligence programs in FORTRAN.
If you can't do it in FORTRAN, do it in assembly language. If you
can't do it in assembly language, it isn't worth doing.
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 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 computer languages, and
create 1000-line programs that WORKED. (Really!) Then I got out into the Real
World. My first task 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
- Real Programmers like Arithmetic IF statements -- they make the code more
- 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
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 programing 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.
What kind of operating system is used by a
Real Programmer? CP/M? God forbid -- CP/M, after all, is basically a toy
operating system. Even little old ladies and grade school students can
understand and use CP/M.
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 UUCP-net and write adventure games
and research papers.
No, your Real Programmer uses OS\370. A good programmer can find and
understand the description of the IJK305I error he just got in his JCL manual. A
great programmer can write JCL without referring to the manual at all. A truly
outstanding programmer can find bugs buried in a 6 megabyte core dump without
using a hex calculator. (I have actually seen this done.)
OS is a truly remarkable operating system. It's possible to destroy days of
work with a single misplaced space, so alertness in the programming staff is
encouraged. The best way to approach the system is through a keypunch. Some
people claim there is a Time Sharing system that runs on OS\370, but after
careful study I have come to the conclusion that they were mistaken.
What kind of tools does a Real Programmer
use? In theory, a Real Programmer could run his programs by keying them into the
front panel of the computer. Back in the days when computers had front panels,
this was actually done occasionally. Your typical Real Programmer knew the
entire bootstrap loader by memory in hex, and toggled it in whenever it got
destroyed by his program. (Back then, memory was memory -- it didn't go away
when the power went off. Today, memory either forgets things when you don't want
it to, or remembers things long after they're better forgotten.) Legend has it
that Seymore Cray, inventor of the Cray I supercomputer and most of Control
Data's computers, actually toggled the first operating system for the CDC7600 in
on the front panel from memory when it was first powered on. Seymore, needless
to say, is a Real Programmer.
One of my favorite Real Programmers was a systems programmer for Texas
Instruments. One day he got a long distance call from a user whose system had
crashed in the middle of saving some important work. Jim was able to repair the
damage over the phone, getting the user to toggle in disk I/O instructions at
the front panel, repairing system tables in hex, reading register contents back
over the phone. The moral of this story: while a Real Programmer usually
includes a keypunch and lineprinter in his toolkit, he can get along with just a
front panel and a telephone in emergencies.
In some companies, text editing no longer consists of ten engineers standing
in line to use an 029 keypunch. In fact, the building I work in doesn't contain
a single keypunch. 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 Xerox Palo Alto Research Center for use on their Alto and Dorado
Unfortunately, no Real Programmer would ever use a computer whose operating
system is called SmallTalk, and would certainly not talk to the computer with a
Some of the concepts in these Xerox editors have been incorporated into
editors running on more reasonably named operating systems -- EMACS and VI being
two. The problem with these editors is that Real Programmers consider "what you
see is what you get" to be just as bad a concept in Text Editors as it is in
women. No the Real Programmer wants a "you asked for it, you got it" text editor
-- complicated, cryptic, powerful, unforgiving, dangerous. TECO, to be precise.
It has been observed that a TECO command sequence more closely resembles
transmission line noise than readable text . One of
the more entertaining games to play with TECO is to type your name in as a
command line and try to guess what it does. Just about any possible typing error
while talking with TECO will probably destroy your program, or even worse --
introduce subtle and mysterious bugs in a once working subroutine.
For this reason, Real Programmers are reluctant to actually edit a program
that is close to working. They find it much easier to just patch the binary
object code directly, using a wonderful program called SUPERZAP (or its
equivalent on non-IBM machines). This works so well that many working programs
on IBM systems bear no relation to the original FORTRAN code. In many cases, the
original source code is no longer available. When it comes time to fix a program
like this, no manager would even think of sending anything less than a Real
Programmer to do the job -- no Quiche Eating structured programmer would even
know where to start. This is called "job security".
Some programming tools NOT used by Real Programmers:
- FORTRAN preprocessors like MORTRAN and RATFOR. The Cuisinarts of
programming -- great for making Quiche. See comments above on structured
- Source language debuggers. Real Programmers can read core dumps.
- Compilers with array bounds checking. They stifle creativity, destroy most
of the interesting uses for EQUIVALENCE, and make it impossible to modify the
operating system code with negative subscripts. Worst of all, bounds checking
- Source code maintenance systems. A Real Programmer keeps his code locked
up in a card file, because it implies that its owner cannot leave his
important programs unguarded .
The Real Programmer at Work
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
- Real Programmers work for Los Alamos National Laboratory, writing atomic
bomb simulations to run on Cray I supercomputers.
- Real Programmers work for the National Security Agency, decoding Russian
- It was largely due to the efforts of thousands of Real Programmers working
for NASA that our boys got to the moon and back before the Russkies.
- Real Programmers are at work for Boeing designing the operating systems
for cruise missiles.
Some of the most awesome Real Programmers of all
work at the Jet Propulsion Laboratory in California. Many of them know the
entire operating system of the Pioneer and Voyager spacecraft by heart. With a
combination of large ground-based FORTRAN programs and small spacecraft-based
assembly language programs, they are able to do incredible feats of navigation
and improvisation -- hitting ten-kilometer wide windows at Saturn after six
years in space, repairing or bypassing damaged sensor platforms, radios, and
batteries. Allegedly, one Real Programmer managed to tuck a pattern-matching
program into a few hundred bytes of unused memory in a Voyager spacecraft that
searched for, located, and photographed a new moon of Jupiter.
The current plan for the Galileo spacecraft is to use a gravity assist
trajectory past Mars on the way to Jupiter. This trajectory passes within 80
+/-3 kilometers of the surface of Mars. Nobody is going to trust a PASCAL
program (or a PASCAL programmer) for navigation to these tolerances.
As you can tell, many of the world's Real Programmers work for the U.S.
Government -- mainly the Defense Department. 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 the Defense Department decided that all
Defense programs should be written in some grand unified language called "ADA"
((C), DoD). For a while, it seemed that ADA was destined to become a language
that went against all the precepts of Real Programming -- a language with
structure, a language with data types, strong typing, and semicolons. In short,
a language designed to cripple the creativity of the typical Real Programmer.
Fortunately, the language adopted by DoD has enough interesting features to make
it approachable -- it's incredibly complex, includes methods for messing with
the operating system and rearranging memory, and Edsgar Dijkstra doesn't like it
(Dijkstra, as I'm sure you know, was the author of "GoTos Considered Harmful" --
a landmark work in programming methodology, applauded by PASCAL programmers and
Quiche Eaters alike.) Besides, the determined Real Programmer can write FORTRAN
programs in any language.
The Real Programmer might compromise his principles and work on something
slightly more trivial than the destruction of life as we know it, providing
there's enough money in it. There are several Real Programmers building video
games at Atari, for example. (But not playing them -- a Real Programmer knows
how to beat the machine every time: no challenge in that.) Everyone working at
LucasFilm is a Real Programmer. (It would be crazy to turn down the money of
fifty million Star Trek fans.) The proportion of Real Programmers in Computer
Graphics is somewhat lower than the norm, mostly because nobody has found a use
for computer graphics yet. On the other hand, all computer graphics is done in
FORTRAN, so there are a fair number of people doing graphics in order to avoid
having to write COBOL programs.
The Real Programmer at Play
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 beer 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 simulations printed on 11 by 14 fanfold paper.
- At the beach, the Real Programmer is the one drawing flowcharts in the
- At a funeral, the Real Programmer is the one saying "Poor George. And he
almost had the sort routine working before the coronary."
- In a grocery store, the Real Programmer is the one who insists on running
the cans past the laser checkout scanner himself, because he never could trust
keypunch operators to get it right the first time.
The Real Programmer's Natural Habitat
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:
- Listings 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 Crush.
- Unless he is very good, there will be copies of the OS JCL manual and the
Principles of Operation open to some particularly interesting pages.
- Taped to the wall is a line-printer Snoopy calendar for the year 1969.
- Strewn about the floor are several wrappers for peanut butter filled
cheese bars -- the type that are made pre-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.
- Underneath the Oreos is a flowcharting template, left there by the
previous occupant of the office. (Real Programmers write programs, not
documentation. Leave that to the maintenance people.)
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
between compiles. 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
impresses the hell out of his manager, who was despairing of ever getting the
project done on time, but creates a convenient excuse for not doing the
documentation. In general:
- No Real Programmer works 9 to 5 (unless it's the ones at night).
- 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 know his wife's name. He does,
however, know the entire ASCII (or EBCDIC) code table.
- Real Programmers don't know how to cook. Grocery stores aren't open at
three in the morning. Real Programmers 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 front panel. Hardly anyone graduating from
school these days can do hex arithmetic without a calculator. College graduates
these days are soft -- protected from the realities of programming by source
level debuggers, text editors that count parentheses, and "user friendly"
operating systems. Worst of all, some of these alleged "computer scientists"
manage to get degrees without ever learning FORTRAN! Are we destined to become
an industry of Unix hackers and PASCAL programmers?
From my experience, I can only report that the future is bright for Real
Programmers everywhere. Neither OS\370 nor FORTRAN show any signs of dying out,
despite all the efforts of PASCAL programmers the world over. Even more subtle
tricks, like adding structured coding constructs to FORTRAN have failed. Oh
sure, some computer vendors have come out with FORTRAN 77 compilers, but every
one of them has a way of converting itself back into a FORTRAN 66 compiler at
the drop of an option card -- to compile DO loops like God meant them to be.
Even Unix might not be as bad on Real Programmers as it once was. The latest
release of Unix has the potential of an operating system worthy of any Real
Programmer -- two different and subtly incompatible user interfaces, an arcane
and complicated teletype driver, virtual memory. If you ignore the fact that
it's "structured", even 'C' programming can be appreciated by the Real
Programmer: after all, there's no type checking, variable names are seven (ten?
eight?) characters long, and the added bonus of the Pointer data type is thrown
in -- like having the best parts of FORTRAN and assembly language in one place.
(Not to mention some of the more creative uses for #define.)
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
( and )
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, saving the
documentation for later. Long live FORTRAN!
I would like to thank Jan E., Dave S., Rich G.,
Rich E., for their help in characterizing the Real Programmer, Heather B. for
the illustration, Kathy E. for putting up with it, and atd!avsdS:mark for the
 Feirstein, B., "Real Men
don't Eat Quiche", New York, Pocket Books, 1982.
 Wirth, N., "Algorithms + Data
Structures = Programs", Prentice Hall, 1976.
 Ilson, R., "Recent Research in Text
Processing", IEEE Trans. Prof. Commun., Vol. PC-23, No. 4, Dec. 4,
 Finseth, C., "Theory and Practice of
Text Editors -- or -- a Cookbook for an EMACS", B.S. Thesis,
MIT/LCS/TM-165, Massachusetts Institute of Technology, May 1980.
 Weinberg, G., "The Psychology of
Computer Programming", New York, Van Nostrand Reinhold, 1971, p. 110.
 Dijkstra, E., "On the GREEN language
submitted to the DoD", Sigplan notices, Vol. 3 No. 10, Oct 1978.
 Rose, Frank, "Joy of
Hacking", Science 82, Vol. 3 No. 9, Nov 82, pp. 58-66.
 "The Hacker Papers", Psychology
Today, August 1980.
 sdcarl!lin, "Real
Programmers", UUCP-net, Thu Oct 21 16:55:16 1982
Real Programmers Don't Use Fortran, Either!
A recent article
devoted to the macho
side of programming ("Real Programmers
Don't Use Pascal," by ucbvax!G:tut) made the bald and unvarnished statement
Real Programmers write in Fortran.
do now, in this decadent era of Lite beer, hand calculators and "user-friendly"
software, but back in the Good Old Days, when the term "software"
and Real Computers were made out of drums and vacuum tubes, Real Programmers
wrote in machine code. Not Fortran. Not RATFOR. Not, even, assembly language.
Machine Code. Raw, unadorned, inscrutable hexadecimal numbers. Directly.
Lest a whole new generation of programmers grow up in ignorance of this
glorious past, I feel duty-bound to describe, as best I can through the
generation gap, how a Real Programmer wrote code. I'll call him Mel, because
that was his name.
I first met Mel when I went to work for Royal McBee Computer Corp., a
now-defunct subsidiary of the typewriter company. The firm manufactured the
LGP-30, a small, cheap (by the standards of the day) drum-memory computer, and
had just started to manufacture the RPC-4000, a much-improved, bigger, better,
faster -- drum-memory computer. Cores cost too much, and weren't here to stay,
anyway. (That's why you haven't heard of the company, or the computer.)
I had been hired to write a Fortran compiler for this new marvel and Mel was
my guide to its wonders. Mel didn't approve of compilers.
"If a program can't rewrite its own code," he asked, "what good is it?"
Mel had written, in hexadecimal, the most popular computer program the
company owned. It ran on the LGP-30 and played blackjack with potential
customers at computer shows. Its effect was always dramatic. The LGP-30 booth
was packed at every show, and the IBM salesmen stood around talking to each
other. Whether or not this actually sold computers was a question we never
Mel's job was to re-write the blackjack program for the RPC-4000. (Port? What
does that mean?) The new computer had a one-plus-one addressing scheme, in which
each machine instruction, in addition to the operation code and the address of
the needed operand, had a second address that indicated where, on the revolving
drum, the next instruction was located. In modern parlance, every single
instruction was followed by a GO TO! Put that in Pascal's pipe
and smoke it.
Mel loved the RPC-4000 because he could optimize his code: that is, locate
instructions on the drum so that just as one finished its job, the next would be
just arriving at the "read head" and available for immediate execution. There
was a program to do that job, an "optimizing assembler," but Mel refused to use
"You never know where its going to put things," he explained, "so you'd have
to use separate constants."
It was a long time before I understood that remark. Since Mel knew the
numerical value of every operation code, and assigned his own drum addresses,
every instruction he wrote could also be considered a numerical constant. He
could pick up an earlier "add" instruction, say, and multiply by it, if it had
the right numeric value. His code was not easy for someone else to modify.
I compared Mel's hand-optimized programs with the same code massaged by the
optimizing assembly program, and Mel's always ran faster. That was because the
"top-down" method of program design hadn't been invented yet, and Mel wouldn't
have used it anyway. He wrote the innermost parts of his program loops first, so
they would get first choice of the optimum address locations on the drum. The
optimizing assembler wasn't smart enough to do it that way.
Mel never wrote time-delay loops, either, even when the balky Flexowriter
required a delay between output characters to work right. He just located
instructions on the drum so each successive one was just *past* the read head
when it was needed; the drum had to execute another complete revolution to find
the next instruction. He coined an unforgettable term for this procedure.
Although "optimum" is an absolute term, like "unique", it became common verbal
practice to make it relative: "not quite optimum" or "less optimum" or "not very
optimum." Mel called the maximum time-delay locations the "most pessimum." After
he finished the blackjack program and got it to run, ("Even the initializer is
optimized," he said proudly) he got a Change Request from the sales department.
The program used an elegant (optimized) random number generator to shuffle the
"cards" and deal from the "deck," and some of the salesmen felt it was too fair,
since sometimes the customers lost. They wanted Mel to modify the program so, at
the setting of a sense switch on the console, they could change the odds and let
the customer win.
Mel balked. He felt this was patently dishonest, which it was, and that it
impinged on his personal integrity as a programmer, which it did, so he refused
to do it. The Head Salesman talked to Mel, as did the Big Boss and, at the
boss's urging, a few Fellow Programmers. Mel finally gave in and wrote the code,
but he got the test backwards and, when the sense switch was turned on, the
program would cheat, winning every time. Mel was delighted with this, claiming
his subconscious was uncontrollably ethical, and adamantly refused to fix it.
After Mel had left the company for greener pa$ture$, the Big Boss asked me to
look at the code and see if I could find the test and reverse it. Somewhat
reluctantly, I agreed to look. Tracking Mel's code was a real adventure.
I have often felt that programming is an art form, whose real value can only
be appreciated by another versed in the same arcane art; there are lovely gems
and brilliant coups hidden from human view and admiration, sometimes forever, by
the very nature of the process. You can learn a lot about an individual just by
reading through his code, even in hexadecimal. Mel was, I think, an unsung
Perhaps my greatest shock came when I found an innocent loop that had no test
in it. No test. None. Common sense said it had to be a closed
loop, where the program would circle, forever, endlessly. Program control passed
right through it, however, and safely out the other side. It took me two weeks
to figure it out.
The RPC-4000 computer had a really modern facility called an index register.
It allowed the programmer to write a program loop that used an indexed
instruction inside; each time through, the number in the index register was
added to the address of that instruction, so it would refer to the next datum in
a series. He had only to increment the index register each time through. Mel
never used it.
Instead, he would pull the instruction into a machine register, add one to
its address, and store it back. He would then execute the modified instruction
right from the register. The loop was written so this additional execution time
was taken into account -- just as this instruction finished, the next one was
right under the drum's read head, ready to go. But the loop had no test in it.
The vital clue came when I noticed the index register bit, the bit that lay
between the address and the operation code in the instruction word, was turned
on -- yet Mel never used the index register, leaving it zero all the time. When
the light went on it nearly blinded me.
He had located the data he was working on near the top of memory -- the
largest locations the instructions could address -- so, after the last datum was
handled, incrementing the instruction address would make it overflow. The carry
would add one to the operation code, changing it to the next one in the
instruction set: a jump instruction. Sure enough, the next program instruction
was in address location zero, and the program went happily on its way.
I haven't kept in touch with Mel, so I don't know if he ever gave in to the
flood of change that has washed over programming techniques since those
long-gone days. I like to think he didn't. In any event, I was impressed enough
that I quit looking for the offending test, telling the Big Boss I couldn't find
it. He didn't seem surprised. When I left the company, the blackjack program
would still cheat if you turned on the right sense switch, and I think that's
how it should be. I didn't feel comfortable hacking up the code of a Real
Subject: Real programmers (2)
From: R.D.Eager@UKC 05 Oct 83 16:21:03 BST
Comments: The stuff we got from UNIX
Msg ID: <05 Oct 83 16:21:03 BST 060206@2960>Real programmers would rather use a bank of toggle switches and read a
row of LED's then use such encumbersome devices as keyboards & CRTs to talk
to computers. Marc
Real Programmers patch binaries rather than recompile.
Real programmers punch up their object decks using 029 multipunch. (That is
for production decks; test runs are entered directly with the engineer's console
switches; btw ODT systems are for sissies)
What the hell are all these 'real programmers' doing submitting news
articles? They should be off in some corner hacking FORTRAN.
From: Ron Natalie <ron@brl-bmd>
But real programmers are on every mailing list there is and spend the first
six hours of each 18 hour workday reading their mail and sending off-hand
suggestions to Unix-Wizards and Info-Micro, and writing page long editorials for
SF-Lovers, Poly-Sci, and ArmsD.
From: Charlie Strom (NYU) <strom@brl-bmd>
I agree that the group might have gotten a little carried away, but it
irritates me to see people who claim to be on the leading edge of computer
technology unable to spell even simple words or use acceptable grammar.
Expertise in one field does not imply the necessity of total ignorance in
another, does it?
I would much prefer to see some more messages correcting spelling and usage
(the silicone vs. silicon was the latter) rather than a dozen more opinions on
what 'real programmers' do or do not perform when nobody is watching them!
Real Programmers don't go for all the overhead of patching binaries, Real
Programmers patch memory directly.
From: Jeffrey Shulman <firstname.lastname@example.org>
Real Programmers do AI in assembly language.
Real Programmers do number crunching in InterLisp on a Z-80 with 4K bytes
Real Lisp Programmers never use SETx or PROGx and rely totally on side
From: Jerry E. Pournelle <pourne@mit-mc>
Real Programmers don't use decimal....
Real programmers think in hex and can program their machines without
resorting to assemblers or high-level languages.
Subject: Real Programmers (4)
From: R.D.Eager@UKC 05 Oct 83 16:21:30 BST
Comments: This is even earlier then the Mel one; a short set of definitions.Real Programmers don't write specs -- users should consider themselves
lucky to get any programs at all and take what they get.
Real Programmers don't comment their code. If it was hard to write, it should
be hard to understand.
Real Programmers don't write application programs; they program right down on
the bare metal. Application programming is for feebs who can't do systems
Real Programmers don't eat quiche. In fact, real programmers don't know how
to SPELL quiche. They eat Twinkies, and Szechwan food.
Real Programmers don't write in COBOL. COBOL is for wimpy applications
Real Programmers' programs never work right the first time. But if you throw
them on the machine they can be patched into working in "only a few" 30-hour
Real Programmers don't write in FORTRAN. FORTRAN is for pipe stress freaks
and crystallography weenies.
Real Programmers never work 9 to 5. If any real programmers are around at 9
AM, it's because they were up all night.
Real Programmers don't write in BASIC. Actually, no programmers write in
BASIC, after the age of 12.
Real Programmers don't write in PL/I. PL/I is for programmers who can't
decide whether to write in COBOL or FORTRAN.
Real Programmers don't play tennis, or any other sport that requires you to
change clothes. Mountain climbing is OK, and real programmers wear their
climbing boots to work in case a mountain should suddenly spring up in the
middle of the machine room.
Real Programmers don't document. Documentation is for simps who can't read
the listings or the object deck.
Real Programmers don't write in PASCAL, or BLISS, or ADA, or any of those
pinko computer science languages. Strong typing is for people with weak
Subject: Real Programmers (5)
From: R.D.Eager@UKC 05 Oct 83 16:21:43 BST
To: J.Darby@ukcYou may have observed that:
- Real programmers don't waste time recompiling; they patch the binary
May I add the following:
- Real programmers don't waste time patching binary files; they patch
This won't be understood by UNIX freaks; the EMAS filing system
is too simple for them to comprehend.
- Real programmers on EMAS always patch memory; that IS the binary file!