Python.

It is too easy to write “seems-to-work” code with it, creating tons of shitty software and people who thinks they are good at programming just because they know how to import things.

I hate it because the worst working hours I had consisted of debugging someone’s code on that language, and almost all errors were due to things that would be labeled as syntax errors on any reasonable language (mainly type mismatches). I know it is not actually Python’s fault, but I think that these kind of languages can be a nightmare on the corporate world because a lot of people find it attractive for its apparent high productivity.

Also, I hate the inconsistency of its libraries, where some functions are named with camelCase and others that_way, or the “functionalitis” and the “procedurism” you find all merged there.

Ah, and the no-backwards compatibility between python 3.x and python 2.x, seriously.

And finally, the general douchebaggery on the Python’s community. Don’t ask me why, but the greatests idiots who like to make comments like “wow, Java, so blue-collar, much 2013” are there.

Here are the top 5 most hated programming languages based on “likes” and “dislikes” on Stack Overflow Developer stories:

Image Credit: Technotification.com

1. Perl

A pioneer scripting language in the early web, and one of the most promising languages, Perl gradually became unpopular mostly due to its illegible (“hard-to-read”) syntax.

2. Delphi

Failure to implement OOP structures such as Multiple Inheritance alongside legacy issues were contributing factors to Delphi’s declining popularity.

3. VBA

Professional developers vividly remember Visual Basic for Applications (VBA) and its ability to glue together pieces of Microsoft Office tools such as Excel, Word, Access and PowerPoint. But lack of portability to other platforms alongside legacy issues meant developers were stuck with Microsoft Windows forever.

4. Objective-C

Objective-C is actually a great programming language, but the major drawback is that you have to buy a Mac to use it. In addition, the Objective-C syntax is a little different from other C-derived OOP languages like Swift, Go, C++, Java, C#, etc.

5. PHP

Once the darling of web developers, PHP is one of the most successful programming for developing the web. However, over time, developers accused PHP’s sloppy syntax of making it too easy to write code vulnerable to common attacks such as SQL injections.

PHP is still very popular but has lost ground to other languages such as Python.

That being said, PHP is getting much better with the new OOP features added into the language in PHP7.

In my opinion, BASIC and Visual Basic

The classic BASIC is overcrowded with line numbers and you must reserve the numbers without knowing how many lines you'll have to insert after that. For example when you had written line 10, 20, 30... then you want to insert 11 lines between line 20 and 30 then it's a disaster if your program is a thousand-line one.

5 LET S = 0 
10 MAT INPUT V 
20 LET N = NUM 
30 IF N = 0 THEN 99 
40 FOR I = 1 TO N 
45 LET S = S + V(I) 
50 NEXT I 
60 PRINT S/N 
70 GO TO 5 
99 END 

You also have GO TO’s everywhere and it's hard to follow the program flow. There’s no code block like structured programming languages.

This has been taken advantage (or maybe abused) in this codegolf contest Execute prints backwards

40 print "Line 1" 
30 print "Line 2" 
20 print "Line 3" 
10 print "Line 4" 

Page on stackexchange.com
The code will print backward from "Line 4" to "Line 1". This confuses the programmers when realizing control flow even more.

The newer Visual Basic is better with structured blocks but still overly long and verbose compared to other languages because of several reasons. Firstly, the variable declaration is the longest in all languages that I know

Dim Count As Integer, a As Integer, b As Integer 
Dim ratio As Double, tmp As Double, data(1000) As Single 

You must specify the type for each variable and get stuck with As and type everywhere because there's no shorthand form. In the following code Dim a, b As Interger, a will be of type Var (a type that can store everything) and not integer which is probably not what you expected. That makes performance worse and sometimes provide a gate for bugs to get in. It's unlike most other languages like C or Pascal when multiple variables declared at once (such as int a, b, c or var i, j, k: integer) will be of the same type.

Besides, there's no way to initialize variables and you must assign it explicitly after declaring. Again there's no shorthand. You'll see how much frustrated it get to initialize a thousand-element array. Not to mention the slowdown when you need to assign it individually instead of just reading the compile-time table that is stored in a separate section like in other languages.

Private myarray(3) As Integer, someint As Integer 
myarray(0) = 1 
myarray(1) = 2 
myarray(2) = 3 
myarray(3) = 4 
someint = 5 

It also lacks bit shift operations. Imagine how to do many bitwise operations problem without a shift? There's no way other than you must emulate it with multiplies/divides by powers of 2.

Another thing is that arrays are indexed by parentheses (), that makes it hard to distinguish arrays and functions. I don't know why they don't use {} and [] when they're already available. Lots of other symbols are also wasted in BASIC. They use words instead for statements or block terminations and make the code longer

And did you see some imported function declarations in VB?

Private Declare Auto Function InternetSetOption Lib "wininet.dll" (ByVal hInternet As IntPtr, ByVal dwOption As Integer, ByVal lpBuffer As IntPtr, ByVal lpdwBufferLength As Integer) As Boolean 
Declare Function RegCreateKeyEx Lib "advapi32.dll" Alias "RegCreateKeyExA" (ByVal hKey As Long, ByVal lpSubKey As String, ByVal Reserved As Long, ByVal lpClass As String, ByVal dwOptions As Long, ByVal samDesired As Long, lpSecurityAttributes As SECURITY_ATTRIBUTES, phkResult As Long, lpdwDisposition As Long) As Long 
Public Declare Function GetDiskFreeSpace Lib "kernel32" _ 
	Alias "GetDiskFreeSpaceA" (ByVal lpRootPathName As String, _ 
			   ByRef lpSectorsPerCluster As Integer, _ 
			   ByRef lpBytesPerSector As Integer, _ 
			   ByRef lpNumberOfFreeClusters As Integer, _ 
			   ByRef lpTotalNumberOfClusters As Integer) As Integer 

Occasionally you’ll see even more complex versions with various attributes attached. Beginners are often told to copy those into the code when they need to use some function without explaining why. The syntax is also not easy to understand to them.

The clumsy code makes it harder to skim through the whole program.

VB.NET has solve lots of the problems of VB6. It has added support for arrays/variables initialization. It also added the shift operators which helps a lot in bitwise operations. But in general, it still doesn't help you get rid of the bloated code like previous versions.

Perl is probably also hated by many people. The syntax is horrible with so many syntactic sugars and undecipherable special variable names. The implicit $_ variable also makes it hard to understand in many cases. And there’s no way to pass tuples and arrays to functions. As a result later versions have to introduce references to solve that, which makes the syntax even stranger. All those things are just a pain for maintainers

Another language that I didn’t have a change to code on but I’ve seen a few colleagues working on it. The syntax is even more verbose than VB. It’s COBOL. Applescript is also an overly verbosed language and will be hated by many people.

Edit:

No doubt Visual Basic tops the “most dreaded language” Stack Overflow Developer Survey 3 years in a row (as of 2018)! Perl and COBOL also made their names into the list

If there is one language that is at the top of my least favorites it is Objective C. The language is so radically different to me than every language I’ve ever encountered.

I’ve programmed with BASIC, Visual BASIC, C++, FORTRAN, COBOL, C#, Java, JavaScript, Python, PL/SQL, but none of these languages ever looked so foreign as this one. The brackets use in the language are very strange to me. What bothered me about it was that it was the chosen language for IOS. You take one of the most popular systems and throw an almost unknown language at it…. but even Apple recognized that it was not the best choice and have since replaced it with Swift.

Another program that really bothered me was Visual Basic for Applications (VBA) because it is interpreted instantly which means that if I make a mistake it barks at me until I correct it. In compiled languages I usually come back to double check my code before I compile but first I try to get my basic logic down. Not so with VBA. If you have an error you have to fix it. That aspect of VBA interrupts my flow.

I offer four possibilities. I have not spent any time developing in any of these, so I’m just passing along their reputation. I’ve refrained from languages designed to be infuriating, such as Befunge or INTERCAL.

JavaScript

Brendan Eich whipped up a prototype in 10 days, which is pretty impressive. And then, the prototype escaped the lab before it could be refined. And hence:

PHP

I don’t think I’ve ever read a favorable review of the language. This blog post, however, makes an amusing read: PHP: a fractal of bad design

MUMPS

The Massachusetts General Hospital Utility Multi-Programming System. This language has a number of questionable features, although given it was initially developed in 1967, its creators can be forgiven a little. I think.

Take this one random example: Oddly significant trailing whitespace. Quoting Wikipedia:

In contrast to languages in the C or Wirth traditions, some space characters between MUMPS statements are significant. A single space separates a command from its argument, and a space, or newline, separates each argument from the next MUMPS token. Commands which take no arguments (e.g., ELSE) require two following spaces.

Whaaa?

MUMPS made regular appearances on TheDailyWTF. This is a nice introduction to MUMPS’ specialness.

An excerpt of traditional MUMPS coding style, directly from the MUMPS FAQ:

Appendix 7: An example of "traditional" M coding style 
 
%DTC 
%DTC ; SF/XAK - DATE/TIME OPERATIONS ;1/16/92  11:36 AM 
     ;;19.0;VA FileMan;;Jul 14, 1992 
     D    I 'X1!'X2 S X="" Q 
     S X=X1 D H S X1=%H,X=X2,X2=%Y+1 D H S X=X1-%H,%Y=%Y+1&X2 
     K %H,X1,X2 Q 
     ; 
C    S X=X1 Q:'X  D H S %H=%H+X2 D YMD S:$P(X1,".",2) X=X_"."_$P(X1,".",2)  
K X1,X2 Q 
S    S %=%#60/100+(%#3600\60)/100+(%\3600)/100 Q 
     ; 
H    I X<1410000 S %H=0,%Y=-1 Q 
     S %Y=$E(X,1,3),%M=$E(X,4,5),%D=$E(X,6,7) 
     S %T=$E(X_0,9,10)*60+$E(X_"000",11,12)*60+$E(X_"00000",13,14) 
TOH  S  
%H=%M>2&'(%Y#4)+$P("^31^59^90^120^151^181^212^243^273^304^334","^",%M)+%D 
     S %='%M!'%D,%Y=%Y-141,%H=%H+(%Y*365)+(%Y\4)-(%Y>59)+%,%Y=$S(%:- 
1,1:%H+4#7) 
     K %M,%D,% Q 
     ; 

JCL

I’ll be honest: I don’t know a darn thing about JCL. My only introduction to it was from The Jargon File (or maybe it was fortune -o):

IBM had JCL with syntax worse than JOSS, and everywhere the language went, it was a total loss!

Clearly, someone didn’t think highly of the langauge.

If you say “most disliked” then you must, by definition, preclude obscure hated languages. You have to stick to the “big ones” that millions of programmers suffer through.

That would be, without a doubt, COBOL. There are still millions upon millions of lines of COBOL code still running on old IBM JCL-based mainframe hardware (often emulated on modern systems). It was a terrible language, but it was best suited for doing business-like things (text handling, etc) instead of computational things (like FORTRAN).

All of that code must be maintained, sometimes on a massive scale. When the “Y2K” problem arose, old COBOL programmers came out of retirement to command staggering rates. There aren’t so many of those types of guys around these days.

COBOL

Every year StackOverflow does a survey of developers. According to their survey, the five languages cited often enough to make the list at all, which were most often listed as disliked (they use the word “dreaded”, but the question they asked was something about “which language have you used in the last year that you’d rather not use over the next year?”, which sounds to me like a better fit for “disliked” than “dreaded”) were:

Reference

I don’t generally hate programming languages overall - I’ve programmed in C, C++, FORTRAN, FORTH, COBOL, PL/1, Pascal, Basic, Smalltalk, LISP, and others. I have my favorites certainly.

However, there is one language I took a real disliking to: RPG. The main reason is that it required you to position every command in just the right spot or your program was toast. It apparently was designed to replace punched card processing, which explains its deficiencies in part.

I did program in it for a while (for a AS/400 Advanced 36) but didn’t like it. I recall the computer could be used to assist the RPG programmer, but that didn’t change the fact that everything was literally in code and position dependent.

RPG is still around today, although it’s also got a free-form version with actual words - which, honestly, seems really strange. I would have thought a translator would have been a better idea, which could translate another language to RPG (the way C++ was originally translated to C).

JavaScript

It’s one of the most used programming languages in the world. The problem with it is that most developers use it not because they want to, but because the web forces them to.

Add to this the fact that JavaScript was designed in a hurry in 10 days and that the community has spent the next two decades patching up what was frankly a poorly designed language to begin with, and you can start to understand where all the hatred comes from.

The web is where it happens these days. The most common software development job by far is that of the web developer. If you’re a web developer, you will inevitably be debugging JavaScript front-end code in a browser. Some people have developed a Stockholm syndrome and actually like doing this, but for normal people it’s not a very pleasant experience. Hence the hatred.

Just sticking to serious languages and avoiding stuff like InterCal…

Bgen.

This was an “easy to use” language for supermarket managers to customise their software. All the variable names were something like val_a_23. You know, like a spreadsheet - managers understand spreadsheets, right? No way to change the name to something reasonable like “total”. No way to reserve a range of values for a given bit of data, you just had to hope nothing else trampled over your data. Despite the name, there was no way to index an array. If you wanted to set 100 variables to 0, then you had to write 100 lines like

Val_h_1=0

Val_h_2=0

Val_h_3=0

…

Val_h_100=0

After you'd written your program, it compiled into C, and then you compiled that. And the bgen compiler was buggy, so you had to guess whether a bug was due to you using the wrong val_x_y value somewhere, or the compiler had just created the wrong C code.

Rumour has it, that it was written by one guy going through a very messy divorce. It's been over 20 years and I've never forgotten the joy of using it.

It was even worse than the language I had to use which was written by someone who knew XML, but not bison/yacc/etc which ended up looking like this:

<Var name=”X">

<Operator type=”plus”>

<Constant value=”1″/>

<Constant value=”2″/>

</Operator>

</Var>

That at least got laughed out the building. Bgen was actually used in real live production environments.

There is a fantastic, fascinating source for all these kind of stats: The Stakcoverflow Developer Survey: Stack Overflow Developer Survey 2018

And here is the top 10 list for 2018. It does not give reasons but if you are a developer it is very easy to figure out why these languages make the list.

Generally, Javascript tends to be pretty hated by a good proportion of software developers on any given team I land on.

I put this down to a number of reasons:

1. the name still confuses people, sorry but it isn’t nor will it ever be java for scripting :) and no. knowing Java does not give you a headstart when learning Javascript any more than knowing Go would.
2. Generally, it is the people that don’t know much about the language that hates it because they find themselves having to dabble and it can be quite painful if you are not persistent in learning.
3. Javascript is single-threaded but this isn’t necessarily a problem because you can write asynchronous code that helps to alleviate this limitation, developers who haven’t worked with asynchronous code tend to struggle to begin with and see it as a flaw in the language, normally the language they first see this in is Javascript so it is attributed as a nuance of the language rather than a ‘way’ of programming.
4. Testing and TDD, some people find testing front-end code or asynchronous code to be difficult and confusing, especially when you start out, therefore this ends up causing people to hate this aspect of Javascript despite it being pretty simple once you know how (who knew :) ). Others who love TDD also often find it difficult to use this approach to development and get frustrated with the language.
5. Lack of types can and generally are really frustrating (Typescript tends to alleviate this) but for someone coming from a typed language, this can cause a lot of confusion.
6. the keyword ‘this’ is generally not what people think it is, the context of ‘this’ is not always what people think it is and normally it is only by sheer dumb luck it ends up working out until it doesn’t……this causes a lot of frustration as people are forced to reevaluate their understanding that they thought was rock solid.
7. the language is not strictly ‘OOP’, anyone who tries to implement OOP into Javascript is going to find a few nuances, this is not to say you can’t do it but I often wonder whether people should, I personally find the FP paradigm to be better for Javascript, that aside the prototype-based nature of Javascript tends to trip people up at some point.

In truth very few reasons to hate a language are actually justified, you wouldn’t blame a hammer if a carpenter was using that instead of a saw, you would blame the carpenter for not understanding what tool is used when.

Likewise, you wouldn’t blame the hammer if the carpenter was using the base of the handle to try to drive a nail through something, you would blame the carpenter for not knowing how to use the tool.