What is a Real Software Engineer?
(Downloaded from The Cave, Wgtn.)

             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 tat they don't have to
 
Real Software Engineers don't write applications 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 don't 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 queasy 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 program
 
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 don't 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 occasionally 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 don't 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 dependencies 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, preferaby 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 functions
 
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 except that they need 8
megabytes to run their Correctness Verification Aid packages


                   Real Programmers Don't Write Specs
                   ----------------------------------
 
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 eat 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
9AM, 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/1.  PL/1 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
 
Real Programmers can recite powers of 16 up to infinity, write language
translators in SNOBOL to produce COBOL source code, use FORTRAN only for
tricky little programs, never drink lager, never drink decaffelnated coffee,
never smoke low-tar cigarettes
 
Real Programmers explain their work (if ever) to their managers in baby-talk
so they will understand it
 
Real Programmers don't talk to support center 2nd level people.  (Their
working hours are mutually exclusive)
 
Real Programmers start assembly of the whole system at 9AM at high priority
so it will be finished by their evening stand-alone time
 
Real Programmers don't write in APL
Any fool can be obscure in APL
 
Real Programmers think structured programming is a Communist plot
 
Real Programmers don't use schedules
Schedules are for managers toadies
Real Programmers like to keep their man suspense
 
Real Programmers do it middle out
 
Real Programmers enjoy getting CP/M to work on 370 machines and MVS on their
ZX81s
 
Real Programmers write their own assemblers, preferably in LISP
 
Real Programmers know that good human factors design requires only the
application of common sense.  Besides, no one cares about users.  Programs
are written for aesthetic beauty
 
Real Programmers do not wonder where the bits went following a shift
operation.  They do not care


              Real Computer Scientists Don't Write Specs
              ------------------------------------------
 
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 Szechwan food since the
hackers discovered it.  Many Real Computer Scientists consider eating an
implemenation detail
 
If it doesn't have a programming environment complete with interface
debugger, structure editor, and extensive cross-module 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 program in assembler.  They 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 it is compiled.  (Only batch freaks and efficiency
weirdos bother with compilers)
 
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 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 system runs
 
Real Computer Scientists don't run IBM hardware.  If someone will fix it when
it breaks, it's not spacey enough


                             Real users Don't
                             ----------------
 
Real Users don't define requirements...
...If these computer folks are so smart, they should KNOW what we want



