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

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

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.

哇，我很惊讶SQL还没有出现在这里。我猜这意味着没有人喜欢它:)

跨实现的语法不一致 细微的代码差异可能会因为看似模糊的原因而产生巨大的性能影响 对文本操作的支持很差 入门成本低，但掌握这门语言的学习曲线陡峭 最大限度地标准化社区的最佳实践，这包括语法风格。

.．.还有一些额外的讨厌它的理由，不需要额外收费

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)?

C++

太容易随机破坏内存并创建几乎不可能找到的错误(尽管Valgrind在修复这个问题上走了很长的路)。 模板错误消息。 在使用模板时，很容易将所有内容都包含在一个文件中，然后进行愚蠢的编译。 标准库在现代是一个笑话(默认情况下仍然没有线程或网络?) 大量令人讨厌的C语言(特别是所有在short/int/unsigned/等之间的转换)。

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.

C#

我对c#非常满意，但这两个真的让我很恼火:

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.