Retraction of an Obituary
Tags: culture, coding
Published: 2018-12-28 03:19:04

---
title: Retraction of an Obituary
published: true
description: Among programming languages, the claims of death are greatly exaggerated.
tags: culture, coding
cover_image: https://thepracticaldev.s3.amazonaws.com/i/jlihu4c3xxpxi4u3kp2a.jpg
---

I have an announcement...

**Javascript is dead!**

![Graveyard](https://thepracticaldev.s3.amazonaws.com/i/9ggh5hbiur0tqrcky8qx.gif)

Okay, now, be honest. How many of you just had a momentary flash of "ooh, crud, so what should I do my project in instead?"

Rest assured: Javascript is *not* dead. You can keep doing your JS project with no fear. But that one stray statement had an effect. Imagine if the rest of this article had built on that premise. How would people respond?

I've heard some absolutely stunning death proclamations over the past year. Perl is dead! C++ is dead! Java is dead! LAMP is dead! Python is dead!

We have a massive problem in the programming world, and it ain't the platform death rate.

# Define "Dead"...

We throw this term around a lot, but I don't think many of us actually understand what "dead" implies. Maybe Mr. Webster can help us.

> Deprived of life; -- opposed to alive and living; reduced to that state of a being in which the organs of motion and life have irrevocably ceased to perform their functions; as, a dead tree; a dead man.

I think it's pretty clear what Noah is getting at. **Dead is...dead. Not growing, not living, not viable.** Nothing's happening. When you're dead, you're worm food.

![Worms](https://thepracticaldev.s3.amazonaws.com/i/l2r4sqho30ny2yeqwiu7.gif)

Maybe it would help to provide a technical example of dead for you...

![Visual FoxPro](https://thepracticaldev.s3.amazonaws.com/i/vm0w279us12tj6k9nrtx.gif)

Visual FoxPro was discontinued in 2007. As of 2015, it has reached end of support. It wouldn't be possible to build and ship a Visual FoxPro project today, no matter how much you wanted to. **Visual FoxPro is dead.**

[EDIT: I have to retract *that* obituary too! As Herb Wolfe pointed out in the comments, it is not only possible to develop with FoxPro today, but it has an active community. I even found an [open source clone](http://foxincloud.com/opensource.php). Surprise, surprise!]

Now, by contrast, let's look at the claim that finally prompted me to write this article. "Ruby on Rails is dead." According to him, except for a few rare fringe users, no one builds anything meaningful with Ruby on Rails anymore. Let's think about this...

* DEV is literally built on Ruby on Rails!
* Rails just released version 5.2.2 on December 4, 2018
* There are 718 open pull requests right now on their official GitHub.
* A literal *conference* for Rails is slated for Spring 2019 in Minneapolis.
* THE WEBSITE YOU'RE CURRENTLY VIEWING IS BUILT ON RAILS! (It bears repeating.)

Ruby on Rails fails to meet even one criteria of "dead". I could make similar arguments for Perl, C++, Java, Python, LAMP, and so forth.

Even older languages like C, FORTRAN, and COBOL couldn't actually be considered dead. They're still supported on virtually all modern operating systems, and have strong, enduring roles in their respective domains. If you doubt me, walk into a room of Linux developers and shout "C is dead, amirite?" (Pro tip: wear a helmet when you do. It'll protect you from the rocks...although not the derisive laughter.)

# Dead...To Me, Anyway

Clearly, the programming community is not using the term "dead" in any sort of sane and reasonable fashion.

When we say "X is dead," we're usually meaning "X isn't popular," meaning in turn that "X isn't the shiniest new thing out there." To me, that makes us sound like a bunch of nattering middle school girls.

"Like, did you see what Cindy is wearing? That dress is, like, so last week. I'm totally not inviting her to my party this weekend."

![The cool girls](https://thepracticaldev.s3.amazonaws.com/i/6nua33gme9rhdi1rb69b.gif)

The problem, of course, is that sort of assessment is based **purely** on the subjective opinion of the masses. When we parrot that "Ruby on Rails is dead," we're likely citing nothing more than the opinion of some random group of programmers with the attention span of a juvenile golden retriever.

![Squirrel!](https://thepracticaldev.s3.amazonaws.com/i/6mo5pk6pvv8u0dpttfbe.gif)

Sometimes, of course, we're not actually basing our "X is dead" assertions on any mass opinion...we're basing it on own own. I've heard so many people individually claim that "C++ is dead," merely because they didn't like the language: manual memory management, pointers, compiling...it gave them hives. And *that's fine* - they don't have to like the language.

However, as with Ruby on Rails, C++ is very much alive and well - C++17 just rolled out recently. It's also one of my favorite languages. I employ it for use cases that I find it is very well adapted for.

So really, what these people are saying is "C++ is dead...to *me*. I hate it. I wish it would go away."

![Dead To Me](https://thepracticaldev.s3.amazonaws.com/i/f8lzcady6ggmhax2pbxf.gif)

Personally, I hate Javascript, and I wish *it* would go away. But even 20 years from now, if Javascript has fallen out of favor with the masses, I'm probably not going to be writing any articles on how "Javascript is dead," because it won't be!

But honestly, **what does it matter if the technology is popular**? If it meets the needs of the project, if it enables the developer to solve their problem and ship viable software to their target audience, and if it provides them with a development experience they personally find productive and rewarding, **who cares** what anyone else's opinion is about it?

# What's The Point?

So why does this matter, anyway? If we're all clear on what we mean by "dead," what am I going on about?

It's simple: **Words matter!** Not everyone is aware of our middle-schooler definition of "dead," nor should we force them to embrace that connotation. **"Dead" has a precise, meaningful definition that rightly discourages us from making use of a quantitatively non-viable technology.**

Remember at the beginning of the article when I declared that Javascript was dead? You probably (though not definitely) had a brief emotional reaction, even if you *knew* it was a viable technology. The connection between communication and human psychology is a weird one, but it's *very* important! Just as you would not choose to hire a graphics designer if you were informed he or she was dead, and just as you would not buy a parrot if you knew it was dead, it just feels inherently wrong to use a technology you've been told is dead. It becomes a mental speed-bump.

![Dead parrot](https://thepracticaldev.s3.amazonaws.com/i/wv055h1b1cdnl0d0a6qf.gif)

In other words, when we call a viable technology "dead" on the basis of popularity or personal opinion, we're actually *manipulating* others to make a technical decision that conforms to our whims, whether we mean to or not! Even if the other person knows about our popular misinformed connotation of "dead," they'll still have that mental hiccup.

To put that another way, to declare a viable technology as "dead" is to **actually put a psychological roadblock in the way of a person picking the best technology for their project.** And even if your intentions are good, by doing that, you are literally presuming that you're in a better position to make technical decisions for someone else's project than they are!

# The Benefits of Being Unpopular

I've written about [fads in programming](https://dev.to/codemouse92/all-the-cool-kids-are-doing-it-dm8) before, so you may recall when I said...

> An innovation only becomes a technology fad when we start mass-adopting it on any basis other than its own merit!

When a technology falls out of mass favor, it settles into a much more stable role in the use cases it is best suited for. It will go from being adopted for reasons of *popularity*, to being adopted for reasons of *suitability*. Ongoing development, as well as the technology's community, will become better focused on the technology's strengths, often by merit of ignoring those use cases the technology is *not* well suited for.

By way of historic example, look at C, FORTRAN, and COBOL. All three were extremely popular in their day, and people attempted to use them for just about anything they could. Later, as their shine wore off, and the masses moved on to glittering new horizons, those languages settled into the uses they were best suited for.

Even today, C is the underpinning of most systems development, providing what is still some of the most reliable "bare-metal" access. FORTRAN is a pillar of scientific computing, trusted by NASA, CERN, and many other organizations for their most critical code. And COBOL is involved in the majority of financial transactions, even today, owing to its speed, portability, and superb mathematical accuracy.

These languages aren't just being coded in by a few has-been fringe developers and acne-ridden enthusiasts. They're real, professionally viable technologies.

Some day in the future, C may give way to Rust, FORTRAN to R, and COBOL to, honestly, nobody knows what right now. The cycle always goes on, and nothing lasts forever.

But in all seriousness, **languages don't die very often**. Even the much derided Ada lives on, with its most recent stable release coming out in February 2016. The increasing dominance of open source only serves as further insurance that most languages, once established, seldom die.

[In thirty years](https://dev.to/codemouse92/a-trendy-article-from-2048-3e48), I'm sure the cool kids will all be mocking the Python, Javascript, Rust, Haskell, Go, and Java developers for sticking to their "dead" languages.

But, honestly, what does it matter whether our tools are popular or not? So long as Phillips screws are sold at my local hardware store, I'll keep using my Phillips screwdriver. In fact, I guarantee that I'll be fixing a brand new, high-end computer thirty years from now, and take out about two dozen Phillips screws.

Yet, no one is writing articles praising Phillips screws anymore (at least, not that I know of,) but that doesn't make any difference. They work.

"Will this fit the needs of my project" is the only question that should matter in choosing technologies!

# It's Alive!

Reports of Ruby on Rail's death were greatly exaggerated...along with nearly all similar "X is dead" proclamations.

We have a responsibility to each other, especially to the beginners coming in behind us, to *not* make each other's jobs harder! You don't have to love every technology out there, but don't confuse your opinion of a language with its viability, and then go confuse another developer as to whether that language is even worth her honest, objective consideration.

*That language* isn't dead. *That language* is very much alive, with a community of intelligent developers using it to produce valuable, viable software.

So quit trying to tell us it's an ex-parrot. We're not interested in trading it in for a slug, no matter how shiny it is.

---

Read more...

* [You're Doing It All Wrong](https://dev.to/codemouse92/youre-doing-it-all-wrong-3m7c)
* [A Trendy Article From 2048](https://dev.to/codemouse92/a-trendy-article-from-2048-3e48)
* [All The Cool Kids Are Doing It](https://dev.to/codemouse92/all-the-cool-kids-are-doing-it-dm8)
* [Beware the Trendites](https://dev.to/codemouse92/beware-the-trendites-26d)