C

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 :( 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. 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. 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? 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++

Template syntax is heavy and unweildy. Let's see, for(map<string, int>::const_iterator it = mymap.begin(); it != mymap.end(); ++it). Design errors in the STL. Should changing allocation strategy for your vector really change its type? 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... Incredibly long and unwieldy error messages from templates. You know what I mean... 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.

Ruby是我最喜欢的语言，以下是我不喜欢的语言:

绿色线程+阻塞C库=巨大的失败 慢得令人痛苦 标准库本身与其使用bang!方法 模块包含+扩展是混乱的。 “开放类”不能是范围-我想添加一个String#dostuff，但我不希望泄漏到所有的第三方库 没有二进制部署打包解决方案。

C#

我的大部分抱怨都与假设c++约定自动成为c#的最佳选择有关

Class接口中不允许静态。这仍然是课程的一部分。为什么它不能成为界面的一部分?我不得不想出这么愚蠢的变通办法。 区分大小写。我知道在这一点上它会破坏遗留的应用程序，但为什么不区分大小写不是一开始的规则

对于。net的好处之一(不是c#特有的)

编译器不够聪明。在。net 3中。X，编译器可以找出“var”在编译时，为什么不其他常见的优化?我们都知道string和StringBuilder / immutable和mutable的区别。为什么编译器不为你转换它在很多情况下，显然StringBuilder比多个connect .s更好?我相信在默认情况下，编译器可以为我们做大量的其他优化(带有否决选项)，并为我们节省大量的时间。

Perl代表了一种可怕的语言。

No "public" or "private" or "protected" declarations/definitions. The "my $variable_name;" does not declare a global outside of a subroutine. The "my $variable_name;" gets accessed by subroutines but "use strict;" or other "use " creates warnings. Function prototypes end up unexplained, undemonstrated, unwanted, or some other excuse. Overzealous symbol use ends up "cool and quick" when reading globs of symbols. When one gets hot they like to stay hot, and need nothing to cool them. After a week of Perl, I end up unable to write a function and prototype it. What exactly is a module and does it actually NEED a ".pm" extension? If you want to create a public variable and access it from inside a subroutine, how do you accomplish this without creating a warning? Where do you find some neat scripts that teach one some neat Perl?

Ruby有许多与速度相关的缺陷，但我并不讨厌它们。它也有社区传福音过度的缺陷，但这并没有真正困扰我。以下是我最讨厌的:

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.

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)