war crimes in programming - A thread to discuss and share horrifying programming ideas/code

  • 🐕 I am attempting to get the site runnning as fast as possible. If you are experiencing slow page load times, please report it.
  • Like
Reactions: 419, grimacefetishist, Harvey Danger and 1 other person
IForgotMyEmail <3 said:
If he wasn't a two-time teen talker and could code competently, people would respect him since he's enduring.
Click to expand...
Lol no. Imagine wasting 10 years on something straight from Steam Greenlight. He could master programming two times in that period, yet he couldn't even master not talking to minors. This is not endurance, this is retardation so severe that he simply cannot realize that it was better to quit. Nevermind the fact that he has a degree in 2D/3D animation, yet not only he can't model or animate, he draws on the level of Chris. As for his code, I can't find it, but I remember that kiwis dived into his noodles and found something like "if something != true then it = false".
 
  • Agree
  • Like
  • Winner
Reactions: Evil Whitey, 419, grimacefetishist and 2 others
African Safari continues:

C: 
double x = //(some long expression);
if (x == x)
{
    doSomething();
}
else
{
    exit(1);
}

Only true C whales will know this one offhand (I didn't) - this is actually a NaN check, since by the IEEE754 rules, NaNs are the only values where x == x is false. (Why isn't this the way isnan is implemented in standard libs then?)

I have no idea whether optimizers are smart enough to leave this alone despite how it looks, and I don't want to know.
 
  • Feels
  • Informative
  • Agree
Reactions: Raging Capybara, stares at error messages, 419 and 5 others
named said:
isnan is implemented by checking some bits at the start of the float.
Click to expand...
Right, that's what I'm saying. Why  isn't it done with the clever-man equals- operator trick if that works? This has all been implemented in hardware.
Is it just faster to examine the bits inplace than to send it to the FPU and do an "equals"?
 
Kosher Dill said:
Is it just faster to examine the bits inplace than to send it to the FPU and do an "equals"?
Click to expand...
In an extremely contrived scenario where it's not in a register and you're loading it from scratch, I think it's very marginally faster. Usually, in x86 and x86_64 calling conventions, you'll already have your value loaded into x87 / xmm anyway, and you'll just use SSE2's UCOMISD instead of taking a round trip through RAM.
 
  • Informative
Reactions: Verpa Teutonica Ingens, grimacefetishist, Scout Trooper and 1 other person
This is modest compared to some of the examples in the video. But then much of that video was deliberately humorous. This was a sincere attempt at coding (mildly anonymised by me). I was subjected to it by someone last week. I was not impressed:

JavaScript: 
 const replacer = ["username"]
 const usernameString = JSON.stringify(user.messages_for, replacer)
 
 const extractedName = usernameString.slice(
    usernameString.indexOf(':') + 2,
    usernameString.lastIndexOf('"')
 )

user is an object with a messages_for property which is an array of message objects. Message objects have, amongst other properties, including a creation timestamp, a username property. His solution to getting the username of the first message recipient (ordered by time), is to stringify the array, filtering only for username properties, and then do a find for the positions of the first : and the last " in the resulting string and return everything in between as the username.

There are multiple mistakes here, not least the idea itself of stringifying objects for purposes of using string searching to get a property. But the greater mistake is probably that of his parents in conceiving him.

He also claimed "it works" which rules out a career in testing pretty conclusively as well.
 
Last edited:
  • Winner
  • Horrifying
Reactions: Verpa Teutonica Ingens, 419, Harvey Danger and 6 others
Overly Serious said:
This is modest compared to some of the examples in the video. But then much of that video was deliberately humorous. This was a sincere attempt at coding (mildly anonymised by me). I was subjected to it by someone last week. I was not impressed:

JavaScript: 
 const replacer = ["username"]
 const usernameString = JSON.stringify(user.messages_for, replacer)
 
 const extractedName = usernameString.slice(
    usernameString.indexOf(':') + 2,
    usernameString.lastIndexOf('"')
 )

user is an object with a messages_for property which is an array of message objects. Message objects have, amongst other properties, including a creation timestamp, a username property. His solution to getting the username of the first message recipient (ordered by time), is to stringify the object, filtering only for username properties, and then do a find for the positions of the first : and the last " in the resulting string and return everything in between as the username.

There are multiple mistakes here, not least the idea itself of stringifying objects for purposes of using string searching to get a property. But the greater mistake is probably that of his parents in conceiving him.

He also claimed "it works" which rules out a career in testing pretty conclusively as well.
Click to expand...
The shier retardation of this code makes it kinda beautiful, tbh. I bet he was proud about what he did.
 
  • Like
Reactions: Verpa Teutonica Ingens, Pedophobe and Scout Trooper
This is a great thread. I always wanted to register the domain www.criminalcode.com and showcase stuff like this.

I recently had to work on a complete disaster of a codebase (supplied by Chinese who just bent over and shat code out of their asses) and my initial approach was to change as little as possible because I wasn't sure of all the requirements that they were answering (don't get me started) and didn't want to break anything.

Until I saw this:

C#: 
double stoptime = Stopwatch.ElapsedMilliseconds - lastExecute * 1000/1000;

Then I knew they had literally no idea what the fuck they were doing or why they were doing it. It made it a lot easier to just delete massive sections of nonsensical code.

I also make everyone read this:

(This is just an excerpt in the quote, the full thing makes the post over 64K characters so it won't let me post it)

How To Write Unmaintainable Code​

Ensure a job for life ;)​

Roedy Green
Canadian Mind Products

Introduction​

Never ascribe to malice, that which can be explained by incompetence.
- Napoleon
Click to expand...


In the interests of creating employment opportunities in the Java programming field, I am passing on these tips from the masters on how to write code that is so difficult to maintain, that the people who come after you will take years to make even the simplest changes. Further, if you follow all these rules religiously, you will even guarantee yourself a lifetime of employment, since no one but you has a hope in hell of maintaining the code. Then again, if you followed all these rules religiously, even you wouldn't be able to maintain the code!

You don't want to overdo this. Your code should not look hopelessly unmaintainable, just be that way. Otherwise it stands the risk of being rewritten or refactored.

General Principles​

Quidquid latine dictum sit, altum sonatur.
- Whatever is said in Latin sounds profound.
Click to expand...
To foil the maintenance programmer, you have to understand how he thinks. He has your giant program. He has no time to read it all, much less understand it. He wants to rapidly find the place to make his change, make it and get out and have no unexpected side effects from the change.
He views your code through a toilet paper tube. He can only see a tiny piece of your program at a time. You want to make sure he can never get at the big picture from doing that. You want to make it as hard as possible for him to find the code he is looking for. But even more important, you want to make it as awkward as possible for him to safely ignore anything.

Programmers are lulled into complacency by conventions. By every once in a while, by subtly violating convention, you force him to read every line of your code with a magnifying glass.

You might get the idea that every language feature makes code unmaintainable -- not so, only if properly misused.

Naming​

"When I use a word," Humpty Dumpty said, in a rather scornful tone, "it means just what I choose it to mean - neither more nor less."
- Lewis Carroll -- Through the Looking Glass, Chapter 6
Click to expand...
Much of the skill in writing unmaintainable code is the art of naming variables and methods. They don't matter at all to the compiler. That gives you huge latitude to use them to befuddle the maintenance programmer.

  1. New Uses For Names For Baby​

    Buy a copy of a baby naming book and you'll never be at a loss for variable names. Fred is a wonderful name, and easy to type. If you're looking for easy-to-type variable names, try adsf or aoeu if you type with a DSK keyboard.

    Single Letter Variable Names​

    If you call your variables a, b, c, then it will be impossible to search for instances of them using a simple text editor. Further, nobody will be able to guess what they are for. If anyone even hints at breaking the tradition honoured since FØRTRAN of using i, j, and k for indexing variables, namely replacing them with ii, jj and kk, warn them about what the Spanish Inquisition did to heretics.

    Creative Miss-spelling​

    If you must use descriptive variable and function names, misspell them. By misspelling in some function and variable names, and spelling it correctly in others (such as SetPintleOpening SetPintalClosing) we effectively negate the use of grep or IDE search techniques. It works amazingly well. Add an international flavor by spelling tory or toriin different theatres/theaters.

    Be Abstract​

    In naming functions and variables, make heavy use of abstract words like it, everything, data, handle, stuff, do, routine, performand the digits e.g. routineX48, PerformDataFunction, DoIt, HandleStuff and do_args_method.

    A.C.R.O.N.Y.M.S.​

    Use acronyms to keep the code terse. Real men never define acronyms; they understand them genetically.

    Thesaurus Surrogatisation​

    To break the boredom, use a thesaurus to look up as much alternate vocabulary as possible to refer to the same action, e.g. display, show, present. Vaguely hint there is some subtle difference, where none exists. However, if there are two similar functions that have a crucial difference, always use the same word in describing both functions (e.g. print to mean "write to a file", "put ink on paper" and "display on the screen"). Under no circumstances, succumb to demands to write a glossary with the special purpose project vocabulary unambiguously defined. Doing so would be an unprofessional breach of the structured design principle of information hiding.

    Use Plural Forms From Other Languages​

    A VMS script kept track of the "statii" returned from various "Vaxen". Esperanto , Klingon and Hobbitese qualify as languages for these purposes. For pseudo-Esperanto pluraloj, add oj. You will be doing your part toward world peace.

    CapiTaliSaTion​

    Randomly capitalize the first letter of a syllable in the middle of a word. For example ComputeRasterHistoGram().

    Reuse Names​

    Wherever the rules of the language permit, give classes, constructors, methods, member variables, parameters and local variables the same names. For extra points, reuse local variable names inside {} blocks. The goal is to force the maintenance programmer to carefully examine the scope of every instance. In particular, in Java, make ordinary methods masquerade as constructors.

    Åccented Letters​

    Use accented characters on variable names. E.g.
    • typedef struct { int i; } ínt;
  2. where the second ínt's í is actually i-acute. With only a simple text editor, it's nearly impossible to distinguish the slant of the accent mark.

    Exploit Compiler Name Length Limits​

    If the compiler will only distinguish the first, say, 8 characters of names, then vary the endings e.g. var_unit_update() in one case and var_unit_setup() in another. The compiler will treat both as var_unit.

    Underscore, a Friend Indeed​

    Use _ and __ as identifiers.

    Mix Languages​

    Randomly intersperse two languages (human or computer). If your boss insists you use his language, tell him you can organise your thoughts better in your own language, or, if that does not work, allege linguistic discrimination and threaten to sue your employers for a vast sum.

    Extended ASCII​

    Extended ASCII characters are perfectly valid as variable names, including ß, Ð, and ñ characters. They are almost impossible to type without copying/pasting in a simple text editor.

    Names From Other Languages​

    Use foreign language dictionaries as a source for variable names. For example, use the German punkt for point. Maintenance coders, without your firm grasp of German, will enjoy the multicultural experience of deciphering the meaning.

    Names From Mathematics​

    Choose variable names that masquerade as mathematical operators, e.g.:
    • openParen = (slash + asterix) / equals;

  3. Bedazzling Names​

    Choose variable names with irrelevant emotional connotation. e.g.:
    • marypoppins = (superman + starship) / god;
  4. This confuses the reader because they have difficulty disassociating the emotional connotations of the words from the logic they're trying to think about.

    Rename and Reuse​

    This trick works especially well in Ada, a language immune to many of the standard obfuscation techniques. The people who originally named all the objects and packages you use were morons. Rather than try to convince them to change, just use renames and subtypes to rename everything to names of your own devising. Make sure to leave a few references to the old names in, as a trap for the unwary.

    When To Use i​

    Never use i for the innermost loop variable. Use anything but. Use i liberally for any other purpose especially for non-int variables. Similarly use n as a loop index.

    Conventions Schmentions​

    Ignore the Sun Java Coding Conventions, after all, Sun does. Fortunately, the compiler won't tattle when you violate them. The goal is to come up with names that differ subtlely only in case. If you are forced to use the capitalisation conventions, you can still subvert wherever the choice is ambigous, e.g. use both inputFilename and inputfileName. Invent your own hopelessly complex naming conventions, then berate everyone else for not following them.

    Lower Case l Looks a Lot Like the Digit 1​

    Use lower case l to indicate long constants. e.g. 10l is more likely to be mistaken for 101 that 10L is. Ban any fonts that clearly disambiguate uvw wW gq9 2z 5s il17|!j oO08 `'" ;,. m nn rn {[()]}. Be creative.

    Reuse of Global Names as Private​

    Declare a global array in module A, and a private one of the same name in the header file for module B, so that it appears that it's the global array you are using in module B, but it isn't. Make no reference in the comments to this duplication.

    Recycling Revisited​

    Use scoping as confusingly as possible by recycling variable names in contradictory ways. For example, suppose you have global variables A and B, and functions foo and bar. If you know that variable A will be regularly passed to foo and B to bar, make sure to define the functions as function foo(B) and function bar(A) so that inside the functions A will always be referred to as B and vice versa. With more functions and globals, you can create vast confusing webs of mutually contradictory uses of the same names.

    Recycle Your Variables​

    Wherever scope rules permit, reuse existing unrelated variable names. Similarly, use the same temporary variable for two unrelated purposes (purporting to save stack slots). For a fiendish variant, morph the variable, for example, assign a value to a variable at the top of a very long method, and then somewhere in the middle, change the meaning of the variable in a subtle way, such as converting it from a 0-based coordinate to a 1-based coordinate. Be certain not to document this change in meaning.

    Cd wrttn wtht vwls s mch trsr​

    When using abbreviations inside variable or method names, break the boredom with several variants for the same word, and even spell it out longhand once in while. This helps defeat those lazy bums who use text search to understand only some aspect of your program. Consider variant spellings as a variant on the ploy, e.g. mixing International colour, with American color and dude-speak kulerz. If you spell out names in full, there is only one possible way to spell each name. These are too easy for the maintenance programmer to remember. Because there are so many different ways to abbreviate a word, with abbreviations, you can have several different variables that all have the same apparent purpose. As an added bonus, the maintenance programmer might not even notice they are separate variables.

    Misleading names​

    Make sure that every method does a little bit more (or less) than its name suggests. As a simple example, a method named isValid(x) should as a side effect convert x to binary and store the result in a database.

    m_​

    a naming convention from the world of C++ is the use of "m_" in front of members. This is supposed to help you tell them apart from methods, so long as you forget that "method" also starts with the letter "m".

    o_apple obj_apple​

    Use an "o" or "obj" prefix for each instance of the class to show that you're thinking of the big, polymorphic picture.

    Hungarian Notation​

    Hungarian Notation is the tactical nuclear weapon of source code obfuscation techniques; use it! Due to the sheer volume of source code contaminated by this idiom nothing can kill a maintenance engineer faster than a well planned Hungarian Notation attack. The following tips will help you corrupt the original intent of Hungarian Notation:
    • Insist on using "c" for const in C++ and other languages that directly enforce the const-ness of a variable.
      Seek out and use Hungarian warts that have meaning in languages other than your current language. For example insist on the PowerBuilder "l_" and "a_ " {local and argument} scoping prefixes and always use the VB-esque style of having a Hungarian wart for every control type when coding to C++. Try to stay ignorant of the fact that megs of plainly visible MFC source code does not use Hungarian warts for control types.
      Always violate the Hungarian principle that the most commonly used variables should carry the least extra information around with them. Achieve this end through the techniques outlined above and by insisting that each class type have a custom wart prefix. Never allow anyone to remind you that no wart tells you that something is a class. The importance of this rule cannot be overstated if you fail to adhere to its principles the source code may become flooded with shorter variable names that have a higher vowel/consonant ratio. In the worst case scenario this can lead to a full collapse of obfuscation and the spontaneous reappearance of English Notation in code!
      Flagrantly violate the Hungarian-esque concept that function parameters and other high visibility symbols must be given meaningful names, but that Hungarian type warts all by themselves make excellent temporary variable names.
      Insist on carrying outright orthogonal information in your Hungarian warts. Consider this real world example "a_crszkvc30LastNameCol". It took a team of maintenance engineers nearly 3 days to figure out that this whopper variable name described a const, reference, function argument that was holding information from a database column of type Varchar[30] named "LastName" which was part of the table's primary key. When properly combined with the principle that "all variables should be public" this technique has the power to render thousands of lines of source code obsolete instantly!
      Use to your advantage the principle that the human brain can only hold 7 pieces of information concurrently. For example code written to the above standard has the following properties:
      • a single assignment statement carries 14 pieces of type and name information.
      • a single function call that passes three parameters and assigns a result carries 29 pieces of type and name information.
      • Seek to improve this excellent, but far too concise, standard. Impress management and coworkers by recommending a 5 letter day of the week prefix to help isolate code written on 'Monam' and 'FriPM'.
      • It is easy to overwhelm the short term memory with even a moderately complex nesting structure, especially when the maintenance programmer can't see the start and end of each block on screen simultaneously.

  5. Hungarian Notation Revisited​

    One followon trick in the Hungarian notation is "change the type of a variable but leave the variable name unchanged". This is almost invariably done in windows apps with the migration from Win16 :- WndProc(HWND hW, WORD wMsg, WORD wParam, LONG lParam) to Win32 WndProc(HWND hW, UINT wMsg, WPARAM wParam, LPARAM lParam) where the w values hint that they are words, but they really refer to longs. The real value of this approach comes clear with the Win64 migration, when the parameters will be 64 bits wide, but the old "w" and "l" prefixes will remain forever.

    Reduce, Reuse, Recycle​

    If you have to define a structure to hold data for callbacks, always call the structure PRIVDATA. Every module can define it's own PRIVDATA. In VC++, this has the advantage of confusing the debugger so that if you have a PRIVDATA variable and try to expand it in the watch window, it doesn't know which PRIVDATA you mean, so it just picks one.

    Obscure film references​

    Use constant names like LancelotsFavouriteColour instead of blue and assign it hex value of $0204FB. The color looks identical to pure blue on the screen, and a maintenance programmer would have to work out 0204FB (or use some graphic tool) to know what it looks like. Only someone intimately familiar with Monty Python and the Holy Grail would know that Lancelot's favorite color was blue. If a maintenance programmer can't quote entire Monty Python movies from memory, he or she has no business being a programmer.

Camouflage​

The longer it takes for a bug to surface, the harder it is to find.
- Roedy Green
Click to expand...
Much of the skill in writing unmaintainable code is the art of camouflage, hiding things, or making things appear to be what they are not. Many depend on the fact the compiler is more capable at making fine distinctions than either the human eye or the text editor. Here are some of the best camouflaging techniques.

  1. Code That Masquerades As Comments and Vice Versa​

    Include sections of code that is commented out but at first glance does not appear to be.
    • for(j=0; j<array_len; j+ =8)
      • {total += array[j+0 ];total += array[j+1 ];total += array[j+2 ]; /* Main body oftotal += array[j+3]; * loop is unrolledtotal += array[j+4]; * for greater speed.total += array[j+5]; */total += array[j+6 ];total += array[j+7 ];}
  2. Without the colour coding would you notice that three lines of code are commented out?

    namespaces​

    Struct/union and typedef struct/union are different name spaces in C (not in C++). Use the same name in both name spaces for structures or unions. Make them, if possible, nearly compatible.
    • typedef struct {char* pTr;size_t lEn;} snafu;
      struct snafu {
      unsigned cNt
      char* pTr;
      size_t lEn;
      } A;

  3. Hide Macro Definitions​

    Hide macro definitions in amongst rubbish comments. The programmer will get bored and not finish reading the comments thus never discover the macro. Ensure that the macro replaces what looks like a perfectly legitimate assignment with some bizarre operation, a simple example:
    • #define a=b a=0-b

  4. Look Busy​

    use define statements to make made up functions that simply comment out their arguments, e.g.:
    • #define fastcopy(x,y,z) /*xyz*/...fastcopy(array1, array2, size); /* does nothing */

  5. Use Continuation to hide variables​

    Instead of using
    • #define local_var xy_z
  6. break up "xy_z" onto two lines:
    • #define local_var xy\_z // local_var OK
  7. That way a global search for xy_z will come up with nothing for that file. To the C preprocessor, the "\" at the end of the line means glue this line to the next one.

    Arbitrary Names That Masquerade as Keywords​

    When documenting, and you need an arbitrary name to represent a filename use "file ". Never use an obviously arbitrary name like "Charlie.dat" or "Frodo.txt". In general, in your examples, use arbitrary names that sound as much like reserved keywords as possible. For example, good names for parameters or variables would be"bank", "blank", "class", "const ", "constant", "input", "key", "keyword", "kind", "output", "parameter" "parm", "system", "type", "value", "var" and "variable ". If you use actual reserved words for your arbitrary names, which would be rejected by your command processor or compiler, so much the better. If you do this well, the users will be hopelessly confused between reserved keywords and arbitrary names in your example, but you can look innocent, claiming you did it to help them associate the appropriate purpose with each variable.

    Code Names Must Not Match Screen Names​

    Choose your variable names to have absolutely no relation to the labels used when such variables are displayed on the screen. E.g. on the screen label the field "Postal Code" but in the code call the associated variable "zip".

    Don't Change Names​

    Instead of globally renaming to bring two sections of code into sync, use multiple TYPEDEFs of the same symbol.

    How to Hide Forbidden Globals​

    Since global variables are "evil", define a structure to hold all the things you'd put in globals. Call it something clever like EverythingYoullEverNeed. Make all functions take a pointer to this structure (call it handle to confuse things more). This gives the impression that you're not using global variables, you're accessing everything through a "handle". Then declare one statically so that all the code is using the same copy anyway.

    Hide Instances With Synonyms​

    Maintenance programmers, in order to see if they'll be any cascading effects to a change they make, do a global search for the variables named. This can be defeated by this simple expedient of having synonyms, such as
    • #define xxx global_var // in file std.h#define xy_z xxx // in file ..\other\substd.h#define local_var xy_z // in file ..\codestd\inst.h
  8. These defs should be scattered through different include-files. They are especially effective if the include-files are located in different directories. The other technique is to reuse a name in every scope. The compiler can tell them apart, but a simple minded text searcher cannot. Unfortunately SCIDs in the coming decade will make this simple technique impossible. since the editor understands the scope rules just as well as the compiler.

    Long Similar Variable Names​

    Use very long variable names or class names that differ from each other by only one character, or only in upper/lower case. An ideal variable name pair is swimmerand swimner. Exploit the failure of most fonts to clearly discriminate between ilI1| or oO08 with identifier pairs like parselnt and parseInt or D0Calc and DOCalc. l is an exceptionally fine choice for a variable name since it will, to the casual glance, masquerade as the constant 1. In many fonts rn looks like an m. So how about a variable swirnrner. Create variable names that differ from each other only in case e.g. HashTable and Hashtable.

    Similar-Sounding Similar-Looking Variable Names​

    Although we have one variable named xy_z, there's certainly no reason not to have many other variables with similar names, such as xy_Z, xy__z, _xy_z, _xyz, XY_Z, xY_z, and Xy_z.
    Variables that resemble others except for capitalization and underlines have the advantage of confounding those who like remembering names by sound or letter-spelling, rather than by exact representations.

    Overload and Bewilder​

    In C++, overload library functions by using #define. That way it looks like you are using a familiar library function where in actuality you are using something totally different.

    Choosing The Best Overload Operator​

    In C++, overload +,-,*,/ to do things totally unrelated to addition, subtraction etc. After all, if the Stroustroup can use the shift operator to do I/O, why should you not be equally creative? If you overload +, make sure you do it in a way that i = i + 5; has a totally different meaning from i += 5; Here is an example of elevating overloading operator obfuscation to a high art. Overload the '!' operator for a class, but have the overload have nothing to do with inverting or negating. Make it return an integer. Then, in order to get a logical value for it, you must use '! !'. However, this inverts the logic, so [drum roll] you must use '! ! !'. Don't confuse the ! operator, which returns a boolean 0 or 1, with the ~ bitwise logical negation operator.

    Overload new​

    Overload the "new" operator - much more dangerous than overloading the +-/*. This can cause total havoc if overloaded to do something different from it's original function (but vital to the object's function so it's very difficult to change). This should ensure users trying to create a dynamic instance get really stumped. You can combine this with the case sensitivity trickalso have a member function, and variable called "New".

    #define​

    #define in C++ deserves an entire essay on its own to explore its rich possibilities for obfuscation. Use lower case #define variables so they masquerade as ordinary variables. Never use parameters to your preprocessor functions. Do everything with global #defines. One of the most imaginative uses of the preprocessor I have heard of was requiring five passes through CPP before the code was ready to compile. Through clever use of defines and ifdefs, a master of obfuscation can make header files declare different things depending on how many times they are included. This becomes especially interesting when one header is included in another header. Here is a particularly devious example:
    • #ifndef DONE#ifdef TWICE// put stuff here to declare 3rd time aroundvoid g(char* str);#define DONE#else // TWICE#ifdef ONCE// put stuff here to declare 2nd time aroundvoid g(void* str);#define TWICE#else // ONCE// put stuff here to declare 1st time aroundvoid g(std::string str);#define ONCE#endif // ONCE#endif // TWICE#endif // DONE
  9. This one gets fun when passing g() a char*, because a different version of g() will be called depending on how many times the header was included.

    Compiler Directives​

    Compiler directives were designed with the express purpose of making the same code behave completely differently. Turn the boolean short-circuiting directive on and off repeatedly and vigourously, as well as the long strings directive.

Documentation​

Any fool can tell the truth, but it requires a man of some sense to know how to lie well.
- Samuel Butler (1835 - 1902)
Click to expand...


Incorrect documentation is often worse than no documentation.
- Bertrand Meyer
Click to expand...
Since the computer ignores comments and documentation, you can lie outrageously and do everything in your power to befuddle the poor maintenance programmer.

  1. Lie in the comments​

    You don't have to actively lie, just fail to keep comments as up to date with the code.

    Document the obvious​

    Pepper the code with comments like /* add 1 to i */ however, never document wooly stuff like the overall purpose of the package or method.

    Document How Not Why​

    Document only the details of what a program does, not what it is attempting to accomplish. That way, if there is a bug, the fixer will have no clue what the code should be doing.

    Avoid Documenting the "Obvious"​

    If, for example, you were writing an airline reservation system, make sure there are at least 25 places in the code that need to be modified if you were to add another airline. Never document where they are. People who come after you have no business modifying your code without thoroughly understanding every line of it.

    On the Proper Use Of Documentation Templates​

    Consider function documentation prototypes used to allow automated documentation of the code. These prototypes should be copied from one function (or method or class) to another, but never fill in the fields. If for some reason you are forced to fill in the fields make sure that all parameters are named the same for all functions, and all cautions are the same but of course not related to the current function at all.

    On the Proper Use of Design Documents​

    When implementing a very complicated algorithm, use the classic software engineering principles of doing a sound design before beginning coding. Write an extremely detailed design document that describes each step in a very complicated algorithm. The more detailed this document is, the better.
    In fact, the design doc should break the algorithm down into a hierarchy of structured steps, described in a hierarchy of auto-numbered individual paragraphs in the document. Use headings at least 5 deep. Make sure that when you are done, you have broken the structure down so completely that there are over 500 such auto-numbered paragraphs. For example, one paragraph might be(this is a real example)
    1.2.4.6.3.13 - Display all impacts for activity where selected mitigations can apply (short pseudocode omitted).
    then... (and this is the kicker) when you write the code, for each of these paragraphs you write a corresponding global function named:
    • Act1_2_4_6_3_13()
  2. Do not document these functions. After all, that's what the design document is for!
    Since the design doc is auto-numbered, it will be extremely difficult to keep it up to date with changes in the code (because the function names, of course, are static, not auto-numbered.) This isn't a problem for you because you will not try to keep the document up to date. In fact, do everything you can to destroy all traces of the document.
    Those who come after you should only be able to find one or two contradictory, early drafts of the design document hidden on some dusty shelving in the back room near the dead 286 computers.

    Units of Measure​

    Never document the units of measure of any variable, input, output or parameter. e.g. feet, metres, cartons. This is not so important in bean counting, but it is very important in engineering work. As a corollary, never document the units of measure of any conversion constants, or how the values were derived. It is mild cheating, but very effective, to salt the code with some incorrect units of measure in the comments. If you are feeling particularly malicious, make up your ownunit of measure; name it after yourself or some obscure person and never define it. If somebody challenges you, tell them you did so that you could use integer rather than floating point arithmetic.

    Gotchas​

    Never document gotchas in the code. If you suspect there may be a bug in a class, keep it to yourself. If you have ideas about how the code should be reorganised or rewritten, for heaven's sake, do not write them down. Remember the words of Thumper in the movie Bambi "If you can't say anything nice, don't say anything at all". What if the programmer who wrote that code saw your comments? What if the owner of the company saw them? What if a customer did? You could get yourself fired. An anonymous comment that says "This needs to be fixed!" can do wonders, especially if it's not clear what the comment refers to. Keep it vague, and nobody will feel personally criticised.

    Documenting Variables​

    Neverput a comment on a variable declaration. Facts about how the variable is used, its bounds, its legal values, its implied/displayed number of decimal points, its units of measure, its display format, its data entry rules (e.g. total fill, must enter), when its value can be trusted etc. should be gleaned from the procedural code. If your boss forces you to write comments, lard method bodies with them, but never comment a variable declaration, not even a temporary!

    Disparage In the Comments​

    Discourage any attempt to use external maintenance contractors by peppering your code with insulting references to other leading software companies, especial anyone who might be contracted to do the work. e.g.:
    • /* The optimised inner loop.This stuff is too clever for the dullard at Software Services Inc., who wouldprobably use 50 times as memory & time using the dumb routines in <math.h>.*/class clever_SSInc
      • {.. .}
  3. If possible, put insulting stuff in syntactically significant parts of the code, as well as just the comments so that management will probably break the code if they try to sanitise it before sending it out for maintenance.

    COMMENT AS IF IT WERE CØBØL ON PUNCH CARDS​

    Always refuse to accept advances in the development environment arena, especially SCIDs. Disbelieve rumors that all function and variable declarations are never more than one click away and always assume that code developed in Visual Studio 6.0 will be maintained by someone using edlin or vi. Insist on Draconian commenting rules to bury the source code proper.

    Monty Python Comments​

    On a method called makeSnafucated insert only the JavaDoc /* make snafucated */. Never define what snafucated means anywhere. Only a fool does not already know, with complete certainty, what snafucated means. For classic examples of this technique, consult the Sun AWT JavaDOC.

Program Design​

The cardinal rule of writing unmaintainable code is to specify each fact in as many places as possible and in as many ways as possible.
- Roedy Green
Click to expand...


  1. The key to writing maintainable code is to specify each fact about the application in only one place. To change your mind, you need change it in only one place, and you are guaranteed the entire program will still work. Therefore, the key to writing unmaintainable code is to specify a fact over and over, in as many places as possible, in as many variant ways as possible. Happily, languages like Java go out of their way to make writing this sort of unmaintainable code easy. For example, it is almost impossible to change the type of a widely used variable because all the casts and conversion functions will no longer work, and the types of the associated temporary variables will no longer be appropriate. Further, if the variable is displayed on the screen, all the associated display and data entry code has to be tracked down and manually modified. The Algol family of languages which include C and Java treat storing data in an array, Hashtable, flat file and database with totallydifferent syntax. In languages like Abundance, and to some extent Smalltalk, the syntax is identical; just the declaration changes. Take advantage of Java's ineptitude. Put data you know will grow too large for RAM, for now into an array. That way the maintenance programmer will have a horrendous task converting from array to file access later. Similarly place tiny files in databases so the maintenance programmer can have the fun of converting them to array access when it comes time to performance tune.

    Java Casts​

    Java's casting scheme is a gift from the Gods. You can use it without guilt since the language requires it. Every time you retrieve an object from a Collection you must cast it back to its original type. Thus the type of the variable may be specified in dozens of places. If the type later changes, all the casts must be changed to match. The compiler may or may not detect if the hapless maintenance programmer fails to catch them all (or changes one too many). In a similar way, all matching casts to (short) need to be changed to (int) if the type of a variable changes from short to int. There is a movement afoot in invent a generic cast operator (cast) and a generic conversion operator (convert) that would require no maintenance when the type of variable changes. Make sure this heresy never makes it into the language specification. Vote no on RFE 114691 and on genericity which would eliminate the need for many casts.

    Exploit Java's Redundancy​

    Java insists you specify the type of every variable twice. Java programmers are so used to this redundancy they won't notice if you make the two types slightlydifferent, as in this example:
    • Bubblegum b = new Bubblegom();
  2. Unfortunately the popularity of the ++ operator makes it harder to get away with pseudo-redundant code like this:
    • swimmer = swimner + 1;

  3. Never Validate​

    Never check input data for any kind of correctness or discrepancies. It will demonstrate that you absolutely trust the company's equipment as well as that you are a perfect team player who trusts all project partners and system operators. Always return reasonable values even when data inputs are questionable or erroneous.

    Be polite, Never Assert​

    Avoid the assert() mechanism, because it could turn a three-day debug fest into a ten minute one.

    Avoid Encapsulation​

    In the interests of efficiency, avoid encapsulation. Callers of a method need all the external clues they can get to remind them how the method works inside.

    Clone & Modify​

    In the name of efficiency, use cut/paste/clone/modify. This works much faster than using many small reusable modules. This is especially useful in shops that measure your progress by the number of lines of code you've written.

    Use Static Arrays​

    If a module in a library needs an array to hold an image, just define a static array. Nobody will ever have an image bigger than 512 x 512, so a fixed-size array is OK. For best precision, make it an array of doubles. Bonus effect for hiding a 2 Meg static array which causes the program to exceed the memory of the client's machine and thrash like crazy even if they never use your routine.

    Dummy Interfaces​

    Write an empty interface called something like "WrittenByMe", and make all of your classes implement it. Then, write wrapper classes for any of Java's built-in classes that you use. The idea is to make sure that every single object in your program implements this interface. Finally, write all methods so that both their arguments and return types are WrittenByMe. This makes it nearly impossible to figure out what some methods do, and introduces all sorts of entertaining casting requirements. For a further extension, have each team member have his/her own personal interface (e.g., WrittenByJoe); any class worked on by a programmer gets to implement his/her interface. You can then arbitrary refer to objects by any one of a large number of meaningless interfaces!

    Giant Listeners​

    Never create separate Listeners for each Component. Always have one listener for every button in your project and simply use massive if...else statements to test for which button was pressed.

    Too Much Of A Good ThingTM​

    Go wild with encapsulation and oo. For example:
    • myPanel.add( getMyButton() );private JButton getMyButton()
      • {return myButton;}
  4. That one probably did not even seem funny. Don't worry. It will some day.

    Friendly Friend​

    Use as often as possible the friend-declaration in C++. Combine this with handing the pointer of the creating class to a created class. Now you don't need to fritter away your time in thinking about interfaces. Additionally you should use the keywords private and protectedto prove that your classes are well encapsulated.

    Use Three Dimensional Arrays​

    Lots of them. Move data between the arrays in convoluted ways, say, filling the columns in arrayB with the rows from arrayA. Doing it with an offset of 1, for no apparent reason, is a nice touch. Makes the maintenance programmer nervous.

    Mix and Match​

    Use both accessor methods and public variables. That way, you can change an object's variable without the overhead of calling the accessor, but still claim that the class is a "Java Bean". This has the additional advantage of frustrating the maintenence programmer who adds a logging function to try to figure out who is changing the value.

    Wrap, wrap, wrap​

    Whenever you have to use methods in code you did not write, insulate your code from that other dirty code by at least one layer of wrapper. After all, the other author might some time in the future recklessly rename every method. Then where would you be? You could of course, if he did such a thing, insulate your code from the changes by writing a wrapper or you could let VAJ handle the global rename. However, this is the perfect excuse to preemptively cut him off at the pass with a wrapper layer of indirection, beforehe does anything idiotic. One of Java's main faults is that there is no way to solve many simple problems without dummy wrapper methods that do nothing but call another method of the same name, or a closely related name. This means it is possible to write wrappers four-levels deep that do absolutely nothing, and almost no one will notice. To maximise the obscuration, at each level, rename the methods, selecting random synonyms from a thesaurus. This gives the illusion something of note is happening. Further, the renaming helps ensure the lack of consistent project terminology. To ensure no one attempts to prune your levels back to a reasonable number, invoke some of your code bypassing the wrappers at each of the levels.

    Wrap Wrap Wrap Some More​

    Make sure all API functions are wrapped at least 6-8 times, with function definitions in separate source files. Using #defines to make handy shortcuts to these functions also helps.

    No Secrets!​

    Declare every method and variable public. After all, somebody, sometime might want to use it. Once a method has been declared public, it can't very well be retracted, now can it? This makes it very difficult to later change the way anything works under the covers. It also has the delightful side effect of obscuring what a class is for. If the boss asks if you are out of your mind, tell him you are following the classic principles of transparent interfaces.

    The Kama Sutra​

    This technique has the added advantage of driving any users or documenters of the package to distraction as well as the maintenance programmers. Create a dozen overloaded variants of the same method that differ in only the most minute detail. I think it was Oscar Wilde who observed that positions 47 and 115 of the Kama Sutra were the same except in 115 the woman had her fingers crossed. Users of the package then have to carefully peruse the long list of methods to figure out just which variant to use. The technique also balloons the documentation and thus ensures it will more likely be out of date. If the boss asks why you are doing this, explain it is solely for the convenience of the users. Again for the full effect, clone any common logic and sit back and wait for it the copies to gradually get out of sync.

    Permute and Baffle​

    Reverse the parameters on a method called drawRectangle(height, width) to drawRectangle(width, height) without making any change whatsoever to the name of the method. Then a few releases later, reverse it back again. The maintenance programmers can't tell by quickly looking at any call if it has been adjusted yet. Generalisations are left as an exercise for the reader.

    Theme and Variations​

    Instead of using a parameter to a single method, create as many separate methods as you can. For example instead of setAlignment(int alignment) where alignment is an enumerated constant, for left, right, center, create three methods setLeftAlignment, setRightAlignment, and setCenterAlignment. Of course, for the full effect, you must clone the common logic to make it hard to keep in sync.

    Static Is Good​

    Make as many of your variables as possible static. If youdon't need more than one instance of the class in this program, no one else ever will either. Again, if other coders in the project complain, tell them about the execution speed improvement you're getting.

    Cargill's Quandry​

    Take advantage of Cargill's quandary (I think this was his) "any design problem can be solved by adding an additional level of indirection, except for too many levels of indirection." Decompose OO programs until it becomes nearly impossible to find a method which actually updates program state. Better yet, arrange all such occurrences to be activated as callbacks from by traversing pointer forests which are known to contain every function pointer used within the entire system. Arrange for the forest traversals to be activated as side-effects from releasing reference counted objects previously created via deep copies which aren't really all that deep.

    Packratting​

    Keep all of your unused and outdated methods and variables around in your code. After all - if you needed to use it once in 1976, who knows if you will want to use it again sometime? Sure the program's changed since then, but it might just as easily change back, you "don't want to have to reinvent the wheel" (supervisors love talk like that). If you have left the comments on those methods and variables untouched, and sufficiently cryptic, anyone maintaining the code will be too scared to touch them.

    And That's Final​

    Make all of your leaf classes final. After all, you'redone with the project - certainly no one else could possibly improve on your work by extending your classes. And it might even be a security flaw - after all, isn't java.lang.String final for just this reason? If other coders in your project complain, tell them about the execution speed improvement you're getting.

    Eschew The Interface​

    In Java, disdain the interface. If your supervisors complain, tell them that Java interfaces force you to "cut-and-paste" code between different classes that implement the same interface the same way, and they knowhow hard that would be to maintain. Instead, do as the Java AWT designers did - put lots of functionality in your classes that can only be used by classes that inherit from them, and use lots of "instanceof" checks in your methods. This way, if someone wants to reuse your code, they have to extend your classes. If they want to reuse your code from two different classes - tough luck, they can't extend both of them at once! If an interface is unavoidable, make an all-purpose one and name it something like "ImplementableIface." Another gem from academia is to append "Impl" to the names of classes that implement interfaces. This can be used to great advantage, e.g. with classes that implement Runnable.

    Avoid Layouts​

    Never use layouts. That way when the maintenance programmer adds one more field he will have to manually adjust the absolute co-ordinates of every other thing displayed on the screen. If your boss forces you to use a layout, use a single giant GridBagLayout, and hard code in absolute grid co-ordinates.

    Environment variables​

    If you have to write classes for some other programmer to use, put environment-checking code (getenv() in C++ / System.getProperty() in Java) in your classes' nameless static initializers, and pass all your arguments to the classes this way, rather than in the constructor methods. The advantage is that the initializer methods get called as soon as the class program binaries get loaded, even before any of the classes get instantiated, so they will usually get executed before the program main(). In other words, there will be no way for the rest of the program to modify these parameters before they get read into your classes - the users better have set up all their environment variables just the way you had them!

    Table Driven Logic​

    Eschew any form of table-driven logic. It starts out innocently enough, but soon leads to end users proofreading and then shudder, even modifying the tables for themselves.

    Modify Mom's Fields​

    In Java, all primitives passed as parameters are effectively read-only because they are passed by value. The callee can modify the parameters, but that has no effect on the caller's variables. In contrast all objects passed are read-write. The reference is passed by value, which means the object itself is effectively passed by reference. The callee can do whatever it wants to the fields in your object. Never document whether a method actually modifies the fields in each of the passed parameters. Name your methods to suggest they only look at the fields when they actually change them.

    The Magic Of Global Variables​

    Instead of using exceptions to handle error processing, have your error message routine set a global variable. Then make sure that every long-running loop in the system checks this global flag and terminates if an error occurs. Add another global variable to signal when a user presses the 'reset' button. Of course all the major loops in the system also have to check this second flag. Hide a few loops that don'tterminate on demand.

    Globals, We Can't Stress These Enough!​

    If God didn't want us to use global variables, he wouldn't have invented them. Rather than disappoint God, use and set as many global variables as possible. Each function should use and set at least two of them, even if there's no reason to do this. After all, any good maintenance programmer will soon figure out this is an exercise in detective work, and she'll be happy for the exercise that separates real maintenance programmers from the dabblers.

    Globals, One More Time, Boys​

    Global variables save you from having to specify arguments in functions. Take full advantage of this. Elect one or more of these global variables to specify what kinds of processes to do on the others. Maintenance programmers foolishly assume that C functions will not have side effects. Make sure they squirrel results and internal state information away in global variables.

    Side Effects​

    In C, functions are supposed to be idempotent, (without side effects). I hope that hint is sufficient.

    Backing Out​

    Within the body of a loop, assume that the loop action is successful and immediately update all pointer variables. If an exception is later detected on that loop action, back out the pointer advancements as side effects of a conditional expression following the loop body.

    Local Variables​

    Never use local variables. Whenever you feel the temptation to use one, make it into an instance or static variable instead to unselfishly share it with all the other methods of the class. This will save you work later when other methods need similar declarations. C++ programmers can go a step further by making all variables global.

    Reduce, Reuse, Recycle​

    If you have to define a structure to hold data for callbacks, always call the structure PRIVDATA. Every module can define it's own PRIVDATA. In VC++, this has the advantage of confusing the debugger so that if you have a PRIVDATA variable and try to expand it in the watch window, it doesn't know which PRIVDATA you mean, so it just picks one.

    Configuration Files​

    These usually have the form keyword=value. The values are loaded into Java variables at load time. The most obvious obfuscation technique is to use slightly different names for the keywords and the Java variables. Use configuration files even for constants that never change at run time. Parameter file variables require at least five times as much code to maintain as a simple variable would.

    Bloated classes​

    To ensure your classes are bounded in the most obtuse way possible, make sure you include peripheral, obscure methods and attributes in every class. For example, a class that defines astrophysical orbit geometry really should have a method that computes ocean tide schedules and attributes that comprise a Crane weather model. Not only does this over-define the class, it makes finding these methods in the general system code like looking for a guitar pick in a landfill.

    Subclass With Abandon​

    Object oriented programming is a godsend for writing unmaintainable code. If you have a class with 10 properties (member/method) in it, consider a base class with only one property and subclassing it 9 levels deep so that each descendant adds one property. By the time you get to the last descendant class, you'll have all 10 properties. If possible, put each class declaration in a separate file. This has the added effect of bloating your INCLUDE or USES statements, and forces the maintainer to open that many more files in his or her editor. Make sure you create at least one instance of each subclass.

​

Click to expand...
 
  • Winner
  • Informative
Reactions: DickFalcon, Verpa Teutonica Ingens, 419 and 4 others
Any recommended resources for people avoiding some of these bad practices when learning to program? Is there some signposted examples or case studies of what not to do for certain languages?

I'm attempting to learn C++ but I don't want to start off coding like a retard.
 
I don't know much about coding and I don't know any Current Year programming, but it's ridiculous how bloated programs are in Current Year compared to the early '80s when one could do a lot within just a few KB of memory. Or even the '90s and mere MB of memory there.
 
  • Like
  • Agree
Reactions: ducktales4gameboy, HahaYes and QE65
QE65 said:
I'm attempting to learn C++ but I don't want to start off coding like a retard.
Click to expand...
googling "c++ beginner mistakes" returned this


from google AI:
Here are some common mistakes in C++ programming:
  • Initialization: Forgetting to initialize class members


  • Name-hiding: An identifier in the innermost scope hides any matching name in an outer scope


  • Type conversions: Balancing and promotion rules can result in unexpected values


  • Using “new” and “delete” incorrectly: It can be difficult to free all dynamically allocated memory, and even if you can, it may not be safe from exceptions


  • Extra semicolons: Semicolons should not be placed after if statements, loops, or function definitions


  • Division errors: A common type of runtime error that can be difficult to detect


  • Linker errors: Occur when the execution cannot be generated, for example, typing in Main() instead of main()


  • Undeclared variables: C++ is a strongly typed language, so you must declare what type of data a variable will hold before using it

Other mistakes include:
  • Overusing magic numbers
  • Attempting to add or remove elements from a container while looping over i
Click to expand...

Scout Trooper said:
Until I saw this:
Click to expand...
if you saw my real-time reaction, you'd laugh at the face I made
 
  • Informative
Reactions: grimacefetishist and QE65
QE65 said:
Any recommended resources for people avoiding some of these bad practices when learning to program? Is there some signposted examples or case studies of what not to do for certain languages?

I'm attempting to learn C++ but I don't want to start off coding like a retard.
Click to expand...
When you're first learning to program, the important part is just getting the syntax right and the code to compile.

I have mixed feelings about people learning programming with C++ as their first language.

Don't get me wrong, it's an awesome, powerful language. But there are initial languages with less mental overhead (like C#) where you can get comfortable with a lot of the concepts and then take on the additional responsibilities that C++ trusts you with.

That said, remember this man when you get the basics down.
 
  • Informative
  • Like
Reactions: 419, grimacefetishist, Pedophobe and 2 others
Lieutenant Rasczak said:
Just a reminder, if you think those case statements as the beginning of video 2 are bad. I'll remind people that the entirety of Undertale's dialogue is written in a single case statement that goes for 3,000 lines.
Click to expand...
As someone who knows very little about modern programming, what issues does this cause?
 
Thé au lait said:
As someone who knows very little about modern programming, what issues does this cause?
Click to expand...
it's an extremely messy and unorganized way to sort dialogue lines. i wouldn't say it causes specific issues, it can cause the game to load poorly.

if I'm trying to find a specific line/code, i'd have to sort out 3,000 lines of text rather than say "oh I put it in the Dialogue.class section"
 
  • Agree
  • Like
  • Informative
Reactions: Verpa Teutonica Ingens, 419, grimacefetishist and 2 others
Thé au lait said:
As someone who knows very little about modern programming, what issues does this cause?
Click to expand...

Osama Bin Laden said:
it's an extremely messy and unorganized way to sort dialogue lines. i wouldn't say it causes specific issues, it can cause the game to load poorly.

if I'm trying to find a specific line/code, i'd have to sort out 3,000 lines of text rather than say "oh I put it in the Dialogue.class section"
Click to expand...
I don't know anything about this game specifically, but an enormous case like this isn't inherently bad nor does it necessarily cause performance problems.

The CPython interpreter has an enormous machine-generated (by a Python script, ironically) case statement responsible for a large portion of the run-time code interpreter's execution.

Super-stripped down, concrete code is often generated from more abstract sources and intentionally structured to get a certain output from the compiler.
 
  • Informative
  • Like
Reactions: Archduke of Sneedinheim, 419, Belisarius Cawl and 3 others
You must log in or register to reply here.
Back