Preamble
Over the last decade or so, I've had a peek into quite a few developer communities. I do most of my private programming in Lua, and interact with that community almost daily. At work I use Ruby, and often get a good glimpse of that community as well. Through Hacker News, Reddit and a bunch of other sites I get a good impression of many different "general" programming communities. I am only human, so my opinions will of course be biased, but for what it's worth, I do believe that I have at least some degree of objective perspective on this topic.
The Problem
Lately, I've noticed a bit of a trend within the world of software development. Put bluntly, it seems to me like the field of programming is slowly but surely drifting down the hillside, spearheaded but not exclusively caused by the web community in particular.
The Symptomatology
What do I mean by this though? Well, starting with the a parallel, but mostly positive process: Programming is becoming more and more inclusive and easy to get into. Elitism is slowly becoming more of a meme than an honest feeling of superiority, and more and more people are picking up programming or closely related skills.
However, in the process of wiping away elitism and gatekeeping in the software world, it seems to me, that in our excitement we are also throwing out valuable barriers that keep our world stable and nice
One of the big changes I have noticed is a general shift from "hobby that you can even get paid for" to "easy way to land a comfortable job". Discussions about fancy things you can do with software for the sake of experimentation are being replaced with top ten interview questions for whatever the hottest new technology is at a given moment. Enthusiasm for technologies despite its economic viability is being replaced with amusement at getting something to work as quickly (read: wasting as little paid hours) as possible.
The result is that these days, there's a much bigger emphasis on learning products over theories. The "brand" is slowly sneaking into the world of programming, and while specific technologies have always been something you'd learn, it used to be more about languages than single platforms. Maybe this started with Java and the JVM platform, but I'm not old enough to judge that.
At the same time, some of the blame might fall on the internet. In the "good old days", when "everything was betterโข", the lack of a centralised knowledge-base meant people had to learn their IT skills though manuals and text-books. One could consult a manual for certain questions, but given the limited space, this would only lay out the components and tools you'd need to fix a problem. These days, one can consult the internet with a very specific question and is likely to get a solution for that exact problem spoonfed by the collective knowledge of the entire programming community.
Is this bad? No. But it leads people to rely on it, and that certainly is bad. One of the reasons I have stopped visiting the ProgrammerHumor subreddit despite enjoying most of the bad and repetitive jokes there, is that a certain category of self-deprecating humor has gotten so overused, that it's impossible to scroll though it for 5 minutes without seeing at least one post where the punchline falls along the lines of "all programmers do is google" or "if stackoverflow is offline, all development just stops worldwide".
By itself, each one of those jokes would be funny. Programming does sometimes feel like most of what one does is googling, specially when just learning a new technology. But the obsession with this narrative, over time, has started to make me wonder if this is what some people actually believe, and, by constantly repeating and repeating and repeating this same punchline, if newcomers and outsiders will sooner or later get the impression that this is the unironic reality of programming.
Why does this matter? Consider the public image of programming. Currently, most people, when I tell them I do programming, react with at least some degree of respect. "He's a programmer, he must be smart" is what some people might think, not unlike someone calling themself a "scientist" or a "mathematician". Programming is considered an intellectual discipline. This directly translates into how much worth is associated with the job: if you have to be smart to do something, you will get paid well, because you're "in demand". What, did you believe we're getting paid more than a janitor, who spends most of their day doing physically demanding work, because our job is so much harder? You probably know that that's not how it is.
So from that perspective, constantly reiterating the idea that programmers are just code-monkeys that only google things is, to put it bluntly, strategically stupid.
The Mythology
The idea that programmers just copy together all of their code is far from the only harmful idea out there though. Parallel to it, a much more harmful myth is that "everyone can code [on the same level]". Now, just as with drawing, music and many others, I do believe that everyone, without exceptions, is capable of learning the basics of programming.
However, it is simply a fact that not everyone has the talent to program something like the linux kernel. And this is probably one of the hardest truths to properly internalize: we don't want to be elitists, we want everybody to have a chance at joining our community. We want others to discover and enjoy our hobby, just as we did. And that's fine. I won't stop telling people that they can learn to code. But I don't want to keep spreading the lie that everybody can become just as good as everyone else. Some people don't have what it takes, and some people have talent that I just won't be able to reach myself.
So how does that persistent myth do any real harm? In the same way the Google and StackOverflow jokes do: by devaluing our skills and our work. If everyone can do a thing, then there's nothing valuable about it. If anybody can go to a boot camp and become a super-duper good programmer within a year or two of job experience, then there's nothing worth respecting about anything one can achieve.
On the other side, it sometimes seems that employers still haven't given up on the mythical plug-n-play developer that can be employed today and start being 100% effective tomorrow. It used to be that OOP promised developers who could be interchanged without any effort, and instead of just disappearing, this supersticion seems to just have shifted to the ridiculous belief that a developer can specialise in a specific tech stack to the degree where they can just be sat down before a project and they'll instantly know how to make the product better.
The End Game
Is all of this coincidence? Well, it probably is. I don't believe there's any mastermind about us programmers shooting our own leg and devaluing our own skills. However, there is someone who profits from it, and certainly has good enough reasons to help the process along occasionally.
I am, of course, talking about employers. There used to be a myth of software systems that don't need programming. Where anybody could just drag a few boxes around and the result would be a program that does exactly what it needs to, no matter how complex the task. Unfortunately for employers, and very fortunately for us employed and employment-seeking programmers, this never happened, and we've somewhat accepted that it just won't happen anytime soon.
What other hope is there to not have to pay well-trained and experienced professionals for their expensive time? The simplest answer is: make their time less expensive.
While observing the community discuss employment practices, specially in the USA, I'm routinely baffled at how comically and artificially imbalanced this whole process is.
More than enough people have written lengthy articles about how pointless and arbitrary the distinction between "junior" and "senior" developers often is, and have done a much better job than I could, considering this is not all that common in my country. I also often read about interview processes that just seem utterly lacking in any sort of respect for the applicant and their time.
The strategy seems obvious: gasslighting us all into believing we're of very low, if any, worth to the employers who so generously offer to grant us shelter from our own lack of practical skills. We're not corporate simps, we're just grateful that we don't have to sleep under a bridge. I am exaggerating, of course, but it does seem very clear that this is the general direction things are going. It's not a problem specific to our field either, but it might be more pronounced because of the rapid influx of newcomers, and the arcane image to the outsider.
While everybody can estimate how much skill and effort goes into, say, building furniture, it is very hard if not impossible to the uninitiated to get a feeling for how difficult it is to build a software product. It seems almost like black magic to the outsider, and this is another thing that people often joke about (sadly, the punchline is often that ultimately, we're not doing anything at all difficult).
The Remedy
It is hard to say what could be done to push programming back up the hill. There seems to be a strong culture of self-deprecation (probably adopted from broader nerd-culture), and a tendency to unironically under-value ones own skills in this community. The amount of posts I find about impostor syndrome every week on its own already indicates that we have a serious problem that needs to be addressed.
At the same time, our attempts to be kind to everyone might be pushing us further into the corner. Maybe we should develop a bit more of a "git gud" (git: 'gud' is not a git command. See 'git --help') attitude as the gaming world (sans the insults and trash-talking, if possible), that puts more emphasis on showing someone how to improve than to defuse their insecurities and feelings of insufficiency.
As for the focus on finding employment, I really think that needs to be toned down. Yes, it is easy to be excited about potentially turning your hobby into your job, or switch careers to something you found to be much more enjoyable. For some, programming might even be a unique chance for a better life. But for many of us it is also a hobby, and for me personally, it is as much an art as is music or drawing. I don't care about top 10 javascript interview questions and would much rather talk about all the totally useless and impractical but technologically cool and creative things you guys have built.
And please, don't sell yourselves under value. Programming is hard. Everyone can learn it, but few can master it. We're not just code-monkeys copying from google. And if you're learning: Try having fun and don't worry too much about maximising your employability.
In Conclusion
It's not like I think the world will end. Programming won't stop being my hobby, nor do I fear I some day won't find a job (at least not before someone develops an AI that does all the programming for us and understands human language). I want the world of programming to stay this quirky place, where people build cool stuff, share what they've built and discuss it with others. Ultimately I hope we can all have fun programming ๐งก
PS: Title image unrelated, but I have fond memories of when it was taken, so it seemed fitting.
Top comments (9)
Good piece ... well, programming any sort of moderately complex stuff still requires a heck of a lot of experience in order to avoid the pitfalls, and to tell the bad or mediocre solutions apart from the good ones, no amount of pasting from SO is replacing that.
The "thinking", planning and designing parts are where judgement and experience are STILL hugely valuable, that's what's not going to be automated away (think ChatGPT) anytime soon, or replaced by paste-from-Stackoverflow code monkeys.
Good employers (the ones you want to work for) know this.
But, the threats are there, we need to keep evolving and adapting or we'll go the way of the dinosaur (and you're right that we need to combat the myths and the fairy tales).
Good thoughts! Although I hestitated to click on "like" when I first saw this post because I was triggered that you said anything positive about "elitism" and that computing had become "too inclusive" in a way, when at the same time, both the deliberate toxic gatekeeping by certain people on StackOverflow, and an often unintentional preference for white dudes in companies still happens.
Apart from that aspect, I got a bit nostalgic about the textbooks and other memories of the time when computing was still only a hobby for me.
A mental leap in my comment made me mix up different aspects of discrimination.
Some people are deliberately gatekeeping on StackOverflow, probably with good intentions due to the conundrum that some posts get downvoted and deleted which shouldn't have, while there are still too many low quality posts. But the gatekeeping behavior leads to a "toxic" atmosphere keeping others from participating at all.
At work, a psychological bias makes people overestimate the skills of those who resemble themselves, plus a preference for "culture fit" makes mostly white dudes hire mostly other white dudes, at least in the companies that I used to work at.
Both forms of elitism are obviously not something to miss, so if I understand you correctly, you fear that the mainstream developer culture gets focused more on beginners and the good content will become hard to find, or that it might eventually lead to a proliferation of bad code (and maybe even bad user experience) everywhere?
Well, we already got all that. And what about the usability of software and hardware in the "good old times"? Try to use Windows 3.0, try to use CP/M, or write an application in COBOL. While in my personal good old times, I have been sitting in front of a home computer, playing games and experimenting with BASIC programming to produce some simple, but interactive and colorful animations, others sat in a dull basement office wearing an ironed shirt, writing boring code that must make no mistake when processing a bank transaction. Those must have been the old elite, but it does not sound much fun to me.
I hope for some "good new times" in the future.
I think I was a bit hasty in pointing out that elitism and gatekeeping are generally bad and it's a good thing that we're getting rid of them, although I did technically mention that at the start.
My point isn't "elitism is bad except when it isn't", but that the change in culture that accompanies the decline of elitism isn't going in a direction that I think is good for the community in general.
If the old culture of elitism and gatekeeping can be summarised as "You lack skill and should therefore be excluded", then it seems we are moving towards "We all lack skill and that's fine", instead of the (in my honest opinion) much more healthy "Everyone can learn and not everyone even needs to".
And this change seems to be tightly intertwined with the slow shift away from a sort of "software idealism" towards a culture that's more centred on a capitalist idea of value. E. g. "Good code" is no longer an intrinsic benefit, but needs to further the goal of building a better product faster, etc.
Ultimately, what I would want is a culture that emphasises improvement, and both includes everyone while still valuing programming both as a tool, but also as a form of art. And I'm also just really tired of the stack-overflow joke.
This is a fantastic quote (from the article) and describes the situation perfectly...
"However, in the process of wiping away elitism and gatekeeping in the software world, it seems to me, that in our excitement we are also throwing out valuable barriers that keep our world stable and nice."
This seems to be what creates the idea that only The New has any value. Anything from 2 years ago is old crufty garbage based on old ideas and must not be used.
This, however, seems to play right into the marketing of New Technologies ==> YAJL -- Yet Another JavaScript Library. You can never get to solid ground with this type of mentality.
This quote from the article is a perfect explanation of the situation too...
"The result is that these days, there's a much bigger emphasis on learning products over theories."
I notice that a many newcomers don't want to read any books on dev topics but instead only want to do online bootcamp or whatever. I think bootcamps are great but they really should be supplemented with books which can provide a much deeper understanding of the material. If you only learn from web sites and snippets and bootcamps where you build specific test apps then you don't always know what is really happening underneath.
Again, I think bootcamps etc are fantastic but what is really needed is some type of hybrid learning where a student learns how to build and then learns why you choose certain ways to build and what is really going on under the software. In some ways, developing apps for the Web Browser causes this. Seeing the "machine" only as the Virtual Machine of the browser doesn't let you see all the way down into the metal (hardware) of what you are actually doing. A layer of understanding is lost. Sometimes this doesn't matter, but often it does. Great discussion.
Having seen the university landscape, I can certainly agree that we need some sort of hybrid-approach. Pure book-smarts on their own aren't worth much in the real world of software development, but they are, at the same time, an integral aspect of being a competent developer.
I wouldn't say actual books are necessary though; I was never a big fan of programming books myself and much prefer reading shorter papers and articles. There's some very in-depth articles out there that explain a lot of theory.
Not only does it often matter in a very practical sense, like when trying to optimise languages that run on a VM, there's also often a whole lot of tricks to be learned by studying the underlying technology. Elegance of design is an almost universal concept in the world of IT and ideas from the bottom of the stack (that is, hardware) can sometimes be applied even at its top (say, javascript programs).
ุงูู ูู ุงูู ุชุณุชู ุชุน ุจู ุดุงูุฏุฉ Tranns
ุจููู ู ุตูุฑูุง ูุชูุงุฌุฉ ูุงุฐูุฑ ุจููู ุชู ูุฑูุจ
?