似乎每个人最近都在加入动态的、非编译的潮流。我主要只使用编译的静态类型语言（C、Java、.Net）。我在动态语言方面的经验是 ASP（Vb 脚本）、JavaScript 和 PHP。在考虑动态语言时，使用这些技术在我的嘴里留下了不好的味道。通常会被编译器捕获的事情，例如拼写错误的变量名和为变量分配错误类型的值，直到运行时才会发生。即使这样，您也可能不会注意到错误，因为它只是创建了一个新变量并分配了一些默认值。我也从未见过智能感知在动态语言中运行良好，因为变量没有任何显式类型。
我想知道的是，人们觉得动态语言有什么吸引力？就动态语言允许您做的事情而言，在编译语言中无法做到或难以做到的事情的主要优势是什么？在我看来，我们很久以前就决定，像未编译的 asp 页面抛出运行时异常是一个坏主意。为什么这种类型的代码会死灰复燃？为什么至少在我看来，Ruby on Rails 看起来不像是 10 年前用 ASP 做不到的事情？
我认为原因是人们习惯于静态类型语言，这些语言的类型系统非常有限且缺乏表达能力。这些是 Java、C++、Pascal 等语言。有些人不想朝着更具表现力的类型系统和更好的类型推断方向发展（例如在 Haskell 中，甚至在某种程度上甚至是 SQL），而是喜欢保持他们头脑中（以及他们的测试中）的所有“类型”信息，并完全取消了静态类型检查。
这到底给你带来了什么还不清楚。关于类型检查有很多误解，我最常遇到的就是这两个。
谬误：动态语言不那么冗长。误解是类型信息等于类型注释。这是完全不真实的。我们都知道类型注解很烦人。机器应该能够弄清楚这些东西。事实上，它在现代编译器中也是如此。这是两行 Haskell 中的静态类型快速排序（来自haskell.org）：
qsort [] = []
qsort (x:xs) = qsort (filter (< x) xs) ++ [x] ++ qsort (filter (>= x) xs)
这是 LISP 中的动态类型快速排序（来自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 被静态类型化和解释的时间比我活着的时间还要长。
你知道，也许充满活力的人群只是想要自由，而不必仔细考虑他们在做什么。该软件可能不正确或不健壮，但也许不必如此。
就个人而言，我认为那些放弃类型安全来购买一点临时自由的人既不值得自由也不值得类型安全。
不要忘记你需要在单元测试中编写 10 倍的代码覆盖率来替换你的编译器所做的：D
我去过那里，用动态语言做到了，我认为绝对没有优势。
在阅读其他人的回复时，动态语言似乎或多或少有三个论据：
1）代码不那么冗长。我不认为这是有效的。一些动态语言没有一些静态语言那么冗长。但是 F# 是静态类型的，但那里的静态类型不会添加太多（如果有的话）代码。但是，它是隐式类型的，但那是另一回事。
2）“我最喜欢的动态语言X有我最喜欢的功能特性Y，所以动态更好”。不要混淆功能和动态（我不明白为什么要这么说）。
3) 在动态语言中，您可以立即看到结果。新闻：您也可以在 Visual Studio（自 2005 年起）中使用 C# 来做到这一点。只需设置一个断点，在调试器中运行程序并在调试时修改程序。我一直这样做，而且效果很好。
我自己是静态类型的坚定拥护者，主要原因有一个：可维护性。我有一个包含 10k 行 JavaScript 的系统，我想做的任何重构都需要半天时间，因为（不存在的）编译器不会告诉我变量重命名搞砸了什么。那是我自己编写的代码，IMO 结构也很好。我不希望负责管理其他人编写的等效动态系统的任务。
我想我会因此而被大量否决，但我会抓住机会。
VBScript 很烂，除非您将它与另一种 VB 进行比较。PHP 没问题，只要你记住它是一种过度生长的模板语言。现代 Javascript 很棒。真的。很多乐趣。远离任何标记为“DHTML”的脚本。
我从未使用过不允许运行时错误的语言。恕我直言，这在很大程度上是一个红鲱鱼：编译器不会捕获所有错别字，也不会验证意图。当您需要显式类型时，显式类型非常有用，但大多数时候，您不需要。搜索此处的问题generics或关于使用无符号类型是否是索引变量的好选择的问题 - 很多时候，这些东西只是碍事，当人们有时间时，他们可以转动旋钮.
但是，我还没有真正回答你的问题。为什么动态语言很有吸引力？因为一段时间后，编写代码变得乏味，您只想实现算法。你已经坐下来用笔完成了所有工作，绘制了潜在的问题场景并证明了它们是可以解决的，剩下要做的就是编写二十行实现代码......以及两百行样板文件以使其编译. 然后你意识到你使用的类型系统并不能反映你实际在做什么，而是别人对你可能在做什么的超抽象想法，而且你早就放弃了编程，过着小技巧调整的生活，所以强迫症，即使是虚构的侦探阿德里安·蒙克也会感到羞耻。
那是你开始认真研究动态语言的时候。
我是一名全职 .Net 程序员，完全沉浸在静态类型 C# 的阵痛中。但是，我喜欢现代 JavaScript。
一般来说，我认为动态语言比静态类型语言更简洁地表达你的意图，因为你花费更少的时间和空间来定义你试图表达的构建块是什么，而在许多情况下它们是不言而喻的。
我认为动态语言也有多种类别。我不想回到用 VBScript 编写经典的 ASP 页面。为了有用，我认为动态语言需要在其核心支持某种集合、列表或关联构造，以便可以表达对象（或传递给对象的内容）并允许您构建更复杂的构造。（也许我们都应该用 LISP 编写代码……这是个笑话……）
我认为在 .Net 圈子中，动态语言名声不好，因为它们与 VBScript 和/或 JavaScript 相关联。由于 Kibbee 所说的许多原因，VBScript 只是一场噩梦——任何人都记得使用 CLng 在 VBScript 中强制类型以确保您有足够的位用于 32 位整数。另外，我认为 JavaScript 仍然被视为下拉菜单的浏览器语言，它为所有浏览器编写了不同的方式。在这种情况下，问题不在于语言，而在于各种浏览器对象模型。有趣的是，C# 越成熟，它看起来就越有活力。我喜欢 Lambda 表达式、匿名对象和类型推断。感觉更像是每天的 JavaScript。
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))))))
I think you're biasing things with your choice of language here. Lisp is notoriously paren-heavy. A closer equivelent to Haskell would be 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 code from here
For me, the advantage of dynamic languages is how much more readable the code becomes due to less code and functional techniques like Ruby's block and Python's list comprehension.
But then I kind of miss the compile time checking (typo does happen) and IDE auto complete. Overall, the lesser amount of code and readability pays off for me.
Another advantage is the usually interpreted/non compiled nature of the language. Change some code and see the result immediately. It's really a time saver during development.
Last but not least, I like the fact that you can fire up a console and try out something you're not sure of, like a class or method that you've never used before and see how it behaves. There are many uses for the console and I'll just leave that for you to figure out.
你反对动态语言的论点是完全有效的。但是，请考虑以下事项：
一开始我也觉得离开静态类型的安全世界有点可怕，但对我来说，优点远远超过缺点，而且我从未回头。
我相信动态类型语言的“新发现的爱”与静态类型语言是更好还是最差（绝对意义上）的关系比某些动态语言的普及程度要低。Ruby on Rails 显然是引起动态语言复兴的一大现象。让 Rails 如此受欢迎并从静态阵营中获得如此多转换的原因主要是：非常简洁和 DRY 的代码和配置。与需要大量 XML 配置的 Java Web 框架相比，这一点尤其正确。许多 Java 程序员——也有聪明的程序员——转换过来了，有些人甚至传播了 ruby 和其他动态语言。对我来说，三个不同的特性让 Ruby 或 Python 等动态语言更加简洁：
所有这三个特性都不是动态语言独有的，但它们肯定不会出现在当今流行的静态语言中：Java 和 C#。您可能会争辩说 C# 在委托中排名第二，但我认为它根本没有被广泛使用 - 例如列表操作。
至于更高级的静态语言... Haskell 是一门很棒的语言，它有 #1 和 #2，虽然它没有 #3，但它的类型系统非常灵活，你可能不会发现缺少 meta to限制。我相信您可以在编译时使用语言扩展在 OCaml 中进行元编程。Scala 是最近添加的，非常有前途。.NET 阵营的 F#。但是，这些语言的用户是少数，因此他们并没有真正为编程语言领域的这种变化做出贡献。事实上，除了其他动态语言之外，我非常相信 Ruby 的流行对 Haskell、OCaml、Scala 和 F# 等语言的流行产生了积极的影响。
就个人而言，我认为只是您使用的大多数“动态”语言恰好是一般语言的不良示例。
我在 Python 中的工作效率比在 C 或 Java 中要高得多，这不仅仅是因为您必须进行编辑-编译-链接-运行的舞蹈。我在 Objective-C 中的工作效率越来越高，但这可能更多是由于框架。
不用说，我在这些语言中的任何一种都比 PHP 更有效率。见鬼，我宁愿在 Scheme 或 Prolog 中编写代码，也不愿在 PHP 中编写代码。（但最近我实际上做的 Prolog 比其他任何事情都多，所以请谨慎对待！）
我对动态语言的欣赏很大程度上取决于它们的功能性。Python 的列表解析、Ruby 的闭包和 JavaScript 的原型对象都是这些语言非常吸引人的方面。所有这些都具有一流的功能——我再也无法看到这种功能。
我不会以同样的方式对 PHP 和 VB（脚本）进行分类。对我来说，这些主要是命令式语言，具有您建议的所有动态类型缺点。
当然，您不会获得相同级别的编译时检查（因为没有编译时），但我希望静态语法检查工具会随着时间的推移而发展，至少可以部分解决该问题。
动态语言的优点之一是能够更改代码并继续运行。无需重新编译。在 VS.Net 2008 中，调试时，您实际上可以更改代码并继续运行，而无需重新编译。随着编译器和 IDE 的进步，使用动态语言的这一优势和其他优势是否会消失。
啊，我发类似问题的时候没看到这个话题
除了这里其他人提到的关于动态语言的好特性之外，我想每个人都忘记了一个最基本的东西：元编程。
对程序进行编程。
通常，在编译语言中很难做到这一点，例如 .Net。为了让它工作，你必须制作各种 mambo jumbo，它通常以运行速度慢约 100 倍的代码结束。
大多数动态语言都有一种方法来进行元编程，这让我一直在那里 - 能够在内存中创建任何类型的代码并将其完美地集成到我的应用程序中。
例如，要在 Lua 中创建计算器，我所要做的就是：
print( loadstring( "return " .. io.read() )() )
现在，尝试在 .Net 中执行此操作。
我喜欢动态（类型化，因为这似乎是线程的重点）语言的主要原因是我使用过的那些（在工作环境中）远远优于我使用过的非动态语言。C、C++、Java 等......它们都是用于完成实际工作的可怕语言。我很想看到一种隐式类型的语言，它可以像许多动态类型的语言一样自然地编程。
话虽这么说，在动态类型语言中，某些结构令人惊叹。例如，在 Tcl
lindex $mylist end-2
您传入“end-2”以指示您想要的索引这一事实对读者来说非常简洁和明显。我还没有看到一种静态类型的语言可以做到这一点。
I think this kind of argument is a bit stupid: "Things that usually would have been caught by the compiler such as misspelled variable names and assigning an value of the wrong type to a variable don't occur until runtime" yes thats right as a PHP developer I don't see things like mistyped variables until runtime, BUT runtime is step 2 for me, in C++ (Which is the only compiled language I have any experience) it is step 3, after linking, and compiling.
Not to mention that it takes all of a few seconds after I hit save to when my code is ready to run, unlike in compiled languages where it can take literally hours. I'm sorry if this sounds a bit angry, but I'm kind of tired of people treating me as a second rate programmer because I don't have to compile my code.
这个论点比这更复杂（阅读Yegge 的文章“弱类型足够强”以获得有趣的概述）。
动态语言也不一定缺少错误检查——C# 的类型推断可能就是一个例子。同样，C 和 C++ 的编译检查很糟糕，而且它们是静态类型的。
动态语言的主要优点是 a) 能力（不一定必须一直使用）和 b)博伊德迭代定律。
后一个原因是巨大的。
虽然我还不是 Ruby 的忠实拥护者，但我发现动态语言是非常棒且强大的工具。
没有类型检查和变量声明的想法实际上并不是一个太大的问题。诚然，直到运行时您才能发现这些错误，但对于有经验的开发人员来说，这并不是一个真正的问题，而且当您确实犯了错误时，它们通常很容易修复。
它还迫使新手更仔细地阅读他们正在写的内容。我知道学习 PHP 教会了我更专注于我实际输入的内容，这改进了我的编程，即使是在编译语言中也是如此。
好的 IDE 会为您提供足够的智能感知，让您知道变量是否已“声明”，并且它们还会尝试为您进行一些类型推断，以便您知道变量是什么。
在我看来，动态语言的强大功能确实让它们变得如此有趣。当然，你可以用编译语言做同样的事情，但需要更多的代码。Python 和 PHP 等语言可以让您在更短的时间内进行开发，并在大多数情况下更快地获得功能代码库。
郑重声明，我是一名全职 .NET 开发人员，我喜欢编译语言。我只在空闲时间使用动态语言来了解更多关于它们的信息，并让自己成为一名开发人员。
我认为我们需要不同类型的语言，具体取决于我们试图实现或解决的问题。如果我们想要一个通过互联网从数据库中创建、检索、更新和删除记录的应用程序，我们最好使用一行 ROR 代码（使用脚手架）来完成它，而不是使用静态类型语言从头开始编写它。使用动态语言可以让大脑从疑惑中解放出来
更接近业务需求的问题，例如
无论如何，松散类型语言的一个优点是我们并不真正关心它是什么类型，如果它表现得像它应该做的那样。这就是我们在动态类型语言中使用鸭子类型的原因。这是一个很棒的功能，我可以在需要时使用相同的变量名称来存储不同类型的数据。此外，静态类型语言迫使您像机器一样思考（编译器如何与您的代码交互等），而动态类型语言，尤其是 ruby/ror，迫使机器像人类一样思考。
这些是我用来证明我在动态语言方面的工作和经验的一些论据！
一般来说，我对动态语言没有太多经验，但是我知道的一种动态语言 JavaScript（又名 ECMAScript），我非常喜欢。
好吧，等等，这里讨论的是什么？动态编译？还是动态类型？JavaScript 涵盖了这两个基础，所以我想我会讨论这两个：
动态编译：
首先，编译动态语言，编译只是推迟到以后。Java 和 .NET 确实被编译了两次。一次是他们各自的中间语言，然后是动态地，再次是机器代码。
但是当编译被推迟时，您可以更快地看到结果。这是一个优势。我很喜欢简单地保存文件并很快看到我的程序运行。
另一个优点是您可以在运行时编写和编译代码。这在静态编译的代码中是否可行，我不知道。我想它一定是，因为编译 JavaScript 的最终都是机器代码和静态编译的。但在动态语言中，这是一件微不足道的事情。代码可以自己编写和运行。（而且我很确定 .NET 可以做到这一点，但是 .NET 编译成的 CIL 无论如何都是动态编译的，而且在 C# 中并不是那么简单）
动态类型：
我认为动态类型比静态类型更具表现力。请注意，我非正式地使用表达性一词来表示动态类型可以用更少的东西说更多。下面是一些 JavaScript 代码：
var Person = {};
你知道现在的人是什么吗？这是一本通用字典。我可以做这个：
人["First_Name"] = "约翰"; 人["姓氏"] = "史密斯";
但它也是一个对象。我可以像这样引用这些“键”中的任何一个：
Person.First_Name
并添加我认为必要的任何方法：
Person.changeFirstName = function(newName) {
this.First_Name = newName;
};
当然，如果 newName 不是字符串，可能会出现问题。它不会立即被抓住，如果有的话，但你可以检查自己。这是一个用表达能力和灵活性换取安全性的问题。我不介意自己添加代码来检查类型等，而且我还没有遇到一个让我很伤心的类型错误（我知道这没什么。这可能是时间问题： ））。然而，我非常喜欢这种即时适应的能力。
这一切都归结为适合特定目标的部分以及共同的个人偏好。（EG 这将是一个庞大的代码库，由更多的人维护，无法一起进行合理的会议？你需要类型检查。）
个人部分是关于权衡一些检查和其他步骤以提高开发和测试速度（同时可能会放弃一些 cpu 性能）。对于某些人来说，这是解放和性能提升，而对于有些人来说，这是完全相反的，是的，它也确实有点取决于你的语言的特殊风格。我的意思是这里没有人说 Java 是快速、简洁的开发，或者说 PHP 是一种可靠的语言，你很少会遇到难以发现的错字。
我喜欢静态和动态语言。自 2002 年左右以来，我参与的每个项目都是带有嵌入式 Python 解释的 C/C++ 应用程序。这给了我两全其美：
我发现构建系统的静态类型语言和配置系统的动态类型语言的混合给了我灵活性、稳定性和生产力。
回答“对动态语言的热爱是什么？”的问题。对我来说，这是在运行时以任何可以想象的方式完全重新连接系统的能力。我将脚本语言视为“运行节目”，因此执行的应用程序可以做任何你想做的事情。
我认为这两种风格都有自己的优势。在我看来，这种非此即彼的想法对我们的社区来说有点严重。我曾在从上到下静态类型化的架构中工作过，这很好。我最喜欢的架构是用于 UI 级别的动态类型和功能级别的静态类型。这也鼓励了强制分离 UI 和功能的语言障碍。
作为一个愤世嫉俗的人，可能只是动态语言允许开发人员更懒惰并且在完成工作时对计算的基础知识知之甚少。这是好事还是坏事取决于读者:)
FWIW，在大多数应用程序上编译不应该花费数小时。我曾使用过需要几分钟才能编译的 200-500k 行的应用程序。当然不是小时。
我自己更喜欢编译语言。我觉得调试工具（根据我的经验，可能并非对所有事情都如此）更好，IDE 工具更好。
我喜欢能够将我的 Visual Studio 附加到正在运行的进程。其他IDE可以做到吗？也许吧，但我不知道他们。我最近一直在做一些 PHP 开发工作，老实说，这并不是那么糟糕。但是，我更喜欢 C# 和 VS IDE。我觉得我工作得更快，调试问题也更快。
所以也许它比动态/静态语言问题对我来说更像是一个工具集？
最后一条评论...如果您正在使用本地服务器进行开发，则保存比编译要快，但通常我无法访问本地计算机上的所有内容。数据库和文件共享存在于其他地方。FTP到Web服务器然后运行我的PHP代码只是为了找到错误并且必须修复并重新ftp更容易。
特定环境下的生产力。但这只是我知道的一种环境，与我知道或见过的其他一些环境相比。
Smalltalk on Squeak/Pharo with Seaside 是一个比 ASP.Net(/MVC)、RoR 或 Wicket 更有效的 Web 平台，适用于复杂的应用程序。直到您需要与其中一个具有库但不是 smalltalk 的东西进行交互。
拼写错误的变量名称在 IDE 中显示为红色，IntelliSense 有效，但并不具体。网页上的运行时错误不是问题而是功能，一键调出调试器，一键进入我的IDE，修复调试器中的错误，保存，继续。对于简单的 bug，这个循环的往返时间小于 20 秒。
把自己放在一个全新的程序员的位置，选择一门语言开始，他不关心动态、静态、lambda、this 和 that 等等；你会选择哪种语言？
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)
因为我认为必须声明盒子的类型是愚蠢的。类型保留在实体中，而不是与容器中。当盒子的类型对如何解释内存中的位有直接影响时，静态类型是有意义的。
如果您查看 GoF 中的设计模式，您会发现其中很大一部分只是为了与语言的静态特性作斗争，而它们没有任何理由存在于动态语言中。
此外，我已经厌倦了编写 MyFancyObjectInterface f = new MyFancyObject() 之类的东西。DRY 原理有人吗？
关于同一主题的不错的博客文章：Python 让我感到紧张
方法签名在 Python 中几乎没有用处。在 Java 中，静态类型将方法签名变成了一个秘诀：这是使该方法工作所需的全部内容。在 Python 中并非如此。在这里，方法签名只会告诉您一件事：您需要多少参数才能使其工作。有时，如果您开始与 **kwargs 混在一起，它甚至都不会这样做。
因为好玩好玩好玩。一方面，不用担心内存分配很有趣。不等待编译很有趣。等等等等
弱类型语言允许您灵活地管理数据。
去年春天我在几个类中使用了 VHDL，我喜欢他们表示位/字节的方法，以及如果您尝试将 6 位总线分配给 9 位总线，编译器如何捕获错误。我试图在 C++ 中重新创建它，并且我在努力使打字能够顺利地与现有类型一起工作。我认为，Steve Yegge 很好地描述了强类型系统所涉及的问题。
关于冗长：我发现 Java 和 C# 在大方面非常冗长（我们不要挑选小算法来“证明”一个观点）。而且，是的，我都写过。C++也在同一领域挣扎；VHDL在这里屈服了。
简约似乎是一般动态语言的优点（我以 Perl 和 F# 为例）。
从理论上讲，静态类型语言可能具有动态语言的优点，从理论上讲，动态语言也可能会让人头疼而不是快乐。
然而，在实践中，动态语言允许您快速编写代码，无需太多样板，无需担心底层细节。
是的，理论上 c 风格的语言可以提供类似的功能（D 尝试，具有auto类型发现dmdr，编译模块并像脚本一样运行它们），
所以是的，反对者是对的，因为动态并不一定意味着更容易/更清洁的代码。
但是，在实践中，Python > Java
尝试w = "my string here".split()[1]使用 C，甚至 Java。
对我来说，这是一个情况问题。我花了很多时间为网站编写 Perl 代码，为图形引擎编写 C++ 代码。两个完全不同的编程领域，使用两种截然不同的语言。
无论如何，对我来说，动态语言的开发速度更快，因为我花更少的时间来确保框架到位，而更多地关注手头的实际问题。
然而，静态语言提供了更精细的控制，这在某些应用程序中可能是必需的，例如实时图形渲染。我可以在 C++ 中完成比我为 Perl 编写的更高效和更快的操作，但是对于大多数 Perl 脚本的大小而言，效率损失可以忽略不计。
最后，它真的归结为问题陈述和你的目标是什么。如果您有很多简单的事情要做，而速度和内存效率并不重要，请使用动态语言。如果您有一个巨石项目需要从系统中挤出每一个最后一个周期，请保持静态。