views:

36964

answers:

185

There's been a cluster of Perl-hate on Stack Overflow lately, so I thought I'd bring my "Five things you hate about your favorite language" question to Stack Overflow. Take your favorite language and tell me five things you hate about it. Those might be things that just annoy you, admitted design flaws, recognized performance problems, or any other category. You just have to hate it, and it has to be your favorite language.

Don't compare it to another language, and don't talk about languages that you already hate. Don't talk about the things you like in your favorite language. I just want to hear the things that you hate but tolerate so you can use all of the other stuff, and I want to hear it about the language you wished other people would use.

I ask this whenever someone tries to push their favorite language on me, and sometimes as an interview question. If someone can't find five things to hate about his favorite tool, he doesn't know it well enough to either advocate it or pull in the big dollars using it. He hasn't used it in enough different situations to fully explore it. He's advocating it as a culture or religion, which means that if I don't choose his favorite technology, I'm wrong.

I don't care that much which language you use. Don't want to use a particular language? Then don't. You go through due diligence to make an informed choice and still don't use it? Fine. Sometimes the right answer is "You have a strong programming team with good practices and a lot of experience in Bar. Changing to Foo would be stupid."


This is a good question for code reviews too. People who really know a codebase will have all sorts of suggestions for it, and those who don't know it so well have non-specific complaints. I ask things like "If you could start over on this project, what would you do differently?" In this fantasy land, users and programmers get to complain about anything and everything they don't like. "I want a better interface", "I want to separate the model from the view", "I'd use this module instead of this other one", "I'd rename this set of methods", or whatever they really don't like about the current situation. That's how I get a handle on how much a particular developer knows about the codebase. It's also a clue about how much of the programmer's ego is tied up in what he's telling me.

Hate isn't the only dimension of figuring out how much people know, but I've found it to be a pretty good one. The things that they hate also give me a clue how well they are thinking about the subject.

+117  A: 

C# / .NET:

  • Classes should be sealed by default
  • There should be no lock statement - instead, you should have specific locking objects, and there should be methods such as Acquire which return disposable lock tokens. Corollary: there shouldn't be a monitor for every object.
  • GetHashCode() and Equals() shouldn't be in System.Object - not everything's suitable for hashing. Instead, have an IdentityComparer which does the same thing, and keep the IComparer<T>, IComparable<T>, IEqualityComparer<T> and IEquatable<T> interfaces for custom comparisons.
  • Poor support for immutability
  • Poor way of discovering extension methods - it should be a much more conscious decision than just the fact that I'm using a namespace.

Those were off the top of my head - ask me tomorrow and I'll come up with a different 5 :)

Jon Skeet
Sealed by default? Why?
Erik Forbes
Java has hashCode() and equals() methods as methods on Object, and I find this to be a very reasonable design. As it makes semantic sense for every object to be able to compare itself against other objects and generate its own hash code I am not understanding why you are opposed to this.
Ryan Delucchi
I really don't agree with classes being sealed by default. But hey, it's your list I suppose.
JSmyth
@Eric: for most classes, deriving doesn't make sense and most classes actually support it poorly. By default, every virtual class should be abstract and every other class sealed, meaning that you could only have leaf classes as dynamic types, never node classes in the inheritance hierarchy.
Konrad Rudolph
Sealed by default: inheritance should either be designed into a class (which takes time and limits future options) or prohibited.hashCode/equals: it sucks in Java too. One day I'll write a long blog post about it. Read Effective Java for details of why equals is hard in inheritance chains.
Jon Skeet
Sealing by default means that you have thought of every possible reason that someone may want to inherit from your class and you don't think any of them make sense. Sorry, but none of us are that smart.
Ed Swangren
In that case I'm not smart enough for you to derive from my code: because I can't predict what future changes I might make which could break your code. That's a very significant problem, IMO. Sealing the code is more restrictive, but leads to more implementation freedom and robustness.
Jon Skeet
I agree with all except #3: how can an IEquatable help with the fact that equals() is broken under an inheritance chain?
Buu Nguyen
@Buu: You'd usually only use IEquatable when only one sense of equality was sensible, which would usually exclude unsealed types. For other situations you'd use an IEqualityComparer, which is effectively context-sensitive: "I'll compare for equality in <this> way because that's what I care about."
Jon Skeet
Good point. Thanks for clarifying, Jon.
Buu Nguyen
Hi Jon can you elaborate more on why inheritance should be prohibited? If inheritance is designed into a class wouldn't that mean that the class would be very massive and represent multiple entities? I can see there will be many switch statements inside the class.
RWendi
RWendi: Designing for inheritance doesn't mean that it has to be massive or already know what the subclasses will do, exactly. It just has to know which bevahiours may be specialised, and deal with them appropriately. (Continued in next comment)
Jon Skeet
I have a blog post on the "inheritance tax": http://msmvps.com/blogs/jon_skeet/archive/2006/03/04/inheritancetax.aspxIt's fairly old now - I may have to rewrite it some time. Josh Bloch (unsurprisingly) does a better job in Effective Java. See item 17 in the second edition.
Jon Skeet
I can't believe no-one mentioned the "goto case" syntax, I hate that one!
Aistina
Glad you aren't Anders! This business of "sealed by default" is just a bridge too far for me. It sounds like propaganda from some incomprehensible Java Community Process community with some kind nonsense JSR assigned to it.
BobbyShaftoe
I'd 'kill' anyone that will make all classes sealed by default in .Net, even if it tries to hide on the other side of the moon. Actually I have a better "Idea", ban the sealed keyword ....
Pop Catalin
@Pop: I think we'll have to agree to disagree then. I *strongly* urge you to read Josh Bloch's "Effective Java" on the topic though.
Jon Skeet
@Bobby: I don't see what this has to do with the JCP at all. Is that just because I mentioned Effective Java? Let me know when you have wisdom to match that of Josh Bloch...
Jon Skeet
@Pop: I think a death threat is a pretty extreme reaction to a suggestion that is as reasonable as wearing a seatbelt.
MusiGenesis
@MusiGenesis: it's a metaphor to show my extreme position regarding this, and that I'm strongly against it. I know it's bad to be at extremes, but in this case I'm combating an extreme solution with a extreme attitude :P
Pop Catalin
@MusiGenesis: guess not everyone knows about that classic vb 6 joke: "code like the next person maintaining the code is a psycho maniac killer that knows where you live", or that everyone digs this kind of jokes...
Pop Catalin
@Musigenesis: I think we must have a different idea of "extreme". I'm saying that I believe that the *default* should have been sealed. I'm not trying to ban inheritance - you could still explicitly unseal a class. By being explicit, you'd be showing that you've thought about the consequences.
Jon Skeet
I'm going to go ahead and agree with Jon Skeet on the subject of keeping classes sealed by default. If you want something to be inheritable, make it so. Don't assume that every class should be inheritable, though.
Alex Fort
@Jon: by "extreme" I was referring to Pop's saying that he would 'kill' anyone who sealed classes by default (I know he didn't really mean that). I agree 100% with sealing classes by default - it makes sense like wearing a seatbelt makes sense. :)
MusiGenesis
@Musigenesis: Sorry, my comment should have been to Pop, who was claiming that my idea was an "extreme solution".
Jon Skeet
no friend class support.
Kon
+10 for "there shouldn't be a monitor (or even an index into the lazily-created monitor table, which I believe is the present situation) for every object"
Doug McClean
Good list. I agree with every point, and in particular the "sealed by default" and no implicit support for comparison/hash-code. There should be as few built-in things in the base object as possible, and everything else should be explicitly specified that a class supports it.
Lasse V. Karlsen
+1 for sealing classes by default. I strongly believe (and Jon stated it above already) that designing a class that PROPERLY supports inheritance is an order of magnitude harder than designing a sealed, immutable class. Thus "allow inheritance" should be a conscious decision.
Milan Gardian
+1 for sealing by default. Planned Inheritance: The contract of a class must describe what derived classes must, may and can't do.
peterchen
+1 for poor immutability support. I always prefer immutable data structures.
Anton Tykhyy
You really don't hate array covariance!?
Mehrdad Afshari
@Mehrdad: I don't like it, but it was *somewhat* useful pre-generics. It's not a big "hate" for me.
Jon Skeet
The biggest problem I have with classes being sealed is the difficulty in mocking them for Fitnesse or Unit tests. The biggest example that comes to mind is HttpContext - it can't be extended, and only implements IServiceProvidor. If I want to mock a call to a function that takes an HttpContext, it would be nice to pass in a MockHttpContext that extends/overrides HttpContext. Instead, you have to create an instance of HttpContext and populate it, and there's no way to spy what functions were called. Even Rhino Mock can't deal with a sealed class.
Matt Poush
@Matt: To me, that says that HttpContext should implement a suitable interface, not that it should be unsealed. Overriding arbitrary methods of classes without understanding whether internally one of those methods would normally call another is just replacing one problem with a different one, IMO.
Jon Skeet
I think I could live with sealing by default as long as there was a keyword to allow you to override the sealing: Please allow us to run with scissors if we want to! I think a better solution (which could actually be implemented in a future version of C#/.NET) would be a DesignedForInheritanceAttribute and a warning from the compiler when a class derives from it anyway.
Rasmus Faber
You'd be able to override the sealing at the *base* class level obviously, but not at the *derived* level. If I design a class not to be derived from, I don't want that to be violated.
Jon Skeet
Here's my 2c on default sealing of classes. This should be done. Even in the framework itself, this causes troubles. For instance, once upon a time, I wanted to extend some of `List<T>` 's default behavoiur (specifically, I wanted to add events for Add, Remove, etc). So away I go and derive from `List<T>` which worked, but then I couldn't actually do anything from there...
Matthew Scharley
Wow, It's been a long time since I looked at this topic :). I do understand your point about 'sealed by default'. Inheritance is often overused and used incorrectly. However, in practice I doubt that sealed by default would make our lives any better. In my own code I wouldn't care because I can change it as I see fit (I don't develop public libraries). Unfortunately, elegantly designed third party API's are the exception, not the rule. So, what does this mean? It would probably mean that almost every darn class in the API I am using is sealed. I would rather be able to inherit from
Ed Swangren
these deficient classes if needed than to be blocked out entirely. Since this theoretical API was designed poorly to begin with, I highly doubt that they have provided sufficient flexibility in their interface for me to accomplish what I need, so now I am screwed. In theory I think that you may be right, in practice, at best, I doubt that it would help.
Ed Swangren
What about Mutex class? I think it solves 2nd issue.
terR0Q
@terR0Q: Yes, but at the cost of being a full Win32 kernel object instead of a lightweight .NET lock.
Jon Skeet
(It also doesn't free "lock" from being a keyword, which is one of the annoyances of the current situation.)
Jon Skeet
@Jon SkeetYep, Mutex is heavy.But managing lock tokens involves more information and actions that can be mishandled while lock introduces only one more variable handling per lock (and that's definitely easier). And we always can implement tokens support system if we really need them in a project :)Concerning syntax, well, there are pros and cons of equal weight: keyword (bad as it is, yet better readability), brackets (more indentation, yet we have better view of what is being locked), some strange variable doing some strange business inside :)
terR0Q
No array properties. No constants inside a method.
Loren Pechtel
I believe in C# everything should be virtual by default..
Tigraine
It's a good thing Jon Skeet didn't design C#, or my list would look like "1. classes are sealed by default; 2. locking is too complicated; 3. most objects aren't hashable"!
Gabe
@Gabe: Locking would still be easy to do *right* - it's only *bad* locking (e.g. locking on "this" or typeof(...)) which would be broken. And you could still use any type in a hash table - just use the ReferenceEqualityComparer which would obviously be required.
Jon Skeet
@John Skeet, Now is tomorrow++. What 5 do you have today?
Thorbjørn Ravn Andersen
@Thorbjørn: They're still the same, as it happens :)
Jon Skeet
+6  A: 

My language du jour is Java. Here is what I hate about it:

5.) Lack of pointers
4.) Exception catching
3.) The Boolean type
2.) BigDecimal type
1.) C# fanboys and Java fanboys

Boolean can be null. I find this counterintuitive.

BigDecimal is a library and not a language feature. My annoyance with BigDecimal and Exception catching stems mainly from writing test classes that have to jump through a bunch of hoops to get actual work done. I should clarify I'm annoyed by these things, I'm not about to lobby for changes.

zmf
5 is not enough for java!
Ali A
Item 1, is really not about java. :)
grieve
I could use some clarification on issues 2 - 4.
Bill the Lizard
What exactly is the problem with Boolean? Also, item (2) is a library rather than a language issue
Don
Lack of pointers? I thought every object was a pointer in Java...
Martin Cote
You left the 'why' part out of your list. =\
Erik Forbes
References are sufficient. For the rare occasion that you need change the referenced object: you could always create a Pointer class that does this. And I am not following why you hate Exception, Boolean and BigDecimal.
Ryan Delucchi
So why is there a NullPointerException if there are no pointers?
Mark
@Mark, it's just a bad name, NullReferenceException would be more appropriate
Don
So, in Java, what exactly is the difference between a Pointer and a Reference? Why would you want a Pointer?
Mark
You don't get to have fanbois as one of your items. Every language has those. :)
brian d foy
Alternatuive to Boolean is to use boolean, can't be null (but not an object). Pointers would be nice in regards to primitive arrays IMHO
basszero
If you go into an interview claiming Java has no pointers, you are going to be in a world of hurt. Java is nothing but pointers.If you don't think so, describe how to call a method without passing a reference back to the objects you are calling with...
Kendall Helmstetter Gelner
@brian: I'm fairly certain Visual Basic has no fanboyz. If there ever were any, they're dead now.
MusiGenesis
Pre-.NET Visual Basic, I mean. VB.NET has plenty.
MusiGenesis
@Kendall. JVMs of course use pointers under the hood to implement references, but the Java language doesn't "have pointers". A fundamental property of pointers is the ability to do arithmetic on them. Java has re-seatable references.
Steve Jessop
@onebyone.livejournal.com: Pointer arithmetic is *not* fundamental to pointers - unless the only pointers that count are C pointers. There is no pointer arithmetic Pascal/Ada, Modula and PL/1, recent Fortran, and virtually every high-level language with pointers *other* than C and C++.
crosstalk
+37  A: 

C++

  1. Template Syntax
  2. Diamond Inheritance issues
  3. The plethora/lack of standard libraries that modern languages have (though boost comes close).
  4. IOStreams
  5. The syntax used around IOStreams

Python

  1. Spaces are meaningful (sometimes)
  2. underscored keywords
  3. Limited thread support (at least currently)
  4. "self" instead of "this"
  5. Spaces are meaningful (sometimes)
grieve
You can refer to "self" as "this" is you really want to (although it might be hard for others to follow). "Self" isn't a keyword, and you can name the variable anything you want.
mipadi
Could you split these into two separate answers?
wnoise
there you go, I would actually list the meaningfulness of whitespace (especially indentation) in Python as one of its biggest pluses... ;)
Oliver Giesen
@Oliver - I agree, but it gets confusing when you mix spaces and tabs. Tab space space is not the same as any number of just spaces.
Tom Leys
Personally, if I were to make this list, I'd list "Spaces are meaningful" 3 or 4 times.
Paul Wicks
@wnoise: I could, but laziness overwhelms.
grieve
@mipadi: Damn! how did I not know that. Thanks!
grieve
Why the emphasis on "sometimes"?
Joshua Swink
I don't know Python, but the "sometimes" seems of quite an interest!
call me Steve
"spaces are meaningful" is one of the best features of python!! p.s. try to run this in an interpreter "from __future__ import braces"
hasen j
@mipadi why do you need to give a name to "this" in the first place? Why cant python do it like everybody else (say C++/C#/Boo)?
SDX2000
The way python methods are implemented (they are just a funciton with the object as the first parameter) allow all sorts of flexible tricks, for example monkey patching. Is it really that hard to write "self, " once for each method?
gnud
spaces and tabs not being equal frustrated me too until I set my editor to 'replace tabs with spaces'. The whitespace syntax I find very appealing.
Josh Smeaton
I disagree with pretty much your whole python list, except thread support. Whitespace is not meaningful, indentation is meaningful; there's a big difference.
Christian Oudard
@Gorgapor: You are welcome to disagree, I am certainly no great authority on anything. :) I will point out, however, that you achieve indentation by using whitespace.
grieve
@Oliver - mix your space and tabs, and you're going to have a real fun time debugging. It will waste at least a good couple of minutes (if you're experienced in python), and you'll feel like an idiot when you finally found the problem after stressing over it.It happens more than you think, and the lack of real tokens for code blocks makes it impossible to attempt to put the code back in _some_ kind of order.
Calyth
@gnud - yes. yes it is very hard to write self for each method because it shows that Python, historically, didn't think of OOP. The Python interpreter _should_ take care of that. You'd think that with all the other OOP languages getting the self/this pointer right that Python would eventually fix that crap?
Calyth
I really enjoy the Python's aspect of "self." It finally taught me how to think of OOP. It would be so easy to write a C++ program in C now (with regards to classes). The "methods" would take the object (structure) as its first argument. Of course, many things would still be lacking in C, but writing from an OOP perspective would be must simpler now.
Noctis Skytower
Oh god, Python's threading support or lack thereof is ridiculous.I disagree with the __keywords__ though. I believe that a lexical differentiation of this sort is necessary in this case.
orokusaki
just be glad its not like the language whitespace
mikek3332002
@Calyth It doesn't show that Python forgot to think of OOP; it just shows that they are following their philosophy of *explicit is better than implicit*. If you don't know what I mean, run `import this`
crgwbr
So spaces are not meaningful in, say, C? `if(condA)foo();elseif(condC)bar();`
badp
@call: they are only meaningful in indentation: `if x and y:` and `if     a     and     y:` and `if a and\ny:` are perfectly equivalent.
badp
imho: Non of the points mentioned for python are bad (except [a python keyword] #3).I like that Python do things in its own way. :)
Joschua
If self wasn't explicit, then understanding python's scoping rules would be more difficult. Python's scoping rules are very different to other conventional languages.
Arafangion
Wow. It's like no one invented a text editor that highlights/shows whitespace/tabs as special chars (What, are you coding in notepad?).Also, if you expand tabs to spaces, please go die in a fire.
Fake Name
Python threading is crap, though. WTF can't I change thread priority?
Fake Name
@Fake Name: Jython, my friend. Python has no language concurrency constructs, so the best you can do is grab a library for it.
Longpoke
People rejecting Python due to whitespace is the most retarded thing I can imagine. Braces are just redundant in C-like languages, since all good code is indented anyways. You don't even need to indent all the time in python, you can separate statements with semicolons (although, just like in C-like languages, nobody does this, because it's retarded) `print 'hurr'; print 'durr'`. Although I wish I could make anonymous functions/classes, which is natural with braces, but hardly any big deal, plus you can use lambdas a lot of the times for this.
Longpoke
+6  A: 

Python:

  1. Too slow!
  2. list operations don't return the list, so you can't do list.append(4).append(5). (I mean a reference to the same list, not a copy). This is a minor gripe; it's only come up a few times.
  3. statements don't return values (if, print, while, for, etc). This is only a problem when dealing with lambdas.
  4. lambdas can only be one expression. There's no real need for this restriction, as they are equivalent to functions in every other way. What if I want a button press event which calls two functions? I'd need to create a named function to supply that functionality to an action listener, while doing "lambda: f1(); f2()" would not hurt.
  5. you can only put standard a-zA-Z_0-9 as names. Having functions like "true?" and "+" would be great. Of course, this could lead to terrible obfuscation, but I'm not saying we immediately rename all functions to "[email protected]$%3". Which do you find clearer to read: "dec2bin" or "dec->bin"? ("store_results" or "storeResults") or "store-results"?
Claudiu
Your second point is sooo minor. Why don't you list.extend([4,5])?
Martin Cote
@pt 2, Lists are MUTABLE. Why return a copy of itself when adding a new entry?
Nick Stinemates
@Nick: He doesn't want to return a copy, he wants it to return the original list so that he can chain modifications to it. I think.
Jeremy Banks
In Py3k you'll be able to use non-ASCII characters in identifiers, but I _think_ it still tries to stick to ones that are letters, not symbols. It's a pity, I think this would have been a good time for them to add that ability to the language.
Jeremy Banks
My gut reaction to number 5 is shuddering in horror. This summer I had to clean up column names which had slashes, spaces, question marks, parens, colons, etc. Not fun.
pbh101
Yeah, the lambda thing is a big WTF for me, too. Overall, you seem to want Lisp.
Svante
This is heavily influenced by my recent exposure to Scheme, it's true. for 5, it's mostly the fact that function names with dashes as separators ("print-columns") are prettier than either print_columns or printColumns, and also conversions (dec->bin) is cleaer than (decToBin) or (dec2bin).
Claudiu
"Too slow!"... as compared to?
digitala
@Philip: as compared to java, c, c++, haskell (Damn haskell is fast), maybe scheme.
Claudiu
#2: list.extend([4, 5])
Just Some Guy
list + [4] + [5] + [some comprehension]
hasen j
if the langauge allows + in function names, parsing would be hell!! a+b is that a function name or an expression? if you have a function called "a+b" and two varialbes a,b then what should a+b do??
hasen j
tmp = 2048x=3tmp>>xUnder your suggestion of having other characters be available for function names is "tmp>>x" a function or an expression? what about "tmp>x", or "tmp%x"? This would kill the readability of python.
Asa Ayers
Reason why symbols appear in lisp identifiers and not in other languages: Number of lisp reserved symbols: 5 (, ), `, ', and " and the last two are optional.
TokenMacGuy
@hasen and asa: under my suggestion, tmp>x would be a function/identifier called "tmp>x", and you'd have to type "tmp > x" to use the greater-than symbol. Allright, maybe it's not the best idea =).
Claudiu
"Too slow!" ... my Python data processing code runs at 50k-200k rows/sec on a 3 year old laptop. That's good enough for me...
"lambda: (f1(), f2())" is a trick I've used in a few cases.
Joe
I don't get all the complaints about limiting lambdas to only one line. Just use a regular function!
TM
Unladen Swallow for the "Too slow" part.On your ->bin addition... ????? I think you're looking for Pearl or Ruby if you want your code to look like Mesopotamian hieroglyphics.
orokusaki
@TM: Of course. And, while we're at it. Why have lambdas at all when you have functions? If you're going to add a feature to a language, make it useful.
luiscubal
#1: http://psyco.sourceforge.net/ ~~~ #3: For a good reason: lambdas are supposed to be side effect free! http://en.wikipedia.org/wiki/Functional_programming Besides, what should a `if` return? ~~~ #4: Use full fledged functions instead. You can also nest them. ~~~ #5 Not being able to insert operators in variable names sounds like a good idea to me... unless you believe `a = 2; b = 3; c = b-a` should raise a `NameError`? ;)
badp
+107  A: 

C

  • string manipulation.

Having to deal manually with the string buffers is an error-prone pain. Since so much computing is really moving and modifying strings (computers aren't used quite as much for big number-crunching stuff as people thought they'd be way back when), it's really nice to be able to use managed languages or C++'s string objects to deal with these. When I have to do it in straight C, it feels like swimming in quicksand.

Michael Burr
Agreed. String manipulation is item 1 through 5 of things I hate about C.
BoltBait
I guess I wasn't too interested in coming up with 4 others - that one is just a real bear. Also, I suppose straight C isn't really my 'favorite' language, so maybe I should have just passed on this question.
Michael Burr
String manipulation in C is great, all you have to be able to do is count. Compare it with the syntax nightmare of using istringstream in c++
Martin Beckett
Just use DJB's safe string library or something. XML manipulation is difficult in most languages, and a lot of programs do XML manipulation, but you don't see many posts saying "Perl is totally broken because it doesn't support DOM nodes as a primitive data type". They use a library.
Steve Jessop
C string manipulation does suck balls, but as far as language issues go, it's not the worst.
Chris Lutz
Okay, I really really don't get this complaint. C is a low level language, system work. It is not meant for UI stuff, not compared to modern languages. This is a case of trying to put on elephant robes on a donkey. You're asking C to do something it really doesn't want to do.C has enough problems, string manipulation is just using a hammer instead of a philips screw.
Daniel Goldberg
I don't know what else to say - I don't really do much in the way of UI programming so it's not that. But I also don't do a whole lot of number crunching. I still find myself doing a lot of string manipulation, and it's generally more painful to do in C compared to C++ or other languages. I use C an awful lot, and I don't hate it. But I wish dealing with strings was somehow less difficult. I can't tell you how that might look since I haven't thought much about fixing it at the language level. I have library routines that help quite a bit, but they still require more effort than I'd like.
Michael Burr
strcat to concatenate, but wait... does the destination have enough space... ok, must insert if statement to check... but wait, what if my string is on the heap? Ok, must keep a variable around to keep track of size... And this can go on and on and on...
blwy10
Maybe I'm daft and haven't used much of C itself, but couldn't you just make an abstract data type for char* (and relevant properties) in a struct and call it string?
trinithis
@trinithis: you're not daft - that can be done (and there are several libraries that implement that kind of thing), but you often run into a problems integrating existing code and practices or using the datatype with other libraries.
Michael Burr
@blwy10: `strcat`? Try using `getcwd()` or `readlink()` correctly.
Joey Adams
Just use an excellent string implementation like GLibs GString (http://library.gnome.org/devel/glib/stable/glib-Strings.html) and string handling becomes at least as easy than in C++.
ahe
Design principal if esoteric language BIT (http://www.dangermouse.net/esoteric/bit.html): "Extend the ease of string processing in C to other, more basic, data types such as integers." :)
whybird
We need a thread for five things we _don't_ hate about C...
Longpoke
I would like to add "no function overloading"
Dave
String manipulation is the most beautiful part of C. How can you make strings any simpler! Better than having some monster string library that goes and does a zillion copy ops or a locale specific lookup of Klingon plurals when I want to read the first character.\
Martin Beckett
+48  A: 

Here are some things I dislike about Java (which is not my favorite language):

  • Generics type erasure (i.e. no reified generics)
  • Inability to catch multiple exceptions (of different types) in a single catch block
  • Lack of destructors (finalize() is a very poor substitute)
  • No support for closures or treating functions as data (anonymous inner classes are a very verbose substitute)
  • Checked exceptions in general, or more specifically, making unrecoverable exceptions checked (e.g. SQLException)
  • No language-level support for literal collections
  • No type-inference when constructors of generic classes are called, i.e. the type parameter(s) must be repeated on both sides of the '='
Don
Inability to catch multiple exceptions (of different types) in a single catch block -> will most likely be added in Java 7
Jorn
Thank god! Now I will see shit liketry{...}catch(Exception1 e1, Exception2 e2, java.sql.SQLException e3 ... ){...}Hmmm... that's gonna get ugly
Ubersoldat
yeah, and you wont know what exception you are dealing with...
Svish
@Svish - I think is the point is that you would only use this construct when you don't care what type of Exception you're dealing with. In other words, when you want to handle them all identically
Don
I wouldn't call a lack of destructors a flaw when the language has a GC, and a GC that's gotten better and better with each release. Destructors were missed in java 1.1.8 but not in java 6 because gc is so vastly improved.
Mike Reedell
C# fixes all of these except catching multiple exceptions. Generics are reified, destructors are replaced by using/IDisposable, closures are implemented by anon methods and lambdas, exceptions are unchecked, there are collection literals, and there is 'var' to avoid specifying the constructed type twice.
Daniel Earwicker
Java definitely has closures. An anonymous inner class closes over local final variables in its scope. I agree that anonymous inner classes are not a proper substitute for anonymous functions, but they *are* closures.
Adam Jaskiewicz
Re inability to catch multiple exceptions - please name a language that *does* support this. At least it is *planned* for Java. The planned implementation might not be elegant but that is better than making no effort to solve the problem. However if you meant SQLException should have been unchecked then I agree.
finnw
Anon inner classes are NOT closures: try creating a visitor callback with something like "sum += current.amount()" in it, where "sum" is a non-final variable from the enclosing scope. Close, but no cigar.
Roboprog
The lack of destructors: how could I forget. That often sucks mightily.
Roboprog
type erasure is really annoying.
fastcodejava
@finnw: Well since you asked, Python supports catching multiple exceptions (as a tuple of exception classes) in a single `except` clause.
Don O'Donnell
@Roboprog This is due to the fact that everything in java is pass by value. If your created a Ref<T> class that held a T[1] that was access via a get/set pair, you'd be able to pass a local `final Ref<Integer>` into an anon function and do `myRef.set( myRef.get().intValue() + current.amount()`. Now I should go try that to make sure it actually works.
KitsuneYMG
Anonymous inner classes are syntactic vinegar (the opposite of syntactic sugar) for closures.
Gabe
+33  A: 

Python:

  • Lack of static typing
  • Default argument handling (specifically the fact that you can change the default argument for future callers!)
  • Too many required underscores (constructors must be called __init__)
  • Lack of proper private members and functions (convention just says that most things that start with underscore are private, except for all the stuff like __getattr__ that isn't)
  • Funny syntax for printing to a file (but they're fixing that in Python 3)
Greg Hewgill
really? how do you change the default argument? that's great!
Claudiu
If it's a mutable object, because there is only a single instance of it created, when the function is first evaluated, any changes to it will be reflected in all future calls.
Jeremy Banks
Most consider lack of static typing an advantage. Anyway in Python 3 you will be able to use function annotations for type checking.
Adam Byrtek
What I'd like is an *option* to use static types.
Greg Hewgill
BTW: __init__ isn't really the constructor, the object was already created, when you enter there (guess what self is...). The constructor is acutally __new__ where you get access to the class to be instantiated.
André
If you prefer static typing, why is Python your favourite language?
finnw
finnw: Static typing is great for some kinds of programs, and not really needed for other types. I usually don't mind the lack of static typing, but when you need it, it's *really* nice to have at least the option.
Greg Hewgill
The only time I miss static typing is in IDE's since static typing improves auto completion capabilities. Python 3's function annotations will fix this, for any code which annotates its functions with type information (assuming someone will come up with a standard way of doing so).
Dan
Please add: No try-except-finally construct in Python 2.x
pi
@pi: try-except-finally was added in Python 2.5: http://python.org/doc/2.5/ref/try.html
Greg Hewgill
static typing would destroy python, even if it was a built in optional feature...
Longpoke
Actually, things that start with a **single** underscore are considered 'private' by convention. Names prefixed and suffixed by double underscores are reserved by the language.
Romuald Brunet
You can also have double underscore prefixes on methods (without double underscore suffixes) which makes them "really" private, but it's generally kind of a bad idea that will make your code less easily extendable. Better to use the single underscore convention.The default argument thing, as others have pointed out, is only true for mutable objects. In cases where a mutable object is the expected input, it's best to just have `None` defaults or something like that and then check for them in the body. Annoying, but once you're aware of it, not that big a deal.
dwf
@greg hewgill have you looked at ctypes?
Jiaaro
I would say that lack of static typing is a feature, not missing functionality...
arnorhs
python 3 has now a (optional) syntax, that can be used for typechecking: http://stackoverflow.com/questions/1275646/python-3-and-static-typing
Joschua
if you don't like the 'self' keyword. how is it any better than having to add the 'public' for methods or 'static' for non-method functions. or override public static void FunctionName(). I much prefer self/no self over public/internal/static. private is '__var' and internal is '__var__'. I agree that the underscores suck but I'd prefer python over static typing anyday (unless I was getting paid per LOC :)~).
Evan Plaice
the fact that python does not enforce member privacy is a conscious language choice. It wouldn't have been hard to add this, but it's not there because *we're all adults here*. Anyone that is mucking about in the implementation of a class knows what he's doing, and is doing it for the right reasons. This is fine! If a pythonista doesn't need to muck with the implementation, our good sense will prevent us from doing so, because it's undocumented or some such and we don't want to write fragile code.
TokenMacGuy
+18  A: 

PHP:

  • One can never be sure that certain almost common extensions are available on all webservers.
  • tries to be everything in future ( goto, closures, ... )
  • many security risks for unexperienced users
  • more operator overloading would be nice
  • all the poor programmers that don't learn how to make it work properly, and give it a bad name

Nevertheless PHP is the (scripting) language. ;-)

okoman
OK, only one more thing to go!
brian d foy
there's a fifth.
Alister Bulman
Totally agree with point 5 - would be on a Javascript list too.
Steve Claridge
I disagree with "all the poor programmers that don't learn how to make it work properly, and give it a bad name". I'd replace it with "massive tacked on runtime language configuration options".
Longpoke
+2  A: 

I use Java, and my biggest beef is the inefficiency of string operations. when you use the + operator. Seriously, can't the compiler figure out how many strings I'm adding and then generate the StringBuffer stuff in the background for me?

Often code that uses + is more readable than a sequence of StringBuffers operations.

Also, I hate the redundancy between native arrays and the collection framework. The syntax for .toArray() is extremely ugly.

Uri
If you use "+" for String concatenation within a single statement, it is converted to StringBuilder.append() by the compiler. However, this doesn't happen across multiple statements.
Don
I was referring to the multiple statement situation. I would like to be able to write a series of concatenations of variables and constant string literals, and have the compiler figure out which literals to combine at compile time and which ones to then automatically add the stringbuffer stuff for.
Uri
I only see one thing, the question asked for five.
Brad Gilbert
Actually, there were two.... My other beefs were already mentioned by others, so this is the delta :)
Uri
You should probably use StringBuilder rather than StringBuffer, if you don't have multiple threads accessing it. It's faster.
rlovtang
I really don't like this kind of micro optimization. Most of the time, the compiler is clever enough to use StringBuilder, and when it's not I usually don't mind the extra microsecond anyway. I prefer readability, and optimize when there is need for it.
rlovtang
+25  A: 
Bill the Lizard
What socket syntax? C has no concept of sockets.
Ferruccio
http://www.cs.utah.edu/dept/old/texinfo/glibc-manual-0.02/library_15.html
Bill the Lizard
Oh, c'mon! You can come up with five. Doesn't pointer arithmetic just suck? :)
brian d foy
Bill the Lizard
Okay, the peer pressure got to me. I came up with one. (I could never cut it as that 5th dentist.)
Bill the Lizard
+1 I laughed at "C-style strings." And @brain_d_foy: pointer arithmetic only sucks if you don't understand it.
Chris Lutz
@Chris Luts: Even back when I was learning plain C (before I knew C++ or any other OO language) I just knew there was something wrong about char arrays. :)
Bill the Lizard
pointer arithmetic is a power saw - very efficient, but you risk taking your whole leg
Thorbjørn Ravn Andersen
library != syntax
Longpoke
Seriously.. the "Cryptic syntax" point is valid, but should refer to actual syntax (i.e: type declarations) to get the point across. For example: `char *(*(**foo [][8])())[];` Not to mention the standard library is a useless piece of crap. "No function overloading" is also a pretty bad point... C is meant to be a portable assembler, _not_ an OO language.
Longpoke
@Longpoke: Nobody said library == syntax. There's nothing particularly OO about *function* overloading. Plenty of languages have it, and I always miss it when I write anything in C.
Bill the Lizard
@Bill: Well it would be kind of useless since C isn't good for anything but glue code these days...
Longpoke
@Longpoke: Maybe if it had nice features people could stand to write more than glue code in it. :)
Bill the Lizard
@Bill: Yeah well it would also need a total remake, I find programming assembler more intuitive than C (although I'm not sure if it's possible to effeciently remove all the undefined behaviour, but at least the syntax and semantics could be fixed up quite a bit). I've always been hoping to see a modern version of C be made, Ada, D, C++, and Go are too big to be called that.
Longpoke
@Longpoke - no one considers assembler more intuitive than C. You can't be serious. Hate C, OK. But implying assembler is somehow easier than C is disingenuous. Have you ever looked at the assembler output of a good C compiler?
xcramps
@xcramps, The _syntax_, not semantics, (although the semantics are equivalent to a very well documented library). Take C vs the style of Intel x86: in C, a pointer dereference is `*x`, while in x86, it's `[x]`. Now imagine if you could expand that how Ollydbg does. double dereference would be `[[x]]`, while in C it's `**x`. call deref would be `[x]()`, while in C it would be `(*x)()`. func pointer declaration: `[int function(int a, [float] b)] x`, vs `int (*x)(int a, float* b) x`. clearly the former is superior. heck anything is better than C syntax.
Longpoke
but yeah, that would be if Intel x86 assembler syntax was generalized to a C like language. nonetheless the restricted subset that's allowed is _very_ easy to comprehend compared to C...
Longpoke
+84  A: 

Five things I hate about Java (which, presently, is my favorite language) in no particular order.

  1. As much as I am a fan of Java Generics, there are a lot of oddities that arise from the way it was designed. As such there a myriad of annoying limitations with generics (some of which are the result of type-erasure).
  2. The way Object.clone() and the Cloneable interfaces work is totally broken.
  3. Instead of taking the high-road and making everything an object (a.la. SmallTalk), Sun wimped out created two distinct categories of data-types: Objects and primitives. As a result there are now two representations for fundamental data types and wierd curiosities such as boxing/unboxing and not being able to put primitives in a Collection.
  4. Swing is too complex. Don't get me wrong: there's a lot of cool stuff one can do with Swing but it is a great example of over-engineering.
  5. This final complaint is equally the fault of Sun and those whom have written XML libraries for Java. Java XML libraries are way too complicated. In order to simply read in an XML file, I often have to worry about what parser I am using: DOM or SAX? The APIs for each is equally confusing. Native support in the language for easily parsing/writing XML would be very nice.
  6. java.util.Date sucks. Not only is it unnecessarily complicated but all the useful methods have been deprecated (and replaced with others that increase complexity).
Ryan Delucchi
You forgot about java.util.Date!
TM
ah yes. The Java Date/Time classes. Well, I probably forgot about it because it's been a long while since I have had to use them.
Ryan Delucchi
I agree with all of these, but I would like to hear your explanation of (2). Saying it's "totally broken" is not much of an explanation. Could you clarify? Thanks.
dj_segfault
You can't reassign final fields in clone.
Steve Kuo
Also: The "Cloneable" interface doesn't have a "clone()" method. This makes The Cloneable interface an Oxymoron. And since clone() returns an Object, type safety is out the window (there does not appear any attempt made to rectify this even after Generics have been introduced in J2SE 5.0).
Ryan Delucchi
As long as we're bashing cloneable, might as well include the so called Serializable "interface". Whenever using it I always want to stab myself.
wds
XMLBeans for the win!
TofuBeer
Hard to do simple things like open a file and read from it.
Eric Johnson
JAXB makes XML reading/writing very slick (1.6+), but I'll concede the rest and a few more I havne't thought of yet.
Andrew Coleson
Roboprog
@Ryan clone() does not necessarily need to return "Object". With J2SE 5.0 Java introduced covariant return types, which means you can return any subtype of a base class. So public MyType clone() IS possible!
Helper Method
@Eric +1 Decorator pattern done wrong :D. It's funny that in C file handling is so much easier -,-.
Helper Method
"Native support in the language for easily parsing/writing XML would be very nice." If you think Java should have this, you don't understand Java... Enjoy your bloated JavaScript with E4X...
Longpoke
For XML I find that xmlpp (Pull Parser) it just about the easiest to use. I like that I can pass the xmlpp around like an iterator. What's this? a Foo tag? Let me can parseFoo() to deal with that.
KitsuneYMG
DOM and SAX are two inherently different approaches to parsing XML. One is document-based (i.e. read the whole doc in, and then manipulate it) vs stream-based (react to tokens as they are seen in the input- much better for larger documents). But I'll grant you that using them both can be a PITA, especially since they're implemented via "service provider" interfaces.
Caffeine Coma
+6  A: 

Groovy/Grails

  1. Duck-Typing
  2. Convention over Configuration, assuming you know the Convention
  3. Everything you hate about Spring
  4. Everything you hate about Hibernate
  5. [Groovy] common operations across collections aren't (but recent releases improve this)
Ken Gentle
Maybe more important than all of those: **horrible documentation that is usually either missing or flat out *wrong*.**
TM
+120  A: 

C++

  • Far too easy to randomly corrupt memory and create almost impossible-to-find bugs (although, Valgrind goes a long way towards fixing this).
  • Template error messages.
  • When using templates it's easy to end up having to include everything in one file, and then get stupid compile times.
  • The standard library is a joke in the modern age (still no threads or network by default?)
  • Lots of nasty little bits of C poking through (in particular, all the conversions between short/int/unsigned/etc..)
Chris Jefferson
I agree with the STL, but I will say what _is_ there is pretty good.
Bernard
STLfilt for the win. :-)
Chris Jester-Young
iomanip. if it would be a puppy it should keep a 100 meters distance from me at all times.
wilhelmtell
unicode. i do respect ascii's simplicity, but for goodness' sake, we're well into the 21st century now.
wilhelmtell
lambdas should have been here in 1998 if the standards committee would be technology geeks like us. surely in 2003 if they had a little bit of desire to be at the forefront. but no, they have fermat's math skills AND age.
wilhelmtell
argh. i wish my love for c++ wouldn't be so strong. :)
wilhelmtell
Const Correctness - So much effort for so little gain.
Kieveli
What bothers me the most about C++ is the lack of a standard POSIX C++ API, though that's not really the language's fault.
Tyler McHenry
@Kieveli const correctness is actually one of the things i miss most when programming in other languages. particularly the dynamically-typed ones. raii is a big feature i often miss too.
wilhelmtell
+1 for template error messages. Argh.
JasCav
...implicit conversions can be really interresting.
KarlP
Most of C++ problems come from being an ISO standard and locked for 10 years.
graham.reeds
I completely disagree with #4 - this is handled so radically different on operating systems that any attempt to pin it down to a standard would be a mess.
George Edison
I think you can count Boost and Qt as standard libraries.
tstenner
+1 "Template error messages."
João Portela
+1 Template error messages. Threads are being added to 0x (whenever that get's here =/)
KitsuneYMG
I definitely think that const correctness is often worth far more implementation time and "Oh I forgot to mark that method const, now my build won't compile" than it's actually worth in value.
DeadMG
+1000 for template error messages
Brendan Long
@tstenner: I don't think you can call Qt standard when it cannot even be compiled with a C++ compiler. (Unless you pass the code through something else first...(
Billy ONeal
@DeadMG - or my var is const but somewhere deep down in a library somebody made an iterator not const so I can't pass my const value to it.
Martin Beckett
+676  A: 

English:

  • Inconsistent spelling
  • Multiple-use tokens ("She's said 'Bob's Bob's "own worst enemy."'", e.g.)
  • Swear words are kinda worn out
  • Lack of non-gender-specific pronouns ("he/she", "they" or "it" are the only choices)
  • Shared with Canada et.al.

Add more in the comments if you've got 'em.

MusiGenesis
Lol! He did not mention programming languages ;-).
Gamecat
I find English inconsistency not really inconsistent which in the end makes English a non-inconsistent language.
Trap
I probably should have said "Inconsistent spelling/pronunciation".
MusiGenesis
It lacks a good syntax-checking compiler.
Tom Leys
+1 for originality
Ken Gentle
@Tom: it's got 400 million syntax-checking compilers. That would have been #5, but mentioning Canada seemed snarkier.
MusiGenesis
@MusiGenesis, yeah, but none of the conform to the standard
Adam Rosenfield
I before E Except after C, or when sounding like A like in neighbor and weigh, unless it's weird. Or science.
Dean
English spelling is weird because a lot of the words are borrowed from other languages
geometrikal
Re: #4 - aren't "it" and "they" non-gender-specific pronouns? Someone once told me that English has two neuter genders (whereas most [European] languages have one), although they never explained how...
alastairs
@alastairs: "it" is a non-gender-specific pronoun, but it's kind of impolite to use it to refer to a person. "They" is a non-gender-specific plural pronoun that technically isn't correctly used for an individual. "he/she" is just a drag to type over and over again.
MusiGenesis
A book I read in college (Woman on the Edge of Time) got me to try and push the use of "per" (short for person) instead of him or her. Then I actually started dating.
MusiGenesis
@MusiGenesis, I like point 5. However, I have to disagree. Most of the compilers don't syntax check on compilation but instead raise errors at runtime. Most don't even raise errors, they just execute the bad code unpredictably. Don't get me started on the lack of error-checking in the transmission.
Tom Leys
"lack of error checking" - "What?" - "I said: 'lack of error checking'" - "Huh?" - "I said: 'lack of error checking'" - "What?"
MusiGenesis
@Tom: good point, actually. Any game of "telephone" illustrates your point perfectly.
MusiGenesis
Well played MusiGenesis, well played
cole
Also, English lacks a second-person plural pronoun, instead forcing the speaker to say "you guys", "you all", or "y'all".
Nik Reiman
@sqook: I'm a former yankee transplanted to Louisiana, and I've come to love "y'all" and possibly the only second-person plural-plural (or is it second-people plural?) in any language: "all-y'all".
MusiGenesis
@spook, Southern Standard English has the word yall as a second-person plural pronoun. Other dialects borrow this word or try to replace it with other constructions like "You people"
epochwolf
Evangelists of the language often have poor proficiency in the language.
James Schek
Highly customizable - e.g. every noun can be verbed. Poor interoperability - e.g. embrace/extend/extinguish, native speakers tend to be monoglots.
jamesh
I like the monoglot comment, but that's not really the fault of the language. When you have guns, you don't need to learn a new language. :)
MusiGenesis
thus, Disadvantage:relatively high coupling with gun ownership
Jimmy
I'd put that one up there, but I'm afraid of gun owners. :)
MusiGenesis
I always get pissed off that English doesn't use Chinese characters like Japanese and Korean (and Vietnamese I suppose).
Ziggy
@Ziggy: think how that one would look on the list: "Doesn't use Chinese characters like Japanese and Korean". Sure you want that up there? :)
MusiGenesis
You don't use English, you use American. "English" speakers don't spell colour and centre, wrong, and don't call officers "loo-tenants".
Roddy
English actually *does* have a second person plural pronoun: "you". 200+ y. ago, the English started using "you" as a respectful "thou" imitating French "vous". Soon they treated everyone respectfully. Then forgot about "thou", so "you" became the only word for both second persons.
Joe Pineda
The same is happening in Latin America: Spanish here lost "vosotros" (familiar "you"), our friends we might call "tu" alone, yet altogether they always deserve respect. Portuguese lost both "tu" (thou) and "vos" (familiar you). So in Brazil people always address each other in the respect form.
Joe Pineda
I disgree abot the lackof eror checkng. English, like all human lnagaugse, is higly redndnt/compresble, therfore it contans plnty of err chekng.
Jeffrey L Whitledge
@Jeffrey: I wish I could upvote a comment! But then that's only true of polysyllabic languages written in alphabetic scripts, or any language in ideographic scripts. Try omitting a vowel writing Mandarin in pinyin, or avoiding a letter in a Semitic scripture, and you destroy the word!
Joe Pineda
Subject/object ambiguity: "Tom put Bill's suitcase in his car." Whose car is the suitcase in?
Dour High Arch
#5 Shared with Canada et.al. <- the rest of us says this about you Americans. :P
Phillip Whelan
@Philip: are you saying Canadians aren't Americans? :)
MusiGenesis
'She's said 'Bob's Bobs "own worst enemy."' -- Both Bobs need apostrophes, 'Bob's Bob's "own worst enemy"', unless Bob's the worst enemy of all Bobs, in which case 'Bob's Bobs' "own worst enemy."'
Windows programmer
Correct, and corrected. Amazing how so many apostrophes camouflage the one that isn't there.
MusiGenesis
"English doesn't use Chinese characters like Japanese and Korean" is a better example of ambiguity.
ysth
buffalo^n is a grammatically correct sentence (see http://en.wikipedia.org/wiki/Buffalo_buffalo_buffalo)
drhorrible
@Dean, I'm late with this, but here goes: I before E except after C when sounding as S (without an S), or when sounding like A as in neighbor and weigh, unless it's really, really weird. At least that how I was taught it.
dragonjujo
Verb conjugation is a totally useless pain the butt which afflicts all the Romance languages. I am, he is, you are? Simpler: I be, he be, you be. Chinese got it right by leaving that out.
Eric Johnson
@Eric: ever try to learn Esperanto? I did, but it didn't bring the chicks running, as I expected. :)
MusiGenesis
Second-person plural pronoun: don't forget "yinz" if you're in Pittsburgh!
Daniel Dickison
What's wrong with not having a formal second person pronoun? Why should the pope get any more respect than my dog?
Zifre
About the second person plural pronoun, you are all in error. English DOES have a second person plural pronoun: "you". What it lacks is a second person SINGULAR pronoun.
Peter Wone
we should just lump she/he/it into a new word for a none-gender specific pronoun. I propose: shheeit
yx
@yx: that is some funny shheeit right there. :)
MusiGenesis
Another bullet to add: No formal standard, and conflicting ad-hoc implementations. (US English vs. UK English is only the tip of the iceberg)
Christoffer
@jamesh: Here's a perfect example of that - "I helped my uncle Jack off a horse" vs "I helped my uncle jack off a horse". With a lack of syntax checking the primary communication method of the above statements (verbal) can result in the same outcome (disgust)
Slace
Backwards-Compatibility requirements of old libraries has stalled progress on the language's evolution.
too much php
"Shared with Canada et.al." - Pah; cheeky. We shared our language with you a few hundred years back, and look what happened then. -- A Brit, with his tongue planted firmly in his cheek.
Andrew Ferrier
@Andrew: you guys didn't share it - we took it. And you guys stole it from the Neanderthals in the first place. -- A TheUnitedStatesian, with his tongue somewhere. :)
MusiGenesis
It is very easy to write but TERRIBLY HARD to speak (at least for me, I'm spaniard)
Konamiman
Lack of standardisation when adding new accepted vocabulary. Words are 'words' when they been popularised.
rockacola
Hahahhahahah, best answer on this entire website! English is full of "Configuration over Convention". What about vowels, which make different sounds based on context (An idiotic feature of all ASCII languages).
orokusaki
So it's like PHP?
Mike Robinson
From orokusaki: "Use of loose pronunciation conventions in lieu of diacritical marks ("o" sounds like "oh" when followed by a consonant followed by a vowel but not when followed by only a consonant... except in the word "oh", et al) "
MusiGenesis
Buffalo buffalo Buffalo buffalo buffalo buffalo Buffalo buffalo.
Corey D
'its' is always incorrect.
Robert Davis
Of course it has syntax-checkers. Some of them even run in the background without the need to activate them. I think this kind of syntax checker is called "grammar nazi". Better checkers exist, though. *scnr*
Meinersbur
English is a language, American is an accent.
Paul McKenzie
Since losing "you vs thou," English has not had a GOOD way to distinguish second person plural from singular. Fortunately, we in the Southern US created "y'all" for the plural form. (The Midwestern "yous" is also acceptable.) Let's not let snobbery limit our grammatical possibilities.
Nathan Long
If you are finding swear words worn out then I suggest you increase your sweary vocabulary: http://www.viz.co.uk/profanisaurus.html
Colonel Sponsz
Words like "colour" and its crippled American brother "color". Or alternatively: Words like "color" and its "what the hell is that growth on its face?" brother, "colour". Depending on your inclination.
Ryan Bigg
English pronounciation just follows the Perl mantra of 'many ways to do it'. - Notice for example this alternate way of spelling fish - using the [f] from cough, the [i] from women and the [sh] from station: Ghoti.
Thomas Ahle
There is a non-gender-specific 3rd person pronoun: one. For too many examples see Ayn Rand's "Anthem"[email protected] Long: "Y'all" is the singular form. The plural form is "all y'all".
Chris Wuestefeld
In Northern Ireland, Dublin, and parts of Scotland, "youse" is used as a second-person plural. In the Irish midlands, "ye" is more common. As with "y'all" (and "you" itself), the plural form "ye" is occasionally used as a singular. This seems to be a common pattern in English.
TRiG
@TRiG: that's interesting about "youse". In the New York - New Jersey area, "youse" is commonly used (yoused?), but usually by Italians (I think).
MusiGenesis
@Chris - "All y'all"? Y'all is "you all." I support useful contractions, but not redundancy. Southerners have a useful language feature - let's not ruin it.
Nathan Long
All your base are belong to us.
icelava
+16  A: 

Delphi:

  • IDE is a bit unstable.
  • Code insight is sometimes confused.
  • Debugging is sometimes buggy.
  • Updating several project files can be cumbersome.
  • If starting up when one or more packages are unavailable, the error message is popped several times.
Gamecat
All of these seem to be complaints about Delphi the IDE rather than Delphi the language (AKA Object Pascal)
Don
Presumably that's because Object Pascal is perfect ;-)
Mark Bessey
Ehm, I love Object Pascal because it's what I started with ... but every IDE since D7 was an utter failure. Mostly due to the insane instability since D7, no version after that has run properly on my systems (and I've used it across 3).
The Wicked Flea
@The Wicked Flea: things are supposed to have become a *lot* better since Delphi2007, and that's also actually my own experience...
onnodb
Delphi 2007 is rock-solid. I use it everyday and it just works. I previously used Delphi 2005 for about 3 months and it really really sucked for me. Delphi 2007 is sweet.
Mick
Delphi 2009 is a lot more stable than Delphi 2007 yet, I cant imagine working with a old version animore.
Cesar Romero
I still use delphi 6 and love it...
MikeJ
I'm a bit late to the party, but here goes anyway: - having to write down method signatures twice (interface + implementation) - Unit name is REQUIRED to be identical to the file name. WTF?!?
Martijn
The IDE has reasonable code completion so you're writing method signatures ONCE.Keep in mind that with Delphi, it really is a one stop shop - the IDE and the Language really come in together.
Arafangion
Carpal tunnel from having to type begin and end all these years...
dverespey
@dverespey At least you don't need to use the shift key { :-}
Gerry
I find the begin..ends to be superior--they're much clearer than {}. You spend a lot more time reading code than writing it. For a gripe, though--you can't use defined subranges of enumerated types in a case even though it's perfectly legal if you declare the range right there in the case. Also, no forward references across units.
Loren Pechtel
isn't Delphi dead as disco by now?
AlexanderN
@AlexanderN: No, it has never been more alive, popular or great.
Andreas Rejbrand
+1, easy to build, optional namespaces, clear syntax
arthurprs
You forgot: The compiler enforces type safety with a strictness unknown to many languages, yet considers strings as "special". Changes the size of 'char' depending on compiler, has a confusing implementation of "Interfaces", which turn out to be almost completely unrelated to classes - classes are to object oriented programming, whereas Interfaces are as to Microsoft COM interfaces! Classes are not reference counted, but interfaces are!
Arafangion
Interfaces _may_ be reference counted if, for instance, the implementations subclass TInterfacedObject. But interfaces do invoke "compiler magic" at the entry- and exit-points of a procedure/function.
Frank Shearar
+13  A: 

Smalltalk

  • I don't want to develop in java, delphi, c#, or ruby anymore (which is impractical as the main development languages in my company are c#, delphi and java).
  • Left-to-right evaluation.
  • Has a class comment but no method comment (at least in Squeak)
  • No real standard library, lots of differences in details
  • Lack of namespaces
Stephan Eggermont
How is the first something you hate about Smalltalk?
ysth
Smalltalk made me much unhappier over other languages, that's not nice.
Stephan Eggermont
@ysth: since my day job uses C++ to exclusion of (almost) all other languages, anything that makes me like it less could hurt my morale. :-) If my goal was only to feel better about my day job, I'd learn Intercal!
Aaron
+23  A: 

Common Lisp:

  1. Keywords are often too wordy.
  2. Library support is pitiful.
  3. Doesn't work well in OSes that want to handle memory more strictly.
  4. Doesn't have good facilities for interacting with the OS.
  5. The "loop" facility is not well defined, and sure doesn't look Lispy.
David Thornley
'loop' might not be lispy, but what's poorly defined about it?
Daniel Cassidy
I haven't read the standard myself, I'm mostly going on Paul Graham's "On Lisp". He says the standard is mostly examples, and doesn't define corner cases at all well.
David Thornley
don't you mean keywords-are-too-wordy ?
GClaramunt
I agree that it isn't "lispy," but CLtLv2 spends a lot of time on it. I just think it was designed to do way too much. http://sunsite.univie.ac.at/textbooks/cltl/clm/node235.html#SECTION003000000000000000000
HVS
In addition to "loop", "format" is also not very Lisplike. I hate "format" and "loop" both even though Lisp is my favorite language.
Paul Reiners
+1  A: 

Python: Array part-selection doesn't give you what you asked for.

a[1] gives you one element
a[1:2] gives you one element, not [ a[1], a[2] ]
a[1:3] gives 2 elements

I hate that, but maybe that's just because I mostly work in Verilog.

Marty
Okay, you only have four more to go!
brian d foy
That one counts for all 5 in my book!
Marty
It makes sense when you do [0:2] or a[2:4], it is much better than PHP's array_slice().
too much php
I remain unconvinced, Peter! You get 2 elements for both of those, which is exactly the behaviour which annoys me. I would (and did) expect that [2:4] would return elements 2 to 4 _inclusive_.
Marty
I believe it's easier to understand in a graphic manner:[0:2] -> |0 1 |2 3 4 5 6 7 -> [0,1][6:7] -> 0 1 2 3 4 5 |6 |7 -> [6][6:] -> 0 1 2 3 4 5 |6 7| -> [6, 7][-3:-1] -> 0 1 2 3 4 |5 6 |7 -> [5, 6]The numbers represent a limit rather than a specific location:[2:8] -> 0 1 |2| -> [2]
I GIVE TERRIBLE ADVICE
Here's the trick I learned: subtract the first number from the second number. That tells you how many elements you're slicing. So [5:6] will contain one element because (6 - 5 == 1) and [12:87] will contain 75 elements because (87 - 12 == 75)
benjismith
At least it is consistent with the range() functions, so you can put a mental alert like "watch out! the last element will be left out"
Mario
@Marty: It is a standard practice to left out end element when defining a range, e.g. in C++: `iterator.end()` is pointer *after* the last element; in C: `for (int *p = a; p !=
J.F. Sebastian
If it was inclusive, it'd prevent many good python idioms. First off, s[0:len(s)] would actually give *more* elements than exist (Though most builtin types will actually treat it like s[0:len(s)-1]). Also, how do you select 0 items? maybe s[2:1]? What about s[0:-1]? Currently, it will not return 0 items, but instead return all but the last element. And yes, I do often take slices of length 0 from arrays (when the indices are calculated from variables)
Wallacoloo
+55  A: 

I'll do PHP as I like it at times and Python will be done way too much.

  • No namespace; everything is in a kind of very big namespace which is hell in bigger environments

  • Lack of standards when it comes to functions: array functions take a needle as a first argument, haystack as second (see array_search). String functions often take the haystack first, needle second (see strpos). Other functions just use different naming schemes: bin2hex, strtolower, cal_to_jd

    Some functions have weird return values, out of what is normal: This forces you to have a third variable declared out of nowhere while PHP could efficiently interpret an empty array as false with its type juggling. There are near no other functions doing the same.

    $var = preg_match_all('/regexp/', $str, $ret);
    echo $var; //outputs the number of matches 
    print_r($ret); //outputs the matches as an array
    
  • The language (until PHP6) does its best to respect a near-retarded backward compatibility, making it carry bad practices and functions around when not needed (see mysql_escape_string vs. mysql_real_escape_string).

  • The language evolved from a templating language to a full-backend one. This means anybody can output anything when they want, and it gets abused. You end up with template engines for a templating language...

  • It sucks at importing files. You have 4 different ways to do it (include, include_once, require, require_once), they are all slow, very slow. In fact the whole language is slow. At least, pretty slower than python (even with a framework) and RoR from what I gather.

I still like PHP, though. It's the chainsaw of web development: you want a small to medium site done real fast and be sure anybody can host it (although configurations may differ)? PHP is right there, and it's so ubiquitous it takes only 5 minutes to install a full LAMP or WAMP stack. Well, I'm going back to working with Python now...

I GIVE TERRIBLE ADVICE
And I so want strong typing. Or at least give me the choice to activate it.
christian studer
You can partially have it, just use !== and === for comparisons. That ensures the types are respected but for +-/* etc.I believe PHP gives enough choice. Being weakly typed is a language choice like duck typing, and letting people choose on their own would make the language even less consistent.
I GIVE TERRIBLE ADVICE
Love the irony of point 4 :)
Damir Zekić
I suppose point 1 is implemented in 5.3 :) While param ordering is getting better naming is still poor. I agree with the backward compatability though.
Ross
Chainsaw of web development? Man, I'll use that in my signature. Hehe.
capfu
The only thing I have to (sort of) disagree with is the weird return values. With the way PHP does it now, you can do if(preg_match_all("/regexp/", $str, $ret)) { print $ret; } (or if (preg...(...) > 2) {...}, etc) which was probably the point.
Andrew Koester
When returning an empty array, PHP will evaluate it to false with its loose typing. Returning the array itself would still let you like "if($matches = preg_match_all($regexp,$str)){...}". Adding 'or' after sounds like a pretty bad reason to have the return values that way.
I GIVE TERRIBLE ADVICE
I believe the common version of the phrase is "Swiss Army Chainsaw," which is also accurate. Also, you were supposed to write it about your favorite language, not one you "kinda" like.
NateDSaint
Gotta love #4. That's one of the things that bothered me the most all the time, too.
Franz
I think, the speed argument is pretty subjective. Speed depends much more on how efficient the code is than on the language itself. Poor PHP code is probably slower than high quality python code but good PHP may also perform better than poor Python.
Techpriester
It is subjective, especially since the largest bottlenecks you have are about the network and how long it takes to render the page to the user (CSS, JS), which amounts to roughly 90% of the time taken to load a page.What makes file importing really bad though is that it basically just calls 'eval' on the file you pipe in. It's neither smart, safe or fast.
I GIVE TERRIBLE ADVICE
no_really_now_mysql_escape_the_string_im_serious()
Salaryman
namespaces schmamespaces. PHP is on the world wide web so everything should be global
Evan Plaice
+7  A: 

VBA (including MS Office IDE):

1) Poor Documentation
2) Poor Error Messages
3) Inadequate Array Manipulation Routines
4) Having to repeat types for DIM statements
5) Won't print in color (have to buy 3rd party addin)

Lance Roberts
I dont get how VBA can be anyone's prefered language
Eric
Because that's what I have to do most of my work in. I have to support a huge amount of convoluted, interconnected Excel spreadsheets. I hope to rewrite it all someday in a console app, but it'll take a while.
Lance Roberts
i Feel so so sorry for you...:( vba is trash
Kelly
@Eric: be a non CS enginneer, install MSOFFICE, and start solving everyday problems while doing your spreadsheets, docs, etc.
jpinto3912
How about lack of casting from variant to its named object type. Had the problem varient/Contanct assigned to contact produced type mismatch.
mikek3332002
+5  A: 

I have a book exploring all sorts of projects in SNOBOL. The first chapter explores the history and culture around SNOBOL programming and language and spends some time making the argument that a good programmer likes a language not because of its flaws but in in spite of them.

My favourite language is Icon/Unicon. But there are still things that annoy me about it:

  1. It's not well known or all that popular.
  2. It has a much smaller library compared to PHP, Perl, Java, etc. Database access is done via ODBC, which is actually quite annoying.
  3. For all it's otherwise excellentt list handling, I miss PHP's built-in explode() and implode().
  4. It doesn't have a table constant. Lists, yes, tables, no.
  5. It is a compiled (actually translated) language.
staticsan
+70  A: 

Ruby has many flaws related to its speed, but I don't hate those. It also has flaws with the community evangelism going overboard, but that doesn't really bother me. These are what I hate:

  • Closures (blocks) have 4 different creation syntaxes, and none of them are optimal. The elegant syntax is incomplete and ambiguous with hashes, and the full syntax is ugly.
  • The community tends to be against real documentation, favoring ‘read the code’. I find this childish and lazy.
  • Metaprogramming abuse, particularly in libraries, makes bugs a nightmare to track down.
  • On a related note, pervasive metaprogramming makes a comprehensive IDE difficult, if not impossible, to make.
  • The way block passing to functions is done is silly. There is no reason blocks should be passed outside the parameter list, or have odd special syntax to access (yield). I am of the opinion that blocks should have been given a less ambiguous syntax (or hashes could have used different delimiters; perhaps <> rather than {}), and passing as parameters to methods should have been just like all other parameters.

    object.method(1, {|a| a.bar}, "blah")
    

    These oddities, like the block must be the last parameter passed and passing more than one block is different with longer syntax, really annoy me.

Myrddin Emrys
I agree with the last one, it was also surprising to me when I started to learn Ruby that passing a function (block) is conceptually different from passing any other argument.
Adam Byrtek
Keltia
I thought that metaprogramming abuse is called "idiomatic ruby" :)
Slartibartfast
1. Global variables (especially, class/module names) which cuts possibility to load several versions of the same library2. Mutable string literals (you have to write Cblah = "blah".freeze to optimize GC)3. Operators are not methods (!=, !~, !, if, while), so you cannot do 100% proper proxies and futures
Oleg Andreev
I never thought about lame sides of metaprogramming abusing. Nice point.
Arnis L.
I wish Ruby blocks were just JavaScript anonymous functions with a more elegant syntax. That would make much more sense IMO than doing what they did.
musicfreak
Re: closure (block) passing after function args: this lets you extend your own language to create "visitors" and the like. It's quite useful, actually. Nothing stops you from making and passing function/closure references in as standard arguments.
Roboprog
I can see the problem in excessive cutesy dynamic programming in frameworks gumming up IDE support, though. I don't want to sound like too much of a fan-boy (fan-geezer?). And, Ruby implementations do run a bit slowly. And, I have gotten a little tired of Rails version thrashing: I want my Postgres driver to just continue working, please.
Roboprog
You can get to within one character of your desired syntax: alias :L :lambda object.method(1, L{|a| a.bar}, "blah")I fully agree that it's not optimal, but I think it's a useful, and more importantly, practical convention.
ben_h
Threads are not true kernel threads, but 'green' threads.Using require to include other ruby files doesn't expand the path, so if multiple files in a library load the same files from different paths they get linked twice.
Allyn
What are the 4 creation syntaxes? I only know { ... } and do ... end.
akway
akway: The other two syntaxes are *lambda* and *Proc.new*.
Myrddin Emrys
Re documentation, I once heard a talk by someone working at the Pragmatic Programmers publishing house, who said that when the company was founded, they wanted a Ruby book because the only one that was available was in Japanese. So they could have had that book translated and published by their company. But what they did instead what to read the source code :-) The Ruby book was apparently one of the books that launched Pragmatic Programmers.
Arthur Reutenauer
I find it interesting that 3 of these are to do with people and not the language itself. Ruby remains the language I hate least.
Toby Hede
Lol. Myrddin, I wish I could vote twice for this answer. :-)
conny
I think it may be that there's an inherent tradeoff between language power and IDE power. Making a language more expressive may place hard limits on how much help an IDE can provide. If that's the case, I'll go for language power every time because I've found that powerful IDEs help a lot more for writing code than reading it, and I do more of the latter.
Zak
OH GOD, THERE ARE SO MANY `end`S!
John Douthat
Just because you can infer some code's purpose by reading it doesn't mean that it's the One True Way of finding out what some function does.
MiffTheFox
I actually love blocks coming last and coming outside of parameter list brackets (if any). The reason for that is, the function is usually the largest parameter: it quite often spans lines. I hate the split argument lists way more than I mind the separate syntax.
Amadan
@Amadan I wouldn't mind it as an optional, occasional way to pass blocks that were long... but as the only way blocks are usually passed, I think it kinda sucks.
Myrddin Emrys
+6  A: 

ColdFusion

  1. Compile Time for large Flash Forms.
  2. Dynamic Variable Types (Sometimes I hate them.)
  3. Lack of features in CFScript.
  4. CFTable (Can never get it to display right).
  5. The lack of chart types left out of CFChart.
  6. Complete lack of NTLM support (enterprise ready - yeah right)
  7. Moronic var scoping in CFCs
  8. No concept of a true NULL - your variable just vanishes!
  9. No way to test for the existence of certain things (like scopes, just members inside them)
Jeremy Reagan
Oh god...Cold fusion. Why hasn't it died yet?
Nick Stinemates
Because it rock so hard. :)
Jeremy Reagan
ColdFusion is a zombie. Zombies are already dead ... yet somehow they're still up and about, still biting people in the face. (I get to say that: I work with it day-to-day.)
Justice
I worked for a company that had their main website in ColdFusion. I hated trying to debug the thrown-together and bug-ridden mess. And it didn't help that the some servers used ColdFusion 5, others used 6, and others ran the ColdFusion code on .NET via BlueDragon.
Adam K. Johnson
+23  A: 

JavaScript

  1. numbers as strings - Math can be frustrating when numbers are intpreted as strings. 5 + 2 = 52? Grrr...
  2. permissions - all the best stuff requires permission from the user!
  3. screen updates - The browser must be in the steady state to update the screen. There doesn't seem to be a way to force the screen to update in the middle of a script.
  4. Slow - although Google's Chrome is nice...
  5. Browser differences make using the language a [censored].
BoltBait
The numbers as strings is easily fixed. If you've ever got a string, you need to parseInt(x,10) it. The giant fail is when you leave out the ,10, and it interprets '017' as OCTAL
Orion Edwards
What I have been doing is multiplying all of my numeric variables by 1. That seems to force Javascript to read them as numbers. And, it doesn't convert decimals to integers.
BoltBait
Didn't everyone learn that 1+1=11 when they were a kid?
Flame
false == 0 == [] == "" but null and NaN are not. NaN != NaN. null == null.
Jimmy
typeof "a string" == "string". typeof new String("another string") == "object. new String('a').constructor == "a".constructor. typeof new Array() == 'object'
Jimmy
for(x in list) returns the indices rather than the values.
Jimmy
for(x in object) returns functions
Jimmy
(ok, not javascript technically) domelement.onmouseover/out fires against child nodes.
Jimmy
@boltbait, that probably just translates to a parseFloat(str) call. javascript does treat numbers and strings as different types.
Jimmy
function rather than block scope, this causes not only the standard looping counter headaches but also manifests as sometimes requiring extra functions in loops just to provide closures around variables
Jimmy
Joe Pineda
@Jimmy: NaN != NaN is important (and C's fault anyway)
ysth
ok, perhaps NaN!=NaN isn't a 'real' problem, but [NaN, null, and <undefined>] form an unholy trinity of confusion. Add in isNaN(undefined) == true, undefined==null, undefined != NaN, for example.
Jimmy
personally i think NaN != Nan, null == null, null != everything else, NaN != everything else makes sense
Dan
-1, this list is mostly about browser issues, not the language itself.
Mauricio Scheffer
@mausch: Yes, but IE support is a real "clusterbomb", no?
Roboprog
typeof null == 'object'
I.devries
@Mauricio, how would you use the language except in a browser?
BoltBait
@Jimmy: `isNaN(undefined) == true` that makes perfect sense, undefined is NotaNumber you wouldn't expect `isNaN('string') == true` to return false, would you?
Javier Parra
@Jimmy: a little clarification isNaN doesn't test if `var == NaN` it tests if ` typeof var != number`
Javier Parra
@BoltBait: Mozilla Rhino, Windows scripting host, node.js, just to name a few. The question is about languages, not about particular runtimes or environments.
Mauricio Scheffer
+137  A: 

PHP:

1) Forces me to make unnecessary variables:

$parts = explode('|', $string);
$first = $parts[0];

2) An implementation of lambdas so lame it is roughly equivalent to using eval() and so hidiously wrong I have never used it (see www.php.net/create_function).

3) A try/catch system which can only catch about 80% of errors that might occur.

4) Regex support just as lame as lambda support because it has to be written inside regular strings, making one of the most hard-to-learn programming tools about three times as difficult. And PHP is supposed to be an "easy" language?!?!?

5) No way to safely pull stuff out of $_POST without writing it twice or building your own function, or using the '@' operator:

$x = isset($_POST['foo']['bar']) ? $_POST['foo']['bar'] : null;

6) Bonus answer: '@'. If you can't be bothered writing your code correctly, just add '@', and too bad for anyone who has to debug your code later.

too much php
what about list($first) = explode('|', $string); ?
mlarsen
or $first = explode('|', $string); $first = $first[0];
Pim Jager
Ideally, I would like to use some_function(explode('|', $string)[0]);
too much php
Best solution for #1 is to use strtok. That only works if you're getting the first element - otherwise list is the only other method I can think of (apart from using some hideous regex...). I, too, would love to add [0] to the end of functions. It's very neat and intuitive.
DisgruntledGoat
Btw for 5. you cant check isset within a function, php is gonna yell at you for sending an undefined variable into the function.
Ólafur Waage
What about its weird variable scoping?
Leonardo Herrera
What weird variable scoping? Having everything local and forcing you to declare when you want to use a global is a good idea, it prevent noobs from making functions that just use globals, rather than using arguments and return values like they should do.
scragar
you forgot about functions with parameter order changing randomly
dusoft
It's funny looking at this, because almost all these gripes have been addressed in newer versions of PHP. Mainly real lambdas and the ternary shortcut operator. Also, by setting a simple error handler, you can convert all PHP errors (notices, warnings, etc) to Exceptions, so they can be caught by try/catch blocks.
jason
5.3 has fixed #2, and that is all. Custom error handlers still can't catch fatal errors, so try/catch still can't catch all errors.
too much php
@too much php, consider fatal errors to compiler errors. In languages like Java and C# if you leave a semicolon out or make a syntax error which doesn't let it compile, you would get a compiler error the same way you get fatal errors in php
Click Upvote
@Click Upvote: But Fatal errors are not the same as compile errors - if you have `null` instead of an object than trying to call a method results in a Fatal Error. Could you imagine trying to build a reliable Java program if the NullPointerException instantly crashed your program and there was no way to catch the exception?
too much php
How does #4 make the language harder? And why would you consider it being one of the hardest to learn? That is simply not true.
Franz
My favorite part is I thought of explode and having to toss it into a separate variable first too when I was listening to the last SO podcast
Andrew G. Johnson
@Franz: I think he meant that regex is a hard language - and I'd concur. It's hard enough to keep track of escaping for regex, without adding string-escaping as well.
K Prime
@1: http://stackoverflow.com/questions/1965017/php-syntax-arrays-and-errors/1965035#1965035
Alix Axel
$parts = current(explode('|', $string));
Galen
For the #5 : filter_input.
Arkh
PHP 5.3.0+ has nice lambda-like functions: http://php.net/manual/en/functions.anonymous.php
Felix
PHP isn't a language it's a _hack_.
Longpoke
You forgot about verbNoun, verb_noun, noun_verb, nounverb, verbnoun, nounVerb, etc >_>
ItzWarty
To solve the first problem: function elem($array, $key) { return $array[$key]; } ... elem(explode('|', $string), 0);
Ollie Saunders
@Ollie: When you're writing library code that you need to run anywhere, it's dangerous to define functions with short names (as it will likely clash with something else somewhere), and a longer function name just isn't convenient any more. Also, the function call is expensive, especially when you need to handle more than one $key.
too much php
For #1: Why not $first = reset(explode('|', $string)); I do agree with the rest though... also, for #1 it is such a hack to use reset there... sigh
SeanJA
namespaces... namespay-what?
Evan Plaice
@too much php: Even in php 5.3 lambda are poorly design, you are oblige to specify which variable you want to capture and you could even not capture $this and self ...
mathk
#1 should be `substr($string, 0, strchr($string, '|'))`.
Billy ONeal
+147  A: 

JavaScript:

  1. It's fugly

  2. All the coolest things are insanely complex, but then, all the coolness is also wrapped up in such a small amount of code that you feel stupid for struggling to follow it

  3. '+' is an absurd choice of operator for concatenation in a weakly-typed language. Were they trying to scare off the noobs?

  4. It's a cross-browser compatibility minefield (never mind if it's even turned on or not)

  5. It's generally untrusted - associated with scummery such as blocking the back button, pop-ups that never die, etc.

  6. Did I mention that it's fugly?

  7. It's nearly impossible to debug because there are only a few different error messages and a few different types (Number, String, Object, etc.)

If it wasn't for jQuery, I'd probably still hate it as much as I used to :)

jTresidder
I wonder how many total programmer hours have been spent on trying to disable the back button. Has to be millions and millions, if not billions.
MusiGenesis
indeed, jQuery totally fixed my hate for javascript (as soon as you get the chaining part that is).
Pim Jager
Javascript is indeed the fugliest language... except for all those others.
JoeBloggs
It appears we need to work on natural language programming again for the sake of beauty!
Albert
-1, this list is not about the language but the browser environment. Javascript itself *rocks*
Mauricio Scheffer
I agree with mausch. ECMAscript in and of itself is a beautiful and powerful language. It's the pesky browsers (:cough: IE) that muddle its name.
tj111
...and here I was thinking beauty was subjective :)
jTresidder
@Mausch: where does javascript live in the *vast* majority of cases? You're saying the equivalent of "cars don't contribute to global warming, it's driving cars that does it" - true, of course, but missing the point - what else do you do with a car?
jTresidder
I would like an argument for #3. In some cases it makes perfect sense (to me) for numbers and strings to share a similar operator that does something different to each. For example, Python has "2*2" for 4 and "'yes'*2" for "yesyes". Same operator, different meaning. I think this makes perfect sense.
Chris Lutz
@Chris: Yes, "+" is a good operator for concatenation in a strongly typed language (like Python). In a weakly typed language (like Javascript or C) it is terrible; it decides (silently!) that 'sum: '+2+3 is not 'sum: 5' but 'sum: 23'. Someone with more Javascript experience can give better examples.
ShreevatsaR
I agree with #3.
grayger
So your problem is not the use of + to be addition and concatenation, but the absurd contextual rules that the language uses to determine which one to do?
Chris Lutz
Undeclared identifiers are global variables. Eeek!
Martijn
@ShreevatsaR: C is weakly typed?
Blindy
Fugly? Really?
eyelidlessness
@shreevatsaR: since when is C a weakly typed language? oO
knittl
The beauty of javascript is it keeps me employed
Mike Robinson
*JQuery* is fugly. JQuery code looks like somebody who likes to eat a lot of brackets got sick.
Pekka
Yes, C is weakly typed, compared to, say, Python (e.g. you can assign integers to `char`s, cast anything to anything via void* pointers, etc.) It is *statically* typed instead of *dynamically* typed, and also requires *explicit* typing instead of type inference, but those are unrelated to strong v/s weak typing. [Random examples: Python has implicit dynamic strong typing, Haskell has (optionally explicit) static strong typing, Java has explicit (mostly static) strong typing, C has explicit static (relatively weak) typing.] "Strongly typed" and "weakly typed" are actually not well-defined.
ShreevatsaR
I never want to have 'max' returned as a value.
graham.reeds
Viet
@Viet: Can you state your definition of strongly typed? (As I've already said, "strongly typed" is not well defined. See http://www.c2.com/cgi/wiki?StronglyTyped — by most of those definitions, C is less strongly typed than Python or Ocaml.) My definition of strongly typed, which I already made clear from context, is that casts are not silently performed. This is the sense relevant to JavaScript and this question, anyway.
ShreevatsaR
Would web applications be a lot more advanced now, if all browsers had been gifted with a bytecode interpreter from the start?
Chris S
@ShreevatsaRThe clasical example is: `'3'+'2'='32'`, `'3'-'2'=1`.
Thomas Ahle
javascript has no "proper" associative arrays: you cannot use arbitrary objects as keys.I find this mindboggling.
deubeulyou
If it's fugly you're doing it wrong.
Justin Ludwig
Well, as for #7, you're lucky if you get an error message at all. In most JS environments I've seen, the only "error message" is causing the script to terminate silently. D:
MiffTheFox
i'd add a bullet point for broken scoping rules for closures necessitating stuff like: var that = this;
Nathan Hughes
no JS specifically but I hate the DOM
xenoterracide
I strongly disagree with Mauricio Scheffer: DOM and the browser-dependent APIs are indeed very bad, but the language itself is also pretty terrible. I actually refused to touch it until I found jQuery.
reinierpost
JavaScript is a language of politics. That's why typeoff(null) is object. Some guy made a mistake in LiveScript. JScript copied the mistake. Now the mistake's an ECMAscript standard.
diadem
@Gordon Tucker: What would you want it to return?
configurator
@Gordon Tucker: oh, that makes sense. I was thinking you're saying it returns that as opposed to something else it should have returned.
configurator
JavaScript has a tendency to be mistaken as an ugly version of Java or C by people who don't know enough JavaScript. It's a damn pretty language when you truly know it.
Ates Goral
+68  A: 

Perl

  • Mixed use of sigils

    my @array = ( 1, 2, 3 );
    my $array = [ 4, 5, 6 ];
    
    
    my $one  = $array[0]; # not @array[0], you would get the length instead
    my $four = $array->[0]; # definitely not $array[0]
    
    
    my( $two,  $three ) = @array[1,2];
    my( $five, $six   ) = @$array[1,2]; # coerce to array first
    
    
    my $length_a = @array;
    my $length_s = @$array;
    
    
    my $ref_a = \@array;
    my $ref_s = $array;
    
    • For example none of these are the same:

      $array[0]   # First element of @array
      @array[0]   # Slice of only the First element of @array
      %array[0]   # Syntax error
      $array->[0] # First element of an array referenced by $array
      @array->[0] # Deprecated first element of @array
      %array->[0] # Invalid reference
      $array{0}   # Element of %array referenced by string '0'
      @array{0}   # Slice of only one element of %array referenced by string '0'
      %array{0}   # Syntax error
      $array->{0} # Element of a hash referenced by $array
      @array->{0} # Invalid reference
      %array->{0} # Deprecated Element of %array referenced by string '0'
      

    In Perl6 it is written:

    my @array = ( 1, 2, 3 );
    my $array = [ 4, 5, 6 ];
    
    
    my $one  = @array[0];
    my $four = $array[0]; # $array.[0]
    
    
    my( $two,  $three ) = @array[1,2];
    my( $five, $six   ) = $array[1,2];
    
    
    my $length_a = @array.length;
    my $length_s = $array.length;
    
    
    my $ref_a = @array;
    my $ref_s = $array;
    
  • Lack of true OO

    package my_object;
    # fake constructor
    sub new{ bless {}, $_[0] }
    # fake properties/attributes
    sub var_a{
      my $self = shift @_;
      $self->{'var_a'} = $_[0] if @_;
      $self->{'var_a'}
    }
    

    In Perl6 it is written:

    class Dog is Mammal {
        has $.name = "fido";
        has $.tail is rw;
        has @.legs;
        has $!brain;
        method doit ($a, $b, $c) { ... }
        ...
    }
    
  • Poorly designed regex features

    /(?=regexp)/;           # look ahead
    /(?<=fixed-regexp)/;    # look behind
    /(?!regexp)/;           # negative look ahead
    /(?<!fixed-regexp)/;    # negative look behind
    /(?>regexp)/;           # independent sub expression
    /(capture)/;            # simple capture
    /(?:don't capture)/;    # non-capturing group
    /(?<name>regexp)/;      # named capture
    /[A-Z]/;                # character class
    /[^A-Z]/;               # inverted character class
    # '-' would have to be the first or last element in
    # the character class to include it in the match
    # without escaping it
    /(?(condition)yes-regexp)/;
    /(?(condition)yes-regexp|no-regexp)/;
    /\b\s*\b/;              # almost matches Perl6's <ws>
    /(?{ print "hi\n" })/;  # run perl code
    

    In Perl6 it is written:

    / <?before pattern>  /;   # lookahead
    / <?after pattern>   /;   # lookbehind
    / regexp :: pattern  /;   # backtracking control
    / ( capture )        /;   # simple capture
    / $<name>=[ regexp ] /;   # named capture
    / [ don't capture ]  /;   # non-capturing group
    / <[A..Z]>           /;   # character class
    / <-[A..Z]>          /;   # inverted character class
    # you don't generally use '.' in a character class anyway
    / <ws>               /;   # Smart whitespace match
    / { say 'hi' }       /;   # run perl code
    
  • Lack of multiple dispatch

    sub f(   int $i ){ ... }  # err
    sub f( float $i ){ ... }  # err
    sub f($){ ... } # occasionally useful
    

    In Perl6 it is written:

    multi sub f( int $i ){ ... }
    multi sub f( num $i ){ ... }
    multi sub f( $i where $i == 0 ){ ... }
    multi sub f(     $i ){ ... } # everything else
    
  • Poor Operator overloading

    package my_object;
    use overload
      '+' => \&add,
      ...
    ;
    

    In Perl6 it is written:

    multi sub infix:<+> (Us $us, Them $them) |
                        (Them $them, Us $us) { ... }
    
Brad Gilbert
I don't see lack of true OO as being as bad as you make it. Sometimes, it's a saviour, especially when the CPAN module you're using didn't think to expose what you need. And lack of multiple dispatch could be worse: perl could have been strongly typed ;-)
Tanktalus
Basically I went through the differences of Perl5 and Perl6.
Brad Gilbert
my @two = @array[0,1];
derobert
$array->[0] != $array[0] != @array[0]
Brad Gilbert
Poor exception handling is one of my #1 problems with Perl 5. I also dislike the fact that it is not strongly typed and that I can't have defined paramater-ized functions
Mick
What's wrong with m/(?=>look ahead)/; ?
ysth
Should have been (?=look ahead). ... fixed.
Brad Gilbert
I like that Perl isn't strongly typed, but it would be useful to add in some type information.
Brad Gilbert
Wow. I REALLY don't like the change in character class notation. That's one thing I don't think should be changed. I don't mind (?non-capture) - it's clearly a GROUP, which is what matters more then whether or not it captures.
Chris Lutz
The only change in character class notation, is that they must be inside of <>. Which would allow you to do <-[a-z]> for negation.
Brad Gilbert
It seems like you chose to criticize a language that's not your favorite (you should have criticized perl6)
Frew
What's the point about comparing to perl 6? Are you suggesting that perl 6 fixes your issues, or continues them?
Robert P
Perl6 improves upon them.
Brad Gilbert
I agree with all of these, except for the regex constructs - I think that Perl's regular expressions are as good, if not better than any other language.
Drew Stephens
That's not a bug, it's a feature! Perl is probably my favorite "get 'er done" language, but the OO bag-on-the-side in Perl 5 did kind of jump the shark, in terms of conceptual and notational clutter.
Roboprog
+1 for the list of all possible array / hash notations, all but two of which are authorized by the syntax, with completely different meanings :-)
Arthur Reutenauer
Perl should just die. But it **can't**. It's specified as mandatory by the **Linux Standard Base** :(
java.is.for.desktop
The "inconsistent sigils" are actually typed dereferencing operators, and should be thought of as such. Every one of those examples makes sense. Perl 6 is going to break this, and therefore, regardless of its improvements on Perl 5, is downright offensive. Most of the actual inconsistencies in Perl can be chalked up to growing pains.
Jon Purdy
I doubt I need to say more than: http://www.ozonehouse.com/mark/periodic/
Arafangion
Lack of true OO? You appear to actually not like the lack of a clean implementation of a common way of implementing OO. Others would argue that OO is simply about message passing, isolation and polymorphism. Still others would have different definitions of what "OO" really is. While I agree with some of your warts, this isn't one of them.
Ovid
The question was '[...]about your **favourite** language[...]'.
hlynur
TNANC;DR (too many non-alphanumeric characters; didn't read)
Longpoke
@Drew Stephens: By any other language do you mean `{COBOL, microcode, VB}` ?
Longpoke
Forget "fake" OO. My biggest issue with Perl is that `sub foo { +(1..5) }` returns 5 elements when called in list context, but `''` when called in scalar context. That's just not right.
fennec
+1  A: 

C++

  1. It takes so much time to make a simple snippet of code.
  2. for(std::vector::const_iterator iter = [...]
  3. vector.remove() doesn't remove.
  4. vector.push_front() doesn't exist.
  5. header files
  6. No lambda
  7. No automatic empty virtual destructor if there is at least one virtual function.
Boost solves at least #2 and #6. For the rest, I agree with you.
Martin Cote
#3, it does. It just doesn't delete. #4 use deque.
Jasper Bekkers
#7. The reasoning is that you may not want a virtual destructor if e.g., your derived classes do not add any non-POD members. Explained here: http://www-igm.univ-mlv.fr/~dr/CPP/c++-faq/virtual-functions.html. I think it should force you to declare a destructor as "nonvirtual ~ClassName()" to let it know that you have thought this through though.
Neil G
2. for_each(v.begin(), v.end(), foo);3. std::vector has no remove member function. Perhaps you mean std::remove_if()? Use the member function erase to erase elements from containers, and remove_if to move elements to be erased by a predicate.4. Thankfully, because then it wouldn't work as a linear array, or it would make the allocator much more complex.6. Use Boost's lambda.
Mads Elvheim
#4 cant be implemented effectivly for a vector. So dont blame C++ for that, but choose a container class which fits your needs.
smerlin
+14  A: 

Haskell:

  1. Space leaks from lazy evaluation.
  2. Numeric Hierarchy not constructed with regard to mathematical abstractions.
  3. Strict monadic IO can make it harder to debug.
  4. The big implementations handle I/O in ways that don't seem quite compatible with the standard. (In particular, outputting characters only outputs the low 8 bits -- and then code gets built that uses this assumption to do binary I/O. Ick.)
  5. Associativity of ($) operator could be changed to make some expressions prettier.

Most of these don't rise to the level of hate, and there are people trying to fix or construct solid workarounds for each of these.

wnoise
Why would you want to change the associativity of ($)? 'f g h x' brackets as '((f g) h) x' and 'f $ g $ h $ x' brackets as 'f (g (h x))'...
Erik Hesselink
I <3 Haskell. The standard library needs to include mountains of mathematical abstractions, including vector spaces et al. The prelude also needs an operator which chains just like ($) but from left to right { source |> func1 |> filter func2 |> map (func3 10) }.
Justice
You missed out the really bad one: the tendency of Haskell programmers to use one letter variable names.
Benjamin Confino
A left-associative ($) operator is just function application, which in Haskell is represented by the space character. @Justice: Try the flip function. (|>) = flip ($)
Apocalisp
I was with you up to the `$`. An infix right-associative identity function is the best thing *ever*.
Norman Ramsey
mikek3332002
Can someone explain the point of #5? I thought right associativity was the whole point of ($).
Tim Matthews
The thing I hate the most is the ugliness of working with mutable arrays (example: http://www.haskell.org/haskellwiki/Prime_numbers#Using_ST_Array ). However, dynamic programming with immutable boxed arrays works very nicely.
Joey Adams
6. Difficult to work out time and space complexities due to laziness.
j_random_hacker
7. Half the useful things in the language are described in a huge DAG of research papers.
j_random_hacker
8. Basic stuff like recursing through nested data types requires either a pile of repetitive boilerplate or a language extension (rank-2 polymorphism for SYB)
j_random_hacker
9. Point-free style! What's the point? Other than to satisfy some masochistic minimalistic craving? (Of course half the time it won't automatically typecheck due to the monomorphism restriction.)
j_random_hacker
10. It's hard. It's taking me forever to get beyond newb. I love it though :D
Matt Ellen
+36  A: 

Objective-C

1) No namespaces, just manual naming conventions - I don't mind the that in terms of class separation, but I do miss being able to import all class definitions in a namespace in a single line (like import com.me.somelibrary.*).

2) Libraries still have some holes in important areas like RegEx support.

3) Property syntax is a bit clumsy, requiring three lines (in two separate files) to declare a property.

4) I like the retain/release model, but it is easier than it should be to release a reference and then accidentally make use of it later.

5) Although not really a language feature, Xcode is so intertwined with use of Objective-C I can't help thinking about that aspect... basically the autocompletion, is very iffy. It's more like a system that rewards you for finding something you want exists, and then presents it as a choice afterwards. But then I suppose I never have liked autocomplete engines.

Kendall Helmstetter Gelner
Agree about the namespaces, prefixing classes with letter codes is dumb. And I would add missing support for real class variables, I don’t like faking them with file statics.
zoul
Definitely agree with the property verbosity. It ought to default to @synthesize until you tell it otherwise. I also have a gripe with the amount of C-ness and the amount of code needed to move between C and Foundation types.
Graham Lee
Objective-C properties. Seriously, they are shocking, I can't understand the hype especially seeing how well C# does them.
Justicle
I really like codesense, but it's still not what it should be. I personally think that it needs to take time and frequency into effect. If you've been using a lot of NSPoint recently, it should be the first suggestion, and it should pop up faster.
Sneakyness
Don't forget the message sending syntax: [[[someObject sendMessage] doSomethingElse] doAnotherThing];Making sure the # of open/close brackets match up is a PITA for especially complex messages, it's like I'm working in LISP again.
drewh
Actually I really liked that aspect of Lisp and ObjC - you just need an editor with good brace matching, like Emacs or XCode. I usually type braces in pairs before I type anything in them, so I don't really run into problems with matching... and XCode can also highlight the region enclosed by a brace just by double-clicking on either containing brace.
Kendall Helmstetter Gelner
@synthesize should make it in there. YES/NO for boolean values. Named parameters. Strange mixture of dot notation and [].
Chris S
@Chris S: Are you saying `YES/NO` for booleans is a bad thing? And more importantly, are you saying Named Parameters are a bad thing?? I can understand bools, but named params are possibly one of ObjC's best features (in terms of readability).
jbrennan
named parameters rock! I like YES NO it makes code more readable.
nickthedude
Property syntax really requires four lines, if your properties are marked `retain` and you don't want to leak memory.
Frank Schmitt
Yes/no is too VB-esque for my liking. Named parameters are good if the method has many, many overrides, but pointless otherwise
Chris S
Maybe I'm a masochist, but I like prefixed class names. It makes google and documentation searches crystal clear, there's never any confusion about what kind of string your using if the class is called NSString.
kubi
@kubi: That's a really good point, but I'd still like to be able to import a prefixed group all in one import... the way you get with package imports like #import <MapKit/MapKit.h>. I guess I could set it up that way myself...
Kendall Helmstetter Gelner
+18  A: 

VB6

  1. Windows only.
  2. No longer supported.
  3. Arrays can start at any number, rather then all being normalized to 0.
  4. compiled applications depends on many dll's to run properly.
  5. Many complicated controls like a browser control or complicated pieces of code tend to break the IDE when you run code uncompiled, but work just fine when compiled.
Asrrin29
VB is someone's favourite language? O_o. Why isn't "syntaz that is completely different and incompatible with other languages" and "gives bad habits with regards to other languages" here?
Jonta
just out of curiosity, what bad habits? I need some ammunition against my VB6 colleagues.. ;-)
petr k.
I actually find #3 a very powerful feature, not a bug - I'd really love VB.NET had this. AWK has it, in a sense, but then in AWK arrays are really hashes in disguise :(
Joe Pineda
@Joe: Maybe you should program in PL/1 or Pascal where you can start your arrays from anywhere :)
Adrian Pronk
On 1 and 4, and .NET C# doesn't require A COMPLETE FRAMEWORK and Operating System??? (hey, I heard that you mono bigot... it's still a "complete framework" for you, and I doubt a debian dist ever eats it).Regarding 5, no right-minded VB6 programmer (back in the day) kept the default "Compile On Demand" option ON...
jpinto3912
Still have to support vb6 occasionally. Pet pieves: can't initialize a variable at declaration, no parametrized constructurs, one class per file, etc... If they would fix these issues, the language could go on for another 10 years easy.
AngryHacker
What about "On Error Resume Next"... thats like saying "this code is F**KED, but lets keep running it anyway. =)
StingyJack
It's a pity no 2 didn't come sooner, then I would've had to be taught it in Highschool.
mikek3332002
I will add these: 1 No brackets! 2 Variable declaration. 3 Function calling and array accessing.
Secko
Also, many older VBx installers did not check the 'minor' part of Major.Minor.Revision.Build on DLL versions and would actually end up downgrading system DLLs.
JBRWilkinson
The different syntax is actually not _that_ terrible. What is more informative, C's and friends' `}`, Pascal's/Ruby's `end`, or VB's `End If`? (or `Wend`? har har har.)
badp
+3  A: 

C/C++

  1. Lack of integral SWAP functionality
  2. Template Syntax
  3. You can not #define a #define (no multi-pass)
  4. Structure packing incompatibilities between compilers
  5. char is signed or unsigned ?

Java

  1. Immutability on the edge
  2. No ref keyword like C#
  3. try/catch blocks everywhere
  4. Poor runtime performance
  5. All string related stuff

Python

  1. No "main" (I'm used to it !)
  2. underscored keywords
  3. Limited thread support
  4. "self" instead of "this"
  5. Lack of C/C++ like syntax
Malkocoglu
I noted this in an earlier post, but in Python, "self" isn't a keyword, so you can call it "this" if you want; you can have a method like: def my_method(this, whatever): this.whatever = whatever. Of course, coming from an ObjC background, I think "self" is nicer than "this" anyway. :)
mipadi
I am not very fluent in Python yet, so thank you for clarification...
Malkocoglu
Python: `def main(): ...` solves the 1st point.
J.F. Sebastian
... the idiom i've seen in python is "if __name__ == '__main__':\n #your code here" to represent 'main'. it seems to work well enough, and is ugly enough to be found by code search :)
Aaron
If I understand your comments correctly you really should learn a LISP-family language. Take a look at Scheme (the easiest to learn) or Clojure (the most "modern".)
finnw
C++ has integral swap. `int a, b; std::swap(a, b);`.
Billy ONeal
@Billy: Well; it generally requires the use of stack, because it uses a temp variable to do the swap. Bu in fact; in ASM, you can do a swap without using a temp variable regardless of the size of your variables. When I wrote integral, i actually meant "as a function of the language/compiler"
Malkocoglu
@Malkocoglu: Most any compiler is going to be smart enough to do that when it's available in hardware, if it would benefit performance. On modern hardware I'd be willing to bet the swap instruction gets translated into the same thing as effectively what `std::swap` does, and therefore isn't much (if any) of an optimization.
Billy ONeal
@Billy: I have not come accross a compiler that does what you say when the type is not a POD but somewhat big struct. For small datatypes you are right, it does not use the stack. But for big structs, they always use the copy to/from stack code as I examined their ASM output.
Malkocoglu
+1  A: 

C#

  • Generic parameters are invariant C# 4.0 introduced covariance and contravariance for generic types
  • Overridable class members must explicitly be marked as virtual

Java

  • Missing unsigned numeric data types
  • Primitive data types aren't objects
Enrico Campidoglio
Primitive data types aren't objects: what is the problem with this?Since Java 5 you have autoboxing/unboxing
nkr1pt
Well, .NET everything is an object, including the primitive datatypes (the only difference is that they are allocated in the stack). The advantage of this approach is that behavior (methods) can be added directly to primitive types, instead of having to use a separate "utility" class like in Java.
Enrico Campidoglio
Autoboxing sucks. Make everything an object. Allow access to primitives in rare cases. The problem is objects can't override many operators like - and * etc. So can't make it work on Integer objects.What about Java's Generics. Can't cast when using generics, have to ungenerify objects. Its stupid.
Dmitriy Likhten
+17  A: 

Ruby is my favourite language, here's what I don't like:

  • Green threads + blocking C libraries = giant fail
  • SO PAINFULLY SLOW
  • The standard library itself is inconsistent with it's use of bang! methods
  • Module include + extend is messy.
  • "Open Classes" can't be scoped - I want to add a String#dostuff, but I don't want that to leak into all the third party libraries
  • No binary deployment packaging solution.
Orion Edwards
Have you tried Ruby 1.9.1? It offers a vast speed-up compared to Ruby 1.8.6
Christian Stade-Schuldt
Try jrubyc. JVM JIT FTW!
KitsuneYMG
+9  A: 

VB.NET

  • The behavior AndAlso / OrElse and And / Or seems backwards. Perhaps they should be switched.
  • When can only be used for exception catching. The ability to do a When conditional would be nice for some other things.
  • There is no friggin Refactoring in the VS IDE (not really the language's fault) like there is with C#
  • Not <obj> Is Nothing. Yes, this has been remedied by IsNot, but for some reason I see the Not Is being used too often. (I see it much more frequently with devs who speak english as a second language, does it make better sense from that angle?)
  • It doesn't require the () on ToString() and most functions. (Leads to sloppy coding habits)
  • Having to do _ when breaking a line.
  • It allows optional parameters. (Leads to sloppy coding habits)
  • declaring an array is done by UpperBound and not by capacity. "Dim arr(2) as String" will actually hold 3 elements.
  • Having = be a comparison and assignment operator.
StingyJack
+1 for UpperBound array declaration. I dislike optional parameters too, but the C# guys are clamouring for them? odd. According to someone (can't remember who, on SO) said that in vb11 will allow mid line breaks (think fluentInterfaces) with out the _. I look forward to that :)
Pondidum
past .Net, there's no good reason for you to stay with VB... go C#.
jpinto3912
c# is getting optional parameters, and I miss them
Maslow
Do some office interop work. You'll end up praying for optional parameters.
wefwfwefwe
@wefwfwefwe - I have, but I just see it abused too much.
StingyJack
*Nothing* being *null* as well as default(T) for value types. This leads to such nice effects like If(True, Nothing, 5) returning zero!
Heinzi
How do optional parameters lead to sloppy coding habits?
helium
Because you or the next dev can "forget" to set the parameters in the correct order on a method call, and cause yourself additional debug/troubleshoot/recompile time. Once this pattern is established, it will continue to be used, leading to additional time wasted.
StingyJack
@jpinto3912 - VB has literal XML handling that C# doesn't appear to have yet.. http://blogs.msdn.com/b/bethmassi/archive/2007/10/30/quickly-import-and-export-excel-data-with-linq-to-xml.aspx
JBRWilkinson
In VS 2010 you don't have to use _ in most of the places you used to have to.
Kyralessa
+202  A: 

Wow, I'm surprised that SQL hasn't made it up here yet. Guess that means nobody loves it :)

  • Inconsistent syntax across implementations
  • Subtle code differences can have massive performance ramifications for seemingly obscure reasons
  • Poor support for text manipulation
  • Easy cost of entry but steep learning curve towards mastering the language
  • Minimal standardization across the community for best practices, this includes syntax style.

...And a few bonus reasons to hate it, at no extra charge

  • the WHERE clause goes last, making it easy to prematurely execute an UPDATE or DELETE, destroying the whole table. Instead, the WHERE should go somewhere up front.
  • It's difficult to implement relational division.
  • I can set a value to NULL, but I can't test it for equality with NULL. I can check IS NULL, but that just complicates code -- needlessly so, in my opinion.
  • Why do we need to completely respecify the formula for a GROUPed column, rather than setting an alias on the column and then GROUP BY the alias (or column index as with SORT)?
Jeremiah Peschka
+1 for poor string handling.
BoltBait
Maybe nobody can learn to love it until they stop thinking of it as a language. :)
Alan Moore
+1 for everything. And yet people wonder why I'll put up with the headaches of ORM...
James Schek
For the record, all I do for a living is write SQL :)
Jeremiah Peschka
Apparently, we need an open-standard SQL parser that DB vendors can plug in and merely be responsible for the backend data retrieval...
Tanktalus
@Alan M...isn't that what the L stands for? :)
Kev
@Kev I thought it stood for Legume.
Jeremiah Peschka
I can't understand why the syntax for INSERT is so different from UPDATE. And MERGE is incomprehensible.
LaJmOn
Poor support for text manipulation?
Dalin Seivewright
@Dalin in comparison with, say C# or Ruby, SQL's text manipulation is god awful, especially when you take regex text replacement into account.
Jeremiah Peschka
SQL isn't a shining example of language design, but many constraints are imposed on the architecture by query optimisation and the mechanical component to database operations. SSDs notwithstanding, database development is more or less unique in that SQL is a declarative language controlling operations with a mechanical component - disk heads moving and rotational latency. Not subject to Moore's law. http://stackoverflow.com/questions/339744/better-languages-than-sql-for-stored-procedures
ConcernedOfTunbridgeWells
I am a huge fan of SQL, but I hate the fact it lacks Regex or any other advanced string manipulationoptions.
TimothyAWiseman
My general feeling about string manipulation and SQL is “do it in something else if you can, almost anything will do”. If only no queries ever required it…
Donal Fellows
LOVE your bits about checking NULL and not being able to GROUP by an alias! Seriously. The compiler can't internally translate " [!]= NULL" into [NOT ]IS NULL" ??
eidylon
I can't write`SELECT col1,col2,col3,col4,col5,from`
xenoterracide
@All "SQL sucks for string manipulation" commenters: In some legacy code of my company there is a scripting language implemented entirely in T-SQL (SQL Server 2000), I once had to modify it.. that was... interesting.
Earlz
+1 for IS NULL ...
Rekreativc
The necessity of IS NULL should be clear, if you consider that NULL is a third possible result, right after TRUE and FALSE. Since it's meaning is "unknown" you can not tell if something which is unknown matches another thing which is unknown as well. Another example: if NULL equals NULL this would mean that the whole concept of making JOINs would be impossible, since any NULL value could be matched to another NULL value. If you understand this (what also is called ternary logic) than you might understand the reason for introducing the "IS" operator for testing against NULL.
Vash
Vash is right. Another (easier to digest?) way of putting it: if you made NULL = NULL, then you don't *remove* weirdness from the language, you just push it into other, even more inconvenient places.
j_random_hacker
+1 for missing WHERE clause havoc. Thank $deity for ROLLBACK;
al
+23  A: 

PHP

  1. No debugging features if you don't control the server, and even then they kinda suck
  2. The extreme amount of bad PHP code floating around gives all PHP programmers a bad name
  3. Inconsistent function naming
  4. Inability to have a static typed variable if I want one (I'm a big fan of dynamic typing 90% of the time)
  5. REGISTER_GLOBALS is the devil
mabwi
REGISTER_GLOBALS once ate my dog :(
Pim Jager
1: I recommend xdebug and a GUI client such as MacGDBp. That really eases some of the pain...I agree on the other points.
Jonas Due Vesterheden
#2 == Wordpress
Jason Miesionczek
#2: Oh god, don't get me started on that. I always have to defend myself as a PHP developer against people who only have seen the mess that many people create with PHP.
Techpriester
+1 for #2 I've spent far too much time defending myself as a PHP developer.
Unkwntech
+1 for #2 -- results in bad salary too :(
Shiki
I heard that: A long time ago, Chuck Norris got angry with the world and roundhousekicked REGISTER_GLOBALS from hell until it got to PHP.
Javier Parra
There are IDEs such as NuSphere's phpED that comes with their own debugger that will work with any server, regardless of your level of control. Also, you can use any debugger, like you said, when using your own server, such as localhost. You wouldn't want to do line-by-line debugging with a live build anyway.
asnyder
+2  A: 

Objective Caml

  1. Lack of namespace facilicty.
  2. Wordy class and object nortation.
  3. Complex build system.
  4. Inconvenient to make infix.
+1  A: 

Python:

  • speed
  • static analysis (lack of)
  • anonymous functions limited to one expression
orip
+1  A: 

VB.NET

1) If Not x Is "foo" (instead of <> "foo")
2) "OrElse" and "AndAlso" short circuit (instead of simply "Or" and "And", which act differently)
3) Nothing (instead of Null)

MattK311
+7  A: 

Delphi (aka Object Pascal), I'll talk about the native version, not .NET.

  • Var blocks!
  • Interfaces in the language are designed with COM usage in mind - thus more complex than say in C# or Java. ie. Reference counting involved unless you disable it explicitly.
  • No try except finally end;
  • Object creation too explicit:

    var obj: TMyObject;
    ...
    obj := TMyObject.Create;
    try
      ...
    finally
      obj.Free;
    end;
    

Instead something like

auto obj: TMyObject; // compiler adds the default constructor call and the destructor call in a try/finally block.
  • OK, the language is so good I can't really think of any more so I'm pushing myself here: Builtin types such as string, integer.. or enums would better have methods. ie. i.ToString instead of IntToStr(i).
utku_karatas
+1 i find *with* blocks in delphi very unhelpfull
oɔɯǝɹ
+1  A: 

Ruby:

  • Significant whitespace. For the interpreter, end of line = end of statement, unless it looks like the statement ought to continue (or you explicitly escape the newline).
  • Slow
  • Online documentation not as good as Python's (in defense, Python's is excellent)
  • Did I mention slow?
Joshua Swink
If you want fast Ruby, have you tried maglev? Languages are never slow. Only their implementations can be slow. :)
brian d foy
@brian, most languages have only one implementation. This applied to Ruby until recently, so yes languages *can* be slow.
finnw
+2  A: 

Python:

  1. Global Interpreter Lock - Dealing with this complicates parallel processing.
  2. Lambdas functions are a bit clunky.
  3. No built-in ordered-dictionary type.
  4. Depending on how Python is compiled, it can use either UCS-2 vs UCS-4 for the internal Unicode encoding, many string operators and iterators may have unexpected results for multi-byte characters that exceed the default width. String slicing and iteration depend on the bit width rather than checking and counting characters. (Most other programming languages do similar things as well and have similarly odd behavior with these characters.)
  5. There are inconsistencies surrounding GUI frameworks for Python.
Adam K. Johnson
I don't have many problems with Python. I love the language. But #3 is so needed.
Echo
GIL doesn't complicates parallel processing. Exactly the opposite is true. GIL just restricts your script to one CPU if you don't use `multiprocessing` or similar.
J.F. Sebastian
It's not built in (yet) but the 3.1.1 collections module has the OrderedDict class.
Don O'Donnell
+4  A: 

Python

  • Errors/Exceptions are vague when debugging
  • I don't use it at work
  • using __init__, __repr__, __str__, etc in classes
  • Can't simply compile an executable (.exe or otherwise)
  • Some other thing that I haven't tried doing yet, but I'm sure will bug me

And to all those C-ish language programmers, self makes more sense to me than this, because the object is referring to its self

dragonjujo
You should look at py2exe — http://py2exe.org/ — it allows you to make an executable file with all the required dependencies.
Paul Fisher
py2exe still requires the manipulation of a half-dozen dll's and such. The bottom line is no matter what, there's an installer. This makes python a real hard sell for me for desktop stuff. (still using tcl/tk for this, with starkits)
TokenMacGuy
Why do you want an exe-file ? Java and C# require an installation of runtime files aswell...and noone complains about this. The real problem is that few people have python installed on their machine
smerlin
+1  A: 

Ruby

  1. No type inference
  2. Methods/functions are not first-class objects
  3. Scope of variables is not lexical although scope of block variables is lexical
  4. def inside def
  5. the difference between super and super()
+31  A: 

C++

  • Strings.
    They are not interoperable with platform strings, so you end up using std::vector half of the time. The copy policy (copy on write or deep copy) is not defined, so performance guarantees can not be given for straightforward syntax. Sometimes they rely on STL algorithms that are not very intuitive to use. Too many libraries roll their own which are unfortunately much more comfortable to use. Unless you have to combine them.

  • Variety of string representations
    Now, this is a little bit of a platform problem - but I still hope it would have been better when a less obstinate standard string class would have been available earlier. The following string representations I use frequently:

    • generic LPCTSTR,
    • LPC(W)STR allocated by CoTaskMemAlloc,
    • BSTR, _bstr _t
    • (w)string,
    • CString,
    • std::vector
    • a roll-my-own class (sigh) that adds range checking and basic operations to a (w)char * buffer of known length
  • Build model.
    I am sick to death of all the time spent muddling around with who-includes-what, forward declarations, optimizing precompiled headers and includes to keep at least incremental build times bearable, etc. It was great in the eighties, but now? There are so many hurdles to packing up a piece of code so it can be reused that even moms dog gets bored listening to me.

  • Hard to parse
    This makes external tools especially hard to write, and get right. And today, we C++ guys are lacking mostly in the tool chain. I love my C# reflection and delegates but I can live without them. Without great refactoring, I can't.

  • Threading is too hard
    Language doesn't even recognize it (by now), and the freedoms of the compiler - while great - are to painful.

  • Static and on-demand initialization Technically, I cheat here: this is another puzzle piece in the "wrap up code for reuse": It's a nightmare to get something initialized only when it is needed. The best solution to all other redist problems is throwing everything into headers, this problem says "neeener - you cannot".


Granted, a lot of that is beyond strict language scope, but IMO the entire toolchain needs to be judged and needs to evolve.

peterchen
Looking documentation on the STL is like looking for manuals on how to build a graphics card from scratch.
Aviral Dasgupta
+2  A: 

Scheme:

  • Lack of users/small community
leppie
No dynamic scoping, no bignums or complex numbers in some implementations, non-portable type declarations, no native hash tables.
Daniel Cassidy
+1  A: 

I feel that a favorite language is impossible to choose. Dynamic typing and static typing can't quite be compared, so I'll just list which of which I use

C++:

  • Template metaprogramming syntax is ugly. An implicit ::value would make it much more concise
  • ->. Why can't the compiler figure out that I'm doing a ptr.thing and just do -> for me?
  • I hate whitespace. So the whole vector<vector<int>> has to be vector<vector<int> > makes me get the jitters and then I can't focus whenever I see that line of code and I end up trying to figure out a way to use int[][] or something
  • Macros. I personally love the concept of macros. But with C++, I that the system is a hack
  • I'm a hater of ;

Python:

  • Strings being immutable. Makes it so I can't just do string[4]="b"
  • Lists being implicitly copied by reference. Which leaks into [[0]width]height issues
  • Lack of tail recursion (I had to rig IDLE to not spit out 1000s of error messages whenever I mistyped a recursive function)
  • Dictionaries keys not accepting lists/dicts
  • Lack of deep scopes. When I do a list comprehension, I don't want the variable in it to affect the outer scope
Demur Rumed
alist = list("abc"); alist[4] = "b"; ... in Python.
J.F. Sebastian
[[0]*width for _ in xrange(height)] instead of [[0]*width]*height
J.F. Sebastian
use sys.setrecursionlimit(20) for debugging recursive functions
J.F. Sebastian
How exactly should python make hash a mutable in order to make that dict key? If you want a sequence for the key, use a tuple, or a frozenset.
Gregg Lind
+4  A: 

Python:

  • Slow for number crunching. This wouldn't be much of a problem except it...
  • Doesn't come with an easy way to include C code with your program that automatically gets compiled when imported.
  • We still have to live with stupid integer division rules until py3k takes over.
  • We still have to live with goodies like imap and izip being in a separate module until py3k takes over.
  • We have to do a lot of work before py3k can take over.
Theran
About your 2nd point: use weave, see http://stackoverflow.com/questions/23930/factorial-algorithms-in-different-languages#52946
J.F. Sebastian
You don't need py3k for `from __future__ import division` to work
J.F. Sebastian
Inlining C (although not perfectly), you might want to check out Cython.
Noufal Ibrahim
A: 

The lack of a preprocessor in C#.

I know they left it out because some folks can abuse it, but I think they threw the baby out with the bathwater. Code generation is regarded as a good thing, and in C++ the preprocessor was my first-line code generator.

Mike Dunlavey
-1, it's essentially a bad thing. That another language has it, does not mean it is a good thing to include in C#
oɔɯǝɹ
@oɔɯǝɹ: Bad thing? Who told you that? Professors will say anything. I was one. Just because the inventor of Java thought it was too hard to do and found a way around some of its uses, does not mean it doesn't have some really good uses. One thing these kinds of people don't tell you is how to think for yourself.
Mike Dunlavey
You want C's preprocessor? It's just a simple text replacer. If anything I want real lispy macros like you can find them in Nemerle (a very C#-like language for .net as well).
helium
@helium: no contest. Lisp macros are the best.
Mike Dunlavey
+156  A: 

Five things I hate about Java:

  • No first-class functions.
  • No type inference.
  • Lack of sane defaults in eg graphics.
  • NullPointerException not containing more information about what is null.
  • The proliferation of pointlessly "configurable" frameworks/service provider interfaces/factory classes/dependency injection systems. The configurability is almost never used, DRY is violated egregiously, and code quadruples in size and halves in legibility.

I know, I should check out Scala.

Zarkonnen
Do you have any idea to make Java's NPE contain information about what is null?
grayger
@grayger I wish I had some kind of idea, but I don't. It's admittedly not a trivial problem, as the thing that may be null may not be assigned to any variable.
Zarkonnen
@both: The NPE is shown in the first line of the stack trance. It contains ( most of the time ) class,java file name, and line number like: "at your.faulty.code.Instance( Intance.java:1234 )" Then you just open that file, go to that line and there it is, a variable which has nothing assigned to it.
OscarRyz
@Oscar Reyes - Er, we know that. But there may be multiple variables on that line, and the exception message doesn't tell me which one is null.
Zarkonnen
I was about to say scala as I was reading this.We're learning it as part of a course. Amazing stuff.
Ape-inago
Scala has its warts too. However, it is magnificently better than Java.
wheaties
@Zarkonnen : yeah, but when you know the line, a simple debug can tell you the incriminated variable
Valentin Rocher
@Bishiboosh Yes, if you can replicate the problem, and it's on your own machine so you can attach a debugger, and it's not in a loop that goes around 10000 times...
Zarkonnen
+1 for the proliferation of frameworks etc.
ammoQ
@Valentin, just imagine the fun of the NullPointerException being in a gigantic logfile from a nightly run and you need to figure out what happened... Debugging is not an option.
Thorbjørn Ravn Andersen
If you use Eclipse (or anything similar), you can set a breakpoint at the line, then set breakpoint properties to only stop when the variables are false - otherwise it would continue on. In other words, conditional breaks.
nevets1219
you always trade one evil against another
Chris
type inference... meh.
Longpoke
@grayger, write your code so there is only _one_ candidate in each source line - i.e. _one_ array index - [..] - or _one_ period - foo.bar() - in each line. Then there is no doubt which one caused the NPE.
Thorbjørn Ravn Andersen
@Thorbjørn Ravn Andersen So my method (with 5 parameters) call should be on 5 lines? :p
Jeriho
@Jeriho, naturally not as all your parameters are already calculated and placed in local variables.
Thorbjørn Ravn Andersen
@Thorbjørn Ravn Andersen, I disagree strongly: adding extra variables just to hold a value that's used once add a lot of mental overhead for the reader and make the code more verbose. (Obviously, it's OK to convert code to do this temporarily as a debugging technique.)
Zarkonnen
@Zarkonnen, "conversion of code temporarily as a debugging technique" does not help much when you need to find an issue in production which cannot be reproduced, and you are not allowed to change the code. Feel free to disagree, and come back when you've had the 3 AM call...
Thorbjørn Ravn Andersen
@Thorbjørn Ravn Andersen: "Not allowed to change the code"? I'd run away. Quickly.
configurator
@configurator, we are talking production code here, and the issue happens in production. I don't know about you, but we are simply not allowed to change code in production which has undergone acceptance test etc.
Thorbjørn Ravn Andersen
@Thorbjørn Ravn Andersen: Okay, that makes a bit more sense :) I think you should be allowed to change production code to add logging if that's the only change you make, but I'm not sure how that would be accepted in most places.
configurator
@configurator, in a true emergency anything goes, but then comes the question why the log statements were not in the code in the first place, and why you need to insert them to find out which candidate on the source line were the culprit. In other words, the defensive coding I started mentioning.
Thorbjørn Ravn Andersen
+9  A: 

Python

  • 1-3: There is no one obvious choice of packaging/build/documenting system (such as Perl's cpan, POD or Ruby's gem, rake, rdoc).

  • 4: Python 3.0 is incompatible enough to require two source branches (2.x and 3.x) for every single Python project. But Python 3.0 is not incompatible enough to justify it. Most py3k advantages are too subtle.

  • 5: Jython, IronPython, CPython are incompatible.

J.F. Sebastian
+4  A: 

C++

  • The inconsistencies in the libraries related to char* and std::string. All C++ libs should take std::strings.

  • Characters are not bytes with respect to iostream. I do a lot of byte-oriented work. Having a "byte" type and a "character" type would significantly make it simpler. That, too, would permit scaling to Unicode somewhat easier.

  • Bit operations should be easy on a value. I should be able to access and set the n'th bit of a value without playing AND/OR dancing.

  • The lack of a standardized interface for GUIs. This is where Microsoft has really been able to position themselves well with C#. A standard interface binding that OS makers provide would go really far for my work.

Paul Nathan
+6  A: 

JavaScript

  1. Function object syntax:

    f = new Function( "foo", "bar", "return foo+bar;" );
    

    (It takes n arguments, the first n-1 are arguments for the function, then nth is the actual function, in string form. Which is just silly.)

  2. Function arguments can be repeated.

    f = new Function( "foo", "foo", "return foo;" );
    

    The last repetition is the only one ever used, though:

    f( "bye", "hi" ) // returns "hi"
    f( "hi" ) // returns undefined
    
  3. E4X should just die. My users are always complaining that it doesn't work the way they think it will. Let's face it, when you need a page and a half of psuedocode for a setter, it's time to rethink things.

  4. A standard notion of stdin/stdout/stderr (and files!) would be nice.

  5. null != undefined

    It's irritating to have to handle them both. Sometimes it's useful, but most languages manage to limp along fine with one.

kristina
Actually, null == undefined (loose equality). However, null !== undefined (strict inequality). You only need to handle both if you're testing for strict equality (null === undefined, which is false).
Daniel Cassidy
Also, why would you ever use the function constructor? f = function (foo, bar) { return foo+bar; }
Daniel Cassidy
To add to what Daniel Cassidy said, the Function constructor basically exists to ensure the language is consistent and developed upon its own foundations. You're not meant to use it for anything that isn't dynamically generated (which is probably a bad idea for most purposes anyway).
eyelidlessness
+1 for the fifth. It just makes your life a lot harder.
Şafak Gezer
+51  A: 

Spanish

  1. Irregular verbs. All the common ones are irregular, too. First person of "ir" is "voy"?? That does not follow the "o" "as" "a" "an" "amos" rule at all.

  2. What is up with the subjunctive? "El que tenga sed" - he who is thirsty, hypothetically speaking. Do we really need to conjugate this differently?

  3. Venezuelans. How come Venezuelans are always leaving out the s in the middle of words like "mosca?" Come on people, it's right there in the spelling. I thought your language was phonetic.

  4. Vocabulary. "Peel" and "rind" and "skin" and "husk" and "shell" are all "cascara" to you? Just "the outside part, who cares about the texture or edibility?" Sloppy.

  5. Corazón. OK, so this is not so much linguistic as cultural. Why do all Spanish songs contain the word "corazón" (heart)? I mean seriously, even in Spanish 1101 I could understand half the song lyrics, because I knew this one word. You've got to come up with some new subject matter. Somebody start translating They Might Be Giants into Spanish - they sing about all kinds of weird stuff.

Nathan Long
5. ref. http://blogs.msdn.com/oldnewthing/archive/2005/02/14/372267.aspxcorazon is the english love-dove, the german Herz-Schmerz. 3. Try Argentina...
peterchen
3. Venezuelans aren't the only ones. I've heard Dominicans,Puerto Rican, even a couple of Mexicans greet me with Como eta? For a long while I thought the common spanish exit phrase was No vamo.
Thedric Walker
I was taught Spanish by an Argentinian, so I sound like a challenged Frenchman. And you can't translate They Might Be Giants songs into Spanish - see point 4.
JasonFruit
The common verbs are irregular in almost every languge: Be, Go
chris
On #4 Probably is the kind of spanish speakers you've met. Here are the translations: peel-pellejo,rind-corteza,skin-piel,husk-cascara,shell-caparazón. Spanish also have formal mode (Tú-Ustéd) On #5 I haven't heard a song with the word "Corazón" in ... mmh years!! ( and I'm being honest on this )
OscarRyz
On the others points there is no way to argue ( I have the same complaint je je ) . Still it is good to know Spanish is your favorite language. :) :) Byte!!
OscarRyz
Haha - thanks for chiming in, guys. I actually had to make up complaints for the sake of this joke; every language has its odd bits, but Spanish is a beautiful one.
Nathan Long
Almost all my songs are in Spanish and none of them has the word corazón (which, by the way, has a tilde in the o). I hate that word too.
Eduardo León
Good point Eduardo: accent mark's and ~'s. Another annoying feature in Spanish. Typing those are annoying.
Eric Johnson
'Eating' the syllable-terminating S is common all over Caribbean, most coastal South America, and southern Spain (where it originates); see e.g. http://en.wikipedia.org/wiki/Cuban_Spanish. But personally I think it's kinda neat, and I like to put on a Cuban accent imitation featuring that :)
Jonik
Spanish lacking vocabulary? We have two different verbs for "to be" and two more for "to have"! And verb tenses FTW!
Roberto Bonvallet
@Eduardo, fixed 'corazón'. By the way, ~ is tilde; you meant accent. :-)
Jonik
we have the subjunctive mood in English too. "If he *were* president..." It makes sense to distinguish hypothetical situations from things that actually are true.
Neil G
Name a language that doesn't have irregular common verbs (esp: to be, to go, to do)
Dinah
OK, once again folks - this was a joke answer. I thought it was funny to pick Spanish in a context where "programming language" was clearly implied. I have taken linguistics and I realize that every language has irregularities, and in fact, the most common words are the most irregular (because for rarely-used words we forget the rule and default to something that sounds normal). THIS ANSWER WAS A JOKE. :)
Nathan Long
+1 for TMBG
eyelidlessness
#4: corteza, piel, concha, cáscara, vaina, pellejo, escama, costra, monda... If you don't know the words it doesn't means that they don't exist.
Pedro Ladaria
@chris, that's true, for instance 29 of the 30 most used Dutchs verbs are irregular. Only 'maken' is regular.
tuinstoel
"If he were present" is not in the subjunctive mode, it's in the conditional mode. English doesn't have a subjunctive mode.
René Nyffenegger
that's why there are no programming languages based in Spanish :-p (ok, there are one or two, I can recall "Lexico" XD)
fortran
About #5, may I suggest that you listen to some songs by Sr. Chinarro.
Daniel Daranas
@Rene - I think English may have a subjunctive, or at least used to. "Be he live or be he dead, I'll grind his bones to make my bread." "Be he dead" might be translated "esté muerto"...
Nathan Long
Fortunately English has fewer irregular verbs than Spanish, it lacks the subjunctive mood, and it has no word selections that are different than the first language of learners. Oh, wait...
pc1oad1etter
if you think all those words are cascara and all songs have corazon your problem might not be spanish per se, but venezuelans :) on the other hand all r'n'r songs have the word baby and they still rock.
Lol funny answer just keep up with it and sound all smart pants, @Jonik, it is called tilde. Accent is the stronger intensity on a syllable when pronouncing it, tilde is the actual little mark that goes over any letter to specify it is pronounced different or to distinguish it from others. Of course, since tilde is most commonly used to denote accent, the word accent became a sort of synonym of the word tilde.
Francisco Noriega
There are two kinds of past tenses and that is really bloody and make Español more complex language. They are preterite and imperfect.
Bakhtiyor
+2  A: 

Another vote for C++ here... still my favorite with a few close followers - C and Python. Here's my current hate list in no particular order:

  • Plethora of integer types inherited from C - way too many problems caused by signed vs. unsigned mistakes
  • Copy constructors and assignment operators - why can't the compiler create one from the other automatically?
  • Variable argument madness - va_list just doesn't work with objects and I'm so sick of problems created with sprintf(), snprintf(), vsnprintf(), and all of their relatives.
  • Template implementation is required to be fully visible at compile time - I'm thinking of the lack of "export" implementations or at least usable ones
  • Lack of support for properties - I want to have a read-only member like "a.x" that can be read publicly and only assigned internally. I really hate the "val=obj.getX()" and "obj.setX(val)". I really want properties with access control and a consistent syntax.
D.Shawley
+2  A: 

Lua

I love programming in Lua, but here's what burns me:

  1. There's no way to write down an API in the language---nothing like a C .h file or Java interface
  2. The language has first-class functions but somebody forgot to tell the people who designed the libraries.
  3. The syntax for writing a function is way too heavyweight.
  4. Syntax is split between statements and expressions.
  5. The expression form is impoverished: there's no 'let' form, there's no true conditional expression, ...

Despite all of which I will insist that Lua is fabulously great :-)

Norman Ramsey
+5  A: 

F#

  1. Type inference is limited.

    1. It propagates forward only.

    2. F# won't try to infer an object type based on the methods and properties used: you'll get "lookup of indeterminate object type" errors when it doesn't have a clue.

  2. One cannot mix floats and ints: 1 + 2.3 is a type error.

  3. It's a little awkward to have to create a builder object in order to define a monad or computation expression. In Haskell or Scala, you can define the monad operations directly on the monadic object.

  4. Though the #light syntax is preferred, the indentation rules are sometimes not very intuitive or become cumbersome.

namin
"1 + 2.3 is a type error" -- is F# derived from Fortran?
Windows programmer
No, F# is not derived from Fortran but from OCaml. Like F#, OCaml doesn't automatically convert from ints to floats. Unlike F#, the + operator is not overloaded in OCaml: it's + only for ints and +. for floats.
namin
In Fortran, even though the + operator was overloaded, it was + only for ints and + only for floats, no mixing allowed. (Vendor extensions often allowed it with automatic promotions.)
Windows programmer
Yes, F# is exactly like Fortran in this respect, then.
namin
+3  A: 

Perl 5:

  1. All the really good stuff nowadays seems to require mod_perl, which has low availability everywhere I want to go.
  2. Some really incredible functionality can be encapsulated in modules, but what is under the hood is often fragile or frightening: source filters, typeglobs, whatever Moose is doing...
  3. DateTime is brilliant but still made some very bad design decisions (not returning a stopwatch duration when subtracting two DateTime objects)
  4. Dual-lifed modules in core and on CPAN still cause conflicts
  5. module authors still put interactive stuff in their module configuration scripts so that they can't be automatically installed
skiphoppy
None of that has anything to do with the actual language of Perl :)
brian d foy
Yeah ... Perl's a pretty good language ... :) I'll think and see if I can come up with some more language-specific answers.
skiphoppy
Okay, here's a real one: even when I do a test compile with perl -c, perl still can't tell me that it's going to blow up on an undefined subroutine. That really sucks.
skiphoppy
Why would you want -c to tell you that? Perl's a dynamic language. That means perl can't know everything you are going to do at runtime. That's the point. :)
brian d foy
+5  A: 

Python

  • __init__
  • some libraries are awkward, like smtplib
  • 'self' has to be in the method declaration !!!
  • (for pre-3.0) somewhat poor unicode support
  • lack of inline try-catch
  • no direct reference to "this"/current module (instead have to use sys.modules[__name__])
hasen j
I don't mind `self` in the method, there is no other way to distinguish a method from a function other than context otherwise. I suppose `met` could be made a keyword tho ...
Brendan
+35  A: 

JavaScript:

  • The Object prototype can be modified. Every single object in your program gets new properties, and something probably breaks.

  • All objects are hash maps, but it's difficult to safely use them as such. In particular, if one of your keys happens to be __proto__, you're in trouble.

  • No object closure at function reference time. In fact, no object closure at all -- instead, this is set whenever a function is called with object notation or the new operator. Results in much confusion, particularly when creating event callbacks, because this isn't set to what the programmer expects.

    • Corollary: calling a function without object notation or the new operator results in this being set equal to the global object, resulting in much breakage.
  • Addition operator overloaded to also perform string concatenation, despite the two operations being fundamentally different. Results in pain when a value you expect to be a number is in fact a string.

  • == and != operators perform type coercion. Comparisons between different types involve a list of rules that no mortal can remember in full. This is mitigated by the existence of === and !== operators.

  • Both null and undefined exist, with subtly different, yet redundant meanings. Why?

  • Weird syntax for setting up prototype chains.

  • parseInt(s) expects a C-style number, so treats values with leading zeroes as octal, etc. You can at least parseInt(s, 10) but the default behaviour is confusing.

  • No block scope.

  • Can declare the same variable more than once.

  • Can use a variable without declaring it, in which case it's global and probably breaks your program.

  • with { }.

  • Really difficult to document with JavaDoc like tools.

Daniel Cassidy
For `null` and `undefined`: sometimes you really want to know if the variable has been assigned a value or not. Since null is a value, undefined is the only way to tell. Granted, the only time I've found this useful was for creating getter/setter functions.
Zach
Javascript being my favorite language, this is pretty close to the list I'd write. Exceptions: object closure/this doesn't confuse me; null/undefined doesn't confuse me; don't know what you mean by syntax for setting up prototype chains; block scope with closures (and I believe Mozilla's block scope implementation is syntactic sugar around that); I would note that the use of a variable without declaring -> global is a necessary consequence of the lack of a documented global object (window is DOM, not JS).
eyelidlessness
The lack of object closure and the fact null !== undefined doesn't confuse _me_ either, but they're still design flaws, as well as a plentiful source of confusion with _other_ programmers (whose code I then have to fix). Also I disagree that implicit globals is a _necessary_ consequence -- it's just the solution Netscape chose. One possible (albeit somewhat unpleasant) alternative would be to require programmers to declare all referenced globals in every file (e.g. JSLint requires this). I am easily able to imagine other alternatives.
Daniel Cassidy
I guess I don't see object closure/this and null/undefined as design flaws. I see them as design *choices*, with benefits and drawbacks, and I happen to appreciate the benefits. One thing I'd add about globals is that the language does not offer any way to distinguish between global and local variables of the same name.
eyelidlessness
"if one of your keys happens to be __proto__" -- well, it's a reserved word with special meaning. it's like complaining that you can't use `for` as a variable name.
nickf
@nickf: The key to a hash is a string. Strings can have any value including reserved words. In particular the value `"for"` is valid as a hash key. `__proto__` is not a reserved word. Special string values that do not work as expected when used as hash keys violate reasonable expectations about how associative arrays work in any language. They also violate the EcmaScript spec.
Daniel Cassidy
How about the fact that semicolon isn't needed to terminate statements, except everyone seems to think they are so they use them. Statements are terminated by newline in JavaScript.
Thomas
Thomas: Newline doesn't always end a statement. Therefore sensible coders terminate every statement with a semicolon to make the code more clear.
Daniel Cassidy
Well if you think undefined may be corrupted, you may just declare a new one inside your function...var undefined;But still, you bette use this : function isset(obj) { return typeof obj === 'undefined';}The only way it can fail is by using is on non-declared vars.But in this case, you're able to get window.varname and it works.
xavierm02
`newline may or may not end a statement depending on context` is one in my top 5 list
reinierpost
+1  A: 

I can add another one for Python:

Given a list l = [l1, l2, ..., ln], then repr(l) = [repr(l1), repr(l2), ..., repr(ln)], but str(l) != [str(l1), str(l2), ..., str(ln)] (str(l) = repr(l)). This was decided because there could be obscure entries in the list like l = ["foo], [bar,", "],["] and str(l) would return "[foo], [bar, ], []" which "could confuse users". However, this makes str impossible to use for just dumping data, since list kills the "just dump data in a readable format". Augh!

Tetha
+5  A: 

Not that I hate my mother tongue but a couple of points that humour me.

Spelling! That is, English spelling is revenge for German grammar!

Oh, and different sounds for the same spelling! Cough, bough, through, rough, thorough, thought, and hiccough.

This is why ghoti spells fish!

  • gh from rough
  • o from women
  • ti from nation
Rob Wells
hah that 'ghoti' comment really cracked me up
Andreas Grech
How come you could spell ghoti but you couldn't spell grammar? They didn't teach you spelling in grammar school?
Windows programmer
How do you pronounce hiccough? Isn't the 'ough' the same in hiccough and cough?
wilberforce
On googling - weird! I've always assumed that was some kind of cross between a hiccup and a cough, rather than a legitimate alternative spelling to hiccup. Thanks again StackOverflow!
wilberforce
hicough ahhhhhhh!
eyelidlessness
Don't forget 'though'. Or, if you feel that it has the same terminal vowel sound as 'thorough', then don't forget 'thoroughfare'.
Zac Thompson
+17  A: 

JavaScript

  • Every script is executed in a single global 'namespace'...something which you have to look out for when working with scripts from different sources

  • If a variable is used but hasnt been defined before hand, it is considered a global variable

  • Browser vendors making up standards as they please, making coding for us developers using such a beautiful language harder than it should be

  • Case-Sensitivity - considering that there is no decent IDE for developing js with compile-time checking

  • Workarounds (such as the use of hasOwnProperty method) to perform some, otherwise simple operations.

Andreas Grech
AFAIK, all extensions to the JS *language* (not the DOM) by browser vendors have at least been pushed for standard adoption—even if the standards process has failed to achieve that.hasOwnProperty/workarounds: double-edged sword. To force the "simplicity", we lose a lot of power and flexibility. That complaint always pisses me off. Write your loops right (and check your object members right too)!
eyelidlessness
+6  A: 

ActionScript / AS3

  • No abstract classes
  • No private constructors (so singleton is a hack)
  • No typed arrays before FP10
  • Compile/publish time is ludicrously slow in Flash IDE
  • Performance of built in functions (e.g. Math) is slow

Otherwise it's actually a good language - much better than JavaScript, contrary to popular belief, and a million times better than something like PHP.

Iain
nowai js > as! ;)
eyelidlessness
nah-uh! as3 > js
Iain
nowai !
eyelidlessness
ptthhhhhhhhhhhfff
Iain
No method overloading, doesn't throw exception on division by zero
Amarghosh
1~5 Fantastic Flash code editor.
Eonil
@eyelidlessness: ActionScript3 is *compiled*, has inline XML capabilities (no DOM required), output works on 98% of internet-connected computers (source: Adobe :-) ) and comes with a ton of awesome graphical abilities in the libraries. Iz soo > JS.
JBRWilkinson
+2  A: 

Scheme

  • Lack of static typing
  • No static function overloading (due to the above) leading to long names for field accessors
  • No unified object system
  • Kinda slow
  • Relatively small community
Henk
+1  A: 

MEL (Maya Expression Language):

  • Single dimensions arrays: Forcing me to manually sync two or more lists, or use delimited strings to simulate more complex data structures. Naturally, they're immutable too.
  • Single threaded and slow: Causing the entire Maya application to hang while it completes a task. Bonus points for not being able to kill long operations, instead having to close and re-open Maya.
  • Script sourcing paths aren't recursive: Meaning every directory you want to store scripts in must all be added to the script path.
  • No namespaces: Forcing the inconsistent use of naming conventions to make sure global procedures don't collide.
  • Modal commands: Each command is modal, meaning the Create, Modify, and Query operations are all handled by setting flags. This also forced the developers to cause most of the commands to return arrays
  • Inconsistent command style: Most array commands actually return arrays, but the Tokenize command has to take an array as a reference which it then populates, rather than spitting out an array. This among other inconsistencies.

These and several other reasons are why AutoDesk adopted Python as a secondardy scripting language, which brings up a few other annoying factors:

  • Not all MEL commands are supported: Most are, but every now and then you find yourself having to use the mel() function to execute some arbitrary code. What's worse is all the annoying escaping you have to do to it.
  • Inherited the modal command style: Gotta use the same create=True, query=True, edit=True stuff.
Soviut
+3  A: 

.NET framework (the libraries)

  • Nested types rarely used (e.g. MessageBoxButton should be MessageBox.Button)
  • Mutable structs (Rect, Point)
  • Too much stuff in System namespace
  • Too many different notions of equality (Object.Equals, Object.ReferenceEquals, operator ==, operator !=, IComparable.CompareTo() == 0)
  • Arrays have mutable members but immutable length.

And one more:

  • XmlSerialization doesn't work with immutable types
Jay Bazuzi
As far as equality goes, it could be worse. There is no === operator in C# like some other languages, and Object.ReferenceEquals exists because == can be overridden (it's also nice for null handling).
Matt
One more from me: Everything I want to fix is sealed. HttpContext and System.CodeDom being sealed both drive me absolutely crazy, for two completely different use cases.
Jacob
+28  A: 

C#

  • I wish I could switch() on any type, and that case could be any expression.

  • Can't use object initializer syntax with 'readonly' fields / private set autoprops. Generally, I want language help with making immutable types.

  • Use of {} for namespace and class and method and property/indexer blocks and multi-statement blocks and array initializers. Makes it hard to figure out where you are when they're far apart or mismatched.

  • I hate writing (from x in y ... select).Z(). I don't want to have to fall back to method call syntax because the query syntax is missing something.

  • I want a do clause on query syntax, which is like foreach. But it's not really a query then.

I'm really reaching here. I think C# is fantastic, and it's hard to find much that's broken.

Jay Bazuzi
+1 for switch on any type
oɔɯǝɹ
+1 for switch issues, and {} issues, which I hadn't really thought about until now
Maslow
I hate {}. They look too much like (). Mismatching has never been much of an issue to me because I always put them at the same level unless they are basically one-liners.
Loren Pechtel
+1 for the linq query. Especially when you only want one object returned. Instead of (from x in y select).first(), why not a (from x in y select top 1) or something to fit closer to actual sql syntax.
AdmSteck
if you wish you could switch() on any type, and that case could be any expression check out F# pattern matching. http://www.c-sharpcorner.com/UploadFile/mgold/PatternMatchingFSharp04292008183848PM/PatternMatchingFSharp.aspx
gradbot
+1: because C# belongs on higher place on this list ;-) (Oh, and the LINQ thing)
GvS
+1 for the LINQ method call thing, and I'd give +45 for switch()ing on any type.
drharris
`switch` on any elementary type? `case` as any expression? Sounds like VB.Net is better :) http://msdn.microsoft.com/en-us/library/cy37t14y(VS.71).aspx
MarkJ
The do method is trivial to write in only 2/3 lines of code with an etension method - pretty sure many here have written one themselves...
saret
Surely switching on a type could be better handled with polymorphism?
Stimul8d
@Stimul8d: No, not switching on type, `switch` on any type. Not just `int`, `enum`, `string`.
Jay Bazuzi
+3  A: 

C#

Most of my gripes have to do with assuming C++ conventions were automatically the best choice for C#

  • No statics allowed in Class interfaces. It's still part of the class. Why can't it be part of the interface?! I've had to create such stupid hack-y work-arounds for this.
  • Case sensitivity. I know it would ruin legacy apps at this point but why wasn't case-insensitivity not the rule from the beginning

Bonus one for .NET (not C# specific)

  • Compiler not smart enough. In .NET 3.x, the compiler can figure out "var" at compile time so why not other common optimizations? We all know the string vs. StringBuilder / immutable vs. mutable thing. Why doesn't the compiler convert it for you when in many cases it's obvious that StringBuilder is better than multiple concat.s? i'm sure there are tons of other optimizations that the compiler could do for us by default (with option to overrule) and save us tons of time.
Dinah
Hmmm, a more intelligent compiler would be nice, however i do find the vb.net (background) compiler slightly better than the c# one. I think both language dev teams need to talk to each other more :p
Pondidum
@Andy: I couldn't agree more. It seems to be that they are 2 brilliant teams with different strengths. Combine them and imagine the results!
Dinah
var is not an optimization. String vs. StringBuilder will depend, an it will almost never matter in practice.
erikkallen
+2  A: 

C++:

  • Lack of symbolic import.
  • Over-obsession with C compatibility.
  • Ridiculously complicated preprocessor.
  • Template errors are nearly incomprehensible.
  • No garbage collection.
cgranade
+2  A: 

Javascript;

  1. the dynamic binding of "this" is very confusing and dangerous if you don't know exactly what you're doing.
  2. a function declaration requires the keyword "function". It's not the typing I object to, it's the reading it when I want to do something slightly clever. Hrm now I think of it maybe that's a plus. Discourages me from doing clever things.
  3. As a result of number 2, it's often less code (in terms of characters) to just copy/paste a code segment than to declare it as a function, if it's a fairly short idiom. This unfortunately promotes bad practice, especially in my own code.
  4. Javascript makes motions at being a functional language by having first class functions and closures, but there's no way to verify referential transparency in a function, at either runtime or compile time. Without this, some architectures become either risky or bulky.
  5. Its fantastically bad reputation, and thus my inability to say "I program in javascript" to anyone without being laughed at.
Breton
+1  A: 

C is my favorite but it is also horrible.

  • It has the worst pre-processor ever. Why didn't they use something like m4?
  • The whole header vs source file model is broken. Pascal got it right with units.
  • It needs case ranges in the switch statement.
  • Unions and casts from void* break the type system. This makes garbage collectors impossible.
  • No nested functions. GNU C has this, but it should be standard.
  • No boundary checking for allocated memory. There are tools that discover this but they don't detect errors where a piece of code miscalculates an address and writes to an allocated region which isn't related at all. I hate the whole pointer arithmetic.
  • No bounds checking for arrays.
  • Too many issues regarding portability. Even wchar_t differs across platforms.
Incidentally, GCC supports ranges for cases in the switch statement.
mipadi
+6  A: 

C#

It's a great language, especially with LINQ, but generics support is poor compared to C++. It had so much potential, but the current implementation is only useful for strongly-typed collections and similar trivial things. Some examples of where it falls down:

  • A generic argument cannot be restricted to enums (only classes or structs).
  • A generic argument cannot be a static class. Why? This seems like a completely artifical restriction.
  • You cannot specify that a generic type must have a constructor with a certain signature because you cannot have constructors on interfaces. Why not? It's just another method with the special name ".ctor".
  • Similarly, you cannot specify that a generic type must have a static method, because those also cannot be declared on interface. Something like static T Parse(string s) would often come in useful.
  • The compiler is too eager in prohibiting some casts which the programmer knows would actually work, so they require uglyness like (TheRealType)(object)value
  • No covariance, eg. IList<string> cannot be converted to IList<object>, even though string[] can be converted to object[]. (Microsoft might be fixing this in C# 4.0, though.)
Evgeny
You cannot specify that a generic type must have a constructor...while thats true but you can specify the constructor where you want to use it..class Test<T> where T : New(int) or some thing like that.
Petoj
If you could cast IList<string> to IList<object>, you'd be able to call Add(object) on it and add stuff like integers. That's hardly type safe.
Blindy
You can use where T: Enum to limit the type argument to enum's
oɔɯǝɹ
Nope, you can't. :)
Evgeny
you're right, my bad.
oɔɯǝɹ
> "while thats true but you can specify the constructor where you want to use it.. class Test<T> where T : New(int) or some thing like that"Um.. what?
Fowl
"A generic argument cannot be a static class. Why?" This is for the same reason interfaces can't have static methods. What method could you call on the generic type? Static classes have no instance methods; static methods are non-inheritable. Alternatively, what method in your class could have a static parameter type-- you can't instantiate it, so by definition there can be no instance!
Jacob
+5  A: 

PHP

  1. No constructor overloading
  2. Inconsistent function naming (str_replace, but strtolower)
  3. define() does not replace the global variable literally like C++ does.
  4. When combining with XHTML, statements like the if-statement must start out with no indentation, even though the XHTML is indented if you want to keep the XHTML indentation consistent.

Ex:

You must type:

<?php
if($x == NULL)
{
?>
                     <p><?= $x . ' is null' ?></p>
<?php
}
?>
  1. Error catching is awful

(not sure why SO changed #5 to #1 again but whatever)

Logan Serman
Your example code is pretty shocking there... you break out of the PHP section to output some text, but then you break into PHP again to output a string. I'd suggest `<p><?=$x?> is null</p>`. Also, you can do `<?php if (...) : ?> [HTML] <?php endif; ?>` which is a bit more readable.
DisgruntledGoat
Place a space after escaping out of PHP and the following new line will be honored as legitimate whitespace. So will the space, which is annoying, but it at least lets you keep sane indentation in your templates.
eyelidlessness
+2  A: 

R (R-Project for statistics)

  1. Terrible, terrible string support
  2. Surprisingly difficult for some simple descriptive tasks, like cross-tabulation
  3. Large data set manipulation is done in-memory.
Gregg Lind
+4  A: 

Emacs Lisp

  • There is not enough of a commercial market to be coding in elisp full time
  • GNU Emacs vs XEmacs incompatibilities
  • Nested functions in Scheme are neat, I wish elisp had the concept [1]
  • The do loop or some other facility for simply looping over a list is not standard (granted, you can now mapc with a lambda) [1]
  • There should be a shorthand for (function (lambda (...))) [1]

[1] Of course, one of the beautiful things about Lisp is that it's not hard to fix these things in your own code with a one-liner. Still it irks me that it's not built in.

Good question; I'm a bit embarrassed that I couldn't come up with better things to hate, but honestly, your honor, there is not much to hate.

Regarding the last gripe: you can do `#'(lambda (...))`
Trey Jackson
Come on, no lexical scope? Threading? FFI?Plus XEmacs is basically dead, no need to worry much there.
technomancy
+4  A: 

Self

  • No real code browser, instead hundreds of small windows flying around.
  • Only a research project, not stable enough, no active community.
  • No decently fast version for Linux or Windows. Only Mac OS X.
  • No support of standard keyboard commands.
  • Oh! And the documentation on writing native plugins is so outdated!
nes1983
self? as in .. yourself? or what?
hasen j
Well, Self is a generalized Smalltalk, which is a programming language. It's called Self after the keyword. See http://research.sun.com/self/language.html
nes1983
Woot, you are into self? I am a huge fanboy of self. Unifications of methods and class (to say so), never seen that elsewhere, except BETA.
Adrian
Guess what, so am I.
nes1983
+5  A: 

Python.

Although the weird way python deals with scope has been mentioned, the worst consequence of it, I feel, is that this is valid:

import random

def myFunction():

    if random.choice(True, False):
        myString = "blah blah blah"

    print myString

That is, inside the if block is the same scope as the rest of the function, meaning that variable declaration can occur inside condional branches, and be accessed outside of them. Most languages will either prevent you doing this, or at least offer you some kind of strict mode.

This function will sometimes succeed, and sometimes throw an exception. Although this is a contrived example, this could lead to some subtle problems.

SpoonMeiser
I actually consider this good. Its easy to point at the scope rules of language X and say that its scope rules are insane, but my feeling is that fewer rules to learn is better.
TokenMacGuy
I think generally scope rules for languages are simple and consistent, conditional blocks and loops having their own scope isn't _more_ rules, it's the same rules being applied recursively.
SpoonMeiser
.. and I ususally would set myString to None just before the if anyway, signifying "have not been set yet".
kaleissin
@kaleissin I would too, but it's another step to get safe code that you get for free in other languages.
SpoonMeiser
@SpoonMeiser: How is that another step since you seem to be implying that in other languages `myString` needs to be declared/initialized outside of the `if` scope in order to exist outside of that scope?
Don O'Donnell
Since `myString` is obviously a string, for most use cases it would be safer to initialize it to the nul string, '', rather than `None`.
Don O'Donnell
+4  A: 

C# (well, part of it is the VisualStudio IDE, I guess):

  • No covariance (yet), like Class<D> cannot be used in place of Class<B> even though type D derives from type B.
  • Graphic designers don't support generic based inheritance (or inheritance from abstract classes), even though the inheritance itself works just fine if you work around the designer problems by adding extra inheritance levels just so designers always see concrete non-generic variants of your code.
  • No constructor inheritance
  • No constructors in where clauses of generic type parameters
  • VisualStudio seems to have a tendency to mysteriously check out files (like project files and/or unit test definitions) when opening a solution, even though the files do not seem to actually get altered.

Could be different list if you ask me again tomorrow. Even though the covariance and designer trouble will be in my top 5 until they are solved (with variance added to C# 4.0, this seems to have happened for at least one of them...).

peSHIr
Yeah the mystery checkouts are annoying especially if someone else as an exclusive lock on the file.
mikek3332002
+12  A: 

Lua

I love this language, but there are some things that bug me for years!

  • No (built-in) support of binary operations (as of 5.1, it might come with 5.2).
  • Should have a built-in binary buffer implementation, allowing for example in place long string concatenation.
  • I know it doesn't fit well in the syntax, but sometime I miss longVariableName++ or verboseVariableName += 5.
  • Reference assumes knowledge of C (I have it but it is a minus for newcomers) and defers some help to C reference! And sometime it is too terse.
  • It is starting to have a good deal of libraries, but you have to get them from various places. On the other hand, the download is very small! ;-)
PhiLho
Not sure exactly what you mean with "long string concatenation", but lua has one facility for building strings: pack a table of strings, and make the result with `table.concat(..)`.
kaizer.se
I greatly miss the `continue` statement when I'm using Lua. Pretty much entirely because I find less indentation levels more aesthetically pleasing.
David
@kaizer.se: I know, and use it, but yet I feel there is some waste of memory in this process (can be wrong, though). Anyway, it is really a minor issue... :-)@David: I agree on this one too.
PhiLho
+6  A: 

Lua:

  • I understand the reasons, but seriously. Variables should be local by default, with a global keyword, not vice versa.
  • I'm in general not a huge fan of the do/end style semantics. I much prefer C-style braces.
  • Dynamic typing. I know, some of you go "Huh?" but I've been entirely spoiled by knowing exactly what type of data will be in a given variable. Constant if (type(var) == "string") then stuff() end is a pain.
  • Variables need not be defined before they're used. I would much rather be explicit about what I'm trying to do than risk a typo causing what I like to call "wacky beans".

PHP:

  • Again, dynamic typing.
  • Lack of closures. I know, you can do $function($arg); but that doesn't count.
  • Yet again, variables can be used before being defined. I have a personal policy of always explicitly initializing any variable to a known value before I use it, and I extend that to whatever best practices documents I have any sort of control over.

C/C++:

  • Headers = pain in the neck.
  • No support for closures. (I'm excited for C++0x, which has them.)
  • Static typing. "Wait," you say. "You just said you don't like dynamic typing!" Yes, I did say that. But static typing can be a pain in the butt too. (If given a choice I'd still pick static typing.) Optimally I'd like a language that was statically typed by default, but supported a dynamic type as well. (And I'd also like a pony, and fifty billion dollars, and the world, please.)
Sean Edwards
It sounds like you preffer C# to C++, it supports every one of your dislikes about C++.
Blindy
I don't understand the connection between $function($arg) and closures. $function is a dynamically assigned function name, closures are basically equivalent to block scoping (and usually mistakenly conflated with anonymous functions).
eyelidlessness
I'm sorry, you're right. Closure is the wrong word.
Sean Edwards
Regarding static/dynamic typing, your ideal system seems a description of C#.
luiscubal
luiscubal and Bindy: Funny you say that. Since writing this, I've been using C# a lot more, and it is wonderful.
Sean Edwards
+7  A: 

Ruby:

  1. It's damn slow
  2. The egotistical community
  3. It's not quite smalltalk
  4. Errors when calling methods on nil rather than just returning nil à la Objective C
  5. Non-native threading
brian
+5  A: 

C:

  • Lack of distinction between function pointers (executable) and data pointers (you really don't want to execute this).
  • Extreme unreadability. Making code look like it does what it does is orders of magnitude more difficult than making it do the task in the first place.
  • Lack of clear support for lisp-think. Doing functional things is possible, barely, but it's not clear.
  • Serious inconsistency between libraries about how error codes are returned.
  • Antiquated string handling. The strings aren't strings, they're null-terminated blobs. This is all manner of wince-worthy.

Lisp:

  • () involves hitting the shift key. Every time I'm doing a lot of lisp, I swap it and [].
Kim Reece
That's why Lisp Machines had a the parenthesis on their own keys!
Technical Bard
A: 

Java:

  • No procedural coding, it compiles into procedural code, So let me Use it!
  • No multiple inheritance, trying to do the same thing with 15,000 intefaces suck.
  • Date class, do I need to say more.
  • That I cannot use polymorphism to it full extent. Java will not override with different parameter types being to trigger.
  • I cant think of a fifth reason,if I do i'm come back and edit this post.
WolfmanDragon
A: 

Python

  • slow
  • I finally got used to the print statement, and now there's this print function??? (py3k)
  • never got py2exe or cxFreeze working
  • not standardized (minor nitpicking)
  • recursion depth only 100 (iirc)
Andrew Szeto
The default recursion limit is 1000, try: `sys.getrecursionlimit()`; and you can change it with: `sys.setrecursionlimit()`.
Don O'Donnell
+3  A: 

Perl

I love this language, and I don't want to add things that have already been used, but no one has mentioned this yet, so I'll throw it on the pot. When I used this feature, I found it to be the most horrible experience of my life (and I've worked in assembly language):

  • The write() and format() functions.

They have the single worst, ugliest, most horrifying syntax imaginable, and yet they don't manage to give you any more functionality than you could already achieve with some (infinitely prettier) printf() work. No one should ever try to use those two functions to do any output, simply because of how bad they are.

I'm sure someone will disagree, but when I looked into them, hoping they would solve my problem, I found them to be a "world of pain" (to quote the Big Lebowski), and hope that Perl6 has either done away with them or, better, completely rewritten them to be somewhat more usable and useful.

Chris Lutz
I used them quite a bit when I first learned Perl for automating reports. The brilliant thing about format/write is that you can see what the report will look like (more or less) from the format string. But the mechanism is unwieldy to say the least. There are better solutions these days.
Jon Ericson
format() paginates and applies headers,footers, and page numbering which you'd have to do on your own with printf. format() can also handle line wrapping, etc.
brian d foy
@brian d foy: Good points. I ran out of space to mention an alternative I use that does these things: <http://www.ctan.org/tex-archive/help/Catalogue/entries/perltex.html>. If you need plain text, pdftotex works well.
Jon Ericson
+4  A: 

Oracle SQL

  1. The DUAL table.

  2. Can't GROUP BY an alias.

  3. I can never remember the syntax for analytic functions and so I forget/am too lazy to use them.

  4. Lack of combined LIKE and IN conditional operator. (After 10g there's a REGEX_LIKE operator that could do the trick, though.)

  5. Awkward concatenation syntax.

SQL isn't really my favorite language, but it's one of the top three I use everyday. There are probably more items, but these are the ones at the top of my mind.

I have a whole slew of problems with SQL*PLUS. I wrote a Perl replacement that does what I'd like from the command line and I use sql.el in Emacs for interactive SQL sessions. These tools help me work around my SQL*PLUS issues.


Speaking of which:

Perl

  1. "Only perl can parse Perl." (But this is mostly an issue in syntax highlighting, which I don't prefer to use much anymore for any language.)

  2. I'm sometimes surprised by "the simple (but occasionally surprising) rule...: It looks like a function, therefore it is function, and precedence doesn't matter." (From perlfunc(1))

  3. Dereferencing complex data structures can be confusing at times. I can't decide if this is a true flaw in Perl or just a consequence of having really powerful data structure facilities. Either way, I can normally get it right by taking a few minutes to think about what I'm doing.

  4. No option to cause system calls to raise their errors like the DBI module. (Thanks to brian d foy, I now know the autodie module on CPAN does this, but I'd like it built-in.)

  5. Warnings and strictures not enabled by default in scripts. (The -e option would turn them off for command line use.)

Again, there are bound to be more things, but these are issues I've noticed recently. I'd add the need for =over and =back and the quirky L<...> syntax in POD, but maybe that ought to be a separate list.


Now for the trifecta:

KornShell

  1. Sourcing a file with arguments replaces the values of the parent script's arguments. (Executing . file arg1 puts arg1 in $1.)

  2. ksh is not an ideal interactive shell and defaults to vi key-bindings, rather than emacs. (My solution is to use bash for interactive shells.)

  3. Common utilities (such as grep) are implemented differently across different platforms thereby preventing perfect portability. Some useful commands need to be installed on some platforms and are part of the OS core on others.

  4. The syntax for conditionals is overly heavy. (if [ ... ]; then ... fi)

  5. Although it is Turing Complete, you are eventually going to want to move up to a more expressive language like Perl.

One solution for #4 is to get used to short circuit evaluation:

[ ... ] && ...
Jon Ericson
For 4) in Perl, the pragma is autodie.
brian d foy
One can use the regexp_like operator in Oracle 10 too. Only Regexp_count is a new feature in Oracle 11.
tuinstoel
For Perl: PPI can parse Perl. 'Fatal' and 'autodie' are both core modules, you don't need to install them from CPAN. "use strict" will be enabled by default in 5.12.
Alexandr Ciornii
@Alexander RE: `use strict;` no it won't you have to use 5.012; to get strict in 5.012 (or use strict). which imo is not the same as default.
xenoterracide
+4  A: 
Ellery Newcomer
Associative arrays + array/string literals was finally fixed :-)
Robert Fraser
I don't use D. But `a not_in b` is the same as `not (a in b)` in all the languages which i use that have an 'in' operator.
Wallacoloo
+2  A: 

C

  1. bit fields -- they aren't well specified by the language and how they work is compiler dependent and architecture dependent.
  2. It's often hard to find where a particular symbol is defined in a large mass of code, esp. if that symbol is produced by a macro. Which reminds me...
  3. The preprocessor is a rather ugly hack, amenable to all sorts of abuse.
  4. lack of standard sized integers (remedied by uint*_t lately, but there is lots and lots of old code floating around out there with custom typedefs or #defines for DWORD, WORD, BYTE, etc.)
  5. Lack of something akin to Perl's cpan.org (would love to be wrong about that one.)

Edit: While thinking about a CPAN for C, I thought... what would I call such a thing, and thought of "ccan", and googling it, I came across this: http://ccan.ozlabs.org/

It seems to be as yet in its infancy though.

smcameron
Bit fields are awesome! I don't target multiple compilers and architectures, so I wasn't aware they weren't portable. Understandable, I guess. (And if C didn't have unions I'd say bit fields were just ok.)
Jon Ericson
If only C was still "sexy" - we have the technology to solve all these problems now. But not enough programmers care.
finnw
+2  A: 

I'm going out on a limb since I can't really use it full time, but I'll try anyway!

Perl 6

  1. func("frew") != func ("frew")
    • It annoys me, but there is good reason for it. In Perl 5 print (5 + 6) * 10 still gets me every now and then
  2. It may be easier to parse than Perl 5 in a lot of places, but it still kills my editor sometimes
  3. It still has a lot of the line noise Perl 5 which scares a lot of people. That means it's harder to get them excited etc.
  4. There are no libraries yet.
    • This will be a non issue if Perl 6 does indeed end up supporting Perl 5, but that may be a burden not worth bearing.
  5. There's no REPL, or what rubyists would call irb.
    • A solid interactive Perl 6 with tab completion, color coding, etc, would make using and learning it so much nicer.
  6. Currently the documentation is basically the English spec. Not exactly an easy read.
  7. I know it's a stupid cliche, but it's not out yet!
    • (I am allowed to complain because I am helping :-P)

The first three are the language; the rest aren't really the language itself but the fact that it's not out yet.

Frew
Only two has anything to do with the language. The rest are about the tools, and those things change. So, only three more to go. :)
brian d foy
+3  A: 

C#

  1. The foreach command bombing out when an object in the collection being enumerated changes,
  2. UI controls spitting the dummy because they were accessed on the wrong thread. Surely all the dispatcher.invoke calls can be moved into the CLR plumbing,
  3. PInvoke, marshalling etc.,
  4. The wasted two years I spent learning remoting,
  5. It's not as sexy as Ruby.
sipwiz
+1 - Totally agree with Point 2. It is a real pain and they havent fixed it in WPF (which uses even more threading) I feel your pain with remoting as well :)
Russell
+2  A: 

C

  • It's so flexible and powerful that it's really easy to write really awful, or downright dangerous code (or, if you prefer, "with great power comes great responsibility").
  • '=' for assignment, and '==' for equality; easy to confuse in 'if' statements.
  • The implementation of a number of fundamental parts of the language are compiler-dependent; e.g. the size of the basic types, order of bits in bitfields, padding and byte order in unions.
  • Bitfields aren't parameterisable (i.e. you can array of ints, but you can't have an array of bits).
  • String handling could be improved.
Steve Melnikoff
+11  A: 

I know I'm late to the party, but hate is timeless!

Java

  • Runtime.exec(). So, if I don't manually clear the STDOUT and STDERR buffers, my code will hang? Wow. Die, plz.
  • Null Pointer Exceptions. Responsible programming means I have to treat most objects like they're unexploded bombs, which is kind of a pisser in an object-oriented language. And when the inevitable happens I kinda need to know which object blew up in my face, but Java apparently feels telling me would be cheating.
  • File I/O. Why do I have to jump through this many hoops to read a dang text file? And when copying files, I have to funnel the source file into my code and manually handle the output byte buffer? You're serious?
  • Primitives vs. Primitive Wrappers. Note that Java now has a number of features that allow you to treat primitives and their wrapper objects as interchangeable in some places, but not in others; don't worry, the compiler will let you know which is which. This feels like a hack to work around a fundamentally broketastic design decision. And it is. (EDIT: Actually, the compiler is a much crappier safety net than I thought, particular when doing equality checks. If `a` and `b` are integers, `a == b` is guaranteed to behave as expected only if at least one of them is of type `int`. If they're both type `Integer`, then that statement will do what you think only if the two numbers are between -128 and 127. `Integer a = 1000; Integer b = 1000; return a == b;` will return `false`. Really.)
  • XML. I have this dirt-simple little XML file I need to create and I have to do what?
BlairHippo
-1 java tells you which object it is, it's the one before the . or [] operator in the first line of the stacktrace
flybywire
Uhm, no. It will tell me which LINE it's on. If there's only one object that could be null on that line, that's sufficient. If there are multiple objects on that line that could be null, I have to guess.
BlairHippo
@File IO: Moving files is painful, but Java's IO API is not that bad. I used to hate it, but that's before I learned about encodings. Now, I find it quite handy. Of course, if you just want something like C#'s ReadAllText/ReadAllBytes, it's still inconvenient.
luiscubal
+4  A: 

Java

  1. checked exceptions
  2. type erasure
  3. missing operator overloading (e.g. for BigInteger/BigDecimal)
  4. missing regexp/date/durations/complex literals
  5. poor support for immutability
dfa
+2  A: 

Python

  • No statements in lambdas. GRRRR
  • foo( a for b in c if d ) feels wrong, it surprises me every time I get away with it. Shouldin't it be foo( (a for b in c if d) )?
  • Can i have a dict comprehension?
  • map and filter operators have special syntax in list comprehensions, how about something for reduce? or sort?
  • Just by having a yield statement in it, a function is magically transformed into a generator, and its interface changes completely. Also, that generator cannot do any work before the first next(). at least, not without using a function that returns a generator.

JavaScript

  • No brief syntax for making modular code libraries. You have to call a function that returns a dictionary of public methods. And you have to edit that in (at least) two places every time you alter the interface of your module.
  • Creating closures involves returning it from a function that returns a function from ('sup dog) yo' function. Clutter!
  • for each ( foo ) syntax and behavior feels like an afterthought.
  • Knowing when your code will actually run (and in what order) is more of a dark-art. The only way to get it right for sure is put everything (yes, that too) in one big file. and even then you still need to wait for a document.onload
  • Am i missing something? is there no trivial way to get json serialized values without building them by hand? (yes jQuery can do this, sort of).
TokenMacGuy
dict comprehensions are available in py3k
SilentGhost
@SilentGhost: I did see that, and I'm happy about that and other changes, but until py3k receives widespread acceptance, It's pie in the sky.
TokenMacGuy
dict((f(k), g(k)) for k in keymaker)
Jonas Kölker
+9  A: 

Objective Caml

  1. Non-concurrent garbage collector. I can write multi-threaded programs all day long, but they're only ever going to get one of my eight cores at a time. This makes me sad.

  2. No type classes (or their moral equivalent). There's Furuse-san's GCaml, but it's A) not quite as good as type classes, and B) not in the INRIA distribution.

  3. Badly in need of a Cocoa bridge. Seriously. If I wrote more code with actual interfaces to DNA-based life forms, then I'd probably break down and write the damned thing myself. Why hasn't anybody else done this yet?

  4. Functors are abominable. Seriously, modules ought to be first-class values. There should be only one kind of function. Read Montagu and Rémy before you flame me for this.

  5. Should use LLVM for its back-end. Who do I have to murder to get OCaml to compile for my stupid little ARM6 core?

So yeah, I have some issues. I still love the language to pieces. It's totally awesome.

james woodyatt
I agree 100%. OCaml is a language that I *want* to love so much, but just won't ever use it because of a combination of the factors you list.
Jason Baker
Hey, so it turns out that OCaml-3.12 adds first-class modules. I should edit my original entry to replace item 4 with item 5, and append a new item 5: tagged boxes. Seriously gentlemen, I think the debate is settled now-- the spineless tagless G-machine is the proper way to lower functional languages into stock hardware. Please fix this at the same time you add the LLVM back-end and the concurrent garbage collector. I don't want to lose the 'mutable' keyword by going to Haskell, but the temptation is near overwhelming.
james woodyatt
A: 

Python:

1) It's a scripting language and not a fully compiled one (I'd prefer to be able to compile binaries—I don't care about bytecode). This is very annoying if I have to use very many libraries (i.e. everyone who uses my program has to install all the libraries, and this basically means no normal people will be able to, or have the patience to, properly set it up—unless I do a ton of work that should be unnecessary). I know ways to make binaries, but they don't always work, and I'm guessing they bundle the interpreter in the binaries anyhow (and I don't want that). Now, if I could get a bytecode compiler that would include copies of all the files that I imported (and only those) to be placed in my program's folder, that might be a suitable compromise (then no one would have to download extra libraries and such). It would also be nice if the compiled python files could be compressed into a single file with one specified as the file to run the program before this is done.

2) It seems a bit buggy at times; there have been a few times when code that was supposed to work simply did not (there were no programmer errors), particularly code relating to such as "from moduleX import *", and other import-related issues, as well as some issues pertaining to global and local variables.

3) Maximum recursion depth could be higher. There has been at least one time when I felt that I needed it to go higher.

4) No switch statement (let alone one that allows for numbers, strings and ranges)

5) The newer Python versions seem to be doing away with a lot of useful string operations, and they don't seem to have simple documentation on how to do the same things without them.

6) Forced automatic garbage collection (I'd like to be able to do it manually, although not necessarily forced to do so).

7) No pre-made Timer class without the use of a GUI (well, there might be one, but after all the searching I've done, it's sure not convenient to find! I actually did find something, but it didn't work at all when I tried it.) By a timer, I mean the sort that will execute a specified function every x seconds, with the ability to turn it off when desired, etc.

8) People in the community who give examples rarely tell what modules they imported, and how they imported them.

9) There's not a lot of support for integration with Lua.

10) There doesn't seem to be a way to add an extra function to a particular instance of a class (and not the entire class at large), unless you dynamically add an object variable to that class with the object having the needed function (but still, you have to make another class just for that).

for #10: if c is an instance, and f is a function, then c.newFunction = f.__get__(c) -- Just don't forget that f needs to have 1 extra argument (self)
Wallacoloo
3. sys.setrecursionlimit(limit) -- 4. Thank god for no switch statement! --5. You mean the string module? All those operations are available as methods on string objects. --6. gc.disable() Believe me, you don't want to do it manually. Just one session of debugging gc problems and you'll know what I mean. --7. +1 Though pyqt does this pretty well with QTimer. --8. You must not have been looking on SO. --9. ?? --10. Sounds like a terrible idea, but you can add staticmethods to instances at runtime. For bound methods, this could be done with overridden `__new__`, or `__metaclass__`.
Brendan Abel
You can easily add a method to a class with `Class.method = some_method`. I just tested it with IronPython, and I think it works with CPython as well.
Bastien Léonard
+1 just for point #1
Lo'oris
+6  A: 

C

  1. No parametric polymorphism (i.e. C++ templates). It makes writing reusable data structures and algorithms a pain (and there's hardly any static checking). See for instance the comparator argument to qsort and bsearch: the comparator takes void pointers :(
  2. No library of data structures. I really hate writing my own hash table. I also really hate scouring the web for a library of reusable data structures. Especially if it turns out to be incomplete.
  3. Strings. Inefficient representation, unwieldy if you make it sane, too hard to safely input a string. No standard for snprintf. Too hard to create a format string with sprintf, then use that to create a string with sprintf again, in a safe way.
  4. Only lexical macros. If different compilers expects function annotation in different places, I have to put the same HAS_NO_SIDE_EFFECTS in different places. Why can't I just grab the function, switch over the compiler type, and then insert it at the right place by a macro call?
  5. No portable libraries for common functionality. For sockets and threading, I use SDL---a frigging game library. For .ini-style parsers, the only library I could find which was packaged for ubuntu, I posted on the daily wtf (it calculates an array of hash values, then does a linear scan through it...)

C++

  1. Template syntax is heavy and unweildy. Let's see, for(map<string, int>::const_iterator it = mymap.begin(); it != mymap.end(); ++it).
  2. Design errors in the STL. Should changing allocation strategy for your vector really change its type?
  3. Overly complex type system. Type T1 has a convert-to-T2 method, and T2 has an implicit from-T1 constructor. Which is called? How does overloading, overriding and multiple inheritance interact? Poorly, I guess...
  4. Incredibly long and unwieldy error messages from templates. You know what I mean...
  5. References means you can't see output parameters at call sites. In C, you can guess what foo(bar, &baz) can and can't modify.
Jonas Kölker
"Should changing allocation strategy for your vector really change its type?" -- I can't see how you could use more than one allocation strategy without considering it a different type. The type includes the operations upon it, and the operations must be different if different allocators are used.
Juliano
+1 for C++ point 4. Template error messages make your eyes bleeed.
Steve Claridge
But when you fix all the problems in C, you basically get C++
Calyth
@Calyth: When you fix all the problems in C++, you basically get D. :)
missingfaktor
C 2.,3. and 5. are all handled by Glib pretty well.
Helper Method
Very well written lists +1.
JBRWilkinson
I agree a lot about #5: references bring so little to pointers and they obscure readers, all that for some convenience for not having to use `*` there in front of the name.
progo
+2  A: 

1 - indentation

2 - indentation

3 - indentation

4 - indentation

5 - indentation

I'll let you guess the language. :-)

G B
FORTRAN! I want my eight columns back!
brian d foy
Looks like you're a Java programmer. I'd hate to have to read your Java code if you don't indent it.
Don O'Donnell
Could be any language without enforced indentation and bad coworkers that don't indent their code.
helium
Well, I *work* as a Java programmer, but that doesn't make Java my *favorite* language. I think it's just good enough.
G B
+2  A: 

VBA (because you thought your language was bad)

  1. Whitespace inside a line is rigidly enforced.
  2. Statements just end, and require a " _" to break to the next line, but not every line can be broken.
  3. No ++,--,+=,-= statements. Seriously?
  4. Arrays can begin at any index, not just 0.
  5. Some types (i.e.: fixed-point "Decimal" value) must be subtypes of Variant, and aren't available as their own type.
  6. != and <>.
  7. "=" is used as both comparator and assigning, instead of splitting into "=" and "==".
  8. "Option Explicit".
  9. UI hasn't been updated since 2000.
  10. Office2k7 didn't upgrade to VB.NET
  11. Most object models are non-sensical and overly verbose.
A. Scagnelli
I haven't used VBA much, but the `=` for comparison and assignment sounds horrible! I use == all the time in math expressions, and I'm guessing something like `x=x+(x=0)` is a syntax error (or unpredictable)(Though I'd never actually use *this* example).
Wallacoloo
+1  A: 
Gregory Higley
+2  A: 

c#:

1) static methods must be a member of a class

2) static extension methods can only be added to static classes

3) The implementation of interface functions are not marked with something like 'override' to show they are from a base class or interface (making it hard to ensure you're overriding the method you expect (with correct signature) with just code review).

I just have 3. I guess thats pretty good.

Frank Schwieterman
+3  A: 

First post, so take it easy on me :) ... Awesome community site, btw!

I tried reading all other C# replies just so mine doesn't overlap

C# ... In no particular order:

1) No fallthrough for cases in switch statements. And if there is no fallthrough ... why does one have to explicitly type break; anyway? It's just retarded and confusing since it implies the ability to not have the break;!!!

2) Can't declare a variable with the same name in a child scope, but you can declare a variable by the same name as a class variable? Either allow both or disallow both. Otherwise, it doesn't make sense.

3) No optional/default parameters in functions

4) Exceptions in finally{} should be implicitly caught for every line. Or at least, just the NullReferenceException exception. For instance, after accessing a db, one should always clean up. So, the finally block should look something like this:

finally
{
  if(par1 != null)
    par1.Dispose();
  if(comm != null)
    comm.Dispose();
  if(conn != null)
    conn.Dispose();
}

It would be so much cleaner if it could be written as:

finally
{
    par1.Dispose();
    comm.Dispose();
    conn.Dispose();
}

But, no ... you have to check if you are accessing a null object, otherwise it may throw a NullReferenceException from the finally block .. and who really needs exceptions in the finally block anyway?

5) Generics: you can specify new() to be able to instantiate your generic objects, but that object needs to have a default constructor. Why can't you specify a signature instead so one doesn't need to create empty constructors if it doesn't already have them and just use the constructors it does have.

Rado
The C# switch statement isn't very good but fallthrough isn't the solution. The possibility to comma separate more than one case value is much better.
tuinstoel
There is fallthru in case statements.
Qua
#4: There is `using` block for that.
ssg
#5: Oh this is so annoying! probably a consequence of no static methods in interfaces.
Fowl
+4  A: 

Haskell.

  1. The Prelude is imported by default.
  2. The scope of type classes is universal.
  3. Modules are not first-class.
  4. Types cannot depend on values.
  5. Monad does not unify with Functor.
Apocalisp
What's wrong with default inclusion of Prelude?
kodai
+2  A: 

Python:

I am still a moderate user for python, so my complaints might just well be lock of knowledge or mis-usage. Comments are welcome. I do love this language.

  1. Poor thread support and GIL. If you'd like to take use of multicore platform, most of the python programmers would probably recommend multiprocessing or some sort, don't use threading. It wouldn't give you the performance you are expecting.
  2. property only for instance variable. _class_var = property(classmethod(some_method)) just wouldn't work. How can I get a property wrapped class variable?
  3. no access control. All access controls are syntax mangling. Like private is __private, protect is _protected, etc... And hope that everyone programs python follows the naming convention. Come on, we can do better than that.
  4. I agree the python philosophy of being simple and clear syntax but some simple and clear syntax not being supported seems lock of good judgement, in my opinion. Such as, a++, ++a, a-- and --a, self-de/increment, what's wrong with those? foo = (a > b ? a : b) unary operation, what's wrong with those? (I know py2.6 has something similar introduced, but given the massive support of almost every other language for those simple syntax, why reinventing the wheel? why not just follow the best practice? Shouldn't a good thing just keep in its good "form"?)
  5. Program to interface. Python has no interface or abstract class concept (py3k has something called abc), everything is concrete. Providing an "interface" or "abstract" keyword to build class skeleton and guard class inheritance and extension wouldn't be a bad idea I think. It helps on top-down design. Currently, I just have to fill the each of methods with NotImplementedError, quite a tedious job.
  6. I have to add this. version less than 3.x has str and unicode types. This is a true nightmare. It makes ascii and non-ascii/unicode mixing most likely to fail (bad, bad)

I saw people complains about speed. I don't get that. Its an interpret language, code not compile to machine code until runtime, that's just the nature of it. You can't compare speed from an interpret language to a compiled one. As far as I can see, among the interpret/scripting languages, python isn't slow.

jimx
4. You miss both ++a *and* a--? Heavens... If you get those, may I have inline assembler back please?6. Ah, you're only used to 7-bit ASCII I take it. The mixing of ASCII and unicode *will* bite you sooner or later, badly, and in a way hard to debug. Explicit is very much better than implicit in this case.
kaleissin
agreed. that's why I said its a nightmare because you can't 100% sure when you are dealing with pure ascii and when you are dealing with unicode. Luckly is that py3k treats them all unicodes with utf-8 encoding as default (instead of ascii). And that, we are all talking about just unicodes...++/-- do not seem to be very evil to me.. :) short than i += 1. the thing is i += 1 is a statement which can't be used in expression, where ++/-- is expression.
jimx
for #4: foo = a if a>b else b--That probably looks better when surrounded by parenthesis. I like that syntax because you can read it as "foo equals a if a is greater than b, else b", foo = (a > b ? a : b) is harder to decipher.
Wallacoloo
You can create class properties, but it can be non intuitive. See my question here: http://stackoverflow.com/questions/2173206/is-there-any-way-to-create-a-class-property-in-python
Jason Baker
The problem is that ++ and -- can be used in expressions like `a=b*++a+c[a++]`, which IMO is hard to predict the resulting value of a. I have no problem with just `a++` (even though you're only saving 1 character). But if it was chosen to allow the later and not the former, it could be more confusing to programmers with background knowledge of a language that has full support for pre/post increment.
Wallacoloo
+9  A: 

My own top-5 "what do I really hate in c++":

[5] Automatic generation of constructors, destructor and assignment operator. Man, whenever I don't declare something in the class, it means I DON'T NEED IT, not I FORGOT IT. Do you, compilers, hear me?!

[4] Template syntax. Oh, do I really need to type all these "<" and ">", whenever I decide to extract definitions from the class body?

[3] Strings. Jeez, I am fed up with "const char*", I have to handle NULL situations, I have to waste O(N) to get its length, I have to allocate a buffer for concat operations.

[2] Macroprocessing. Whenever I do not understand, what is going on with my compiler, I start looking for a macro.

[1] Operator overloading. I see the code "A + B * C" and I cannot say a word what this code is about, until I see the actual types of A, B and C.

SadSido
+1 for [1] Lots of people moan that Java should have operator overloading, clearly they never coded much in C++
Steve Claridge
+1 for all the items in the list (I wish I could give you +1 for *each* item of the list ;-)Re operator overloading, I'm going to illustrate that someday, by writing a very special class where all possible operators will be overloaded, and things like +, += or = will have completely incomprehensible meanings and unrelated to their semantics in C.
Arthur Reutenauer
Re: operator overloading: it won't be the fault of the language but of the programmers if they write strange overloaded operators that don't do what they convey. I like the flexibility coming of operator overloading.
MP24
@SteveClaridge operator overloading isn't difficult to handle when you have managed memory and you only pass reference the way Java does. The reason it's a disaster in C++ is because you can get values or references and you have to manage the memory yourself.
TM
+1 for Automatic Constructor creation
Viktor Sehr
Constructors and destructors are generated not because you forgot them, but because no matter what the compiler needs them to be there. Construction so that the compiler can call the constructors of member variables, and destructors likewise. - there's no other sensible place to call them.
blwy10
to blwy10: I would like to see an error, if I try to create an object, but no constructors were defined. I don't want to receive object with uninitialized members instead.
SadSido
re: [3] You're in luck, there are at least two dozen other implementations of string for you to choose from!
Jacob
Re: operator overloading. 'A.Add(B).Mult(C)' doesn't tell me any more then 'A+B*C'. Either way I have to either look up the types and functions, or trust that the programmer gave things sane names. And 'A.Add(B).Mult(C)' is ugly and wordy.
Matthew Scouten
If (3) is biting you, you are doing something wrong. Well written C++ code uses std::string.
Billy ONeal
+84  A: 
+1, even though everything should be an object. ;)
eyelidlessness
Languages aren't perfect, and if you make a list of things you hate about a language, you may get some interesting comments and ideas. First, it allows others to give you solutions which you didn't know existed (look through the posts, you will see a few things were learned). Second, it constitutes user feedback for the language developers (wouldn't you be interested if your users came up with a list of the 5 things they hate the most about your software?), and third, it's kinda interesting to ponder on the flaws of your tools.
Sylverdrag
+1, amazing post
the_drow
you just made my day.
MathGladiator
I certainly agree with your #1. On the other screen as I write this I have 11 "objects" which contain nothing but data and can't logically contain anything else. They only exist to organize fields in a parent object so I don't end up with an object containing 2 pages worth of fields.
Loren Pechtel
If you view it at that level not only break and continue are gotos, but loops are gotos (jump the begin of the loop if the condition is met), if is goto (if the condition is not met jump over the block, function calls are goto (jump to the begin of the function and later jump back), ...
helium
@helium If you think about it, even Exceptions can be considered some form of goto. @Znr ++upvote Best post in weeks.
Helper Method
Creating executable files from source code "has no use"? What?
detly
Perl could create an executable from a Perl file since the late '80's. One thing to distribute is useful. No need to a) install Perl, b) install components of program, c) maybe write a script to set paths and execute it all... Yeah, really useless.
xcramps
I agree with #1, but not the example given. You should always target as close to vanilla Windows as possible with software like this.
MiffTheFox
I agree with you, but I just had to snarkily point out "Because your not perfect, and you make mistakes." My not perfect WHAT? B-)
Brian Postow
crgwbr
Exactly. Try distributing a wxPython program to someone who wants an easy install. Gauntlet of pain.
detly
But, if you can't create .exe files from the source, windows users won't be able to run it. ;)
Evan Plaice
@Sylverdrag Not to mention these lists can help programmers decide which programming language IS appropriate by the limitations of each (intended limitations or otherwise).
Dan
Nice list, but everybody should understand by now *why* `for` loops and `goto` are bad.
reinierpost
"Adding a bunch of flare to something which doesn't add functionality or support just wears down the keyboard faster." What popular languages actually do this? I can only think of Perl and C#... Others are drawing from new paradigms to help create *better* code (not fancier). @MiffTheFox @delty, sure you can create an exe, but then again you can create a one line batch file to launch the app with the proper lang runtime.. Ideally, the OS should manage the entire packaging (what Linux distros do, although still too ghetto)
Longpoke
And what *aren't* objects? Everything down to the atom and whatever is under that is an object, likewise for conceptual objects. Globals **are** bad (or any state for that matter). They can be convenient in certain situations, but they should be used conservatively. Every time you add more state, your program gains (exponentially) more bugs. Continue is a goto? Maybe, but then every statement could be a goto to the next statement. I've never personally seen a use for goto in any high level language (and I'm mainly an assembly guy...)
Longpoke
Maybe in PHP where a ton of functions return error values instead of raise exceptions, goto may be useful, but not in any good high level language.
Longpoke
@Longpoke - So, how can a one-line batch file detect the presence of a certain version of .NET/Java/whatever your project uses, run the code if the runtime is present, or else display a helpful message to the user prompting to install the runtime?
MiffTheFox
@Longpoke - I'm sorry, that comment was so old I forgot what it relates to. :O
MiffTheFox
@MiffTheFox: eh you're right, you can't in Windows, which is a major flaw, you can always double click the jar to run it though, as jdk registers that on windows, although this is also bad because it makes the code have to manage its dependencies. Depending on old versions of Java is bad and insecure though, dunno about .NET as there is 1/2/3/4... Then again, most devs don't care about security so they'll just force the user to install a bunch of useless native crap and ship with some old JRE.
Longpoke
Well written, but a terrible message. Making up excuses.
reinierpost
+6  A: 

Haskell:

  • Space leaks - a price paid for laziness by default - maybe too high a price?
  • Even pure functions like head and tail can invoke error and boot you out to IO.
  • fail from Monad - bring back MonadZero.
  • The Num class - (+) should have been in AdditiveGroup or similar.
  • That Monad is not an Applicative.
Paul Delhanty
+2  A: 

C++ lack of good refactoring tools, lack of checked exceptions

Java lack of templates, lack of const keyword

quant_dev
You don't have `const` keyword in Java, but you can acomplish the same just declaring a method, a variable, or even a Class! using `final` keyword
unkiwii
Not true. "final" for methods and classes has different meaning than "final" for variables. For variables, "final" is not the same as "const" in C++, see http://stackoverflow.com/questions/502430/passing-const-variable-to-method-in-java/502467#502467 There is simply no "const correctness" in Java, you can declare an array as "final" and modify its contents.
quant_dev
+3  A: 

Objective-C / Cocoa / Cocoa Touch:

  • Lack of namespaces
  • Difficulty using primitive values with any of the interesting and powerful techniques of Cocoa, e.g., distributed objects, notifications, KVO
  • Inconsistency with the use of the shortcut dot syntax for accessing properties, often having to use the full length accessors
  • No GC on the iPhone, and generally GC came rather late to an otherwise highly dynamic language
  • Inconsistent library support, at least in Cocoa Touch; some very basic things have only recently gotten high level support, e.g., audio handling.
  • Lack of blocks!
mythogen
Blocks are in the latest version(but not on iPhone yet, I believe). Pretty nifty implementation, too.
Mark Bessey
If you want a really dynamic language similar to Objective-C you should try Smalltalk.
Amuck
+2  A: 

PHP

  • Almost every standard function is in the global scope
  • Inconsistent function argument order
  • Inconsistent function naming
  • Case insensitive functions
  • Script may behave differently depending on the php.ini file
  • Being able to use undefined variables
  • In some cases having to assign a result to a variable before it can be used in a function

And far more subjectively:

  • Dynamic Typing
Yacoby
The purpose of config files is to change the behavior. Why is that a problem? And can you give more details about the "Terrible error catching" please?
Techpriester
@Tech Regarding the config files, I meant the php.ini file. Things like magic quotes make it harder to write code that works everywhere. I can't remember what I meant when I said "Terrible error catching" (Hence I have removed it from the answer)
Yacoby
+3  A: 

Common Lisp

  • Lack of standard libraries for more modern features (sockets, threads, ...)
  • Could use a standardized UI that maps to the native windowing system
  • Scheme's ability to assign a lambda expression to a variable and use the variable directly as a function call looks neater that APPLY for FUNCALL. Side effect of having multiple name spaces, I guess
  • Standardized source-level packaging system for libraries so that they could be easily used from multiple implementations

I wonder what a strongly-typed lisp would be like

Gautham Ganapathy
I assume by "strongly-typed" you mean strongly *statically* typed (most Lisps avoid implicit coercion and such). It would probably look a lot like PLT's typed Scheme.
Zak
yes, sorry about that!i had been looking into haskell, and really liked it's type system (well, whatever i understood so far). i'll take a look at typed scheme, thanks for the tip
Gautham Ganapathy
> I wonder what a strongly-typed lisp would be likeYou mean like Qi?
technomancy
+3  A: 

Haskell (with all GHC extensions, not just the base Haskell'98 spec).

There's exactly one thing that I hate about it: it's not mainstream.

Pavel Minaev
+1  A: 

C#

1) Lack of practical ability to write generics for value types. For example, any idiot (well most idiots) can write a routine that calculates the standard deviation of a list of int, float, double, etc in C++, it is straightforward to write, easy to read and performs as fast non-generic code. I think if you can write something in C# that is close to hitting any one of these 3 without being ridiculous on the other 2, you are a really great programmer.

2) Covariance and contra variance, although this is being added to 4.

3) Extremely poor documentation of LINQ (alright, not really part of the language).

4) Trying to use foreach/iterators when I want to do the same thing every time except something slightly different the last time (such as concatate a bunch of strings with commas between them and the word and between the last two). If I write it with an IEnumerable, it is hard to write and read, and with a for (int i=0 i < ...) it isn't much better and it is less efficient.

5) I know I am going to get complaints about this, but lack of checked exceptions. This does not need to be implemented the way it is in java (The framework developers do make some very good points on why they didn't do this), but I would be happy with a compiler warning users who don't like checked exceptions can turn off.

Brad
If you want to concatenate strings with commas do it differently in the first iteration (you prepend the strings in all but the first iteration with a comma).That's IMO a lot easier than doing it different in the last iteration.
helium
+4  A: 

I can't believe it, my favorite Python pet peeves still haven't been mentioned:

  1. (Prior to 3.x) Relative imports look like absolute imports.

    import foo
    

    Does this import foo from the directory you're standing in or from the sys.path?

  2. Zipped eggs, leading to a sys.path full of shite. Zipped eggs means you can't use grep and find (to among other things debug problem 1)! Fortunately, there's pip. Use pip.
  3. Some of the included batteries are unpythonic. It grates to use them.
  4. Might be the fault of distro's and packagers, but still: sourcefile-encoding set to fscking ASCII on install/compile. WTF? Means I have to put the "# coding: UTF-8"-stuff in every single .py I ever make.

Py3k fixes several of my other pet peeves, by for instance insisting that strings are unicode and that 8-bit-stuff are treated differently...

kaleissin
Source encoding used to default to `latin-1`, then to `ascii` after Python 2.3 or 2.4, and now to `UTF-8` in Python 3!
kaizer.se
A: 

jQuery

  1. lack of compatibility across browsers (hey it looks great...try it in Internet Explorer 6...oops)
  2. falling into the trap of using too much jQuery in especially dynamic sites (works great for static sites - dynamic sites start becoming very complex to pull off).
  3. heaby reliance on getting your CSS right (i know this isn't a big thing...but it's a pet peeve - I suck at UIs :))
  4. never really being sure of what you're doing wrong (and you're usually getting something wrong).
  5. spending hours on the jQuery site trying to get the best plugin :P
Kamal
JQuery is not an language.
Maiku Mori
Browser compatibility is usually really good in jQuery. We should be happy that ANYTHING AT ALL works in IE6 :) And why do you think dynamic sites are a problem for jQuery?
Techpriester
A: 

C#

5. The null-coalescing operator

The ?? operator allows you to write:

x = y ?? z;

instead of:

x = (y == null) ? y : z;

I like this operator, but I want another one:

x = y ??? y.foo() : z.foo();

instead of

x = (y == null) ? y.foo() : z.foo();

I use this kind of thing all the time, and I find it annoying to type the == null part.


4. Equals should have better support

I have having to start every Equals(object obj) method with: MyClass other = obj as MyClass; if (other == null) return false;

You should only have to write:

public override bool Equals(MyClass other) {...}

And the language should take care of providing the Equals(object obj) method.
NOTE: other should be guaranteed to not be null.


3. Cannot use ternary operator with different types

This doesn't compile, and I think it should!

string foo = "hello";
int bar = 4;
object baz = foo == null ? foo : bar;


2. Lack of namespace private

I like the internal protection, but I wish there was a protection which would only allow access from within the same exact namespace. This would be nice to better control access in large class libraries.


1. No multiple inheritance

I really only use implementation (class) inheritance for default implementations of an interface, but there are plenty of times when I want to do just that.

tster
Your first one is actually easy to implement with the null coalesce operator:x = (y ?? z).foo();I also tend to do this alot with ToString and an empty string:x = (y ?? "").ToString()
Pete McKinney
Nice idea! (any more)
tster
+2  A: 

Quenya

• Community is too small. It's next to impossible to get a good language-immersion program going when there's no easy to find another speaker nearby.
• Irregular verbs. Yes, I know English and Spanish mentioned them, too, but Quenya was invented. Why does there still need to be irregular verbs?
• No Unicode support. I have to have three different Tengwar fonts on my computer before I can read most messages, and several of them are poorly kerned. This wouldn't really be a huge issue given the existence of a Romanized transcription, but Tengwar is so beautiful, you don't not want to use it.
• Not all concepts can be easily referenced in Quenya, leading to annoying circumlocutions, or resorting to Sindarin, Númenórean, or (Manwë save me) Klingon to get my point across.

Eldalië
+14  A: 

Chinese (as written language)

Inspired by hilarious (yet to the fact) answer on English. I feel like posting something not as original as fun facts.

  • There are over 47,000 characters vary from 1 to 64 strokes per character.
  • Characters/words can have multiple pronunciations, meanings and written form.
  • Characters/words can be region specified (eg/ Hong Kong, Taiwan), disregard of Traditional/Simplified system. Some only exists/understandable in certain region(s).
  • Swear words are not swear words if they are not in context, therefore it is difficult to screen rude posts/comments. (eg/ character for 'f*k' can also interpret as 'do')
  • Confusion caused by Traditional-Chinese system vesus Simplified-Chinese system doubles the complexity of already-complex language.
rockacola
..and the same script is also used by Japanese Kanji.
JBRWilkinson
how about "Not phonetic!!!!!" So if you find a character and want to know how to pronounce it, there's no way you will ever know unless you ask someone or look it up in the dictionary.
Jacob
@JBRWilkinson: Japaneses writing system is another worth-mention due to its combination of 3 categories of character [email protected]: Kids grow up with phonetic character system like Korean or Japanese would be consider as `lucky`.
rockacola
+3  A: 

My favourite is really C#, but there are already a ton of answers for C#, so I'll go with my next "favourite":

T-SQL

  1. The GO statement, and the fact that you need it for all manner of DDL/DML scripting, and the fact that it also breaks transaction semantics, making it far more difficult than it needs to be to write an atomic script, which you really need to have in order to upgrade a production database.
  2. Inconsistent semicolon semantics. 99% of the syntax doesn't need it, MERGE statement has to end with it, WITH statement has to begin with it... make up your mind!
  3. WITH CHECK CHECK / WITH NOCHECK CHECK. Uuuu-gly.
  4. Optional parameters in UDFs aren't really optional. Caller must specify DEFAULT (and don't even try using NULL instead). Compare to SPs where they are truly optional.
  5. "...may cause cycles or multiple cascade paths." HATE HATE HATE HATE HATE HATE HATE HATE HATE HATE HATE
Aaronaught
+3  A: 

TCL

This is my absolute favourite language for doing almost everything. Over the years it has evolved (slowly, very slowly) to address most of the things that annoy me. And the language is so flexible it's easy to implement syntax sugar to cover things that still annoy me. But there are things about the language that can't easily be changed just breaks its Zen:

  • Arrays (of the associative kind, what Perl calls hash) don't have proper value semantics. This makes them awkward to pass to and return from functions. Also, this means that they can't be nested. For this reason dicts (dictionaries) were invented but too late, the nice array access syntax:

    $array($foo)

    is now forever taken by stupid arrays for backwards compatibility. We're now stuck with:

    dict get $dict $foo

    which is much more verbose and to me feels less readable.

  • No real closures. Though it can be emulated somewhat by globals or namespaces but that defeats the reason for closures in the first place. Although, I can't really see for now how closures can be implemented in a pure value semantics system.

  • Teacup is hard to use and is not at all intuitive compared to all other repository tool out there. This is more ActiveState's fault than tcl-core and doesn't really break tcl's Zen when coding but it is still very annoying.

slebetman
I agree on the first two points. I've got some plans for where to evolve arrays that give them more purpose, I've seen some ideas for syntax for dicts (though I'm not sure that I agree with all of them) and I would like closures and have ideas there (the main problems are how to do introspection and how to pass them through lambda values given our strict value requirements). And I also really want both true GC and UDP support. (Teacup is Someone Else's Problem.)
Donal Fellows
+3  A: 

C++

(Except for lambda functions, I've avoided things that will be available in Cpp0X)

  • Doesn't force the use of "this" to access member variables, ::GlobalFunction to access the global namespace.
  • Everything in (to be more specific, the lack of lambda functions in algorithms, will be fixed in 0x thou)
  • Taking care of dependencies/header and source files
  • Stupid names on basic data types (should be named uint8, int16 etc)
  • The const_cast functionality
Viktor Sehr
+1  A: 

C#

The number one all time pet hate of C# has to be:

(1) Events have strong references to all listeners thus preventing garbage collection of anything that listens to an event. If you want to see the problems this has caused just search on the net for all the people who have tried to solve the problem by creating some sort of "weak referenced event handler".

(2) Needing to check if an event equals null before you call it seems like something that should be handled by the language.

(3) The XML serializer has no way of reading/writing comments in an XML file. Not great in an environment where XML files are modified both by hand and by the tool written in C#. Can be worked around by just using a raw XmlDocument, but would be nicer to be able to abstract that away to a class.

(4) The build process doesn't let you directly access things like xsd files, instead you need an intermediate step where you create a C# partial class. This also causes issues with XAML files where you need to rebuild twice sometimes to get changes to flow through properly.

(5) No support for CPU intrinsics like MMX and SSE 1,2,3,4 and thus these valuable CPU features go unutilised when running C# apps.

Others that didn't make my top 5:

(6) Can't tag fields as properties, all properties have to be explicitly implemented from the get go:

E.g. currently has:

public class MyClass {
    private int someInt;

    public int SomeInt {
        get {
                return someInt;
        }
        set {
                someInt = value;
        }
    }
}

Would like

public class MyClass {
    [IsProperty(public, get, set)]
    private int someInt;
}

(7) No support for multiple return values e.g:

public int, string, double MyFunction()
{
    ....
    return x,y,z;
}


public void TestMyFunction()
{
    int x, string y, double z = MyFunction();
}

(8) No support for covariant return types

I have some gripes about the generics implementation, but I'll cut it there. I think C# is a great language for doing all the GUI, networking and configuration plumbing and is my number one language for getting things up and going quickly in a way that can be supported in the long run.

John Stewien
A: 

VB.NET

  • Weakly typed by default (Option Strict fixes this, but it's not on by default)
  • Does not require parentheses on methods (myFunction instead of myFunction() and so on)
  • Does use parentheses for array definition/use (myArray(12) instead of myArray[12])
  • Does not support direct incrementation (i++)
  • Does support legacy On Error keywords and the whole VB6-Namespace
Bobby
+1  A: 

Python

Ones that I just don't understand ...

  • math.ceil() and math.floor() return floats, not integers (probably to avoid an integer overflow in the underlying C function - but why not cast to a Python long?)
  • len() is a function not a method
  • reload() is very limited, does not reload a module 9 times out of 10, only reloads an imported label if it is a module - i.e. cannot do from bar import foo; reload(foo) if foo is not itself a module
  • Mutable default arguments have a single reference (why not a new instance each function call?!)
  • All these underscored variables - if they are so private, how come we see inbuilt ones so much in code? Get a namespace!

Ones that make sense based on the implementation but are annoying ...

  • array.sort() does not return an array (I suppose it happens in-place)
  • List/generator comprehensions don't define a new scope (Is just syntactic sugar for a for loop, right?)

and a couple that are fixed in Python 3

  • Integer division by default
  • global can only refer to the top level namespace
Brendan
For #2, I believe len(instance) just calls the method instance.__len__()
Wallacoloo
@wallacoloo Sure but in terms of syntactic sugar, `__len__()` should just be aliased to `len()`
Brendan
I completely agree with you. I'm just saying that if you ever truly need it as a method, you can use it as a method.
Wallacoloo
I don't really know too much python but I imagine floor and ceil return floats for the same reason C# does. `Math.Floor(double.MaxValue) > int.MaxValue` returns true in C#.
Robert Davis
In C#, that would be the case, in C too (which CPython is written in) however Python int's are automatically cast to arbitrary length 'longs' when the int limit is reached - this effectively means a Python programmer almost never has to think about integer overflow. It seems to me that the CPython is built on the C implementation of `floor` and `ceil` and the step of converting to appropriate Python variables was not implemented.
Brendan
+1 for #4, my biggest annoyance with Python.
missingfaktor
the `math` module is just a very thin shell over C's math.h.
kaizer.se
+1  A: 

Scala:

  • standard library weirdnesses: it does not always show best practices, and is way underdocumented
  • the hard-coded FunctionX, TupleX classes
  • lack of properties: getters and setters are separate, which violates DRY, and makes things such as FRP nearly impossible
  • need of = _ to initialize properties
thSoft
"the hard-coded FunctionX, TupleX classes" -- What other alternative did they have?
missingfaktor
Nothing. Just it would be elegant in a parametric way.
thSoft
+2  A: 
Robert Davis
You mean *nominative not structural* instead of *declarative*.
Dario
+1  A: 

My 5 for Delphi:

  1. Procedures and functions aren't necessarily distinguished from variables if not parameterized (eg, I can have statement such as x := GetPositionOnScreen; instead of x := GetPositionOnScreen();)
  2. Try/Finally and Try/Except needs to be nested (stated once before, but it's still one of mine as well).
  3. Not case sensitive.
  4. Can have a multiple objects (functions, global variables, local variables) named the same and Delphi will happily try to figure out what you mean. names should be unique.
  5. Odd if condition rules. a single conditional check doesn't require a () around it, but if I do multiple checks, I need a () around each one, and sometimes multiple nested sets for bigger checks.
  6. No inherited includes. If I need to reference functionality from the Windows unit in a base and an inherited form, I have to include Windows in both.
Tom
+1  A: 

HyperTalk:

  • Died long long ago
  • No simple assignment (you can't just say a := 3, you have to say put 3 into a
  • No nested functions
  • No real data structures, just strings. To make "lists", you delimit items with the itemDelimiter and escape them manually. You can also get lines and words like get word 2 of line 5 of txt

As an aside, I think one of the coolest features unique to HyperTalk is the special it variable:

ask "How many years old are you?"
answer "You are " & it*12 & " months old."
Joey Adams
A: 

Things I hate about Python:

  • there's no compiler
  • it's not taken seriously

Things that annoy me about Python:

  • (self,
  • no private
  • breaking compatibility


Five things I hate about PHP:

  • "working as intended" when it's plainly a bug
  • no goto
  • bugged references (foreach $arr => &$val ... foreach $arr => $val)
  • no multiple inheritance
  • no compiler that really works without having to sacrifice a lamb to a dark god
Lo'oris
The goto thing got me amazed. Can you explain why not having it is a bad thing?
egarcia
`goto` is sometimes useful. Many people don't know how to use it, use it in a bad manner, abuse it, or blindly teach other people that `goto` is the Dark Lord Satan. It isn't. It's just a tool, which you have to know to use properly, that's all. Anti-goto crusaders are just retarded people that don't know how to do something hence want nobody to be able to do it.
Lo'oris
The goto operator is available as of PHP 5.3. http://php.net/manual/en/control-structures.goto.php
nico
Techpriester
Lo'oris
A: 

Python

  • No namespaces.
  • Pseudo-private attributes / name mangling (mostly with getattr).
  • Filepath manipulation is spread across multiple modules. Stringing together os.path calls is ugly, difficult to read, and in most cases, violates DRY. Common filepath operations still don't have convenience functions, like getting a list of files in a dir. The path - type module to fix this was rejected.

([f for f in os.listdir('/file/path') if os.path.isfile(os.path.join('/file/path', f))])

  • Python documentation (I'm very, very, very grateful there is documentation at all, and that it is formatted so nicely, but I hate wading through 5000 lines of quick-start usage examples to find the individual function documentation for particular modules (I'm looking at you optparse and logging)). Built-in types are documented piecemeal in nearly 10 different places.
Brendan Abel
A: 

Lua

  • If you do foo.bar(1,2) then 'self' is nil inside the bar method. You must remember to do foo:bar(1,2) instead. I'd rather have that switched ('self' should be defined by default unless you use the ':' operator, or you call a function that isn't a method).
  • Variables are global by default. I'd rather ditch the 'local' keyword and have a 'global' one instead.
  • Undeclared variables are assigned the nil. I'd rather receive an error message. You can sidestep this by manipulating the global env's metatable, but I'd rather have it implemented by default and be able to deactivate it.
  • Multiple returned values on parameters are not handled very nicely. Say you have a function foo() that returns 1,2,3 (three values) and bar() returns 4,5 (two values). If you do print(foo(),bar()) you will get "1,4,5" ... only the "last" tuple is expanded on calls.
  • The # (table length) operator only works in tables indexed with continuous integers. If your table isn't like that and you want to know how many elements does it have, you need to either parse it with a loop, or update a counter each time you insert/remove an element from it.
egarcia
You can use an environment-based function to dodge #2 by creating a function that will automatically set all new files to their own env. This doubles as a file-cache.I'm surprised you didn't add "incredibly poor CAPI" to the list.
DeadMG
Well, those where the 5 that bugged me the most. I don't use the C API.
egarcia
re 1: the problem with that is that you have one data structure for everything (including classes) and a class is just a special table. Thus, you're just calling a function in a table to lua. Though having the environment set itself to whatever you're in (instead of a global scope) on function call would be nice.
RCIX
@RCIX: I'm sorry, I don't follow you. What does "you're just calling a function in a table to lua" mean?
egarcia
Yea, i didn't word that very well. I meant to say, "to lua, "you're just calling a function in a table"
RCIX
I see. On point 1, I didn't mean that the "not self" behaviour should be eliminated from the language - I said it should be switched; so foo.bar(1,2) passes "self" and foo:bar(1,2) doesn't pass self. I believe that the first is the most common case, and should use the most common syntax.
egarcia
+3  A: 

C++:

1: Header files.

Linking your code is harder than compiling it. Also, the requirement of templates to have the full source in that translation unit is absurd. It's over in that other file there .. the one you compiled two seconds ago. Go look there. Stupid compiler.

2: Empty standard libraries.

I mean, yes, there's std::thread in C++0x, but no std::socket or anything of the sort. The primary reason there's no cross-platform code is because you have to learn a new library for every function that you want to perform on more than one platform. Without OS headers or OS functions provided as standard, C++ is only good for pushing bits around.

3: No multiple returns or return value overloads

double x, int y, char z = func(); is just as valid as void func(double x, int y, char z);. Please. The only reason ever given for no return value overloading is because we "might" write ambiguous code. Might! Please, give me grief when I actually write ambiguous code, not before.

4: No reflection

It's ok to make reflection compile-time. It really is. Not having any makes writing a lot of libraries difficult, at best, and seriously annoys me. I could abuse the preprocessor but..

5: Duck typing on templates

Yaargh. Please, concepts and proper template error messages. It's practically impossible to use a library like Boost, just because if you get it wrong, you're shooting in the dark.

DeadMG
A: 

I just discovered I cannot use Enum as a type constraint when creating a Generic method in c#.

Microsoft has a good enough explanation as to why, but still. I'm MAD

public static T MyFunc<T>(string arg) where T:Enum //wont work :(
Midhat
A: 

JavaFX

  • Type inference sometimes doesn't behave like you would expect, so you often need to explicitly declare the type.
  • def behaves likes const in C and not final in Java
  • you can insert a value in a sequence by accessing an index >= seq.length, which should actually throw a compiler error (according to the reference).
  • if you assign null to a String, it defaults to "". If you assign null to an Integer, a compiler error is thrown (in contrast to what the reference says).
  • handles CheckedExceptions the same way as RuntimeExceptions
Helper Method
A: 

C#

  • Cannot create a reference (var &t = struct)
  • No local scope destructors (IDispose comes close but its not the same)
  • ToString, i almost dislike that every object has it but it turns out i dislike everything using it like string.format does. I rather have things that accepts a certain type (like ints, floats, text, chars only). So instead of passing in any object i need to pass in something with a implicit typecast or interface. I ended up writing something like this to safely escape text for html which worked great.
  • Cannot use a virtual typecast (blah)obj; does not work if obj does not inherit/has an interface of blah. Simple workaround is to supply an interface with a convert function.
  • Has no local creation. Instead of writing var o = new Item(); i would like to write (something like) Item o() (with an automatic dispose if it has one).
acidzombie24
re 1, see WeakReference...
RCIX
+2  A: 

Japanese

This was inspired a bit by the Chinese and English responses

1) Has not one, not two, but three writing systems.
2) For every verb you can do about 50 conjugations to mean almost 50 different things
3) Sooooooo many double negatives
4) Particles
5) on-yomi and kun-yomi

Funny enough 1, 2, and 4 are reasons I also like it.

percent20
+1  A: 

Rewrote this after some more thinking ...

Five things I hate about PHP although I love it (in no particular order):

  • Inconsistent naming and parameter order in the built in functions.
  • Object oriented approach to arrays thanks to the SPL but sadly not to strings (yet).
  • No real concurrency in PHP itself, only via the hosting webservers multiprocessing
  • No asynchronous calls like in JavaScript
  • Opcode caching only via extensions. Not really bad but just annoying.

Those are the language features (or lack of) that annoy me but the much bigger problems are these more people/community related things:

  1. The fact that a lot of people who use PHP, don't know anything about programming and good practices in general and produce really messy code. JavaScript has the same problem.

  2. The huge amount of tutorials/book that teach really bad practices and style. This may be the main cause of #3.

  3. The bad reputation it has developed mostly because of #3 and #4.

Techpriester
+2  A: 

C#

  • Reference types are nullable by default; in-language null keyword is untyped.
  • Lack of discriminated unions
  • Exceptions as default, non-exceptional error handling method - there's not much of an alternative.
  • archaic switch statement syntax and limitations
  • Needless distinction between constructors + static methods
  • Static methods can't be part of an interface
  • Lack of by-shape interface implementation rather than explicit interface implementation - leading to numerous language design hacks such as the linq query syntax, foreach, collection & object initializers -- none of which can be flexibly reused. For example, the object initializer syntax may be nice, but plays poorly with immutable objects.
  • Cannot inherit "interface" of a class independently of implementation - leading to code duplications and overarchitected code that provides interfaces, abstract base classes, a few common implementations, and no way to pick and choose the bits of each to use. Also; leads to too many code that's tightly coupled to a particular implementation since it's common to explicitly refer to the implementation type rather than an interface.
  • Cannot multiply inherit via composition since a classes "interface" is tightly coupled to it's implementation; effectively lack of mixins.
  • The above limitations of interfaces lead to a proliferation of virtually identical interfaces that don't overlap naturally in any kind of type hierarchy. IComparable vs. IEquatable vs. IComparable<T> vs object.Equals vs. operator == etc. etc. By extension, making a custom type that satisfies all these things is a lot more work than necessary (in particular for collection classes). Obviously, the language designers realize this, hence the various workarounds for things like linq, foreach and collection initializers which work by-shape rather than by-interface.
  • Redundant use of parentheses and braces rather than layout-is-structure.
  • Return values can be ignored, limiting the effectiveness of type inference.
  • Enums aren't a normal type and can't have methods. Also, enum values aren't typesafe and may be initialized to 0 despite not having a 0 value. Mixing metaphors by lumping flag and non-flag enums together.
  • Lack of proper value type support. Value types can't be inherited, have different constructor semantics, and perform poorly due to CLR limitations. Also, confusing semantics regarding value types: some values are really values (and can't be modified), and others are really non-aliased, non-null references (variables). This gets particularly confusing with regards to the next issue:
  • Semantic distinction between fields and properties, particularly in conjunction with lack of mutability modifier (ala C++'s const)
  • Can't specialize generics
  • Cannot provide default generic type parameters (e.g. factory generics)
  • lack of typedef makes generics a pain to use (using is a limited but good-to-know substitute!)
  • Can't genericize over things other than types (e.g. functions, plain values, or names). This means you can't do something like make a generic implementation of a dependancy property leading to, well, nasty implementations of things like dependancy properties and the overuse of code-snippets and poorly readable code as a result.
  • Limited capability to specify generic type requirements e.g. generic sum method that takes both int, double and a bigint (without tricky and often slow hacks).
  • An interface method implementation or virtual method override cannot return a more specific type or accept a more general type; i.e. limited co/contravariance support even in C# 4.
Eamon Nerbonne
Whoof!!! Thats a really long list!!
Bragboy
C#'s pretty practical and my primary language - but after using a more niche language for a particular subproblem I'm often left wondering why C# has some of these limitations - particularly since some of these issues result in the overall language being rather more complex than less complex - risking C# growing towards the C++ end of the spectrum in terms of complexity. Honestly though, I don't think it'd be good thing for C# to actually address most of these issues. Better to fix em in a new language than deal with an ever more complicated compatibility scenario.
Eamon Nerbonne
One that I hate is the difference between `(Class)` and `as Class`. Mainly to do with the whole `null`able-or-not thing.
Nick Bedford
+2  A: 

Five things I resent in Nemerle:

  • Local functions can't yield
  • Ability to compile a lambda sometimes depends on whether it gets inlined
  • Inconsistent value/reference type semantics for tuples
  • Occasional ambiguity between array indices and type arguments
  • Lack of general adoption
Don Reba
+1  A: 

Having to assume we have a language. Do we?

LarsOn
+2  A: 

Clojure

  • Lack of built-in syntax for optional and keyword parameters in function definitions. Sure, you can add it easily enough, but that means library writers don't use it. Pervasive destructuring hasn't proven to be a good substitute yet
  • Lack of method combination (before/after/around methods of the sort found in Common Lisp)
  • Too much reliance on Java interop, e.g. there's no built-in file IO
  • Sometimes I want static typing. This one isn't pure hate; I usually prefer dynamic, and attempts to mix the two have been largely unsatisfactory
  • There's no built-in fast binary serialization format for the built-in data structures, though I hear people are working on it
Zak
+2  A: 

Python, again:

  1. No switch keyword. And NO, dictionary is not a replacement for it. Not even a bunch of elif statements.

  2. Inconsistent line break handling. Why can I do:

     test = (1,
             2,
             3)
    

    And not:

    from itertools import cycle,
                          islice,
                          izip
    

    Why can't I do:

    if stuff \
       and foo \
       or bar:
        return "Formated string with %(arg)s" % \
               {'arg': "bloody slash"}
    

    without using slashes?

  3. There is not one obvious and only one way to do it. Python fails on its motto just like Java failed on "Write once run anywhere".

    # what somebody from an another language would do
    if not test.has_key('foo'):
        test['foo'] = 0
    n = test['foo'] = test['foo'] + 1
    

    vs

    # what an agnostic beginer would do 
    try:
        test['foo'] += 1
    except KeyError:
        test['foo'] = 1
    n = test['foo']
    

    vs

    # what you end up after looking for dictionary default value in the python doc
    test.setdefault('foo', 0)
    n = test['foo'] = test['foo'] + 1
    

    vs

    # what I would do
    n = test['foo'] = test.get('foo', 0) + 1
    

    And the worst is that they don't do exactly the same thing. There are subtle differences.

  4. Choice between spaces and tabs. There should be no choice. Pick on, set it in stone and stop fighting.

  5. Why can you do that:

    test = {}
    test['foo'] = 0
    

    but not:

    test = []
    test[] = 0
    

P.S: " ".join(l) is fine people. Stop complaining about it, it's not obvious but with the iterator pattern in mind, it's just the right way to do it.

e-satis
Use parentheses for all your line continuation needs.
kaizer.se
+1  A: 

C#

I'm very happy with C# but these two really annoy me:

  • Constructor-based initialization for immutable classes is less convenient, less intuitive (when you read the code you don't understand what you assign to what), has less IDE backing than inline object initialization. This makes you lean towards mutable classes inevitably. I know this has been mentioned before, but I strictly have problems with initialization syntax for immutable classes.

  • switch is too verbose. Whenever I see a situation where a switch would be proper, I'm really inclined to use an if..else if.. just because it's more terse (~30% less typing). I think there should be no fallthrough for switch, break should be implied, and case should allow comma separated list of values.

ssg
Sorry for the ignorance, but what is the problem with constructor-based initialization for immutable types?
devoured elysium
First you have to write one and write all redundant assignment statements in it. On the other hand, mutable classes support inline initialization syntax by assigning properties just after constructor directive, much easier. Second, with parameterized constructors it's hard to know what you assign to what. Inline initialization shows you that. .NET 4.0 cures this partially with named parameters. In many functional languages, constructors of immutable classes actually act like "member definitions" at the same time, saving you *a lot*. See F# or Scala.
ssg
+3  A: 

Erlang

  • doesn't have static inferred typing like one found in Haskell. This can lead to runtime errors and one have write code carefully or use dialyzer(1) to discover discrepancies. Dynamic typing is also considered to be slow;
  • is almost unknown compared to C, Java etc.;
  • 's lists(3) module is pretty lean, sometimes I lack useful functions for list processing (like ones in Data.List in Haskell for example);
  • makes me put , at the end of an every statement within clause, and . in the end of the latter.
Yasir Arsanukaev
+1  A: 

Java is slow according to many but I agree to a certain to degree of usage.

Java is dramatic. They have lots of classes just for a single thing you wanted to do. But you know flexibility property XD.

Java is hard at first but fun as always.

When you are writing a simple code for printing "Hello,World!" PLEASE DO NOT USE JAVA! XD I'm sure I am justified.

Java is a mixture so don't say it is purely an OOP language.

There's many more but I am only restricted to five XD. Thanks!

Richeve S. Bebedor
+1  A: 

Common Lisp

  • conditions aren't classes (since classes came later), even though their interface is almost identical
  • some of the names are just weird, e.g., flet / labels (only difference: scope), and defvar / defparameter (only difference: behavior when already defined), or any of the bit-twiddling functions (dpb, ldb, etc.)
  • packages are ... really hard to get right -- every time I think I understand them, they don't do what I want
  • built-in data structures and functions aren't as generic as they could be (e.g., why can't I define my own hash function portably?)
  • multiple namespaces for functions, variables, etc. (I'm not opposed to this in principle, but CL made it too complex; Norvig has said he can't tell from the spec but there appear to be at least 7 namespaces)
Ken
A: 
  • The length property is easily confused with the length() function; use size() instead
  • The syntax to interpolate variable in selector strings('" +$.month+ "') stinks
  • $(event.currentTarget) does not always work for bubbling and capturing
  • attribute syntax works ("[class='foot']") in places where selector syntax (".foot") returns nothing
  • Contains selector ([class~=done]) sometimes fails where JavaScript (this.className.search("done") > 0) works
Paul Sweatte
+2  A: 

Haskell

  1. Sometimes the type system feels backwards. What if I don't want the compiler to infer types for my variables? What if I want the opposite, where it does constraint checking on said variables? For example, instead of inferring the type of the elements of a list, it instead makes sure that they all belong to a particular typeclass. This is a subtle but huge difference that makes it difficult for me to program UIs. It can be done, but it takes more effort than it does in some other languages. Haskell rocks for the non-UI parts, but the UI I leave to an untyped language.

  2. Allowing the construction of infinite values leads to some really frustrating errors sometimes.

  3. NoMonomorphismRestriction.

  4. Bytestring handling bites me in the ass sometimes and you don't know it until your program crashes because you mixed them up improperly. Something is wrong here, when we are losing type information that should have prevented this.

  5. Typeclasses should be automatically derived for trivial cases, like witness types, but there's a strong potential for abuse there.

Re #1, do you mean there are type constraints that you want to impose that you can't using the likes of `foo :: SomeTypeClass a => [a]`?
j_random_hacker
+2  A: 

C#

I know its stupid, but I'd like datatypes to convert to what I want on their own, without me having to add (int) or Convert.ToInt32 or whatever. It would just save me time. And it annoys me that if I write something to output an int and then it turns out that I need a long, then often I have to go through and change everything I've done to make it work. Just do it for me!

Sorry, couldn't think of five, but I'm new to it, so maybe I'll come back and add more later :P

Sir Graystar
+1  A: 

C#

  1. No easy way to check if a type is Numeric
  2. It means you are probably stuck using most of the microsoft stack, IIS and MSSQL
  3. Instead of being a specific tool for a specific problem, C# tries to be a language for every paradigm.
  4. Lack of community. Sure, there are starting to be open-source frameworks and libraries for C#. The same ones that have been available to Java developers for years.
  5. Hard to find good help. The internet is littered with poor examples of how to solve problems with C#. This goes back to problem #3.
CountCet
+4  A: 

Erlang is absent from this list. Among my favorite languages, but a few flaws for sure:

  • Syntax. This includes the 3 terminating tokens (,;.) and aesthetics, but more generally on how the semantic meaning of the code is expressed in text. An example is on how all lowercase tokens are atoms, so to refer to a function you can't just name it, you have to fun my_function/1, and ?PRECEDE_CONSTANTS_WITH_QUESTION_MARKS. Coming from Scheme, Haskell, etc. you just wish you could use a name.

  • Library support is lame. This is mostly external libraries, but even the old standard library. Newer versions of Erlang have sensible POSIX regexes, but the old one had a pretty horrible library for basic string manipulation. You also never know when you're getting the value, or {ok, Value}.

  • Related: non-uniform tools for building and distribution. Ruby has gem and rake, RSpec. Perl has CPAN. I'm unaware of decent equivalents in Erlang.

  • The few Erlang specific tools are pretty strange. Mnesia is a great database, but coming from SQL you have lots of trivialities to learn. Same with the documentation @spec, which has a strange way of describing signatures.

  • Often the functional paradigm hurts when you just want that little bit of mutation. Supposing you want a Hash Table, you can't just hack it as in Scheme, or SML. ets and dets alleviate some of the pain, but not much.

Sixth, bonus:

  • Import and export syntax for modules is a pile of fail, not unlike Java's 80+ lines of import statements.

All that being said, Erlang is a joy ^_^

paul.meier
+4  A: 

Here's some more for Perl 5, from the perspective of someone who's created a lot of Perl modules, and in particular worked on Moose.

  1. The horrible brokenness that is overloading and tied variables. Both of these features are a failed attempt to allow transparent extension to the built-in types.

    They both fail in various ways, and require module authors like myself to either implement horrible hacks to support them, or to say "never pass an overloaded object to the foo() method". Neither alternative is really acceptable.

  2. Lack of proper hooks into the compilation process and the meta-model. Moose in general, and role usage in particular, could be made much safer if the Perl core allowed us to affect the compilation process via a sane API that allowed us to hook into the meta-model (packages, classes, etc.)

  3. Lack of named parameters built into the language. Instead, everyone reinvents this. It's annoying.

  4. Similarly, lack of optional types. I don't want a static language, but the ability to specify types and constraints, particularly on function/method parameters, would be great. Perl 6 gets this right. Types are optional, but very rich, and there's no fundamental difference between built-in and user-defined types.

  5. The backwards compatibility police. This is more of a cultural issue. A number of the above issues can never really be fixed, since Perl 5 has a very strong commitment to backwards compatibility. So even if something were to be added that effectively replaced the current ball of shit that is tie and overloading, those features will never be removed. Of course, backwards compatibility is also one of Perl 5's greatest strengths.

  6. Bonus hate: Perl's built-in exception mechanism is a joke. The fact that exceptions may be a string or object makes for an eternity of fiddly exception-catching code, and the lack of a catch in the language syntax is the wart on the wart.

Dave Rolsky
Well done, sir.
brian d foy
#5 should be #1 imo and this needs to be voted up more.
xenoterracide
I heard you like warts so I put a wart on your wart so you can pull it in rage while you wrestle with exceptions.
Jon Purdy
+2  A: 

Five things I hate about C++

  • Link times. With distributed builds I can rebuild our entire project in the same time it takes our linker to run.
  • No standard way to prevent reordering of memory operations. Using write-combined memory typically requires abuse of the volatile keyword. Preventing read reordering (often critical for optimization when dealing with SIMD math pipelines) is typically accomplished via injection of a null ASM block in the middle of a routine.
  • Multi-step macros to work around stringification issues:
#define STR_LINE2(x) #x
#define STR_LINE(x)   STR_LINE2(x)
#define LINE_NUMBER STR_LINE(__LINE__)

  • It's just generally painful to do string manipulation.
  • Proliferation of non-standardized printf variants (vsnprintf_s vs _vsnprintf_s).
Matt R
A: 

SAS

  • Never has own ideas (every thing is borrowed).

  • Greedy for huge datasets.

  • Uses Java, but never learned what it is to be an object.

  • Steals Perl, but hide it in its data step.

  • Lie always with statisticians!

john
A: 

JavaScript

From the ECMAScript 5 spec:

  • 7.6.1.2 Future reserved words:

    class, enum, extends, super, const, export, import

    In strict mode: implements, let, private, public, interface, package, protected, static, yield

  • 11.9.4 The Strict Equals Operator (===) vs. 11.9.1 TheEqualsOperator(==)
  • 11.9.6 The Strict Equality Comparison Algorithm (NaN === NaN is false)
  • 8.5 The Number Type - No real Integers, everything is a float.
  • 4.2.1 Objects - prototypal inheritance

OK, I kinda enjoy the last one, but it's 7 kinds of confusing

thejefflarson
Prototype inheritance is great but you have to know what you're doing :). JavaScript is great instrumentaion language but for implementing some logic I prefer something more type-checked and use only thinh JS layer around it.
binary_runner
Yeah, the thing that always messes me up about it is setting the inheritance chain, but this is a sweet way to do it: http://closure-library.googlecode.com/svn/docs/closure_goog_base.js.source.html#line1206
thejefflarson
All those things make good sense to me... How come some people find those concepts so difficult/annoying? I love the loose and strict comparisons and using instanceof. Also having numbers as floats means they just work like real life. And prototype inheritance is my favorite feature... Having reasons in your post on why they annoy you would be nice.
balupton
thejefflarson
+2  A: 

C++

  • cryptic error-messages when templates are involved
  • lack of template constraints (many cases can be worked around with template metaprogramming, but this will result in unreadable code (at least for average programmers) in most cases)
  • pointer to member-function syntax
  • c++ standards committee should release offical standards more often (or at least release separate updates to the standard library itself), i mean really TR1 was released 2005, and we still dont have a shared_ptr, bind and alike in the standard library.
  • -
smerlin
+2  A: 

VB .NET, but only because VB6 poisoned an entire generation of programmers

I work in a VB .NET shop that used to be a VB6 shop, and every person working here who used to be VB6 developers stubbornly refuses to learn anything about .NET. They code as if it’s still VB6, and their apps suck just like VB6 apps did. My boss actively discourages any use of LINQ because she fears it’s too difficult for others to understand, which is true because nobody wants to understand it.

I think we would have all been better off if MS just went with C#, which kills me to say because I think curly braces are far inferior to VB’s verbose closing statements.

Bremer
I agree (and I'm coding in VB.NET). If you look around forums and boards you find a lot of code written in VB.NET which looks like VB6 or even VBScript...the people just think "It's the same as always" and just refuse to learn anything about the framework or the new features. It goes even so far that someone told me that OOP is "hard to write, read and understand" and VB6 would be way easier. For some reason I only see this behavior in the VB-Community, and in my opinion dragging the VB6-Namespace along was the worst decision Microsoft made with VB.NET.
Bobby
+2  A: 

Regarding C#:

  1. I hate that there is no keyword to specify which exceptions are thrown from a method like in java. Its a much better way to document exceptions than using an XML comment.
  2. I would also want a much better syntax for generic constraints like oring and anding of constraints.
  3. Why a method can't return more than one value?
  4. Lack of support for aspect oriented programming in the language.
  5. Why can't you annotate each one of the property accessors with an attribute?
  6. Lack of builtin regexp support like in perl.
Ikaso
+1 for exceptions documented on the method itself. It sucks having to go to the API to see what could possibly be thrown from some call I make to ensure I handle all the cases. Even better: a code snippet that can add catch()es for all exceptions that can be thrown.
drharris
+3  A: 

R

Not my favorite language, but I use it a lot and there is plenty to complain about...

  • S3 objects are just glorified lists and S4 classes still keep all data exposed to user
  • The assignment operator can be <- -> or =, see Mike Dewar's rant
  • my.var is a very confusing variable naming convention for an OO language, see Google's style guide
  • I should not have to regret using a loop
  • Cryptic error messages
DrewConway
I think the looping thing is a community issue more than a language issue... related: apply() has the be the most opaque and frustrating language construct I have used.
JD Long
As you say, the `.` character in a variable name is not special and is completely ignored by the parser. Except that it's critically important to S3 method dispatch! Who thought that was a good idea?
Harlan
JD, sorry, that is what I meant (it being a community thing). I love apply, but sometimes I just want a loop, and don't want to feel dirty doing it.Harlan, see, there you go talking about something I had no idea about.
DrewConway
Some base library functions have strange interfaces that make sense if you're working interactively, but cause nasty bugs if you're writing longer code. Worst example: `sample(10:12, 3)` gives three numbers between 10 and 12; `sample(10:10, 3)` gives three numbers less than or equal to 10! Who thought that was a good idea? (And no, the fact that the behavior is documented is no excuse!)
Harlan
+1  A: 

Ruby.

  1. Strange scoping rules - variables, constants, and methods each behave differently from each other. The rules change also depending on which keyword you used to create a closure. Or on whether you're in a class, eigenclass, object, module, or module's self. Then there's instance_eval, which changes the rules to a different set of rules. And they change again when a module is "included" or "extended", which themselves do different things to scope. And some sets of rules can't be emulated by metaprogramming, so you have to use eval. Unless you're on ruby 1.9, where all of this is different.
  2. Namespacing is basically useless. If you have Foo::File, then the stdlib File is probably broken for all of Foo.
  3. require statement is broken. If two files require eachother, the behavior of those files can change dramatically depending on which is loaded first from elsewhere.
  4. libraries change APIs dramatically and suddenly, so you have to require specific minor revision numbers of all of your dependencies. For every single ruby application on your system.
  5. The rubygems package system overrides "require" rather than putting files in the search path - because why use a system when you can replace it?
jes5199
+2  A: 

Python 3

  • both tabs & spaces allowed for indentation
    And you'd think people learn from the past (Makefile). Just pick spaces and forbid tabs. YAML got it right.
  • lack of popular third-party libraries
    The standard library is great, but a lot of what makes Python 2 so powerful lies in the third-party realm. Python 2 got this right :-).
  • IEEE floats
    Floating points in programming languages are confusing because they're different from the way we use them in math. Instead, the number operations should be viewed as expressions that are only converted to a decimal point format when needed (i.e. printing to a screen). Maple and Mathematica did this right I think.
  • the character set for identifiers is too restricted
    list.empty? is better than list.is_empty or even len(list) != 0. Similarly, process.kill! would be better than process.kill. Ruby and lisp got this right.
  • when calling a function you must always write parentheses
    It would be nice if we could omit them in unambiguous cases. How is it again? dict.items or dict.items()? Ruby got this one right, too.
Tomas Sedovic
+2  A: 

Python

  1. Standard library disobeys their own style guidelines in many places. (PEP-8)
  2. Py3k's super keyword is full of unwanted magic (you can't assign it to a different name, works without self, why do we have this explicit parameter at all?)
  3. Unicode support is incomplete in Py2k and sucks in Py3k (standard input in unicode, no binary data! WTF? Creating a new WSGI standard is hacky.)
  4. The GIL. Very limited multi-threading support (with CPython)
  5. PyPI (Python Package Index) sucks. Envious glance at rubygems
ch0wn
re-open stdin in binary mode?
kaizer.se
+1  A: 

Python:

  1. No standard GUI toolkit (the community goes round and round about this but never seems to settle on anything).

  2. The evolution of tools and methods to distribute and install Python apps and libraries has been, well, rocky. (Although lately this seems to be moving closer to getting fixed.)

  3. CPython is still slow as interpreters go (although PyPy is looking pretty good these days, if it becomes the "standard" Python this problem goes away).

  4. You can't subclass built-in classes (e.g., list and dict) without overriding a lot of methods, even if all you want to do is a simple hook into an event (e.g., to hook into an item being added to or removed from the list, you need to override delitem, append, extend, insert, pop, and remove--there's no subclassable "change" event notification, nor any "protected" methods that factor out common code used by all the above methods).

  5. Up until virtualenv was invented, keeping separate Python environments for different purposes on one machine was a real pain.

Peter Donis
+1  A: 

PHP:

  • Absurd assert() function... it runs eval() on the code inside
  • ?> tag removes any newlines following it ?!
  • Strange handling of numeric strings (try them as array keys)
  • Painful unicode support that seems no longer will be resolved by PHP 6
  • Low cost of entry means 95% give PHP programmers a horrible name - and trying to find someone in the 5% to hire is crazy.
Josh
+2  A: 

Python

  1. There is no Django for Python 3.
  2. Static typing. Yes, dynamic typing is great thing, but sometimes I do want to make it static.
  3. Proper unicode support (fixed in Python 3)
  4. Construtors naming. I hate all this underscores __in__ my code.
  5. Threads are not very efficient
Davinel
+1 for the underscores
RCIX
+5  A: 

Scala is my favourite language. Five things to hate? Easy:

  1. Takes a long time to learn properly. I know you can write Scala as a 'better java'. That is what we used to say about C++ and C too. I agree this is an inevitable consequence of the deep ideas in the language. But still ...

  2. Methods vs. Functions: def f(x: Int) = x*x defines a method f, not a function f. Methods are not functions despite a lot of early Scala tutorial material blurring the distinction. The language tries to blur it too because if you supply a method in some places where a function is expected it is accepted. Do we have to have both methods and functions? Yes it is fundamental. But it was initially confusing to me.

  3. Composing classes or objects from mixins in the 'cake' pattern is prone to NPE's. e.g. trait X { val host: String; val url = "http://" + host } is a mixin that will NPE on instantiation, or not, depending on its position in the class declaration. The compiler could tell you if it will fail but doesn't. (In 2.7 anyway.) It is hard to diagnose the problem in complex inheritance graphs.

  4. Arrays in 2.8 rely on implicits to mesh with the main scala collection types. But implicits are not applied everywhere. An Array can be supplied where a Seq is expected. But an Option[Array] cannot be supplied where an Option[Seq] is expected. I know there are no completely 'right' ways to handle java Arrays.

  5. Type erasure. Enough said.

Arnold deVos
A: 

Python:

  • no delimiter signaling the end of blocks introduces ambiguity such that automatic indentation will not work with poorly formatted code.
  • no macros (decorators don't count)
  • no library auto-fetch like haskell's cabal, or perl's CPAN
  • can't declare variables const (yeah it's possible to role your own but ... )
  • meta-programming is nerfed
  • almost forgot the Global Interpreter Lock
drhodes
+13  A: 

BrainF*ck

  • Your highlight is that you're Turing complete?! I can do more in Perl regular expressions!

  • Lack of objects. C'mon, people! It's like, hello...

  • No networking libraries. All I want to is scrape a web page, GOSH.

  • No first-class functions. Congratulations — you get to commiserate with your Java friends.

  • An infinite tape for storage and nothing else. This is so anally pretentious that we might as well be writing Lisp.

a paid nerd
There's no namespace or dynamic module support. How can we be expected to write chemical plant control systems without such basics?
Donal Fellows
A: 

I have only one but I believe it worth sharing.

CSharp / .NET

We have Length property to get number of elements in array and Count property to get number of elements in collection. It looks more stranger if you consider the fact that CLR automatically adds IList, ICollection, IEnumerable to zero-based one-dimenssonal arrays behind the scene.

I believe CLR team and BCL team had hard times discussing this subject ;)

Andrei Taptunov
+3  A: 

C#.

What I hate most:

  1. No multiple inheritance - imagine you could provide whatever GUI framework base class (Control, Window, whatever) with MVC - related stuff, etc... framework / base class agnostic!

  2. No "friend" keyword... I know, the RAD - victims would abuse it for all kinds of stinky code and for hilarious malpractices, but it would be nice for the OOD - guys to enforce the law of demeter

  3. No language integrated DBC features, there are the Contracts, but I would rather have that Spec# - style with a general purpose "!" - postfix operator

  4. No AOP (I don't get it... this language has attributes, it would have been SO EASY to add interception code in the compiler!)

  5. No weak event delegates - the observer pattern becomes nothing but a memory leak bait as it is now... :-(

stormianrootsolver
1: if you need multiple inheritance, consider interfaces (there's sooooo much that is confusing with multiple inheritance); 4: you can get a very nice AOP library
RCIX
4: Just got into AOP, and C# would be an awesome language for this! I really wish they would add something in soon for this. 5: Totally agree. I've been slowly converting everything to RX and IObservable, which seems more comfortable.
drharris
@RCIXI KNOW about interfaces, but this is not the point. For many tasks you don't only need the interface but also the behaviour to be able to code things in an understandable way. Of course one can use the strategy - pattern (for example) to implement MVC, but the better way would have been to be able to add, say, the full data context handling to a System.Windows.Forms.Form by adding a generic base class - oh, and I use PostSharp.NET. It's [email protected] totally agree. It's not understandable to me why they didn't expand attributes to interception. That would perfectly solve it.
stormianrootsolver
RCIX
If you ask me, the compiler should fail with an error if one tries to inherit from two classes with colliding member names. I do, however, believe that this should rarely by the case, given well educated developers who know how to separate concerns and observe the law of demeter.People who only write code to earn a living (Morts, approximately 90% of developers around) will always give us hell, multiple inheritance or not.I guess the best way to solve that would be to only allow Elvis and Einstein types to work on software.
stormianrootsolver
A: 

Object Pascal:

  • There's a lot of jumping back and forth in the file you're editing since the interface and implementation are split into two parts but still jammed into the same file.
  • Dynamic indexing of arrays, strings start at 1, you specify the starting index when declaring fixed arrays and dynamically allocated arrays always start at 0.
  • Classes and objects (not to speak of interfaces) are bolted on top of the language and among other things can't be stack allocated like records can.
  • When calling functions without parameters the () are optional, leading to a lot of pain when you are dealing with function pointers or trying to refer to the result of a function using the function name.
  • Parameter lists can't handle fixed array types or function pointer types without external type definitions.

This is just the language, the sorry excuse for a standard library and flaky IDE deserve their own lists.

Adde
+1  A: 

Java - no support for composition on language level

binary_runner
+5  A: 

German

My native language... Though it can sound even more beautiful than Klingon it's a grammar hell...

  1. conjugations: even regular verbs have different forms for each person and time (with few exceptions)... Example: I see, you see, he/she/it sees, we see, you see, they see translates into: Ich sehe, du siehst, er/sie/es sieht, wir sehen, ihr seht, sie sehen.
  2. polite form of address: equals 3rd person plural, used to equal 2nd person plural in the middle age... I really hate the concept of distinguishing between "Du" and "Sie" for my philosophy is that each human being should be considered equal in the amount of respect for it deserves (I mean, what are swear words for, hm?)
  3. punctuation: show me a language that uses more commas regularly!
  4. missing suitable words: eg. there's no real German equivalent of "convenience" or any derivate of this word... in almost every case you just can't translate it into another German word and keep the meaning... instead you would have to make up a whole subset to describe it somewhat adequate...
  5. Anglicisms and Denglish: Sure, the English language has "Kindergarten" or "Poltergeist" and what not but the German language is overflowing with Anglicisms nobody needs... Even worse: We redefine some words we adopt, eg. in German "Handy" means a cell phone and has nothing to do with the adjective it is in English... There are influxes on grammar as well, leading to "Denglish" expressions (see linked article at Wikipedia) There's more, but I don't want to exaggerate this and those are my personal Top5 of what I hate about the German language...
luxifer
+3  A: 

Five things I hate about all languges (that I know of at least):

  1. Does what I say/type, not what I mean
  2. Will undoubtedly meet people who think they are experts in the language, but just make a mess of it (e.g. people who insist that removing comments/unused local variables will speed up execution time for a program)
  3. Unless the language is obsolete, then it will probably continue to evolve (either the actual language, or the concepts behind using it effectively) requiring you to actively develop with it so as to not fall behind.
  4. Can't modify the lexer/compiler (add in own context sensitive grammar)
  5. No perfect language (every language is missing some sort of useful feature that usually is either impossible to simulate, will unavoidable have an ugly interface or just require far too much time to implement and get it right)
Grant Peters
Lisp has do-what-I-mean flags.
mpez0
So lisp can figure out that I meant to initialize a variable to 1, but out of habit I wrote 0? (recently did this and made a very hard to track bug, was involving networking so it could work depending on packet losses/ordering)
Grant Peters
A: 

Objective-C 2.0

Sticking strictly to the language and runtime, and not the libraries, and not in any particular order:

  1. Lack of cVars.
  2. No modules. I'm not terribly unhappy with a lack of namespaces, but modules would be nice to have.
  3. Ivar-based property syntax requires declarations using the variable name in 3 places. It's fairly hideous.
  4. C heritage. Anything to hate about the C language, except for OO and GC, is present.
  5. Objects can't live on the stack. Not a problem with Obj-C so much as what it does to programming practices in other languages. I find it strange when I get a return value on the stack in C++, for instance. If I'm not actually looking at the library documentation when I write the code, I'll assume that every function returns a pointer, which often makes for some siginificant cleanup later.
A: 

C# 4.0

The "dynamic" keyword, ripe for abuse. If you want/need to use Reflection, use and make it obvious that you're using it, don't try and disguise it with dynamic.

Chris L
-1: there are very valid uses for dynamic (and goto and var and break and for and if and...), plus that's not 5 things.
RCIX
A: 

Python:

1) line continuation syntax: "...\" works, but "...\ " does not, and that trailing space is generally invisible, without unusual eol-marking by editer.
2) a bare 'raise' is invisible in the stack trace, as the stack trace looks like the previous raised exception.
3) slow
4) poor integration into web-servers (mod_python: dead, mod_wsgi: limited scope of operation). This is complicated by 3], requiring daemonization or some sort of memory-persistance to perform well.
5) overly tolerant of mixed tabs and spaces, allowing changes to control flow to sometimes remain hidden. (maybe fixed in recent versions)

pduel
+1  A: 

Java:

  1. Very inconsistent.
  2. Graphics APIs are sometimes a pain to use
  3. NullPointerExceptions don't tell you what's null
  4. Programs I write sometimes don't work on a different JVM which is a huge pain and contradicts Java's "Write once, run anywhere" statement.
  5. Swing isn't as good as it should be.
Shaken_Earth
+5  A: 

Python:

  • You usually have the entry point of the program at the end of the file. (Because if it calls any function defined in the module, it has to occur after those functions in the sources.) I hate it when you have to spend time looking for the entry point of a program, so I always have a simple main.py file with:

    def main():
        ...
    
    
    if __name__ == '__main__':
        main()
    
  • When an exception is raised, it can only be catched by the main thread. Or something like that.

  • Destructors are quite useless, because when written in Python they may break garbage collection IIRC.

  • I've never figured out how relative imports work in Python 2.

  • I'd like to see more collections in the standard library. For example: linked lists, thread-safe collections, ...

Bastien Léonard
+4  A: 

Lua:

  • Metatables are sooo confusing until they "click"
  • Lack of assignment operators like a += 20 is a pain
  • No integrated object oriented solution means everyone and his dog uses his own flavor
  • The syntax used for commenting (--) precludes the possibility of pre- and post- increment/decrement operators
  • Not possible to have any sort of pre-emptive multitasking system without hacking the C side
RCIX
+5  A: 

Perl 5 In order from most annoying to least.

1.) Backwards compatibility police. Yes backcompat is a strength but Perl 5 takes it too far. Now we don't really even get new features in our language without having to enable them explicitly. I'm much prefer the inverse, if a new feature causes a problem let me disable it or enforce old behavior. e.g. perl 5.10 added say I'd rather have no feature 'say' if I have my own say implemented than have to put use feature 'say'; or use 5.010; also if 5.8 worked but 5.10 didn't. I'd rather have use 5.008; to restrict my code to only use features available up to and including 5.8 if no use version; was defined then it should be defaulted to whatever version you're running, and a recommended practice of not to restrict it unless you have to.

2.) Excessive Boilerplate.

#!/usr/bin/perl
use strict;
use warnings;
use utf8;
use autodie;
use English '-no_match_vars';
use 5.010;
package Package::Name;

BEGIN {
    Package::Name::VERSION = 0.1;
}

sub somesub {
    my $self = shift;
    my ( $param1, $param2 ) = @_;
}
1;

now you may start coding. This won't change due to #1. of course there are shortcuts to this stuff like use common::sense; or use modern::perl; which will shorten the above and you may want some slightly different modules or pragma's. But because of #1 we'll never be able to reduce it to.

#!/usr/bin/perl
package Package::Name 0.01;

sub somesub ( $param1, $param2 ) {
}

some modules are helping with this, and there is the new package version in 5.0.12 which allows exactly that syntax though I think it requires use 5.012; first, and Method::Signatures but it'll never be completely resolved, (in language).

3.) Poor variable choices

slurp a file

#!/usr/bin/perl
use strict;
use warnings;
open my $fh, "< foo" or die $!;
local $/; # enable localized slurp mode
my $content = <$fh>;
close $fh;

wtf is $! and $/? rewrite to be legible.

#!/usr/bin/perl
use strict;
use warnings;
use English '-no_match_vars';
open my $fh, "< foo" or die $ERRNO;
local $INPUT_RECORD_SEPARATOR; # enable localized slurp mode
my $content = <$fh>;
close $fh;

and lest not forget that the '-no_match_vars' must be there if you don't want to take a performance hit.

How 'bout no direct way to create an anonymous scalar?

#!/usr/bin/perl
my $scalar_ref = \do{ my $anon_scalar };

couldn't they have come up with something?

#!/usr/bin/perl
my $scalar_ref = <>;

oh and how about how perl is thread unfriendly because all the variables (including special ones) are global by default. At least now you can use my $_; to lexical scope that and use local on the others.

4.) really ugly syntax

MooseX::Declare is a much nicer syntax. Also I wish for -> to be replaced with . (personal preference doesn't matter much)

5.) Too much TIMTOWTDI or Too many best practices Seems like you have to read 3-5 books just to figure out all of how you should be doing things.

6.) Previous (no longer applies). Un-sane releases. 5.10.0 had features 5.10.1 had features no set time 'till the next release. Now it's yearly feature releases with quarterly updates.

7.) Ivory Tower perspective. community problem, seems to be a large number of devs who want high barriers to entry and thinks it's ok to treat n00bs ( or really anyone who disagrees with them ) disrespectfully.

8.) Insane Version Numbers/Strings Perl has floating point version numbers and they're ugly. Oh and the dev's don't know that not all downstream deals with version comparison the same way. Not really a language problem

0.012 # simple
5.012001 # semantic 
4.101900 # time based + version (for multiple versions in a day)
0.035_002 # prerelease

all valid versions in perl.. can't we just use like...

0.12 # simple
5.12.1 # semantic
20100713 # time based (just use the date and be careful not to need to release more than 1 a day)
0.35-beta2 # prerelease

addition

9.) No obvious way to reinstall all XS modules after an upgrade

xenoterracide
The whole thing with the existence of match variables causing a performance hit always struck me as being an irritating misfeature, especially as it is a problem of Perl's own making. If only the language compiler could determine that a particular RE match wasn't captured and use the faster code automatically. (One basis for doing that would be identifying that the match vars are never used before the next RE is matched, which is amenable to compiler-level theorem proving.)
Donal Fellows
Perl 5.10 has the /p flag so you can use capture variables per match rather than globally.
brian d foy
The "explicitly enable"-thing is required to make updating versions a trivial thing. Nobody would update if all their scripts blew up everytime.
Thorbjørn Ravn Andersen
@Thor *sorry for shortening your name* I don't believe that, because I don't believe that most of these features have overlap in most programs. Even if they did I don't believe people would shirk at an upgrade if the fix was as simple as adding 'no feature 'feature'; to the top on the rare occasion that something did break. We punish people for using modern perl, and reward those who don't. Just my 2 cents. I'm really curious... have you ever seen the function 'say' anywhere? How many places do you think having that would break things?
xenoterracide
@Thor oh and things break every time I upgrade perl, due to the PITA of rebuilding XS modules.
xenoterracide
@xenoterracide, I don't do Perl anymore, but I know that if a release used in production breaks programs we don't install it without _extensive_ retestning in production. Which we don't want to, so it doesn't happen as fast. Don't you have mission critical code in production?
Thorbjørn Ravn Andersen
@Thor you don't do extensive testing before doing a release on a new version of your platform for *mission critical* code as is? ... Basically I just don't believe that we shouldn't be able to add new keywords to perl indefinitely... if they wanted to go through some inverse of deprecation. e.g. first release you have to use `use feature`, next release `use version`, and then after that it'd be just available. I'd be fine.
xenoterracide
@Thor also if you had *mission critical code* that you knew worked on `5.8` why wouldn't it be good enough to put `use 5.008;` at the top if that meant no features from future versions would work after that (unless explicitly imported).
xenoterracide
@xeno, plenty of options. I still maintain that if minor update breaks programs, it will result in less people updating.
Thorbjørn Ravn Andersen
@Thor from 5.10 to 5.12 is not a minor update.
xenoterracide
+4  A: 

Python (3.1)

  • The weird out-of-order T if C else F syntax for conditional statements.
  • bytes literals look too much like str literals. We should have had something like x'414243' instead of b'ABC'.
  • str is UTF-16 on some platforms and UTF-32 on others. (Although at least it's an improvement over 2.x strings.)
  • Having the same operator for addition and concatenation. This hurts with types like numpy.array.
  • Runs slowly.
dan04
+2  A: 

EL - Expression Language, the ${...} and #{...} thing in JSP pages and JSF 2.0 Facelets which is used to pull data up from the underlying Java code.

  • All the fun things, like method calls with parameters and annotation based naming is only present in the EL in Java EE 6 which is only available in Glassfish v3.
  • It is a royal pain to 1) get the right jars for an earlier Servlet 2.5 container, and 2) getting them to work without interfering with any previous implementation available in the container.
  • Having only an earlier version of JSF like 1.2, takes away the method calls and leave you to work with f:setPropertyActionListener - http://weblogs.java.net/blog/2009/07/22/say-sayonara-spal - which, trust me on this, is not very nice.
  • The EL parser has no idea of where the snippet it is to parse and interpret came from, so you tend to give everything an id so you at least can identify which tag made it grumpy.
  • Eclipse gives a warning at every EL method call as it is JSF 1.2. only too.
Thorbjørn Ravn Andersen