No matter how much you love a programming language, there are always a few details in it that aren’t quite as nice as they could be.
In this question, I would like to specifically focus on syntax elements. In a programming language that you use frequently (perhaps your favourite programming language, or perhaps the one you are forced to use at work), which syntax element do you find most unreadable, unclear, inconvenient or unpleasant?
I haven't really been bitten by it often, but it's just such a phenomenally bad idea it makes my head spin.
Here's the rules (from ECMA-262 Section 7.9)
Example:
return 1; // returns 1
return
1; // returns undefined
/**
* Name of user
*/
private String name;
/**
* Gets name of user
* @return Name of user
*/
public String getName() {
return this.name;
}
/**
* Sets name of user.
* @param name
*/
public void setName(final String name) {
this.name = name;
}
GAH!!!
Issues I have with this
getX, getY, getZ, getAnotherAnnoyingField, getWhyIHateJavaBeans, getThisIsVerbose, getGAH... ah there it is, hashCode.Python annoys me in this respect. I mean, I indent properly anyway, but it bugs me that I should have to. Making presentation part of the syntax irks me.
switch statement (in C, C++, C#, Java, etc.)Here is an example of why I find it highly inconvenient:
switch (someVariable)
{
case 1:
int i = something();
doSomething(i);
break;
case 2:
int i = somethingElse();
doSomethingElse(i);
break;
}
This doesn’t compile because the variable i is redeclared in the same scope. This seems like a minor detail, but it bites me really often. I can add curly brackets to mitigate it, but it would have been nice if the curly brackets had been mandatory part of the syntax, and there was no redundant extra level of indentation. I also really hate having to write the extra break. This would be much nicer:
switch (someVariable)
case 1
{
int i = something();
doSomething(i);
}
case 2
{
int i = somethingElse();
doSomethingElse(i);
}
default
{
...
}
This makes it look more like an if/else chain, which is a good thing because it is semantically similar too. At least in C# it would still not be the same thing however, because in a switch statement the order of the case labels doesn’t matter, but in an if/else it does.
I always manage to forget that when initializing fixed arrays in VB.NET, you're specifying the upper bound of the array and not the number of elements like in C/C++, PHP, or Java. Besides VB6 (we won't go there...), I can't think of another language that does it this way:
Dim myArray(20) as Integer '# Creates an array with 21 elements,
'# indexed from 0 to 20
Most languages let you declare a variable and assign it in one line of code; VB6, on the other hand, forces you to use two.
Dim i as Integer
i = 0
Dim derpderp as Collection
Set derpderp = new Collection
You can use a colon to put two commands on one line, but it quickly turns messy in actual code.
Dim i as Integer: i = 0
Dim derpderp as Collection: Set derpderp = new Collection
// doesn't comment out lines of code like it does in many other languages, like PHP and Javascript. Although /* this is commented out */ works, I prefer to use //.
Its a nuisance, because half the time I forget I am editing CSS and then have to go back and fix the error.
PHP has a number of handy functions for doing pretty much every operation you could think of on an array or string. Many of these operations require using both a $needle and a $haystack, but different functions take them in different orders. Which function requires which arguments is one of those facts my brain refuses to absorb, no matter how often I come across them!
Take the functions in_array and strstr:
// Check whether $needle occurs in array $haystack
bool in_array (mixed $needle, array $haystack [, bool $strict])
// Check whether $needle is a substring of $haystack
string strstr (string $haystack, mixed $needle [, bool $before_needle=false])
Funnily enough, PHP seems to be internally consistent with these orderings in that all string functions seem to use $haystack, $needle while array functions are the other way around, but this can take a bit of getting used to for someone new to PHP. There's a good post on ExpressionEngine talking about this particular quirk in more detail, as well as a discussion on the PHP bugs list, which features a very short response from the PHP team!
helly@php.net
Use a decent IDE then.
self parameter in instance method definitions
Period. Full stop. End of story.
Where to start? Oh, I know where to start: Java’s insanely complicated and ugly and stupid and inherently broken generics. Need I say more? :( Ok fine, then: type erasure.
Then there’s non-deterministic resource management. Kewl feetcher!
What’s next up? Oh yeah: Java’s stupid regexes are my most irritating, seething beef. I cannot count how many times I’ve been hosed by not having enough backslashes. This is even worse than not having access to any Unicode properties from this millennium — which is complete bull. Ten fricking years out of date!!! Completely useless. Trash it.
Then there’s the bug that the character class shortcuts don’t work on non-ASCII. What a royal pain! And don’t even consider using \p{javaWhiteSpace}; it doesn’t do the right thing with several very common Unicode whitespace code points.
Did you know there’s a \p{javaJavaIdentifierStart} property? Whatwhatatat wereere they thinkinking? So glad they got such smart peepers wurkin on dis tough.
Ever tried to use the CANON_EQ flag? Do you know that really does, and what it doesn’t do? How about so-called “Unicode case”? A bunch of normal casing things just don’t work at all.
Then they make it hard to write maintainable regexes. Java still hasn’t figured out how to write multiline strings, so you end up writing insane things like this:
"(?= ^ [A-Z] [A-Za-z0-9\\-] + $) \n"
+ "(?! ^ .* \n"
+ " (?: ^ \\d+ $ \n"
+ " | ^ [A-Z] - [A-Z] $ \n"
+ " | Invitrogen \n"
+ " | Clontech \n"
+ " | L-L-X-X \n"
+ " | Sarstedt \n"
+ " | Roche \n"
+ " | Beckman \n"
+ " | Bayer \n"
+ " ) # end alternatives \n"
+ ") # end negated lookahead \n"
What are all those newlines? Oh, just Java stupidity. They used Perl comments, not Java comments (idiots!) which go till end of line. So if you don’t put those \n’s there, you chop off the rest of your pattern. Duh and double duh!
Don’t use regexes in Java: you’ll just end up wanting to smash things, it’s all so painful and broken. I can’t believe people put up with this. Some don’t.
Then we can start talking about Java’s idiot nonsense with encodings. First, there’s the fact that the default platform encoding is always some lame 8-bit encoding even though Java’s charchars are Unicode. Then there’s how they don’t raise an exception on an encoding error. You’re guaranteed to get crap. Or how about this:
OutputStreamWriter(OutputStream out)
Creates an OutputStreamWriter that uses the default character encoding.
OutputStreamWriter(OutputStream out, Charset cs)
Creates an OutputStreamWriter that uses the given charset.
OutputStreamWriter(OutputStream out, CharsetEncoder enc)
Creates an OutputStreamWriter that uses the given charset encoder.
OutputStreamWriter(OutputStream out, String charsetName)
Creates an OutputStreamWriter that uses the named charset.
What’s the difference? Did you know that only one of those will raise an exception if you have an encoding error? The rest just muzzle them.
Then there’s the idiocy of Java chars not being sufficient to hold a character! What the hell are they thinking? That’s why I call them charchars. You have to write code like this if you expect it work right:
private static void say_physical(String s) {
System.out.print("U+");
for (int i = 0; i < s.length(); i++) {
System.out.printf("%X", s.codePointAt(i));
if (s.codePointAt(i) > Character.MAX_VALUE) { i++; } // UG!
if (i+1 < s.length()) { System.out.printf("."); }
}
}
And who ever thinks to do that? Next to nobody.
How many characters are there in "\uD83D\uDCA9"? One or two? Depends on how you count them. The regex engine of course deals with logical characters, so a pattern ^.$ will succeed and a pattern ^..$ will fail. This insanity is demonstrated here:
String { U+61, "\u0061", "a" } =~ /^.$/ => matched.
String { U+61, "\u0061", "a" } =~ /^..$/ => failed.
String { U+61.61, "\u0061\u0061", "aa" } =~ /^.$/ => failed.
String { U+61.61, "\u0061\u0061", "aa" } =~ /^..$/ => matched.
String { U+DF, "\u00DF", "ß" } =~ /^.$/ => matched.
String { U+DF, "\u00DF", "ß" } =~ /^..$/ => failed.
String { U+DF.DF, "\u00DF\u00DF", "ßß" } =~ /^.$/ => failed.
String { U+DF.DF, "\u00DF\u00DF", "ßß" } =~ /^..$/ => matched.
String { U+3C3, "\u03C3", "σ" } =~ /^.$/ => matched.
String { U+3C3, "\u03C3", "σ" } =~ /^..$/ => failed.
String { U+3C3.3C3, "\u03C3\u03C3", "σσ" } =~ /^.$/ => failed.
String { U+3C3.3C3, "\u03C3\u03C3", "σσ" } =~ /^..$/ => matched.
String { U+1F4A9, "\uD83D\uDCA9", "" } =~ /^.$/ => matched.
String { U+1F4A9, "\uD83D\uDCA9", "" } =~ /^..$/ => failed.
String { U+1F4A9.1F4A9, "\uD83D\uDCA9\uD83D\uDCA9", "" } =~ /^.$/ => failed.
String { U+1F4A9.1F4A9, "\uD83D\uDCA9\uD83D\uDCA9", "" } =~ /^..$/ => matched.
That idiocy is all because you can’t write the perfectly reasonable \u1F4A9, nor of course do you get any warning that you can’t do that. It just does the wrong thing.
Stoooopid.
While we’re at it, the whole \uXXXX notation is congenitally brain dead. The Java preprocessor (yes, you heard me) gets at it before Java does, so you are forbidden from writing perfectly reasonable things like "\u0022", because by the time Java sees that, its preprocessor has turned it into """, so you lose. Oh wait, not if it’s in a regex! So you can use "\\u0022" just fine.
Riiiiiiiight!
Did you know there’s no way in Java to do an isatty(0) call? You aren’t even allowed to think such thoughts. It wouldn’t be good for you.
And then there’s the whole classpath abomination.
Or the fact that there’s no way to specify the encoding of your Java source file in that same source file so you don’t lose it? Once again I demand to know: WHAT THE HELL WERE THEY THINKING‽‽‽
Stop the madness! I can’t believe people put up with this garbage. It’s a complete joke. I’d rather be a Walmart greeter than suffer the slings and arrows of outrageous Java insanity. It’s all broken, and they not only can’t fix it, they won’t fix it.
This by the same foxy-grapey people who prided themselves on a language that made it illegal to have a printf() function. Gee, that sure worked out real well, didn’t it though!?
Sheer numbskulls. Bitch-slapping is too kind for them. If I wanted to program in assembler, I would. This is not a salvageable language. The emperor has no clothes.
We hates it. We hates it forever. Let it die die die!
Function pointer declaration syntax in C and C++:
(int)(*f)(int, int);
That declares a function pointer named f whose pointee can take two ints and return an int.
I'd much prefer a syntax like this:
f: (int, int) => int
Say you want to declare a function pointer g whose pointee can take two ints and a function from int and int to int, and return an int.
With C or C++ notation, you'd declare it as:
(int)(*g)(int, int, int(int, int));
With the above-proposed notation same thing can be declared as:
g: (int, int, (int, int) => int) => int
Latter is much more intuitive IMO.
Aside: The programming language called OOC fixes this syntax (and various other syntactical issues in C and C++). Check out its homepage here.
Verbosity in Java.
ie:
public static final int
The syntax is not only ugly, it leads to confusion when newer developers have to think about namespaces in strings. (PHP interpolates backslashes in double-quoted strings as escape sequences. Trying to represent a namespace like \you\should\never\do\that in a double-quoted string instead of a single-quoted string will lead to newlines, tabs and disaster.)
I despise the fact that curly braces can be optional after an if/while/for statement.
Especially when I see code like,
if (...)
for(...)
... One line of stuff ...
Please just put the braces in and be done with it.
Unlike nearly every sensible language, VBScript uses bitwise operators instead of logical operators. What does this mean in practice? Well, as Eric Lippert points out:
If Blah = True Then Print "True!" Else Print "False!"
and
If Blah Then Print "True!" Else Print "False!"
are NOT the same in VBScript!
Even worse, though, this means that there is no short-circuit evaluation in VBScript so that the following statement will crash your program if Blah is Nothing
If (Not Blah Is Nothing) And (Blah.Frob = 123) Then
...
That's right, VBScript will evaluate both parts of the AND comparison, even if the first one is false! Just let that sink in...
EDIT: Following the discussion in the comments I decided to update this answer to explain myself better.
I really hate the way function pointers look in C. Usually any variable declaration looks like a tuple of: type varname;
Function pointer declarations on the other hand look like a declaration of the function with * before the function name. I can accept this as a description of a pointer type, but in C this declares both the type and the name of a variable of that type. This looks inconsistent to me because type declarations are otherwise distinct from variable declarations. struct myStruct{int X; int Y;} only defines a type, it does not define a variable named myStruct. Likewise I see no reason for type declarations and variable declarations to be grouped into one atomic statement in function pointers, nor do I appreciate the deviation from the type varname; structure.
Someone pointed out that it's consistent with some spiral rule, and that may be the case, but the mark of a good syntax is that it is self explanatory and its internal logic is obvious. The spiral rule is not obvious by any means.
Typically, a variable declaration is of the format type variable_name. You can easily read those declarations in a left-to-right manner. But int foo[size] looks at first like it's declaring foo as an int, and then you read further and see that foo's of type "array of integers." int[size] foo reads much better.
And I also hate it when programmers declare pointers like this for a similar reason: int *foo. For some reason I haven't figured out, that's the typical way it's written.
In/out arguments. I'm all for in arguments (good thing I am), out arguments are fine too, but an argument that must convey these two states pisses me off.
What I target here are functions that take input from a parameter then overwrite that input with some output. It's okay to pass an object by reference to update it. But, mostly for primitive types, taking an object, use it, then change it completely, is not right by me. You shouldn't change the meaning of the argument through an inout.
I spend all day working in languages that expect semicolons at the end of each line. Add one to the end of the line in VBScript and your code doesn't run anymore.
Since people have already complained about = vs. ==, let me point out a much worse alternative. PL/I had both := and =, but when something was "obviously" an assignment, it would let you get away with using = to do it. Using := let you force something to be an assignment in a situation where the compiler would otherwise interpret it as a comparison.
Unfortunately, the compiler didn't always decided on things quite the way you might expect. Consider just one obvious example:
A = B = 0;
Now, to most people familiar with most "ordinary" languages, the meaning of this is pretty obvious -- assign 0 to both A and B. PL/I is just a bit...different though. For reasons known only to the (insane) designers of the language, the first = is interpreted as an assignment, but the second = is interpreted as a comparison. Therefore, this compares B to 0, and then assigns the result of that comparison to A (following the C-style convention that "false" results in 0 and "true" in 1).
So, if B was 0, then A becomes 1. Otherwise, A becomes 0. In other words, rather than assigning the same value to A and B, this actually ensures that A cannot have the same value as B.
Bottom line: even though the C/C++/PHP style initially seems like a pain, the alternative is much worse1.
1Well, technically, there's another alternative: Pascal style, where = always means comparison and assignment always requires :=. After using that for a while, it's pretty obvious (at least to me) that assignment is enough more common than comparison that if you're going to require extra "stuff" to disambiguate the two, you should definitely keep assignments clean and simple and require the extra "grunge" on comparisons, not vice versa.
Redundant parameterization in Java:
HashMap<String,HashMap<String,String>> foo = new HashMap<String, HashMap<String, String>>();
What other type parameterization does the compiler think foo could have?
The for ... in construct in JavaScript and the foreach construct in PHP when looping over arrays. Both of them make it easier to write bugs than correct code.
if($x < 10) do_something();. At the moment, you have to write that as either do_something() if($x < 10); or as if($x < 10) { do_something(); }.
reinterpret_cast<unsigned long> in c++. This operation is useful in dealing with foreign APIs and ensuring numerical precision, why should it be such a pain to type and so ugly to look at?
Pointers of arrays or arrays of pointers in C/C++. I am still confused about these.
Javascript/Java etc, equals comparison, eg if(a==1)
How many times do I write if(a=1) ?
As a human I read that perfectly. But the darn interpreter/compiler says, "hey I'll assign 1 to a, then check if a is equal to 1, and would you believe it yes it is!
Drives me up the wall.
if(a==1) is far less readable, and the interpreter/compiler should know what I mean anyway; many other lesser languages (VB) have been working it out successfully for hundreds of years.
Scala multi-line code in brackets
For instance:
class Foo(
val bar: String,
val baz: Int,
val bing: String,
val bong: Boolean
) extends Model {
// body here
}
What you actually get from it is terrific. It generates the constructor and the getters and setters for you. But it sure is ugly and breaks all my mental models of how to indent code and basically leaves me feeling like I'm in a sort of bizarre sandwich with Java on one side and Lisp on the other. (Oh, wait... that is rather the point of Scala.)
preg_match() in PHPFirstly, its completely different syntax than PHP uses. While the preg_match() function emulates regex quite excellently, I have to completely switch my mode of thinking to work with it.
Secondly, its just plain obscurification half the time. I usually have to quite literally take out a scratch pad and figure out WTF its doing half the time.
Besides, I program in PHP, not Perl. If I liked Perl, I would program in Perl. (no, sir I don't like it.)
To make matters worse, with the new PCRE delimiter format, you can practically use any character, which includes having to escape that same nested character, making the pattern even more obscure.
Sure, its great if you want to be cryptic.. or even efficient... but holy hell the amount of time it wastes to normally perform simple tasks.
structPointer->member in C/C++ . May be good for reading someone else's code, but I don't like it. Two characters instead of one... what a waste of space!
$this->... in PHP ... unnecessary, looks bad and considerably slows down "quick-grasp-on-short-glance" (my closed thread on SOF).
SSIS - SQl Server I hate everything about the Expression Builder. I already know how to write these types of conditions in t-sql. Why can't they Expression builder use the same syntax t-SQl would use (especially The equivalent to the CASE statement)? Or let me write t-sql statements instead of creating stupid wierd expressions. And why am I stuck doing complex conditions in a form that only allows me to use one line so I am in scroll bar hell?
& && | || in C
C++ has rectified it to some extend with explicit "and" "or" keywords. Many a bugs and torn hair could have been avoided in C if logical operations and bitwise operations weren't so hard to differentiate.
Ternary statements. They are generally much harder to read yet only save a few lines of code.
if (myCondition) {
return firstAlternative();
}
return secondAlternative();
versus
return myCondition ? firstAlternative() : secondAlternative();
