From: michaelb@cse.fau.edu (Michael Rogero Brown)
Newsgroups: alt.folklore.computers
Subject: The Techie Code
Summary: Real Programmers, Real Software Engineers, Real computer scientists
Date: 9 Oct 92 16:03:09 GMT
Distribution: na
Organization: Florida Atlantic University, Boca Raton, FL, USA

This is a more complete work on Real Programmers.  Got it from a prof
here in the department.


                         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.

-- 
<<                                                               >>
<< Michael R. Brown    CS Graduate Student-Florida Atlantic Univ >>
<< Internet: michaelb@sol.cse.fau.edu                            >>
<< BitNet: m_brown@fauvax                                        >>
Newsgroups: alt.folklore.computers