What programming languages do people hate most?

- Java: too verbose, no convenient way of passing functions around (anonymous clases are too verbose and clunky), lacked of unsigned types (apart from char) is sometimes irritating, mutable Date object is REALLY annoying. CHECKED EXCEPTIONS.

- Python: sometimes the acrobatics you have to do to get everything indented correctly (on a statement that covers multiple lines) is a bit irritating. I actually get a bit irritated by the "superfluous" colons. Module/variable name collision. The amount of times you have to write "self" (compared to, say, Java where 'this' is implied nearly all the time). Lack of a range/xrange that includes the final element.

- Javascript: it's important to separate Javascript the language and the DOMs in which it most often inhabits. Everyone has frustrations with the DOM, different behaviour and so on but the language is actually quite nice. My biggest frustration around JS is that debugging is probably the hardest of any interpreted language I use. Crude scoping (eg "var s = 'foo'" in an inner loop will have that defined outside of that).

- C: I love the simplicity and elegance of C but the lack of try-finally semantics (not that I'm advocating exceptions in general). The mess you can get into of who is responsible for freeing memory (caller or callee). Macro acrobatics (you've never seen so many parentheses in your life).

- PHP: inconsistent naming and parameter ordering. This is often cited but I think it tends to be overblown. You get used to it so at some point it simply offends your aesthetic sensibilities, which says more about the observer than the observed. Deep magic frameworks (I pretty much hate them all). People who try and turn what's actually a quite convenient templating language into Java/MVC. No cross-platform 64 bit int type. Really crude lambda semantics.

It's quite popular amongst programming language hipster-wannabes to hate on Java these days. The language I get closest to hating is... C++.

I've never in my life seen such a horrifically convoluted mess and if you look at C++0x (which is really C++1x now) it only gets worse. You see that every shop that uses it uses a (typically different) subset of the language because no one in their right mind would having coding standards allowing it all. Those slices can be pretty narrow too.

There are only two kinds of languages: the ones people complain about and the ones nobody uses. http://en.wikiquote.org/wiki/Bjarne_Stroustrup

On another note, I'm surprised not to see Javascript at all in the list. It used to be seen as one of the worst languages to work with. It's weird how fast these things can change.

Enjoy your bashing while it lasts. Tomorrow your "{elegant,robust}" language will be the one that's obsolete.

Even though higher level programming languages are supposed to abstract the difficult parts away from you, LabVIEW abstracts you to the point that it's a whole new level of complexity, which completely defeats the purpose of it being abstract.

So silly, for even the simplest things you need a framework. Code written for one framework is not compatible with code written for another framework, so you find this nice widget or library but need to port it first before it fits into your application.

I only use Javascript because there's no other choice for client-side browser development (yes, there's things like GWT, they're not that much adopted so you lose most of the advantages of code already out there, and they compile to JS anyway).

PHP comes second. I'm mostly frustrated with PHP for the way most people use it (mixing up presentation and logic in the web root), and the insecure-by-defaultness, not for the language itself.

On the other hand, there are deeper things to legitimately hate in the spirit of languages and how they came to be. C++'s 'everything but the kitchen sink' feature set reveals a lack of the essential job of curation in its design. I think it's fair (and not silly) to 'hate' this flaw, since it means you've observed and learned from that mistake. PHP's evolution has stemmed from the "screw it, just hack it out" mentality, with less thought to long term consequences of design decisions and inconsistencies. This attitude bleeds into the work built with it. I think it's fair to 'hate' these things, since they are important cautionary tales for people who set out to build something new for the world.

"The ATLAS language was initially developed by an international committee made up of representatives from the airline industries, military services, avionics manufacturers, and Automatic Test Equipment manufacturers. The goal of the committee was to design a standard English-like language that could be easily understood and used by both avionics and test equipment engineers."

The result was the goatse of computer languages.

I can't say I dislike any language that I have used.

Then, there is JavaScript, which I cannot avoid using despite having concerns with it. I would not say I "hate" it though, it's more of a "love and hate" relationship that formed over time here. I guess I look at it as being in a large city: if you know where to go it can be a wonderful time, if you don't you'll be shot in the face.

Among the things that bother me the most are function only scope, specifically when it mixes with declaration hoisting and implied globals. You can really end up writing some deceitful, innocent looking code that just does not do anything you'd expect it to. It's somewhat simple to avoid any problems that might come up if you're aware of them, but it's made me extra touchy; I get uneasy feelings when I see a variable declaration that is anywhere except the top of the function it is declared in. At the same time, having a large distance between the declaration of the variable and its use has been somewhat problematic for me: if I change the name of the variable, I must also remember to scroll up to change where it was declared, otherwise I just added a new global property. This bites.

The other significant issue I have is inheritance. I wouldn't mind if it actually resembled normal prototype based inheritance, but it just doesn't. It's too mixed up with the classical approach, making the end result neither simple nor powerful. It's easy to see that this problem in the language since there are so many different patterns of creating and extending objects as a result. Almost every framework/lib uses a different approach and tries to abstract it so the end user doesn't have to be aware of it. Of course, that only gets you so far before you end up having to look at how the libs you're using implemented it, and that sort of defeats the reason for the abstraction in my opinion. Something as fundamental as this shouldn't be so problematic, but it is.

Strangely, when I'm looking at EcmaScript 5 and Harmony, and see the changes that might try and fix these things, I kind of feel sad because it just wont be the same JavaScript I got used to fighting with.

1) PHP - for inconsistency and security bugs (did you know, that you can inject into mongodb with PHP? :)

2) Perl - for write only style.

3) C/C++ - for manual memory management and subtle bugs, which manifest itself long after actual bug happens (once i was searching for a rare-triggered bug in the C server for several months).

4) Java - for over-engineered APIs and verbosity.

I'm going to go with Java. So verbose, so stale. The worst part though is that Java developers don't seem to realize this.

You can call PHP anything you want but, the fact remains: it's easy to learn, and it gets the job done. It's not meant to be OOP like, if you want to go crazy with OOP, then go with a strongly typed language.