Mine was 'normalise' (a long time ago, thanks!). The light that went on at that moment lit up the entire world of databases-as-something-other-than-a-big-file.

I don't think the second two are $5 words, they're pretty common. Idempotent is a great one, though. Another one I like is reify: to make something abstract concrete or real. So in programming, you might have something abstract like the intermediate state of a search algorithm. When you make an object that perfectly encapsulates that state, you've reified it.

"Normalisation" would be one for me. It expresses the Don't Repeat Yourself ethic in terms of minimising the number of copies of data, and instead articulating relationships between the data.

How about "instantiate" :)

So these are five dollar words...now you know..

Mine is Orthogonality, i first read about it in the Pragmatic Programmer book ;)

I do love things connected to maths!

"Naming"

https://en.wikibooks.org/wiki/Naming/How_to_name_a_concept

My big one was "Canonicalization". Which simply means removing duplication and creating one unique representation of an object or piece of data.

https://en.wikipedia.org/wiki/Canonicalization

Canonical - the canonical method recognized, authoritative, authorized, accepted, sanctioned, approved, established, orthodox. antonym unorthodox.

the only aha moment i had was when I found the definition for what it meant - in the context its always used in: examples of doing things the right way.

My favourite five dollar word has to be 'sucky sucky'

"Contiguous"

I think mine is "covariance," discovered when I was looking for an explanation of why casting from List<T> to List<U> where T is a subclass of U doesn't work as I had naively expected in C#. Apparently something like this is in the works for C# 4.0, though.

Speaking of Eric Lippert, he had a whole series about this: https://blogs.msdn.com/ericlippert/archive/2007/10/16/covariance-and-contravariance-in-c-part-one.aspx

It was Classes for me :->
https://en.wikipedia.org/wiki/Class_(computer_science)

I'll go with "SOLID", though the nitpickers may either dock me for choosing an acronym and say this is a $1 word, or perhaps applaud the choice and credit me for $25. Regardless, you can't go wrong following these guidelines.

https://butunclebob.com/ArticleS.UncleBob.PrinciplesOfOod and see also the SOLID Screencasts at https://unhandled-exceptions.com/blog/

Mine are the four words that make up the ACID acronym - Atomicity, Consistency, Isolation, Durability.

I'm with BobF - it had to be "Objects" ... I remember being completely clueless and struggling through Basic, C, Turbo Pascal, C++ ... and then discovering "Object" magazine at the local newsstand. It took me 2 years of reading before I really "got it."

My suggestion is deprecation, deprecate or any of the variations. Usefully but try to use it in a meeting; they could of used obsolete and made it easier for managers.

My favorite $5 concept is atomic. An atomic operation can not be interrupted and left partially complete by other concurrent operations, it either completely succeeds or completely fails. Its mostly important at the lower layers of the system, at higher layers the operations become so large and complex that you use locking or other mutual exclusion techniques.

My favourite one is SEMANTIC. It pops up everywhere and makes me really think about what I want to do with the code I'm writing

Two of them. They are even pretty common.
"Indirection" and "abstraction".

These are so fundamental, so powerful, so common.
But there's a common level of programmer who doesn't know either.. and those are doomed to remain scriptmonkeys forever.

I'd have to go with "Mission Critical" (yes, I know it's two words) or, even more impressively, "Enterprise."

I actually used the words "domain" and "range" yesterday, discussing a web service that accepted and returned xml in a certain format. A web service is a *function*.

"overspend"

monotonic - values must be monotonically increasing
hysteresis/equilibrium - feedback loop to manage data queue depth
reentrant - not quite the same as thread-safe

I?m not sure if I understand the first definition of idempotent. Are you saying that if foo is a function, then x is idempotent under foo if

x == foo(x)?

After some brief searching I?ve not been able to find any other source that defines idempotent this way. (Not saying that this isn?t a valid definition, but it doesn?t seem to be standard).

Is it possible this definition is being confused with that of an idempotent element of a binary operation bar,

x == bar(x,x)?

Jeff:
your interpretation of "idempotent" conflicts with the quote you used to describe it.

the quote says: f(x) = f(f(x))

you equated idempotence with the value of a function depending only on its inputs ("functional").

Thanks for the words, I have to admit I hadn't heard of the first two and the third I only had references from reading large novels as a kid. If I can, I'd like to add a vote for abstraction as a $5 word, mostly because it takes a lot of people a while to actually "get" it. Just like pointers. Which I could add but it's such a basic concept, even if it does take some years to actually figure it out.

Mine was Bikeshedding

My answer would have to be "functor" in the mathematical sense. Simple, straightforward, two laws, millions of instances of them.

Reference (or pointer) - The thing you're changing is not a real value, it's actually the value of some other thing, which could also be a reference to something else.

@Mark 'Mission Critical' and 'Enterprise' are more like $500,000 or $5M words because nothing that costs 'only' 5 bucks can be worthy of the 'Enterprise' ;).

Referential Transparency (a 10 dollar phrase?). It means that an expression can be replaced with its value and the program won't change. Purely functional languages are referentially transparent since there are no side affects and anytime you call a function you'll get the same result. Wikipedia has some exammples.

For me its "race condition". From wikipedia:

A race condition or race hazard is a flaw in a system or process whereby the output and/or result of the process is unexpectedly and critically dependent on the sequence or timing of other events. The term originates with the idea of two signals racing each other to influence the output first.

Favorite words -

Structured - as in structured programming
Function - as in not a subroutine
Encapsulate
Abstraction

Can anyone give an example of a context in which "orthogonal" could NOT, without loss of meaning, be replaced with "independent" ?

Seriously? You link to another of your posts about him instead of to his blog? Oh the hilarity when you mention him again and link to this post.

I like coalesce.

"inculcate"

?verb (used with object), -cat&#8901;ed, -cat&#8901;ing.
1. to implant by *repeated statement* or admonition; teach persistently and earnestly (usually followed by upon or in):

"to inculcate [coding standards] in the young."

You'll find that many classic Don Box writings will use these $5 words, many times, often in the same sentence.

"sesquipedalian"!

Example:
float getShippingValueAfterCalculatingRateThatInfluencesProductPlusSomeOtherRandomWords(Product product);

See, rather keep the method name a bit smaller, still communicating intent, and put the rest in the code comments.

And I consider us bloggers "deipnosophists of the wild wild web" ;-)

"Coupling" as in "loose coupling". I've been avoiding tight coupling ever since I first heard the expression years ago and it's saved me many, many times.

"Code smell", while not exactly a $5 term, communicates quite a bit with very little.

Meh. Words are useless unless they're obvious to *everyone* what they mean. And "Idempotent" is certainly not obvious.

So in a comment you'd have to write:

//This function is idempotent (i.e. it returns the same value if you feed run it multiple times)

''(or whatever it means)''

which means that this word is more of a barrier than anything.

For me the word was "Inherit". The opened a whole new world for me.

As for Idempotent, consider this sequence:

x = foo(bar)
y = foo(bar)

Now, if x and y are equal, foo() is idempotent.

I think there might also be something with global state in the definition, but I can't work out exactly how that can fit in. (Taking the example of a cache, if no global state changing across the call is a requirement to be idempotent, then a function that might fetch a result from cache or fetch from remote server is never idempotent, because it'd implicitly be updating the cache with the fetched value if it was not in cache.)

To me, 'refactoring' fits the bill. It seems like such an invented word. Re-Factoring. When was it factored in the first place? The code was never FACTORED - it was WRITTEN.

@Steve and Chris:

I agree - I thought the same thing.

@Jeff

I think an example would be:

a = foo(x)
b = foo(x)

a == b ALWAYS

I feel like i?m in my math class!!

Idempotent is used all over the HTTP spec. It's the biggest difference between an HTTP GET and an HTTP POST request; a GET request should be idempotent, but a POST request might not be. If you follow this, you will usually not break the back button.

Arity - https://en.wikipedia.org/wiki/Arity
Atomic - (not the bomb kind)
Interpolation - https://en.wikipedia.org/wiki/Interpolation
Sigil - https://en.wikipedia.org/wiki/Sigil_(computer_programming)
Autovivify - https://en.wikipedia.org/wiki/Autovivify

@niels

That's the definition of Deterministic, not Idempotent.

Idempotent means:
f(x) = f(f(x))

One that comes to mind is "invariant."

Involution, least fixed point and coinduction are nice words.

polymorphism

The example of caching functions wrt idempotence is not very useful, because what you call "functions" here are really procedures with a side effect. In mathematics (and functional programming), "function" means something else entirely. Therefore, calling this constant behavior "idempotence" is a bit misleading, and not very useful IMO.

A better example of idempotence would be:

&#119891;&#8336;: x &#8614; x % a

where "%" is the modulo. Example: 25 mod 10 is 5, and 5 mod 10 is 5.

Another non mathematical example would be a function FQDN which would return the canonical, fully-qualified domain name, given a name. Or one that returns the capitalized version of the input string.

Oh, and Scaffolding

That is NOT idempotent. Idempotent is from the database world and just means that you have the same results IN A DATABASE if you repeat the operation. The standard example is a withdrawal from a bank account (or credit card charge, etc.) You only want the balance to be debited once even if the action is submitted multiple times. That is, the CONSEQUENCES of the action are the same, not the return value of the function. It's easy to see how you could be confused if you don't have the right context for the description.

You can generalize this to identical consequences in any stateful system. That's where the HTTP definition comes in. They're saying that you should get the same results no matter how many times you do a GET, e.g., if you're submitting a request for your bank account balance. If you want to change something, e.g., you're transferring money between accounts, you should use a POST.

x = f(x) is "identity."

For me, although quite recent, it would be all the words associated to Functionnal Programming :

Curryification, closure, immutability

although closures are not inherent to FP, it took me quite a while to grasp the concept, wich is pretty simple when it finally 'clicks', hence the AHA moment. I'm not a .net guy but i remember they were added to C# quite some time ago.

V.Good link about closures, in javascript, which is good because most people can understand the syntax : https://blog.morrisjohns.com/javascript_closures_for_dummies

Immutability is a big one. I watched at the FP crowd like if they were crazy for a long time, i mean, what's the use of an immutable variable.

This one is beginning to click for me, i'm in the middle of an AHA moment :)

These aren't quite as fancy as some of the examples above, but I always thought Verification and Validation were fun ones since it's easy to switch the meanings or forget the difference. (Vaguely: Verification is "Does it do what the requirements say?" and Validation is "Does it do what the user wanted?")

https://en.wikipedia.org/wiki/Verification_and_Validation_(software)

I just took my Sun Certified Java Programmer exam. "Covariant", "cohesiveness" and "coupling" stood out quite prominently in the study guide for the examination.

Eric Lippert's blog entry is a little confusing because it gives one of the mathematical definitions of an idempotent function without explaining how that relates to the typical computer science definition of the term (i.e. from Wikipedia "In computer science, the term idempotent is used to describe methods or subroutine calls that can safely be called multiple times").

To help make things more clear think of it this way. Any operation you call in a computer program operates on an environment (the "state" of the program, i.e. values of local, global, and system variables). If you think of an operation as a function f, and the current state of the environment as x, then any operation can be written as x1 = f(x), where x1 is the new state of the environment after the call. For idempotent operations, calling a method once may change the environment somehow, x1 = f(x), but calling it a second time should produce the same result, x1 = f(f(x)) and thus f(x) = f(f(x)). To give an example, suppose we have an operation that adds two parameters and assigns them to the third parameter:

AddValues(x, y): x + y

And we call this operation twice:
z = AddValues(x, y)
z = AddValues(x, y)

it's idempotent, because the environment is the same after the first call as it is after the second call. Now, suppose we have an operation that adds values to a global accumulator.

AddToAcc(x): acc <= acc + x

And we call it twice:

AddToAcc(x)
AddToAcc(x)

it's not idempotent, because the environment is different after the first call than it is after the second call. In other words f(x) != f(f(x))

wait, I thought "understanding and eventual mastery" was "yak shaving"?
https://en.wiktionary.org/wiki/yak_shaving

I once tried to use the word "concatenate" in a history paper. My prof wrote in the margin something about not making up words.

People, most of these (canonical, coupling, invariant) have the same definition in other disciplines, so they're not software specific. Try learning something outside of your programming bubble!

1) Closure - Which I found very useful in JavaScript
2) Polymorphism - Basic Object Oriented Programming
3) Pointer/Reference - 'Nuff Said
4) Buggered - Technical term for describing the state of any given development project :)

It's interesting that all three of your $5 words have to do with resistance to change.

Immutable: can't change, period;
Idempotent: can't change after the first iteration (for a given input);
Orthogonal: can't be changed by the other quantity.

Knowing what is and isn't subject to change is of enormous benefit to the programmer. Const, final, invariant, value objects, and the like make our jobs easier because once established, we know what they've got. On the other hand, if everything were constant, programming would be impossible. Interesting software happens on the shore; one foot on solid dry immutable sand and one in wet uncontrolled chaos.

Like Serge, mine is "Orthogonality" which I picked up reading Pragmatic Programmer.

Ha: A colleague of mine says "orthogonal" all the time.

Words from set theory also come up frequently: Superset, subset, union, intersection.

If you're refactoring two functions to share some code, you find the intersection of code between them. If you are combining two products together into one, it will have the union of the two feature sets.

Concatenation - I know it's not a new word, and probably pretty common in everyday programmer-speak. But it's always seemed like an awfully complex (and hard to say) word for such a simple idea.

chris,

(a) What the hell are you talking about?

(b) Why don't you educate us with your educated suggestions?

"ephemeral" - enduring a very short time;

The classis use is an "ephemeral port", which is what you get when you don't specify a port to use for outbound network connections. The OS assigns an ephemeral port to use.

I would like to pile on here, in the idempotent-versus-deterministic train of thought: ABS() is both idempotent and deterministic, SQRT is deterministic but not idempotent. In the grand scheme of (caching) things, idempotent is rather unimportant and uninteresting IMO, deterministic is critical. Eric Lippert's examples of idempotency in https://blogs.msdn.com/ericlippert/archive/2005/10/26/483900.aspx don't really talk about function return values, but discuss side effects. Idempotent means "return the same output value for nested calls", not "I'm only going to do this once per execution context". That's not deterministic either: deterministic returning the same value given the same input. Even extended to non-return values, "doing something once" is vastly different from "doing the same thing". Five Dollar Words rarely help, especially when they are incorrectly used. And now I've used a whole buncha fifty-cent words to confuse everyone :)

this blog is such a waste of mental powers. i'm already regretting the two posts i made. i always regret reading this blog when i do, because the topics are nothing more than rehashing old topics.

this isn't blogging.

Connascence

https://docs.rubyrake.org/articles/connascence/index.html

Carl has described those there, succinctly.

"Idempotent" is often misused, or used to say "I use big words, poorly." Here's a good example of two functions that can be run once, twice, as many times as you want, and you'll get the same results the first the and the fiftieth:
f(x) = 1 * x (Note that applying f fifty times gives the same as f(x).)
or,
g(x) = 0 * x
Note that "g" is the most generate and trivial) example; "f" is fairly trivial.

Or'ing in the bit 0x1 is idempotent; it'll stay on, no matter how many times you OR in that bit. (exclusive-OR of that bit is, well, not idempotent.)

My terms are often phrases:
(1) "one-to-one correspondence, a.k.a. bijection." (The concept underlies a number of hash and database needs.)
(2) "mutually exclusive." (Simple, but is all around us. "Orthogonal" means "absolutely unrelated" and "mutually exclusive" includes "so intertwined in effects that you cannot have both" - which nearly opposite to orthogonal in some ways.)
(3) "relatively prime" (integers with no common factors, are relatively prime. 7 and 22 are relatively prime, so that you can do things with the two numbers as a pair that you might normally do only with a prime number and any-ol' other number, such as generating all the possible buckets in a hash table in one cycle through the list.) Prime numbers and relatively-prime pairs can get you into the part of Math called "group theory", which is what guarantees the working of about every hash algorithm in existence.
(4) "typeface" versus "font family". (Not only does it distinguish the people who do layout and the old prepress work, but leads you to start putting together documents that stick within 1-2 font families -- as opposed to just grabbing pretty typefaces -- and end up with a more professional look.

@[d3m0n], jargon is useful within a subgroup. It allows precise meaning to be transmitted with little effort (the little effort is the key). Compare the phrase "Those two things are the same." to "Those two things are isomorphic." Both phrases have roughly the same meaning, but isomorphic tells the person who knows what it means how they are the same. Idempotent is similar in its power to transmit information.

Jargon is one of the reasons you generally require training to enter a field. Common English by itself is too imprecise for deep discussions.

@[d3m0n]

Your nick and attitude imply that you consider yourself "elite" but as usual the comment betrays a lack of experience.

A word like idempotent not only carries deep meaning, but is an interesting enough word to make someone WANT to understand it. Not to mention you shouldn't need to put "idempotent" in comments; you need only understand and adhere to the principle when writing your code. If you are still documenting what your code does instead of letting it express itself and then documenting the why, you have a long way to go.

I bet you despise the term "enterprise," too...

@Frank
Refactoring is called refactoring because you are breaking the code down to its individual components (like factoring 12 down to 2, 2, and 3), rearranging these components (3, 2, and 2), and then expanding them back into a program that produces the same answer. Ensuring that the same answer occurs during refactoring is why testing is so important to refactoring. I am annoyed by people who use refactoring to mean rewriting (cleaning up the code, but also changing the answer).

I don't know why, but when I first started coding it took me awhile to grok "implicit" vs "explicit". Lots and lots of other coding puzzle pieces clicked together for me when the difference finally penetrated my cranium.

Idempotent is always a good one, and is also a word any good web developer should know. :-)

Also, I don't know if it's necessarily a $5 word, but "technical debt" is a term I love to use.

Refactoring. Although now it seems like the most common programming word around. When I first heard the word refactor it made so much sense. There was a word for what I had been doing all this time.

One of my favorites, that I got from "Godel, Escher, and Bach", is isomorphic[1]. A set is isomorphic to another if is it is both one-to-one[2] and onto[3]. For instance, S-expressions[4] are isomorphic to XML[5]. When I realized this, XML finally started making sense to me. Prior to the realization, I had thought of XML as a handy, if verbose, file format that was readable by humans. After the realization, I started to see all of the ways XML could be used: data structures, DSLs[6], etc.

1. https://en.wikipedia.org/wiki/Isomorphic
2. https://en.wikipedia.org/wiki/One-to-one
3. https://en.wikipedia.org/wiki/Onto
4. https://en.wikipedia.org/wiki/S-expression
5. https://en.wikipedia.org/wiki/XML
6. https://en.wikipedia.org/wiki/Domain-specific_language

Nomenclature (Nothing to do with gnomes)

https://en.wikipedia.org/wiki/Nomenclature

Basically using the big fancy words that experts use instead of laymens terms.

i.e. "My two front teeth" instead of "My two maxillary incisors"

I actually am not a big fan of "five dollar words".

Not because they aren't useful, but because I find they are used less often to describe programming terms, and more often to try and confuse the muggles among us.

Once you get used to using more technical words to describe what you're doing, it becomes difficult to explain technical concepts to people who don't understand the nomenclature.

Also: erinaceous

@Frank Wilhoit - "Can anyone give an example of a context in which "orthogonal" could NOT, without loss of meaning, be replaced with "independent" ?"

How about when discussing orthogonal vectors? If I remember my math correctly, orthogonal roughly translates as "perpendicular", or "at 90 degrees to each other"; there's probably a bit more to it than that, but I don't recall the details.

Deprecated is big on my list, simply due to the fact that it is constantly being substituted by 'Depreciated', which is incorrect, but is also easy to see why.

Dictionary.com says:

"Depreciate: to decline in value"

Which is what you intend, right? Your old code no longer applies since it has been replaced with newer, more efficient code. In this context, it speaks to the quality of the code.

Meanwhile, Deprecate reads:

"Deprecate: to express earnest disapproval of"

Notice that this definition is not a reflection of the code quality, but in fact, your stance on that code. It may be the greatest code in the world, or the worst; this is irrelevant. The point of the term is that you, the developer, are making a statement of how that code should be handled by other programmers.

The wikipedia clears it up:

'software features that are superseded and should be avoided'

They may still have some functionality that is appropriate for your application, but you are making a statement about how other developers should treat it...as opposed to describing the actual code itself (and its value).

Wow, that was a huge nerd post for this early hour of the day.

@[d3m0n], I forgot to add that they also act as shibboleths[1] (another great five dollar word). Many see shibboleths as a bad thing because they are often used in an exclusionary way, but I try to use shibboleths in a good way. I use them to see if someone is already a member of my subgroup. If they aren't then I know that I have to expand my jargon terms into more accessible forms. The shibboleth isn't bad in and of itself, it is how you react to the person passing/failing the test that is good or bad.

1. https://en.wikipedia.org/wiki/Shibboleth

Cruft

@Chas.Owens - I was dreading Discrete Math, but it turned out to be the best/most fun math class I ever took. All of the graphing theory and set theory really cleared up a lot of things. When you have a concise set of vocabularies to describe very specific relationships,it becomes a lot easier to understand those relationships. That class was nothing but $5 words......

FWIW: GEB is one of my all time favorite books.

Another $5 word making the rounds these days, "Ontology"

@Dave

erinaceous? of, pertaining to, or resembling a hedgehog? I am afraid to ask what field you work in that you find that a useful word to have on tap.

I'm idempotent, you insensitive clods.

"brevity"

A good example of a non-trivial idempotent function is set insertion or deletion.

If you start with an empty set {} and then insert 1 into it, you get the set {1}

If you take the set {1} and then insert 1 into it again, you get the result {1} again.

So the set-insertion function is idempotent.

Here 's a 5$ word that language nerds should know:

homoiconic - when describing a programming language, means that the primary representation of programs is also a data structure in a primitive type of the language itself.

I have found that me knowing a specific word with the context and nuance it brings does not guarantee my counterparty knowing the word. Even more so in international organisations where English is often a second language.

It is more a of a skill when you know a word, say it, and then proceed to concisely explain its meaning.

When peers were reviewing my code, I heard this word a lot: "dubyatief". After learning that it was "WTF" and what it meant, I've downgraded it from a 5-dollar word to only 2 cents.

Bifurcation, or for those of you that don't like binary trees, try
trifurcation...

NP-complete works everytime.

When I finally learned what a *Closure* was, that blew my mind. It makes code much more expressive and power... it also made me hate Java for not supporting them ;)

On the other end, we have useless marketing terms like "ajax," that sales people use to try and sell junk software to business people.

1.) Closures. Like a couple others, this was a big "aha" moment for me. Once I understood closures, languages like Ruby and JavaScript suddenly opened up to a whole new dimension. Event handling and callbacks in JavaScript becomes much more concise when you know how to use a closure. My favorite article that describes closures is by Paul Graham: https://www.paulgraham.com/icad.html and is the section about accumulators (Appendix: Power). That section helped me have the "aha" moment.

2.) Duck typing. I don't really have a link, so.... https://en.wikipedia.org/wiki/DuckTyping (aaaah, Wikipedia... the default reference link). I learned closures and dynamic languages at the same time, and to this day I feel duck typing makes closures significantly more expressive and useful. I've seen the closures proposals for Java... as much as I would love to be able to use closures in Java, they are just so verbose and clunky compared to the dynamic language counterparts (at least in my opinion).

@irrelivant

"brevity"

pure brilliance.

Mine is 'fuck'!

I use it a lot whilst programming.

"Invariant", especially when prefixed by "class" or "loop".

Also the less well-known "variant". A loop variant is the expression which changes value on each iteration of the loop. If nothing changes, you have an infinite loop. Expressing variants explicitly can help prove that a loop does in fact terminate, and checking variants at runtime can help detect bugs that hang (as opposed to core-dump).

I first encounted these ideas in an early book on the Eiffel programming language.

A word that came up for me this week is "sargable."

It applies to a SQL query condition that can take advantage of an index to speed up the query.

Red Herring - describes an all-too-common experience when debugging, but once you discover something is a red herring, you've vastly increased your understanding of the problem.

Now this is *popular* content. Thanks :)

Mine is "Patterns"

They wont say method, system, methodology, practice, procedure, tactic or strategy. They wont state the problem of managing the software in simple words. They'll "invent a new pattern" and market it as the direct path to Nirvana.

But once the word was familiar, it was mundane and obvious. But I hated the class divide when the guys knew something great if they knew what a pattern was. Then i found out.

Very interesting, but you must know some math to do it right.

"catamorphism"

Obviously, one word uncommon in software development circles - but very valuable - is "education"

*All* those "five-dollar-words" are part of decent education in computer science. Yes, I understand not all of us have a degree - but if you're serious about your craft, you should at the very least take a look at all the publicly available classes from Stanford and MIT.

Seriously - it will make your live *much* better.

I'm a code monkey writing spaghetti applications!! And I admit it!! What can I do about it? Nothing, or else I should switch jobs. At least I get paid for putting in lines of code in a spaghetti app...
Could be worse. I despise those architect astronauts who get paid astronomical amounts of money and put in little actual value in code, fuck them hippocritical bastards!!!

Metacircularity!

Metacompilation/metacompilar. Sorry, I'm a Forth dude. :-)

Extensibility. We (the functional world, mostly) are still waiting for our unenlightnened brothers to catch up. :-) Then again, extensibility is exactly what many DO NOT want, so I not betting on that one.

But, to be honest, I have this very old book about Programming Languages. It's full of concepts -- such as orthogonality -- on which languages can be evaluated. I'm sure there's still such books around, if only because it's basic material for any theoretical computer language design course. At any rate, these concepts where usually expressed as a single word, and they were ALL 5-dollar words.

So, if you like such stuff, do try to find a computer languages theory book.

Despite the fact that I've now used almost every 5-dollar word mentioned here, I *loathe* programming jargon.

Most of it is either made-up nonsense or an unfortunate holdover from a time when a bunch of pimply adolescents needed to be convinced of their own intellectual superiority.

Does "regular expressions" really convey anything to any non-mathematician at first blush? Would it kill anyone to say "symbolic string substitution" so you could at least get a clue as to what the topic was about?

"Byte" is cute, but "8-bit data chunk," though longer, is clear.

And of course, the forest of unexplained TLAs (Three letter acronyms) infesting the industry just makes me want to *slap* someone silly and tell them to grow up.

I'm a fan of "isomorphic" as well :) It's a fancy way of saying, "these two things are basically the same. It doesn't matter which one you choose." I used the word "colinear" in a meeting the other week (then again I do a lot of UI/graphics work).

"Coalesce" is a good one. <a href="https://en.wiktionary.org/wiki/coalesce">https://en.wiktionary.org/wiki/coalesce</a>; . It comes up in C# with the ?? operator, and also a lot in computer graphics. For example, if I am rasterizing the interior of a polygon (essentially, a function from Point[] -> Int32Rect[] which approximates its interior for a given transformation), my outer loop goes by 1 pixel on the Y axis. I'd rather emit a rectangle that's 10 pixels tall than emit 10 rectangles that are 1 pixel tall (all with the same X left/right coordinates). It's basically run-length encoding of data in order to unroll data-driven loops, and conserve memory. This is very important when sending those rectangles to, e.g., GDI, because the performance is very sensitive to the number of GDI function calls you make. One call to draw a very tall rectangle is substantially cheaper than many calls to draw smaller rectangles that visually result in the same pixels on-screen.

A lot of the work I've been doing lately has centered around functional, asynchronous, and concurrent programming, as well as graph theory, so the related nomenclature has been prevalent for me.

Understanding the meanings of and relationships between closures, first-class and higher-order functions (and partial derivatives!), immutability, and how they can all facilitate async/concurrent programming via continuation passing style ... it's wicked :)

"They are a bit off the beaten path. Words you don't hear often, but also words that provide the thrill of discovery, that "aha" moment as you realize a certain programming concept you knew only through experimentation and intuition has a name."

You said it perfectly. The first time I picked up the Design Patterns book was after I'd been amateur/student hacking in C++ for a few years. For almost every pattern I said, "Oh! I've totally done that!"

In the introduction of a book I wrote a few years ago for O'Reilly:

Finally, this is not a book that uses words such as paradigm and ontology. In this book, companies and projects release products; they don't "optimize passions for agile solutions." And bugs are called bugs.

#3 got me thinking about strings in c#.

If you inline a few string functions does each method create a 'new' string?

string foo = " a b c d e ";
string bar = foo.TrimStart().TrimEnd();

So if as you stated Jeff a string is never modified, rather a new one is created, then how many strings are created in the above code, 2, 3, or some other value?

btw - congrats on your kid, mine came 3 weeks ago tomorrow. sleep is so golden right now.

Dude (more precisely, ThatGuyInTheBack), jargon is meant to convey with meaning with precision, not to obscure things or convince anyone of anything.

Regular expression has a very precise meaning. If you don't know it, you probably don't know what you can or cannot do with it. You cannot validate an arithmetic expression with parenthesis using a regular expression, but you can validate one without parenthesis.

That tells you when you have to break out a grammar to solve a problem. It also tells you when your Perlish expressions -- confusingly called regular expressions -- cease to guarantee performance.

And it has NOTHING AT ALL to do with symbolic string substitution.

Byte is a UNIT. Just like miles, grams, meters, liters, etc. Yes, one byte is 8 bits (except when it's 7, 9 or 16, or some other number, by the way), just like a foot is 12 inches. So what? It's useful.

But, more importantly, byte did not START as, simply, a unit. A byte was smallest piece of addressable data, and in some computer architectures it was NOT 8 bits.

Well, it's a two word phrase but you have to love 'Cyclomatic complexity'.

Mine is a two word phrase for a single word, 'Deadly Embrace'

It's funny; you've just identified a concept that I just used in a hobbyist game programming project, but I didn't know the name of it: "idempotent". In my game loop, there are two steps: Update and Draw. By making the Draw function idempotent, I was trivially able to implement pausing at ANY time in the game. The Draw call never updates game logic; it only reads from it. So now, if I want to pause the game, I simply do nothing in Update.

Oh yeah, "transitive closure". Understanding that one is important. Luckily it's pretty simple, and easily explained with a quick whiteboard diagram. It comes from graph theory which many may dismiss as a "froofy" subject (academic astronauts, anyone?), but you'd be amazed at how applicable it is.

As a simple example, imagine you are trying to remove unused code from your application. Conceptually, all you need to do is compute the transitive closure of functions called starting at main(), and remove everything that is NOT in that set. FxCop does this to generate warnings about unused code, and C++ linkers do as well for removing code from compilation units (i.o.w., if "x.obj" has 10 functions, but when app.exe links to x.obj there are 3 that app.exe doesn't use, then those 3 functions are discarded from the final executable).

Garbage collection is also based on this. Compute the transitive closures of reachable objects from all your roots (e.g. local variables at the top of every thread's callstack, and from all static fields), and anything that isn't in that set is eligible for collection. Those objects are not "reachable."

Thanks for the shout-out once again Jeff.

A favourite five-dollar word not mentioned already that is slightly relevant to programmers is "boustrophedonic". Most dot-matrix and inkjet printers are boustrophedonic -- that is, they alternate going left-to-right and right-to-left.

"Chaos" aka "Cohesion" aka "High Granularity"

I think "Cyclomatic" is a pretty good $5 word. As in Cyclomatic Complexity.

Concantenate.

https://www.google.co.uk/search?hl=en&ei=exPESdmNE8WO-Abxk7mGBw&sa=X&oi=spell&resnum=0&ct=result&cd=1&q=define%3A+concatenate&spell=1

Funky and hokey, two very important terms that have been overlooked.

thunk
the first time i saw this, i thought my c++ compiler was yanking my chain. But i had done something terribly wrong with virtual functions and i learned a lot that day about multiple inheritance

also: authenticate and authorize. seems trivial now but back then i didn't understand that there was a difference.

meta

Polymorphism! Especially "parametric polymorphism"---a fertile source of reuse.

Really? I thought blogging was supposed to replace "dead tree" venues for attaining knowledge. I think that idea is close to being resoundly disproven. Is it ironic that you're using (or actually quoting someone else, as always) using the phrase "Five dollar word" which is really just another anti-intellectual epithet? I don't know anymore.

I think this is a good $5 word along the lines of idempotent:

*Inverse*. Two functions f and g are inverses if g(f(x))=x. Common example in programming is a pair of functions "decode" and "encode" or "decrypt" and "encrypt".
https://en.wikipedia.org/wiki/Inverse_function

Jeff -

A linguist might be interested in comparing the frequency of words used in .ppt files versus words in a standard (e.g., newspaper) corpus. I suspect words like "refactor," "instantiation," and "use-cases" would be severely over-represented. Once (non-techincal) managers adopt technical words, they lose their original meanings, and may be used to explain anything.

BTW, now you're a Dad: Noone Asks My Baby's Leakage Average.

- Lepto

If I'm paying $5 for a word, my word is 'poontang'...

Anyway seems like a lot of people pretty uptight about what was a reasonably entertaining read. If it's not any value to you, you might find your time better spent elsewhere instead.

A simple example of idempotent

As Chris questions if the following complies with the meaning of the word:
f(x) = f(f(x))

The answers is: Yes. That is idempotent.

Consider the following implementation.
int f (int someValue)
{
return someValue x 0
}

It does nto matter if you call it recursively or not. It does not matter if it is a rainy day, you always get the same results.

Practical examples:
- A function that returns the value of Pi.
- Save a unique record in a table e.g Save bank transaction #2343. Does not matter how many times you save the record, it will result in that record being unique in the table.

You want your code to be idempotent when you want to prevent duplication or conditional behavior.

Like preventing me from posting this comment multiple times by simply pressing the 'submit' button frenetically. You want the 'submit' button to be idempotent.

Another bloggers post cut-n-pasted into your own blog. Stop.

I have 2 words: re-entrant and reify.

Functional Programming.

I am by no means a functional programmer, but understanding a lot of its concepts and history has been highly enlightening. It was definately an 'ah-huh!' moment when I realised how state was maintained across a functional program and how everything is immutable.

It did happen to me when I was undergoing training about design patterns and I was surprised to know that many patterns which I already used has a name such as Factory, Builder, Proxy etc. Though I did use those with little variations.
I wonder whether the name is actually important. You just need to know what is right and obvious choice for a given problem and it just comes from within.

Garbage Barge - When a class contains junk functions at the same time fail to meet it's functionalities.

A little off topic but I thought this was interesting. I just upgrade to IE8, which has a new feature called "Suggested Sites". Here are the Suggested Sites for Coding Horror:
1. Command Prompt Tricks
2. Windows Command Prompt Tricks
3. Command Prompt Commands
4. Command Prompt Tricks
5. The Command Prompt in Windows XP
This "Suggested Sites" sounds like a GREAT new feature. Now I am off to learn about the "Command Prompt".

Duality of syntax

A language feature provides a duality of syntax feature, if the effort to change program A to program B, becomes easier with that feature.

Brevity

A feature that makes the program shorter.

Brevity features enables duality of syntax.

Alas but I am but a poor boy having only a paltry few $3.00 words to offer:

Pretentious

Derivative

Disengenuous

Unoriginal

Self-referencing

> Two functions f and g are inverses if g(f(x))=x.

Using mathematical definitions without knowing them precisely often results in a mess.
The definition is that g(f(x)) = x _and_ f(g(x)) = x.
If you just consider functions over natural numbers, e.g.
f(x) = 2 * x
g(x) = floor(x/2)
fulfill g(f(x)) = x, but not f(g(x)) is not x for all odd numbers.

Bug

The word on which you'll spend all the money you earned, learning these and other 5-dollar words, trying prevent.

Does it qualify as the million dollar word?

I recently came across your blog and have been reading along. I thought I would leave my first comment. I don't know what to say except that I have enjoyed reading. Nice blog. I will keep visiting this blog very often.

Alessandra

https://www.craigslisttool.info

I use these two all the time and get stares:

vestigial (adj): left over from a previous release
ex: Your appendix is vestigial as is the old acct_nmbr column.

synoptic (adj): telling the same stories but maybe in a different way.
ex: Those 5 tables which share the same PKs, and should probably be one table, are synoptic, as are the first 3 books of the New Testament of the Bible (which is where I learned about the word).

I like "dog fooding", basically using your own products.

https://en.wikipedia.org/wiki/Eat_one%27s_own_dog_food

I can't believe no one has mentioned obfuscation yet

of course, there's my favorite made-up one...

Continuous Disintegration

How about Cartesian Product? I had a case recently where table joins were creating absolutely monstrous and untenable replies to queries.

Yes, this isn't blogging. I have removed it from my bookmarks. adieu.

The $5 dollar bill pictured has a tracking history at:

https://www.wheresgeorge.com/report.php?key=1bf2afbb76d31bc4a0c370d4d8819e3c1f32bb0c65be0cb0

Not software specific but a word useful in Requirement Analysis - "platitude". Seen in pointless requirements like "The software shall be user friendly".

(First post ever- been reading a couple of weeks and love this blog!)

Recursive - The classic definition is: look up recursive in the dictionary and it will say "see recursive"

(phase, not a word - and may top the $5 limit)
Non Repudiation - From security: The sender cannot deny sending a message that the receiver can neither deny receiving the message.I sent it, and I cannot deny I sent it. You received it, and you cannot deny you received it.

I'd have to go for Concurrency and Instance. Mention those two words to non-programmers and watch the questionmark appear over their heads.

What we really want to know is the proper mispronunciation of these words. My guess is ihd-eem-POORT-eent, owe-rr-thoog-OH-nail-tie, ee-MYOU-table-tea.

In my c++ days, it was "dereference". Everything made sense when I realized what that meant.

Now there's a couple big ones that really say a lot with a little for me:

- "tightly coupled"
- Anything in Big-O (wrt algorithmic complexity)
- Any well known design pattern name.

Mine are "encapsulation" and "decoupling".

These are really probably just $1 dollar words as they're not as peculiar as, say, "idempotent". Yet I think these two words, when applied as practices, contribute with the most impact to writing better real-world software systems than any others that have been mentioned here.

Orthogonality has a slightly more interesting meaning than "independent" when one speaks of programming languages and libraries. It relates to the uniformity or generality of the abstractions and idioms of a language or library facility. Orthogonality can come from a variety of properties.

A good example of orthogonality is basic arithmetic operations in various languages. In Java (for example) you can do arithmetic on primitive numeric types like "int" using operators: a = b + c. However, Java does not have operator overloading. So extensions of the Java language that add number-like types must make up a new idiom for doing arithmetic; one cannot write the expression "a = b + c" if these three variables are, for example, instances of BigIntegers, or some class representing complex numbers or rational numbers.

C++ on the other hand has operator overloading, and extensions like this can be written to use operator syntax for arithmetic. In this case one would say "C++ operators are more orthogonal than Java operators," because the concrete constructions involved have broader applicability and can be extended to apply in more cases in the C++ language than they can in Java.

In other words, orthogonality means that for each notional concept (adding two quantities a and b) there is [very close to] one concrete construction in the language to express it (a + b). The more variations and "gotchas" that one is forced to use and remember to express the same notion, the less orthogonal the language. It's related to the Principle of Least Astonishment: "A BigInteger and a Complex and a primitive int are all 'number-like' and can all be added! Why doesn't the + operator work on all of them!?"

What orthogonality buys you is a multiplicative effect in the expressive power of a system as you add features to that system. A perfectly orthogonal system with N features can be made to express N*M additional concepts by adding M features, where as a completely *non*-orthogonal system can only be made to express M additional concepts by adding M features. Most systems, naturally, fall somewhere between these two extremes.

Interfaces, operator overloading, and things like Python's magic methods are common language features used to enhance orthogonality: "I can use a for-each loop on anything that implements IEnumerable", or "I can use the + operator on anything that overloads operator+()" or "I can call str() on anything that implements __str__()".

To consider why it's a good property to have, would you rather write 10 algorithms that each work on all of 10 data structures (orthogonal), or would you rather have to write the same 10 algorithms 10 slightly different ways in order to get the same amount of functionality (non-orthogonal)?

Even if you had to implement the algorithms differently for each of the 10 data structures (as you would for the addition example), would you rather have to remember 10 different ways to add 10 different kinds of 'number-like' things (non-orthogonal), or simply have to remember "+ adds things" (orthogonal)?

Anyway, I guess my vote is certainly for "orthogonal" :)

Fubar. f*cked up beyond all repair.

Saying there is 'a problem' or something has 'gone wrong' sometimes just doesnt get across the gravity of some situations.

So in project management jargon it's time to 'leg it'.

My Votes: Tuple, Closure, Taxonomy, Covariant...
To the "how is orthogonal not equal to independent" crowd.

In my head, Orthogonal != independent because orthogonal implies that two solutions are dependent and related, but they do not affect one another. Using a two dimensional example, moving up and down the y axis doesn't affect the x axis, If you have a function that accepts and x and a y value and returns the point of these two, you cannot have the x value affect the effect of the y value (that is, y cannot be a function of x).

From a math perspective, Orthogonal means "perpendicular" and it's very clear that for two lines to be perpendicular, They must meet some strict criteria.

In some ways, for something to be orthogonal it is similar to being deterministic, but, instead of relying the on the function returning the same output for the same input, you're relying on the input not modifying another input. It seems like this could be mathematically provable, but I have neither the skill, patience, or free time to pursue it.

ontology.

And just putting all your data in a wiki is not the same.

State (stateful, stateless), and Referential Transparency.

"Isochronous" vs. "asynchronous" are two that I mixed up for awhile, mostly because as a software guy, I was so used to the concept of asynchronous I/O and APIs.

I actually misheard it the first time a colleague used isochronous; he was referring to USB transfer protocol specifics (ironically, https://en.wikipedia.org/wiki/Isochronous actually calls this specific case out).

When I later referred to something was working on as "asynchronous," he said "you mean isochronous?" A great "to-may-to"/"to-mah-to" conversation ensued... and he gave me a new $5 word.

Mine has to be "Draconian Validation" its sounds so cool, and you get very few chances to say it (in context of course)...

If words can have poor usability, this post and its comments prove it.

Can someone post a real code example of Idempotent(cy). I can't think of any.

As far as I know the mathematical description is:

f(x) = f(f(x))

As someone pointed out, but I can't think of any method I have coded that falls into this category. The only examples I could think of are something like:

public double idempotent(x:double){
return x * 1;
}

But those are not a real life examples.

Two words that have been guideposts for me arrived in one package, specifically Yourdon and Constantine's "Structured Design", which we used as a text in my undergrad work:

Cohesion - the relationship of elements within a software component (e.g., functions within a C source file, methods within a class). Cohesion should be strong, meaning the elements are closely related; throwing miscellaneous functions into a 'junk drawer' utility class is poor/weak cohesion.

Coupling - the relationship between discrete software components. Coupling should be weak: only use declared interfaces, and make those interfaces as small and simple as possible, so that components can be modified in isolation. (In other words, so that components are orthogonal.)

Hey I don't know much coding but I like reading blogs I can tell you the word that most impacted me and made me do 'aha' and that word is Laconic. It can be used to describe the Spartans(remember 300). It means to say very little but bang on target....Just like a short efficient code.

What about those ones :

"Smoke testing"
"Diamond problem"
"Progressive Disclosure"
"object-relational impedance mismatch"
"Situational applications"
"multi-versioning"

Nice words, Jeff Atwood.

One of the words we've learned to use a lot here is "dehydrate." This is a point in a process where data is written out to a database, a bit like breakpoints in a debugger.

I love saying the phrase "dehydration store" when a non-techie is around. They have absolutely no clue what I'm talking about.

Subsume:

To include or place within something larger or more comprehensive : encompass as a subordinate or component element

Ever since college where we used it when discussing logic design and minimization I've found I use it frequently - particularly when trying to refactor objects or generalize problems. For example, making a more generalized schema that subsumes several problems we used to express in different schemas.

Heuristic!

Chepech:

A real-life, but trivial, example could be something like a setter function.

public void SetSomeVal(int x)
{
this.val = x;
}

Whether you call this once or fifty times with the same x passed in, the result is the same.

Another example might be the following shopping cart scenario.

class ShoppingCart
{
private List cart;
public void RemoveAllItems()
{
cart.Clear();
}
}
...
myCart.RemoveAllItems();
myCart.RemoveAllItems();
myCart.RemoveAllItems();
myCart.RemoveAllItems();

Again, calling this method one time, or 100 times, the result is the same.

Compare that to the following.

Suppose we add a method to the cart class above called AddItem, written as such:

public void AddItem(Item item)
{
cart.Add(item);
}

And later...

myCart.AddItem(someItem);
myCart.AddItem(someItem);
myCart.AddItem(someItem);
myCart.AddItem(someItem);

If our cart allows multiple of the same item to be added, we have a much different result.

Hope this helps!!

I like these ones:

Nondeterministic finalization
Runtime polymorphism
Synchronization primitive

If my project manager starts bugging me, I just start reeling these off at random, and he goes away...

Chepech, Jeremy Nunn,

the problem is that the different meanings of idempotent are happily mixed up here. But the mathematical meaning doesn't really make sense for programming problems. The Wikipedia entry is much more clear:

https://en.wikipedia.org/wiki/Idempotence

"In computer science, the term idempotent is used to describe methods or subroutine calls that can safely be called multiple times, as invoking the procedure a single time or multiple times results in the system maintaining the same state; i.e., after the method call all variables have the same value as they did before."

Thus f(x) = f(f(x)) makes sense if you consider x to be the overall program state before calling the function f and f(x) to be the program state after calling the function.

"namespace" was one of these for me. Or, a "visibility problem" in concurrent code. Or "lambda calculus". Sad thing is, I actually do have a degree in CS and have actually known what these meant some years ago. :)

For me it's Single Table Inheritance. Ok, that are counted three words. Anyway, it's a technique of ActiveRecord, Ruby On Rails' ORM. What it makes 5 dollars worth, is that it specializes the word "inheritance", which is itself a very useful word in the programming domain.

Single Table Inheritance means, that you save different objects, that are instantiated from different classes, that therefore inherit from the same superclass, are saved in the same table.

Not so easy the explain, I'm glad that I can just say "es tee ay" and my colleagues, know what I mean ;)

Favorite definition of a five dollar word: "In order to understand recursion you must first understand recursion."

I'm surprised no one mentioned "defenestrate". It's what you do to your computer when you know your code _should_ compile yet it _wont_.

deadly embrace

and

Pseudo-conversational (programming)