似乎每个人最近都在使用动态的，未编译的潮流。我主要只使用编译的静态类型语言(C，Java，.Net)工作。我对动态语言的经验是诸如ASP(Vb脚本)，JavaScript和PHP之类的东西。在考虑动态语言时，使用这些技术给我留下了不好的印象。编译器通常会捕获诸如拼写错误的变量名以及为变量分配错误类型的值之类的东西，直到运行时才发生。即使那样，我们可能也不会注意到错误，因为它只是创建了一个新变量，并分配了一些默认值。我也从未见过intellisense在动态语言中能很好地工作，因为变量没有任何显式类型。

我想知道的是，人们对动态语言有何吸引力？就动态语言允许我们完成的事情或者在编译语言中很难做到的事情而言，主要优势是什么？在我看来，我们早就决定了，诸如未编译的asp页引发运行时异常之类的事情是一个坏主意。为什么会有这种类型的代码复活？至少在我看来，为什么Ruby on Rails看起来真的不像10年前用ASP无法完成的任何事情？

解决方案

回答

该论点比这更复杂(请阅读Yegge的文章" Is Weak Typing Strong Enough"获得有趣的概述)。

动态语言不一定没有错误检查，C＃的类型推断可能就是一个例子。同样，C和C ++具有可怕的编译检查，并且它们是静态类型的。

动态语言的主要优点是：a)能力(不一定一直使用)和b)博伊德迭代定律。

后一个原因是巨大的。

回答

尽管我还不是Ruby的忠实拥护者，但我发现动态语言确实是非常棒且功能强大的工具。

没有类型检查和变量声明的想法并不是一个太大的问题。诚然，我们必须等到运行时才能捕获这些错误，但是对于有经验的开发人员来说，这并不是真正的问题，当我们犯错时，通常可以轻松地将其解决。

它还会迫使新手更仔细地阅读他们正在写的内容。我知道学习PHP可以使我更加专注于实际键入的内容，即使使用编译语言，也可以改善我的编程。

优秀的IDE将为我们提供足够的智能感知，让我们知道变量是否已"声明"，并且它们还会尝试为我们进行某种类型推断，以便我们可以分辨出变量是什么。

我认为动态语言可以实现的功能真正使它们变得非常有趣。当然，我们可以使用编译语言执行相同的操作，但是会花费更多代码。像Python和PHP这样的语言使我们可以在更少的时间内进行开发，并且在大多数情况下可以更快地获得功能代码库。

作为记录，我是.NET的专职开发人员，并且我喜欢编译语言。我只在业余时间使用动态语言来了解有关它们的更多信息，并且可以更好地成为一名开发人员。

回答

我们反对动态语言的说法是完全正确的。但是，请考虑以下事项：

• 动态语言不需要编译：只需运行它们即可。在大多数情况下，我们甚至可以在运行时重新加载文件而无需重新启动应用程序。
• 动态语言通常不那么冗长，更易读：我们是否曾经看过以静态语言实现的给定算法或者程序，然后将其与Ruby或者Python相提并论？通常，我们正在考虑将代码行减少3倍。在动态语言中，不需要太多的脚手架代码，这意味着最终结果更具可读性，并且更加专注于实际的实际问题。
• 不必担心输入问题：使用动态语言进行编程时，通常的方法是不必担心输入：大多数情况下，正确的参数会传递给方法。有时，有人可能会使用另一种恰好也起作用的论点。当出现问题时，程序可能会停止，但是如果我们进行了一些测试，这种情况很少发生。

我也觉得刚开始离开安全的静态类型有点恐惧，但是对我来说，优点远大于缺点，而且我从不回头。

回答

我认为原因是人们习惯了具有非常有限且缺乏表现力的类型系统的静态类型语言。这些语言是Java，C ++，Pascal等语言，而不是朝着更具表现力的类型系统和更好的类型推断的方向发展(例如，在Haskell中，甚至在某种程度上甚至是SQL)，有些人喜欢保持所有"类型"信息都在他们的头脑中(以及在他们的测试中)，并且完全消除了静态类型检查。

这到底能为我们带来什么，目前尚不清楚。关于类型检查的观念很多，我最常遇到的是这两个。

谬误：动态语言不那么冗长。误解是类型信息等于类型注释。这是完全不正确的。我们都知道类型注释很烦人。机器应该能够弄清楚这些东西。实际上，在现代编译器中也是如此。这是两行Haskell(来自haskell.org)中的静态类型的QuickSort：

qsort []     = []
qsort (x:xs) = qsort (filter (< x) xs) ++ [x] ++ qsort (filter (>= x) xs)

这是LISP中的动态类型的QuickSort(来自swisspig.net)：

(defun quicksort (lis) (if (null lis) nil
  (let* ((x (car lis)) (r (cdr lis)) (fn (lambda (a) (< a x))))
    (append (quicksort (remove-if-not fn r)) (list x)
      (quicksort (remove-if fn r))))))

Haskell示例伪造了静态类型的假设，因此比较冗长。 LISP示例伪造了冗长的假设，因此是静态类型的。在键入和详细程度之间的任何方向都没有暗示。我们可以放心地将其排除在外。

谬论：静态类型的语言必须编译而不是解释。再次，不是真的。许多静态类型的语言都有解释器。有Scala解释器，Haskell的GHCi和Hugs解释器，当然，SQL是静态类型的，而且解释的时间比我活着还长。

我们知道，也许充满活力的人群只是希望自由而不必对自己在做什么进行认真思考。该软件可能不正确或者功能强大，但不一定必须如此。

就我个人而言，我认为那些放弃类型安全以购买一点暂时性自由的人既不应该享有自由，也不应该拥有类型安全。

回答

我对动态语言的欣赏与它们的功能密切相关。 Python的列表理解，Ruby的闭包以及JavaScript的原型对象都是这些语言非常吸引人的方面。所有这些功能还具有一流的功能，这是我再也看不到的生活。

我不会以相同的方式对PHP和VB(脚本)进行分类。对我来说，那些主要是命令式语言，具有我们建议的所有动态键入缺点。

当然，我们不会获得相同级别的编译时检查(因为没有编译时)，但是我希望静态语法检查工具会随着时间的推移而发展，至少可以部分解决该问题。

回答

针对动态语言指出的优势之一是仅能够更改代码并继续运行。无需重新编译。在VS.Net 2008中，调试时实际上可以更改代码并继续运行，而无需重新编译。随着编译器和IDE的发展，使用动态语言的优势和其他优势可能会消失。

回答

VBScript很烂，除非我们将其与另一种VB风格进行比较。
PHP是可以的，只要我们记住它是一种过长的模板语言即可。
现代Javascript很棒。真的。吨的乐趣。只是远离所有标记为" DHTML"的脚本。

我从未使用过不允许运行时错误的语言。恕我直言，这在很大程度上是一条红线：编译器不会捕获所有错别字，也不会验证意图。当我们需要显式类型时，显式键入非常有用，但是在大多数情况下，不需要。在"泛型"上搜索有关问题的信息，或者在大多数情况下，使用无符号类型是否是索引变量的一个不错的选择，这些东西会妨碍工作，并让人们在有时间的时候不停旋转他们的手。

但是，我还没有真正回答问题。动态语言为何具有吸引力？因为过了一会儿，编写代码变得乏味，而我们只想实现该算法。我们已经坐好了，用笔解决了所有问题，图解了潜在的问题场景并证明了它们可以解决的，剩下要做的就是编写二十行实现代码和两百行样板代码以进行编译。然后，我们意识到我们使用的类型系统并不能反映实际工作，但是其他人对我们可能正在做的事情却过于抽象，而我们很久以前就放弃了编程，以至于对其进行了细微的调整。强迫性的，甚至会使虚构的侦探阿德里安·蒙克(Adrian Monk)感到羞耻。

从那时起，我们便开始认真研究动态语言。

回答

就我个人而言，我认为只是我们使用的大多数"动态"语言恰好只是一般语言的不良示例。

我在Python中比在C或者Java中生产力更高，这不仅是因为我们必须执行edit-compile-link-run舞蹈。我在Objective-C方面变得越来越有生产力，但是由于框架的原因，这可能更多。

不用说，在这些语言中，我比PHP更有效率。地狱，我宁愿使用Scheme或者Prolog进行编码，也不愿使用PHP。 (但是最近我实际上在做Prolog上比其他任何事情都多，所以请加一点盐！)

回答

我是一名全职的.Net程序员，深深扎根于静态类型C＃的阵痛。但是，我喜欢现代JavaScript。

总体而言，我认为动态语言比静态类型的语言更简洁地表达意图，因为在很多情况下，当它们花费很多时间和空间来定义要表达的内容时，它们所花的时间和空间会更少。

我认为动态语言也有多种。我不想回到用VBScript编写经典ASP页面的过程。为了有用，我认为动态语言需要在其核心支持某种收集，列表或者关联构造，以便可以表达对象(或者对象的传递)，并允许我们构建更复杂的构造。 (也许我们都应该只用LISP编写代码……这是个玩笑……)

我认为在.Net圈子中，动态语言会受到不良的说唱，因为它们与VBScript和/或者JavaScript相关联。由于Kibbee所说的许多原因，VBScript只是一场噩梦而已-有人记得使用CLng在VBScript中强制类型，以确保获得足够的位数来容纳32位整数。另外，我认为JavaScript仍被视为下拉菜单的浏览器语言，对所有浏览器而言，编写方式都不同。在这种情况下，问题不是语言，而是各种浏览器对象模型。有趣的是，Cmatures越多，它看起来就越动态。我喜欢Lambda表达式，匿名对象和类型推断。每天感觉都更像JavaScript。

回答

不要忘记，我们需要在单元测试中编写10倍的代码覆盖率来替换编译器的工作：D

我去过那里，是使用动态语言完成的，我绝对看不到任何优势。

回答

对我来说，动态语言的优势在于，由于较少的代码和功能技术(如Ruby的代码块和Python的列表理解)，代码变得更具可读性。

但是然后我有点想念编译时检查(确实发生了打字错误)和IDE自动完成的情况。总体而言，较少的代码和易读性为我带来了回报。

另一个优点是该语言通常具有解释性/非编译性。更改一些代码，然后立即查看结果。在开发过程中确实节省了时间。

最后但并非最不重要的一点是，我喜欢这样的事实，我们可以启动控制台并尝试不确定的内容，例如从未使用过的类或者方法，并查看其行为。控制台有很多用途，我只供我们弄清楚。

回答

我认为这种说法有点愚蠢："通常在编译器捕获到的东西，例如拼写错误的变量名以及为变量分配错误类型的值，直到运行时才会发生"。 PHP开发人员直到运行时，我才看不到错误输入变量的情况，但对我而言，运行时是步骤2，在C ++中(链接和编译之后)，它是步骤3.
更不用说在我的代码准备好运行时，从保存到保存需要花费几秒钟的时间，而在编译语言中，这可能要花几个小时。如果这听起来有点生气，我感到很抱歉，但是我有点厌倦了人们将我视为二等程序员，因为我不必编译我的代码。

回答

Here is a statically typed QuickSort in two lines of Haskell (from haskell.org):

qsort []     = []
qsort (x:xs) = qsort (filter (< x) xs) ++ [x] ++ qsort (filter (>= x) xs)

  
  And here is a dynamically typed QuickSort in LISP (from swisspig.net):

(defun quicksort (lis) (if (null lis) nil
  (let* ((x (car lis)) (r (cdr lis)) (fn (lambda (a) (< a x))))
    (append (quicksort (remove-if-not fn r)) (list x)
      (quicksort (remove-if fn r))))))

我认为我们在此处选择语言时会产生偏见。众所周知，Lisp太重了。与Haskell更为接近的等价词是Python。

if len(L) <= 1: return L
return qsort([lt for lt in L[1:] if lt < L[0]]) + [L[0]] + qsort([ge for ge in L[1:] if ge >= L[0]])

此处的Python代码

回答

因为它很有趣很有趣。不用担心内存分配是一件很有趣的事情。不等待编译很有趣。等等等等

回答

阅读其他人的回答时，动态语言似乎或者多或者少地包含三个参数：

1)代码不太冗长。
我认为这无效。某些动态语言不如某些静态语言那么冗长。但是Fis是静态类型的，但是那里的静态类型并没有添加太多(如果有的话)代码。虽然它是隐式键入的，但这是另一回事。

2)"我最喜欢的动态语言X具有我最喜欢的功能特征Y，因此动态性更好"。不要将功能性和动态性混为一谈(我不明白为什么要这么说)。

3)在动态语言中，我们可以立即查看结果。新闻：我们也可以使用Cin Visual Studio(自2005年起)做到这一点。只需设置一个断点，在调试器中运行程序，然后在调试时修改程序即可。我一直都这样做，而且效果很好。

我本人是静态类型的坚定拥护者，其主要原因之一是：可维护性。我有一个包含两万行JavaScript的系统，由于(不存在的)编译器不会告诉我变量重命名弄乱了什么，所以我想做的任何重构都将花费半天左右的时间。那就是我自己写的代码，IMO的结构也很好。我不想让别人负责编写等效的动态系统。

我想我会为此而被否决，但我会抓住机会。

回答

啊，当我发布类似的问题时，我没有看到此主题

除了良好的功能之外，这里提到的其他有关动态语言的人们，我认为每个人都忘记了一个最基本的东西：元编程。

对程序进行编程。

通常，以编译语言很难做到，例如，.Net。要使其正常工作，我们必须制作各种曼波舞(mambo jumbo)，并且通常以运行速度慢约100倍的代码结尾。

大多数动态语言都有进行元编程的方式，这使我能够在内存中创建任何类型的代码并将其完美地集成到我的应用程序中。

例如，要在Lua中创建计算器，我要做的就是：

print( loadstring( "return " .. io.read() )() )

现在，尝试在.Net中执行此操作。

回答

我认为两种风格都有其长处。在我看来，这种"或者"思维对我们的社区来说是一种残废。我在从上到下都是静态类型的体系结构中工作，这很好。我最喜欢的体系结构是用于UI级别的动态类型和用于功能级别的静态类型。这也鼓励了将UI和功能分离的语言障碍。

成为愤世嫉俗的人，可能只是因为动态语言使开发人员变得更懒惰，并且使他们对计算的基本知识更少了而把事情做好了。这是好事还是坏事取决于读者:)

回答

FWIW，在大多数应用程序上编译不需要花费数小时。我已经处理了200-500k行之间的应用程序，这些程序需要几分钟的时间来编译。当然不是几个小时。

我自己更喜欢编译语言。我觉得调试工具(根据我的经验，可能并非对所有情况都适用)更好，而IDE工具则更好。

我喜欢能够将Visual Studio添加到正在运行的进程。其他IDE可以做到吗？也许吧，但我不知道他们。我最近一直在做一些PHP开发工作，老实说这还不是很糟糕。但是，我更喜欢Cand VS IDE。我觉得我工作得更快，调试问题也更快。

因此，相对于动态/静态语言问题，对我来说，这更像是一个工具集吗？

最后一句话...如果我们正在使用本地服务器进行开发，则保存比编译快，但是通常我无法访问本地计算机上的所有内容。数据库和文件共享位于其他位置。通过FTP到Web服务器，然后运行我的PHP代码仅是为了发现错误，并且必须修复并重新进行FTP，这比较容易。

回答

在一定情况下的生产力。但这只是我所知道的一种环境，与我所知道或者已经看到的其他一些环境相比。

与ASP.Net(/ MVC)，RoR或者Wicket相比，带有Seaside的Squeak / Pharo上的Smalltalk是效率更高，效率更高的Web平台，适用于复杂的应用程序。直到我们需要与其中包含一个库但不包含Smalltalk的库进行交互。

拼写错误的变量名称在IDE中为红色，IntelliSense可以工作，但不那么具体。网页上的运行时错误不是问题，而是一项功能，一键调出调试器，一键到我的IDE，修复调试器中的错误，保存并继续。对于简单的错误，此周期的往返时间少于20秒。

回答

动态语言反击

http://www.youtube.com/watch?v=tz-Bb-D6teE

讨论动态语言，哪些是肯定的，以及有多少否定不是真的。

回答

弱类型的语言使我们可以灵活地管理数据。

去年春天，我在几个类中使用了VHDL，我喜欢它们表示位/字节的方法，并且喜欢尝试将6位总线分配给9位总线时编译器如何捕获错误。我试图在C ++中重新创建它，但我一直在努力地使输入类型与现有类型一起平滑地工作。我认为，Steve Yegge在描述强类型系统所涉及的问题方面做得非常好。

关于冗长性：我发现Java和Cto在大型语言中非常冗长(让我们轻而易举地选择小型算法来"证明"观点)。而且，是的，我都写过。 C ++也在同一领域中挣扎。 VHDL在这里屈服。

简约似乎是动态语言的优点(我以Perl和Fas为例)。

回答

我认为，对动态类型语言的"新发现的爱"与某些类型的动态语言的普及程度相比，绝对类型上静态类型的语言是好是坏，与之无关。 Ruby on Rails显然是一个引起动态语言复兴的大现象。使rails如此流行并从静态阵营中产生大量转换的原因主要是：非常简洁和DRY的代码和配置。与需要大量XML配置的Java Web框架相比，尤其如此。许多Java程序员聪明的人也进行了转换，甚至还传播了ruby和其他动态语言。对我来说，三个独特的功能使像Ruby或者Python这样的动态语言更加简洁：

• 极简主义语法-最大的优点是不需要类型注释，而且语言设计者从一开始就将语言设计得简洁
• 内联函数语法(或者lambda)-编写内联函数并将其作为变量传递的能力使许多代码更加简短。对于列表/数组操作尤其如此。这种想法的根源显然是LISP。
• 元编程-元编程是使rails滴答作响的重要组成部分。它带来了一种重构代码的新方法，该方法使库的客户端代码更加简洁。这也源自LISP。

所有这三个功能并非动态语言所独有，但在当今流行的静态语言：Java和C＃中肯定不存在。我们可能会在代表中争论Chas＃2，但我会说它在诸如列表操作之类的应用中并未得到广泛使用。

至于更高级的静态语言... Haskell是一种很棒的语言，它具有＃1和＃2，尽管它没有＃3，但是它的类型系统非常灵活，以至于我们可能不会发现缺少元数据限制。我相信我们可以在编译时使用语言扩展在OCaml中进行元编程。 Scala是最近才添加的，并且非常有前途。 F.NET阵营。但是，这些语言的用户很少，因此他们并没有真正为编程语言领域的这一变化做出贡献。实际上，我非常相信Ruby的流行，除了其他动态语言之外，还以积极的方式影响了Haskell，OCaml，Scala和Fin等语言的流行。

回答

我喜欢动态(类型化，因为这似乎是线程的重点)语言的主要原因是，我在工作环境中使用的语言要远远优于我所使用的非动态语言。 C，C ++，Java等……它们都是完成实际工作的可怕语言。我很想看到一种隐式类型的语言，它与许多动态类型的语言一样自然。

话虽这么说，但某些类型的构造在动态类型的语言中却是惊人的。例如，在Tcl中

lindex $mylist end-2

我们传递" end-2"以指示所需索引的事实对于读者而言简明扼要且显而易见。我还没有看到实现这种效果的静态类型语言。

回答

让自己代替一个全新的程序员来选择一种语言开始，他们不关心动态，静态，lambda，这种，那种等等。我们会选择哪种语言？

C＃

using System;
class MyProgram
{
    public static void Main(string[] args)
    {
        foreach (string s in args)
        {
            Console.WriteLine(s);
        }
    }
}

卢阿：

function printStuff(args)
    for key,value in pairs(args) do
       print value .. " "
    end
end
strings = {
    "hello",
    "world",
    "from lua"
}
printStuff(strings)

回答

我认为我们需要不同类型的语言，这取决于我们要实现的目标或者要解决的问题。如果我们想要一个应用程序可以通过互联网从数据库中创建，检索，更新和删除记录，那么最好只用一行ROR代码(使用脚手架)来完成，而不是使用静态类型的语言从头开始编写它。使用动态语言可以使我们摆脱思考的烦恼

• 哪个变量具有哪种类型
• 如何根据需要动态增长字符串
• 如何编写代码，以便如果我更改一个变量的类型，则不必重写与之交互的所有函数

解决更接近业务需求的问题，例如

• 数据正在数据库中保存/更新等，如何使用它来驱动网站流量

无论如何，松散类型语言的一个优点是，如果它的行为与预期的一样，我们就不必在意它是什么类型。这就是我们对动态类型的语言进行鸭式输入的原因。这是一个很棒的功能，我可以使用相同的变量名来存储需要存储的不同类型的数据。同样，静态类型的语言迫使我们像机器一样思考(编译器如何与代码等交互)，而动态类型的语言(尤其是ruby / ror)则使机器像人一样思考。

这些是我用来证明我的工作和动态语言经验的一些论点！

回答

因为我认为必须声明框的类型是愚蠢的。
类型取决于实体，而不是容器。当框的类型直接影响到内存中的位的解释方式时，就可以使用静态类型。

如果我们看一下GoF中的设计模式，我们将意识到其中的很大一部分只是为了与语言的静态特性作斗争，而没有理由将它们存在于动态语言中。

另外，我已经厌倦了不得不编写MyFancyObjectInterface f = new MyFancyObject()之类的东西。干燥原理有人吗？

回答

从理论上讲，静态类型的语言有可能具有动态语言的优势，并且从理论上讲，动态语言也有可能吮吸并引起更多的头痛而不是愉悦。

但是，实际上，动态语言使我们可以快速编写代码，而无需花太多时间，也不必担心底层细节。

是的，从理论上讲，c风格的语言可以提供类似的功能(D尝试，通过auto类型发现和dmdr来编译模块并像脚本一样运行它们)，

所以是的，反对者是正确的，因为动态性并不一定意味着更简单/更简洁的代码。

但实际上，是" Python> Java"

在C甚至Java中尝试w ="我的字符串在这里" .split()[1]。

回答

对我来说，这是一个情况问题。我花了很多时间来为网站编写Perl代码，为图形引擎编写C ++。使用两种非常不同的语言进行编程的两个完全不同的领域。

无论如何，对于我来说，动态语言的制定速度更快，因为我花费更少的时间来确保框架就位，而将更多的精力用于解决实际问题。

但是，静态语言提供了更精细的控制，这在某些应用程序(例如实时图形渲染)中可能是必需的。我可以用C ++来执行比我为Perl编写的程序更高效，更快的工作，但是对于大多数Perl脚本而言，效率的损失可以忽略不计。

最后，它实际上取决于问题陈述和目标目标。如果我们有很多简单的事情要做，而速度和内存效率并不重要，请使用动态语言。如果我们有一个巨石项目需要从系统中挤出每个最后的周期，请保持静态。

回答

这全部归结为适合于特定目标的部分内容以及常见的个人偏好。 (例如，这将是一个庞大的代码库，由更多人维护，而不是可以在一起进行合理的会议？我们想要类型检查。)

私人方面是权衡一些检查和其他步骤以提高开发和测试速度(同时可能会放弃某些CPU性能)。有些人可以解放这种语言并提高性能，而有些人则相反，是的，它的确也取决于我们语言的特殊风格。我的意思是，这里没有人说过Java会促进快速简洁的开发，或者说PHP是一种可靠的语言，我们几乎不会发现拼写错误。

回答

我喜欢静态和动态语言。自2002年左右以来，我参与的每个项目都是一个带有嵌入式Python解释程序的C / C ++应用程序。这使我两全其美：

• 对于应用程序的给定版本，组成应用程序的组件和框架是不可变的。它们还必须非常稳定，因此必须经过良好测试。静态类型的语言是构建这些部件的正确选择。
• 组件的连接，组件DLL的加载，插图，大多数GUI等...可以有很大的不同(例如，为客户端定制应用程序)，而无需更改任何框架或者组件代码。动态语言是完美的选择。

我发现静态类型的语言(用于构建系统)和动态类型的语言(用于配置系统)的混合为我提供了灵活性，稳定性和生产率。

回答"对动态语言的热爱是什么？"的问题。对我来说，它是在运行时以任何可以想象的方式完全重新连接系统的功能。我将脚本语言视为"运行节目"，因此正在执行的应用程序可能会执行我们想要的任何事情。

回答

我一般对动态语言没有太多经验，但是我绝对喜欢一种动态语言，JavaScript(又名ECMAScript)。

好吧，等等，这里的讨论是什么？动态编译？还是动态打字？ JavaScript涵盖了这两种基础，所以我想我将同时讨论这两种：

动态编译：

首先，将编译动态语言，只是将编译推迟到以后。 Java和.NET实际上被编译了两次。一次是使用它们各自的中间语言，然后是动态地使用机器代码。

但是，推迟编译后，我们可以更快地看到结果。那是优势之一。我确实喜欢简单地保存文件，并很快看到我的程序在运行。

另一个优点是我们可以在运行时编写和编译代码。我不知道在静态编译的代码中是否可行。我想一定是这样，因为编译JavaScript的最终都是机器代码，并且是静态编译的。但是用动态语言来说，这是一件微不足道的事情。代码可以自行编写和运行。 (而且我非常确定.NET可以做到这一点，但是.NET编译到的CIL总是动态地动态编译的，在C＃中并不是那么简单)

动态输入：

我认为动态类型比静态类型更具表现力。请注意，我非正式地使用"表达"一词来表示动态类型可以说的少而多。这是一些JavaScript代码：

var Person = {};`

你知道人现在是什么吗？这是一本通用词典。我可以做这个：

Person["First_Name"] = "John";
Person["Last_Name"] = "Smith";

但这也是一个对象。我可以像这样引用任何"键"：

Person.First_Name

并添加我认为必要的任何方法：

Person.changeFirstName = function(newName) {
  this.First_Name = newName;
};

当然，如果newName不是字符串，可能会出现问题。即使有，它也不会立即被捕获，但是我们可以检查一下自己。为了安全起见，要交换表达能力和灵活性。我不介意自己添加代码来检查类型等，而且我还没有遇到类型错误，这给我带来很多麻烦(而且我知道这并没有说太多。这可能是时间问题： ))。但是，我非常喜欢这种动态适应的能力。

回答

关于同一主题的不错的博客文章：Python使我紧张

Method signatures are virtually
  useless in Python.  In Java, static
  typing makes the method signature into
  a recipe: it's all the shit you need
  to make this method work. Not so in
  Python.  Here, a method signature will
  only tell you one thing: how many
  arguments you need to make it work. 
  Sometimes, it won't even do that, if
  you start fucking around with
  **kwargs.