C#

1)缺乏为值类型编写泛型的实际能力。例如，任何白痴(好吧，大多数白痴)都可以编写一个例程，用c++计算int, float, double等列表的标准偏差，它写起来很简单，易于阅读，并作为快速的非泛型代码执行。我认为，如果你能用c#写一些东西，接近于达到这三个中的任何一个，而在其他两个上又不荒谬，你就是一个真正伟大的程序员。

2)协方差和反方差，尽管这被添加到4。

3)非常糟糕的LINQ文档(好吧，并不是语言的一部分)。

4)尝试使用foreach/迭代器，当我每次都想做同样的事情，除了上次略有不同(如连接一串字符串与逗号之间的单词和最后两个)。如果我用一个IEnumerable来写它，它很难写和读，而用一个for (int I =0 I <…)它并没有好到哪里去，而且效率更低。

5)我知道我会收到抱怨，但是缺少受控的例外。这并不需要像在java中那样实现(框架开发人员确实提出了一些很好的观点，为什么他们没有这样做)，但我很乐意看到编译器警告不喜欢受控异常的用户可以关闭。

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.

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)

Haskell(包括所有GHC扩展，而不仅仅是Haskell'98的基础规范)。

我讨厌它的一点是:它不是主流。

我对特尔斐的5分:

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();) Try/Finally and Try/Except needs to be nested (stated once before, but it's still one of mine as well). Not case sensitive. 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. 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. 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.

REBOL

REBOL是我最喜欢的语言之一。我不能说我有一个最喜欢的，尽管Haskell排名也很高。

Its odd syntax scares off many developers before they even give it a try. use [email rules url] [ ; A small DSL that sends email to people about URLs. rules: [ some [ into [ set email email! set url url! (send/subject email url reform [ "Check Out" url ]) ] ] ] ; Global context notify: func [ [catch] dsl [block!] ] [ unless parse dsl rules [ throw make error! "You screwed up somehow." ] ] ] notify [ [ a@b.com http://www.google.com ] [ b@c.com http://www.yahoo.com ] ] Recursive dialects are very easy to validate with PARSE but very difficult to evaluate. (Stacks can be helpful here.) REBOL has very poor integration with many popular technologies, particularly XML. I suspect this is partly arrogance, because the REBOL BLOCK! datatype can do almost everything XML can do. However, the real world has XML in it. No Unicode. Thanks to AltMe, REBOL's user community is very insular. I can understand why they want to use AltMe. It's written in REBOL and shows off its strengths. Unfortunately it also puts them off on their own little island.

即将到来的REBOL 3有望解决许多这些问题，除了最后一个。