How To Write Unmaintainable Code
Tricks In Offbeat Languages

©1997-2003 Canadian Mind Products.
You are here : home : Java Glossary : unmaintainable code : Offbeat Languages.

Programming in Basic causes brain damage.

Edsger Wybe Dijkstra

• SQL Aliasing

  : Alias table names to one or two letters. Better still alias them to the names of other unrelated existing tables.

• SQL Outer Join

  : Mix the various flavours of outer join syntax just to keep everyone on their toes.

• JavaScript Scope

  : "Optimise" JavaScript code taking advantage of the fact a function can access all local variables in the scope of the caller.

• Visual Basic Declarations

  : Instead of:
  dim Count_num as string
  dim Color_var as string
  dim counter as integer
  use:
  Dim Count_num$, Color_var$, counter%

• Visual Basic Madness

  : If reading from a text file, read 15 characters more than you need to then embed the actual text string like so:
  ReadChars = .ReadChars (29,0)
  ReadChar = trim(left(mid(ReadChar,len(ReadChar)-15,len(ReadChar)-5),7))
  If ReadChars = "alongsentancewithoutanyspaces"
  Mid,14,24 = "withoutanys"
  and left,5 = "without"

• Delphi/Pascal Only

  : Don't use functions and procedures. Use the label/goto statements then jump around a lot inside your code using this. It'll drive 'em mad trying to trace through this. Another idea, is just to use this for the hang of it and scramble your code up jumping to and fro in some haphazard fashion.

• Perl

  : Use trailing if's and unless's especially at the end of really long lines.

• Lisp

  : LISP is a dream language for the writer of unmaintainable code. Consider these baffling fragments:
  (lambda (*<8-]= *<8-[= ) (or *<8-]= *<8-[= ))

  (defun :-] (<) (= < 2))

  (defun !(!)(if(and(funcall(lambda(!)(if(and '(< 0)(< ! 2))1 nil))(1+ !))
  (not(null '(lambda(!)(if(< 1 !)t nil)))))1(* !(!(1- !)))))

• Visual Foxpro

  : This one is specific to Visual Foxpro. A variable is undefined and can't be used unless you assign a value to it. This is what happens when you check a variable's type:
  lcx = TYPE('somevariable')
  The value of lcx will be 'U' or undefined. BUT if you assign scope to the variable it sort of defines it and makes it a logical FALSE. Neat, huh!?
  LOCAL lcx
  lcx = TYPE('somevariable')
  The value of lcx is now 'L' or logical. It is further defined the value of FALSE. Just imagine the power of this in writing unmaintainable code.
  LOCAL lc_one, lc_two, lc_three... , lc_n

  IF lc_one
  DO some_incredibly_complex_operation_that_will_neverbe_executed WITH
  make_sure_to_pass_parameters
  ENDIF

  IF lc_two
  DO some_incredibly_complex_operation_that_will_neverbe_executed WITH
  make_sure_to_pass_parameters
  ENDIF

  PROCEDURE some_incredibly_complex_oper....
  * put tons of code here that will never be executed
  * why not cut and paste your main procedure!
  ENDIF