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