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.

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.

Haskell:

惰性计算导致空间泄漏。 数字层次结构不是根据数学抽象构造的。 严格的单元IO会使调试更加困难。 大型实现处理I/O的方式似乎与标准不太兼容。(特别是，输出字符只输出低8位——然后构建代码，使用这个假设来执行二进制I/O。我吐!) ($)运算符的结合性可以被改变以使某些表达式更漂亮。

大多数问题都不会上升到讨厌的程度，有些人试图解决或为每一个问题构建可靠的变通办法。

编辑:关于第5点有些困惑。特别是有些人似乎认为我指的是论证的顺序，但我不是。我不解释我的意思，我只想让人们去下面的链接http://hackage.haskell.org/trac/haskell-prime/wiki/ChangeDollarAssociativity，它很好地表达了我的意思。

我自己最讨厌c++的5个地方:

自动生成构造函数、析构函数和赋值操作符。伙计，每当我在课上没有声明什么东西时，这意味着我不需要它，而不是我忘记了。你们这些编辑们，听到了吗?!

[4]模板语法。哦，我真的需要输入所有这些“<”和“>”，每当我决定从类主体提取定义?

[3]字符串。天啊，我受够了“const char*”，我必须处理NULL情况，我必须浪费O(N)来获得它的长度，我必须为concat操作分配缓冲区。

[2] Macroprocessing。每当我不明白，什么是我的编译器，我开始寻找宏。

[1]操作符重载。我看到代码“A + B * C”，在我看到A、B和C的实际类型之前，我说不出这个代码是关于什么的。

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.

我讨厌Java的五个方面:

没有一级函数。 没有类型推断。 缺乏理智的默认值在eg图形。 NullPointerException不包含更多关于什么是null的信息。 毫无意义的“可配置”框架/服务提供者接口/工厂类/依赖注入系统的激增。可配置性几乎从未使用过，严重违反了DRY，代码的大小增加了四倍，易读性减少了一半。

我知道，我应该试试Scala。