
What programming languages do people hate most? - ideamonk
http://www.quora.com/What-programming-language-do-people-hate-the-most
======
cletus
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.

~~~
troels
> It's quite popular amongst programming language hipster-wannabes to hate on
> Java these days.

I'd say the hatred-du-jour has switched from Java to PHP in recent years. Java
still gets a lot of heat though.

------
6ren
Hatred is predicated upon use, or

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

~~~
fogus
> Hatred is predicated upon use

That's not true -- plenty of people hate Lisp who've never used it.

~~~
staunch
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.

------
singular
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 :-)

------
yannickmahe
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.

~~~
albertzeyer
I think JS was mostly hated because of the available implementations at that
time and the differences between them.

------
suhair
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.

------
arkitaip
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.

~~~
Retric
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.

~~~
davidw
> I still use Java when writing tiny multi threaded projects that communicate
> over TCP/IP

Sounds like a good reason to learn Erlang.

------
hardy263
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.

------
gumbo
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.

------
wladimir
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.

------
gfodor
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.

------
gvb
ATLAS
[http://en.wikipedia.org/wiki/Abbreviated_Test_Language_for_A...](http://en.wikipedia.org/wiki/Abbreviated_Test_Language_for_All_Systems)

"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.

------
mc2k
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.

~~~
cafard
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.

~~~
troels
Actually, since 5.3 PHP has had anonymous functions. The implementation is a
bit of a kludge, but they're there.

------
nxn
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.

------
ecounysis
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?

------
mike_esspe
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).

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

~~~
cheald
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.

~~~
mike_esspe
Nope, PHP silently converts URL parameters into arrays (and if you don't
expect this, than you can get a nasty NOSQL inject)

<http://www.php.net/manual/en/mongo.security.php>

~~~
cheald
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.

------
latch
Vb gets a lot of hate.

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.

~~~
jpitz
_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.

------
DjDarkman
If PHP sucks so badly, why is it so popular? :)

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.

------
alexfarran
Stretching the definition of programming language a little, but CSS is pretty
awful.

------
rickmb
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.

------
nayanga
Why Quora is spamming HN and Techcrunch !!

~~~
mahmud
Is that a Questment! (Something that starts as a question and ends as a
statement)

George W was a master of it: he would start to say something controversial,
then raise the intonation at the end.

