Click here to Skip to main content
15,867,308 members
Articles / Artificial Intelligence

Real Programmers Don't Use PASCAL

Rate me:
Please Sign up or sign in to vote.
4.97/5 (48 votes)
17 May 2012Public Domain 195.9K   74   32
Very humorous historical text about the art of programming computers

Update 

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"[1] is an essay[2] about computer programming written by Ed Post of Tektronix, Inc., and published in July 1983 as a letter to the editor in Datamation.[3]  

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.

Introduction

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" and "ABEND" (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] 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 even understand their very own Personal Computer. The Real Programmer is in danger of becoming extinct, of being replaced by high-school students with TRASH-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 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).

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

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

Operating Systems

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.

Programming Tools

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 computers [3]. 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 mouse.

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 [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 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 programming.
  • 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 is inefficient.
  • 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 [5].

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 (literally!).
  • 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 transmissions.
  • 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 [6]. (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 sand.
  • 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 [9].
  • 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.

The Future

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 ([7] and [8]) 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!

Acknowlegement

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 initial inspiration.


References

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

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

[3] Ilson, R., "Recent Research in Text Processing", IEEE Trans. Prof. Commun., Vol. PC-23, No. 4, Dec. 4, 1980.

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

[5] Weinberg, G., "The Psychology of Computer Programming", New York, Van Nostrand Reinhold, 1971, p. 110.

[6] Dijkstra, E., "On the GREEN language submitted to the DoD", Sigplan notices, Vol. 3 No. 10, Oct 1978.

[7] Rose, Frank, "Joy of Hacking", Science 82, Vol. 3 No. 9, Nov 82, pp. 58-66.

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

[9] 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.
Maybe they 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" sounded funny 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 discussed.

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

"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 genius.

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


Historical Messages

Subject:  Real programmers (2)
From:     R.D.Eager@UKC         05 Oct 83  16:21:03 BST
To:       J.Darby@ukc
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 <shulman@rutgers.arpa>

Real Programmers do AI in assembly language.

Real Programmers do number crunching in InterLisp on a Z-80 with 4K bytes memory.

Real Lisp Programmers never use SETx or PROGx and rely totally on side effects.

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
To:       J.Darby@ukc
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 programming.

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

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 debugging sessions.

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


(Message 19)
Subject:  Real Programmers (5)
From:     R.D.Eager@UKC         05 Oct 83  16:21:43 BST
To:       J.Darby@ukc
You may have observed that:

  • Real programmers don't waste time recompiling; they patch the binary files.

and that
  • Real programmers don't waste time patching binary files; they patch memory.

May I add the following:
  • Real programmers on EMAS always patch memory; that IS the binary file!

This won't be understood by UNIX freaks; the EMAS filing system is too simple for them to comprehend.

License

This article, along with any associated source code and files, is licensed under A Public Domain dedication


Written By
Product Manager PSI Logistics GmbH
Germany Germany
I started programming computers in 1979. After years of management and administration application programming, I started to work mainly in the telecommunication sector in 1986. While working at Cycos AG (formerly known as PP-COM GmbH) from 1992 to 1999 I was involved in the development of core and GUI components of their telematic server MRS for ISDN. After that I worked for a telecommunication company named Infitel International N.V. that produces software for open telecommunication services. After a long stop at Cycos AG, I worked for several other companies like Siemens Enterprise Communications, Axxom Software AG and PSI Logistics GmbH.

If you are curious about my other Computer related activities and previous projects, visit YeaSoft International

Comments and Discussions

 
GeneralMy vote of 5 Pin
_Vitor Garcia_18-Jul-13 6:48
_Vitor Garcia_18-Jul-13 6:48 
QuestionSmart Programmers Don't Use CPP Pin
Highflyer4-Apr-13 18:47
Highflyer4-Apr-13 18:47 
GeneralMy vote of 5 Pin
Sperneder Patrick17-May-12 5:04
professionalSperneder Patrick17-May-12 5:04 
GeneralWonderful ... Pin
Bill Gord1-Dec-09 15:15
professionalBill Gord1-Dec-09 15:15 
GeneralThe Glory Days Pin
fldz22-Dec-08 15:31
fldz22-Dec-08 15:31 
GeneralIn Fact Pin
sabrown10016-Oct-07 11:49
sabrown10016-Oct-07 11:49 
GeneralRe: In Fact Pin
krashan16-Dec-09 1:17
krashan16-Dec-09 1:17 
Generalthe halo Pin
jane Mary22-Aug-07 17:22
jane Mary22-Aug-07 17:22 
GeneralReal Programmer Pin
youlittlebrain7-Nov-06 21:53
youlittlebrain7-Nov-06 21:53 
GeneralRe: Real Programmer Pin
kakarato18-May-09 2:58
kakarato18-May-09 2:58 
GeneralI finally found it Pin
underclocker7-Apr-06 6:23
underclocker7-Apr-06 6:23 
GeneralNahhhhh, Real Programmers use APL Pin
hector santos23-Nov-05 15:57
hector santos23-Nov-05 15:57 
GeneralA few corrections Pin
Joseph M. Newcomer25-Jun-03 6:32
Joseph M. Newcomer25-Jun-03 6:32 
GeneralRe: A few corrections Pin
Anonymous15-Oct-03 8:41
Anonymous15-Oct-03 8:41 
GeneralRe: A few corrections Pin
Don Clugston19-Nov-03 12:57
Don Clugston19-Nov-03 12:57 
GeneralRe: A few corrections Pin
Anonymous3-Nov-04 3:55
Anonymous3-Nov-04 3:55 
GeneralRe: A few corrections Pin
Seishin#26-Dec-06 22:19
Seishin#26-Dec-06 22:19 
AnswerRe: A few corrections Pin
Steve Reilly24-Apr-07 7:44
Steve Reilly24-Apr-07 7:44 
GeneralRe: A few corrections Pin
Joseph M. Newcomer24-Apr-07 8:05
Joseph M. Newcomer24-Apr-07 8:05 
GeneralRe: A few corrections Pin
Steve Reilly24-Apr-07 8:18
Steve Reilly24-Apr-07 8:18 
GeneralRe: A few corrections Pin
Hezek1ah21-May-12 14:33
Hezek1ah21-May-12 14:33 
GeneralIt is nonsense Pin
jirisoler10-Feb-03 2:05
jirisoler10-Feb-03 2:05 
Cry | :(( Real programmer uses IBM/360, IBM/370 mentioned is superfluous luxury. I personally started with FORTRAN IV on IBM 7040, to say nothing about assemblerRose | [Rose] and russian "computer" MINSK IV (the same number as for FORTRAN). But true lover of digital world preferes perfocards a perfortapes - how beautiful has been perfotape stars on the Xmas tree! And real computer gourmet uses binary computer code, no assemblers and/or similar helpers. The set of harware switches on the computer desk is the best debugging tool!

Jiří Šoler
GeneralReal Authors... Pin
Tim Lesher16-Sep-02 6:55
Tim Lesher16-Sep-02 6:55 
GeneralRe: Real Authors... Pin
Thomas Freudenberg31-Oct-02 13:40
Thomas Freudenberg31-Oct-02 13:40 
Generalmmm Pin
13-Nov-01 3:22
suss13-Nov-01 3:22 

General General    News News    Suggestion Suggestion    Question Question    Bug Bug    Answer Answer    Joke Joke    Praise Praise    Rant Rant    Admin Admin   

Use Ctrl+Left/Right to switch messages, Ctrl+Up/Down to switch threads, Ctrl+Shift+Left/Right to switch pages.