Real Programmers

Real Programmers don't eat quiche. They eat Twinkies and Szechwan food.

Real Programmers don't bring brown bag lunches to work. If the vending machine sells it, they eat it. If the vending machine doesn't sell it, they don't eat it. Vending machines don't sell quiche.

Real Programmers don't play tennis or any other sport which requires a change of clothes. Mountain climbing is OK, and real programmers often wear climbing boots to work in case a mountain should suddenly spring up in the middle of the machine room.

Real Programmers wear hiking boots only when it's much too cold to wear sandals. When it's only too cold, they wear socks with their sandals.

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 never work 9 to 5. If any real programmers are around at 9 A.M., it's because they were up all night.

Real Programmers spend 70% of their workday fiddling around and then get more done in the other 30% than a user could get done in a week.

Real Programmers are surprised when the odometers in their cars don't turn from 99999 to 9999A.

Real Programmers are concerned with the aesthetics of their craft; they will writhe in pain at shabby workmanship in a piece of code.

Real Programmers will defend to the death the virtues of a certain piece of peripheral equipment, especially their lifeline, the terminal.

Real Programmers never use hard-copy terminals, they never use terminals that run at less than 9600 baud, they never use a terminal at less than its maximum practical speed.

Real Programmers think they know the answers to your problems, and will happily tell them to you rather than answer your questions.

Real Programmers never program in COBOL -- money is no object.

Real Programmers never right-justify text that will be read on a fixed-character-width medium.

Real Programmers don't think that they should get paid at all for their work, but they know that they're worth every penny that they do make.

Real Programmers log in first thing in the morning, last thing before they go to sleep, and stay logged in for lots of time in between.

Real Programmers don't write application programs. They program right down to the bare metal. Application programming is for dullards who can't do systems programming.

Real Programmers don't write specs. Users should be grateful for whatever they get; they are lucky to get any programs at all.

Real Programmers only write specs for languages that might run on future hardware. Noboby trusts them to write specs for anything Homo sapiens will ever be able to fit on a single planet.

Real Programmers don't comment their code. If it was hard to write, it should be hard to understand and even harder to modify.

Real programmers don't document. Documentation is for simpletons who can't read listings or the object code from a dump.

Real programmers don't draw flowcharts. Flowcharts are, after all, the illerate's form of documentation.

Real Programmers don't use Macs. Computers which draw cute little pictures are for wimps.

Real Programmers don't read manuals. Reliance on a reference is the hallmark of a novice and a coward.

Real Programmers don't write in COBOL. COBOL is for gum-chewing twits who maintain ancient payroll programs.

Real Programmers don't write in FORTRAN. FORTRAN is for wimpy engineers who wear white socks. They get excited over finite state analysis and nuclear reactor simulations.

Real Programmers don't write FORTRAN. FORTRAN is for pipe-stress freaks and crystallography weenies.

Real Programmers don't write in Modula-2. Modula-2 is for insecure anal-retentives who can't choose between Pascal and COBOL.

Real Programmers don't write in APL unless the whole program can be written on one line.

Real Programmers don't write in APL. Any fool can be obscure in APL.

Real Programmers don't write in Lisp. Only effeminate programmers use more parentheses than actual code.

Real Programmers don't write in Pascal, Ada, or any of those other pinko computer-science languages. Strong variable typing is for people with weak memories.

Real Programmers distain structured programming. Structured programming is for compulsive neurotics who were prematurely toilet-trained. They wear neckties and carefully line up sharp pencils on an otherwise clear desk.

Real Programmers scorn floating-point arithmetic. The decimal point was invented for pansy bed-wetters who are unable to think big.

Real Programmers know every nuance of every instruction and use them all in every Real Program. Some candy-ass architectures won't allow EXECUTE instructions to address another EXECUTE instruction as the target instruction.

Real Programmers despise petty restrictions.

Real Programmers don't use PL/I. PL/I is for insecure momma's boys who can't choose between COBOL and FORTRAN.

Real Programmers don't use BASIC. In fact, no programmers use BASIC after reaching puberty.

Real Programmers don't like the team-programming concept. Unless, of course, they are the chief programmer.

Real Programmers have no use for managers. Managers are sometimes a necessary evil. Managers are good for dealing with personnel bozos, bean counters, senior planners, and other mental defectives.

Real Programmers don't use schedules. Schedules are for managers' toadies.

Real Programmers like to keep their managers in suspense.

Real programmers ignore schedules.

Real Programmers write self-modifying code.

Real Programmers think better when playing Adventure or Rogue.

Real Programmers use C since it's the easiest language to spell.

Real Programmers don't use symbolic debuggers -- who needs symbols?

Real Programmers only curse at inanimate objects.

Real Programmers know better than the users what they need.

Real Programmers think structured programming is a communist plot.

Real Programmers do it middle-out.

Real Programmers enjoy machine-coding PASCAL compilers for their micros, which they improve but never use.

Real Programmers enjoy getting CP/M to work on 370 machines and MVS on their ZX81's.

Real Programmers write their own assemblers, preferably in LISP.

Real Programmers never get annoyed by security systems. They turn off the RACF bits and leave unsigned messages in the security data sets.

Real Programmers never update the source to reflect the ZAP's; after all, it will have changed again tomorrow.