How to Write Code Nobody Can Maintain – A Satirical Guide

01 Naming

Easy‑to‑type names : e.g., Fred, asdf Single‑letter variables : a, b, c, x, y, z (or a1, a2 …)

Creative misspellings : e.g., SetPintleOpening, SetPintalClosing Abstract names : e.g., ProcessData, DoIt, GetData Acronyms : e.g., WTF, RTFSC, or Chinese pinyin abbreviations like BT, TMD Random capitalisation : e.g., gEtnuMbER Reused names : using the same variable name in nested blocks

Accent characters : e.g., int ínt (second ínt is not int)

Underscores : _, __, ___ Mixed languages : combine English, German, or Chinese pinyin

Symbolic names : e.g., slash, asterix, comma Irrelevant words : e.g., god, superman, iloveu Confuse l and 1 : use lowercase L and digit one interchangeably

02 Obfuscation

Interleave comments and code

for (j=0; j<array_len; j+=8) {
    total += array[j+0];
    total += array[j+1];
    total += array[j+2];
    /* Main body of
       total += array[j+3]; * loop is unrolled
       total += array[j+4]; * for greater speed.
       total += array[j+5]; */
    total += array[j+6];
    total += array[j+7];
}

Hide macros : e.g., #define a=b a=0-b Line breaks to hide identifiers : split names like

xy_z

#define local_var xy\_z // local_var OK

Code/display mismatch : UI says “postal code” but code uses zipcode Hide globals : pass global variables as function parameters to disguise them

Synonyms : use different words for the same concept

#define xxx global_var // in file std.h
#define xy_z xxx // in file ..othersubstd.h
#define local_var xy_z // in file ..codestdinst.h

Similar variable names : swimmer vs swimner, ilI1|, parselnt vs parseInt, etc.

Function overloading with unrelated behaviour

Operator overloading for nonsense

Macro tricks to change definitions per include count

#ifndef DONE
#ifdef TWICE
// put stuff here to declare 3rd time around
void g(char* str);
#define DONE
#else
#ifdef ONCE
// put stuff here to declare 2nd time around
void g(void* str);
#define TWICE
#else
// put stuff here to declare 1st time around
void g(std::string str);
#define ONCE
#endif // ONCE
#endif // TWICE
#endif // DONE

03 Documentation and Comments

Lie in comments : never update comments when code changes

Obvious comments : e.g., /* add 1 to i */ Comment what, not why

Never comment secrets : hide critical logic from documentation

Over‑detail : write exhaustive design documents with hundreds of sections

Never mention units : omit seconds vs milliseconds, pixels vs inches, etc.

Gotchas : never comment pitfalls

Vent frustrations in comments

04 Design

Java casts : excessive type casting from collections

Exploit Java redundancy : e.g., Bubblegum b = new Bubblegom(); Never validate input or return values

No encapsulation : expose all details to callers

Copy‑paste cloning : reuse code without understanding

Huge listeners : a single listener handling all buttons with massive if…else chains

Multi‑dimensional arrays : use 3‑D or even 4‑D arrays unnecessarily

Mix getters/setters with public fields

Deep packaging : wrap APIs 6‑8 times, 4+ layers deep

Make everything public

Swap parameter order repeatedly

Rename variables to be overly specific

Packratting : keep all unused variables and methods

Final everything : mark all classes final to prevent inheritance

Avoid interfaces and avoid layout managers

Environment variables for initialization

Magic numbers

Global variables everywhere

Configuration files with mismatched names

Bloated classes

Excessive subclassing

05 Mess Up Your Code

Use XML to bloat code

Obfuscate C code

Use different numeral bases

Prefer void* and cast everywhere

Implicit conversions (e.g., C++ constructors)

Decompose conditions : a==100 → a>99 && a<101 Exploit semicolons : if (a); else { int d; d=c; } Indirect conversions : new Double(d).toString() instead of Double.toString(d) Deep nesting : >10 parentheses or >20 nested blocks

Swap array indexing syntax

Long lines

Avoid early returns, goto, break

Omit braces in nested if‑else Macro abuse

Trivial encapsulation

Loop tricks : replace for with while, swap bounds, etc.

06 Testing

Never test : skip error‑handling tests

Never do performance testing

Don’t write test cases

View testing as cowardice

07 Other

Your boss knows everything : obey blindly to learn unmaintainable tricks

Subvert the help desk : hide bugs from support

Stay silent about big bugs

Deceive : label bad code with GoF patterns or agile buzzwords

Write Everywhere, Read Nowhere