你自己的编程语言会是什么样的？

Question

你自己（我认为是完美的）编程语言会是什么样的？举一个小例子来解释你的小说的想法吧！

我对语法很感兴趣。

Answer 1

有点神秘，但这就是我想要的：

Answer 2

Jon说得对，“[d]不同的任务适合不同的语言和范例。”然而，有一些考虑因素在很大程度上独立于领域。这些主要涉及语法，但由于代码的阅读频率高于编写代码，因此我认为语法很重要。

一方面，以及许多语言错误的东西，将语法基于C语言完全是任意的.C实际上有一个非常糟糕的语法。我只想选择两个例子。

第一个是毫无争议的：分号是不必要的。请使用以下代码;语法完全明确，易于解析编译器。分号和明确的续行都不是必需的。

answer = 42
fraction = answer * 2 /
           (answer + 1)
Console.WriteLine(
    "Some funny number: {0}",
    fraction
)

这实际上与Python非常相似，但更宽松：fraction的定义跨越多行。这是合乎逻辑的，因为第一行尚未完成。

我必须选择具有类C语法的另一个骨骼是它们的隐含变量声明。而不是明确宣布“我宣布variable类型Foo，”所有他们羞涩地低语是“ _{Foo var} ”。由于Foo在大多数情况下甚至不是保留字，因此程序员不会在此提供单个视觉提示。我更喜欢VB的显式Dim var As Foo，甚至认为这里使用的关键字是，非常暗淡。

（C ++实际上通过引入许多几乎完全相同且通常含糊不清的语法，从变量初始化到函数声明完全不同的事情，使事情变得更糟，更糟糕。）

另一件事我的语言必须是静态类型。确实，动态类型具有的用途，但它们非常罕见。即使是大多数“脚本语言”也不会真正需要它们。我认为这经常与隐式打字混淆，后者具有更多用途。拿（再次）Python的例子。为什么不提供静态输入？它已经是强类型的，静态类型检查只会随之而来，并且会在调试时减少很多。显式变量声明也是如此。我没有看到隐含变量声明提供的优势。

所以我们已经有了一种语言大纲：

• 清晰的语法，避免历史混乱。特别是：
  • 没有分号
  • 没有明确的行延续àlaVB
• 显式变量声明
• 静态输入

此外，我是某些C ++概念的忠实粉丝，例如通用模板，RAII（即避免垃圾而不是收集它），不变性以及通过迭代器定义的值范围的概念。我在别处说过，我认为迭代器是有史以来最基本的创新之一。 Give'em有点口红，你甚至都不会认出那个丑陋的野兽C ++：

for i in MyVector:
    print(i)

而不是

for (typename vector<T>::const_iterator i = MyVector.begin();
     i != MyVector.end();
     ++i)
    cout << *i << endl;

当然我知道上面的语法是由许多语言提供的。但它们都只提供了C ++强大的迭代器概念的淡化版本（使用C ++术语，大多数语言都知道的唯一类型的迭代器是输入迭代器，它们基本上是最不强大的迭代器）。

此时我可能会说，所有这些想法的唯一版权是我的，正在申请专利（特别是MayOrMayNotBe operator没有真正比较对象参考）。

Answer 3

我没有“完美”编程语言的概念，因为不仅要执行一项任务。

不同的任务适合不同的语言和范例。

Answer 4

它看起来像C＃。我很想拥有微软！

Answer 5

我完美的语言可以让我在需要的时候提升功能。如果我需要编写一个没有类的小型直接实用程序，我可以。如果我需要使用类，我也可以这样做，如果我想编写一个完全面向对象的解决方案，我也可以这样做。链接器足够聪明，可以让我创建小型快速命令行实用程序（没有运行时依赖性）或者我能想象的最大的膨胀OOP GUI应用程序。

问题是我喜欢的东西有相反的目标，因此我总是被迫使用完全不同的语言。我目前没有特别使用PowerShell，VBScript，PowerBasic，Java和C＃（有时候是VB .NET，VB 6，C ++，Python和Perl）。

现在，如果我可以在创建这些小应用程序时使用一个具有全局函数但没有运行时依赖性的C＃语言，但是当我需要时，让我充分利用.NET Framework和Java SDK的强大功能。 ，我很高兴。

Answer 6

完美的编程语言往往出现在科幻小说中。例如：

• Orson Scott Card的 Ender系列 - 为了创造你必须走向另一个维度并在你的脑海中形成一个纯粹的思想。当你回来时，它就是。
• Robbert A. Heinlein在野兽数量
中探讨了世界为神话的概念
• David Brin的地球通过人声和眼睛和手指动作进行编程。

这一切仍然归结为同样的基本困境。任何不强迫人类学习技能的编程语言都会限制思想的自由。自然语言也不好，因为它有很多含糊之处。

我不介意将自由与权力和最小语法结合起来的人。我最近开始学习lisp，到目前为止看起来非常好。

Answer 7

由Amazon Mechanical Turk.

授权的大规模并行性

job = "Upvote this answer"
@price = "$0.01"
fork(10000, job, @price)

Answer 8

与采用Eiffel和C＃的最佳创意并没有什么不同（因为，显然，我没有足够的知识来提出更好的东西 - 我没有首先研究过CS）。

但是，我的主要实际关注点是超越传统的“源代码文本”方法。我知道这是（或听起来像）一个IDE的东西，但为什么我不能有一个可配置的代码视图，如前置条件/​​正文/后置条件而不是“线性”形式（i）：

  function f
  // f's preconditions
  // f's body
  // f's postconditions
  end

  function g
  // g's preconditions
  // g's body
  // g's postconditions
  end

为什么不（ii） - 想象这是表（带边框）：

f      f's parameters    f's prec      f's body      f's postc    f's comments
g      g's parameters    g's prec      g's body      g's postc    g's comments

而且，为什么我不能选择风格（i）中“开始”和“结束”（大括号，关键字......）的功能？为什么我不能立即显示或隐藏私人或受保护的成员？为什么我不能立即看到内置所有继承函数的“平面版本”？等

关键不是要有一个神圣的代码文件，你编辑，然后多个“酷视图”，但能够编辑和添加（i），（ii）和任何最有用的形式的代码你。

在某种程度上，谈论“IDE”在这里可能看似偏离主题。但OTOH我认为这会改变我们编写和阅读代码的方式，迟早。这最终将影响语言的发展方式。未来的目标不仅是提高可读性，还要提高“可理解性”和互动性。

Answer 9

我是C宏的忠实粉丝，但我认为如果你能用你正在使用的同一种语言编写宏或“元代码”，那可能会很好。 （C是一个不好的例子;这可能适用于脚本语言。）

在这些示例中，我使用大括号来识别元代码。您可以通过“预处理器”运行源代码以扩展元代码。否则它只会在运行时扩展一次。

print "Your product ID is: ", { print '"', generateGUID(), '"' }

或

lookupTable[] = {
                  /* insert code to generate table here
                   *
                   * This lets you modify the algorithm easily
                   * but speeds up the final program.
                   * 
                   * This would be especially appropriate in
                   * cases where you would otherwise type out
                   * the table as a literal (yuck)
                   */
                }

我们不得不写几行非常重复的代码;现在想不出一个很好的例子，但这种想法在这种情况下也会非常有用。

Answer 10

多媒体。

我希望能够涂写一些图形符号，快速绘制连接，然后翻转到其他模式，例如在需要精确度的地方输入。

我还认为编程语言应该支持那些不用英语思考的人（是的，甚至是美国人......开玩笑！）。我已经学习了足够的日语，并试图拿起一些印尼语 - 我希望看到语言支持人们有不同的语法结构和命令。

我在最近一次关于网络未来的论坛上提出了一个问题，向一位来访的中国教授询问他是否认为中文书面语言比英语更有可能实现可行的语义网络。他被这个概念所吸引。

很多SF我都在阅读有关计算机交互的未来UI的讨论：

• David Drake Lt Leary series中的数据棒（其中一些可用free from Baen）
• Matadora中的多模式最喜欢的手势和发声以及佩里斗牛士系列中的其他随意提及
• 笔和基于手势的用户界面，包括签署密封日志 Fool's War

Answer 11

Python对我来说非常理想......我只是想摆脱一些烦恼，比如拥有自己的关键字......但是有了一个好的编辑器，Python可以很快做出惊人的事情......

Answer 12

我想我的位置会介于Brainf*ck和LOLCODE之间，除了多了parentheses。

Answer 13

Clojure越来越近......

Answer 14

我不确定我的梦想语言是什么样的，但我对C风格的语言有一点改进。我写了多少次这样的事情：

Node foundNode = null;  // need stupid null value here to keep track if it was not found
foreach (Node testNode in nodes) {
  if (testNode.YesItsMe) {
    foundNode = testNode;
    break;
  }
}
if (foundNode == null) {
  // create new instance
  foundNode = new Node(blabla);
}

我知道有更多优雅的功能方法，但有时您仍然会得到这样的代码。一个简单的“警卫”声明将有助于此：

Node foundNode;  // no need to initialize anymore
foreach (Node testNode in nodes) {
  if (testNode.YesItsMe) {
    foundNode = testNode;
    break;
  }
} guard {  // we get here if break was never called
  // create new instance
  foundNode = new Node(blabla);
}

Answer 15

我设想的语言必须被告知对输入，变量和执行顺序的精确限制，因此可以编译成快速多线程（或可群集）软件。

这是一个有趣的想法：想象一下，“函数”中的所有“语句”都可以按任何顺序执行。如果某些东西取决于其他东西，则需要明确地“调用”依赖项。这将使并行设计成为语言的一个组成部分。

不幸的是，我没有投入足够的想象力来提出更具体的内容。

Answer 16

我理想的编程语言，代码很聪明，它会告诉我它是否有另一段代码的问题，我们会坐下来谈谈，它会告诉我它的问题是什么，所以我们可以解决它......我称之为“EmotionPeople ++”

Answer 17

我想要一种编程语言，使得工具很容易正确编写。提取方法，着色，自动完成，编译等。

我希望这种情况发生，同时仍然易于编写且易于阅读。

Answer 18

一种不具有结构或变量的语言，只有一种功能。

doEverything（）; //基于已预测的输入自动生成所有内容

Answer 19

它看起来与Scheme完全一样。只有它会编译成IL和Java字节码，以及汇编，所以我可以使用所有这些库。

Answer 20

设计语言以满足特定目标。 语法和语义应遵循所需的功能。

就我而言，我想要一种具有细粒度并行性的语言， 也就是说，每个谷物的开销非常低，允许小块 要并行化的代码。

我在x86 SMP系统上设计并实现了它， 它作为大规模的基础已经使用了大约10年 软件分析工具。

主要观点是允许我（我们）指定 容易并行：

(|| A B)

并行A和B，并让编译器 产生使这成为可能的所有crud。 我们不关心语法是否正确 中缀与否，所以我们采用LISP风格来避免 参数。

一篇描述语言和一些文章的论文 并行应用程序可以在 http://www.semanticdesigns.com/Company/Publications/parallelism-in-symbolic-computation.pdf

本文简要讨论了我们是如何做到的 成功避免了语法上的争论 尽管我们做出了决定。

Answer 21

我将从主要功能开始：

• 应该是 homoiconic language ，强大支持基于宏的元编程。这对生产力来说是一个巨大的优势（参见Paul Graham的beating the averages）
• 它应在任何平台上运行，并且非常支持运行分布式代码。设置机器云应该是一项简单的任务。
• 应该是开源。
• 它应该拥有最大的库和工具生态系统。实际上，这意味着您需要访问Java生态系统，因此可能需要使用JVM语言。
• 应该支持类型推断。生命太短暂，不让编译器为你排序类型细节......
• 它应该是功能，强调数据结构的不可变性。这是高级语言的未来（我并不反对功能语言难以掌握，但这种语言不适合初学者......）
• 它应该支持交互式开发，最好是在类似REPL的环境中，您可以在其中与正在运行的（可能是分布式的）代码环境进行交互。
• 它应该提供出色的无锁并发支持。随着我们进入大规模多核世界，基于锁定的方法根本无法扩展。软件事务内存可能是前进的方式。
• 它应该支持性能所需的低级编码。高级编码在95％的时间都很好，但有时你只需要直接操作字节.....

目前我发现的最接近我的愿望清单的是 Clojure ，其中包含大部分要求。

由于OP引用语法，我将给出一些代码示例：

适当的变量arity函数，支持大型参数列表：

(+ 1 2 3 4 5)
=> 15

(apply + (range 10000))
=> 49995000

在运行时对编译器的交互式访问：

(def function-string "+")

(def function (compile-string function-string))

(function 7 8 9)
=> 24

分布式代码执行（MapReduce样式）。请注意，这意味着语言/库能够采用本地定义的some-long-running-function并透明地将其分发到集群中的所有节点，以便在运行时执行。

(def my-cluster 
     (create-compute-cluster :nodes 100 :service "Amazon"))

(defn some-long-running-function [input]
  ....)

(def reduction-function 
  (fn [a b] 
    (do-something-to-reduce a b)))

(def lots-of-inputs (range 10000))

(distributed-map-reduce
  my-cluster
  some-long-running-function
  inputs
  reduction-function)
=> (whatever the result of the mapreduce is over the cluster)

正确的类型推断（即编译器确定my-function总是返回一个String并相应地进行优化/推理：

(def my-function [name]
   (str "Hello " name "!"))

(my-function "Bob")
=> "Hello Bob!"

(compile-time-type my-function)
=> [java.lang.String :not-null]

Answer 22

它是机器可读/可写的，它将由智能软件编写，通过语音接收指令。

Answer 23

我的最佳语言看起来很像Nemerle（减去任意限制）。真的，它归结为元编程设施;我应该能够以任何我认为合适的方式（句点）任意扩展或修改语言，以完全适应域名。

给我宏，允许我按照自己的意愿处理所有代码的AST，并且可以构建我的完美语言。

Answer 24

嗯。这是困难的一个。我的口味倾向于易于理解和轻松的脚本风格语言（虽然我相信这可以适用于更大的应用程序）。请参阅代码段：

function Foo takes x as string, y as boolean //can add returns [return type] if one wishes to be explicit
    //explicit variable declaration
    z as number
    //explicit cast from boolean to number
    z is y as number
    //implicit variable declaration
    bar is 3 * 5
    //function call
    print x
    return z / bar //since we casted z to a number, it returns a number

Answer 25

我希望看到函数的工具包含任意数量的引用参数，并将它们传递给嵌套函数调用。在.net中，可以通过类似（显示的两个额外参数版本）之类的任何固定数量的通用参数执行此操作：

// I forget the C# syntax for delegates, since I normally code in vb
delegate void RefAction<T1, T2, T3>(ref T1 p1, ref T2 t2, ref T3 p3);

Point myPoints[];

void DoSomethingWithIndexedPoint<XT1, XT2>(int index, 
  RefAction<Point, XT1, XT2) theAction, 
  ref XT1 xp1, 
  ref XT2 xp2)
{
  theAction(myPoints[index], xp1, xp2);  
}

我首选的语法是：

delegate void RefAction<T1, T2, T3>(ref T1 p1, ref T2 t2, ref T3 p3);

Point myPoints[];

void DoSomethingWithIndexedPoint<ref ...>(int index, 
  RefAction<Point, ref ...>, ref ...) theAction, 
  ref XT1 xp1, 
  ref XT2 xp2)
{
  theAction(myPoints[index], ...);  
}

编译器会以适当的方式自动扩展“...”。这样的工具可以在很多情况下使用Lambdas而不必生成闭包实例，并且还可以执行以下代码：

  Interlocked.CompareExchange(SomeObject["George"], SomeValue, SomeOtherValue);

编译器可以将其重写为类似于：

的内容

  SomeObject.ActUponProperty("George",
    (ref dest, ref p1, ref p2) => {Interlocked.CompareExchange(dest, p1, p2);},
    SomeValue, SomeOtherValue);

请注意，因为lambda表达式不会使用除作为ref参数传递的实例成员或变量之外的任何实例成员或变量，所以它可以实现为静态函数，而不需要生成闭包。