Perl is by far the worst widely used language that I have ever seen.

I will bite.

I think this perception is prevalent because Perl was most popular before programmers knew how to program. (We still don't, but we are doing much better than we were doing 10 years ago.) Perl was especially easy to use, and attracted many non-programmers (or programmers who "didn't care"), and this left a bad taste in many people's mouths.

The thing is, everything of that era sucked. C sucks ("Segmentation fault (core dumped)"), C++ sucks (diamond inheritance, no type safety), Java sucks (no way to reuse non-trivial code), PHP sucks (no lexicals!), etc. The common thread there is that it's very easy to write bloated, unmaintainable code. Perl made that easy too.

Fast-forward 10 years, and Perl has made an attempt to solve these problems. You can still use all your old Perl code, libraries, and skills... but you can also do OO correctly, you can also test your code easily, and you can also easily share your code with the community. The good parts were kept, the ugly parts are pushed to the background, and the bad parts were replaced.

Other languages have done a bit of this too; C++ has boost and C++0x, C has the Boehem GC, eliminating many memory management problems (but it sill has no type safety), Java is being replaced with things like Scala and Clojure (which let you use old code but not suffer with the Java language's stagnation), and so on. In the end, though, I don't think any of these languages have made enough progress. (Partially because the communities are convinced that their language Is Perfection, and haven't felt any pressure to fix things. Perl is constantly derided as The Worst Language Ever, but we just can't seem to stop using it, so there is a lot of pressure to fix things. This pressure has resulted in a lot of good work on the VM, and a lot of exceptional libraries.)

So the point of my rant, I guess, is that Perl from 10 years ago is not what Perl is today. You can still use your 10-year-old skills, libraries, and applications, though... but when you want to do something new, there are tools available to help you Do It Right. More Right than, say, Java or C, anyway. (Moose is significantly more featureful than even CLOS now! Java and C++ look like a first-year CS student's first attempt at designing an object sytem. That's not the fault of Java and C++'s designers, BTW; the computer science community simply had no idea how OO worked when Java and C++ were implemented. The difference is that Java and C++ have kept their broken object systems, but Perl has replaced its.)

There are a lot of people that don't like a language (or application) for some small flaw, and feel the need to completely rewrite everything from scratch. ("I say we take off and nuke the entire site from orbit. It's the only way to be sure.")

This is very time-consuming, however, and the results tend not to be particularly compelling. The Perl community has shown that incremental improvements work a lot better than throwing everything away and starting over. We kept some historical baggage, of course, but if you are willing to ignore that, you have a language that competes with the best of them. (BTW, Perl6 is a great example of how difficult it is to design and implement a new programming language. Even with some of the smartest minds in computer science working on it constantly, it is still not complete. Programming languages are big projects; most of the new languages that we've seen crop up lately are extremely limited in scope or features, and while stable, will probably never be as popular as the "worse" langauges.)

BTW, just so it sounds like I am not fanboi-ing for Perl; Haskell is another example of successfully-applied incremental improvement. As an example, Haskell 98's type system doesn't allow overlapping instances. Instead of creating a brand new programming language to address that problem, the GHC folks just fixed GHC's type system, and allowed you to turn on the fixed version when you want it. The good stuff was kept, the bad stuff was pushed back into the realm of "historical compatibility", and the language moved forward as a result. (See section 7.6.3.3 here, if you care: http://www.haskell.org/ghc/docs/latest/html/users_guide/type... )

Anyway, it's a shame that you are letting people from 10 years ago get in the way of being a productive programmer. Throwing away an entire language and a community every time someone writes a bad script is not always the answer.