"Yoda Conditions"— using if(constant == variable) instead of if(variable == constant), like if(4 == foo). Because it's like saying "if blue is the sky" or "if tall is the man".

Thanks to dreamlax ^[1] for helping me find that.

Trillian ^[2] suggested the following during an IM conversation:

Here's a dirty but portable trick you can use to force a compile-time error:

struct not_a_bool {};
template<typename T>
not_a_bool ERROR_CONDITIONAL_EXPRESSION_IS_NOT_BOOL(T value) { return not_a_bool(); }
bool ERROR_CONDITIONAL_EXPRESSION_IS_NOT_BOOL(bool value) { return value; }
#define if(x) if(::ERROR_CONDITIONAL_EXPRESSION_IS_NOT_BOOL(x))
#define while(x) while(::ERROR_CONDITIONAL_EXPRESSION_IS_NOT_BOOL(x))

This will cause Visual Studio to emit the following error:

error C2451: conditional expression of type 'not_a_bool' is illegal

While GCC will emit:

error: could not convert ‘ERROR_CONDITIONAL_EXPRESSION_IS_NOT_BOOL [with T = int]((lhs <unknown operator> 1))’ to ‘bool’

It doesn't work with for loops, but equality testing in for loops is less frequent.

Pokémon Exception Handling. For when you just Gotta Catch 'Em All.

You know the style of brackets where the opening brace goes on the end of the current line, e.g. this?

if (a == b) {
    printf("hello");
}

We used to refer to this style of brackets as "Egyptian brackets". Why? Compare the position of the brackets with the hands in this picture:

(This style of brackets is used in Kernighan and Ritchie's book The C Programming Language, so it's known by many as K&R style.)

Different kinds of bug reports:

Smug Report - a bug submitted by a user who thinks he knows a lot more about the system's design than he really does. Filled with irrelevant technical details and one or more suggestions (always wrong) about what he thinks is causing the problem and how we should fix it.

Drug Report - a report so utterly incomprehensible that whoever submitted it must have been smoking crack. The lesser version is a chug report, where the submitter is thought to have had one too many.

Shrug Report - a bug report with no error message or repro steps and only a vague description of the problem. Usually contains the phrase "doesn't work."

A Duck

A feature added for no other reason than to draw management attention and be removed, thus avoiding unnecessary changes in other aspects of the product.

I don't know if I actually invented this term or not, but I am certainly not the originator of the story that spawned it.

This started as a piece of Interplay corporate lore. It was well known that producers (a game industry position, roughly equivalent to PMs) had to make a change to everything that was done. The assumption was that subconsciously they felt that if they didn't, they weren't adding value.

The artist working on the queen animations for Battle Chess was aware of this tendency, and came up with an innovative solution. He did the animations for the queen the way that he felt would be best, with one addition: he gave the queen a pet duck. He animated this duck through all of the queen's animations, had it flapping around the corners. He also took great care to make sure that it never overlapped the "actual" animation.

Eventually, it came time for the producer to review the animation set for the queen. The producer sat down and watched all of the animations. When they were done, he turned to the artist and said, "that looks great. Just one thing - get rid of the duck."

I wish I had invented it myself, but credit goes to Jason Gorman:

Refuctoring ^[1] - the process of taking a well-designed piece of code and, through a series of small, reversible changes, making it completely unmaintainable by anyone except yourself.

Stringly Typed

A riff on strongly typed. Used to describe an implementation that needlessly relies on strings when programmer & refactor friendly options are available.

For example:

• Method parameters that take strings when other more appropriate types should be used
• On the occasion that a string is required in a method call (e.g. network service), the string is then passed and used throughout the rest of the call graph without first converting it to a more suitable internal representation (e.g. parse it and create an enum, then you have strong typing throughout the rest of your codebase).
• Message passing without using typed messages etc.

Excessively stringly typed code is usually a pain to understand and detonates at runtime with errors that the compiler would normally find.

Example:

Person 1: "Did you check out Jimmy's API?"

Person 2: "Yeah, what a mess. It's so hard to understand and it always fails at runtime in an obscure fashion because it's Stringly Typed from top to bottom."

Heisenbug ^[1] - can't take credit for this, but it is awesome!

A computer bug that disappears or alters its characteristics when an attempt is made to study it.

Doctype Decoration - When web designers add a doctype declaration but don't bother to write valid markup.

"Jimmy"

A generalized name for the clueless/new developer.

We found as we were developing a framework component that required minimal knowledge of how it worked for the other developers.

We would always phrase our questions as:

"What if Jimmy forgets to update the attribute?"

This led to the term: "Jimmy-proof" when referring to well designed framework code.

A Higgs-Bugson is a hypothetical bug predicted to exist based on a small number of possibly related event log entries and vague anecdotal reports from users, but it is difficult (if not impossible) to reproduce on a dev machine because you don't really know if it's there, and if it is there what is causing it.

(see Higgs-Boson ^[1])

nopping
I'm writing a scifi novel ^[1] from the POV of an AI, and their internal language has a lot of programming jargon in it. One of the more generalizable terms is "nopping", which comes from assembler NOP for no-operation. It's similar to 'nap', but doesn't imply sleep, just zoning out.

Example: Stanislav sat watching the screensaver and nopped for a while.

Unicorny - An adjective to describe a feature that's so early in the planning stages that it might as well be imaginary. We cribbed this one from Yehuda Katz, who used it in his closing keynote at last year's Windy City Rails ^[1] to describe some of Rails' upcoming features.

Barack Obama - An account in Redmine that we assign our most aspirational tickets to, i.e. the stuff we'd really like to do with a project but will probably never get approval for.

Baklava code

Code with too many layers ^[1].

Hindenbug

A catastrophic data destroying bug - "Oh the humanity!"

Counterbug

A bug you present when presented with a bug caused by the person presenting the bug

Bloombug

A bug that accidentally generates money (just did this one)

Workaroundability (by co-worker)
That's the feeling when already hacked approach still can or can't be hacked further.

Fear Driven Development
When project management adds more pressure (fires someone or something).

Hydra Code

Code that cannot be fixed. One fix causes two new bugs.
It should be rewritten.

Common Law Feature: A bug in the application that has existed so long that it is now part of the expected functionality, and user support is required to actually fix it.

I've started Loch Ness Monster bug for anything not reproducible / only sighted by one person. I'm hearing a lot of people in the office say it now..

Ninja comments: Also known as invisible comments, secret comments, or no comments.

Smurf Naming Convention

When almost every class has the same prefix. IE, when a user clicks on the button, a SmurfAccountView passes a SmurfAccountDTO to the SmurfAccountController. The SmurfID is used to fetch a SmurfOrderHistory which is passed to the SmurfHistoryMatch before forwarding to either SmurfHistoryReviewView or SmurfHistoryReportingView. If a SmurfErrorEvent occurs it is logged by SmurfErrorLogger to ${app}/smurf/log/smurf/smurflog.log

Protoduction - A prototype that ends up in production.

Heard this from a tech at the Fermi lab. He said he didn't coin the term but had heard it used a number of times at Fermi.

Rubberducking

Sometimes, you just have to talk a problem out. I used to go to my boss and talk about something and he'd listen and then I'd just answer my own question and walk out without him saying a thing.

I read about someone that put a rubber duck on their monitor so they could talk to it, so rubberducking is talking your way through a problem.

Databasically

"Hey, I'll put all of our customers into a Word document and then we can X." "No, we should do that database-ically so that we can keep that list up to date."

Yes, I named my company ^[1] that.

At one company where I worked, we had a lot of food-related jargon, in-jokes, and backcronyms:

Programmer fuel - Mountain Dew, coffee, Mate, anything which gets you well-caffeinated.

I can't get started on Monday mornings until I've had my programmer fuel. (Synonyms: nerd fuel, geek chow.)

Hot potato / Hot potatoes - Http and Https repsectively. Same number of syllables, but more fun to say.

Submit all customer information through the authentication service at hot potatoes company-name.com/auth

[Noun] cake - depends on context, usually indicating an action related to the placeholder noun. Noun should be a single syllable for easy communication.

Marty's noob cake broke the build. (See also: noobery, noobage, noobular, works on my machine)

Juliet's serving ample amounts of bitch cake because everyone double and triple books her for meetings without checking her availability.

Banana banana banana - placeholder text indicating that documentation is in progress or yet to be completed. Mostly used because FxCop complains when a public function lacks documentation.

/// <summary>
/// banana banana banana
/// </summary>
public CustomerValidationResponse Validate(CustomerValidationRequest request, bool useStrictValidation, bool throwIfSessionExpired)

Chunky salsa - based on the chunky salsa rule ^[1], a single critical error or bug that renders an entire system unusable, especially in a production environment.

The whole system turned chunky salsa after Bob's change to the login screen locked everyone out of their accounts.

Bicrement - Adding 2 to a variable

Reality 101 failure:

The program (or more likely feature of a program) does exactly what was asked for but when it's deployed it turns out that the problem was misunderstood and it's basically useless.

Mad Girlfriend Bug

For when you see something strange happening, but it will just tell you everything is fine.

Megamoth

Stands for MEGA MOnolithic meTHod.
Often contained inside a God Object ^[1], and usually stretches over two screens in height.

Megamoths of greater size than 2k LOC have been sighted. Beware of the MEGAMOTH!

Hooker Code - Code that is problematic and causes application instability (application "goes down" often).

Example:

Did the site go down again? Yeah, Jim must still have some hooker code in there.

Squizzle-giz: A horribly mispronounced version of the file extension .sql.gz

We made it up while setting up a server and looking for something easier/more fun to say than "dot ess que ell dot gee zee file" or "gzipped sequel file."

Jenga Code

When the whole thing collapses when you alter a block of code.

Baseball Exception Handling This is a pattern wherein when application logic is implemented via a deeply nested set of try/catch/throw blocks. Specific application logic is implemented in catch blocks and correct program behavior depends on exceptions being thrown at the right time. In the canonical example, the throwing and catching happens within a single, very long, method.

Example:

try
{
    // 10-1000 lines of code
    if (someCondition)
         throw new SomeConditionException();

    // 10-1000 lines of code
    if (someOtherCondition)
         throw new SomeOtherConditionException();

}
catch (SomeConditionException)
{
    // 10-1000 lines of code, preferably with nested baseball exception handling
}
catch (SomeOtherConditionException)
{
    // 10-1000 lines of code, preferably with nested baseball exception handling
}

Advanced Baseball Exception Handling The same as Baseball Exception Handling but with the addition of added state held in the Exception class so that the catch block can logically branch based on where the throw was. This is useful when a single Exception type is used but catch logic needs to know where in the process it was thrown from.

try
{
    // 10-1000 lines of code
    if (someCondition)
         throw new SomeConditionException("early in the process");

    // 10-1000 lines of code
    if (someCondition)
         throw new SomeConditionException("late in the process");

}
catch (SomeConditionException e)
{
    // execute shared logic

    if (e.State == "early in the process")
         // execute early in the process logic

    if (e.State == "late in the process")
         // execute late in the process logic
}

apt-got and wgot for files installed using apt-get or downloaded using wget.

"I apt-got 100MB of updates this morning"

"Once this loop has wgot that file, it takes the md5 hash"

Blogware

Code that looks great in a blog post, but doesn't work well in a full application.

MAXIT - Talk to Max about the problem. I had a real life manager named Max, when we had code we could not figure out, we would talk to Max. He would just ask us to tell him about it, describe what it is supposed to do and then walk through what it IS doing - most of the time (all?) we would figure it out from that. Max actually died a few years ago. I still talk to Max.

Hocus Focus problem - unexpected behavior in Windows caused by changes in focus, or incorrect setting of focus.

SOGO When you look for answers on Google and your Stack Overflow questions come up as first place within 5 minutes.

Try, Catch, Forget - An empty catch block, no tracing, not even a comment. No attempt to resolve the error and of course the catch block is not at all specific on the exception type.

Mortgage Code

Code purposely so terrible that only you can maintain it, forcing your employer to keep you; thus providing job security ( so you can pay your mortgage).

Someone did a web application in Mortgage Code : every page was returned as HTML built entirely by SQL queries.

can-has

alias of apt-get

sudo can-has php5

XMHell : When your project contains only 92 classes but has 243 Spring xml configuration files and every object relationship is mapped through a DI framework.

Props to Daniel for this one.

Hope Driven Development - a software development technique in which an application is developed in a long unplanned development cycle, with minimal "Steve Irwin-style testing", all with the hope that everything will work as intended when released.

Steve Irwin-Style Testing - testing that consists of poking around in an application hoping that you will not have a "Crikey!" moment.

Floater: The case in the bug tracking system that seems to always be sitting near the top of the queue but never gets claimed. It just floats there while developers work around it.

Natural Selection - The act of replacing someone else's code with your own.

svn vomit
I usually alias the 'svn commit' command to simply 'vomit'... Reminds me of teammates who messed up repositories by committing files anywhere...

Scar Tissue - Any code that is commented out but still included in the current and/or checked-in version. This definition only gives a name, it does not pass judgment on the value of the code in question, i.e. whether its acceptable to check in scar tissue.

public class JDBCDBServlet extends HttpServlet {
    private String      className = "JDBCDBServlet: " ;
    private JDBConnectionPool   connPool ;
    //static JDBCConnectionManager connMgr;

   public void init(ServletConfig config) {

    int maxConns = Integer.parseInt(config.getInitParameter("MAX_CONNECTIONS")) ;
    connPool = new JDBConnectionPool(maxConns) ;
    //connMgr = new JDBCConnectionManager(driverListStr, maxConns) ;
    JDBCConnectionManager.initialize();
    }

It was one of the first topics I blogged about. See " The Scars We Bear ^[1]". I remember coming up with this term in college back in the late 80's/early 90's when version control wasn't discussed or really available.

My wife (also a programmer) had a good one. When programs send email or post log/console messages at the drop of a hat, they are 'twittering'. I'd add it as a separate answer except the question is locked.

Object Oriented Pasta - Used to describe spaghetti code wrapped in classes to make it look like an object. Not mine, but a commonly used term at my office.

Festive - A bug causes a window or the entire screen to produce a visually stunning result.

Ghetto code - a particularly inelegant and obviously suboptimal section of code that still meets the requirements.

The future is not implemented yet

Derived from a misspelled comment that originally meant "the feature is not implemented yet". Now used in various other scenarios, whenever a feature is not yet implemented.

Click it Harder - Developer response to QA testing the developer's software when the button doesn't function, or doesn't function completely.

Vaneshia: PJack. The save button doesn't save.

PJack: What? No way. Works on my machine... show me.

<Vaneshia.click>fail</Vaneshia.click>

Vaneshia: See.

PJack: Ohh, you've got to click it harder.

n-gleton - a class that only allows a fixed number of instances of itself. I've recently seen another (perhaps official) term for this; something like multiton or polyton.

NAME_OF_MY_FORMER_BOSS-switch
Generally in hardware, a very impressive looking adjustable dial that isn't connected to anything but lets them feel that they are involved by giving them something to fiddle with - without any risk to the carefully calibrated instrument.

In software it would be a page of advanced configuration settings that don't do anything except make the software more 'enterprisey'

Automanually

The term is used to refer to a batch job or application that should be scheduled or triggered automatically, but due to unspecified reasons (typically, bugs), requires manual intervention every time. (Note: This is not the same as automagically.)

"The data is stale because the synchronization job is scheduled to happen automanually and I've been on vacation."

IRQed = annoyed by interruptions

Example: The phone IRQed me so much today I couldn't get anything done.

The distinction between "IRQed" and "irked" is subtle and only obvious in written form or by context.

Related: IRQload

Example: "The poor slob who runs the switchboard has an IRQload you wouldn't believe."

Code Slush

for the date after which no changes will be accepted, except, of course, all the changes that management will ask for at the last minute. Like Code Freeze but accepting of the fact that some changes will still get in.

Memo to developers, Code Slush is March 31 so get your fixes in.

Scare the bug when you call another developer to help you spot some trivial and obvious bug you spent way longer than reasonable trying to find.

Often mere presence of the other person allows you to spot the bug, i.e. as you begin to explain the piece of code (without the other person ever getting to say anything of value) - "the code got scared of two people at once working on it and revealed itself without a fight."

A request of Could you come over and scare the bug for me, please? is the traditional interrupt request of this kind of assistance.

Carpet Logging

The act of completely riddling a piece of source code with debug log calls, until pretty much every single line of the code is followed by a call of the form log.debug("After my_killer_function_call, var1=....");

This is done in lieu of using a debugger to step through the code, typically by l33t certification-prodigies who think that only noobs use debuggers.

RIT's Society of Software Engineers has a name for this diagram I created a while back:

The Rob Busack Waterfall Model.

Named after the Rob Busack Memorial Rapid Development Weekend, a yearly event where in one single, caffeine-fueled weekend, an unnecessarily large number of developers congregate for the purpose of failing to complete an overly ambitious programming challenge.

Bug Bait

Programming practices that encourage, rather than discourage, program flaws.

Barnacle method A function implemented as a method of some class for lack of a better place.

If you don't have a "generic toolbox" class and don't tolerate functions outside a class or a namespace, you sometimes attach simple, generic, stateless functions like "dec2hex", "crc16file" or "JSONtimestamp" to a specialized class because that class often uses them or they somewhat resemble its functionality, but you often call them from other classes (which don't need the "host" class for any other purpose).

Bob the cardboard cut-out programmer.

This is a real life-sized cardboard cut-out figure that can be placed in the corner of the office, whenever one of his non-cardboard peers has a problem they can walk up to him and discuss the problem and half of the time this discussion will help solve the problem.

The conversation usually goes something like this:

I can't figure out why my class won't ... Oh, OK don't worry I've just figured it out - thanks!

Reticulating Splines - Used to describe development that still needs to be done to non-programmers who probably don't care about the specifics of what still has to be done (beyond the time estimate) or know what you are talking about. Lifted from the SimCity 2000 game load screen, which displayed nonsense phrases with a progress bar while the game loaded.

Fragile - To use Agile methodologies and have people totally screwing it up.

Project Manager: Let's use Agile methodologies!

Developer: Ok sure, I will spike. I'll do the minimum of what takes to achieve this piece of business functionality

Project Manager: Excellent work developer!

Developer: We can refactor later when we build later parts of the system. It's not important to that now.

Project Manager: Good. We shouldn't do more than we need right now.

And later on in the project...

Developer: We need to do that refactoring because the code is unmaintainable

... silence follows ...

Project Manager: Deploy lame excuse machine, choose one or more

1. Say "We can do it a little later"
2. Say "But it works why change it?"
3. Say "This is way more important, do it later"
4. Say "We don't have time to do this 'refactoring'"
5. Say "I promise we will do it later"

Resulting in...

Developer suffers development with increasingly incoherent & spaghettified code AND no one cares about the pain he/she suffers.

Then ..

Outsider / CTO: Man, this agile stuff stinks! I'll never use that! Waterfall RULES!

Perl -grade obfuscation

The highest level of obfuscation possible. Better than passing code through a 1-way hash function.

"No one will reverse engineer our code - it's written in Perl."

Most of mine can't be shared in polite company, but I started using the term

Swiss army software

about 15 years ago to describe projects suffering from feature creep.

NP Tricky. Describes an algorithm whose complexity is too hard for a mere mortal to figure out.

NP Hilarious. Describes an algorithm whose complexity is "a joke", literally (as in BogoSort ^[1]) or metaphorically.

Affair

If you invoke a private method in C++ from a class with friend status.

Pro-gasm

When you love your own code so much you have a programming ... well, ... you know what.

Search And Destroy -- A multi-file search/replace that goes horribly awry.

Hi-driven development - When you debug your program by writing alert('Hi') statements in a trial-and-error fashion

Pixies are the opposite of gremlins. While gremlins cause unexplained bugs, pixies cause unexplained fixes. They usually appear when fixing a totally unrelated bug or implementing some other function and, voila: the bug is fixed!

cut and waste code

When someone uses cut and paste code they found online (usually from a blog) in a production product, the result is usually a lot of wasted time trying to track down an obscure bug from a line or variable that undoubtedly made sense in the original context but not in our code.

Typical conversation:
"What did you do today?"
"I spent all day debugging cut and waste code."

Bang It

Not really sure if I'm the first to use this, but I got into the habit of describing the process of negating a logical expression as "banging" it. This refers to the "!" symbol, used in some languages to denote logical negation, and the word "bang", a synonym for the exclamation mark symbol.

e.g.

Dev1: What's wrong with my expression? It's doing the exact opposite of what I want.

Dev2: You need to bang it.

Extraface An interface that is added for no reason or is never used. In Java, Serializable is often an Extraface.

Intraface or Inyerface An interface that is added to every class in a system, usually as a way of adding constants. Inyerface is used when the use of caps to define constants leads to a source file that looks like it's yelling at you.

Abstruse Base Class An Abstract base class with one or more code smells.

Combination Lock API An object with an overly complex interface which fails silently when you deviate slightly from the API.

Obfuscated Oriented Programming When code says one thing but the comment says something else. Usually points to cut-copy-paste.

//get account from audit
Broker b = audit.getOriginBroker(order.getBrokerID());

//reset form
Form f = new Form(id,map);

Bottle Rocket When an application launches, displays something then leaves a trail of error messages before crashing. As in, "I added the new client jar in dev and the app goes bottle rocket when hitting the CRM system"

Copy-Pasta

It's the main ingredient for making spaghetti code. A favorite of a co-worker.

Use:

In a code review: So what I did was copy-pasta the loop from Foo into Bar, so they can both Fizz.

To which you should reply: What if later I change Fizz to Buzz and now Foo Fizzes and Bar Buzzes?

Disaster Driven Development - When Your PMs and salesmen promised that You will build "space shuttle" in one month.

Boss Build

At a previous company, we generally built two versions of any product that ran on the Boss's computer. One "real" version which was shipped to customers, and one "boss build" which reflected the endless list of font, color, size, and placement tweaks that came every several days from the corner office.

Classtrophobia

When someone chooses not to use the obvious object oriented approach when it is available.

Ravioli Code – The object-oriented equivalent of spaghetti code, where it's all in nice small self-contained packets, yet is still impossible to grapple with and covered in sauce (i.e., where finding out how anything actually happens requires understanding virtually every method of every class in the whole damn program).

Boolean Zen - using boolean expressions directly without testing for equality to true or false. (not coined by me)

"Yuck, this code lacks boolean zen: "

if(var > 20 == true) {
    ...
}

if (var > 10 && var < 20) {
    return true;
} else {
    return false;
}

"Nice boolean zen:"

if(var > 20) {
    ...
}

return var > 10 && var < 20;

Useful for introductory programming teachers...

TDDD: Technical Debt-Driven Development

Encraption - Really insecure encryption, which gives management the illusion that the code is securing sensitive data, but in reality isn't.

For example, management has a requirement that user IDs and passwords (eg, for database access) must be encrypted within the server configuration files. However, the data files containing potentially sensitive info (eg, SSNs, driver license numbers, bank account numbers, etc.) are stored in unencrypted plaintext form on the server.

Obviously, if network security were ever compromised and the server was hacked into, the hackers wouldn't bother trying to decrypt the user-IDs and passwords, because they have instant access to the real data in the clear.

Blamestorming

• the inevitable round the table shitstorm activity that happens during the post mortem of a fubar project.

Build Potato

When your code check-in breaks the build, you receive a build potato. It stays with you until someone else's code check-in breaks the build.

P.S: This is not a term coined by me. It's a jargon we use at work.

Mosquito Bites - The annoyance of small software bugs that are frustrating but do not cause critical/catastrophic errors in the usage of the application. They are typically ignored until the agitation becomes painfully annoying.

Company Whore

a module or a piece of code, every programmer of the company had it's fingers on.

Eraser Stains - Code that has been written, then re-factored multiple times leaving swaths of vestigial code or design. Like erasing a sheet of paper so many times, the pencil marks are no longer the problem - the large greasy stain is.

Showdea

For an idea that you came up with in the shower!

integerize - the process of turning a floating point number into an integer

The Sheath - the isolating interface between your team's (good) code, and the brain-dead code contributed by the other guy(s). The sheath prevents horrible things (badly named constants, incorrect types, etc) in the other guy(s) code from infecting your code.

headlessCamels and ProudCamels for verbally differentiating between the two different types of camelCase (or CamelCase)

Darwin programming -- keep evolving the code randomly (or deterministically) until it does-the-right-thing. Very efficient for example when hesitating between + or - inside a formula.

It's not a bug, it's undercoded.

Google Code

5-10 lines of code you found after three hours of Googling that you don't want to touch for fear of it breaking due to the underlying API being illogical and needlessly complex to work with.

wibni - wouldn't it be nice if. A "nice to have" feature only more fun to say.

rebugging - The opposite of debugging. The act of adding a feature. Normal development adds features, adding features adds bugs hence rebugging

Troolian Logic

Using a Boolean to intentionally represent 3 values; True, False, null

private void someMethod(Boolean someBoolean)
{
  if (someBoolean == null)
    doThis();
  else if (someBoolean)
    doThat();
  else
    doOther();
}

JamesBond Interface: contract defined very well, documented... but there's no real life implementation for it..

Clicking Administrators (originally Administrateur Cliqueurs in French)

That's for all those system administrators and IT people that have always evolved in a Windows environment, growing from managing their own home computer to managing an enterprise network, and don't have a clue about the actual technical changes they make when clicking here or there.

They usually apply the management methodology named DTIW, Don't Touch, It Works! (originally TPCM, Touche Pas, Ça Marche !) (I would probably need a better translation in English here, it sounds really great in French …)

Over oriented programming - using OOP to do evil. five layers of inheritance where only one (or none) will suffice.

fuXOR, pronounced fuckzor

AND, OR, XAND, XOR.... fuXOR!

Used to describe broken logic statements, such as

if( x == 1 && x == 2 )...

Turducken

Term to describe insane nesting of data in various formats, usually stored inside a relational database. Hence creating an abomination resembling the stuffing of a chicken inside of a duck inside of a turkey.

Example:

A database text-column containing a list of pipe-delimited name/value pairs with the values being PHP objects as serialized strings.

SELECT options FROM filterfield WHERE id = 123;

yields

foo=bar|options=a:4:{i:0;a:2:{s:5:"title";s:13:"Kids + Family";s:7:"options";s:128:"Amusement Parks...

Another example is how several wordpress plugins store their configuration options as serialized PHP array in the "wp_options" table.

ship in a bottle - an API that is so over-simplified that it is painfully complex to use.

To see an example of this, take some well-written polymorphic code, remove all the derived classes, and put a state bag in the base class that holds all information that used to live in the derived classes. For extra points, store the state bag as an XML string.

For an extreme example of this in hardware, imagine a remote control with only one button that requires you to enter commands in Morse code.

notwork - n. a network in a non-working state

Can't claim original credit but it's stuck around with us for years.

Committing hairy query

An act of suicide caused by many nested sub-selects, unions and joins.

Actually I just use the term when I let other people on my dev team know the SQL is getting deep.

Barebacking

When you submit code, without proper testing, to get pushed with someone else's build.

Silk-Pursing

Using some "blessed" terminology, technology or API to do something generally considered a bad idea, but give it the appearance of respectability. Generally done when the developer in question does not understand why the underlying practice is considered poor, or lacks the knowledge of how to avoid it.

Example: "Most uses of the Singleton pattern are just silk-pursing a global."

Example: "I know we're supposed to throw our own exceptions, and not the underlying ones, so we'll just wrap everything in a MyProductException."

Ajah for Ajax when it is using HTML instead of XML.

Bucket Variable: a capacious variable, usually with a complex internal structure, that is used to hold everything. It makes argument lists much easier to write. It is passed around from function to function, sometimes by value even when it isn't modified, sometimes by reference even when the modifications shouldn't be saved. The things in it can be completely unrelated, used by different functions but accessible to all. And of course there are no safeguards to protect any of the fields, it's just all mixed up togezer in a bucket ^[1].

Flux Capacitate

When a piece of jargon is used to confuse someone who really has no business asking a particular question.

Claustrocodeia

The fear of coding on a dinky monitor that has no screen real estate.

Defactoring - Cleaning up code by deleting loads of unnecessary garbage.

Binary Comment Debugging (BCD) - recursively commenting half of the suspect code until the bug disappears. A method usually used in late night coding sessions close to a deadline. Only works on obvious bugs and is usually used when the mind is on autopilot.

Impediphile - Someone who codes in such a manner as to constantly cause impediments to others work. Coined by someone at my office, not me.

Agent. I didn't actually invent it, Carl Grundstrom did. We were discussing what to call the little programs that were part of "Security Toolkit/UNIX" version 2.0, that would rattle around a UNIX system (remember UNIX?) and decide how securely it was configured. I said something about the program being a spy, and Carl jumped to Secret Agent, then Agent. This was early 1992, and I haven't seen any earlier references to agent-based computing, which is really common NOW.

Bug farm, as in, "Man, every piece of code he wrote turned into a bug farm.", or "That's a hell of a bug farm – we probably end up fixing two bugs a month in that code."

FrAgile Development: The process of taking an existing framework that performs its required task very well and is well tested. Then throwing it out the window and rolling your own implementation. This process is repeated until the software has become such a kludge that someone suggests using the original framework in the first place.

It's a vicious cycle widely observed at Rapid Development Weekends at RIT's Society of Software Engineers.

SpongeBob developer

A developer that happily hacks away without a care in the world what happens to the codebase often to the sound of "la la la".

'Outsourcing it'

These days, this term is used at my office to describe the act of taking some freakishly elusive bug that's been pestering you for hours and just posting it to StackOverflow, going home, sleeping off the frustration, and getting back to work the next day to find a perfect solution from the internets.

Hillbilly Namespaces: using the same prefix on all functions/variables/table names for a particular module rather than putting it in its own namespace. Used when the environment doesn't have namespace support, or when the programmer doesn't or didn't know how to use them.

Flock of Geese Code: A series of deeply nested conditionals where exceptions, return statements, or even gotos would be more appropriate.

GUI-Licious: Software designed to feature a plentiful (and sometimes unnecessary) amount of graphics in order to subsitute form for function in an user experience. "I added 20 modal dialog boxes because I felt like it would make it look more like a real Microsoft program.

Black Magic Hacks: To use a seemingly inapplicable algorithm or otherwise out of the box method to design a solution that uniquely and effectively solves a problem. "I used the postfix-infix algorithm to create hierarchal XML parser! It was total black magic hacks

Dropping Algorithmic Bombs: To design a program using arcane or esoteric algorithms to great effect. I dropped serious algorithmic bombs when I used A Star to calculate Nash Equilibrium

Total Hack Job: A quickly-written program that substituted quality for time to market/speed in delivery, performance, etc. I needed to submit a diff super-quickly, so I wrote a total hack job that's probably going to have race conditions up the wazoo.

Configuration Programming / Programmer - someone that says they are a programmer but only knows how to hack at configuration files of some other pieces of software configuration to make them do what they want. Apache config files are a good example. Being able to hack at a mod_rewrite config doesn't make you a programmer. Much like hacking at Spring/Hibernate/etc config files isn't programming either.

Tired RAM Syndrome

After your Windows computer has been running for some time, and something breaks due to cumulative memory or resource leakage, requiring a reboot.

IOP - "Insistment" Oriented Programming

It happens when the developer keeps compiling a program (or changing a script) over an over, after really small modifications (like a single line or a single variable), and runs the program to see if the modification works instead of trying to really understand the problem to fix it.

Fairy Magic - The type of work applied to a task that's long, grueling and just complicated enough that writing an algortihm to do it automatically would take longer than doing the task itself. Refers sarcastically to nonprogrammers' assumptions that everything done on a computer is done by the computer rather than the person using it. Etymologically derived from a large 'Fairy Magic-Powered' windmill in The Legend Of Zelda which only spins due to slave labor.

"Wow, all 11000 rows of the the database are clean! How'd you do that?"

"Fairy magic."

Coffee Coder

An inexperienced programmer who was taught Java in college and doesn't know anything about pointers or memory management. They stay up all night coding Java and think Java is just great; the only way to save them is to teach them C++.

Sonic - A manager who is so clued out that you wonder if he's actually plugged into the same reality you are.

The name stems from a passage by Douglas Adams where he goes on at length about how certain kinds of madness should be easy to sort out. The provided example was someone who thought he was a hedgehog, a form of madness that was ostensibly easy to point out the flaw in: "Here's a mirror. Here's a photo of a hedgehog. You sort out the difference."

A Sonic (named after the video game hedgehog) is someone who'd take the mirror, take the picture and say "Yep, that's me alright!"

.NET sandwich - when .NET code called native code which calls other .NET code and makes the poorly designed application crash.

Programmer DNA.

(Do. Not. Assume.)

Look it up in the docs. Write Asserts. Ask your coworkers. If there is as much as a spec of doubt, check it.

It's something that should be in the "DNA" of every programmer, ingrained so deep that they can't sleep well if they based even a line of code on an unchecked assumption.

Those assumptions can lead to horrible mutations, you know...

Rocket Surgery As in 'It's not rocket surgery'. We have so many non-tech people telling us it's not 'brain surgery' or it's not 'rocket science' we had to come up with our own term for simple.

You're not holding the mouse right

When someone shows me a problem they are having and I don't have an answer for them, I just say "You're not holding the mouse right".

Wrong Finger Error

What gets written in a bug report for our touch-screen software when manual testing cannot reproduce a problem and the developers are too tired to care anymore:

Tester: Module X doesn't work properly.

Developer: Show me the steps you're doing to test it.

Tester: I touch this, then that, then...oh wait, it works now.

Developer: Which finger did you use to touch the screen?

Tester: Index finger on my right hand.

Developer: There you go - you must've used the wrong finger earlier.

Tester: Oh.. right..

Not really a jargon, but I don't actually spell out "A-P-I". I just say "ah-pee".

I.D. 10-T error

i kept hearing this at a review meeting a month ago. its kinda funny - i did not realize what it meant til a peer told me to write it down (just take out the all periods and dashes.)

it's self-explanatory i guess. :)

Barfcode

== Code that looks like someone opened Notepad, barfed into it and hit save.

I like to use this term to describe code with messed up formatting (or no formatting whatsoever). Also applies to code which does not follow any kind of naming/capitalization convention (not even an uncommon/discouraged one) - capitalization appears to be completely random.

Highlander - when a solution requires a singleton of some kind, such as a single running process, or a single instance of a global... There can be only one!

I first used it in http://www.stonehenge.com/merlyn/WebTechniques/col54.html, and it got spread from there. I've even heard it quoted back at me by someone who didn't know I started it. :)

I go to ask smart guy - when You go to bathroom to re-think some idea...

Prefactoring -- When you say to a co-worker (or when a co-worker says to you), "Hey, you know that code you were gonna write this afternoon? Yeah, uhm ... why don't you let me take care of that instead? Don't you have some errands you need to run?"

IEssues for IE issues :P

Error Message Blindness For those compiler and linker errors that colleagues can't handle until you read the error message out loud to them. Related to Popup Message Blindness.

Electron Heaven

Where you unsaved code goes when your IDE or PC crashes.

Brute force programming

When a (generally clueless) "programmer" tries every sequence possible and imaginable of instructions and blocks of code in order to get a working program that does (or seems to do) what have been asked. After a few hundred iterations, they manage to get more or less a working solution and call it finished.

I teach some Computer Science classes, and this term is specially applicable to those undergrad students who managed to get into a CS course, but really do not have aptitude to be computer scientists at all. They lack the abstraction skills to understand how a program is written.

It is an allusion to brute force attacks ^[1], used to break encryption by trying every possible sequence of bits in the key.

Doubleton

When it turns out a singleton is just not enough.

Instead of a simulator, we have something called a stimulator (the other end). One of our customers actually came up with it by accident, although he doesn't know it yet. Lets just say, he has an accent and we were sure he referred to our "stimulator".

Delsert- Delete all previous listing then repopulate with new.

Here ^[1] is a blog post.

Code clam (or 'kodmussla' in Swedish)

Refers to a developer who refuses to commit (or push his commits) to the shared code server regularly. (The reference is apt since the clam is usually kept shut, and doesn't open unless some pressure is applied.)

Such practice usually ends in merge hell (for said devloper, then testing for everyone else, since he or she isn't up-to-date with the latest behaviour and likely introduces new bugs with their mammoth commit). Unless, of course, they've been pulling/updating/merging on their local computer.

We almost decided to buy a fuzzy toy clam and award it on a regular basis to the last week's (or last month's) Code Clam Developer.

Basil - We were banned from saying 'Fail' in the workplace as it was demotivational, and against company policies... And one employee in particular (who made it onto the Fail board exclusively when we were allowed that) complained to the manager.

So, unbeknown to our boss, we changed the word from Fail to Bail, and then because we already used Bail when we wanted to 'Bail out' of somewhere, it was changed to Basil.

This went through a few of our sub-companies, and also through companies who ex-employees joined and now we refer to a 'Fail' as a 'Basil'...

To this day our boss is unaware as to what a 'Basil' is... but still 'Fail' is banned...

String typed

Referring to a code module or framework that only uses strings in its interfaces even though it is implemented in a OO language and handles things that have obvious benefits of using classes (such as IP addresses, cars, references to other object, etc).

Borken

A misspelled check in comment "Fixed a borken merge" is now standard jargon for small faults.

Line Programing

For code that is written like the worlds longest Pascal program despite the OO language, everything in one method, with random flow control and error handling. The nightmare case of this in our office is a 9k lines Java class with 5 methods containing regions of some hundred lines copy pasted all over it.

Tabify

To make a data-entryist happy (by adding Tab-Indexes to a form).

"It Compiled"

A defense you supply in jest when someone points out an obvious mistake in your code.

It's reference to a former employee who was the sort of programmer that people talk about for decades after. This programmer submitted for final review some extensive changes to a core application, which due to some serious bugs he had introduced, failed to even launch.

When confronted about the results of his testing prior to submitting his code, he looked confused for a second, and then responded, "well, it compiled." Apparently the struggle he underwent with the compiler to get his code to even build was so extensive that he assumed that he had fixed all of his bugs when it finally actually compiled.

Bukazoid documentation pattern for when people try to cut corners when documenting the code:

/**
 * Bukazoid manager is a manager to manage bukazoids.
 */
public class BukazoidManager extends SomeOtherClass {
...
}

This is especially annoying when you are trying to grasp someone else's code (why is the class here? What functionality does it cover? Why does it extend SomeOtherClass? Is it thread safe?, etc.) ...and all you find are some meaningless words.

Trynally - a Try..Finally block:

try
{
   ...
}
finally
{
   ...
}

Invented by @ohadh ^[1]

ManHunt. The process of finding the person responsible for bad code.

Sextuple-u (or, for those of puritan or mixed greek-latin descent, hextuple-u)

Not so much a term as a pronunciation of "www". Arguably not programming jargon, as it's useful beyond web development.

Not a specific term, but where I used to work, we always used ColdFusion as a sort of placeholder for some technology/language that's esoteric, out of date, not mainstream, etc.

We also used Atari Jaguar Emulator as a placeholder for a futile personal project that someone would work on instead of something more mainstream that would provide actual value to society/customers/etc.

Also, we used Dreamcast Browser as a general term for an obscure browser in discussions about whether to support one feature or another.

Reclinacode

-To code in your recliner

Macaroni Code

You know what spaghetti code is. Sometimes in badly written OO code, there are so many short methods of only a few lines, but only a convoluted path of execution challenging to follow, weaving in and out of various classes. It's like with spaghetti except the pieces are much shorter.

Rice Code

If all the pieces are very short, e.g. almost all the real action is in one-liner methods inside a messy OO hierarchy. (It's not pasta, but still is starch.)

Architectural M*sturbation

Code that has no real world value, other than to entertain the ego of the developer that wrote it.

LDD - Layout Driven Development

The developers are given PDFs which show how a page should look like. There is no text describing any functionalities. In the extreme form of LDD the developers are forced to copy-paste graphics contained in the layouts into the actual end product, doesn't matter if they are in scale or not.

I don't remember who invented this acronym in my previous company, but it became quite commonly used.

In our DOS app in 1981 we coined the phrase interstitial programming to mean pre-processing while waiting for the user to make a choice. Interstitial is a medical term meaning between closely spaced. We would guess which F-keys the user was most likely to select in any given circumstances and preprocess some of the responses.

De-demoscene. Refactoring code written by someone who thinks it's hilarious to have obscure or one-letter variable names throughout his code, even in public interfaces.

Not specifically programming jargon: Braino--like a typo except it involved a mental process going astray rather than a finger going astray.

Right-Tap or Right-Touch - the theoretical gesture a user does on a touch screen device that mimics a mouse right-click.

I know some UX people that love right-click context menus, and want something similar on the iPad.

TIN Loop - a situation that arises when a programmer makes an attempt to fix a bug by guessing what the cause might be, declares the bug fixed without verifying, and tells the user to "try it now." ("TIN" is short for Try It Now.) Invariably, the user will encounter the bug again and report it to the programmer, who will proceed with the next half-assed guess of a fix, thus repeating the same scenario.

A more specific version of the term is the n-order TIN Loop, where n is the number of "try it now" iterations.

Spectagular Expression

A cleverly done, very useful regex

Dollarscore/Anglesign

In PHP, reading code is a pain with the $_s and the =>. A team I was on referred to the former as a "dollarscore" and the latter as an "anglesign". Handy!

Firm copy, n: a scanned hardcopy, like a raster image of a text. It's impossible to edit or parse programmatically, but is still better than a hardcopy in terms of weight, volume, storage, etc. For images, "firmcopy" may refer to reduced-resolution soft copy of the actual image.

It's analogous to "firmware" as something in the middle between hardware and software. Google seems to know nothing about it yet. I hope it catches :)

Duck: a physical unit (typically, voltage) corresponding to 1 LSB in raw integer data sent to a DAC (or ADC) for further conversion to voltage.

Example - "5V corresponds to 4096 ducks", "Atmospheric presure is 2200 ducks with this sensor", etc

Kinetic hazard: The opposite of "potential hazard"

Perversion: a manual version control system for large data and 3rd party files, that cannot be stored in Subversion.

More here: http://bugpwr.blogspot.com/

We have three types of employee at our web dev company:

• Pokey — graphic designer
• Gumby — web developer
• Blockhead — programmer

"We need to make a gumby-friendy API for this feature"

"Ask pokey to create an icon for that button"

Excepticons

With all of the LOLSPEKA around these days, a lot of emails have a tendency to go back and forth in this geek-tongue of sorts. Alas, "excepticons" were born, and have been plaguing developers at my company (and now a couple of others) ever since. I even have some non-dev friends that have completely erased "error" from their vocabulary.

Not sure if this is what the spirit of the thread was, but I thought I would ante up those 2¢. ;)

Automagical - A term used by a want-to-be developer to describe an automated function they don't really understand. Most often used by PMs who think they're really a developer.

Faith-Based Programming - when you're writing code and you know it's going to take an act of God for it to work, or you're using a technique that "nobody quite knows how it works, but it does" (often related to stochastic algorithms).

Interociter: A fictional feature added to a specification in order to provoke questions and reveal ignorance. The inclusion of an interociter ^[1] in a spec will determine:

1. Whether the reviewers have actually read the spec.
2. Whether any of the reviewers will admit ignorance about a technology they've never heard of.
3. Whether any of the reviewers will offer an opinion on the inclusion of the interociter based on their prior experience.

I coined the term "deceptive idleness", which my friend Sitaram Iyer used in his MS thesis on anticipatory scheduling. The paper became quite popular, so the term now gets a fair number of google hits ^[1]

Snergle

A Snergle is a practice followed or advocated by a developer with little understanding of that practice, simply because the developer in question does not want to admit their lack of understanding. "If I don't understand it, it must be good. If I use it a lot, I'll sound smart."

The Snergle is an application of a practice, not the practice itself. Maybe applications of design patterns are in fact snergles, but this does not mean that all applications of design patterns are snergles.

Snergles are different from Cargo Cults in that a Cargo Cult mistakenly believes it understands what it is doing. A Snergle is the result of someone that knows they do not understand the concept, and assumes that means it must have value.

Example: "Why in the world do we have a StringFactory class that takes a string as a parameter? Someone must have been snergling hard."

User error - replace and retry.

Started using this when I had to help tech support track down issues. Make sure they aren't on speaker phone when you use it.

Confuckuration

When you have a framework or software which actually can do a lot but won't do anything if you don't set up everything properly in thousands of lines of deeply nested XML code (often in one single file, in .NET projects the App.config file).

Usually you're just able to validate the XML syntax/format but not the configuration logic behind (interrelations etc.) so having a typo in one of dozens cross-referencing configuration items (string keys which might contain whole namespaces) will cause the software just to "not do the expected", but without failure.

The Perkov Method - this is a programming style reliant on both in-line pseudocode comments (in its truest form, this will be 4 times more detailed than the actual implementation would be) and on the assumption that someone else will review this code and implement the functionality in their spare time.

Example: implementation of Hello World in the normal style:

class Program 
{ 
    static int Main(string[] args) 
    {         
        Console.WriteLine("Hello World"); 
    } 
}

Example: implementation of Hello World using the Perkov Method:

class Program 
{ 
    static int Main(string[] args) 
    {   
        // at this point the program really should be outputting text to the 
        // console. we must take into account 78 character maximum line length
        // and ensure that we use Environment.NewLine for line endings. 
        // ideally should provide multi-region language support and UTF-8 / 
        // UTF-16 encoding. 
    } 
}

This excerpt taken from our team wiki. The culprit knows who he/she is...

Ivory Tower Programmer This is a term for academic programmers who are tucked away in their posh, lush computer science departments. They work on the fastest hardware, don't have to be concerned with end-users, speak with a LISP, and pontificate frequently on the meaning or semantics of a program.

g11n ("globalization", also pronounced gee-leven)

The opposite of i18n and l10n ^[1]. Opting to use language-neutral elements like a more obvious design or text-less graphics, instead of adding more content that requires translation.

"If we use some g11n here, we can greatly reduce the l10n work and make it more accessible."

Crumment
From Comment, and Crummy, "of little value; inferior; contemptible". A comment that adds no value or hasn't been updated to reflect the code.

"Jimmy's last commit is a solid piece of well-crummented code."

OutOfLinebreaksException: Linebreaks for Loader.php exhausted. die() has been disabled for your convenience.

This is a very specific one, so I imagine no one can actually relate, but it was gleeful amounts of utter, raw despair for me, hence sharing:

The Story

The PHP Parser is a robust creature that rarely hiccups.

Except when it does.

This is a once-in-a-lifetime occurrence. Apparently I have two lives, because I've observed it getting its knickers in a twist twice now. Let me tell you about the second time.

PHP usually ignores indentation whitespace and blank lines between code blocks - but somehow, when we were updating Zend 1.9.7 to 1.10.3, half our PHP Unit tests broke. I made a copy of the offending file (Loader.php in Zend's autoloading sublibrary), placed the old code in, commented the new code out and was about to sequentially comment back in to find the core of the error when I noticed it was still happening.

• I did a diff.

The only difference was in comments. I didn't even want to believe it, so I asked two other people to look at the diff and find the programmatic difference for me. They confirmed a lack thereof. I still felt my sanity slowly leaving me.

• I checked the file with a hex editor.

No broken UTF-8 characters. Well-formed through-out.

• I took out the comments.

Suddenly it worked again. Cue first manic, despair-driven cackling!

To cut a long story short, I 'narrowed it down' to the amount of linebreaks in the file (without the help of die() which didn't quite want to work in that file anymore). The old file would break just the same if you put more that ~two more linebreaks into it.

To cut to the chase: To this day we don't know what caused it. Suhosin patch? No. xdebug? No. Suhosin extension? No. PHP core? Apparently no, except that's the only thing left to 'explain' it. (Same PHP version on Ubuntu/Kubuntu/CentOS was showing the error, but it wasn't doing it on OpenSUSE; we're not sure if it was the OS or their respective package doing it.)

Our project internal wiki documented the mess and this is (paraphrased) the 'Solution' section:

Depending on your definition of 'solution':

• There is none
• Zend 1.10.4

So we had the Exception on our Whiteboard for a while ^[1]. Much amusement ensued.

The term

Whenever a parser of an interpreted language hiccups, for whatever reason, and elements of the source file that should not matter suddenly do, despite well-formed syntax and no broken characters, any observed changes in logic are to be considered the result of an OutOfLinebreaksException.

(Even if it has nothing to do with linebreaks in that particular parser-tripping-over-itself case.)

Field Trip Fix The solution to dealing with an issue that is frustrating you to the point of madness. The cure for which is taking a field trip to a local restaurant for a mental break.

Kludge Hammer

When you attempt to rewrite/repair a segment of messy, hack code. It's akin to needing a sledge hammer to knock out poorly built walls/structures in a house. Used when there is nothing else you can do but tear it all out and start over.

*"Have you looked at that new module from Tom?"

"Yeah, we're going to have to take a kludge hammer to it to fix it."*

Bob

This one's kind of narrow, because it is specific to interpreted scripting languages that don't have decent debuggers in which you can set breakpoints. Specifically, it came up at my last job where we used Stata a lot. I got in the habit of deliberately inserting a syntax error into my code wherever I needed a breakpoint. Usually, I just added the word "bob," which was quick to type, and unlikely to be recognized as a command name. It can be used as a verb, as in "bob that function after you load the data--I want to have a look at it before we do anything to it."

The practice caught on, and soon everyone was using "bob" to add breakpoints. Unfortunately, they weren't always as conscientious as I was about removing the "bob"s when they were done debugging. This gave rise to

Scraping Dan off the ceiling

Which had to be done every time I tried to run the build and it broke because someone on my team had left behind an errant "bob." Also known as "reaping what you sow."

Trojan Horse ESB: for an enterprise service bus that really hosts a whole bunch of bilateral connections.

The idea with these service buses is to reduce n^2 system connections to n, by putting a neutral layer in the middle. Unfortunately, most business don't have the stamina or discipline to do it properly, so they feed system specific crap through, and end up with a much more expensive version of whatever they were already doing with point to point connections.

God (Code) File

An extremely oversized file that "does it all".

Lethal Dependency Injection

Too much Spring XML wiring to configure a handful of classes.

Funhouse mirror effect When a bunch of classes reflect similar subsets of data from a common super-set of data in such a way that they are more than 80% identical but no two classes fully look alike or are sub or super sets of each other.

IE, the Customer, Account and Portfolio classes are 80% identical, but are used by different apps or different parts of the same app. They are used in conjunction with the Order, Trade and Holding classes which share only a common set of Ids

turd files are the (often hidden) files that a version control system "drops" around your file system.

Example usage: "Oh, I usually fix that by deleting my turd files and then doing an svn update".

foodoo

The arcane process by which demo apps using dummy data perform superbly in all areas. This magic somehow disappears and performance suffers as real code is written and hooked up to real databases, etc. [Back formation from "voodoo" (black magic) plus "foo" (standard exemplar variable name)]

Sample usage: "I don't know, guys, the final release seems to have lost all the foodoo."

One that was in common use at a former employer.

Using the force - Identifying the source of a problem through intuition.

"How you figure out what was causing that?"

"I used the force."

"The force is strong with this one"

This particularly applies to obscure or hard to track down bugs. Concurrency issues, heisenbugs, that kind of thing. If the cause of an error leaps into your head while not actively debugging it or the cause of the bug is so obscure as to make it virtually impossible to debug then you are using the force.

Glocal variable

A global variable disguised as a local variable.

To avoid the embarrassment of using global variables one can always make them local and put them in a singleton or something...

Futility Classes or Services.

Utility classes or services that are so full of bugs or useless features that you'll never get anything useful out of them.

Left Than Conditions

An enhancement in readability of composite conditions; only use less than to logically order expected values from the left to right in expected ascending values.

Example:

if (0 < x && x < y && y < z.length) {
    doStuff();
}

Ajaxification
Using ajax to make something "cooler", fast and/or better. Not super original I'm sure. It's just quicker than saying "You should re-write that using ajax, no more giant page reloads". We (TeamBizStream) all know what we are talking about when saying it.

JQuerification
Along the same lines of Ajaxification.

These can both be used in the past tense as well. "I just ajaxified the !@#$ out of that code, it is rocking now"

Columnify To change a table's column name into a user-friendly name. Requires a valid table column naming schema, fails if column names are x1, x2, x3...

e.g. 'user_id_num' -> User Identification Number (s/id/identification; s/num/number; underscores -> spaces; first character after space capitalised.)

I built a utility procedure to do this process, and the pet-name stuck in production. I still get laughed at :<

TLA. It stands for Three Letter Acronym. It's from a coworker who used to work at Digital where they had lots of TLA's. Two letters is too short and four is too long. Examples: TCP, WCF, WPF, TDD, BDD, JVM, need I go on?

Doomed loop. A smelly device for a clean flow control.

VB

    Do 'omed

        '' lots of stuff with arbitrary exit points

        Exit Do
    Loop

CS

        do//omed loop
        {
            //lots of stuff with arbitrary exit points

        } while (false);

Hackfactoring The process of taking code and refactoring it without consequence to make it do what management demands that the code do.

Enchancement - A fantastical feature or function of a program that would often require re-invention of the technology chosen or rewrite a programming language to support. Is usually given after the first review with a client or management team, massively increasing scope creep for this one feature that has a 50/50 chance of working but is suddenly absolutely mandatory because the customer thinks they saw it somewhere. (Usually from the TV or movies)

Examples: -Make that video completely interactive so that I can take it and drag it from my desktop to my PDA, and it should just work, like in the movies. -Re-write that to natively support pdf files.

Sheng Long: Whenever we catch a SQL Injection, PHP Injection or anything like that, the user gets and alert message with the classic message from Street Fighter 2: "You must defeat Sheng Long to stand a chance!". Now, whenever we want add security layers or refer to something that happens after these filters, we call is "post Sheng-Long code".

Screw the developers I have power: We use it whenever a client asks us to do something ridiculous, but he has power inside of the company to request anything. Based on the animation Yu-Gi-Oh The Abridged Series.

Call Stack Carnage when you accidentally (or purposefully) corrupt the stack. Also when you use extreme amounts of tiny event notification messages and attempt to read the call stack with an attached debugger.

[variable/function/feature/API] has a Schizophrenia - when it tries to be two contradictory things at once (usually due to a design error - you refactored half of the project with new meaning of the piece in mind, while keeping the other working)

Examples:

• In soft-typed languages when the variable can appear as two different types - say, an index in a table of values and a reference to a function returning a similar value.
• an API that tries to protect users from shooting themselves in the foot while aiming at maximum freedom for the user.
• a variable that holds a value that only coincidentally works in two places, e.g. a database index and file line number.
• a variable that is written to with two different formats of the same data, e.g. an array of 1-byte integers, or an ASCII string containing the values as CSV text.
• a flag that does two remotely similar things at once, e.g. "isStopped" which is set both when the system finalizes a total emergency stop and when it is momentarily idle and ready to change work mode.
• a "unit" difference, say x and y in px but height and width in mm.
• a GUI API that can't make its mind about using x,y,w,h and x1,x2,y1,y2
• a function that can return an error code, value of which lies within legal valid return values.

Super pipelines and Ziggurats.

These are n-tier pseudo-architectures. Super pipelines are methods that call methods that call method, etc, and the intervening methods don't actually do anything except call the next method. Ziggurates are classes that inherit from classes that inherit from classes that inherit from classes and the middle classes don't actually do anything.

I think this comes from developers who've been told to create 3 layer code and put all their code into the UI anyhow, but have stubs for the other 2 layers.

http://suburbandestiny.com/Tech/?p=576

The infamous AhTeJodesException (something like OhYouAreFuckedException, in Spanish), the first use among my friends was in a computer science assignment as a joke, but now we use it for everyday situations when you're screwed no matter what you do.

RBAR (Adjective) [pronounced ru-bar] - Describes one who works with relational databases but really has no clue how to do so propelry and so every action they take is RBAR'd which is short for 'Row by Agonizing Row'.

Credits for RBAR go to DB guru Jeff Moden

Faith based programming

When "Jimmy", instead of using a more.. "scientific" approach to problem solving, just randomly delete, comment or rename a variable/line of code and prays for it for compile/runs.

This is sad, but true :(

Good programmer expected ( not mine originally )

When "Jimmy" says: It gives me an error!!

I ask? What does the error says? "Good programmer expected?

I did not coin this one but have had some fun with it:

FM as in f***ing magic

FM is a name given to processes during early analysis and design where we know what must go in and what is supposed to come out but, as yet, have no idea of how the process is supposed to make such a transformation.

Once we had a trainer come into our shop to give a workshop on a particular design methodology. The trainer must have overheard us refering to FM quite a bit and decided to use it in the workshop as an example of a process that we might be working on. It really cracked us up - the trainer had no idea what it stood for.

Dejunkify - To clean up someone else's crappy code.

Marketing Bytes - Bytes as measured in multiples of 1000.

Also applicable: Marketing Terabytes, etc.

Politics Driven Design - A design decision with no technical merit that suddenly shows up in the code only to cause an interruption in production as soon as it is promoted. Root cause analysis usually reveals user story sessions held behind closed doors between the weakest programmer on the team and management obtained a stamp of approval for the design. Management usually claims innocence and blames the campaign promises of "everything will be easier from now on" and FUD like "if you don't allow this, the sky will fall" from the weakest programmer.

Experimental programming - Arranging tokens with little or no understanding what they really mean, and testing if the resulting code works well or not. This is repeated until the code works.

Sometimes this is really bad, like in this question ^[1].

Sometimes this can be a valid technique, provided the testing is done well. Once case I use it is when doing a vector cross product, as I never remember what is the orientation of the result. I try it one way, if it does not work, then try the second one.

If the tests are automated and fully cover the required functionality, I think this is a valid special case of test driven development - with TDD you do not need to care what the code is and where it came from, as long as it passes.

Björn Borg - To completely remove old code and rewrite from scratch, without being able to use the old code as reference. We came up with this expression in the demoscene in the mid-90s when we had to rework parts of our demos and were sure that the existing code would trip us up rather than help us. We also argued that rewriting the effects made you learn them properly rather than relying on cut'n'paste for the more advanced stuff (mathematics, pointer voodoo etc).

There might have been a reference to cocaine use and staying up all night (the latter being a natural consequence of the Björn Borg principle). Before you do a Björn Borg you have to actually shout "Björn Borg!", also for reasons I can't quite remember. Maybe as a warning/invitation to veto.

Inequality Debugging

When you have a program and an if statement isn't working so you switch the less than sign with a greater sign (or vica versa) in the if statement and your program starts working as expected. Usually happens with extremely long if statements.

macrobator (n.) (māk'rō'bey-ter) - 1. A C programmer who creates a new language using the preprocessor. 2. A C++ programmer who uses #define for anything other than include guards. 3. A fisherman who buys his worms from Kevin Bacon.

entoliferator (n.) - 1. A programmer who efficiently multiplies bugs in a program using cut and paste. 2. Someone who leaves food crumbs all over the house. 3. Robert A. Heinlein.

pastafibrolator (n.) - 1. A programmer who fouls up a well structured program with global variables. 2. A toddler eating spaghetti. 3. Ron Popiel's latest invention.

literomagnon (n.) - 1. A programmer that codes with numerals instead of labels. 2. A librarian with a protruding suborbital ridge. 3. The web-browsing GEICO caveman.

autopathosite (n.) - 1. A programmer that attempts to curry favor with management by fixing problems in their own shoddy code. 2. A person that tries to gain notoriety by capitalizing on their character flaws. 3. See Rod Blagojevich, Natalie Suleman, and Richard Heene.

Frankensteined *to frankenstein*

Code or a feature written for one purpose that has been repurposed for an originally unintended use (one that it probably wasn't designed for), and thus has taken on a life of its own.

Usage: "That code that Jimmy wrote to print out schedules has been frankensteined to do payroll"

fishbones

Stray files that choke processing scripts that try to ingest them, usually because the script is coded to process somedir/*, when it should really be processing somedir/$yyyy$mm$dd in loops.

core, nohup.out and .bash_history are examples.

Typewanking.

The excessive use of complicated features of one's type system to ensure the static safety of mostly irrelevant issues.

Un-Variable: A term used to describe a variable that is declared, but never variable, never used, or not actually hooked up to any logic.

Example 1: A variable used once... and only once

Example 2: superImportantHandler is declared, but never used; making it not too superImportant and leaving its handling abilities questionable.

Example 3: You see "turnOnImportantThing = 0" so you assume that flipping it to 1 will have some effect, but it takes you 15 minutes to figure out that its not actually hooked up to anything.

Productional

It's used when something is deployed to production and is being used. Example: Our new feature, Whizbang, is now productional. Or even, the Death Star is fully productional!

Pixie Dust - a "tool" used by developers to "magically" fix certain issues via abnormal/illogical/unexplained means. (coined by the leader of our support team) When an issue completely baffles the development team we are "out of pixie dust".

Un-[name of co-worker]

To refactor copy-and-pasted code into a subroutine.

Paste-o

A typo-style bug caused by sloppy copy and pasting. Especially prevalent in boilerplate comment blocks, where that style is used.

Code Monkey

An insulting term to describe a poor programmer, usually who does not grasp basic or common programming concepts, and sometimes whose best coding capabilities can be described as "GoogleCut&Paste".

C*nts Socks and Sandals is my nickname for CSS.

SQL.

Some people pronounce it "es-que-ell", for others it's "sea-quell". I like SQUEAL.

Thankie or thanky. What you say to thank somebody who tried to, but didn't, help you. It's a polite alternative to "thanks for nothing".

Nerd 1: "Do you know where the foo class is checked in?"

Nerd 2: "I think it's under the bar directory."

Nerd 1: "No, I already checked there."

Nerd 2: "Then I don't know where it is."

Nerd 1: "Thanky."

Cruftaculous - when a program has more "cruft" than useful features.

Emser Code/Method/Function/StoredProcedure - "Emser" is a part of an application that contains code that is so complicated (even when the task is easy) that you need a few hours to figure out what the code is doing. The better choice is to rewrite the whole function/method/stored procedure. This attribute can also be given to developers if it is known that they mostly write Emser code - in fact, this attribute is named after a developer.

A typical conversation goes like:

I have to look what the code does...oh my god it's an Emser function, we better rewrite it, that should me much faster than finding the bug; if this is even possible!

Other comments that you are able to hear when reviewing Emser code:

WTF, Oh my god, Why is it doing that?, That's completely against our programming guidelines,...

Jidiomatic (extends com.thefreedictionary.Idiomatic)

-adj

1. Peculiar to or characteristic of the Java programming language.
2. Resembling or having the nature of a Java idiom.
3. Using many Java idioms.
4. Peculiar to or characteristic of the style or manner of Java programmers.

example usage:

Joe: "Hey Mike, check out my joint union in type parameter variance on this class!"

public class Baz<T extends Foo & Bar> {}

Mike: "That's so jidiomatic!"

Revelation

Discovering or finally actually using an API or technology, like LINQ, which everyone else has been using for years.

You consequently spend three days rewriting all those for loops and feeling stupid for never getting around to it beforehand.

I'm guilty of this.

I'm covered in chicken blood

M.O.A.V. - Mother of all Views

In a database, this is the view that consolidates data across most or all of the database through numerous joins to other views, subviews, and tables. It is often used for reporting purposes or to transform data into a reporting structure. If you were ever to encounter the 260 table query limit, it would likely be through executing a query against this.

Unicodification

The process of making code or a product Unicode-capable.

We coined this term when we converted Delphi and the VCL framework to be fully Unicode capable.

The verb is "Unicodify".

Like a bought one - Not coined by me, but by my professor:

"The act of writing code, no matter how big or small, and it executing perfectly the first time - like a bought one".

Code in Front

In ASP.Net "the code behind" refers to the .cs file.

Well, the .aspx page is called the "code in front"

Orzo Code

Code which is incomprehensible because it is too modular. Typical signs include functions with very similar names that do nothing but wrap each other, classes which do not remotely correspond to types of objects, and objects which exist only to have a single pointer-member of a subclassable type with a pure virtual function.

worning: it works but with warnings :)

Con Coverage

Tests that run through your code and adds to your code coverage, but has no actual value other than making your code coverage percentage look good.

Doctorowing - Devoting an undue amount of time to creating an overly-complicated multistep routine using free or open-source methods to save money when a $20 app would fix it once and for all. Named lovingly after open-source proponent Cory Doctorow.

also

Apple-Bias - Creating a script or using an app that doesn't produce the intended result. Giving it 30 seconds of thought before scraping the whole thing because it didn't "just work."

The term Ghost Bug. Referring to a bug that cannot be reproduced in controllable conditions, a bug that seams to have appeared but no one is sure about it. A bug that requires voodoo for fixing. A bug that drives a developer to think that a mutex should be used in a single threaded app.

Developer Fairies and Infrastructure Ogres

Terms coined by Sahil Malik ^[1] and often referenced on the .NET Rocks! podcast to represent the contention that often exists between the IT and development perspectives of implementing a solution. Developer Fairies simply want to leverage the best technology to solve a problem, while the Infrastructure Ogres are often more concerned with security, reliability, and performance.

"Blind Coding" - Someone tells you the spec for the communication between your client app and the server app, and give you a piece of code has example that has little or nothing to do with the spec presented.

And you just go in there and code until you get it right.

Hudson Moment - A moment of panic/distress that occurs during the realization that a project has become woefully doomed to a horrible fate. It typically involves a wild verbal rant and complete loss of morale. This moment usually ends when a nearby coworker suggests a way out of it and somebody else says, "Knock it off Hudson!"

Taken from the scene in the movie "Aliens" where Private Hudson freaks out and starts yelling:

Ripley: How long after we're declared overdue can we expect a rescue?

Hicks: [pause] Seventeen days.

Hudson: Seventeen days? Hey man, I don't wanna rain on your parade, but we're not gonna last seventeen hours! Those things are gonna come in here just like they did before. And they're gonna come in here...
Ripley: Hudson!
Hudson: ...and they're gonna come in here AND THEY'RE GONNA GET US!

Ripley: Hudson! This little girl survived longer than that with no weapons and no training. [to Newt]

Ripley: Right? [Newt apes a salute]

Hudson: Why don't you put her in charge?

Ripley: You better just start dealing with it, Hudson! Listen to me! Hudson, just deal with it, because we need you and I'm sick of your bull@%$#.

Bit Bucket: Dates at least from the 1960's at IBM. It's the place where bits go when removed from memory.

Tyranny Of Print Width: Coined by me, and never in wide use. It's the reason you can't squeeze the additional column on the report.

The if...then...else...but statement

When coding in VBScript, there are times when you think you've got if and else parts covered:

if RECORDSET( "Title" ) = "" then
    Response.Write "Untitled Document"
else
    Response.Write RECORDSET( "Title" )
end if

but may be not.

A NULL title will cause the else clause to execute, nothing will be written to response.

Divtastic

Not mine, but coined internally. Stems from a contractor building a Javascript gallery switcher with a ridiculously amount of div elements. Essentially tag/element soup.

Battling : My friends and I refer to programming as Battling. "I was up late battling that program last night" Or "I really had to battle with this error I was getting"

Shenanigans
When a bug is reported that isn't actually a bug.

Implemications - the implications of an implementation. A true "Bushism".

These are not terms I coined and I'm a Network Engineer, but these are a few terms I enjoy almost daily.

JFFIO - pronounced Jiffy-O - acronym for 'Just F**cking Figure It Out'

Example: Engineer 1: I don't know what the previous engineer was trying to do here. It's working but I don't understand how. Engineer 2: I'm kind of busy right now, JFFIO.

Rodeo - to describe a network port or device that is bouncing up and down. Example: The link was solid, not taking any errors, and passing about 400 megs of traffic, then the splicers closed up the splice case and the link went all rodeo.

SMG - Subject Matter Guru
Alternative to SME, Subject Matter Expert. Pronounced "smug".

Funny story, I once had a Dev Manager who said "If I see the word 'guru' on a resume, I throw it in the trash." lol

FK Hard

Not entirely mine, and probably not the first time it's been used.
Came up while discussing a nasty problem with friends over beers on a Friday night (can't remember who said it...).

You know it's not NP-Complete, but you know it's gonna hurt.

Line noise: The syntax of the Perl programming language, or almost any program written in Perl. (I think one of my co-workers coined this.)

Siesta: The point at around 1:00 - 2:00 in the afternoon, when your PC suddenly becomes unresponsive for 10-30 minutes. May be a surprise clean build triggered by eclipse, quirky windows behavior from network latency, or simply a CPU-intensive background process. More broadly, any time the computer is unresponsive to user input, because it's taking a nap.

Used by myself and my cubemates.

Traished: Inexplicably hosed, for no logical reason. Unable to compile, or produce an intelligible error output. Non-reproducible compiler behavior.

Not mine; came from summer camp, when learning to program. One of my classmates got an error from his Pascal compiler, saying:

This error should never occur. If it does, the file variable has somehow been traished.

The typo was included in the compiler error message. He discovered, after much trial and error and consulting with the lab instructor, that he was missing the period which is required after END to terminate a pascal program. Once he got it to compile, he was no longer able to reproduce the compiler error.

chlode - Code that is intentionally made needlessly complex in order to make some developer appear more capable or irreplaceable.

black ops - The project(s) you take on or create, right before leaving a big company, as a last ditch effort to convince yourself it is worth staying. Out of frustration, you cast off the established development processes, work in the background, or even use some new technology you've been interested in.

Hot Dog Stand code/project

When things are so amazingly stupid or pointless you feel like you're running a hot dog stand. Came out of a project that wouldn't spend the 10k on a new server (old one was literally failing before our eyes) but asked we replace some network cables to increase process times. "Big pile of ain't gonna make a damn bit of difference, coming right up".

Squishy

invented by me (circa 1999 while working at EA)

A term used to define

• the uncertain completeness or efficiency of a piece of code
• the incomplete design of a feature
• the (in)accuracy of an estimate
• or to express a general lack of certitude in what you're describing

eg:
Mgr: When will feature X be completed?
me: well, the specification is still squishy, but I expect in about a week.
or
me: I think I know how to solve the problem but it still seems a bit squishy.

I started using it for lack of a better word at the time, soon the whole team was using it. Its use eventually faded but I still recall it with fondness.

Instead of Rubberducking, I coined the term Plant.

-Do you need a plant to correct this bug?

-Well yes, I do, thanks!

When a programmer is stuck with a problem, he sometimes need to talk about it, so I would go to his desk and do the plant, not really talking but leaving him the chance to explain what is his problem and explain how the code works. It usually comes with a realization part, he just stops, and then says Ok, thank you!, at which point I say No problem, and return to my desk. It could be a theoretical nuclear problem and I could help correcting it, since there's no real interaction, meaning you could very well explain the bug to a plant there would be no difference.

MIBB or Make it Big Boy --> The act of using complicated sounding names for classes and/or methods that otherwise accomplish very trivial tasks. For example:

public static void ThirdRockFromTheSunGreeter(){ System.Console.WriteLine("Hello, World!"); }

IClusterFuck --> The practice of creating an interface with no underlying meaning or concept and with a bunch of unrelated methods.

Benedict security

Refers to "security", measures some clients request based on the complicated and made-up jargon they heard on a movie, thinking it will actually make some improvement on their application.

On "Ocean's Eleven", Terry Benedict's Casino's security system changes its password every 24 hours, so in case it gets hacked, by the next day it'll be useless.

If your web app's admin password gets hacked (not using social-engineering) there are other problems in your server besides a weak password

Bogon: a subatomic particle of software destruction generated by "non essential personnel" (e.g. management, marketing). As bogon fields are often lacking in development groups (apart from a small field generated by the development manager) these bugs are notoriously difficult to detect until demonstration time.

Does jargonology used within just three programmers, and I was not the one coining them, qualify?

Colleagues were commenting on frequency of inheritance classes, to inherit projects from people who were quiting. Then they were getting bug-bitten and had too many bugbites due to the applications. They would call me over as they believed a third pair of eyes would help spot errors. They would explain how a segment of code works to help me spot their errors. Miraculously, as they explained, they would spot the bugs themselves and solved them. So, they believed I was an effective bugicide as bugs evaporate with my mere presence. I protested that I did not do anything, but merely listened. And finally we settled on calling me a software therapist. They tried to advertise me to other programmers to have software therapy sessions with me because not only was I familiar with client side and server side, I was also effective with bug side code.

Those were the days when we used Cobol and CODASYL (network database), migrating to C/C++, Oracle and Sybase = deCobolize and SQLization. Today, the programming world has turned a full circle and with hadoop, we would have called it deSQLization (but we don't work together anymore) - back to network data relationships.

Specification Debt

A play on 'technical debt', referring to the cost of 'coding to assumptions' in software requirements, without taking the time to ask for confirmation.

You can save time in the short term by coding right off the bat, but you'll pay for it in super-high interest later.

I find that it's a good phrase to use to communicate to stakeholders the importance of getting the reqs right first time.

PHP Tourettes

I coined this term as an excuse to why I was screaming profanities at my computer screen when an error cropped up.

KOP (Kick Oriented Programming) - I coined this term mainly because when I'm too lazy to develop something (for being tired, sleepy or something), but I still want to do something, I invoke Chuck Norris name, and I get this programming paradigm in my spirit. So, you should use this term, to denote a code in which it was made using only your intuition, and nothing more. Sometimes you would like to develop it using random logic formation, but this is allowed only for Jedi programmers.

Jedi Programmer - This is the guy who when our team is at the deadline to the final attack, and we don't believe we're going to live after that, he comes, and by using not-known-by-most-ppl skills, he carries the project to final product. And everyone promises him, a pizza party @ Pizza Planet, he feels so happy.

Confusing Me with Facts

A term I use when somebody comes to me with a close set of facts about (a system / a bug / an issue) that absolutely defies logical explanation. In such cases, I counter claim that this person is trying to confuse me with facts, and then I proceed to find that little snag that unties the logical knot...

Not quite "jargon," but whenever somehow makes a change and forgets to commit it, we often laugh about how "well, we men are afraid of commitment."

AJAXPP (ajax-app)

A web application that relies heavily upon AJAX for it's frontend appeal.

Like-Jacking

Similar to click-jacking but applicable to individuals misusing and abusing the Facebook "Like" button functionality with the new Open Graph API to trick users into liking the wrong page.

Copy @ Waste when ever you copy something from somewhere and paste it into your code but by doing that stuff the result up.

Not sure where I first saw or heard it but it's clearly something everyone did.

Eg. copy some java code from a simple example paste it into your code and o wonder it did not handle any exception and as it was a simple example only ;)

The Smarts

What your boss/colleagues ask for when developing a tool for them. They're not programmers. In fact, you're the only one in the entire center.

It ain't smarts, it's just a lot of if statements.

This is my boss's... but he calls code that is left in the program but will never be executed (whether because of conditionals or being commented out, or in a function that is never called, or whatever) "Wilted Celery" as in: "I saw some wilted celery in the fridge, but I didn't throw it out because I thought someone else might want it."

Mangler

Instead of saying Manager, instead say Mangler

Example

• Did you restart the State Mangler Service?
• Who's the Project Mangler?

see http://origin.arstechnica.com/news.media/death-spiral.gif

The Death Spriral - when attempting to resolve a bug. You start with, break statements, then printf(s), then some other tool e.g. wire-shark, logic analyzer, scope, other programmers. Each new tool adds complexity and seems to take you further away from the problem. The solution, pull-up, go home solve it with a clear head.

From Wikipedia: a spiral is a curve which emanates from a central point, getting progressively farther away as it revolves around the point.

I always name my almost unreachable coding goals as "White Whales" (from the famous book Moby-Dick). The book is about a skipper who struggles all his life to catch a white whale, and he eventually does (sort of).

Wow, imagine if I could write something as great as that one day. :)

OBAP - One Big-Assed Program. Pronounced as you would expect: O-Bap.

A big, overly complicated monolithic program that is not well structured or broken down into smaller components.

Yesterday I tried to fix 1 bug and added 3 more bugs, god knows how many more undiscovered.So I just come up with. ReBug which explains itself.

Bogon Field: The field that follows a marketing person/member of senior management team around and permeates all demos making them go awry.

EBCK error An Error Between the Chair and the Keyboard. I use it for human errors

"ProductName" droppings

Used, for example, when uninstalling a product and dlls, registry keys, files are left behind that really can be gotten rid of.

The term can also be extended to refer to code that is no longer called due to refactoring, yet still remains cluttering up the code base.

Broadly, something that is no longer needed by the product to function yet remains behind waiting to be cleaned up.

Double-thinking in sets

Joe Celko's famous book, "Thinking In Sets", advocates set-based approach to SQL queries (which is of course a good thing).

However, it turns out that you still need to know how the optimizers work for the queries to be efficient and thus need to think your queries both in sets and in procedures.

Coined in this blog post ^[1], mentioned by Tom Kyte ^[2] and by some more people on the Internets.

Gurkensalat

German for "cucumber salad". Any kind of coded or crypted text.

Who the hell wrote that line of code?

I used to place that comment every time I came across a buggy code while maintaining our legacy application.

Bastardization nth generation of development teams modifying the code w/o a proper understanding of what the code does and making it very difficult to understand for the n-m generation developers.

Genericization pronounced "generisization". Other forms: "genericize"

Because Generalization already has meaning in OOP, we coined Genericization and Genericize to mean refactoring code to use generics (ie. in C# or Java).

Quantum bug - the bug that fails to occur when trying to observe it (ie tracing through code a line at a time).

Functuality - Used when function != or match reality.

Was first used about 8-10 years ago when a PM stormed into the dev room enraged and complaining. Like all great myths, no one recalls exactly what was said, but it was something to the effect, "The functuality of this product sucks!". After the we humble devs quit laughing, it took on the meaning above.

To this day, I'm not sure if it was on purpose (33% sure) or the result of babbling (66% sure).

Edit:

ANSI bit-masking - The usage of a database, unique table and VCHAR field instead of an enumeration or bit fields.

True story, about 10 years ago we hired a programmer who was (admittedly) far more DBA than developer. During a code review, we found some code that referenced a DB and grabbed a string value from a table. After retrieving said data, a for loop was applied to determine if the character at position n, was either '_' or 'X'. Based on that finding certain logic was applied. When shown a bit-field in code the reply was "oh, didn't you know you could do that." To this day, it's battle cry when using sarcasm to find the most convoluted way to do something.

Edit 2:

SYFT - pronounced "sift". Stands for Synchronize Your F**k-off Time. Used in response management's attempts & desires to fill an iteration with meetings everyday instead of attempting to group them in a logical fashion at the iteration bookends. I've heard cough that some shops have meetings or other non development tasks nearly daily over an entire two week iteration instead of attempting to as many as possible to one day.

Proctalgia - I didn't coin it, but it's a synonymous of "Pain in the ass", and we use it a lot. It's also needed to explain the following term.

Vegetable replacement - We had a java singleton class named xxxCustomerBean, and since testing with singletons is a proctalgia (see above), we have a test-initialization class, where we take the singleton instance, create a new compatible object or proxy, and substitute the original one through reflection: after a "getField()" on the original instance, we "enter the customer bean field to replace the bean". Since then, using reflection to test around singletons has become "vegetable replacement".

Ideal Environment Development

Writing your core code to the exact ideal dependencies that you wished existed. Used to keep the integration code separate from the core internal logic, and to promote the ability to swap dependencies.

Actually used to communicate the concept of "abstraction" to developers who do not understand the differences between abstraction, indirection, and generalization.

Not mine, but still a very funny Easter egg. EProgrammerNotFound exception in Delphi ^[1].

Rear End

The part of the program that comes before the back-end. For 4-tier process, store, access/logic, display architectures.

AEG - Ausschalten, Einschalten, Gehen, which is German for Switch off, Switch On, Go.

Usage: "I've justen driven 2 hours for a stupid AEG".

Mant! ^[1]

A build that uses Ant for compilation and deployment, but also uses the Maven Ant Tasks ^[2] to pull in dependencies from the organizational Maven repository.

Mud as in Slap on another layer of mud

In our office we have a lot of code that is quite similar to the big ball of mud ^[1] description. When we add some code to it, that doesn't bring any more structure into the system. We slap on another layer of mud to the ball.

Blown Stack Ok this is kind of a reverse one since it's legitimate programming jargon applied to meatspace.

When something of an extreme nature interrupts your technical conversation or train of thought in such a way that you totally forget what you were saying/doing.

example:
[some technical discussion with a coworker 1]
[coworker 2 interjects with some grossness just found on 4Chan]
[spontaneous vomiting event from you and coworker 1]
CW1: What were you saying?
Me: Can't remember, that [gross pic] just totally blew my stack

Slacker

Ironic reference to a hard working programmer, coined by the late great Tim Browse. Working on Starship Titanic it was not unusual to work 15-18 hour days for 6 or 7 days each week, with all nighters to punctuate the deathmarch. We began referring to ourselves as "Slackers" for not working the full 24/7.

Optimize the correctness right out of the code - Excessive application of optimizing code by hand which eventually results in broken code.

We all know programmers who spend far too much of their time trying to optimize methods by hand (eg, re-using variables to save stack space, moving too much code out of inner loops, etc.) rather than spending time getting the code to just plain work properly. It's a fact that at least 80% of code does not need optimizing, since it's run only once or less than 10% of the total CPU time of the program. Overly aggressive hand optimization also obfuscates the source code, making it unmaintainable.

Parkinson's Disease: I once worked on a team that had some code that had been written by a guy with the last name of Parkinson. This guy's code was so bad that the following conversation was often heard around the office.

Coder 1: Whatcha doing?

Coder 2: Trying to heal Parkinson's Disease in Module A.

Gorilla-patching

The mother of all monkey-patches. From a Ruby background; this just came up when a colleague was finding where was a method defined in the object hierarchy. As he couldn't find it quickly, he jokingly suggested to monkey patch everything into the Object class itself.

Ninja call:

A function call that doesn't call on the function you thought it was supposed to call on, giving either segfault or garbage data back.

Sucking Mud

Coined by my old boss, Rick Cline. Now retired, he started his programming career in 1959. Here's the entry I submitted to the Jargon File (aka The Hacker's Dictionary) in 1994.

(Applied Data Research) Crashed or wedged. Usually said of a machine that provides some service to a network, such as a file server. This Dallas regionalism derives from the East Texas oilfield lament, "Shut 'er down, Ma, she's a-suckin' mud". Often used as a query. "We are going to reconfigure the network, are you ready to suck mud?"

http://dictionary.reference.com/browse/sucking+mud

Collected Garbage Objects

Those classes that you first wrote when you prototyped the application, only to realize they were flawed in one regard or another. Maybe you still use some parts of them, or have moved them to one of those sad "deprecated" namespaces.

You know you should get rid of them, but sometimes, it's hard to let go...

Code Reuse - Not used in the normal sense of the term, but instead used to refer to parts of our old codebase that seemed to be constructed exclusively by use of copy / paste.

Non Breaking Change

In version control, a changeset that is strongly supposed to not break the build, e.g. fixing a typo in a comment.

If the build actually gets broken, you can skip through changes marked as "NBC" to quickly find the most recent actual (possibly-breaking) change, which is likely the culprit.

Ping Pong Development Methodology - Whack it hard until it doesn't bounce back.

LTTL

An abbreviation of the term 'a Little To The Left', came about when a micro-manager kept on shoulder surfing while we were developing a web application. He would constantly come around and ask us to move text a little to the left/right/up/down etc, while we were conecentrating on functionality. The term stuck and has taken flight.

It usually refers to something irrelevant to the current development cycle:

"Darryl came up with another LTTL: he wants the orange background changed to puce to see if it 'pops' more. Just get the report working first.."

Robocop Build

Ex: "That'll be in qRPSd v 2.Robocop" or "let me compile that with the --robocop flag quick"

Etymology: A small project I'm doing needs to have an initial version released by August. We then want to improve it by August 2011 to include features which are simply not feasible now. Feature request e-mails were always suffixed with "if you don't finish this by next August, robocop is going to break your legs!" and other Robocop related threats.

Scum Churning Queue

I pattern whereby items on a queue that fail get placed at the bottom so as not to block other items.

Squid

An inheritance hierarchy with a single root class (the head) with inordinately long chains of classes below it (the tentacles). This can occur due to long chains of interfaces, mixins, or components, especially for a project that doesn't need that level of abstraction. Or, you know, in the Java standard library.

Offshored Code

It meets the requirements, but was done by twenty people typing as quickly as possible without chatting with one another first, and because of that, is write-only code.

Normally, it wouldn't be on this list, but I used it (often) to describe the trainwreck that a few domestic developers wrote.

Copy-Paste Inheritance: this is both a code reuse pattern and anti-pattern.

It can both have a positive and a negative connotation, even to the same person. It depends wether the pattern is helping, or working against you.

Harv Features - I wish I coined this but it was somebody else at the company I was working for in 2008. During its start-up stages when the company's founder and CTO, Harvard Young, had free rein over their social network software he would often be enthusiastic in responding to client requests for small customization changes here and there. These changes would quite often be useless during a build-out for a different client, or at the worst, a hindrance to development or implementation work. We ended his practice with the implementation of strict software roadmaps, revision and quality control policies, but not before giving these oddballs the affectionate term "Harv features".

20/20 rule

When ever someone initializes an array incorrectly. Came about after a C programmer initialized a pointer array to spaces (ascii hex 20) then set that memory location Hex (2020) to a string which destroyed code. This code destroyed was in another programmers module. Since then we talk about the 20/20 rule

Joott - pronounced "JOOT". Acronym for "Just One Of Those Things" used to describe an observation of a system's behaviour that cannot be explained or is deemend insignificant and is therefore shrugged off.

I didn't invent this term. I picked it up from colleagues about a decade ago when working with multidisciplinary groups of engineers, software developers and technicians on large system integrations. There'd be so many loose ends during early days of integration that classifying an issue as a Joott was a way to put it off or forget it.

I'd like to think that once the big issues got resolved, what were Jootts in the early days of itegration did get looked at in the final days prior to shipping. Or maybe they just became the latent defects that second and third line support engineers would have to deal with months later ;)

I believe "banana banana banana" may have its origins in Douglas Adams's groundbreaking puzzle adventure game, "Starship Titanic". A certain non-player character (Deskbot if memory serves), when unable or unwilling to comprehend player queries, would respond once with the wisecrack "I'm just gonna say "banana" until you start making sense!" ... subsequent player queries it couldn't handle would be met with the response: "Banana. Baaaanana... Banana!"

Siamese an ugly method of attaching a section of code that is halfway flexible, API-like, OS-independent, allowing for generic replacements etc, and halfway grown-in, dehermetizing private variables, calling internal methods and generally binding the section in a very monolithic way (...you wanted to make it right, but halfway through you decided sharing a global variable instead of opening a socket will save you good 300 lines of code, and so the program can't compiled as a separate module any more).

A**hole Features

Features that are thought of during release planning that add little to no actual value to the software.

Quantum bug. Its a heisenbug ^[1] but I didn't think of that play on words ;)

Productionize - The act of stabilizing a system after the users have accepted it.

This is a common term used by executives where I work.

Usage:

"Just deliver the system, we can productionize it after they've accepted it"

Also used for project names as in:

ERP System Productionization

"Sorry, Sir" Bug

A bug caused by an externally developed API, tool or system that means you can't actually correct an issue. Even work-arounds haven't worked. You just have to live with it.

Horror-ble.

The program you made in Win32 a while back. You'd rather rewrite in C# than subject another programmer to its horror.

typedef struct tagHORROR { int unused; } HORROR;

#inclide

On a not-so-small C project, making a stupid and difficult to spot typo (or other dumb error) in a header file included in just about every compilation unit. Depending on your compiler settings, the results range from a single error message to hundreds. Depending on sleep levels, prevailing sanity, etc, time to fix can range from seconds to intervals best measured in multiples of the time it typically takes you to find your keys when you're already running late for something.

(For added word play, pronounce it to rhyme with "elide," because that's what your vision centres will do to the mistake when you look for it.)

Device Specific Issue

Issues that spring up in a mobile/WAP site, where the site renders perfectly fine on one handheld device and renders shabbily on another handheld device

Cheezing - Problems. As in when an application gives problems, its cheezing. Alternatively, if an application produces something that is problematic, that output is referred to as 'cheez'.

Eg:
Admin: The application ended inexplicably, and there's nothing in the log file.
Developer: That's a lot of cheez.

Palimpsest

Any part of a program that isn't used anymore, but got left behind, on purpose or accidentally, as a memory of an earlier time. For example, an API method that nobody uses anymore, but has to be kept for backwards compatibility. Or a function that, after refactoring, isn't actually called anywhere, but whose definition you forgot to delete.

Outside of programming, it refers to a text that was erased and overwritten with something else in order to reuse the parchment, but the original text can still be just made out.

Greaser hack, or in my own native language (swedish) "Raggarhack" - A piece of very badly written software.

This is a follow up to the earlier Higgs-Bugson ^[1] one.

Grand Programmed Theory (GPT) states that all project forces within the field of computer programming can be combined into one set of equations dictating any and all possible behavior. Those factors, the electromagnitized servers, weak programmer forces, and strong end user forces and the various effects of these force interactions consist of the GPT. Since the critical Higgs-Bugson particle’s existence has yet to be confirmed, the GPT still remains incomplete.

Humphrey Appleby

From the series Yes Minister/Prime Minister to describe a person who has a roundabout or exaggerated way of describing things that have gone wrong or have been implemented. For example:

When I say I am overstretched, I was of course talking in a sense of total cumulative loading taken globally, rather than in respect of certain individual and essentially anomalous responsibilities that, logically speaking, are not consonant or harmonious with the broad spectrum of intermeshing and inseparable function, and could indeed be said to place an excessive and supererogative burden on the office, where considered in relation to the comparatively exiguous advantages of their overall centralisation.

X-Coffee Report/Process - The X-Coffee Report/Process is a report or process created by a developer at some point in the company that is so slow and takes so long that you can measure the time it takes from initialization to completion in the number of cups of coffee you can retrieve, bring back to your cubicle, and drink to completion. Replace "X" with the number of coffee cups you think you could drink during the amount of time it takes to run, and select Report or Process based on whatever it is that you're kvetching about taking too long to finish.

Usage example: "Yeah, I heard there's a problem with our settlement reports. I sat there all afternoon waiting for it to process: it was a three coffee report."

PAIN - Plan All Incremental Needs - it will change and will need to be maintained - ease your PAIN. Documentation goes a long way in this regard. Document what you do like you will have to maintain and enhance it and ease your pain and that of others. What is YOUR pain level? If you don't document it, it does not exist. (HOW you ease your pain is up to you). How many times have you written some "quicky code" that still existed years later? Was it a PAIN to maintain?

procramming [proh-cram-ming] The process of preparing to clear a lab examination/internal by a student from Computer/Information Science Engineering by mugging up all the programs in the syllabus.

Yes. There is a university which lists programs in the syllabus, and procramming happens for real.

Commify merge a list of terms using commas.

So if the input is ["A", "B", "C"] the output is "A,B,C". I won't claim to have coined the term, but never heard of it until I joined this team.. and actually found it used as a method name.

DSV Dot-Separated-Values, a format similar to Comma-Separated-Values; I'll leave you to guess the difference. e.g.: Model.Child.Grandchild.And.So.On.Till.ALeaf !

Encryptified

Because it's more fun than saying "encrypted". From a fellow intern back in the college days.

Magic Number

A seemingly unusual and unexplained value that is used in a program and "makes it work".

H2IK Sequence

I first heard it on the TV show "Defying Gravity", but I adopted it.

When faced with a situation or problem that doesn't make sense, you run an "H2IK Sequence".

It means "Hell If I Know" and boils down to starting at the beginning and working the problem methodically to figure out what's wrong.

Went to/ Is in the woods - the action of a program crashing or locking up, usually by trying to dereference a dangling pointer or through a data race in a parallel application. (Originally in German , "Ist im Wald", but it translates quite fine)

Flock the Mocks / Flock Mocking - Using alot of mocks in a single test using a automated mocking framework like Moq or RhinoMocks and therefor create a test which is barely readable.

(Mocks as derived from Mockingbirds that flock in a single Unit Test)

Bug-date - when a critical bug-fix release isn't enough, you have to include lots of new updates and features; probably because your bug fixes just don't seem enough for the end user.

Using names of team members as past-tense verbs as in "I've been 'Hughed'" or "I've been 'Douged'" when you spend hours looking for the source of a problem and then realize who implemented it.

De-emulate

Coined yesterday. We resetted our system by going from non-emulated mode, to emulated mode, back to non-emulated mode.

(This had to do with motor control...)

Bake Cookie - Set/nd client a cookie

Dualton. Like singleton, except.. there's two.

(My head seems to have evicted the reason for why this was needed; I do recall it was horrible.)

Not exactly programming jargon, but it can help to communicate.

Haribo Look-And-Feel: specifically for the default Win XP theme (the one with the Teletubbies Background (you know, green grass and blue sky...)). But can be used for other "soft looking" UI experiences as well.

bug flipper - from joel on software ^[1]

Goose Chase

Or Wild-Goose Chase is usually related to investigating a very tricky bug with the following conditions:

• There are not enough clues and the area of the potential buggy code might be huge.
• It doesn't make any sense what could go wrong.
• The only approach might be just browse through lots of code to find a problem.

Summer of George Working on a project that the architectural decisions are so counter intuitive that we continuously say "summer of george"

double equal syndrome

When you either use '==' incorrectly, or when you don't use it at all when you should

Parmissions

Not a term of my own, but rather an inside joke of a class I took. My professor would stumble words quite a bit, and there was a section on setting security permissions on disk partitions. The class got a laugh out of it, and anything from then on dealing with "partition permissions" was replaced with "parmissions."

Kuzmich - code written just to get around a bug in a very specific situation enabled by the key in the settings.

Twenty-thousand-foot fire drill

I didn't invent it--it was a popular term at my last place of work. Refers to a really big project that is really far behind schedule and has a deliverable due tomorrow.

It is a conflation of two phrases that one of our partners liked to use: "Just give me the twenty-thousand foot overview," (meaning give me the big picture, but spare the details), and "We're in a fire drill" (meaning we're on charrette to meet a deadline).

Gurjeet Code

We had this software engineer who was fond of writing code by copy, paste, and modify, and would maintain all copies. He also used strings as enums. Then he left.

Now everytime we run into copy paste and modify we call it Gurjeet code in annoyance.

Gold Plating -- Joel Splosky in Make Better Software - Schedules ^[1]

It means adding features that are unimportant (as little as to be useless).

I haven't seen it here yet, and I'm sure that many people think that they coined this, but I independently came up with "to play captain obvious" as a dubugging technique. In CS 1, when you have a missing semicolon, or whatever, if you haven't found it in 20 minutes, you're not going to find it. But your friend, looking at the code for 30 seconds will see it immediately.

In college I actually had a friend make a super-hero style cape, and sometimes (usually really late at night) when asked to play captain obvious we'd duck behind the desk, put on the cape and fly to the rescue (With the help of rolly chairs)

ROM (Request/Response Object Model) Used for Web Application. Coined By zigmoyd.net An Adapter Applied on HTTP request Parameters to access them safely in an Object Oriented Way

BāngKshetrā a Special type of Distributed Blackboard Implemented for Self Communicating Adaptive Website.

Bāng Partial/Complete Solution Container.

BāngKnetrā Observer on the Blackboard

These are inspired by the Blackboard System. It is being implemented in Web Application in a generalized way.

Stolen source

After Windows NT 4.0 and Windows 2000 source code was leaked, I use to say that Windows is a stolen source operating system.

Spaguetti code

When you look at others works for hours and don't understand anything because is too mess up.