首页 / 知识

人们对动态语言有何吸引力？

2023-04-14 03:43:00

What do people find so appealing about dynamic languages?

似乎每个人最近都在跳跃着充满活力，没有编辑的潮流。我大多只使用编译的静态类型语言(C，Java，.Net)。我对动态语言的体验是ASP(Vb Script)，JavaScript和PHP。在考虑动态语言时，使用这些技术在我的嘴里留下了不好的味道。通常会被编译器捕获的事情(例如拼写错误的变量名称以及将错误类型的值分配给变量)直到运行时才会发生。即便如此，您可能也不会注意到错误，因为它只是创建一个新变量，并分配一些默认值。我也从未见过intellisense在动态语言中运行良好，因为变量没有任何明确的类型。

我想知道的是，人们对动态语言有何吸引力？动态语言允许您执行的操作无法完成或在编译语言中难以完成的主要优点是什么。在我看来，我们很久以前就决定，像未编译的asp页面抛出运行时异常这样的事情是个坏主意。为什么这类代码会重新出现？为什么至少在我看来，Ruby on Rails看起来并不像10年前你用ASP做过的任何东西？

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

这到底是什么让你不清楚。关于类型检查存在许多误解的概念，我最常见的是这两个概念。

谬误：动态语言不那么冗长。误解是类型信息等于类型注释。这完全是不真实的。我们都知道类型注释很烦人。机器应该能够找出那些东西。事实上，它在现代编译器中确实存在。这是一个静态类型的QuickSort，分为两行Haskell(来自haskell.org)：

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

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

1
2
3
4

(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的静态类型和解释时间比我还活着的时间更长。

你知道，也许充满活力的人群只是希望自由不必仔细考虑他们正在做的事情。该软件可能不正确或不健壮，但可能并非如此。

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

不要忘记您需要在单元测试中编写10x代码覆盖率来替换编译器所做的事情：D

我去过那里，用动态语言完成，我看到绝对没有优势。

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

1)代码不那么冗长。
我觉得这没有效果。一些动态语言比一些静态语言更简洁。但是F＃是静态类型的，但是那里的静态类型并没有添加太多(如果有的话)代码。但它是隐式输入的，但这是另一回事。

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

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

我自己，我是静态打字的坚定拥护者，主要原因之一是：可维护性。我有一个系统，里面有几行10k的JavaScript，我想做的任何重构都需要半天，因为(不存在的)编译器不会告诉我变量重命名的内容。这就是我自己编写的代码，IMO结构合理。我不希望被任命为其他人写的等效动态系统。

我想我会为此大力投票，但我会抓住机会。

VBScript很糟糕，除非你把它与另一种VB比较。
PHP是可以的，只要你记住它是一种过度生长的模板语言。
现代Javascript很棒。真。很有趣。只要远离任何标记为"DHTML"的脚本。

我从未使用过不允许运行时错误的语言。恕我直言，这主要是一个红鲱鱼：编译器没有捕获所有拼写错误，也没有验证意图。当您需要显式类型时，显式键入很棒，但大多数情况下，您不需要。在这里搜索关于generics的问题或关于使用无符号类型是否是索引变量的一个好选择的问题 - 大多数时候，这些东西只是妨碍了，并且当他们有时间时让人们旋转在他们的手上。

但是，我还没有真正回答你的问题。为什么动态语言很吸引人？因为过了一段时间，编写代码变得迟钝，你只想实现算法。你已经坐下来用笔，图解的潜在问题场景进行了全部工作并证明它们是可解决的，剩下要做的唯一事情就是编写二十行实现代码......以及两百行样板文件来编译。然后你意识到你使用的类型系统并没有反映出你实际在做什么，而是其他人对你可能在做什么的超抽象概念，而你很久以前就放弃了编程以进行knicknack调整，所以强迫性的，即使是虚构的侦探阿德里安·蒙克也会感到羞耻。

当你~~去涂抹开始认真看待动态语言时。~~

我是一名全职的.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):

1
2
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):

1
2
3
4
(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。

1
2
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代码来自这里

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

但后来我有点想念编译时检查(错字确实发生)和IDE自动完成。总的来说，较少的代码和可读性为我带来了回报。

另一个优点是语言的通常解释/非编译性质。更改一些代码并立即查看结果。在开发过程中真的节省了时间。

最后但并非最不重要的是，我喜欢这样一个事实：你可以启动一个控制台并尝试一些你不确定的东西，比如你以前从未使用过的类或方法，看看它是如何表现的。控制台有很多用途，我只想留下让你弄清楚。

你反对动态语言的论据是完全有效的。但是，请考虑以下事项：

动态语言不需要编译：只需运行它们。您甚至可以在运行时重新加载文件，而无需在大多数情况下重新启动应用程序。

动态语言通常不那么冗长和可读性：你是否曾经看过用静态语言实现的给定算法或程序，然后将它与Ruby或Python等价物进行比较？一般来说，您正在考虑将代码行减少3倍。动态语言中不需要很多脚手架代码，这意味着最终结果更具可读性，更专注于手头的实际问题。

不要担心输入问题：在动态语言编程时的一般方法是不要担心键入：大多数时候，正确的参数将传递给您的方法。有一段时间，有人可能会使用一种恰好同样适用的不同类型的论点。当出现问题时，您的程序可能会停止，但如果您已经完成了一些测试，则很少发生这种情况。

我也发现一开始就远离静态打字的安全世界有点可怕，但对我而言，优势远远超过了缺点，而且我从未回头。

我认为动态类型语言的"新发现的爱"与静态类型语言在绝对意义上是否优于某些动态语言的普及程度有关。 Ruby on Rails显然是一个引起动态语言复兴的重要现象。使得rails如此受欢迎并且从静态阵营中创建了如此多的转换器的主要原因是：非常简洁和干燥的代码和配置。与需要大量XML配置的Java Web框架相比，尤其如此。许多Java程序员 - 也是聪明的程序员 - 进行了转换，有些甚至传播了ruby和其他动态语言。对我来说，三个不同的功能允许像Ruby或Python这样的动态语言更简洁：

极简主义语法 - 最重要的是不需要类型注释，而且语言设计师从一开始就设计语言简洁

内联函数语法(或lambda) - 编写内联函数并将它们作为变量传递的能力使得多种代码更加简洁。特别是列表/数组操作也是如此。这个想法的根源显然是 - LISP。

元编程 - 元编程是使轨道变形的重要组成部分。它引发了一种重构代码的新方法，使您的库的客户端代码更加简洁。这也来自LISP。

所有这三个功能并不仅限于动态语言，但它们当然不存在于当今流行的静态语言中：Java和C＃。您可能认为C＃在代理中有＃2，但我认为它根本没有被广泛使用 - 例如列表操作。

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

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

我在Python中比在C或Java中更有效率，而不仅仅是因为你必须进行edit-compile-link-run舞蹈。我在Objective-C中的效率越来越高，但这可能更多是由于框架。

毋庸置疑，除了PHP之外，我在这些语言中的效率更高。好吧，我宁愿在Scheme或Prolog中编写代码而不是PHP代码。 (但是最近我实际上做了更多的Prolog而不是其他任何东西，所以拿一点盐！)

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

我不会以同样的方式对PHP和VB(脚本)进行分类。对我来说，这些主要是命令式语言，你提出了所有动态类型的缺点。

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

为动态语言指出的一个优点是能够更改代码并继续运行。无需重新编译。在VS.Net 2008中，在调试时，您实际上可以更改代码并继续运行，而无需重新编译。随着编译器和IDE的进步，使用动态语言的这一优势和其他优势是否有可能消失。

啊，当我发布类似问题时，我没有看到这个话题

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

编程程序。

在编译语言中很难做到，一般来说，例如.Net。为了使它工作，你必须制作所有类型的mambo jumbo，它通常以运行速度大约100倍的代码结束。

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

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

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

现在，尝试在.Net中这样做。

喜欢动态(键入，因为这似乎是线程的焦点)语言的主要原因是我使用的(在工作环境中)远远优于我使用的非动态语言。 C，C ++，Java等......它们都是用于完成实际工作的可怕语言。我很乐意看到一种隐式类型的语言，它可以像许多动态类型的语言一样编程。

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

1
lindex $mylist end-2

您传入"end-2"以指示您想要的索引这一事实对读者来说非常简洁明了。我还没有看到一种完成这种语言的静态类型语言。

我认为这种论点有点愚蠢："通常会被编译器捕获的东西，例如拼写错误的变量名称，并将错误类型的值分配给变量，直到运行时才出现"是的，这是正确的PHP开发人员我直到运行时才看到类错变量之类的东西，BUT运行时对我来说是第2步，在C ++中(这是我有经验的唯一编译语言)它是第3步，在链接和编译之后。

更不用说在我点击保存到我的代码准备好运行之后需要几秒钟，而不像编译语言那样需要几个小时。我很抱歉，如果这听起来有点生气，但我有点厌倦了人们把我视为二流程序员，因为我不需要编译我的代码。

这个论点比这更复杂(阅读Yegge的文章"We Weak Typing Strong Enough"，这是一个有趣的概述)。

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

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

后一个原因是巨大的。

虽然我不是Ruby的忠实粉丝，但我发现动态语言是非常精彩和强大的工具。

没有类型检查和变量声明的想法实际上并不是一个大问题。不可否认，你不能在运行时才能发现这些错误，但对于有经验的开发人员来说，这不是一个真正的问题，当你确实犯错时，它们通常很容易修复。

它还迫使新手更仔细地阅读他们正在写的内容。我知道学习PHP教会我更加关注我实际输入的内容，即使在编译语言中也改进了我的编程。

好的IDE将为您提供足够的智能感知，以便了解变量是否已被"声明"，并且他们还尝试为您做一些类型推断，以便您可以知道变量是什么。

在我看来，使用动态语言可以做什么的力量真的是让他们在工作中变得如此有趣。当然，你可以用编译语言做同样的事情，但需要更多的代码。 Python和PHP等语言可以让您在更短的时间内开发，并在大多数时间内更快地获得功能性代码库。

为了记录，我是一名全职.NET开发人员，我喜欢编译语言。我只在空闲时间使用动态语言来了解更多关于它们的信息，并且作为开发人员自己更好。

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

哪个变量具有哪种类型

如何根据需要动态增长字符串

如何编写代码，以便如果我改变一个变量的类型，我不必重写所有与它交互的函数

更接近业务需求的问题

数据在数据库中保存/更新等，我如何使用它来为我的网站带来流量

无论如何，松散类型语言的一个优点是我们真的不关心它是什么类型，如果它的行为像它应该的那样。这就是我们在动态类型语言中使用duck-typing的原因。这是一个很棒的功能，我可以根据需要使用相同的变量名来存储不同类型的数据。另外，静态类型语言迫使你像机器一样思考(编译器如何与代码交互等)，而动态类型语言，特别是ruby / ror，迫使机器像人一样思考。

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

动态语言反击

讨论动态语言的讨论，一些积极因素，以及有多少消极因素并非如此。

在某种背景下的生产力。但这只是我所知道的一个环境，与我所知道或曾经使用过的其他环境相比。

对于复杂的应用程序，Smalltalk on Sideak / Pharo with Seaside是一个比ASP.Net(/ MVC)，RoR或Wicket更有效和高效的Web平台。直到你需要与其中一个库但不是smalltalk的库接口。

在IDE中，拼写错误的变量名称为红色，IntelliSense可以正常工作但不具体。网页上的运行时错误不是问题，而是一个功能，只需单击一下即可打开调试器，单击一下IDE，修复调试器中的错误，保存，继续。对于简单的错误，此循环的往返时间少于20秒。

关于同一主题的好博文：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.

我认为这两种风格都有其优点。在我看来，这种或/或思考都会对我们的社区造成严重影响。我曾经在从上到下静态打造的架构中工作，这很好。我最喜欢的架构是在UI级别动态输入，在功能级别静态输入。这也鼓励了一种强制UI和功能分离的语言障碍。

要成为一个愤世嫉俗的人，可能只是动态语言允许开发人员变得更加懒惰，并且可以更少地了解计算的基本原理。这是好事还是坏事取决于读者:)

因为我认为必须声明盒子的类型是愚蠢的。
类型保留在实体中，而不是容器。当盒子的类型直接影响内存中的位被解释时，静态类型就有意义。

如果你看一下GoF中的设计模式，你会发现它们中的很大一部分只是为了与语言的静态性质作斗争，而且它们没有任何理由存在于动态语言中。

另外，我厌倦了写MyFancyObjectInterface f = new MyFancyObject()之类的东西。干的原则有人吗？

这一切都归结为部分适合特定目标以及什么是共同的个人偏好。 (E.G.这将是一个庞大的代码库，由更多的人维护，而不是一起进行合理的会议吗？你想要进行类型检查。)

个人部分是关于交易一些检查和其他开发和测试速度的步骤(同时可能放弃一些CPU性能)。有一些人正在为这种解放和性能提升而且有一些人正是相反的，是的，它确实取决于你语言的特殊风格。我的意思是，这里没有人说Java需要快速，简洁的开发，或者PHP是一种可靠的语言，你很难发现拼写错误。

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

对于给定的应用程序版本，组成应用程序的组件和框架是不可变的。它们也必须非常稳定，因此经过了充分的测试。静态类型语言是构建这些部件的正确选择。

组件的连接，组件DLL的加载，图稿，大多数GUI等......可以有很大差异(比如，为客户端定制应用程序)，而无需更改任何框架或组件代码。动态语言是完美的。

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

回答"动态语言的热爱是什么？"的问题。对我而言，它能够以任何可想象的方式在运行时完全重新连接系统。我将脚本语言视为"运行show"，因此执行的应用程序可以执行您想要的任何操作。

我对动态语言一般没有多少经验，但我知道的一种动态语言，JavaScript(又名ECMAScript)，我非常喜欢。

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

动态编译：

首先，编译动态语言，编译简单推迟到以后。 Java和.NET确实编译了两次。一次到他们各自的中间语言，再一次，动态地，到机器代码。

但是当推迟编译时，您可以更快地看到结果。这是一个优点。我喜欢简单地保存文件并快速查看我的程序。

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

动态类型：

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

var Person = {};

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

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

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

1
Person.First_Name

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

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

当然，如果newName不是字符串，可能会出现问题。如果有的话，它不会马上被抓住，但你可以检查自己。这是交易表达能力和安全灵活性的问题。我不介意添加代码来检查类型等，我自己，而且我还没遇到一个给我带来很多悲伤的类型错误(我知道这并不是很多。这可能只是时间问题： ))。然而，我非常喜欢能够随时适应的能力。

FWIW，在大多数应用程序上编译不应该花费数小时。我使用过200-500k行的应用程序，需要几分钟才能编译。当然不是小时。

我自己更喜欢编译语言。我觉得好像调试工具(根据我的经验，可能不适用于所有内容)更好，IDE工具更好。

我喜欢能够将Visual Studio附加到正在运行的进程中。其他IDE可以这样做吗？也许，但我不知道他们。我最近一直在做一些PHP开发工作，说实话，它并不是那么糟糕。但是，我更喜欢C＃和VS IDE。我觉得我工作得更快，更快地调试问题。

那么对于我来说，它可能比动态/静态语言问题更像是一个工具集？

最后一条评论......如果您使用本地服务器进行开发，则保存速度比编译快，但通常我无法访问本地计算机上的所有内容。数据库和文件共享在其他地方。 FTP到Web服务器更容易，然后运行我的PHP代码只是为了找到错误，必须修复并重新ftp。

把自己放在一个全新的程序员选择一种语言开始的地方，谁不关心动态与staic对比lambda与此对比等等。你会选择哪种语言？

C＃

1
2
3
4
5
6
7
8
9
10
11
using System;
class MyProgram
{
public static void Main(string[] args)
{
foreach (string s in args)
{
Console.WriteLine(s);
}
}
}

LUA：

1
2
3
4
5
6
7
8
9
10
11
function printStuff(args)
for key,value in pairs(args) do
print value ..""
end
end
strings = {
"hello",
"world",
"from lua"
}
printStuff(strings)

因为这很有趣，很有趣。一个人不用担心内存分配很有趣。不等待编译很有趣。等等

弱类型语言可以灵活地管理数据。

我在去年春天使用VHDL几个类，我喜欢他们表示位/字节的方法，以及如果你试图将6位总线分配给9位总线，编译器如何捕获错误。我试图用C ++重新创建它，并且我正在努力整齐地让打字与现有类型一起顺利运行。我认为Steve Yegge在描述强类型系统所涉及的问题方面做得非常好。

关于详细程度：我发现Java和C＃在大型中非常冗长(让我们不要挑选小算法来"证明"一点)。而且，是的，我写过两者。 C ++在同一领域也在挣扎; VHDL在这里屈服了。

Parsimony似乎是动态语言的优点(我以Perl和F＃为例)。

从理论上讲，静态类型语言有可能具有动态语言的优点，理论上，动态语言也有可能吸引并引起更多头痛而非快乐。

但是，在实践中，动态语言允许您快速编写代码，而无需太多样板，而不必担心低级别的细节。

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

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

但是，在实践中，Python > Java

在C中尝试w ="my string here".split()[1]，甚至是Java。

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

对我来说，动态语言的运行速度更快，因为我花费的时间更少，确保框架到位，更多的是关于手头的实际问题。

然而，静态语言提供了更精细的控制，这在某些应用程序中是必需的，例如实时图形渲染。我可以用C ++做的事情比我为Perl写的更有效，更快，但对于大多数Perl脚本的大小，效率的损失可以忽略不计。

最后，它真正归结为问题陈述以及您的目标目标。如果您有很多简单的事情要做，速度和内存效率不是很大，请使用动态语言。如果你有一个需要从系统中挤出最后一个周期的巨型项目，那就去静态吧。