Hacker News new | past | comments | ask | show | jobs | submit login
Poll: What's Your Most Disliked Programming Language?
358 points by mrspeaker on March 24, 2012 | hide | past | favorite | 350 comments
Which programming language makes you most sad/angry/annoyed/... - add a note in any comments on the language you most like, so we can do some correlation.
1095 points
1091 points
Visual Basic
653 points
578 points
444 points
239 points
Objective C
226 points
226 points
194 points
131 points
121 points
116 points
100 points
93 points
80 points
72 points
64 points
48 points
46 points
43 points
40 points
37 points
36 points
33 points
33 points
31 points
28 points
27 points
25 points
21 points
21 points
16 points
16 points
13 points
12 points
11 points
10 points

I chose PHP because it's gathers everything I hate about any language in one spot.

* It has everything including the kitchen sink but nothing in the decor matches. There is no unifying principle to help you grok the language

* The Community is all about quick hacky fixes to already broken code and this approach seems to flow from the core developers out.

* It's not type safe, not even at runtime. I don't know if I ever want to work in a language that doesn't have proper type safety as a guard rail. (Note I'm not talking about compile time vs runtime type safety I'm just talking about type safety period)

* The code is just plain ugly to look at and I used to be a pretty heavy perl coder so that's saying something.

I know some of these are pretty subjective but for me php just manages to hit every single one of my top programming language gripes.

If you want to know my favourite that's a much harder question to answer. Golang has been pleasing me lately although it's interfaces have a very tiny hole in the type safety.

ML and it's varying descendants have as close to my ideal type system as I've ever seen. But the chances I'll ever get to use it for a job are slim to none and it seems the community is a little too academic for my taste.

Lisp has the most awesome metaprogramming built in and I had a brief heady love affair with it until it's lack of good type safety brought me back to earth.

I suppose all this means I'm one day fated to write my own "ideal" programming language so it can be featured in a list like this :-)

I once found a login form where 1e3 was a correct password, when yours was 1000. I'm still not sure if it eval'd your password, but it was PHP for sure.

What does this have to do with faults of the language? I can think of a lot of stupid things to do in any language; it doesn't mean the language is the problem.

The weak typing of PHP doesn't make life easier for the programmer in this instance.

For example, this specific problem is harder to create in stronger-typed languages, since you would need to explicitly cast from an integer to a string.

It does if the language itself makes it easier for you to make those kind of mistakes.

It's easy to make any kind of mistake in any language. Singling PHP out for it because some people are shitty programmers is BS, IMHO. Not all of us are asshats who have no idea what we're doing.

I think PHP's main problem on websites like these is that it's too mainstream of a language. It's like asking someone who's an avid fan of world cinema about the latest Michael Bay film.

I'm not that interested in programming, so I think it's a great language. All those years back when first learning to use it, I remember going through a book and being so happy that it did practically everything itself.

> I'm not that interested in programming, so I think it's a great language

I think this sums up everyone I've met who actually likes PHP. They like that they are able to get stuff done, and look no further. It is just frustrating to those of us who know that PHP is one of the most poorly designed (and I use that word loosely) languages ever to be successful.

If you can get over the local maximum of getting stuff done in PHP, the grass actually IS greener in Python and Ruby land.

> I think this sums up everyone I've met who actually likes PHP.

That says more about the people you associate with then with the language.

The people I know care about programming, care about doing it well, care about elegant solutions, and care about a wonderful end product. What they don't care about are stupid language wars.

> the grass actually IS greener in Python and Ruby land.

I never got serious with Ruby, so I'll confess, I might be missing something. But, going by what I see in Destroy All Software's screencasts, I don't feel like I'm missing anything.

I can't help it, but ever since Rails came on the scene, I can't help but feel like the PHP people that make up the PHP community has dramatically improved. This, of course, is purely based on the people I've met.

OK, how about I rephrase to:

> I've never seriously learned a second language, so I think it's a great language

Do the people you know have experience with other comparable* languages, and still think PHP is a well-designed language and platform?

I concede that the PHP community, and PHP itself, has dramatically improved in the last few years. PHP 5 is a revelation compared to PHP 4.

[*] i.e. not "The other language I know is C, and I love that PHP is so high level!"

> Do the people you know have experience with other comparable* languages, and still think PHP is a well-designed language and platform?

For the most part, yeah. There are the obvious quibbles you get with any language, but for it's domain, it's the best bang for the buck. Does that mean it's the only language in our stack? No. But for my money, for the web side, it can't be beat. If I were to do a site in a non PHP language, it would be Python hands down. That being said, it all depends on what the project is, and what it entails.

Listen, I can't help but wonder if your imparting some past on the current crop of PHP developers (and by current, I mean those that moved to PHP5 some 8 years ago). Maybe you had experiences with another group of people that focus on just one language.

The PHP community of today is far from that. It's made up of practical people, who focus on more than just PHP. More to the point, calling someone a PHP developer these days just reflects that when they do the server side web code, they are using PHP. Not that it's their only language.

To be honest, my personal experience is that everyone I've met who pans PHP and proclaims to have switched happily to Rails (because that's what they switch to first, never Ruby), or Python is that they needed the extra structure these languages enforced. Basically, the PHP code they deride so much was code they helped write.

That, of course, is just my point of view. I don't know many people who use Ruby for web development, so it would be unfair for me to suggest the entire community was like that.

> Do the people you know have experience with other comparable languages, and still think PHP is a well-designed language and platform?

Is this the only thing upon which to base your opinion of a language? As someone who's seen at least a glimpse of the world beyond PHP, I'd concede that the design of the language, especially in earlier versions, is probably not its biggest selling point. But as you and I agreed below, PHP derives its value in other areas.

Maybe it's implicit in a question like "What's your most disliked programming language?" that those other areas should be excluded from consideration, but if that's not the case, then focusing solely on language design is a bit unfair to PHP.

> I'd concede that the design of the language, especially in earlier versions, is probably not its biggest selling point.

Keep in mind, the design of the language wasn't to create a new language, but instead, make using various libraries easily usable in a web environment. Hence the reason for the multitude of c or c-like functions. Eventually, the shift moved in a different direction.

I like to think that while PHP wasn't intelligently designed, it did evolve. And for my money, evolution beats out intelligent design.

+Heyo for evolution > intelligent design

> The people I know care about programming, care about doing it well, care about elegant solutions, and care about a wonderful end product. What they don't care about are stupid language wars.

I was just thinking this same thing. My background is mostly in PHP, C#, and more recently JavaScript.

Each of these languages is completely different from each other, but I haven't gotten to point where I curse the fact that one program is written in one language versus the other.

Each language has it features and pitfalls, but as long as you can accomplish the task you've set out on, I'm not sure that it really matters.

For example, I absolutely love the ease of passing functions around in JavaScript, but you can also make a real stinkin' pile if you don't structure things right.

Having used JavaScript, I find myself thinking about using delegates and anonymous functions a lot more in C# than I did before because I've seen the benefit of them in JS.

You can't tell a good programmer by their choice in language but in how they leverage that language to make awesome software.

> What they don't care about are stupid language wars. Then why don't you care about PHP's horrible design, implementation, and development team? I veer away from PHP, fearing very much the Broken Window effect from all the glass scattered in the ground around PHP all the time.

> fearing very much the Broken Window effect from all the glass scattered in the ground around PHP all the time.

You can't program if you use a broken window as a measure of whether you use the language or not. I do not know of a language without issues, ugliness, or mistakes.

I don't know if this counts as meeting, but I consider myself a developer that is interested in programming, doing things right, etc., and I like PHP.

I see PHP as a language comparable to English. Both languages have a bunch of inconsistencies, peculiar idiosyncrasies, a humongous base of speakers/users, etc. In both languages, a lot of what people write is not of high quality, but writing high-quality stuff is certainly possible. If I had to choose one language for the world to speak, it probably wouldn't be English, and if I had to choose one programming language to be used in a given field (say, server-side web development), it probably wouldn't be PHP. But given the reality of the situation, PHP, like English, is an incredibly useful language, and PHP code, like English writing, can be of very high quality. I think this makes it a very valuable language.

I agree that PHP is an incredibly useful language; that code written in PHP can be of very high quality; that PHP is a very valuable language (because every host supports it, and most popular content management systems must be extended using it).

What I don't think it is, is a well-designed one. It could have been all of those other things, AND a well-designed one, it just wasn't. I think it's a shame if a generation of web programmers come of age thinking that the warts of PHP are inherent to all programming languages. (I myself once felt that way about ColdFusion, since it was the first language I learned and everyone I worked with also only knew ColdFusion.)

Rasmus basically said he doesn't care if he copies and pastes stuff around so long as it gives him the end result he wanted. The language reflects that.

And, actually, it's NOT necessarily a bad thing to have a language oriented around people who don't actually care that much about programming when it's also oriented around people who want to ship something useful to an end user (who might care if it's insecure but doesn't care if the code's pretty).

I've encountered a number of orgs now that have PHP on the front speaking XMLRPC or JSONRPC or whatever to a backend daemon (either Java or Perl in the cases I've seen) and since that means messiness on the front end shouldn't be able to violate business rules, it works out really well.

PHP is not much good for security though for beginner developers. It does not help with XSS, CSRF, or SQL injection prevention. If anything it does actually encourage them if you do not know of the risks.

I feel like this is more of a role for a framework built on top of PHP than for a language like PHP itself. PHP itself is pretty low-level. How would you suggest providing better protection against these?

In the past, of course, PHP did have magic_quotes, which was a misguided attempt at mitigating SQL injections. This has since been removed, and there's been a big push in the direction of using prepared statements/parameterized queries through a library like PDO, which I think was introduced in PHP 5.

Agreed, about that this is the role of a framework and this is in many ways what is wrong about PHP. It tries to be both language and a framework with its built in templating. But templating which does not include simple to use support for escaping HTML is a really dangerous tool in the hands of a beginner.

So was the (I believe now deprecated) mysql library they shipped and the tempting ease of string interpolation.

Doesn't the fact that Python won the "Favorite Language" poll kind of show that it's not just about hating on mainstream languages? Python's pretty mainstream, I'd say... definitely top 10.

Python has a very low barrier to entry and that is bad. Very bad, trust me.

That sort of a market generally gets swarmed by low price developers very quickly.

But HN isn't a representative sample, so our poll doesn't accurately reflect the overall popularity of a language.

Your second statements communicates to me that you like it because it's a toy language. It may be useful for just getting something small done and getting started but for someone who looks at programming as an enjoyable craft php loses it's shine. Especially once you've been exposed to other languages that highlight how much better it could be.

I actually disagree to some extent. I know, it's PHP. But it can do some pretty amazing things if you think in terms of files. If you're coming from a C background, it's actually quite nice.

For example, you can use include ( ) in so many ways, autoload classes, write getters/setters and override anything, implement views, etc. Everything "just runs", or can be compiled into fast code with HipHop (or cached with APC).

OK, to be fair, I would say that PHP with a framework that takes advantage of it can be very cool. I can't exactly share our codebase, but you can see the open source version from 2 years ago : http://phponpie.com to aprpeciate some of the "beauty" of PHP

And it can be extremely expressive and powerful. Sure, it can't do everything that Node.js can do, but for serving requests it can be awesome. It isolates every script in its own memory space, so you never have to worry about anything! The one thing I do not like about PHP is that it's married to the outdated thread-based webserver model, while the new boys on the block (NGinX, Node.js and the new Apache) all use event-based programming.

Don't downvote just because I said PHP can be cool. Look at our framework at least, before voting :)

Actually I upvoted you. Just because I dislike PHP doesn't mean someone else can't like it.

I spend a lot of my time writing Python, especially for Django powered sites, and writing client side javascript. Periodically, I'll get stuck maintaining large projects written entirely in PHP and miss the nice features from other languages. Javascript has its bug-a-boos, but with its dynamic design and jQuery, its easy to write clean code. Python is also much cleaner and usually just works.

On the other hand, all of my programming horror stories and terrible hacks have been written in PHP. I remember having to use an older version of PHP that failed to support closures when it was needed in some legacy code. The code was passing functions as arguments, but because the functions were not bound in the local scope, there were issues with namespace collisions. I had to resort to global variables for a situation that should not have needed it because rewriting everything properly required a non-trivial refactoring that I did not have the time to complete. Granted, this has been addressed in more recent versions of PHP, but there are always old versions floating around where "gotcha's" like this show up.

More recently, I ran into an issue porting PHP 5 code across different linux distributions where, for some strange reason, libraries on the include path failed to be found. Debugging something like that is ridiculously frustrating. Problems like this are bound to show up with any technology you use frequently, but my work involves using many languages and technologies and, of them, PHP is the only one that leads to these sorts of problems with such regularity.

What is the definition of "something small"? Millions of users and companies use PHP based software for various business needs, from small to big. Yes, the language has a lot of flaws, but I disagree that you can't create useful and rather "big" software with it. And it's easier compared to other languages. If it solves people problems, why not?

Nothing I said was meant to indicate you couldn't use php for something big. All I meant to indicate was that once you've seen what other languages have to offer and have started to look on programming as a craft php starts to lose it's shine.

Facebook uses a lot of PHP and seems to do fine, just because a language allows you to write horrible code doesn't necessarily mean it can't be used to write good code. PHP obviously has a lot of warts, but I think the bigger problem is that it gives you just enough rope to hang yourself.

There are two kinds of programmers at Facebook: The ones who curse PHP every work day, and the ones who don't use it.

"This language really sucks." -- paraphrased, intro to PHP on Facebook's internal Wiki

I wouldn't be surprised if it happened more than usual with PHP, but in my experience programmers always curse the language/framework/api that they use heavily. You always learn the seams and hit issues with the design if you work with something for long enough.

Yep, It's a phenomenon frequently called "using in anger". The interesting thing about php is you don't have to use it very long before you use it in anger. Most of the time you can tell if someone is well versed in a language if they use it in anger. With PHP all you can tell is they've used it.

Is that was "use in anger" means? I had assumed it came from "fire a shot in anger", meaning serious use rather than practice or ceremony.

It's true that most software makes me either angry or sad, but PHP (where even "==" is wrong after Perl had gotten it right) was a singularly memorable peek into Special Hell.

Nope! I love me some Python, JavaScript, C, and even ActionScrip, Java and Pascal. Blaming the tools is bad form unless you can prove they are bad, which can be done with PHP.

The concept of "bad" is subjective and can't be proven. Don't blame the tools for what the people do with them.

Fair enough. Bad is too broad a term. But I think most developers agree that PHP is inconsistent and lacks type safety. For a long time it lacked namespaces which made for some really silly design patterns. It lacks some neat features too, like lambdas and its support for closures is minimal. The list can go on.

All of the things you listed are missing from at least one of the languages that you listed as your favorites.

Facebook also uses a very restricted subset of php for a lot of it, if the people I've met from over there are any indication. This may make it generally more useful for them than it may normally be.

I think they have to use that subset so it can be compiled by HipHop down to C code.

I agree there is some language snobbery. However, I moved from PHP to Ruby and love it.

My two biggest gripes with PHP:

1) No standard package management system. I worked with some VERY smart developers at a PHP-only company, but nearly every part of their complex system was coded in-house, from the ORM up. Rubyists practically never code things that are available as well-tested gems, saving tons of effort, debugging, and training new people. That's a huge boost to Getting Things Done.

2) Little discoverability. If you can't remember the string method you want, you'll have to Google - and make sure you notice the order of the arguments. In Ruby, you can do `'foo'.methods.sort` and see all the methods available on strings. Since it's OO, you don't have to pass in the string itself, so there are fewer arguments to know in the first place.

I thought PEAR was PHP's standard package manager?

What would you use in place of PHP to build a web app? The only requirement is that you have to be able to hire developers just as easily as you can hire PHP developers. This might be where rubber meets the road. It's easy to dislike a tool based on all kinds of criteria. In the real world one has to be able to get work done and, if needed, find developers to expand a team. Proposing a subjectively or objectively better language that does not have a large enough developer base to call upon when needed isn't really a business solution as much as it is an interesting academic exercise.

To clarify, I have no feelings either way. I've had to learn so many languages over the years that I just see them as another tool in the toolbox. Life goes on.

Yaron Minsky said in one of his talks that hiring OCaml programmers was the easiest thing in the world: he posted an ad on the mailing list, got 20 applications, 15 of which were worthy of a phone interview. Of those 15, 5 were asked to come in for an in-person interview and 3 of those were hired.

Sure, he might not be able to hire 80 programmers in one batch, but I don't think Jane Street would need to do that, or that they are worried about a shortage of OCaml programmers. Also, I would be more confident of the capabilities of an OCaml programmer than of a PHP programmer.

And, as an OCaml programmer, if you were not one of those lucky 3, where would you work other than Jane Street?

At the PHP shop.

All sorts of places.

I'd be willing to wager that there's hardly an OCaml programmer in this world who isn't also skilled in a few other languages.

That still doesn't make a case to learn OCaml.

What it means is, People who learn OCaml generally have to learn something else too. Because the jobs just aren't there. Which in case the person is better off learning that something else properly.

And that is a very big problem.

I generally pass over resumes where someone doesn't list at least one programming language that isn't very marketable, fashionable, or part of C's extended family. It's a quick way to winnow out folks for whom programming is likely to be more than just a paycheck.

At a Scala or an Erlang or a Clojure shop, I expect :-)

Unless you have a very short term project, you shouldn't hire developers based on their knowledge of a particular language - it is far better to hire them based on their demonstrated skills that transcend particular programming languages or technologies (knowledge of multiple programming languages, track record developing software, computer science knowledge, knowledge of software engineering principles, and so on).

Developers can learn new languages if they need to.

> The only requirement is that you have to be able to hire developers just as easily as you can hire PHP developers.

Would you trust your product to the kind of developer you can easily hire?

Just wondering ... what is "large enough developer base"?

If you are hiring, you are not hiring 10000 people, you are hiring one or two people.

If you can choose between a pool of 10000 developers in PHP and 100 in Haskell (whatever...) you will probably find more candidates you want to hire in the second pool.

And it is certainly more likely that you find the appropriate candidate if you don't have to wade though hundreds of applications.

My general point is that evaluating languages based on personal or technical preferences might just be a flawed metric. Unless what you are doing is a hobby you have to deal with additional criteria. I pointed out just one such data points.

I, for example, really love APL. I would also never think of using APL as the basis of a commercial project unless there was an overwhelming reason to do so.

A friend of mine built a nice company around a product built entirely around Forth. He loved the language. And, he lived to regret making that decision. He eventually paid gobs of money to have the entire code base re-written in C. A couple of years later he sold the business for several million. Potential buyers did not want to touch him with the Forth code base. Just a reality of business.

To clarify, the potential buyers were not interested in the Forth code base because they did not use Forth themselves. Acquiring a company whose products were based around Forth would mean adding a new layer of developers to their team and, effectively, byfurcating their efforts and skill sets. A code base written in C was a no-brainier for most interested parties. With C on the table the language was just a check-box item that did not require further discussion. With Forth the discussions stopped right there.

Again, nothing to do with the merits of the language and everything to do with business realities.

I'm not sure why "business realities" are being brought into this discussion.

If the poll were "what is the most common back-end web development language" or "what language should a startup use in order to have the easiest time finding developers", you would have a legitimate gripe with those who chose, for instance, Prolog. However, that's not the case here.

While you certainly make good points from a business perspective, it's becoming increasingly more likely that programmers you can hire that both:

+ know PHP

+ are experienced enough to deliver a working, maintainable application

are also fluent in at least one of ruby or python, both of which are much nicer languages in general and have strong web-dev presences.

The issue with hiring "people who know PHP" just because a whole lot of people know PHP is that issues with maintainability of whatever gets written tend to be much more of a pain than with similar projects in other high-level languages.

It's not, of course, that you can't write a ball of unmaintainable mud in any language -- you certainly can. PHP is lacking in areas that make fixing that less of a nightmare, and lacking in areas -- both in the language, and in the community for lack of a better term -- that make writing maintainable stuff in the first place easier. The devs who know how to create maintainable PHP codebases, or fix unmaintainable ones tend to have experience with other languages.

This should be, in my opinion, a pretty major concern for business. While it may not be apparent at first, there tends to be diminishing returns from maintenance and development of a product if it's a giant mess. Doing PHP on new projects for ease-of-hire is inviting that mess, due to a whole bunch of little things that tend to snowball. Skilled people won't want to work for you, people that will be skilled but lack experience will leave your employ, and eventually the project will grind to an iceberg pace and stress levels will get high for everyone.

A good dev will probably not have a problem picking up whatever language, as long as you're using "general-use" languages. In the web-dev world, this is currently mostly ruby and python. Choose haskell, and you'll probably have some (read great) difficulty finding people to hire. Choose ruby or python and you'll be more likely to attract the type of devs you want, and at the worst you'll get someone inexperienced who makes a mess that is easier to fix than it would be in a PHP codebase of similar messiness.

If it was just the merits of the language, I don't think I'd have much of a leg to stand on talking from a business end. It's not though, it's a whole lot of little negative things that can make a long-term project more likely to be a failure. The language, and the tools, and the community are getting better, but that's mostly due to the efforts of people who are skilled and experienced with a variety of things improving it because it's paying their bills. It's still far, far away from any other "popular" language in terms of tools, community, available libraries, and just about any other measurement you can make other than "number of people that can say they know it on a resume"

> issues with maintainability of whatever gets written tend to be much more of a pain than with similar projects in other high-level languages.

I'm not sure I follow this. If you take one of these good developers you are referring to, and write your codebase in PHP, what about PHP makes it difficult to maintain as compared to Python or Ruby?

If you take one of these good developers, nothing much, other than that they might need to write some things that they wouldn't have to think about in other languages.

If you take a developer who isn't as good, or isn't as experienced, and they create a ball of mud, it's easier to get it to a maintainable point by a good dev if it's written in a language other than PHP.

Some things about PHP that make it difficult to maintain over time are things like lack of consistency in abstraction, lack of first-class objects, extreme behavioral dependency on php.ini, incomplete reflection capabilities, and so on. These types of things are much bigger of a deal when trying to refactor a messy codebase as opposed to developing on a pretty clean one. They're getting better as time goes on, but the other popular web-dev languages are miles ahead, and it's extremely likely that a good dev capable of writing PHP code is familiar with one of them.

"Golang has been pleasing me lately although it's interfaces have a very tiny hole in the type safety."

Go/Golang is indeed an amazing language -- my favorite, in fact, even beating out Python for my #1 spot. Go's creators guarantee its type safety; what hole do you speak of?

To hopefully assuage your concerns and to make an assumption about what you may worry is a hole in Go's type safety...

Empty interfaces allow one to contain _any_ value (such as a string) in an interface{}, but in order to use such a value, one must access the underlying type of the interface{} (i.e., the aforementioned string value). To do so, a type assertion is required, thereby preserving type safety... unless I'm missing something?

The interface{} is a contributor to the hole but not the cause.

The hole occurs when I want to make a generic container like say a binary tree. I can create a node interface that satisfies my needs for a binary tree. What I can't do is guarantee that at compile time every element in my container is of the type that I expect. If they ever add generics of some sort this hole will be closed. It's a very tiny one and can usually be limited to a single functions scope but it still exists and certainly not enough to make me dismiss the languange out of hand. You can see examples of the hole by looking at Go's container/* packages. Some of them had a completely separate implementation for each of the primitive types. Type assertions ensure type safety at runtime provided the programmer does their job. But it depends on the programmer doing their job so it could be better.

Go and ML were two examples that come the closest to my "ideal" language. Go just happens to be one that I have the greatest chance of actually using in a job :-)

> You can see examples of the hole by looking at Go's container/*

container/* is a bit of a corner case which is rarely used, specially since append() was added to the language and container/vector was deprecated I can't remember the last time I needed anything from container/*.

That's why I said tiny hole. :-)

From another comments, we established a time frame:

> Is that new? I don't remember it from my php days. Although I'll freely admit those days were a long long time ago so "new" for me may actually be pretty old.

So, what you are really saying is:

> I chose PHP because it's gathers everything I hate about any language in one spot when I last used it... which was a least 8 years ago.

I haven't seen an elegant pattern emerge from PHP in the last 8 years.

Being blind isn't something to joke about. Mocking those with handicaps is rude and uncalled for.

Respectfully, I think two of your arguments stink.

2) The community. Surely there's a lot of garbage code floating around in the community, but are we going to judge a language by its community now? Perhaps the community is so big it produces a fair amount of garbage code appropriate to its size?

4) Ugly to look at. Perhaps, if you write ugly code. Again, this is about the programmer and not about the programming language. I think I write pretty code.

Disclaimer: I am a PHPer most of the time. But I realize that PHP is probably on its way out in the long run. And I agree with your two other points.

I chose ActionScript because it's a PITA to debug. Good programming languages make it easy to find your mistakes. PHP is good at that, as are a bunch of other languages.

Respectfully they are subjective so I expect people to disagree. However:

The community is a huge part of judging a language. You'll note that I specifically said this appears to flow from the core developers out. A sentiment many in this thread appear to have shared. That to me is a danger sign. The community often is a signal regarding how the core devs of the language approach things.

As for beauty it's completely and purely subjective so what looks beautiful to one person can look ugly to another.

PHP actually does have some type safety, amazingly. You can declare types on function arguments:

    function myFunc(ObjectType $arg1, array $arg2) { ... }
And it'll throw errors if you try to pass an argument of the wrong type.

Is that new? I don't remember it from my php days. Although I'll freely admit those days were a long long time ago so "new" for me may actually be pretty old.

Its been there a long time, I think since PHP 5. (Certainly, it was old in 2008, when I was working on PHP).

You're correct. Type hinting was introduced with PHP 5, which makes it about eight years old.


Type hinting exists for objects and arrays but not for scalar types (string, int, float, bool) unfortunately.

I always compare those who program in PHP to those young teen who are rushing to Justin Bieber Concerts ,and to the cinema just to watch Twillight ,and they are so exited ,but they ignore that there is a hole world out there ,where music is not judged by appearances,and movies are not judged by makeup and love scenes,and where there is some powerful programming languages that let you enjoy building a scalable ,powerful projets in some hours.

What do you mean by type safety? Are all dynamically typed languages type unsafe by your definition?

If the language can tell me when it executes the code that the type is wrong then I consider that type safe. Less usefully type safe than at compile time but safe nonetheless.

If the language treats a string as a number in some cases without an error then that is most definitely not type safe.

The standard term for the feature that allows treating a string like a number is "weakly typed". You like "strongly typed" languages.

Lisp is type safe by that definition, so I'm not sure what your problem was with it.

Dynamically typed is still typed. That the error occurs at run-time means the typing is dynamic. If the error did not occur at all (int was unsafely coerced into a string), then that would be untyped or weakly typed.

Static type safety is desirable, dynamic type safety is almost essential. But they are both type safety.

What's the reason why you don't consider (Common) Lisp to be type safe then?

I prefer prefer strong statically typed languages.

Just because php is at one extreme end of the spectrum of my preferences for type safety doesn't mean that other things can't be closer but not quite on my end of the spectrum yet.

So in short according to you the language is useless if doesn't have type safety?

I don't expect that the responses to this will be enlightening. In fact, I can predict right now that the winner of this poll will be the most commonly-used language which isn't widely considered to be "nice". Depending on the precise demographics of this site, that's either going to be Java, C++ or Javascript, despite the fact that there are clearly worse languages out there (Fortran, COBOL, Brainfuck...)

The reasoning is explained well in a post by Terence Tao [1] in the context of 'List of the worst movie of all time'. Briefly, assuming that there is at least some correlation between programming language quality and uptake of that language (which doesn't seem to be controversial, especially among the users of HN) then you expect that languages which are generally worse will not be used so much, and so there will be fewer people who are able to vote for them as being "the worst".

For example, I have never used Delphi (to pick an example at random). I know literally nothing about it. It could be a stinking ball of crud that irreparably crushes the soul of anyone who tries to use it, but because it's not that popular, I've never used it, and so I'd never get to vote it down for being the horrendous pile of fecal matter that it may well be (I repeat again that I know nothing about Delphi, and it might be wonderful - I'm using it to illustrate a point).

If you make some simplifying assumptions about the probability that someone has used a language given its quality, then you can demonstrate that the language which will end up topping polls like this is whichever one is "just good enough" to be popular - which in this case means Java, C++ or Javascript.

[1]: https://plus.google.com/114134834346472219368/posts/TPjSPPd1...

You can't ignore context. Fortran is a very strong language for a specific application - you can't compare it to Javascript.

Delphi was a framework using Pascal. It was a revolution at the time - and you can see it's influence in many software tools available today.

You could argue that the current SQL/Rails API/JSON/Backbone/JQuery/CoffeeScript/HTML/CSS abomination we've created could be improved or replaced with something as disruptive as Delphi was at the time.

I wish there was some way to vote for that abomination in the poll. Personally, writing Java/Html hybrid templates that are served as html documents and then further manipulated by dynamically altering the DOM in javascript on the client is the stupidest programming style I can imagine.

Out of curiosity, what is your favored alternative for web applications? Server-side rendering of complete pages? Client-side manipulation of pure HTML?

I don't know of a good alternative. Thus my grumpiness.

A redesigned transport model other than HTTP? Continuations? A saner front-end language that can also be used at the server side and it's not the Node.js failfest?

That's a good point. How come we are still using http? I mean, the closest we've come AFAIK to something almost useful is ajax, but that's still not very good considering it's javascript... Maybe I'm unaware of some secret google development.

There's Google's SPDY, but it doesn't fix all that we might like from HTTP, mostly performance stuff.

I guess, it's the agreeing on something and then adopting it and then having it catch the market part that's making this difficult.

On another field that I follow, we haven't had anything better replace MIDI for like 30 years...

Is MIDI bad? I mean, why do you think it should be replaced? I am not familiar with this area but I am honestly interested!

MIDI is very slow and has a very limited message set. There are better alternatives, like OSC, but it seems like the chances of the music industry collectively acting in its own best interest again and approving a new standard are very slim.

Well, the biggest limitation is that it has granularity of 0 to 256 for message data.

That means if you want an analog like continuous change from 0 to max for some audio property, you get stepping instead.

It's also not very fast for todays work with tons of channels.

I doesn't know about audio at all, etc.

OSC is a better replacement, but not widespread enough.

You can replace HTTP with anything you want using WebSockets, but I never got what's wrong with it.

Given that websockets don't even work reliably yet, and are not even implemented in all popular browsers of the day, that's hardly a proposition. Not to mention that everybody implementing his own HTTP replacement from scratch with websockets instead of a common standard is a highway to hell.

As for what's wrong with it:

- better support for non-blocking requests - better support for streaming media - better support for caching - better content negotiation (e.g for "retina" x2 assets) - better authentication mechanisms - better support for encryption

Also check: http://static.usenix.org/event/usenix99/invited_talks/mogul....

I refute that Fortran is axiomatically worse than Java. I've spent a few years working in each, so I got to know them decently well.

Fortran is like C with great math support; that is to say, C is like Fortran with great systems facilities. In each language's domain, it is more expressive and more performant than Java. Outside its domain, you don't want a bad programmer going near it for too long, but you can absolutely still get things done.

On the other hand, Java fills me with such dread that I would write a post defending Fortran just to kick it in the nuts.

I think fortran77 should have been listed separately.

Any language that requires six spaces at the start of the line in order to maintain legacy punchcard compliance makes me gag.

fortran90 or hpf on the other hand are pretty useful in their domain.

In general when people hate on Fortran I assume it's because they had to deal with f77. 90/95/2003 aren't perfect or anything but aren't generally offensive.

The issue is that both C (portable assembler) and Fortran (portable math library) solve some problem pretty well.

What problem is it that Java solves well? That is what makes java such a shitty language to program in, for any particular problem you encounter there are much better languages to solve that problem in, C# comes to mind immediately as to what Java should be.

Note: Yes I realize that Java has excellent cross platform support and a huge ecosystem, but we're talking about languages, not the ecosystem.

> Yes I realize that Java has excellent cross platform support and a huge ecosystem

Java's cross platform support is awful if you go anywhere beyond Windows, Linux, OS X and Solaris (and even there both OS X and Linux have second-class status at best and suffered from serious issues at least until recently). Even Python and plain old C (if you know how to write portable code) are much more portable than Java ever will be.

And many would say the "huge ecosystem" of incredibly big and complex "frameworks" and tools is part of the problem with Java, or at best one of the symptoms of Java's problems. As others have pointed out, IDEs are language smells, and with Java using the language and surviving in its 'ecosystem' basically requires it.

I personally would even say that Java the language is considerably better than Java-the-ecosystem, but using the first without the later is almost impossible, and there are much better languages around anyway.

>>Even Python Why "even"? Python is the most portable language today. It's portability between OSes superb and it "almost portable" between VMs (IronPython, Jython, PyPy).

This has probably been the most senseless post I will read in a while:

- C only got a memory model in C11. So you can't be sure your code does what you think it does, without compiling and testing with every compiler for every platform you intend to target. - C is a low-level language which has its niche. But most of the time you want quite different features, like runtime monitoring, inspection and debugging. - In C you can't just move your binary to a different architecture and run it there, same thing in Python: You can't just deploy your pyc or pyo files on a different machine and expect it to work, especially not if the versions differ. - You can't even do that for source files: Python breaks compatibility frequently, and because it is dynamically typed, you can't just check the signatures that nothing has changed and chances are you won't even see breaking changes until it crashes at runtime. - Python is not nearly as fast as a decent JVM. - Both languages lack a cross-platform UI toolkit, although yes, AWT and Swing suck, and JavaFX isn't that great either.

I agree though, that the whole "framework" stuff has grown out of proportions in Java. It is just a disease if a simple application ships with 40 MB of JAR files because the developer couldn't write any non-trivial functionality himself.

> IDEs are language smells

This smells like envy from someone whose "favorite" language lacks good IDE support, but yes, Java-the-language is just outdated.

> Java the language is considerably better than Java-the-ecosystem

WUT? Java-the-language is the weakest part. You don't have to use any Java library or framework at all and Hotspot is probably the only freely available VM which is fast, mature and stable.

The goal of Java was always to be able to "write large programs quickly." In some ways that sounds terrible by itself, but I think it turns out to be legitimate.

I've been on python projects that need to grow but struggle b/c all the things that make it easy to get a lot done the first few weeks become liabilities very soon. Adding developers to a project that doesn't declare types and encourages just passing around hashmaps is brutal. All the stuff you can't do in Java makes it easy for someone else to understand it and edit it.

I would believe that C# might be a bit better but only being fully supported on MS is a non-starter for many server side situations.

> The goal of Java was always to be able to "write large programs quickly."

That wasn't the goal of Java, not by a mile. The goal of Java was to build a language that runs everywhere, and to facilitate Sun's "everything(your watch, toaster, pc) is networked" ambition.

All the things that people flout about Java saying that how it helps them manage large projects(completion, re-factoring, ide integrated debuggers, good libraries) wasn't even a twinkle in anyone's eyes who was involved with Java development. Java's initial release was terrible - it didn't even have decent stdout facilities, was interpreted and as a result dog slow, took a long time to load the jvm, and essentially failed it's "write once, run everywhere" motto as it became "write once, debug everywhere" in practice.

Java has evolved, mainly because people bought in the hype. I don't know why people stopped questioning the hype.

"Look, we are totally object oriented."

I am not sure what it means for me as a developer. So, what about classes? Are they objects? Packages? Are value type objects?

"Ummm. No it doesn't matter. Just listen to us. We are object oriented."

"Our goal is 'write once, run everywhere."

Your awt looks like dog shit on both windows and linux, and is slow.

"Hey. We didn't say anything about 'looking good'. I can bet it looks equally crap. That's platform independence."

> In some ways that sounds terrible by itself, but I think it turns out to be legitimate.

If that's the actual goal, it isn't terrible at all. Why do you think writing large programs quickly is a terrible goal?

> I've been on python projects that need to grow but struggle b/c all the things that make it easy to get a lot done the first few weeks become liabilities very soon.

And those things which make it easy to get lot done in first few weeks but are liabilities would be?

> Adding developers to a project that doesn't declare types and encourages just passing around hashmaps is brutal.

I understand time complexity, space complexity, and api of dictionaries. If you needlessly wrap it in your class, I couldn't know anything without reading through your wrapper. What exactly do you gain by wrapping dictionaries?

> All the stuff you can't do in Java makes it easy for someone else to understand it and edit it.

Examples please. If your developers have an easier time understanding implementing an interface to sort, rather than saying persons.sort(key=lambda a: a.name) then I don't know how that can be remedied.

> I would believe that C# might be a bit better but only being fully supported on MS is a non-starter for many server side situations.

The list of things which aren't supported on mono is small, and basically includes things which won't run outside of windows(office interop) or are deliberately dropped(WPF).

As my colleague once said: "Java is the only modern language in which it possible to write millions lines of code".

I agreed with him.

Minute later he understood what he said <grin/>

"What problem is it that Java solves well?"

The aging Cobol cohort.

Java solves garbage collection well, better than any other language I know of.

Java is good for enterprise IT consultancies. It requires a lot more detail to attention to implementation most enterprise app features, yet it still works acceptably in the end, maximizing consultancy fees.

In the end it rarely works acceptably, but that just helps sell support contracts, so it is also good for enterprisey software vendors and consultancies.

True, but the original question was not "what is the worst programming language" but rather "what is the most disliked". So I do believe we'll get the results that you've predicted (you should add PHP to the list) but at least we're answering the question at hand.

We wont be incredibly enlightened but it will be interesting to see the results and what that tells us about HN readers. Perhaps we'll learn some interesting stuff from the comments as well.

Brainfuck is not a bad language, it just has different goals. Esoteric languages in general can't be compared with general purpose languages designed to be useful.

Brainfuck has the goal of being a bad language.

The goal of brainfuck is to be as minimal as possible. Being bad is just a side effect of that.

If you want a language that was designed to be bad look at Malbolge or INTERCAL.

After looking at those I take back anything bad I ever said about Brainfuck (and also C++).

No, youre right - brainfuck is a good language.

I would call Brainfuck (and other esoteric languages) as an instance of what "critical design" as described by Anthony Dunn. The goals of critical design are to produce artifacts that get you to think vs. "affirmative design" which is meant to create usable artifacts.

I agree this poll by itself is a little misleading, but if we take this poll and the poll on the favorite languages, we will get a better picture of what people are thinking. Here are the numbers for a few popular ones, as of now: C:780,22; C++:424,213; C#:658,42; Haskell:431,14; Java:435,389; Javascript:1125,149; Python:2484,39; PHP:516,334; Ruby:1373,84; VB:34,249. There are still multiple ways to interpret the results, but I really think this poll is extremely enlightening combined with the other poll. I like them.

You're actually not too far off on your assessment of Delphi. Compared with all the .NET languages that sprang up to replace it, it's painfully verbose, inexpressive, and starved for community support.

On the other hand, what it still does well, decade after decade, is pump a 30MB native standalone executable from millions of SLOC in minutes, one that will run on any Windows box without installing any libraries or runtimes. That is, in its own way, impressive. Many businesses still depend on it and instead of an OSS community you wind up licensing libraries from the few remaining dev shops.

I don't know what the state of Delphi is now, but I remember there was a good community around it 6-7 years ago, plenty of Open Source components that filled the gaps in the VCL.

And back in the day, when .net was awkward to use and Java was too slow, Delphi was the king of RAD. Unfortunately they didn't even try to keep up with .net/Java, for example, proper Unicode support wasn't added until Delphi 2009.

The current state of Delphi is very good. I picked it up about 6 years ago, and it's a wonderful language to use for native Windows development. They just released cross-platform compilation for native OS X GUI and console applications, have 64-bit and 32-bit support.

In fact, the same person that invented C# first created Delphi (Anders Hejlsberg), and you can see how C# has borrowed much from Delphi.

Delphi, in the past 3 releases, has added native generics, anonymous methods, Unicode throughout the language by default, compiling native OS X applications, compiling iOS applications, and writing native 32-bit or 64-bit applications.

In addition, Pascal (and Delphi) does not have many of the serious security issues C/C++ developers have experienced, by design; e.g., format string bugs are non-existent because Delphi allocates strings on the heap.

Also, the Delphi community is alive and well over at StackOverflow. Unfortunately, many new developers in the US aren't familiar with Delphi...but it's extremely popular in European countries. It really is worth considering if you are writing native Windows applications that require complex GUI's done easily.

Exactly. A bird in the hand is worth two in the bush. The languages you know are always better for doing stuff than the ones you don't know yet.

I didn't see my option on the list. My dislike for the abomination that makefiles are made of knows no bounds. Most of the languages above I can avoid (I simply don't use the languages I don't like), but I curse every time I have to open a makefile, because I know how painful it's going to be.

(makefiles are turing complete, so I think it qualifies as a programming language)

There's a great story I heard years ago about makefile syntax. As I recall it: Stu Feldman, who invented 'make' at Bell Labs in the early days of Unix, realized fairly quickly that the syntax was a disaster. He decided not to try to fix it, though, because he already had ten users.

I'll upvote your makefile suggestion :)

The programming languages that would make me the most sad/angry/annoyed I don't use, so it's difficult to make a choice. I suppose I'll have to go with Javascript because it's the de facto 'Web language' which people use to force me to evaluate arbitrary code whenever I want to read anything on the Web. Even with a sandbox that seems a terrible idea.

If we're talking about programming languages I hate but still use, I'd have to go with Python. I spend most of my time writing Haskell, and Python's dynamic typing puts me on edge. I might spend half an hour evaluating a Python script only for it to throw an AttributeError because I mistyped some function name or passed the wrong type.

Does anyone know a static analysis tool for Python? I found one a while back but when I tried it it threw (you guessed it) an AttributeError on NoneType.

I'm going to sign in as a partisan here. I firmly believe that Python is the worst language that people actually use.

DuckTyping is the most deeply misguided aspect of python. With the discover of Hindley-Milner type inference 40 and 30 years ago, this sort of sloth is simply inexcusable.

Pythonistas will say "Oh, I don't care if it's a duck or a swan, as long as it quacks." Guess what? You can treat function calls as a statement that an object is an instance of some typeclass and that typecheck that. With a sufficiently intelligent compiler/interpreter author this is transparent to the programmer.

With fairness, no you can't, not truly. Please point me to the version of HM the works with inheritance. Plus, due to stuff like __getattr__, the interpreter may not know until the method is called if it even exists.

It would be totally possible in python to write a class where when any arbitrary method is called on a class, a function is randomly generated and called, with a random number of arguments, etc. It doesn't even have to be consistent from call to call. How on earth would H-M type inference cope with that?

I never said inheritance, or method for that matter. You can do H-M on typeclasses. Philip Wadler has a paper on it and it's alive and well in GHC: http://homepages.inf.ed.ac.uk/wadler/topics/type-classes.htm...

The fact that Python allows you to do something absurd is simply an argument against its design.

Edit: Uh oh, looks like I ruffled some snakeskin!

The point is you can't just bolt on H-M to a typical scripting language and expect it to work, like, at all. It's a pretty huge sea change, and it would warp the underlying language to the point where you'd just end up with some of non-lazy, non-pure Haskell.

Well, duck typing can still be statically checked, so I'd argue that dynamic typing is more misguided. That said, I do agree that duck typing is fundamentally flawed. I think swans actually don't quack, they honk, but so does a car. Here we can see a problem with both synonymous and homonymous verbs.

I think it comes down to namespacing: we use modules to prevent naming conflicts, allowing us to compose two modules, but if we do the same with objects their attributes conflict. In Haskell everything has a namespace — there are no methods, only functions — and type classes provide polymorphism without (henceforth) 'quack conflicts'.

Two terrible examples of quack conflicts from the Python standard library are '+' meaning both "add" and "append" (the latter being non-commutative), and the comparison operators '<', '<=', '>=', '>' actually meaning ⊂, ⊆, ⊇, ⊃ when dealing with sets.

Sorry for conflating duck typing with dynamic typing. I appreciate the correction!

I enjoy Python's aesthetics and extensive libraries, but wish it had (practical) static type inference. (RPython isn't really practical.)

And to confuse matters, Python 3 added optional type annotations that are ignored by the runtime!

Emacs with flymake mode or pycharm both do a great job at giving you real-time feedback on issues like that.

pylint catches most such common errors.

Editra with the PyStudio plugin has become my favorite development environment. It runs pylint every time you save a file and highlights lines with errors.

I believe vim + syntastic should do the same

Sublimetext 2 + sublime lint plugin makes for a very nice python programming experience

Easily C# and Java, I don't think the virtual machine adds anything other than another abstraction layer to get in the way. Just because code is native doesn't mean you can't have all sorts of built in bounds checking to ensure safety, but when you're in a VM, taking off the training wheels when you need to actually make shit fast is such a pain.

I especially don't understand the point of a VM like the CLR that only runs on one platform. It's fucking retarded.

On top of that, after having worked in an "enterprise C#" project for an unfortunate year, the kind of person who thinks C# is a really neat idea just doesn't get along with my style of programming.

I had to reiterate constantly "Do the simplest thing that will work". And they would get pissed at me whenever I inserted something at the wrong layer of their pointless abstraction hierarchy. Delegates, XML, and design patterns abstracting ONE thing where everywhere. It was fucking horrible and it took the team forever to get anything done.

I work in C# quite a few days a week, and I share your pair regarding the simplest thing. We have a couple of astronaut architects on the team (both of whom are actually good programmers, but they tend to get starry-eyed about MS frameworks and patterns), and I have trouble understanding why even a relatively "simple" web application requires nearly 30 Visual Studio projects.

Personally, I don't mind C# much (I do work at an MS-centric shop), but some of the baggage that comes along with the .NET framework can get bothersome.

How much of your rant has to with the actual language C# as opposed to the VM, other people, XML and patterns?

Good point, the language felt like Visual Basic wrapped in Java's syntax, or maybe a reaction to Java with subtle improvements. There were some nifty things baked in like events and lambdas, but for the most part it didn't feel like I was exploring any fundamentally new constructs or gaining much in the way of expressiveness over C++ with boost. The whole language just feels milquetoast.

It was also difficult to get stuff across the managed/unmanaged boundary without a lot of verbosity and overhead, so optimization was unduly difficult.

But really, it's not the language I hate, the language is mediocre, its the ecosystem around it that's terrible.

I have had the same experience with C++. But it is not the language’s fault. It is people who use it and call themselves “architects” who know shitload of “patterns” and “good practices”, and make all these unnecessary abstractions and distractions.

Sounds like your complaint is against mediocre programmers and enterpriseyness, not C# (which in my opinion is a technically superior language to Java). I use it all the time for simple one-off tasks and while it can be a bit verbose it's never really been a hindrance.

"There are only two kinds of languages: the ones people complain about and the ones nobody uses." - Bjarne Stroustrup

Source: http://en.wikiquote.org/wiki/Bjarne_Stroustrup

But then there's python.

The reason people don't complain about Python is because if you don't like the language, there is no reason to use it, so they don't. When people are forced to use it, they do complain--stupid scoping, horrible lambdas, no pattern-matching, weird desugaring, idiotic default argument semantics and so on. (These are all the things I've heard about it from other students in my compilers course.)

People use C and C++ when they need fast code close to the machine. People use Java when they need more portability but can't sacrifice performance completely. People only use Python because they like it.

I have always felt Python is the new Java. Same qualities of verbosity, low barrier to entries.

And weird level of verbosity for a scripting language.

I do not know why someone has downvoted zxy. He/she has the point: python is used by many but few dislike it. Python is a third kind: the ones people like. Bjarne was looking for excuses for his bad C++.

I don't know, I know a ton of people who don't like Python. The difference is that unlike C or C++ or even Java, if you don't like the language itself there is no compelling reason to use Python, and so those people don't.

That said, when people do have to use Python, like in my compilers class right now, quite a lot are not happy with it. (Even the professor gets annoyed with it; I really don't know why we're using it.) So I think there is just much more selection bias in the land of Python than in C++ or Java.

Yes, that could explain off some differences between python and C++ in these two polls, but right now, over 95% python voters favor it as opposed to about 50% for C++. I can hardly believe your argument alone can explain off this huge difference. Also, look at C and C#. A lot of programmers are forced to use them, too, but they seem to like them better than C++ at least in the HN community. On the other hand, I agree that Python may not be the best choice for a course on the compiler theory. I am sure more would hate python if they were asked to develop a linux kernel with python.

I complain about python all the time, but I'm in the minority.

Is that the language with `pass`?

Are you complaining about the backticks or the pass keyword, or both?


After several years of Java programming I am now in the position of being able to turn down offers of work. I consider having been a Java programmer akin to having appeared in a porn movie. I was young, naive and needed the money.

I am seriously considering excising Java from my cv and replacing it with something I would be more comfortable with - like Mumps :)

You say it as if appearing in a porn movie was something bad.

Have you thought about learning Scala or Clojure? Don't let the fact that they run "on Java" put you off. They're excellent languages but run on the JVM, and their cultures are different enough because of the very high (at least for now) quality of the average developer in these languages.

You missed the worst one in the world - Mumps (or M).

Terrible language that produces (seemingly automatically) terrible software. It also rots the brains of those that are forced to use it.

All of those listed have their charms - seems hard to dislike them in the main.

MUMPS still has a healthy user base at that. MGH is obviously a large user base (interview with a hospital in Boston and it'll eventually come up in conversation), but the fun is when you get into the dialects of it. For example, MEDITECH has their own dialect named MAGIC, and at least one of their employees has attempted to make things better.

I should try to get him to post to talk about it, but he created an object-oriented version of MAGIC that supported longer identifier names and other more modern constructs, as well as an interpreter that spewed out perfectly standards-compliant MAGIC. Originally he was barred from using on existing, but eventually got approval to use it on new projects and I guess some portion of the MEDITECH developer population uses it over plain-jane MAGIC now since it's substantially easier to write and maintain.

Though recently he's reached out asking about the job market. He's been there since his early 20s and now is in his mid-30s and feels as if he's dead-ended himself on the job market unless he gains familiarity with something else. I think he's finally looking to break away from MUMPS.

I came in here to add MAGIC as my "most disliked" language.

I spent a few months writing reports in MEDITECH and their macro language is a variant of MAGIC. Documentation is a closely guarded secret but you can get a taste of what it looks like here: http://www.99-bottles-of-beer.net/language-meditech-magic-38...

Had to look this one up. It's amazing that after 15+ years of programming I keep coming across technologies that seem to live in a parallel universe.

thedailywtf.com usually posts horrible code bases that developed gradually over time. But their collection of MUMPS horror stories has convinced me that any project in MUMPS is already doomed. http://thedailywtf.com/gsearchresults.aspx?cx=00708007008730...

Those are horror stories, recall. If you want to write bad code then you can do it in any language. These stories don't resemble what I have experienced. (I work for a healthcare software company in Wisconsin.)

In particular, a sensible coding style and sensible development practices (yes, name your variables sensibly! yes, use source control! yes, have code review and automated tools to catch common errors) can remove the bad. It also helps if your company wrote its own (quite good) IDE for the language so you don't have to use Intersystems'.

Honestly the most fun thing about M/MUMPS/Caché is that there's very little boilerplate and you can write sensible code quickly. It's like being stuck with Java and then suddenly moving to Python or Ruby. (With, yes, a few pitfalls that these languages don't have, and quite a few features missing. I still prefer modern languages for personal projects. But you quickly pick up a sense for practices to avoid.)

I can't say all companies that use Mumps are great places to work. But mine honestly is. </soapbox>

If only. There's a good chance that some of the important systems at your friendly neighborhood hospital are running on MUMPS.

Some comments on popular choices: I chose C++ because it's a horrible language that holds a lot of industry hostage. You can't use anything else because of tooling and network effect, but writing C++ is painful and dangerous.

A few years ago I would use PHP because it's so horrible and it destroyed a lot of innocent souls who entered programming via it, forever damaging their understanding of consistency, abstraction and modularity. But these days PHP is a dying emperor and there's no much reason to care. Visual Basic is even more strange choice because the language is not as bad (primitive, but not very bad) and you can skip it.

People pick JavaScript because they don't like not having choice + having to adopt to quirks, but on other hand we could never get anything better. Imagine if browsers defaulted on some kind of BASIC (no OOP, confusing data types, obtuse data structures, no hash maps, huge confusing spec) and that's what we'd have to use? Brendan Eich is a genius, he created a language for twenty years in ten days.

Java: Those who actually write in it have reasons to hate it, those who don't just translate their groupthink, I believe.

I still would rather have web browsers say "can't find an interpreter for type=ruby" than be stuck with javascript. Thats why I voted javascript, because in every other case, I have a choice - the languages I dislike, I dislike less because I can just not use them. No the case with JS.

The main problem is the DOM and event binding. Do you want to refit ruby to play nice along with browser model?

Problem is, surprisingly, nobody does! And the sandboxing would be huge too.

I'll volunteer to do this for Lua. Which browser vendors do you have on board? Perhaps we can teach the world that "Asynchronous code" and "Seven nested callbacks" are not synonyms.

Take the chromium, put lua inside.

After you do that you have better chrome than Google does and you can start distributing it. It's in fact doable, once you have a set of patches, to reach some audience with that build.

Shellscript - both sh and csh. It has horribly inconsistent syntax, a myriad of ridiculous quoting rules that always explode on you whenever something unexpected shows up as data, almost zero data structures, and you have to fork a process to do anything. If not for the fact that it comes standard on every UNIX system, everybody would be laughing at anyone who tried to write anything serious in it.

I learned to avoid bash really fast: the first script I wrote in it took more then half an hour to get right because I wasn't expecting it to treat 0 as true and 1 as false in the if statement.

I couldn't find any mention of (pre-PowerShell) MS batch (CMD.EXE, COMMAND.COM) language. At the shop I work at, WinXP is still the standard platform, and .BAT the first line scripting language. It's nauseating; the threshold at which I typically start looking to rewrite .BAT scripts in languages not intrinsic to the platform is about 3 lines of code. Unfortunately, if you want to write programs that modify the environment of the CMD shell from which they were invoked, .BAT scripting is unavoidable.

If you have a requirement to use languages intrinsic to the platform, CScript.exe (Windows Script Host) is your friend. VBScript and JScript may be ugly, but it's a hell of a lot better than CMD.exe.

What, no hate for Matlab? Other than matrix math, data visualization and extensive libraries, it's a terrible language. Depending on the feature, it's either seriously lacking or a decade and a half out of date.

Its support for basic things like string and file manipulation is weak (after seven years, I still have to look up the order of the parameters for the findstr and strfind functions). Object-oriented facilities were only added a few years ago. Closures were likewise added only within the last few years. Anonymous functions are restricted to just one expression (wtf?!).

It's quite expensive, typically costings hundreds or thousands of dollars, and yet is usually too slow for more intensive applications. The recommended optimization method, vectorization, tends to be be incredibly memory-wasteful, negating any code savings. Its GUI building tool is more primitive than anything built since the mid-90's.

And the default indentation level makes it hard to pick out separate functions in a file, to boot.

The Mathworks is the Microsoft of science.

I see that another generation has discovered HN's poll feature. ;)

The pleasure of watching the old classics come back for another run is tempered by the fact that what has come back is yet another language war.

Oh, well. My favorite least-favorite programming language is the Central Dogma. Gotos. Self-modifying code. Code that deliberately recompiles other people's code. A potentially infinite series of build steps. Not intuitive to read. The output often makes no sense. Very few comments. Nobody seems to have written a manual. And the bootstrap process takes a really long time.

I use Perl a lot, but I have a problem with it. And it's not for the usual reasons. I dislike Perl because it amplifies how much I dislike working with other people's code. In something that constrains expression like C, it's easy to read most people's code. And in more expressive languages like Python, I at least feel like we're communicating. But to read someone else's Perl code, you have to get inside their heads! It's like you're not even speaking the same language.

I haven't noticed this, and I've worked on a lot of other people's Perl.

Like anything, practice makes perfect. Read more Perl and reading Perl will become easier.

I chose Python not because of the language itself (in fact, it is not that different from a bunch of languages that I love), but because it is a preacher under the cloak of a language.

I mean, yes, by default, I do a lot of things that Python requires. However, that does NOT mean I need a stupid computer program to rub into my face what I am supposed and not supposed to do. Oh, and for an incomplete, not fully ideal language (look at it stupidity in lambda form, fake private fields in classes), it's a sorry excuse for a preacher who attempts to "right" already right programmers.

Programming is about self expression, about creativity, and about practicality. It's not about preaching, high ideal, and hypocrisy. Reading Python's mailing list always makes me want to puke and stab someone.

Lastly, Python's popularity constantly reminds me of the sad state of, you know, freedom of speech, expression, and thinking. Oh, did you realize that the only thing Python is better than other languages is its library? Yeah, the language itself sucks, restricts people, cumbersome, and fails to implement all features (again, lambda and private). Yet, it's popular. Sad.

That stuff that is used in Autotools, ugh ... What did they call it? M4 I think?

Yeah, most people know M4 from Autotools, which is a poor use of it really. M4 was created by Brian Kernighan and Dennis Ritchie, the same team that created C. So there was some expertise behind its design. I've only use it for assembly programming, where is was very handy. But yeah, Autotools is probably why most people hate it.

Easily Visual Basic for me.

My first exposure academically to a programming language was Visual Basic. This was what they "force-taught" at school.

I already had experience with Java/PHP/C, and just wreethed inside with disgust at the rationale for learning Visual Basic. It was a horrible experience that was forced upon me by my school's teacher. (I was about 16-17 at the time I think).

As a form of silent defiance, whenever I had to declare a variable, I would call it `dim $%something%`. Ha.

Had a similar experience when learning languages at the school I went too. There tehy started out with Perl (ya I dont' know why either), then VB6, and then ended with Java. It's probably the only time I've ever looked at Perl or java so fondly, and the VB6 experience was so bad it tainted my opinion of the .NET platform for years afterwards.

my first academically forced language was Java and now I hate java the most. I wonder if more people hate the first language they got taught.

My first academic (and non academic in fact) language are C... and I still find it nice ! And for the short exposure of Java, I find it distastefull with lot of cruft. Especially since I've met Common Lisp and Haskell...

When I was in college everyone hated C but I loved it.. but when Java came across, all those hated C loved Java but I never liked it.

My first language (after basic) was 68000 assembler (unless you count digital logic), followed by C and C++. When I went to college, they were imposing Object Pascal, which seemed a clunky and pointless language overall. It's possible that the language wasn't as bad as I made it out to be, but first impressions tend to be lasting impressions.

I imagine it varies considerably based on the teacher and other circumstances.

You may be on to something there. I despise BASIC and would never use it as an introductory language to someone learning how to program.

I Chose C++ because it's the language which makes me suffer the most. Besides the existence of legacy code and currently available expertise, this language is totally inappropriate for the work I'm currently doing. Also, I suspect C++ is the language that cause the most suffering among programmers, partly because it is so widely used in the first place.

As for why I hate it so much, the arguments are well known: the language is overly complex, not very consistent, generally unsafe with regards to exceptions and memory management, and widely used for applications that could have used a garbage collector. C++11 solves parts of this, if your team observe very clean coding conventions, and at the price of an even more complex language.

For my favourite language, see http://news.ycombinator.com/item?id=3747696 (The current answer is OCaml, but I now know of another approach that looks orders of magnitude better.)

Javascript because I just don't have the choice to not use it.

You have to stop worrying and learn to love the bomb ;p In all seriousness, I feel that a lot of people(me included) go through a period of hate for javascript until they find that it's actually has some impressive expressiveness using very small set of things.

You know, what I hate is the JS community. It seems JS is split into two camps:

1. Ordinary people trying to get something done. Often not professional programmers. These people account for most JS on the internet.

2. JS hipsters. The kind of people who use Node.js and worship Crockford. They refuse to accept that anybody might want to use a language other than JS on the web, or that if you only accept the "Good Parts", you'll be set for life (where's my static typing, bitch?).

Languages are as much people as they are technology. I use Python because I like the people who use Python. I use Haskell because the people who use Haskell are really gentle and humble.

Good, reasoned people lead to good, reasoned code. I don't see that with the JS community.

Perhaps the JS community you portray doesn't just exist in two discrete attitudes. As far as I see it, JS is a fact of the current web so trying to get the best from it is the easiest way to dull the pain of what is often clumsy and irritating. There are certainly places and uses where static typing would be great and the web is no exception but JavaScript isn't suddenly going to go away just because it's easy to write bad code, or because a load of 'hipsters' are making some flavour of it popular at the moment.

I definitely have a very strong love / hate relationship with javascript. On one hand, you can be very expressive with Javascript and it absolutely can be an incredibly flexible language with a lot of power.

On the other hand, there's a LOT of warts in the language. Random reserved words like 'class' that don't even fit the language's approach, variable scoping that can very easily bite you in the ass if you don't know what you're doing, optional line terminators that seemingly exist for no reason other than to create bugs, stuff that should be avoided at all costs like 'with'. And that's just scratching the surface.

Yeah I agree on a lot of the points you mentioned. Block scoping would have been better in my view also. But there are tools, like in other languages, to ease that pain. I never forget a semicolon due to using js2-mode which makes missing semicolons stand out. JSLint and other tools of the sort help find bad code too. And the in browser tools like the Chrome dev tools with a debugger,tracing,console really make it much easier.

Javascript without the tools would be a real pain.

You must be right. It is like I still have the stigma of the early days of Javascript in the browser.

I do mainly PHP so it's not like I can't overcome bad design. I routinely try to get a fresh perspective of JS but it does little. I praise jQuery everyday though.

Get a hold of Douglas Crockford's 'JavaScript: The Good Parts' book. JS is so incredibly pervasive you're going to have to put up with it, so you may as well see if you can get along with the nice features like closures, functions as first class objects and prototypal inheritance.

I wonder how much of this disappears when you normalize for use? PHP would still seem overrepresented and C underrepresented.

  There are only two kinds of languages: the ones people complain about and 
  the ones nobody uses. Bjarne Stroustrup

I chose Python. The lack of explicit types combined with a crappy documentation make the standard libraries a pain to use. Reading somebody else's code too, unless it is thoroughly documented (aka the what-the-fuck-is-in-this-variable syndrome).

Anything .NET, because I don't see the point of learning a proprietary non-cross platform language.

Agreed 100%. In addition software written in it seems to have the following other problems frequently

- Using Oracle - Rarely contributing to FOSS - Using very non-agile development methods - 9 to 5 corporate culture - Bad UIs and boring software overall - Terrible web accessibility and standards conformity - Hearing people say, "Its better than Delphi" as a comparison point

But those are just my experiences in working with teams using .NET. My run-ins with .NET have only gotten worse since I moved to Columbus, Ohio. I don't know anyone in the Valley using it, but people working for insurance companies seem to love it.

I was originally taught VB in school and thought it was amazing. Of course, I needed to get a student license for Visual Studio...and I needed to wait an hour to install it everytime I bought a new computer...oh and what I created could never be used by anyone on a Mac or Linux system.

A couple weeks later I discovered the wonderful world of Linux and never looked back.

Mono Project www.mono-project.com

yep, forgot about .Nyet and all those C# fanboys Despite my hate for Java, I have to admit Java > .Nyet +1

I think C++ is a terrible language but I actually like that it exists because it distracts people from adding all of the crazy features to C :)

better than java :P

I think for a language to be disliked it should be in one of the following categories:

1) First category is where you are forced to use it, and it is easy enough to get started in. For these languages the programmer base is big enough for the mandatory awkward features of the language be stumbled onto frequently enough to gather all the hate, and also big enough for the language hating to become a pop culture. Javascript, Java, Objective C, Visual Basic, PHP are languages in this category.

2) The second category is where you are forced to use it, but the language takes a long time to master, there are so many rules to learn and practice that unless you have spent 10 years coding in these languages, you cannot call yourself an expert. The hate for these languages is a different kind of hate and it spawns from the programmer's frustration to conquer the language completely. It's anybody's guess that C++ is the language I am talking about.

3) The third category is where you are forced to use it, and learning the language is just an annoyance mainly because it is just a different syntax for a language you have already learnt, and the learning effort that you put in is not commensurately rewarded by expanding your mind by introducing you to new ideas in programming. Ruby (does not add anything to Python), C# (does not add anything to Java), Coffeescript (does not add anything to Javascript) are such examples.

One constant across language-hating is that the programmers are forced to use them, either because their jobs require it (Java, C++, Visual Basic), or it serves a niche where there is (was) no equivalent (C++, PHP, Ruby on Rails, C#, Javascript, Objective C).

Then there are languages like C and Python, which are so freaking awesome, groundbreaking, and so much valuable for their niches that they just simply cannot be hated.

1. I think it's possible to have a hatred of C++ that doesn't stem from a lack of understanding of the language. I think the C++ FQA (http://yosefk.com/c++fqa/) addresses a lot of the dislike people have with C++ that has nothing to do with ignorance of the language.

2. Saying that C# doesn't add anything to Java isn't even a simplification, it's flat out wrong. That argument may have been slightly valid in the C# 1.0 days (although there were quite a few differences like auto-boxing, properties, and pointer support), but the languages have diverged significantly, and modern C# code using lambdas, LINQ, and dynamic variables is signficantly different from Java.

Similarly, CoffeeScript and Javascript are massively different languages - the fact that CoffeeScript compiles down to Javascript doesn't mean the languages are similar, any more than saying Clojure and Java are practically the same since they both compile down to the JVM.

You are partially right about C#, my experience with it dates back to the 1.0 version, but even with all these enhancements is it worth spending in the effort of learning two similar languages when you could be learning a different paradigm which will expand your mind in different dimensions and will make you a better programmer. If you are proficient in Java and want to move to .NET why not learn F# instead.

About you comparing CoffeeScript with Clojure is not fair at all. Clojure gives a whole new world on top of JVM, while CoffeeScript is just syntactic sugar for Javascript.

You're right that Clojure -> Java is an unfair comparison, but I do think there's significant differences between CoffeeScript as a language and Javascript. If you ignore the fact that the main implementation of CoffeeScript compiles down to Javascript, and look at them instead as two wholly distinct languages, I wouldn't consider them very closely related at all.

CoffeeScript has significantly different syntax from Javascript, different variable scoping rules, list comprehensions, a class system, and a whole lot of other features absent from Javascript. If you showed both languages to a programmer who wasn't aware that CoffeeScript compiled down to JavaScript, I'd guess that they wouldn't see much of a relationship between the languages at all.

I hate Python with a passion I cannot express or explain.

Must be the forced indentation. One of the things I love about it.

I don't hate it, but I hate it's growing popularity. It is the little things, for example functions like len() that should really not be standalone but belong to string or array or whatever (I am not that deep into python). Or the the crippled lambda.

To me it is roughly equivalent to JavaScript - both have some syntactic sugar that the other doesn't have. But JavaScript has full power lambda and is overall much more elegant in my opinion (in the sense of needing less concepts to achieve more - basically it is all hash maps and functions).

Perhaps CoffeeScript is the solution, haven't really tried it...

I understand the frustration with the crippled lambda. But with regard to len() and other global functions that seemingly belong as methods on string/array/etc. -- it's worth reading Armin Ronacher's post on the rationale behind that:



Actually, add regex to my hate list.

Bash — language where even spaces are dangerous.

It's frustrating that in shell scripting gap between "looks correct" and "is correct" is enormous.

Whitespace, leading hyphens, paths, globs, shopts, masks, signals, race conditions and POSIX compat problems and quirks — there's always some edge case.

Even `echo` can't output arbitrary values in a portable fashion (sometimes accepts `-n`, but doesn't accept `--`).

Actionscript, Java, Objective C, Rexx, Visual Basic and any language that claims to be god's gift to developers without delivering. But my most hated has to be Java for all the extra condescending syntax and verbosity, enterprise "mambo-jambo" cruft, native code through jni circus, and general ugliness...

SQL by far.

I would have said "Visual Basic" but I have not had to use it in a long time. But I cannot avoid using the damn SQL!

Objective-C. The syntax of this language is hideous. In most cases with languages like C#/Java/Python/Ruby etc. even if you don't know them you can understand a few things by looking at the code. Every-time I look at Objective-C code it hurts my eyes. What a convoluted piece of crap.

I'd encourage you to play around with Obj-C a little more before writing it off. It's actually a pretty simple, compact and concise language once you dig into it. Apple's APIs, on the other hand... :facepalm:

I’d give it a try if it worked on Windows or Linux. I’m not willing to buy a Mac just to be able to study a language-I could build a Hackintosh but it’s too much trouble for what it’s worth. Most of the languages out there work on any platform. Even C# works on Unices through Mono. But for Apple’s products its always the same story, our way or the highway.

Someone can correct me if I'm wrong, but I believe the language itself can be used on almost any platform with gcc, not just OS X.

You are correct. GNUstep would be the most well known project to make use of ObjC outside of the Apple world. Also, since it implements the OpenStep API, you could use it to get a basic feel for Mac development without jumping in to the Apple fog.

You're quite right, though of course you don't get the Cocoa libraries. GNUStep might give something of the same flavor, perhaps.

Which APIs do you dislike? I think Apple's Cocoa and Cocoa touch frameworks are some of the best. Cocoa is old and less polished, but Cocoa touch is pretty awesome.

I'd agree on Cocoa Touch, but Cocoa seems like a mess to me. I hope Apple will clean up the Cocoa API at some point in the future ...

In what way? I find AppKit to be extremely well designed. It has warts, but it's by far the best UI toolkit out there.

My only complaint would be how hacked on Core Animation is in comparison with UIKit. For example, WebView doesn't like having a layer, but this isn't mentioned anywhere in the documentation:


Objective C is the 6th C-like language I've used professionally. It took a bit of getting used to, but now that I know the overall design goals, and how everything's implemented under the hood, I find it to be quite an elegant language. Properly designed APIs are a joy to use in Objective C since it's very easy to describe your intent.

I voted for PHP - it was the first "web" language I ever learnt.

I'm not going to hate on it for all its foibles, like the $ before variables and the jumble of functions that constitute its standard library which totally lacks any and all kinds of namespacing.

The real reason behind why I hate it, is because as a newbie, it let me do things that are now, in hindsight, terrible practices. Things like including mixing code and markup outright, placing source in public facing directories, and not to mention the myriad PHP tutorials which encourage handling paths using simple concatenation.

A better language, I feel, is one that 'pushes' against things that are wrong, and makes them harder to do.

I'd also have voted for Java if I could, for no other reason than its verbosity.

ps. If you're wondering, I like Python most.

I'm rather surprised that there are 30 people on HN that know COBOL well enough to dislike it most.

Java got the vote from me, not because I hate it, not because it's a bad language, but because I use it every day.

There is so much that is good about Java language which I take for granted after working with it for years and yet, given my daily use of it, I see the things that it is sorely missing. I'm a huge fan of Clojure, and have worked with JavaScript a lot too... and in the end I gnash my teeth at Java for lacking immutable data structures and lambdas/first-class functions. If/when these two items become parts of the Java language and JDK, Java will be a language which I (again) find a pleasure to use.

I was kind of expected that the Java will win this, but I think this is clearly misleading. Java is an OK language IMO, its just the open source and j2ee part are bad. But if you let the assumptions which come from sun, oracle and other j2ee pushers, the language is very easy and capable of working with. For instance - the common "wisdom" is to use getter and setter. However if you just declare all your fields as public the code becomes much less verbose and usable. If you are determined to have the work done, Java will do it as fine as any other language and will be very fast and maintainable.

What, no RPG III? That is really at the top of my list, even above perl.

PHP. There are worse languages, but PHP is hard to avoid.

I want to do some simple automation on a website. Because I don't like PHP, I have to pay a premium for a Windows based host that supports ASP.NET.

For next time, there are multiple languages such as Python, Perl, Ruby, Java etc that could do the automation and not have to use Windows. And granted about PHP. The big problem it has is its inconsistency in terms of function parameters. Slows the developer right down.

Windows licence is not free, you know? And there are plenty Linux hosting options that provide other language runtimes.

i used to hate javascript a lot. but then jquery came along and changed everything and i know i'm not the only one who feels this way about javascript.

this goes to show just how easily a well-written framework can change the whole perspective on a language.

another good example is ruby, i doubt ruby would be this popular if it wasn't for the rails framework.

one language that i do like at a glance but haven't had the experience is python. seems to me like it's the easiest language to learn (especially easy on the eyes, good readability) and it's not a surprise why people like it the most here on HN. but one being gripe about python is that it really is a pain to get the environment setup. i've had a friend who worked a backend-piece for me written in python 2.6 and i had a chance to setup the environment first-hand myself to get it working and i must say it wasn't really a pleasing experience. i'm not sure if he just does "things" differently or not but he told me that i need to setup python in it's own container to not conflict with system python because the one he was using was a different version of python. not only that, the pain i saw really came from him having to load a plethora of modules to just get his app work (like modules just to convert decimals?). when it comes to portability and readiness out of the box to start working, i think python still has some ways to go.

I would have to say C++, because it burns so much talent that could have been spent on solving actual problems. I also dislike C++ because I think it is a transitional language. It came about in the vacuum between structured programming and OOP and thus ended up being neither structured programming nor OOP.

If you are a good C++ programmer you still lose, because with a programming language where 90% of your talent is not bound up in foot-shooting-avoidance, you could have been doing fucking amazing work.

Can't remember who built this, but here's a chart: http://hnlike.com/hncharts/chart/?id=3748961

I think this poll might be slightly misleading (just like the other poll about favourite languages sometime ago). Quite simply, people are more inclined to vote for languages they've used themselves, because they've experienced the annoyances and wonderful things first-hand. Personally, I find it rather hard to believe that someone would dislike PHP and Java more than, say, bash scripting (which I presume falls under 'Shell' here) or ASM.

Just for fun I wrote a script to take the diff of the score values for the "most liked" languages in the other thread and the "least liked":

Actionscript -59

Ada 8

Assembly 53

C 809

C# 626

C++ 29

Clojure 386

Cobol -51

CoffeeScript 245

ColdFusion -43

D 38

Delphi 6

Erlang 133

Forth 24

Fortran -9

Haskell 445

Java -324

JavaScript 899

Lisp 258

Lua 123

OCaml 63

Objective C 113

Other 148

PHP -254

Pascal 6

Perl 105

Python 2639

Rexx 2

Ruby 1346

SQL 29

Scala 181

Scheme 149

Shell -25

Smalltalk 47

Tcl -1

Visual Basic -445

(Negative numbers mean the dislikes outweighed the likes)

First I was a bit disappointed by how much hate C++ gets but I'm happy to see it on the positive side even by just a tiny amount.

That said, this poll is not online for the same period of time. Not that negative points could take away anything C++ can do for me.

You can only love or hate C++ if you've used it, and I would guess that many readers on hackernews have never had the pleasure of using C++ a lot before; i.e., as a professional C++ programmer (though this would be an interesting poll to take!).

I listed C++ as a dislike, and I believe it deserves the hate. C++ basically means full employment for PL engineers (like myself) to build decent parsers (C++ is almost unparsable), compilers, bug checkers (C++ code is dense with bugs that can be found via analysis), and so on. I came to a point in my career early on where I realized that this was just ridiculous, so I got out of the C++ tool industry just as fast as I got into it (and worked on Scala instead, sort of ironic).

Many people have to use C++; e.g., if you are writing embedded systems, OSes (device drivers), or games. Most everyone not in those industries will just continue to stay away from it.

Java, I was force-fed it in school. We actually had to develop web applications with it.

I wouldn't have cringed so much if I hadn't have been developing in nodejs and php prior.

Web application with Java? Oh high school.

I'm so confused about why C is so liked, while C++ is so disliked. I mean everything you can do in C you can do in C++...Is it because C++ is too high-level for the work that C is primarily used for, and too low level for applications that are better suited for something like Java or Python? I'm a C++ hacker by education, its the language I'm strongest in. It definitely has flaws, but I DEFINITELY enjoy it over C.

Because C is simple and C++ is complex, perhaps. Personally I agree with you, I would always choose C++ if given an option between those two.

Here's one answer to that: https://lwn.net/Articles/249460/

"The fact that we also piss off people who cannot see that is just a big additional advantage."

I like Linus.

Applications are open for YC Summer 2021

Guidelines | FAQ | Lists | API | Security | Legal | Apply to YC | Contact