- 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 read. - Real programmers don't write application programs, they pro- gram right down on the bare metal. Application programming is for feebs who can't do systems programming. - Real programmers don't eat quiche. Real programmers don't even know how to spell quiche. They eat Twinkies, Coke and palate-scorching Szechwan food. - Real programmers don't draw flowcharts. Flowcharts are, after all, the illiterate's form of documentation. Cavemen drew flowcharts; look how much it did for them. - Real programmers don't read manuals. Reliance on a reference is a hallmark of the novice and the coward. - 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-hours debugging sessions. - Real programmers don't use Fortran. Fortran is for wimpy engineers who wear white socks, pipe stress freaks, and crystallography weenies. They get excited over finite state analysis and nuclear reactor simulation. - Real programmers don't use COBOL. COBOL is for wimpy application programmers. - 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 program- mers write in BASIC, after the age of 12. - 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. - Real programmers know better than the users what they need. - Real programmers think structured programming is a communist plot. - Real programmers don't use schedules. Schedules are for manager's toadies. Real programmers like to keep their manager in suspense. - Real programmers think better when playing adventure. - 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 APL, unless the whole program can be written on one line. - Real programmers don't use LISP. Only effeminate programmers use more parentheses than actual code. - Real programmers disdain structured programming. Structured programming is for compulsive, prematurely toilet-trained neurotics who wear neckties and carefully line up sharpened pencils on an otherwise uncluttered desk. - 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 a necessary evil. Managers are for dealing with personnel bozos, bean counters, senior planners and other mental defectives. - Real programmers scorn floating point arithmetic. The decimal point was invented for pansy bedwetters who are unable to "think big." - Real programmers don't drive clapped-out Mavericks. They prefer BMWs, Lincolns or pick-up trucks with floor shifts. Fast motorcycles are highly regarded. - 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 don't believe in schedules. Planners make up schedules. Managers "firm up" schedules. Frightened coders strive to meet schedules. Real programmers ignore schedules. - Real programmers like vending machine popcorn. Coders pop it in the microwave oven. Real programmers use the heat given off by the cpu. They can tell what job is running just by listening to the rate of popping. - Real programmers know every nuance of every instruction and use them all in every real program. Puppy architects won't allow execute instructions to address another execute as the target instruction. Real programmers despise such petty restrictions. - 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. ------------------------------------------------------------------------------- THE TECHIE CODE --------------- REAL PROGRAMMERS DON'T WRITE SPECS Real Programmers (RP) don't write specs -- users should consider themselves lucky to get any programs at all and take what they get. RP don't comment their code. If it is hard to write, it should be hard to understand. RP don't write applications programs; they program right down to the bare metal. Applications programming is for dweebs who can't do systems programming. RP don't eat quiche. In fact, RP don't even know how to spell quiche. They eat twinkies and szechwan food. RP don't write in COBOL. COBOL is for wimpy applications programmers. RP's 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. RP don't write in FORTRAN. FORTRAN is for pipe-stress freaks and crystallography weenies. RP never work 9-5. If any RP are even around at 9am, it's because they were up all night. RP never write in BASIC. Actually, no programmers ever write in BASIC after the age of 12. RP don't write in PL/1. PL/1 is for programmers that can't decide between COBOL and FORTRAN. RP don't play tennis, or any other sport that requires you to change clothes. Mountain climbing is ok, and RP wear their climbing boots to work in case a mountain should suddenly spring up in the middle of the machine room. RP don't document. Documentation is for simps who can't read the listings or the object deck. RP don't write in Pascal, or BLISS, or ADA, or any of those pinko computer science languages. Strong typing is for people with weak minds. RP never make up schedules. Only planners make up schedules. Only managers read them. RP never deliver programs on schedule. Either the program is "done" in 2 days or it is never finished. In any case, it is never delievered when it was scheduled. RP never eat at restaurants. If the vending machine sells it they eat it. If it doesn't, they don't. Recently RP discovered that popcorn was being sold in vending machines. Common coders discovered that it could be popped in the microwave oven in the vending-machine room but real programmers use the heat escaping from the top of the CPU. RP never deliver programs on Wednesdays. RP never deliver programs in the first day of any month. RP know that good human factors design requires only the application of common sense. Besides, no one cares about users. The program's written for aesthetic beauty. RP know every nuance of every instruction and they use them all in every program RP do not clear registers twice before using them. In fact, if you annoy a RP, he/she won't clear the registers at all. And that goes for your memory too! RP do not wonder where the bits went following a shift operation. They do not care. RP are not in it for the money. Most of them are secret millionaires. REAL SOFTWARE ENGINEERS DON'T READ DUMPS Real software engineers don't read dumps. They never generate them, and on the rare occasions that they come across them, they are vaguely amused. Real software engineers don't comment their code. The identifiers are so mnemonic they don't have to. Real software engineers don't write application programs, they implement algorithms. If someone has an application that the algorithm might help with, that's nice. Don't ask them to write the user interface, though. Real software engineers eat quiche. If it doesn't have recursive function calls, real software engineers don't program in it. Real software engineers don't program in assembler. They become quesy at the very thought. Real software engineers don't debug programs, they verify correctness. This process doesn't necessarily involve executing anything on a computer, except perhaps a Correctness Verification Aid package. Real software engineers like C's structured constructs, but they are suspicious of it because they have heard that it lets you get "close to the machine." Real software engineers play tennis. In general, they don't like any sport that involves getting hot and sweaty and gross when out of range of a shower. (Thus mountain climbing is Right Out.) They will occassionaly wear their tennis togs to work, but only on very sunny days. Real software engineers admire PASCAL for its discipline and Spartan purity, but they find it difficult to actually program in. They don't tell this to their friends, because they are afraid it means that they are somehow Unworthy. Real software engineers work from 9 to 5, because that is the way the job is described in the formal spec. Working late would feel like using an undocumented external procedure. Real software engineers write in languages that have not actually been implemented for any machine, and for which only the formal spec (in BNF) is available. This keeps them from having to take any machine dependencies into account. Machine dependences make real software engineers very uneasy. Real software engineers don't write in ADA, because the standards bodies have not quite decided on a formal spec yet. Real software engineers like writing their own compilers, preferably in PROLOG (they also like writing them in unimplemented languages, but it turns out to be difficult to actually RUN these). Real software engineers regret the existence of COBOL, FORTRAN and BASIC. PL/1 is getting there, but it is not nearly disciplined enough; far too much built in function. Real software engineers aren't too happy about the existence of users, either. Users always seem to have the wrong idea about what the implementation and verification of algorithms is all about. Real software engineers don't like the idea of some inexplicable and greasy hardware several aisles away that may stop working at any moment. They have a great distrust of hardware people, and wish that systems could be virtual at ALL levels. They would like personal computers (you know no one's going to trip over something and kill your DFA in mid-transit), except that they need 8 megabytes to run their Correctness Verification Aid packages. Real software engineers think better while playing WFF 'N' PROOF. REAL COMPUTER SCIENTISTS DON'T WRITE CODE Real computer scientists don't write code. They occasionally tinker with 'programming systems', but those are so high level that they hardly count (and rarely count accurately; precision is for applications.) Real computer scientists don't comment their code. The identifiers are so long they can't afford the disk space. Real computer scientists don't write the user interfaces, they merely argue over what they should look like. Real computer scientists don't eat quiche. They shun Schezuan food since the hackers discovered it. Many real computer scientists consider eating an implementation detail. (Others break down and eat with the hacker, but only if they can have ice cream for desert.) If it doesn't have a programming environment complete with interactive debugger, structure editor, and extensive cross module test checking, real computer scientists won't be seen tinkering with it. They may have to use it to balance their checkbooks, as their own systems can't. Real computer scientists don't 'write' in anything less portable than a number two pencil. Real computer scientists don't debug programs, they dynamically modify them. This is safer, since no one has invented a way to do anything dynamic to FORTRAN, COBOL, or BASIC. Real computer scientists like C's structured constructs, but they are suspicious of it because its compiled. (Only Batch freaks and efficiency weirdos bother with compilers, they're soooo un-dynamic.) Real computer scientists play go. They have nothing against the concept of mountain climbing, but the actual climbing is an implementation detail best left to programmers. Real computer scientists admire ADA for its overwhelming aesthetic value, but they find it difficult to actually program in, as it is much too large to implement. Most computer scientists don't notice this because they are still arguing over what else to add to ADA. Real computer scientists work from 5pm to 9am because that's the only time they can get the 8 megabytes of main memory they need to edit specs. (Real work starts around 2am when enough MIPS are free for their dynamic systems.) Real computer scientists find it hard to share 3081s when they are doing 'REAL' work. Real computer scientists only write specs for languages that might run on future hardware. Nobody trusts them to write specs for anything homo sapiens will ever be able to fit on a single planet. Real computer scientists like planning their own environments to use bit mapped graphics. Bit mapped graphics is great because no one can afford it, so their systems can be experimental. Real computer scientists regret the existence of PL/1, PASCAL and LISP. ADA is getting there, but it is still allows people to make mistakes. Real computer scientists love the concept of users. Users are always real impressed by the stuff computer scientists are talking about; it sure sounds better than the stuff they are being forced to use now. Real computer scientists despise the idea of actual hardware. Hardware has limitations, software doesn't. It's a real shame that Turing Machines are so poor at I/O. Real computer scientists love conventions. No one is expected to lug a 3081 attached to a bit map screen to a convention, so no one will ever know how slow their systems run.