Developers seem to have an irrational love/hate relationship with programming languages. We tend to love the languages we use on a regular basis. And we seem to hate languages we don't or no longer use. I've come to refer to this as Developer Stockholm Syndrome.

As a quick aside before we get into the main content, there is endless debate about what constitutes a programming language. For example, many will say SQL is not a programming language. I say it is. Regardless, this post is about languages and language-adjacent entities and I use the term "programming language" to include them all.

Let's face it. Programming languages ALL have any number of large, glaring faults. A few are even mostly faults and have very little redeeming value. For most of my career, I have mainly been in the C#, SQL (primarily MS-SQL), and JavaScript (AngularJS) spaces.

Love/Hate

Let's start with C#. C# is a fantastic language and constantly getting better with each iteration. It used to be a lot worse. I especially disliked the fact it was Windows platform only. The biggest thing that's still wrong with C# is that 70% of error messages are close to completely, utterly useless. Trying to figure out what's wrong with a piece of code throwing errors without the help of some add-on like Oz-Code is nightmarish in nature.

Note: I used to be an Oz-Code subscriber but I quit after they changed to a subscription model. Still a great product though.

And then there's JavaScript. Entire volumes have been written on everything wrong with JavaScript. Literal terabytes worth of blog posts across the Inter-webs complain about how terrible JavaScript is. However, like C#, JavaScript has steadily improved over time. While it still isn't great, it is pretty good now.

angry face illustration
How SQL makes me feel sometimes.... Photo by Andre Hunter / Unsplash

Lastly, let's look at SQL. If ever there was a language that was spawned from the deepest, darkest corners of the most evil place you could think of, SQL.... Well, it's not in that corner. That corner would be reserved for ColdFusion. But just outside that corner, in the hallway, is where we would find SQL.

SQL is full of evil, hateful things: Pivot tables, cast/convert between types, string manipulation, setting up and maintaining proper permissions... The list of things that are painful in SQL is nigh-unto endless in nature. SQL should burn in hellfire and be cast into the void forever.

But SQL also has some amazing things to it. It's makes the description of relationships between data and accessing that data amazingly simple. It is one of the most ubiquitous, well known and well tested languages in all of computer programming.

There can be no doubt that all three of these languages, which have been my daily drivers for most of the last 10-15 years, have their good parts and their bad parts.

The Syndrome

Despite the glaring flaws present in every language, we tend to group programming languages into two camps: those we love and those we hate. With a small little section set aside in the middle for those languages we have not yet learned much about. To those languages we tend to be indifferent.

If we were to do a self-examination of which languages we have placed into each camp, I think many of us will fall into a certain pattern.

When we learn a new language, we tend to love it. And when we use it a lot, we like it. And that's the first odd thing. We tend to turn on our blinders and look past the deficiencies of a language.

When we talk to others about a language, we focus entirely on the good parts. We tell them how great things are over here in <INSERT LANGUAGE HERE>-land. We can go on for hours about this feature or that. Even though every single language has flaws that abuse us for hours and hours each week as we wrestle our code into functional submission, we still evangelize all the wonderful things about it.

We brush off any counter-arguments as nonsense or "no big deal" or "a huge exaggeration". And if others persist in their arguments, that leads us to the first side effect of this Developer Stockholm Syndrome.

You Are Not One Of Us

Over time, those who do not code as we do become "the enemy".  If you code in Java and I code in C#, you are the enemy. If I use Microsoft SQL and you use Oracle, you are the enemy. If I use the AngularJS library and you use ReactJS, you are the enemy. If I use the .NET Core SDK and you use .NET Standard, you are the enemy. It goes on and on.

The further we press ourselves into a language community, the more we tend to disagree with those who use something, anything, else. We see them as being "wrong" somehow. We'll go out of our way to explain to them in what ways their language of choice is not up to whatever task we deem it should be capable of. Sometimes we'll even go so far as to insult and disparage their choice, and sometimes them. And that's just sad.

I will be the first to admit that I've done this. As a C# developer, I have on numerous occasions over the years gone out of my way to disparage Java and those companies that insist, in their lunacy, on usi..... Oops, there I go again. Sometimes I can't help myself.

I'm trying to do better. We all need to do better, sure. But I need to start with me. And you need to start with you. I've found a lot fantastic guidance to help us change our culture as developers from April Wensel's Compassionate Coding blog and Twitter feed. Check it out. I highly recommend it.

image source: Starecat.com

Love Turns To Hate

The other odd side effect of this Developer Stockholm Syndrome is when we are freed from the grasp of a language. We change into doing something else. For me, I grew up learning to code on old style BASIC languages. First on a Sinclair, then later on a Commodore 128, then on to PCs. At the time they were the coolest thing in the world.

Now I have nightmares about GOTO and GOSUB and PEEK and POKE. On a couple of occasions I have indulged in nostalgia and played around with Commodore 64 emulators. While it was fun for a bit, a very short while, I quickly began to remember all the things I didn't like. Things are never as cool as you remember them being originally. Except Babylon 5. That show will rock for decades yet to come.

When the web first came into being and the very first web languages beyond basic static HTML arrived, I spent years playing around with ColdFusion. I loved it. It was the coolest thing ever. Then I left it behind. The "cool" faded and all I can remember now are the frustrations of trying to make it work, rebooting servers on a regular basis to fix memory leaks, debugging nightmares and database corruption.

When I went back to school to finish my degree, my first professional developer job was an internship writing ASP (now dubbed "classic" ASP) apps for the State Dept of Education. At the time... well, no, I never liked ASP. This was at the time that ASP.NET 1.1 had arrived and all the "real" developers got to work with that while we interns were stuck maintaining the old crap. We were jealous. I was jealous.

On graduation, I got hired on at a bank doing ASP.NET 1.1. AJAX was the new coolness and version 2 was on the approaching horizon. For some reason my boss decided I should code the back end in Visual Basic.NET instead of C#. So that's what I learned and did.

At the time, I loved it. But with distance comes the inevitable dislike, or at least a feeling of "meh". VB.NET is a perfectly fine language. But as time goes by, again I tend to feel less and less fondly about the time I spent coding in it.

After that first job, I've spent just about all my time on C#/SQL/JavaScript. But now I've moved into a position where I'm doing very little (really next to none so far) coding and I'm beginning to wonder if I'll start to feel less fondly about my time with C#, SQL and JavaScript.

The lack of coding at work will change a little over time as I learn more and more about the strange world of Microsoft Dynamics. And I am working a number of personal projects in my free time, so there really is no growing distance here. I don't think that will be an issue this time. But the fact that I've been thinking about it recently is enlightening.

The Effect

What I find most interesting is the attitude we tend to take about languages we are working with on a regular basis. We tend to at least like the language and ignore (as much as possible) the negative aspects of that language.

I think part of our ability to ignore those annoying aspects is that over time we have learned through repetition how to work around those defects. We do it almost without thinking about it. The more we have to deal with it, the more we learn to ignore. The longer we are a "hostage" to that language, the more we see only the good parts and our automatic blinders at least dull the negative parts from our minds, if not block it entirely.

We blithely go on, day after day, becoming more and more a slave to its quirky demands on our coding skills, until the day we become one with the language. We see just how right it was all along. We just couldn't see it until we understood better.

Clearly anyone who doesn't love that language is just... plain.... wrong. Don't be wrong. Come... join us.....

Note: this blog post is a bit tongue-in-cheek. While I'm trying to make a couple valid points, I hope you realized that it was not completely, 100%, totally, all-encompassingly serious. :)