or learn more

The Elite Programming Language Fallacy

Oct 2, 2011

There are no programming languages that will make you “elite”. In fact, there are no “elite” programming languages. “Elite” is as loaded a term as there could possibly be, but I would like to use (abuse?) it for the purpose of this post. I hope you will bear with me as I attempt to make a point.

“Elite” Programming Languages

What is the primary characteristic that an “elite” programming language might posses? It would be difficult to understand and use. I think that every programming language is difficult to understand with little to no relevant context. Even a language like Java that is partially designed for ease of introduction is not based in human nature. That is, every Java programmer at one point or another knew nothing about Java, objects, and interfaces. So I say that even a notoriously difficult language like Haskell is only difficult because you haven’t learned it yet. But what about the idea that some languages are built for “elite” programmers only? I’ll talk about that currently.

“Elite” Programmers

What is an “elite” programmer. It’s difficult to say, but anyone with even a few years of experience is likely to have worked with one, or observed one, or maybe even studied one. The best way to describe an “elite” programmer is simply:

You just know one when you see one.

But does a programming language make a programmer “elite”? Let me speak from my own experience. In my time I’ve met and worked with my share of “elite” programmers:

  • One knew every Java method available, could write Java faster than I could ever write anything, even at my most concise, and could simply “see” the flow of concurrent paths and points of contention.
  • One spoke Emacs Lisp like it was a native tongue. I could not visually follow the shuffling of Emacs buffers nor the random evaluations of Lisp that modified his instance on the fly in very pointed, task-specific ways. Additionally, he had perfect recall of every Emacs Lisp function that he had ever written (or so it seemed).
  • One could trace the flow of Cosmac 1802 assembly code in his head. In one afternoon he wrote a complete 1802 emulator in BASIC.
  • Two were unbelievable when armed with a C++ compiler. During the course of a huge integration event they worked together to rewrite a large portion of a misbehaving simulation node that worked without error on every run that week. One of them moved on to Python and amazingly became even more impressive.

Would you say that Java, Emacs Lisp, Cosmac 1802 assembly, C++, and Python were “elite” languages? Maybe. But the fact remains that they certainly seemed “elite” in the hands of “elite” programmers. I suspect that every language, be it generally viewed as “elite” or mundane, has it’s share of programmers that will take your breath away. I suspect that these programmers would excel given any language, but for some reason certain languages just make sense to them. I’m of the opinion that programming languages are a subjective affair.

Languages do not make a programmer “elite” and anyone that says otherwise is trying to sell you something, or selling themselves short. There is no doubt that there are some programmers who are unbelievably productive and dare I say “elite”, but it’s not the language that got them there. I suspect that for any programmer there is some set of languages that can help them to crystalize their thought processes. You might say that certain languages attract “elite” programmers, but I’m skeptical about that.

I’ve been fortunate enough to work closely with two programmers and corresponded with another who created fairly popular programming languages. In my limited experience it’s always been the case that the language designers are the most tempered in the view concerning the universality of their creations. However, like any social group it’s others, often those not directly connected with the stewardship of said language who make the grandest and most universal claims. Alas this is an ugly side of the programming beast.

“Elite” Problems

Programming is hard. However, there are relative levels of difficulty. A text-editor is harder than the Towers of Hanoi and likewise an operating system is harder than a text-editor. Having said that, there are languages that are designed to solve hard problems. Clojure is one such language. Regardless, there is nothing stopping one from using Clojure to write Towers of Hanoi or text-editors. The “solving hard problems” bit simply means that the language itself provides first-class abstractions and features that encapsulate techniques and semantics to alleviate difficult problems. For example, in the case of Clojure you might say this about its immutable types and STM. Ironically, it’s these very features that make these “elite” problems easier to reason about, so what does that say? Is the language easier, or is it harder? I don’t think that I have the a definitive answer, but you might guess at my opinion.


So why does the term “elite” become attached to certain languages over others? I think that there are many factors, both social and psychological that play into this. Since I’m neither a sociologist nor a psychologist I can’t say for sure. However, I must say that the idea of an “elite” programming language just does not seem right to me. For better or worse I only have my opinions, experiences, anecdotes, and my own notion of what makes sense to offer.

Caveat emptor.


24 Comments, Comment or Ping

  1. Colin

    Haskell is a bit tough for me right now, being right in the middle of learning it. I’m sure once I’m through it though it’ll be as clear as day, and I can really see myself getting good work with it. It certainly isn’t “elite”.

  2. None

    You can define a programmer as “elite” because you have a metric. An “elite” programmer is one who can accomplish a given task “better” for your particular flavor of better than others (possibly to some statistically significant degree).

    Finding a metric is harder for a programming language. Realistically you have multiple dimensions to measure. For a particular problem you have both the programmer skill and the suitability of the language to the problem. These variables are most likely not independent.

    We can create metrics by fixing a parameter. For example, we could say which is the language in which the best programmer in that language can provide the “best” solution. Or you could say in which language can the most people produce a solution above a certain level of quality.

    So any metric is a compromise. The most individually useful metric is probably in which language can “I” produce the “best” solution. But it is impossible to compare directly with others.

    You can combine these metrics to something useful for a general comparison (for say a large organization that wants something to measure). You could define your metric as the expected “quality” of a solution to a problem formed from the distribution of everyone writing the solution in the given language.

    But good luck measuring that! But we come to the point (finally), it’s not that there is no best language in a context. It’s that figuring out the answer is nearly impossible.

    But why should being impossible stop anyone from at least trying?

  3. I’m concerned about the attachment programmers have to specific platforms and languages. Now, I’m not going to say that anyone should avoid specialization. Naturally, in order to be an effective professional you have to grock a language and a problem domain. The “elite” programmer, however, is probably an expert in a problem domain but wouldn’t get too terribly tripped up if you forced him or her to use a different language perhaps even if the language didn’t suit the problem domain perfectly. An “elite” programmer may even be able to move into unfamiliar problem domains with a relatively high level of effectiveness.

    I realize an argument by colloquialism isn’t valid, but my dad used a fishing saying that I think is applicable: “Anyone can catch a whopper but only a fisherman can do it with a stick.” Heh, that’s not to say I recommend programming with a “stick” in your day job.

    In short, I agree with the assertion that there are no “elite” languages.

  4. The closest thing I’ve ever experienced to understanding “the elite” programmer is that they have a highly developed intuition and can execute mechanics extremely well: tracing, debugging, knowing libraries, knowing platforms, seeing errors, that kind of thing.

    I theorise, but have no way to prove, that intuition can come simply from practising mechanics. I teach programmers to focus on the mechanics and let the intuition develop. It’s a grand experiment, and I don’t have any startling results, but it matches my experience, people generally find it reasonable, and no-one has gone out of their way to call me an idiot. So far.

  5. Everyone seems to be missing the obvious: assembly is the Elite programming language:

  6. Learn to play chess. And by this I don’t mean learn the rules, learn all the strategies, famous games and play a lot. You might improve your precoginitive skills the more moves you can think forward.


    An elite programmer who is given a problem knows what he needs, he needs “this & this & this & this & this & maybe that & this & this & this” and improves the code while he is working on it with a dismissal of unnecessary code. A common programmer who is given a problem makes a guess what he needs, “this & this & that”, starts programming, fixes bug in that, adds “this & this & this”, starts over, makes a plan, writes one part after the other, tests each one, fixes bugs again and the finished code is twice as big.

  7. John

    I’ve known many developers grounded in various languages. I I have never met a VB developer who I would regard as elite, and I have never met an assembly developer who isn’t elite.

  8. As an Elite, I prefer Assembler. Mainly because of the advanced debugging and memory access.

  9. Jonathan

    John, there are many elite VB developers (though not a majority). I would consider an elite programmer as anyone who has a rigorous approach to solving problems, those are the professionals in our field.

    My opinion is some languages do seem to attract more elite types of programmers (people motivated and rigorous to understand and solve hard problems).

    That said, those people sometimes need to get off their high horse promoting their own ‘elite Programming Language’.

    An assembly developer sounds probably more elite to you since generally they solve more difficult problems then VB people.

    That’s your perception of elite, for me anyone with a rigorous approach to solving problems is elite (regardless of the language).

  10. Yellow

    After learning 10-12 different languages, I have never found the need for Java. It has never lived up to it’s promises, it runs like crap on any system, and is not the “perfect choice” for any project.

  11. I’ve been programming for 46 years, and the machines I’ve touched have ranged from mainframes to microcomputers and I’ve watched microcomputers grow back into supercomputers. I’ve seen almost countless operating systems and even more programming languages. I’ve literally worked with thousands of programmers over the years, and each of them has been unique in their own way.

    With this extended window in which to look, I have to say that I have never seen what I would call an “elite programming language” unless it happened to be coupled with a “skilled programmer” who could us the language to solve a particularly “unique problem”. I have seen beautiful solutions to difficult problems in almost any of the environments over the tears. I have to completely agree that particular programmers have been very unique, and I have seen excellent solutions in almost every language, and I have seen huge messes in the same environments by other individuals.

    I am a bit offended at the “never met a VB developer who is elite”. The same comment also says assemply developers are elite. In 1966, all we had was assemblers on the IBM 1440, and we wrote software that ran companies. In 2011, we still have assemblers, but far more “elite solutions” can be written in VB than in “Autocoder” simply because 4 and 6 core CPUs are so much more powerful than 8K mainframes (yes, 8K, not 8G RAM). One should define the problem, and the environment, then use the proper tool to forge the solution. The particular language is just a tool.

    Of all the languages over the years, I have to admit that my personal favorite is “C” (and all of the derivatives and extensions).

    Bud Jay

  12. I am a relative newcomer to programming, and self-taught. That said, I agree – there are no elite languages. Languages are nothing but tools. Some are harder to learn, and some may be better within a certain problem space, but it is the craftsman who makes the tool “elite”.

    Elite programmers are another thing altogether. As a self-taught coder who has mostly “grown up” in the modern, abstracted, “framework” era, I stand in awe of those who can use Assemble language. I have looked into it, and while I don;t doubt I could learn it, I feel compelled to keep up on “the latest” if I am going to have any opportunity to use my new-found passion.

    That means learning the newest fancy API built on top of .net/Java/Ruby etc.

    While I did not (and sadly, will not) have the opportunity to attend formal school for CS, my understanding is that even here, folks are now beginning to learn more of the “framework/API” languages right out the gate (Java, anyone?). While I believe you can still expect a decent education in machine architecture and all the important stuff, it sounds like the ability to talk directly to the hardware in ANY language is really the domain of the “Elite.”

    To me, there are elites, and there are ELITES. The truly elite, to me, are those who understand the system top to bottom, and can use the right tool (Language) for the problem domain. Sadly, I will likely not get the opportunity to be one of those. But my hat is off to you!

  13. David

    I have been programming now for 20 years, and have gone from small 8 bit microcontrollers (like 8051) all the way to PCs now. I have done programming in several languages and OSes over the years.

    Like Bud, the comment about VB developers and assembly developers troubles me. I have worked with both for a long time and seen many assembly programmers who weren’t worth the keyboard they were typing on, and VB programmers who were worth their weight in gold. Myself, I typically gravitate toward the C family of languages (c/c++/C#), but I will use the appropriate tool for the project.

    Truly elite programmers in my estimation are the ones who are able to take a set of requirements and use the appropriate tool for the job, getting it done as quickly and efficiently as possible. This includes making the code UNDERSTANDABLE in terms of its logic, flow, and conciseness.

    The language used is immaterial, other than being the right one for the job.

    A good analogy I like to use is that of the auto mechanic. Say you have a problem with your electrical system in your car. The mechanic can solve the problem in several ways:

    1) Replace all the electrical items in the car. Most expensive for you, but will definitely fix the problem. Not a good/efficient way to solve the problem.

    2) Replace the battery. Well, what if the problem still exists? Gotta replace the next most likely thing to cause a problem – the alternator. Keep going until the problem is fixed. Similar issue to 1.

    3) Use a trouble code device to read them from the car’s computer. This might show the proper thing to replace. Much cheaper and faster than 1 or 2.

    So, like an auto mechanic, knowing what tools to use when, THAT is what makes an elite programmer. Tools are just that – tools……

  14. Ryan

    I agree that what makes a programmer elite, is there ability to work with whatever their best toolset is to solve a unique problem.

    However, if you’re just considering languages, it’s obvious C (and perhaps c++) are the most elite, because you have direct memory access. That’s all. Sure you can be an elite java programmer because you memorized the whole API and you can code super fast and you’re the boss hawg at debugging, and for his specific purpose he is elite (of the best in his particular category). But if you’re just talking about straight up computer science, it’s obviously more elite to know what a pointer is, and how to directly manage memory. Simple as that.

    No one’s denying that some languages are better suited for certain tasks than others. If you want to be elite at parsing logs or writing text editors, you don’t choose C or assembly. If you want to be elite at working more directly with the innards of a computer, you choose asm or C. This really has to do with what people perceive as programming “eliteness”

  15. Jonathan Hogg

    It reminds me, really, of a reporter for Jane’s (the military information company) who got to fly an F16. He said that it was far easier to fly than his Cessna.

    Way back when, when grammar and readability checkers were a new thing, I ran one on a Robert Frost poem. It got top marks on readability. I’m sure T.S. Eliot would NOT have. But that experience changed my own writing style forever–why not write for everyone?

    “Elite” should never be confused with difficult. “Elite” is writing in any language where once the rest of us see it, it’s obvious, but we wouldn’t have gotten there ourselves. It is genius, and can be found anywhere. For the rest of us, at least there are those “aha” moments that make our day.

  16. VooDooChicken

    elite language + elite programmer = best solution possible. If you are an experienced programmer, the solution you propose most likely will be similar no matter what language you choose, but that same implementation in one language may be slower than the implementation in other language, because one of them is interpreted, or because the other one has a garbage collector, which though it ‘saves time’, it also means part of the system resources are available collecting garbage instead of solving the problem. So lets start with performance, assembly? yes, but same as thing as pearl, somebody can hardly follow what somebody else has written specially if is part of a block, since the other user can not not beforehand states of registries and so on.. c? great! a performance close to that one of assembly, but without having to guess and use a calculator beside you, so it was great, but objects and stuff where created because there were problems that arose from either having to know the whole application before hand, or to risk screwing the entire app while making a change, so after objects, it became c++. for me this is the ideal language; everything you can do with a computer you can do with this language, and work very close to the top performance; I have worked with other languages for different purposes, but if there is an elite language at all c++ is in top of my list

  17. Armando de la Torre

    Oh , Elite programming languages do exist. Imagine the following scenario : to program in a certain language you must buy an environment that costs more than 10,000 USD. Then you do have an elite language.

  18. Programming is weakly related to the programming language used; it is strongly related to the operating system and the OS-interface library, since so many things one has to do involves the OS+environment – accessing files, dealing with a windowing system, launching other programs, etc.

    The other factors involved are a knowledge of data-structures and a knowledge of algorithms, both non-numeric and numeric – all of this is programming language neutral (except when it isn’t in the case of weaker languages.)

    see on “How to write Computer Programs”.

  19. SeattleC++

    The search for an elite programming language is the search to become “elite” onesself. As with any kind of greatness or coolness, eliteness is found by not searching for it. By definition, anyone searching for or proposing an elite programming language is not going to be elite any time soon. They need to get over themselves and spend 20 years working. Then one day, a young colleague will describe them to someone else as elite, and it will be true.

  20. Roger Fedyk

    Much of the discussion seems to be centered on what a developer might do/will do with the coding language of his/her choice.

    Cart before the horse, in my opinion. If the developer understands the real world problem that needs to be solved, the code will flow irrespective of the programming language. If the developer is sufficiently experienced, they may foresee problems with using one PL compared to another. Eliteness is not a factor, experience is.

    Clients may or may not have a preference for a programming language to use. Their own predilections could be based on profound or trivial reasons. In the end they may have no choice except to defer to the developer’s whim.

  21. A programming language becomes elite when it’s increasingly used by elite programmers. From elite programmers we mean resource persons that are more productive than others. These people usually have many other traits contributing to their stardom, including but not limited to: More clever algorithms Above average persistence Better time management Stronger memory Good listening/understanding skills Vast knowledge base All of them definitely spends more times in company of machines instead of pets or family.

  22. Mad Bollie

    IMHO, until programmer productivity can be objectively and reliably measured, and it can’t at the moment, then trying to discuss ‘elite’ programmers and the ‘elite’ tools that they use is pointless.

  23. Trajan

    An interesting question. I think there are a couple of reasons why “elite” is a concept that becomes associated with particular languages.

    One fact is that certain languages are only easily usable by elite programmers, others not. Someone already brought up VB. One reason VB is viewed with disdain by many people is that the ratio of poor programmers to good programmers in the VB space has always very high. Why? VB has a lower barrier to entry. Anyone who can drag and drop a few things around could make a (pre-.NET) VB program. There is no need to comprehend any serious programming concepts, so lots of people with no such comprehension make use of it. Note that it doesn’t go the other way, however- an elite programmer can certainly still make use of VB. An analogy might be one from carpentry. A hammer is a really easy tool to pick up and use. A router is a bit more complicated, and many people who would happily pick up a hammer and start pounding would shy away from trying to use an unfamiliar power tool like that. So there are a lot more shoddy carpenters using hammers than routers. But at the same time, an elite carpenter could also do things quickly with a hammer that your average person could not easily accomplish. The point here is that languages get associated in our minds with the ways they are used, and some languages are more regularly used by poor programmers, leaving other languages associated in our minds with elite programmers, especially the awe-inspiring ones (“wow, that guy coded the whole thing in pure assembly!”) and thereby associated with the concept of “elite” in general.

    Second, programming languages are tools, and tools can be designed at a high or low level. Consider the difference between a consumer video camera and one used by a television studio. An elite cameraman will produce better video than someone else with either camera, yes. But there are things built into the professional camera which allow someone who really knows camera work to put all of that elite skill to use. This is really where there is probably some legitimacy to the idea of “elite” vs. “other” programming languages. It isn’t that something is an elite language because it is hard to use. The difficulty of use could simply be from poor design. But if not difficulty, at least complexity, comes from the flexibility desired by top professionals in every field. There is a legitimate reason to call Photoshop an elite application as compared to MS-Paint, and the same goes for, say, C# as compared to VBA, or C++ as compared to BASICA.

    In fact, a really elite tool is one that can handle bigger tasks with the same amount of work…but sometimes the tradeoff is that you need to know what you’re doing– you still need to be “elite” enough to understand the bigger task and how to accomplish it well. Note that a program of any real size written in BASIC will probably be a lot harder to comprehend than the equivalent program written in Java. But Java is still a more elite language, because it gives you more power. In fact, one of the powers it gives you is organizing very large programs in a coherent manner, something impossible in every version of BASIC short of VB.NET (if you can even call VB.NET “BASIC” at all anymore).

  24. One suspects INTERCAL of elitism.

    This sounds a bit like the old LFSPs (Langauges For Smart People) vs LFMs (Languages For the Masses) argument from Mike Vanier, republished by Paul Graham:

    “This is not accidental; LFMs deliberately restrict the abstractive power of the language, because of the feeling that users “can’t handle” that much power.”

Reply to “The Elite Programming Language Fallacy”