There are many languages still in use today that have all kinds of warts and ugliness, but they remain in use because they still have momentum and lots of legacy things built in them. So being ugly or old isn’t enough of a factor for people to abandon something in droves.

Once you need to rewrite everything, there’s no reason to stay with something you know since you need to fully retool anyway.

As a Perl programmer since v5 was released, the confusion around 6 completely destroyed almost everyone’s enthusiasm, and immediately caused all new projects to avoid Perl. It seemed like 5 had reached the end of the line, and 6 was nowhere to be found. Nobody wants to gamble so many hours of their lives, and the future of their business, on such an uncertain environment.

If Perl 6 had any visible movement within the first few years, it might have survived, but it was a good decade before they even admitted Perl 6 might take longer than expected, and then more time after that before they admitted it should have been a new language. 6 was interesting for language geeks, and they probably did some cool things, but you can’t run a large popular project like it’s a small research project. That completely destroyed all momentum in the community. Perl 5 development only resumed far too late, after the writing was already on the wall.

Both Bill Gates and Linus understand backwards compatibility as a sacrosanct principle. Python only just barely survived the jump from 2 to 3. JavaScript can only survive this because there’s no other option in a browser.

1. It pulled away folks who would otherwise have spent time improving Perl 5 (either the core or via modules).

2. It discouraged significant changes to the Perl 5 language, since many people figured that it wasn't worth it with Perl 6 just around the corner.

3. It confused CTO/VP Eng types, some of whom thought that they shouldn't invest in Perl 5, since Perl 6 was coming soon. I've heard multiple people in the Perl community discuss hearing this directly from execs.

Of course, hindsight is 20/20 and all that.

Also, even if Perl 6 had never happened the way it did and instead we'd just had smaller evolutions of the language in major versions, I think usage would still have shrunk over time.

A lot of people just dislike Perl's weird syntax and behavior. Many of those people were in a position to teach undergrads, and they chose to use Python and Java.

And other languages have improved a lot or been created in the past 20+ years. Java has gotten way better, as has Python. JavaScript went from "terribly browser-only language" to "much less terrible run anywhere language" with a huge ecosystem. And Go came along and provided an aggressively mediocre but very usable strongly typed language with super-fast builds and easy deploys.

Edit: Also PHP was a huge factor in displacing Perl for the quick and dirty web app on hosted services. It was super easy to deploy and ran way faster than Perl without mod_perl. Using mod_perl generally wasn't possible on shared hosting, which was very common back in the days before everyone got their own VM.

All of those things would still have eaten some of Perl's lunch.

Before Perl, there was no scripting language that could do systems tasks except maybe shell and tcl, but that's shell is an extremely unpleasant programming experience and the performance is horrid, and tcl's string-based nature is just too weird.

Perl gives you something more like a real programming language and can do shell-like tasks and systems tasks very nicely. Compared to what came before, it is amazing.

But then Ruby and Python came along and checked the "real programming language" box even more firmly than Perl while retaining the shell/systems angle. Ruby and Python were better than Perl along exactly the same axis as the one on which Perl was better than Tcl and shell.

By the time Perl 6 was around, Perl's lunch was already eaten by Python. Only a few table scraps left. Perl 6 would have had to be a better Perl 5 and a better Python 2 to win.

Python came with better batteries and better syntax. It allowed producing code you could read and understand a week later. Perl I found was a write-only language for me. I went back looking at my old Perl code and I couldn't decipher it without some effort.

And Python became popular not just because it was a better Perl, but it attracted folks who used Java and C++. CPU speeds were getting fast enough that you could actually do file and network IO at acceptable speeds without all the `public static void main(String[] args)` and `System.out.println(...)` boilerplate, but still had all the object oriented bits like inheritance and composition with which you could go crazy with if you wanted.

Perl and Python were similarly powerful and useful languages, but I could learn and start producing useful code in Python after reading an hour long tutorial. Perl took an order of magnitude longer, and remained more awkward to use just due to the Weirdness. There was a momentum building in the early 2000s toward competitors like Python and Ruby that were seen as less crufty and more modern.

Perl's developers seemed to agree, since they cooked up their own competitor to Perl, an entirely different language confusingly called Perl 6. The coexistence of Perl 5 and 6 made the Python 3 transition look like a cakewalk -- at least it would have save for Perl 6's almost entire failure to exist for over a decade after its inception. It produced lots of constantly churning specs and blog posts about register based virtual machines with native support for continuations or whatever, but no implementation of a language that anyone felt comfortable using for any real development. Meanwhile people kept using the ossifying Perl 5 for existing applications, and gradually transitioning away as they were replaced.

Also PHP overtook it for the "just FTP a script to $5 shared hosting and make a webapp" use case.

1. failing to have a coherent path to Perl 6

2. Ruby (on Rails) taking over the workhorse task of serving up dynamic content that Perl had owned before then

3. Python completely dominating the utilitarian scripting/programming world in nearly every niche

Why did this happen? I was a work-a-day developer working in Perl v5 when this transition occurred and from my perspective and recollection v6's meandering development cycle -- which didn't really address the issues of the broader Perl community was the primary choice. Perl 6 was developed in a way that didn't address the broad concerns of the Perl community, and expected people to make a wholesale switch to what was effectively an entirely new language anyways. It forced people to go out looking and what they found were either stronger solutions to specific domains (Ruby on Rails) or a nicer language than what was being proposed (Python).

Where Python really excelled at the time was that it looked and worked very much like the pseudocode that was going around at the time, and had an opinion about how you should write your code. Perl is wonderful to write in, but in many ways is too expressive and permissive and it resulted in an ungodly mess that could be hard to maintain. Perl 6 simply leaned into that problem rather than encouraging a cleaner approach.

I never liked Python much, but damn if I couldn't argue that I was much more productive with it than Perl in the end. Which was weird because when I was really hacking in Perl I could write code almost as fast as I could think giving a kind of illusion of productivity. But Python was easier to integrate into a coherent team development structure and actual productivity is more important than feels.

I miss working in Perl. But I knew it was really finally dead when I was giving tutorial classes to new bioinformaticists who were being given old Perl codebases to update and they were getting through school without learning the language.

But I think the main thing that made it long term non competitive were a series of bad design choices all the way back to perl 4 or even 1.

Namely:

- the need for sigils

- weird sigil rules where the 0 element of @x is $x[0] not @x[0]

- auto flattening, ex. (@a, @b), and hence the need for manual reference management, as in (\@a, [1,2,3])

- lack of a native object system, and widespread repurposing of hashrefs as objects, with awkward field syntax $x->{foo}

- awkward function argument syntax: my ($x, $y) = @_;

These things add up, and both JS and python showed that all those can be done much more smoothly.

Another thing that counted at the time, is that PHP came out with a slightly worse language, but a super beginner-friendly approach to html templating and request lifecycle: you can just mix php and html in the same file, and the entire runtime environment is nuked at each request. The result was that php replaced perl for an entire generation of web devs in the early 2000s.

Even with those two options, you can't just write some code in a page and execute it without some sort of itermediate code.

Thats why php became so popular, perl coders could pick it up in a day ($ and all) and all you have to do is write .php files to a server - with the bonus that you have a rudimentary templating system built-in to php.

There really isn't much more to it than that.

- Perl's fascination with punctuation makes it hard to google for stuff, since search engines strip punctuation. In an era of RTFM and grep, maybe this is okay, but puts the language at a substantial disadvantage vs languages that use more prose than punctuation

- The distinction between scalar vs array context is subtle and feels somewhat pointless if you learned a language like C or JavaScript first. C has no overloads but manages to work fine, and other scripting languages like JS or Python let you branch on the runtime type of variables explicitly. Why bother with array context?

- Similarly, people got used to having named function arguments in their function signatures. Maybe in an era where most code was either compiled (and had named function args), or was stringly-typed and scripting like Bash, Perl feels like more of the same. But once we started getting decent scripting languages that had named function args, it became a real pain to repeat basic stuff like "assign parameter 1 to variable $name, assign parameter 2 to variable $age" in every function. I wish shells would bite the bullet and figure out a way to adopt them.

Overall, our industry is moving towards larger scale and complexity, and at larger scales, reading and maintaining code is more important than writing code. Perl's language design choices are all balanced for 1-10 unix wizard authors having fun writing small scale scripts. Compare it to Java, the Anti-Perl: today scripting languages like Python, JavaScript are getting closer to Java or ML with compile-time type checkers and sophisticated type systems. Few new or existing languages are getting similar to Perl.

I don't think Perl 6 had anything to do with it. I wrote a lot of Perl5 in college, and didn't particularly want to write any more Perl5, or adopt Perl6.

I was in college 1999-2003, I did PHP in an internship, and then later did some Perl in one of my classes.

Perl (in my college class) was so incomprehensible that I decided that I would avoid it. I've never applied to a job that uses Perl, and never responded to a recruiter that was looking for a Perl engineer. I've never had to use it at work, and fortunately I've never worked with anyone who wanted to use it.

I think it's best to think of Perl as a transition technology.

I was a Perl programmer, and I looked down my nose at PHP. Silly me, then and now

Why did PHP, an objectively a worse language, win?

Rasmus Lerdorf said in a quote I can no longer find, it was modperl vs. modphp for Apache.

Modperl was, typically for Perl, very comprehensive and allowed access to all the Apache processing hooks

Modphp was, typically for PHP, just enough to speed up rendering so only allowed access to the barest minimal set of hooks

Modperl, so much better (I can hear myself say 30 years ago)

But at the time most websites, by count not by traffic, ran on shared hosts where the system administrator gave you access to software. If they installed mosdperl you would be able to intercept, read, and change traffic for all websites hosted on that machine

Modphp, not so.

So PHP was widely available to the pioneers in the day, people scratching together a little web hosting business and growing . Perl was not

Not enough on its own to kill Perl, but an important nail in its coffin

PHP had replaced CGI as the easiest way to get code on a webserver, Python and Java were easier to read and understand, easier to structure large systems with, and generally easier to use. Ruby came along and MVC frameworks became the thing for complex web platforms.

Meanwhile Perl was sorta keeping up, the "Modern Perl" movement helped dispel myths about "write only" code, things like Moose, DBIC, Catalyst, Mojolicious, etc meant you could write pretty modern stuff with it. But the community was smaller, fractured by Perl 6 and dominated by some ahem divisive characters which made it intimidating for newcomers, and it just slowly died from there.

By the time Stack Overflow came along it was easy to see that other languages had vibrant communities surrounding them and for me it never really recovered.

Perl can be very well written. I deeply regret not encountering Perl Best Practices when it came out.

It used to be my goto language for quick and dirty scripts that needed somewhat non-trivial text processing.

Anyway, this made me think of the 2008 Damian Connway Perlcon keynote:

    "Temporally Quaquaversal Virtual Nanomachine Programming in Multiple Topologically Connected Quantum-Relativistic Parallel Timespaces... Made Easy"

It was worth fighting with Perl's syntax because it was the best option for web programming (for random amateurs like myself). Web hosts often didn't have C compilers available so C wasn't an option. TCL was workable but not as prevalent as Perl on web hosts. Same with PHP3. Keep in mind this was an era where you were deploying on machines you didn't on which you didn't have admin access. Most of the time you didn't have shell access on machines you'd deploy on.

As Linux adoption on servers exploded so did the deployment of PHP. It was easy to deploy PHP web apps since they could be readily dropped in your htdocs or public_html directory and be handled by the server. Enabling other CGI outside cgi-bin directories was uncommon.

So by 2000 or so there was no reason to learn Perl to do web stuff easily. You could do it in PHP which was already a templating language. The younger version of me that wanted to do web CRUD stuff bought a PHP book instead of a Perl book. With Python 2's release at that same time if you wanted to do portable non-web stuff you had a much nicer language than Perl available as well.

For me, that's the answer to this question: Ruby had all the stuff I liked from Perl, and didn't have the stuff I didn't like. It's just that simple.

Also, Perl's strength was text processing in a world where data was moving out of simple columnar text formats and into databases, xml, json, and other formats better represented by object models than lines of text.

One day, around 2000 or so, the author/maintainer, a well-known guy in the Perl community, updated the package with an incompatible API. If you used that package, you had to update your code. There was no backward compatibility, nothing. To make things worse, the README stated that it would AGAIN change API in the future, but he didn't know yet what the change would be.

I considered this disastrous maintainer behavior, as I'm sure anyone reasonable would. It was clear I had to stop using this package, and anything else this guy could get his claws on. But there really wasn't a massive outcry that I could see, nobody calling him out for this crap.

That's when I knew I had to stop writing code in Perl. I tried Ruby but found it unstable at that time. Next project I used Python, and never looked back.

For moderately advanced text processing with regular expressions, supposedly its strong point, it was far less elegant and concise than AWK at the low end and far less readable and less batteries-included than Python for more complex tasks involving some integration.

For dynamic web pages, another of the main uses of Perl, PHP was purposefully designed and (while not really good) practical and user-friendly, with plenty of other obviously more robust and serious options (Ruby, Java, later Python, etc.) for more enterprise projects.

A year later I tried to use that script on another project, but had to make some changes; and couldn't make heads or tails of it. Shortly thereafter I had occasion to look at some Tcl/Tk I'd written at about the same time...and it made perfect sense to me.

Had I used Perl on a daily basis, rather than occasionally, I might have stuck with it. Instead I switched to Tcl/Tk, and never regretted it.

I used it in probably one of the more cursed contexts I've ever heard of. Understand[0] is a static analyzer for many languages, and one of its killer features is that it is programmable with a Perl API. I used this feature at a defense consulting job to help target audits of huge, multi-million LOC codebases.

Perl's expressivity was very useful here. I cut my teeth on functional programming concepts to write some very nice traversals. The runtime environment of the host program was a nightmare to deal with though.

[0]: https://scitools.com/

Python evolved, PHP had 1000 times more "how to get started" articles, Node happened. And LAMP became the default for noobs.

This is evolution. Not death. It found what are its strengths that would make it relevant today and it made the leap of faith. That is remarkable.

No one need to switch to Perls 6 and Perl 5 can evolve incorporating incrementally stuff from Perl 6. Not every core team has the time, the $$$ or the devs to put forward long term plans of compatibility.

People always expect "someone" to do it.

What Perl 5 people could do, is improve its code base, clean it up and use sane software engineering practices to make code boring, modern and much more friendly for contributions.

You know, the anthropic side of software.

But I think the package management and culture killed it for me. People took pride is writing obnoxiously messy code. Package dependency hell. Gung ho borderline toxic RTFM culture.

That said, we re-wrote all of our monitoring scripts in....Bash.

Ugh.

It is a great language for quick and dirty scripts, one liners... But no one wants to start a big project in Perl, and I think for good reasons. With only the "quick and dirty" use case remaining, people didn't want to invest into a language for that, it is throwaway, that's the point. So it was left to die slowly.

I don't think that Perl 6 took away the Perl community, I don't think the people on Perl 5 and the ones on Perl 6 were of same kind, the former just wanted to continue using their "Swiss Army Chainsaw", while the latter wanted to design an innovative language. It has created some confusion, but I believe it is minor.

If I want to point at one thing that killed Perl, I would go with PHP. Websites were a common use case for bigger Perl projects. Now that PHP does it better, what's the point of Perl for that application?

Perl 4 was a great upgrade to bash as a scripting language. Perl 5 added a bunch of complexity to remake Perl into a programming language. It failed.

Perl 4 was a great scripting language whereas Perl 5 was a terrible programing language. Perl 5 lost to the better (dynamic) programming languages and bash reclaimed the scripting title as Perl 4 was dead.

> Binary package managers that chase down dependencies on their own weren’t a thing until the early 2000s, I think?

UNIX package managers started to be made available during the 1990's.

(Side note, I know "slim" containers are all the rage these days but please please please please just put curl in your unix containers or provide a script that lets me check the container health. I don't want to spend more than 5 minutes setting this up or I'll just look for something else)

Python claimed to be simple - which fit well with the "line noise", erm... propaganda.

More importantly, there's hardly a problem that can't be solved in a much better way through other means.

I think its just one of those things, they lost mindshare and people stopped making stuff in perl. Network effects made it snowball from there. How often do you see code examples written in perl? Almost never. I see people write blogs with code snippets in python, c, rust or even shell all the time. Never perl.

Momentum matters and perl lost it. I think of perl the same way i think of cobol or fortran.

Especially for the type of users were Perl had gained some ground in the past...data science, DNA related stuff, etc. Non programmers.

If you look at just about any other language and how you would pull data in and out of json yaml, manipulate individual elements, etc... the Perl is just hard to decipher if you don't have immediate recall of all the crazy syntax for dereferencing things.

I completely discount the basic syntax as an issue. Sure, it is an easy thing to complain about. But I've personally seen a number of people with no background master the basic syntax very quickly. In fact I was able to teach myself from the Camel book with absolutely zero background in the various languages that are supposed to help you. And during the dot com era, most of the people writing CGI scripts in Perl, similarly lacked a programming background.

The first issue was the fact that a lot of bad Perl got written. It was remarkably easy to pick up a bit of Perl, then write a bunch of code. This code was generally bad, useful, and full of security holes. (Thanks, Matt Wright.) Most people's exposure to Perl was to this kind of code, and it left a permanent bad impression.

The TIMTOWTDI (There Is More Than One Way To Do It) philosophy fed into a widespread cowboy philosophy. People took pride in their mastery of Perl, and demonstrated it by using obscure features. Like, say, C++, many subsets of Perl make for good languages. But if you try to use all of the features at once, the combination doesn't play well together.

That said, there was a significant group of people who grew and improved together. They learned best practices, wrote good CPAN modules, and elevated their game. But this group fell into a different trap. They learned the immense productivity of small teams. But organizations filled with small teams of senior programmers, don't have a way to mentor junior programmers. This cut off the pipeline of future developers. Losing that pipeline is an organizational threat. How do you find maintenance programmers down the line? Many organizations that had a lot of Perl, then put a lot of work into trying to move away from Perl. A significant number of Perl programmers saw the writing on the wall, and took the opportunity to move away from Perl themselves. This resulted in very few new companies being built around Perl.

(Incidentally the same "no pathway for junior programmers" problem is becoming a big issue for programming in general because of LLMs.)

For the next problem, we have to go to perl5-porters. The group that maintained the core of the language.

Let's start with a key individual. Tom Christensen. Brilliant, productive, and a technical genius. But also confrontational, unstable, and a toxic influence that shut down Perl development. This was a major reason why the Perl 5.6.1 release took over a year to get important bug fixes out. Tom also drove a number of people out of the Perl core.

Then there was an underlying tension between two major groups. The first were people who wanted to take Perl, and run with it. Adding all sorts of new and interesting features. The opposing group was those who cared about production, and wanted to be reaaally careful about breaking anything.

This lead in 2000 to a famous cup throwing incident by Jon Orwant. Larry's solution was to behind the scenes put a muzzle on Tom, and start the Perl 6 effort. That way people who wanted new features could go off and play in the new sandbox, while those who wanted to support existing Perl could stay in Perl 5.

Over time a lot of the good ideas in the new sandbox got ported back to Perl. See, for example, Moose. The spread of these technologies meant that there was a lot of progress within the Perl ecosystem. Unfortunately this came as the Perl ecosystem itself was shrinking. The language itself improved a lot. But the programming world in general didn't notice, and didn't care.

Anyway, I feel Perl's popularity was hugely exaggerated in the mid to late 90s and early 00s. The alternatives were either not there in terms of language and toolchain features, ease of use, "whipuptitude" or whatever, or library support (CPAN was a killer app), or they were too old school or enterprisey. Sysadmins were using it everywhere so it got into all sorts of systems that other languages couldn't without much more faff.

Its back compatibility meant it stayed in those places for a long time. It's still in a lot of those places.

The fall in popularity the last decade or two was more of a regression to the mean, or perhaps below the mean. Many other languages have come along, which have contributed even more to the fall in share.

Yes, yes, Raku (né Perl 6) but I'd argue that also contributed to a lot of really good stuff on CPAN. The Perl 5 core did get neglected for a number of years, as @autarch says, which may have been a factor.

[^1] previously: https://leejo.github.io/2017/12/17/tpc_and_the_end_of_langua...

I worked at a company that had a 50k bash/perl install script maintained by the 3 person QA team.

Dear lord that was a mess.

What I miss from then are the O'Reilly books about Perl. Peak O'Reilly. Every one a joy to read and packed full of goodness. Without being 1,000 pages long. Oh, and CPAN.

Perl 6 was only ever a distraction - I was already out of love with Perl by then and Ruby (and obviously Rails) came along at the right time for the next project.

Jim Weirich was a heavy perl user for a long time, and we were both involved in the Cincinnati perl mongers group. He found ruby and fell in love. He thought Ruby would be a good fit for me and we had a long conversation about why he preferred it to perl. It took me a few years, but I eventually took his advice. As usual, Jim was right, and I haven't written any perl since then.

tl;dr: for me, ruby killed perl.

Which is to say, the customer facing web interface, ordering, management and our own management back ends.

Obviously the actual storage component employs no interpreters of any kind.

Alive and well!

[1] https://0x.co

It was a combination of things, the Perl 6 announcement was one of the smaller parts actually.

- TIMTOWDI lost against "batteries included", and it lost big: It's not so much that the simpleness of the Python language won over Perl, the real and absolutely major problem at that time was the success of CPAN, which "killed" Perl 5. Perl 5 would have needed ONE object system, ONE base exception class, ONE way to do function signatures. Instead at the time, it came bundled with a bunch of Perl 4 utilities which nobody dared unbundling, CGI and a handful math functions. Being able to pick is nice, but everybody else did pick, too, and so if you used any CPAN dependencies, you soon had 3 incompatible object systems, 4 type systems, 5 exception systems co-existing within your project. A problem Perl has to this day and the reason why my team tends to re-implement stuff instead of pulling in dependencies. Python's "batteries included" approach easily won out, because stuff worked with each other and you didn't burn then scarce RAM on having different implementations of the same thing.

- Perl started to lose at the low-cost hosters against PHP already pretty early. It was easier during a certain time period to have a halfway performant PHP installation than a performant Perl installation. Hosters usually only offered CGI for Perl, not mod_perl, while PHP usually was offered as FastCGI module or mod_php which supposedly was easier to install. No low cost hoster wanted to mess with mod_perl, because it always was a hassle to setup.

- Speaking of mod_perl, things in the web dev sector still stayed pretty stable as long as Apache 1 ruled. People had to use mod_perl, but then you had a pretty performant solution. Then Apache 2 came around but mod_perl 2 wasn't ready for a long time (honestly I don't know whether it ever became ready). The Perl community at that time appeared entirely unprepared for that. While Python users were accustomed to run standalone Python servers behind proxies, Perl always was relying mostly on mod_perl. But threading in Perl stagnated and ran against a wall, and Apache 2 preferred multi process multi threading modes versus the simpler prefork multiprocess model that Apache 1 and mod_perl 1 ran on. This was the time were you could basically feel the creaking and everything breaking apart: suddenly there was no clear path forward, with mod_perl2's stability issues and the general threading stability issues of Perl 5.

It took years for the community to recover from that and focus on things like the Python-inspired PSGI/Plack as a way forward.

So, how does Perl 6 fit into this? Yes, in the early 2000s we did think, it would be just around the corner and be a clear upgrade path and solve everything wrong with Perl 5. Nice fantasy at the time. But at the same time, people were busy with far more pressing immediate problems, like how to migrate away from mod_perl1. When Python's WSGI and soon after that, Ruby on Rails came, they pressed directly into the vacuum left open by the mod_perl 2/Apache 2 disaster and this is actually what sealed the deal, IMHO.

(Worked out well I suppose? Almost 1/4 century and still using Python)

https://www.tbray.org/ongoing/When/200x/2003/07/31/PerlAngst

In the early aughts, Google SRE recruiting had such a strong, selective focus on A-player sysadmins with Perl expertise that it drained the market of top talent. Within google these people began to adopt, and eventually create and evangelize newer, Googlier programming languages.

In other words, Perl expertise was the skills filter, and Perl itself a technological ancestor of certain modern languages like Go.

Python was more opinionated, and better able to integrate with external libraries. A lot of the heavy lift in python is really invoking external code from elsewhere. You can solve “real” problems with readable code without the learning curve of C or Java.

Not the language, but the easiest setup ever.

I still have nightmares about the time we were trying to write the server part of a distributed filesystem (the precursor to Lustre) in Perl.

the ever infusion of new blood is what made Javascript & Python to be in top 3 languages today. Even though things like Ruby were easier for some. Ruby not being easily installed on windows back then stopped new blood as well.

for language designers / framework designers -- make your stuff easy for beginners then it easily grows.

Would Python have been able to compete, in a world where Perl could be readily comprehended by LLMs?

So, maybe what killed Perl was lack of VS Code forks and lack of being agentic.

a bunch of other things (java, ruby, js) replaced cgi scripts and mod_perl as a web backend environment.

python became a "must know" to interview at google.

old perl was neglected and became unreadable.

perl itself became ugly to eyes used to modern languages.

the perl 6 mess and associated sentiment made it look worse.

it was time for it to go anyway.

(map { $~ =~ s/.*/$&/r } split /\s/, $^W x $/ ) ~~ tr/a-z/x/r x $!

The language had many strange quirks and every question I posted about its particularities was greeted with responses along the lines of "Are you even trying? How do you not get it? Did you even read the docs?"

Well, yes, I did, and I still didn't understand, because I found them unclear.

I left the job and dropped the language and moved on to greener pastures without much regret. And it seemed like many, many people I spoke to had similar experiences with it.

When the team departed, Perl lost its development velocity and Python wasn't that far behind.

It's the only programming language other than C which actually needs a tutorial on how to use arrays of arrays. It's a part of the standard Perl doc, appropriately named "perllol": https://perldoc.perl.org/perllol

Most popular languages (Python, JS, Java...) as well as classics like LISP manage references transparently - the distinction between "array" and "reference to an array" is abstracted out.

In Perl, it isn't. It's a language with some archaic elements of manual memory management and parameter passing quirks. It's very clear that Larry Wall was not guided by programming language theory or math-inspired abstractions, but "whatever shit would be easiest to implement" (from https://perldoc.perl.org/perlsub#SYNOPSIS):

> ... any arguments passed in show up in the array @_. The array @_ is a local array, but its elements are aliases for the actual scalar parameters. In particular, if an element $_[0] is updated, the corresponding argument is updated

Theorists described call-by-value, call-by-reference, etc. But our man Larry came up with pass-via-a-local-array-but-its-elements-are-aliases-for-the-actual-scalar-parameters. I can see how one can quickly hack this together. But maybe it's time to retire this.

One of the biggest fumbles in the history of computing. (With hindsight ofcourse..)

Perl stems from a time where COBOL, FORTRAN, and SQL made sense and it was already mind bending for those accustomed to those old languages.

Modern minds can't comprehend Perl.

I found myself defending it more and more online against the folks who were nay sayers - those who complained about its syntax and it's quirks - but that wasn't a problem for unixers who used sed/awk/vim and all the other arcane tools. Perl wawa means to and end and it was the best tool to reach for (the glorious Swiss army knife).

I guess there was an infection period - the brain drain to python and Ruby meant it was harder to find decent quality libs on CPAN anymore as folks would only do things in python. And Yea, while CPAN is still rich, it's not the first hit on Google anymore.

Today, the map-sort-map Schwarzian transform is still the easiest to do in perl than any other language and it helps me whip up the throwaway scripts quick. Wouldn't change the language - I really love it!

You can call it dead. That's fine. Keep it unpopular. Popularity kills. Popularity leads to a language becoming dozens of different incompatible things. Perl is quietly amazing. I write once and run anywhere, anytime. Other languages can only dream of this.

Python3 almost killed Python.

It’s a tale as old as time.

[1] https://news.ycombinator.com/item?id=44726347#44752240 [2] https://perldoc.perl.org/functions/-X

[edit: also, even his own graph of "releasers" shows that if current trends continue, there will be essentially 0 "releasers" in 10 years]

The enterprise, who either did not have any webapps or had tried Perl CGI first and suffered it dearly, got pinged by their sales reps that Java and .NET (depending if you were a IBM, Sun or MS shop) were the way to go, and there they went with their patterns and anti-patterns for "scalable" million-dollar web stacks. That kicked-off the age of the famed application servers that resist up until today (Websphere, Weblogic, etc).

So Perl went back to being a glue language for stitching up data, C/C++ and shell, and that's how the 2000s went by. But by then, Ruby and Python had more sane communities and Ruby was exciting and Python was simpler - Perl folks were just too peculiar, funny and nerdy to be taken seriously by a slick new generation that coded fast and had startup aspirations of the "only $1B is cool" types. Also the Perl6 delusion was too distracting to make anyone event care about giving Perl5 some good love (the real perl keeping servers running worldwide), so by the 2010s Perl was shooting down to collective ostracism, even though it still runs extremely well, fast and reliably in production. By the 2020s the release cycles were improved after Perl6 became a truly separate project (Raku, renamed in 2019), the core has gone through a relative cleanup and finally got a few popular features in demand [3]. The stack and ecosystem is holding up fine, although CPAN probably needs some good tidying up.

The main issue with Perl at this point is that it has not been a target for any new stuff that comes out: any cool module, library, database, etc that is launched does not put out a Perl api or a simple example of any kind, so it's up to the Perl community to release and maintain apis and integrations to the popular stacks on its own, which is a losing game and ends up being the nail-in-the-coffin. By the way, nothing (OSS) that comes out today is even written in Perl. That reduces even further the appeal of learning Perl.

Strangely enough, lately Perl has seen a sudden rise in the TIOBE index [4] back into a quite respectable 9th position. TIOBE ranks search queries for X language and is not much of a indicator, being quite noisy and unreliable. My guess is that those queries are issued by AI agents/chats desperately scraping information so that it can answer questions and help humans code in a language that is not well-represented in the training datasets.

[1] mod_perl was released in 1996, and became popular around 1999: https://perl.apache.org/about/history.html

[2] PHP was released 1994, took off ~1998 with PHP3: https://www.php.net/manual/en/history.php.php

[3] Perl's version changes simplified: https://en.wikipedia.org/wiki/Perl_5_version_history

[4] https://www.tiobe.com/tiobe-index/