R

不是我最喜欢的语言，但我经常使用它，有很多抱怨……

S3对象只是美化了的列表，S4类仍然将所有数据公开给用户 赋值操作符可以是<- ->或=，参见Mike Dewar的咆哮 我的。var是一个非常令人困惑的OO语言变量命名约定，参见谷歌的风格指南 我不应该后悔使用循环 神秘的错误消息

我讨厌Java(目前它是我最喜欢的语言)的五个方面，排名不分先后。

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). The way Object.clone() and the Cloneable interfaces work is totally broken. 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. 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. 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. 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).

Perl

我喜欢这门语言，我不想添加已经被使用过的东西，但还没有人提到过这一点，所以我就把它扔到锅上。当我使用这个特性时，我发现这是我一生中最可怕的经历(而且我用过汇编语言):

write()和format()函数。

它们的语法是最糟糕、最丑陋、最可怕的，但是它们并没有提供比printf()更好的功能更多的功能。任何人都不应该尝试使用这两个函数进行任何输出，因为它们有多糟糕。

我相信有人会不同意，但是当我研究它们，希望它们能解决我的问题时，我发现它们是一个“痛苦的世界”(引用Big Lebowski的话)，我希望Perl6已经消除了它们，或者更好的是完全重写它们，使它们在某种程度上更可用和有用。

Emacs Lisp

目前还没有足够的商业市场让人们全职用elisp编码 GNU Emacs vs XEmacs不兼容 Scheme中的嵌套函数很整洁，我希望elisp有[1]的概念 用于简单遍历列表的do循环或其他一些工具不是标准的(当然，您现在可以使用lambda进行映射)[1] (function (lambda(…)))[1]应该有一个简写

当然，Lisp的一个美妙之处在于，用一行代码在你自己的代码中修复这些问题并不难。但这并不是与生俱来的，这让我很恼火。

好的问题;我有点不好意思，因为我想不出更好的东西来恨，但说实话，法官大人，没什么好恨的。

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.

我真的到达这里了。我认为c#非常棒，而且很难发现它有什么缺陷。

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.