Joe Lesko | Blog | creativity, programming, and design

Simpler Programming Lingo

People add extra words when they want things to sound more important than they really are.

— George Carlin

While working on THT, I've thought a lot about the importance of good names and how they affect usability.

As programmers, we know that assigning clear names to our functions and variables is a fundamentally important task. Good names help us build a mental model of how our programs work.

On the flip side, bad names make an already hard job even harder. They slow us down and can lead to more bugs.

This also applies to the jargon we use as an industry.

For example, a term like “dependency injection” sounds impressive and is technically precise. But it doesn’t serve us well in the actual craftsmanship phase of writing code.

Many of these terms come from math or computer science, where they are introduced one at a time, and tend to be long, with the goal of being precise.

However, as programmers, we need to juggle, say, 10-20 concepts in our head at any given point. We can ease that cognitive load by using more concise language.

In other words, the more compact our tools are, the more we can fit in our mental toolbox.

For example, instead of “dependency injection” (7 syllables), the term “plugin” (2 syllables) might be easier to use because it is shorter and easier to imagine.

It’s important to remember that words are just “pointers” to ideas. They don’t need to fully convey meaning on their own. That’s what definitions are for!

However, it does take some creativity to find words that will stick in our minds and also convey difficult ideas. (Naming is Hard, after all.)

Good names tend to have these qualities:

  • Short, few syllables
  • Easy to say, easy to type
  • Familiar, concrete, or uses a real-world analogy
  • Not too technical, maybe even a little fun

Good Examples 

Here are some industry terms I like.

Once you learn what they mean, they tend to stick with you.

bit
bug
mixin
sandbox
duck typing
push/pop
grep
factory
template
AJAX
DRY
front end/back end
dead code
monkey testing
kludge
linker
library
pipe
pointer
race
dump
syntactic sugar
zombie
golf

Bad Examples & Alternatives 

In an alternate universe, here’s how some of our current jargon might be made easier.

CURRENT                 ALTERNATIVE

immutable               locked, read-only
executable              runnable
object-oriented         object-based
instantiate             spawn
encapsulate             blackbox, box
polymorphism            adaptable, shape-shifting
dependency injection    plugin
delegate                helper
interface               front
abstract                template
lambda                  inline function
anonymous function      bare function
closure                 sticky function
increment               uptick
decrement               downtick
modulo                  remainder
null                    none, nothing
subscribe               listen
coalesce                absorb
interpolation           inline
hungarian notation      prefixing
shift                   popFirst
unshift                 pushFirst
obfuscate               jumble
asynchronous            side-run
memoization             call caching

Types:

boolean                 flag, bit
array                   list
hash map                lookup list, map
string                  text

Last Note 

This isn’t about “dumbing down” the language. Humans already have a natural tendency to streamline language because it is more efficient (i.e. acronyms and abbreviations).

Programming will always be difficult, but we can make our jobs easier by adopting more direct language.

On a related note, check out George Carlin’s rant on Airline lingo.

More Posts

About

Joe has been designing and developing games and web apps for about 20 years. He is a self-taught programmer, and creates art and games in his spare time.

He currently works as a User Experience Prototyper at Netflix, on the Interactive Design team that created Bandersnatch.

JoeLesko.com