FROM THE NOTEBOOKS OF LAZARUS LONGINT
-------------------------------------

(With apologies to the late Robert Heinlein)

* Work smarter, not harder. Sometimes the answer you're looking for is 
  simpler than what you're doing right now. Nothing beats falling back to 
  fundamentals.
  
* If you're going to write clever code, document it well. You may have to 
  look at it again a year from now.
  
* There is in old saying to the effect that, after you spend hours banging 
  your head against a bug, someone completely foreign to the situation will 
  walk into your office and immediately spot the flaw. It's true, and 
  something you should use often. If necessary, lure them in with food.
  
* Know yourself, and your limitations. Extend the frontiers of your 
  capabilities early and often. Techniques from one discipline may well 
  apply to another, so generalise. When nobody's looking, assign yourself 
  tasks in things you've never tried before and then try to do them. Don't 
  be afraid to make mistakes. Mistakes should be framed and hanging on the 
  wall.
  
* Read.
  
* An ounce of analysis is worth a pound of debugging.
  
* You can only make your code so fast and so small. After that, you're 
  spending more time on it than it's worth. If you add 25% more time to 
  squeeze out 5% more performance, you're wasting your time and money. Move 
  on to something else.
  
* At some points, depth of experience is more important than breadth. Even 
  though you may be second-best at everything, sometimes you need the help 
  of the "first-best" at some particular thing. Find that person and ask 
  questions.
  
* Be kind to the technically impaired. Every nonprogrammer on the planet 
  can do five or six things you can't, and do them better than you'll ever 
  be able to. Trade talents, not contempt.
  
* Regarding trying to revamp existing products when you're the new person 
  on the block: Never become involved in a debate that was going on when you 
  entered the room. You don't know who's on what side, or what's already 
  been said. Worse, you might end up allied with somebody you don't like.
  
* Never believe your own PR. Nobody could be THAT good.
  
* Never test for an error condition you don't know how to handle.
  
* Beware of being an absolute purist: purely OOP, purely modular, purely 
  C, purely Pascal, purely BASIC, purely ASM. Only academics and the 
  immature are absolute purists: The experienced remember that hybrids are 
  generally stronger than purebreds, and terrier/collie mixes are usually 
  less fussy than teacup poodles.
  
* Of course you're a genius. This is a secret best kept to yourself.
  
* Never confuse intellect with wisdom. Intellect is knowing what or how. 
  Wisdom is knowing when and why.
  
* Admit when you're wrong. Demand the same from others - including upper 
  management.
  
* Never let nontechnical management tell you what is and what is not 
  technically best. Never tell them what is and is not good management. Grit 
  your teeth if necessary.
  
* Don't feel that anything's wrong when you find yourself wandering the 
  hallways muttering to yourself. Most people don't do enough of it.
  
* Don't be intimidated by deadlines. You can always explain why the 
  project is late. What you don't want to explain is why three years of 
  somebody's important data went into the dumper due to a bug you didn't 
  catch because you were working feverishly  to beat the deadline.
  
* Get a hobby. If necessary, get a life.
  
  
(Copied from PC Techniques Oct/Nov 1990)
  