MEL(玛雅表达语言):

Single dimensions arrays: Forcing me to manually sync two or more lists, or use delimited strings to simulate more complex data structures. Naturally, they're immutable too. Single threaded and slow: Causing the entire Maya application to hang while it completes a task. Bonus points for not being able to kill long operations, instead having to close and re-open Maya. Script sourcing paths aren't recursive: Meaning every directory you want to store scripts in must all be added to the script path. No namespaces: Forcing the inconsistent use of naming conventions to make sure global procedures don't collide. Modal commands: Each command is modal, meaning the Create, Modify, and Query operations are all handled by setting flags. This also forced the developers to cause most of the commands to return arrays Inconsistent command style: Most array commands actually return arrays, but the Tokenize command has to take an array as a reference which it then populates, rather than spitting out an array. This among other inconsistencies.

这些以及其他几个原因是AutoDesk采用Python作为次要脚本语言的原因，这带来了其他一些令人讨厌的因素:

并不是所有的MEL命令都受支持:大多数都受支持，但有时您会发现自己不得不使用MEL()函数来执行一些任意代码。更糟糕的是，你不得不对它进行所有烦人的逃避。 继承了模态命令风格:必须使用相同的create=True, query=True, edit=True的东西。

TCL

这是我最喜欢的语言，几乎可以做任何事情。多年来，它已经(慢慢地，非常缓慢地)演变为解决大多数让我烦恼的事情。而且这门语言非常灵活，很容易实现语法来覆盖那些仍然困扰我的东西。但是语言中有一些东西是不能轻易改变的，只是打破了它的禅意:

Arrays (of the associative kind, what Perl calls hash) don't have proper value semantics. This makes them awkward to pass to and return from functions. Also, this means that they can't be nested. For this reason dicts (dictionaries) were invented but too late, the nice array access syntax: $array($foo) is now forever taken by stupid arrays for backwards compatibility. We're now stuck with: dict get $dict $foo which is much more verbose and to me feels less readable. No real closures. Though it can be emulated somewhat by globals or namespaces but that defeats the reason for closures in the first place. Although, I can't really see for now how closures can be implemented in a pure value semantics system. Teacup is hard to use and is not at all intuitive compared to all other repository tool out there. This is more ActiveState's fault than tcl-core and doesn't really break tcl's Zen when coding but it is still very annoying.

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有望解决许多这些问题，除了最后一个。

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.

C#

5. 空合并运算符

的? ?运算符允许你写:

x = y ?? z;

而不是:

x = (y == null) ? y : z;

我喜欢这个运算符，但我想要另一个:

x = y ??? y.foo() : z.foo();

而不是

x = (y == null) ? y.foo() : z.foo();

我一直在使用这种东西，而且我发现输入== null部分很烦人。

4. 平等应该有更好的支持

我必须启动每个Equals(object obj)方法: MyClass other = obj作为MyClass; If (other == null)返回false;

你只需要写:

public override bool Equals(MyClass other) {...}

语言应该注意提供Equals(object obj)方法。 注意:other必须保证不为空。

3.不能使用不同类型的三元运算符

这不能编译，我认为它应该编译!

string foo = "hello";
int bar = 4;
object baz = foo == null ? foo : bar;

2. 缺少命名空间private

我喜欢内部保护，但我希望有一种保护只允许从同一名称空间内进行访问。这样可以更好地控制大型类库的访问。

1. 没有多重继承

我实际上只对接口的默认实现使用实现(类)继承，但很多时候我想这样做。

Python

没有名称空间。 伪私有属性/名称混淆(主要使用getattr)。 文件路径操作分布在多个模块中。串在一起的os。路径调用是丑陋的，难以读取，并且在大多数情况下违反了DRY。常见的文件路径操作仍然没有方便的函数，比如获取目录下的文件列表。修复此问题的路径类型模块被拒绝。

([f for f in os.listdir('/file/path') if os.path.isfile(os.path. isfile)加入(/文件/路径,f))))

Python文档(我非常、非常、非常感谢有文档，而且它的格式很好，但我讨厌费力地在5000行快速入门使用示例中找到特定模块的单个函数文档(我正在查看optparse和logging))。内置类型在近10个不同的地方被零碎地记录。