Back  in  the good old days-  the "Golden Era" of  compu-
ters,  it  was quite easy to separate the real men from the  boys 
(sometimes  called "Real Men" and "Quiche Eaters" in the  litera-
ture).   During  this  period,  the Real Men were the  ones  that 
understood computer programming,  and Quiche Eaters were the ones 
that didn't.  A real computer programmer said things like:

DO 10 I=1,10

and:

ABEND

They talked in capital letters, you understand.  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] points out that Real Men don't "relate  to" 
anything and aren't afraid of being impersonal.

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 
understand their own personal computer.   The Real Programmer  is 
in  danger of becoming extinct,  of being replaced by high-school 
students with TRS-80's.

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 to 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   very 
considerable salary savings).


			    LANGUAGES

The easiest way to tell a Real Programmer from the  crowd 
is by the programming language he or she uses.   Real Programmers 
use  FORTRAN.  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 call  me  by 
name,  pronouncing  it  'Veert',  or you can call  me  by  value, 
'Worth'".   One  can  tell  immediately from  this  comment  that 
Nicklaus  Wirth  is a Quiche Eater.  The only  parameter  passing 
mechanism  that  Real  Programmers  endorse is  "call  by  value-
return", as implemented in the IBM3370 FORTRAN G and H compilers.  
Real  Programmers don't need all those abstract concepts  to  get 
their  jobs done-  they are perfectly happy with  a  keypunch,  a 
FORTRAN IV compiler, and a beer.

oReal Programmers do List Processing in FORTRAN.

oReal Programmers do String Manipulation in FORTRAN.

o Real Programmers do Accounting (if they do it at  all) in 
       FORTRAN.

oReal  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.


		     STRUCTURED PROGRAMMING

The  academics in computer science have gotten  into  the 
"structured  programming" rut over the last several years.   They 
claim that programs are more easily understood if the  programmer 
uses  some  special 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 ino 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 Program-
mer  will  tell you that all the Structured  Programming  in  the 
world  won't help you solve a problem like that- it takes  actual 
talent.   Some  quick observations on Real Programmers and Struc-
tured Programming:

oReal Programmers aren't afraid to use GOTO's.

o Real Programmers can write five-page long DO loops  with-
       out getting confused.

oReal Programmers like arithmetic IF statements- they make 
       the code more interesting.

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

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

o 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, all those structures 
       can  be  simulated,  when  necessary,  by  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.   Nicklaus  Wirth  (the 
aforementioned  Quiche Eater) actually managed to write an entire 
book [2] contending that you could write a program based on  Data 
Structures, instead of the other way around.  As all Real Progra-
mmers  know,  the  only  useful  Data  Structure  is  the  ARRAY.  
Strings,  Lists,  Structures,  Sets-  they  are all just  special 
cases  of Arrays and can be treated that way without  messing  up 
you  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 impli-
cit  typing  based  on the first letter of  the  (six  character) 
variable name.


			OPERATING SYSTEMS

What  kind of operating system does the  Real  Programmer 
use?  CPMM?  God  forbid-  CPMM,  after all,  is basically a  toy 
operating system.   Even little old ladies and grade school  stu-
dents can use and understand CPMM.

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 glori-
fied 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 OS3370.  A good programmer 
can  find and understand the description of the IJK305I error  he 
just  got in the JCL manual.   A great programmer can  write  JCL 
without referring to the JCL manual at all.   A truly outstanding 
programmer  can  find  bugs buried in a  six-Megabyte  core  dump 
without using a hex calculator (I have actually seen this done).

OS3370  is  a truly remarkable  operating  system.   It's 
possible  to  destroy days of work with a single misplaced  space 
(actually this is also true of UNIX), so alertness in the progra-
mming staff is encouraged.   The best way to approach the  system 
is  through  a keypunch.  Some people claim that there is a  Time 
Sharing  system that runs on OS3370,  but after careful  study  I 
have come to the conclusion that they were mistaken.


			PROGRAMMING TOOLS

What  kinds  of  tools does a  Real  Programmer  use?  In 
theory,  a  Real Programmer could run his program 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 his program  destroyed 
the bootstrap.   Back then, memory was memory-  it didn't go away 
when  the  power was turned off.  Today,  memory  either  forgets 
things when you don't want it to,  or remembers things long after 
they're  best  forgotten.   Legend has it that Seymour Cray  (who 
invented  the Cray-1 supercomputer,  and most of  Control  Data's 
computers)  actually  toggled the first operating system for  the 
CDC-7600  in  on the front panel from memory when  it  was  first 
powered on.  Seymour, needless to say, is a Real Programmer.

One of my favorite Real Programmers was a systems progra-
mmer at 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 tele-
phone, getting the user to toggle in disk IOO instructions at the 
front  panel,  repairing system tables in hex,  reading  register 
contents back over the telephone.   The moral of the 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 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 computers [3].  Unfortun-
ately,  no  Real Programmer would use a computer whose  operating 
system is called SmallTalk, and would certainly never talk to the 
computer with a mouse.

Some  of  the concepts in these Xerox editors  have  been 
incorporated  into  editors running on more reasonable  operating 
systems-  EMACS and VI being two.  The problem with these editors 
is  that Real Programmers consider "what you see is what you get" 
is just as bad a concept in Text Editing as it is in women.   No, 
the Real Programmer wants a "you asked for it,  you got it"  text 
editor-  complicated, cryptic, powerful, unforgiving, and danger-
ous.  TECO, to be precise.

It  has been observed that a TECO command  sequence  more 
closely resembles transmission-line noise than readable text [4].  
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 instead to just patch the binary object code direct-
ly, using a wonderful program called SUPERZAP (or it's 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 anyone 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".

Here  are  some programming tools that  Real  Programmers 
don't use:

oFORTRAN preprocessors line MORTRAN or RATFOR.   These are 
       the  Cuisinarts  of programming-  great for making Quiche.  
       See comments above on Structured Programming.

o Source  language debuggers.   Real Programmers  can  read 
       core dumps.

o Compilers with array bounds checking.  They stifle creat-
       ivity,  destroy  most  of  the interesting  uses  for  the 
       EQUIVALENCE  statement,  and make it impossible to  modify 
       the operating system code with negative subscripts.  Worst 
       of all, bounds checking is ineffecient.

oSource code maintenence systems.  A Real Programmer keeps 
       the code locked up in a card file, because it implies that 
       the owner cannot leave important programs unguarded [5].



		   THE REAL PROGRAMMER AT WORK

Where  does the Real Programmer work?  What kinds of pro-
grams 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!).

oReal Programmers work for Los Alamos Mational Laboratory, 
       writing  atomic  bomb simulations to run on Cray-1  super-
       computers.

o Real  Programmers work for the National Security  Agency, 
       decoding Russian transmissions.

o Real  Programmers programmed the computers in  the  Space 
       Shuttle.

o 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 were able to do incredible feats of navigation and  improvi-
sation-  hitting  ten kilometer wide windows at Saturn after  six 
years in space,  repairing or bypassing damaged sensor platforms, 
radios,  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  80+-3  kilometers from the surface  of  Mars.  
Nobody is going to trust a Pascal program (or a Pascal programmer 
for that matter) for navigation to those tolerances.

As  you can tell,  many of the world's  Real  Programmers 
work for the U.S.  Government-  mainly the Department of Defense.  
This  is as it should be.   Recently however,  a black cloud  has 
formed  on the Real Programmer's horizon.   It seems some  highly 
placed  Quiche  Eaters at the Department of Defense 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 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 Real Programmer. Fortu-
nately, the language which the DoD adopted has enough interesting 
features  to  make  it  approachable-  it's  incredibly  complex, 
includes methods for messing with the operating system and  rear-
ranging  memory,   and  Edsger  Dijkstra  doesn't  like  it  [6].  
Dijkstra,  as  I'm  sure you know,  was the author of "The Go  To 
Considered Harmful"-  a landmark work in programming methodology, 
applauded   by  Pascal  Programmers  and  Quiche  Eaters   alike.  
Besides,  the  determined Real Programmer can write FORTRAN  pro-
grams in any language.

Real  Programmers  might compromise their 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 writing video games at  Atari,  for 
example,  (but  not playing them-  a Real Programmer knows how to 
beat  the  machine every time-  there's no  challenge  in  that).  
Everybody at LucasFilm is a Real Programmer (it would be crazy to 
turn  down the money of fifty million Star Trek fans).   The pro-
portion  of  Real Programmers in Computer  Graphics  is  somewhat 
lower  than the norm,  mainly because no one has found a use  for 
Computer Graphics yet.   On the other hand, all Computer Graphics 
programming  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.  The Real Programmer is constantly amazed 
that  his employer actually pays him for what he would  be  doing 
for  fun  anyway  (although  he is careful not  to  express  this 
opinion out loud).  Occasionally, a 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:

o At  a  party,  the Real Programmers are the ones  in  the 
       corner  talking about operating system security and how to 
       get around it.

o At a football game,  the Real Programmer is the one comp-
       aring  the plays against a simulation printed on 11 by  14 
       fanfold paper.

o At  the  beach,  the Real Programmer is the  one  drawing 
       flowcharts in the sand.

oAt a funeral, the Real Programmer is the one saying "Poor 
       George.  And he almost had the sort routine working before 
       the coronary".

o In  a grocery store,  the Real Programmer is the one  who 
       insists on running the cans by the laser checkout  scanner 
       himself,  because  he never could trust keypunch operators 
       to get it right the first time.


		  THE REAL PROGRAMMERS HABITAT

What  sort of environment does the Real Programmer  func-
tion best in?  This is an important question for the managers  of 
Real  Programmers.   Considering the amount of money it costs  to 
keep  Real Programmers on the staff,  it's best to put him or her 
in an environment where they can actually get the work done.

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

oListings of all the programs the Real Programmer has ever 
       worked on,  piled in roughly chronological order on  every 
       flat surface in the office.

o Some  half-dozen  or  so partly filled  cups  of  coffee. 
       Occasionally there will be cigarette butts floating in the 
       coffee.   In  some  cases,  the cups will  contain  Orange 
       Crush.

o Unless  the Real Programmer is very good,  there will  be 
       copies  of  the  OS  JCL  manual  and  the  Principles  of 
       Operation open at some particularly interesting pages.

o Taped  to the wall is a line-printer Snoopy calendar  for 
       the year 1969.

o Strewn  about  the floor are several wrappers for  peanut 
       butter filled cheese bars- of the type that are made  pre-
       stale at the bakery so that they can't get any worse while 
       waiting in the vending machine.

oHiding in the top left-hand drawer of the desk is a stash 
       of double-stuff Oreos for special occasions.

o Underneath  the Oreos is a flow-charting  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 thirty,  forty, 
even fifty hours at a stretch,  under intense pressure.  In fact, 
the  Real  Programmer  prefers it that way.   Bad  response  time 
doesn't  bother the Real Programmer-  it provides the  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 fifty-hour marathons.   This not 
only impresses the hell out of the Real Programmers  manager,  it 
also creates a convenient excuse for not doing the documentation.  
In general:

o No  Real  Programmer works nine to five (unless it's  the 
       ones at night).

o A  Real  Programmer might or might not know the  name  of 
       their spouse.  The Real Programmer does, however, know the 
       entire EBCDIC (or ASCII) code table.

oReal Programmers don't know how to cook.   Grocery stores 
       aren't  open  at  three  o'clock  in  the  morning.   Real 
       Programmers survive on Twinkies and coffee.


			   THE FUTURE

What  of  the future?  It is a matter if some concern  to 
Real Programmers that the latest generation of computer  program-
mers  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 any 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  OS3370  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 programming 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 to a FORTRAN-66 compiler at the drop of an option  card-  to 
compile DO loops the way God intended.

Even UNIX might not be as hard 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  compli-
cated  teletype driver,  and virtual memory.   If you ignore  the 
fact that it's structured,  even C programming can be appreciated 
by  Real  Programmers.  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 at the same  time 
(not even talking about #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 ([7] and [8]) leaving  places 
like  Stanford  and M.I.T.  for the Real  World.   From  all  the 
evidence,  the spirit of Real Programming lives on in these young 
men and women.   As long as there are ill-defined  goals, bizzare 
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!



REFERENCES

[1]Feinstein, B., "Real Men Don't Eat Quiche", New York, Pocket
Books, 1982.

[2]Wirth,  N.,  "Algorithms  + Data Structures =  Programs", 
       Prentice Hall, 1976.

[3]Xerox PARC editors ...

[4]Finseth,  C., "Theory and Practice of Text Editors - or - 
       a Cookbook for an EMACS",  B.S.   thesis,  MITLLCSTTM-165, 
       Massachusetts Institute of Technology, May 1980.

[5]Weinberg,  G.,  "The Pyschology of Computer Programming", 
       New York, Van Nostrand Reingold, 1971, page 110.

[6]Dijkstra,  E.,  "On  the GREEN Language Submitted to  the 
       DoD", Sigplan notices, Volume 3, Number 10, October 1978.

[7]Rose,  Frank,  "Joy of Hacking",  Science 82,  Volume  3, 
       Number 9, November 1982, pages 58-66.

[8]"The Hacker Papers", Psychology Today, August 1980.
