Hatred of languages is pretty silly. I'd only go so far as to say I have frustrations with particular languages:
- 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.
Never met someone that really knows Perl well that thinks the syntax is a big problem or it's a "write only" language. It's all people who were scared off before they saw the light. Almost always the same with Lisp, vim/emacs, etc. Anything that's too foreign looking causes fear and then hatred for the fear it caused.
Read it carefully: There are only two kinds of languages: the ones people complain about and the ones nobody uses.
Nowhere does it say that the people doing the complaining are always the people who use it. I'd guess that the people hating lisp (or perl, php, etc) are ones who were told that it's great by someone who does use it, and who then tried it and formed a different personal opinion.
How can you be sure of that?
Each language has found it core market:
C++ is the leading language in the game industry.
C is used for embed software
Java is the everyone's language and with it awesome j2ee stack is becoming the de facto language for programming entreprise application.
And the list goes ...
So as one said, hating a language is imature.
You don't like it, don't use it.
I've been using C++ professionally and personally for a good ten years now, and aside from compilation speed, I don't really have any complaints about it. Use it properly, use Boost, and it's quite decent.
I only wish it had some of the sexy features of other languages, but C++0x (or whatever it's called now) is addressing a lot of that.
It's really hard to take the things that C++ does well and do it significantly better. I think D has largely proven that.
I don't think it's helpful to hate on languages; it's healthier to discuss frustrations that have got in the way of doing what you want, and how language feature x discovered in language y is a wonderful solution to the problem at hand :-)
Interestingly, I started hating PHP when first doing a personnal project in college. It was a complete unmaintainable mess. Later, when I used it professionally, I learned to do things right (using frameworks and the like) and started liking the language. I think hating a language is more about what you had to do with it, and how you did it.
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.
This programming language hate is pointless. If this was answered 5 years back Javascript could have been at the top. Now it is the most beautiful and flexible one. My jerk reaction at this moment is Perl and PHP b/c of widespread quotes against these one. But still i think they are very much worth learning.
Hating on languages is immature and ultimately pointless. Every generation of coders seems to need at least one language to bash and project their frustrations on. It used to be VB Script, now it's PHP.
Enjoy your bashing while it lasts. Tomorrow your "{elegant,robust}" language will be the one that's obsolete.
I hate Java. ~10 years ago I thought Java was an improvement on C++ at the cost of efficiency. Unfortunately so did the "enterprise" market which infected the stack and the ecosystem that evolves around it.
Anyway, I don't think it's pointless to hate a language. By turning down projects that use Java my work life has improved significantly.
Edit: I still use Java when writing tiny multi threaded projects that communicate over TCP/IP. But, IMO everything has it's nitch.
Hating on a language that other people use is pointless. But I can see how hating on a language that you are forced to use can be somewhat rewarding for a few moments.
I've never hated a programming language until I met LabVIEW.
In all honesty, the reply about LabVIEW is absolutely correct. Even PHP doesn't compare to the monstrosity that is LabVIEW. The FIRST robotics competition promotes using C++ or LabVIEW to create your robot code. And I have to say, programming by connecting squares together didn't feel like programming at all. It felt like I was being infantilized. The "source code" just becomes a whole mess of boxes and lines overlapping each other and just drives you nuts trying to understand how the program works.
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.
This is a too subjective question.
I thought quora was about fact, building a database of knowledge whre each answer is as clear and complete as possible?
Hate is about passion, not aboug fact.
But to answer the question, i don't hate any programming language: i know a lot of them and depending of the needs i choose the one that fit the most.
The single language I hate most is Javascript. I loathe the wieird prototype-based inheritance (need a framework for something simple as subclassing), lack of modularity ("include" everything? really?), and strange handling of "this" (no bound methods). And then I don't even start about the difference between browser implementations.
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.
I think it's important to separate complaints about languages themselves and those about the spirit of the language and how it came into being. For example, I think people who hate on Java and Perl would probably agree that their designers had noble goals and clear thinking but, being human, produced flawed implementations.
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."
It's weird, I only meet intense hostility/hatred/dislike for PHP on websites like this. Is it some sort of geeky way of appearing cool, or do people genuinely dislike it?
I can't say I dislike any language that I have used.
I have a pretty broad experience with a lot of languages, and while I wouldn't say I hate any of them to the point of wanting to murder their creators with my bare hands in a dark alley behind OSCON, I'd say that there are languages (like PHP) that have annoyed me to the point of never wanting to use them unless I absolutely have to on threat of death or incapacitation. I can get the same thing done in Rails with more sanity and less or equal amounts of code and far less frustration. Or I'd much prefer to never, ever use Java again beyond certain very specific tasks; that's largely because I can use a large number of languages for the same task these days. If I need performance, there's always C or C# is cross platform, as is Scheme, Objective-C, etc.; if I need to work with some Java library, there are languages like Scala and JRuby that are much more pleasant.
So, for me at least, my "hatred" of languages comes from finding better alternatives that "knock the shine off" the previously used language, if you will. Progress showing the failings of the past perhaps?
There are things I dislike about PHP as such; it picked up Perl's sigils, but inconsistently; is $x a scalar, a list, or or a dictionary? Its support for first class functions just isn't there (in 5 anyway), and using "map' is a pain. None of these are anything like showstoppers.
What sets my teeth on edge is some code I have inherited, which takes all the possibilities available to the new & undisciplined programmer, and runs with them. 2000-line scripts with mixed HTML and code, global variables used indiscriminately, dead code here and there. None of this is PHP's fault, but reflexively and unfairly I associate it with PHP as a language. I suspect that this is where most of the dislike of PHP comes from.
It's probably because most people have never made something elegant with PHP. The language is always a means to an end. It, in and of itself, will not make you a better developer. It can do a lot of work for you (frameworks) and make esoteric design patterns easier, but it always comes down to your ability to write structured, maintainable code. PHP makes it easier to hack together scripts. A majority of developers never take the next step in their life and learn the ways to properly structure a website. Chances are, if they do, it's because they've joined another language with the promise of an easier world (Rails, Python) and fail to realize you can do the exact same things in any other language - although it might required a little more understanding of its nuances (PHP).
I have distastes towards some languages I've had limited exposure to. Pretty much, these are languages I had to use, but not languages I had to get good at using. Among these would be PHP, VB, and maybe Java (though I actually liked it before I started using C#).
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.
I hate using a screw driver with nails and I hate using a hammer with screws. It seems to me that with any tool there is a specific problem or set of problems it is intended to solve. There is also a (likely) larger set of problems that are very difficult to solve using the tool. Why are we blaming the tools for their users' mistakes. If a carpenter uses tools insufficiently suited for his project, do we blame the tools or the carpenter?
I don't really hate any language, but i have a few dislikes:
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).
re: 1), I assume you mean by passing an array with $operators into code that gets executed naively? If so, that's not just a Ruby problem; it's possible in any language, especially if you're working with a framework that automatically parses query variables and you don't typecheck/typecast before passing user data to your database.
Yeah, that's a problem in lots of languages/frameworks. Rack automatically parses URL parameters like that, too. The solution is to cast your parameters to a string before using them.
The worst part though is that Java developers don't seem to realize this.
As a counter, I humbly submit: Scala, Clojure, Groovy, JRuby, and JPython. A collection of languages that attempt to fix Java's (legion) problems, while allowing us (clueless?) Java developers to remain on a platform that continues to put food on the table.
IMHO, Java developers are the MOST keenly aware of the shortcomings.
BTW, VB does get a lot of hate, but it has a fabulous niche - MS Office COM interop. Down that road lies madness, and a ton of consulting dollars.
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.
My favorite job interview question. There is no right answer, but any answer says so much about the programmer being interviewed that you might as well not bother with the rest of the interview.
- 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.