Cover image for 7 Great Programming Quotes

7 Great Programming Quotes

jeremycmorgan profile image Jeremy Morgan ・2 min read

So... which version of Linux should I install on my brand new machine?
Click here to vote!

Here are some amazing quotes about software development to inspire you, make you laugh, or make you think.

"Programming isn't about what you know; it's about what you can figure out.” - Chris Pine

Especially important for beginners. At first, we're so anxious about knowing everything, especially language syntax. Problem-solving is the skill we end up using most.

"The only way to learn a new programming language is by writing programs in it." - Dennis Ritchie

Programmers are mostly "learn by doing" types. No amount of academic study or watching other people code can compare to breaking open an editor and start making mistakes.

"Sometimes it's better to leave something alone, to pause, and that's very true of programming." - Joyce Wheeler

When managing developers I would always encourage getting up and walking away from the computer when you have a problem. Some of your best solutions will come to you when you're not at the machine.

"In some ways, programming is like painting. You start with a blank canvas and certain basic raw materials. You use a combination of science, art, and craft to determine what to do with them." - Andrew Hunt

Outsiders question whether programming is art. Programmers don't.

"Testing leads to failure, and failure leads to understanding." - Burt Rutan

Some developers hate testing. However, shifting your attitude and embracing it makes you a better developer.

"The best error message is the one that never shows up." - Thomas Fuchs

Remember this the next time you decide to focus on some great error reporting.

“The most damaging phrase in the language is.. it's always been done this way” - Grace Hopper

To be a programmer long term, you have to love change. You can't just tolerate it, you have to love it.

Bonus Quote

Since #6 seems somewhat vague, I'll add this one as a patch:

"Don't write better error messages, write code that doesn't need them." - Jason C. McDonald

Posted on by:

jeremycmorgan profile

Jeremy Morgan


Silicon Forest Developer/hacker. I write about .NET, DevOps, and Linux mostly. Once held the world record for being the youngest person alive.


markdown guide

These are all great...except #6. Unrecoverable errors should display error messages, as those error messages are critical to fixing the problem. Pretending the problem isn't there, as the quote is suggesting, is just plain irresponsible programming, and it's inexcusable in any context.


The quote suggests preventing errors, not hiding them when they're un-avoidable.


Unfortunately, that is neither the explicit statement, nor immediately clear to many readers. Taken as presented, many developers would assume they needed to suppress error messages.

I'm with you, while I can definitely see how someone could get the impression.
But the first thing I thought when I read this was that you need to plan for error states, but seriously attempt to avoid them.
While yes, as others have stated, users need to see errors when it's input or usage related, but the proper understanding of this quote applies there too. Because if the gui/interaction were designed properly, users wouldn't err. (some will always error, some are just dumb, others will try to break stuff on purpose.) there's no way to avoid all user errors, but you can definitely write code to account for all internal errors.
Its not about suppression, it's about prevention.

I'd say the fact that yours is the fourth interpretation of the quote in this thread shows my entire point about the lack of clarity in the quote. ;)

With that said, I do agree with your position wholeheartedly, especially as it relates to a GUI.

Allow me to submit what may be a clearer alternative to the quote in question (although I'm hardly well-known enough to be quotable in my own right)...

Instead of writing better error messages, write better code that doesn't necessitate error messages.

Well said! But while clearer, it doesn't quite a have the same ring ;)

As a professional author, allow me to assert: clarity is better than brevity; but if you can get both, do.

Shrugs What can I say? You win some, you lose some.

Trying again...

Don't write better error messages, write code that doesn't need them.

I like this better than the original.


The problem with that approach is the sentiment that, given sufficient effort, you can eliminate errors when, in fact, failure is the default state of software. And when software fails, the better that users, support people, and developers understand what actually happened, the more effectively they can address the underlying problem.

I don't think anyone is suggesting not to expect errors. It's just a Fluffy quote. Like, the best weapon is one you never have to fire. It's being over-thought.


I don't see it as pretending the error isn't there. I read the quote as spending more time to make sure the error doesn't throw in the first place.

Personally I've seen people spend a ton of time capturing all the error information, logging it neatly in different places, sending off emails etc.

While I'm all for capturing everything I can in an error, more time spent preventing the error pays off, and I think that's what the intention behind the quote was. I could be wrong, it's not my quote.


If you look at the other half of this particular thread, you'll see I entirely agree with the good practice you describe. The quote is, unfortunately, quite vulnerable to interpretation.


"To be a programmer long term, you have to love change. You can't just tolerate it, you have to love it"

This is something that some JS developers need to understand sometimes. With frameworks evolving so rapidly


It's amazing how different people can get completely different meanings from the same statement. (not being rude, just making an observation)
I'm with you, errors need to show when they need to show. But I think this quote was saying they shouldn't have opportunity to show, meaning defensive programming.


Funny, my take-away was it was another way of saying the best kind of errors are those that don't happen. (Or are dealt with automatically, I suppose.) Never even occurred to me to have an error that the user should know about, but are not informed about.


"Errors should never pass silently, unless explicitly silenced."
-Tim Peters (The Zen of Python)


Just to plug a set of programming quotes I curate. One of my favourites:

“So much complexity in software comes from trying to make one thing do two things.”

— Ryan Singer


Great quotes, but I didn't find one that makes me laugh... So here's one that's humorous and in the same time has a very good point:

Programming today is a race between software engineers striving to build bigger and better idiot-proof programs, and the Universe trying to produce bigger and better idiots. So far, the Universe is winning. (Rick Cook)


True and very vaguely understood by many.


Thanks for these. I love the last one!


“Code is like humor. When you have to explain it, it’s bad.” - Cory House


Love the quote from Grave Hopper, so perfect.


that is the great place wow really enjoy the programming. Best laptop buyer's Guide Www.raisaleem.com


Things can change so fast on the internet.
— Tim Berners-Lee