Programmer jargon — a few programming slang words that you should know when working with a technology company
Jargon programming terms for ideas, communication and product flow with PMs, management and the client
Duck
Duck is functionality added for the sole purpose of drawing attention to product management, which is later to be removed, avoiding unnecessary other changes to the product.
In other words, Ducks are “ideas for ideas” created by PMs who really wanted to show that they are needed and they contribute something to the product.
Fear-Driven Development
Fear-Driven Development is a term for such product management which introduces as much fear and panic as possible. Sudden layoffs, shifting deadlines to earlier dates, reducing human resources — Fear-Driven Development is, in other words, management by pressure.
Featuritis
Featuritis, also often called creeping featurism, is a tendency to add tons of new functionalities with each product release.
As a consequence, featuritis makes the final product so overloaded that the user starting his adventure with the product may seriously get scared, and certainly not be able to embrace them all. Only a small group of users who have been using the product for a long time and have regularly updated their knowledge about new doses of functionalities, can use the product properly.
Protoduction
Protoduction is a combination of the words prototype + production and means a prototype that finally went into production.
Satisficing
Satisficing is the equivalent of the well-known “good enough” and refers to solutions that are not the most ambitious or the best, but are good enough to solve the problem and cost less human and time resources.
Jargon programming terms for errors (bugs!)
Common Law Feature
The Common Law Feature is a type of bug that has existed in the system for so long that it has become an integral part of it. Nobody expects to fix it anymore, and the Customer Service Department just patiently explains to users that sometimes it happens and suggests a different way.
Heisenbug
Heisenbug is a program bug that changes its characteristics, giving new results every now and then, or disappears completely when we try to look at it.
The term derives from Heisenberg’s uncertainty principle, also sometimes called the uncertainty principle. In a nutshell, it speaks of the existence of pairs of such quantities that cannot be measured simultaneously with great accuracy, because increasing the accuracy of one measurement reduces the accuracy of the measurement of the other.
Higgs Bugson
Higgs Bugson is quite a specific and mysterious kind of hypothetical bug. Predicted based on a small number of event log entries and imprecise user reports. It is said to be hypothetical because it is extremely difficult to recreate in practice, and sometimes even at all. After all, you never know if the bug is really there or not, and if it is, what causes it.
The name of the error comes from the Higgs boson — a legendary elementary particle that theoretically should have existed, but for decades it could not be physically found (It was! It was finally proven to exist in 2012).
Hindenbug
Hindenbug is a really heavy bug that destroys your data, cripples your system or even crashes it completely.
The term for this bug comes from the crash of the German airship LZ-129 “Hindenburg”, which burned down while mooring at the airport in ’37. The airship literally burst into flames within seconds and collapsed. The Hindenburg disaster put an end to the use of airships to transport passengers for tourism.
Hydra
Hydra is a type of bug that causes two new bugs when you try to fix it. Just like cutting off the head of the mythological Hydra, it did not kill the monster but caused two new ones to appear in place of the severed head.
The code in the form of Hydra cannot be repaired. You have to rewrite it.
Loch Ness
Loch Ness Error is a bug that has appeared once and has never been seen again. Namely — it is impossible to re-trigger the error, so it cannot be fixed.
Mad Girlfriend Bug
The Mad Girlfriend Bug is the kind of bug you see with your own eyes, but the system tells you that everything is fine. Just like in a stereotype: when a woman tells you that everything is fine, know that nothing is fine!
Slang programming terms for bug reports
Drug Report
Drug Report is a user report written in such a vague, incomprehensible way that the author must have smoked crack.
Chug Report
Chug Report is a lighter version of Drug Report — still incomprehensible and weirdly written. The author of the report may not have smoked coca, but he must have had a few glasses of alcohol.
Shrug Report
Shrug Report is a bug report that doesn’t show much. From this report, the developer learns that something is not working, but the problem description does not describe the situation. It is not known what exactly happened where and how.
Smug Report
Smug Report is a user bug report that contains many of irrelevant details, self-styled feedback, bug fix suggestions, and is relatively comprehensive. Since all user’s guesses are always wrong, smug report is treated as a relatively annoying report from someone who thinks they know more than he actually knows.
Jargon programming terms for coding, functionalities, etc.
Brute Force
Brute Force is a programming style that is effective, but very slow and non-finite. It relies on pure computing power (we count everything sequentially, without any algorithms improving performance).
DDD (Butt Debugging)
DDD, Ass Debugging, Ass Driven Development — a common way to find a bug. You paste the word “ass” into the code / alert / console (although of course it can be any other word) and check if it appears on the screen. Not recommended, mainly due to the fact that it can be accidentally put into production ;)
Hooker Code
Hooker Code is a code that introduces instability in the application (e.g. causes it to close).
- Is the page down again? Is that Hooker Code still there?
Jenga Code
Jenga Code is a piece of code which, when removed, completely crashes the program. As in Jenga — remove the key brick and suddenly the whole building falls apart.
Jimmy
Jimmy is a term for a new, newly minted programmer or, more generally, a helpless person.
For example, while working on a new project, we can say:
What if Jimmy forgets to update the code?
Megamoth
Megamoth is an abbreviation of MEGA MOnolithic meTHod. Most often, it is defined as some fundamental, mega-complex method that stretches through at least two screens.
Warning! Megamoths larger than 2k LOCs are hovering over the city!
Ninja Comments
Ninja Comments is a term for comments in the code that are buried, invisible, or not there at all.
Reality 101 Failure
Reality 101 Failure is a program functionality that does exactly what it was asked for, but after implementation it turns out that the original problem was completely misunderstood and the functionality is therefore useless. It does not solve the problem in any way.
Refuctoring
Refuctoring — taking a piece of clean and good code into the programming paws, and by gradually introducing small, irreversible changes, making it impossible for anyone else to grasp it.
Rubberducking
Rubberducking, or talking with a rubber duck, is a term for such a meeting when one person talks about a problem and asks questions, while the other person basically adds nothing to the topic. Ultimately, you go out on your own to answer your own doubts. It’s as if you are talking to a rubber duck next to your monitor (if you have one, of course).
Unicorn
Unicorny, or unicorn, is an adjective sometimes used to refer to functionality and system changes that are still at very early stages of development (not yet specified or described) and might as well be made up / not exist.
Yoda Conditions
Yoda Conditions is, as you can easily guess, writing in the code of conditions in a Yoda style pivot pattern.
Ruler example in Yoda terms:
the sky is blue (‘blue’ === sky)
When it should read:
the sky is blue (sky === ‘blue’)
Other devs slang terms
(not necessarily from the jargon, because these expressions exist, but hardly anyone knows what they mean from outside the tech world)
Tuple
A tuple is a record in the database or one of the data types (e.g. tuple in Python).
Alpha and Beta version
The Alpha version of the product is a very preliminary version of the product that does not contain all planned functionalities. Usually, only internal users of a given company have access to it.
The Beta version, also known as the Beta test, is the last test version of a given product, the key to its development. It is then that the product is made available to external users — it undergoes the final test in a real environment.
