“ blub悖论”和c ++

我在这里阅读文章：http : //www.paulgraham.com/avg.html，有关“ blub悖论”的部分特别有趣。作为主要使用c ++编写代码但接触过其他语言（主要是Haskell）的人，我知道这些语言中的一些有用的东西很难在c ++中复制。问题主要是针对精通c ++和其他某种语言的人，您是否使用某种强大的语言功能或惯用语言，如果仅使用c ++编写则很难概念化或实现？

特别是这句话引起了我的注意：

通过归纳法，唯一能够看到各种语言之间功能差异的程序员就是那些理解能力最强的程序员。（这可能是Eric Raymond所说的Lisp，使您成为更好的程序员的意思。）由于Blub悖论，您不能相信其他人的意见：他们对碰巧使用的任何语言都感到满意，因为它决定了语言的正确性。他们对程序的思考方式。

如果事实证明我等同于使用C ++的“ Blub”程序员，那么就会引发以下问题：如果您遇到过其他语言所遇到的有用概念或技术，您会发现很难概念化在用C ++编写或“思考”？

例如，可以使用Castor库在c ++中实现在Prolog和Mercury等语言中看到的逻辑编程范例，但最终我发现从概念上讲，我在考虑Prolog代码，并在使用时转换为c ++等效语言。为了扩大我的编程知识，我试图找出是否存在其他类似的有用/强大习语示例，它们可以用其他语言更有效地表达，而我可能不是C ++开发人员。我想到的另一个例子是lisp的宏系统，从程序内部生成程序代码似乎对某些问题有很多好处。这似乎很难在c ++中实现和考虑。

此问题并非旨在进行“ C ++ vs Lisp”辩论或任何形式的语言战争类型辩论。提出这样的问题是我发现有可能找出我不知道的事情的唯一途径。

好吧，既然您提到了Haskell：

1. 模式匹配。我发现模式匹配更容易读写。考虑一下map的定义，并考虑在没有模式匹配的情况下如何用一种语言实现它。

   map :: (a -> b) -> [a] -> [b]
   map f [] = []
   map f (x:xs) = f x : map f xs
   

2. 类型系统。有时可能会很痛苦，但是非常有帮助。您必须对其进行编程才能真正理解它以及它捕获了多少错误。同样，引用透明性也很棒。在Haskell中编程一段时间后，只有通过命令式语言管理状态才引起多少错误，这才变得显而易见。

3. 一般的函数式编程。使用地图和折页而不是迭代。递归。这是关于更高层次的思考。

4. 懒惰的评估。同样，它是关于更高层次的思考并让系统处理评估。

5. 阴谋，包和模块。对于我来说，有了Cabal下载软件包比查找源代码，编写makefile等要方便得多。仅导入某些名称比本质上将所有源文件一起转储然后编译起来要好得多。

记住！

尝试用C ++编写它。不适用于C ++ 0x。

太麻烦了吗？好的，尝试使用 C ++ 0x。

看看您是否可以在D中击败此4行（或5行，无论：P）的编译时版本：

auto memoize(alias Fn, T...)(T args) {
    auto key = tuple(args);                               //Key is all the args
    static typeof(Fn(args))[typeof(key)] cache;           //Hashtable!
    return key in cache ? cache[key] : (cache[key] = Fn(args));
}

调用它所需要做的就是：

int fib(int n) { return n > 1 ? memoize!(fib)(n - 1) + memoize!(fib)(n - 2) : 1;}
fib(60);

您还可以在Scheme中尝试类似的方法，尽管它会慢一些，因为它在运行时发生，并且因为这里的查询是线性的而不是哈希的（而且，因为它是Scheme）：

(define (memoize f)
    (let ((table (list)))
        (lambda args
            (cdr
                (or (assoc args table)
                    (let ((entry (cons args (apply f args))))
                        (set! table (cons entry table))
                        entry))))))
(define (fib n)
        (if (<= n 1)
            1
            (+ (fib (1- n))
                (fib (- n 2)))))))
(set! fib (memoize fib))

C ++是一种多范式语言，这意味着它试图支持多种思维方式。有时C ++功能比另一种语言的实现更尴尬或不太流畅，例如函数式编程。

就是说，我想不出yieldPython或JavaScript 所具有的本机C ++语言功能。

另一个例子是并发编程。C ++ 0x对此有发言权，但当前标准没有，并且并发是一种全新的思维方式。

而且，即使您从未离开C ++编程领域，也永远不会学习快速开发-甚至Shell编程。

协程是一种非常有用的语言功能，比起C ++，其他语言还具有许多更明显的好处。它们基本上提供了额外的堆栈，因此功能可以被中断和继续，为语言提供了类似于管道的功能，可以轻松地通过过滤器将操作结果提供给其他操作。很棒，在Ruby中，我发现它非常直观和优雅。懒惰的评估也与此相关。

内省和运行时代码的编译/执行/评估/是C ++所缺乏的强大功能。

在Lisp和C ++中都实现了计算机代数系统后，我可以告诉您，即使我是该语言的新手，但在Lisp中该任务要容易得多。列出的所有内容的这种简单性简化了许多算法。诚然，C ++版本快了数十亿倍。是的，我本可以使Lisp版本的速度更快，但是代码不会那么简单。例如，脚本编写是另一件事，它总是会变得更加容易。所有这些都是使用正确的工具完成工作。

当我们说一种语言比另一种语言“更强大”时，我们是什么意思？当我们说一种语言是“表达性的”时？还是“有钱？” 我认为我们的意思是，当一种语言的视野缩小到足以使描述问题变得轻松自然时，它便会获得力量-真的是状态转换，不是吗？-处于那种观点之内。但是，当我们扩大视野时，这种语言的功能，表现力和实用性将大大降低。

语言越“强大”和“富于表现力”，其使用就越受限。因此，“强大”和“富有表现力”可能是错误的词汇，用于狭义实用程序的工具。对于此类事情，也许“适当”或“抽象”是更好的说法。

我从编程开始，首先编写了许多低级的东西：带有中断例程的设备驱动程序；嵌入式程序；操作系统代码。该代码与硬件紧密相关，我都是用汇编语言编写的。我们不会说汇编程序不是最抽象的，但是它曾经是并且也是所有语言中最强大和最富表现力的语言。我可以用汇编语言表达任何问题；它是如此强大，我可以用任何机器做任何我想做的事情。

我后来对高级语言的所有理解都归功于我在汇编器方面的经验。后来我学到的一切都很容易，因为，您看到，一切（无论多么抽象）最终都必须适应硬件。

您可能想忘记越来越高的抽象水平，即越来越狭窄的视野。您以后总是可以接听。几天之内就可以轻松学习。在我看来，最好学习硬件¹的语言，以尽可能接近骨骼。

¹ 也许不是很密切，但car并cdr从硬件把他们的名字：第一个Lisp的跑了一台机器，有一个实际的递减注册和实际地址寄存器上。怎么样？

关联数组

处理数据的典型方式是：

• 读取输入并从中构建层次结构，
• 为该结构创建索引（例如，不同的顺序），
• 创建它们的提取物（过滤部分），
• 查找一个值或一组值（节点），
• 重新安排结构（根据规则删除节点，添加，追加，删除子元素等），
• 遍历树并打印或保存其中的某些部分。

正确的工具是关联数组。

• 我所见过的对关联数组最好的语言支持是MUMPS，其中关联数组是：1.始终排序2.可以使用相同的语法在磁盘（所谓的数据库）上创建它们。（副作用：它作为数据库极其强大，程序员可以访问本机btree。有史以来最好的NoSQL系统。）
• 我的第二个奖项是PHP，我喜欢foreach和简单的语法，例如$ a [] = x或$ a [x] [y] [z] ++。

我真的不喜欢JavaScript的关联数组语法，因为我无法创建，例如a [x] [y] [z] = 8，首先我必须创建a [x]和a [x] [y]。

好的，在C ++（和Java）中，有很多不错的容器类组合Map，Multimap，但是，如果我想浏览一遍，就必须创建一个迭代器，当我想插入一个新的深层元素时，必须创建所有上层等等。不舒服。

我并不是说C ++（和Java）中没有可用的关联数组，但是无类型（或非严格类型）脚本语言要优于已编译的语言，因为它们是无类型的脚本语言。

免责声明：我不熟悉C＃和其他.NET语言，AFAIK它们具有良好的关联数组处理。

我不学习Java，C \ C ++，汇编语言和Java脚本。我用C ++谋生。

虽然，我不得不说我更喜欢汇编编程和C编程。这主要与命令式编程内联。

我知道编程范例对于将数据类型分类很重要，并给出了更高的编程抽象概念以允许强大的设计模式和代码形式化。尽管从某种意义上讲，每个范式都是模式和集合的集合，用于抽象化底层硬件层，所以您无需考虑EAX或机器内部的IP。

我唯一的问题是，它允许人们的观念和关于机器如何工作的概念被转变为意识形态的关于正在发生的事情的模棱两可的断言。除了对程序员的某种意识形态目标的抽象外，此面包还具有各种奇妙的抽象。

归根结底，最好对CPU是什么以及计算机在幕后如何工作有一个清晰的思路和界限。CPU关心的是执行一系列指令，这些指令将数据移入和移出存储器到寄存器中并执行一条指令。它没有数据类型的概念，也没有任何更高的编程概念。它只会移动数据。

当您将编程范例添加到组合中时，它将变得更加复杂，因为我们对世界的看法各不相同。

如果仅使用C ++编写，您是否使用某种难以用概念化或实现的语言来使用某些强大的语言功能或习惯用法？

如果您使用C ++编写或“思考”，您是否会遇到难以用其他语言遇到的有用的概念或技术，这些概念或技术很难被概念化？

C ++使许多方法变得棘手。我要说的是，如果您局限于C ++，那么大多数编程都很难概念化。以下是一些问题的示例，这些问题用C ++很难解决。

寄存器分配和调用约定

许多人认为C ++是一种裸机底层语言，但实际上并非如此。通过抽象出机器的重要细节，C ++使得难以概念化诸如寄存器分配和调用约定之类的实用性。

要了解类似这样的概念，我建议您进行一些汇编语言编程，并阅读有关ARM代码生成质量的本文。

运行时代码生成

如果您只了解C ++，那么您可能会认为模板是元编程的全部和全部。他们不是。实际上，它们是元编程的客观上不好的工具。操纵另一个程序的任何程序都是元程序，包括解释器，编译器，计算机代数系统和定理证明。运行时代码生成对此非常有用。

我建议启动一个Scheme实施并EVAL开始学习有关元循环评估的知识。

操纵树木

树在编程中无处不在。在解析中，您具有抽象语法树。在编译器中，您的IR是树。在图形和GUI编程中，您有场景树。

该“用于C ++的异常简单JSON解析器”的权重仅为484 LOC，对于C ++而言很小。现在将其与我自己的简单JSON解析器进行比较，该解析器的权重仅为F＃的60 LOC。区别主要是因为ML的代数数据类型和模式匹配（包括活动模式）使得操纵树非常容易。

还要检查OCaml中的红黑树。

纯功能数据结构

由于C ++中缺少GC，因此实际上不可能采用某些有用的方法。纯功能数据结构就是这样一种工具。

例如，在OCaml中检出此47行正则表达式匹配器。简短的原因很大程度上是由于纯功能数据结构的广泛使用。尤其是将字典与已设置的键一起使用。在C ++中，这确实很难做到，因为stdlib字典和集合都是可变的，但是您不能对字典的键进行突变或破坏集合。

逻辑编程和撤消缓冲区是其他实际示例，其中纯函数数据结构使其他语言在C ++中很难实现的事情变得非常容易。

尾声

C ++不仅不能保证尾部调用，而且RAII基本上与之不符，因为析构函数妨碍了尾部位置的调用。尾部调用使您仅使用有限数量的堆栈空间即可进行无数次函数调用。这对于实现状态机（包括可扩展状态机）非常有用，并且在许多其他棘手的情况下，这也是一种出色的“摆脱监狱”的方式。

例如，使用金融行业的F＃中的带有记忆的连续传递样式来检查0-1背包问题的实现。遇到尾部调用时，继续传递样式可能是一个显而易见的解决方案，但C ++使其难以处理。

并发

另一个明显的例子是并发编程。尽管这在C ++中是完全可能的，但是与其他工具相比，它极容易出错，最值得注意的是交流顺序过程，如Erlang，Scala和F＃等语言中所见。

这是一个古老的问题，但是由于没有人提到过，我将添加列表（现在是字典）的理解。用Haskell或Python编写可解决Fizz-Buzz问题的单行代码很容易。尝试在C ++中这样做。

尽管C ++使用C ++ 11向现代性迈进了一大步，但称其为“现代”语言有点困难。只要“现代”的意思是“不是从上一个千年开始的”，C ++ 17（尚未发布）就朝着现代标准的方向迈出了更大的步伐。

即使是可以用Python在一行中编写的最简单的理解（并遵守Guido的79个字符的行长限制），在转换为C ++时也会变得很多行代码，并且其中一些C ++代码行相当复杂。

调用回调的已编译库，该回调是用户定义类的用户定义成员函数。

在Objective-C中这是可能的，它使用户界面编程变得轻而易举。您可以告诉一个按钮：“请在您按下该对象时调用此方法”，然后按钮将执行此操作。您可以自由地为自己喜欢的回调使用任何方法名称，它不会冻结在库代码中，也不必从适配器继承就可以正常工作，编译器也不想在编译时解析该调用，同样重要的是，您可以告诉两个按钮调用同一对象的两个不同方法。

我还没有看到类似的灵活方式来定义任何其他语言的回调（尽管我很想知道它们！）。在C ++中，最接近的等效项可能是传递了执行所需调用的lambda函数，这再次将库代码限制为模板。

正是Objective-C的这一特性教会我重视一种语言自由传递任何类型的对象/函数/任何重要概念的语言的能力，以及将其保存为变量。语言中定义任何类型概念但未提供将其存储（或引用）所有可用变量类型的任何点，都是重要的绊脚石，并且很可能是丑陋的来源，重复的代码。不幸的是，巴洛克式编程语言倾向于表现出以下几点：

• 在C ++中，您无法写下VLA的类型，也不能存储指向它的指针。这有效地禁止了具有动态大小的真正多维数组（自C99起在C中可用）。

• 在C ++中，您无法写下lambda的类型。您甚至无法对其进行typedef。因此，无法绕过lambda或将对它的引用存储在对象中。Lambda函数只能传递给模板。

• 在Fortran中，您无法写下名称列表的类型。根本没有办法将名称列表传递给任何类型的例程。因此，如果您有一个应该能够处理两个不同名称列表的复杂算法，那么您将很不走运。您不能只编写一次算法并将相关的名称列表传递给它。

这些只是几个示例，但是您会看到一个共同点：每当您第一次看到这样的限制时，您通常都不会在乎，因为这样做似乎是一个疯狂的主意。但是，当您使用该语言进行一些认真的编程时，最终您会到达这种精确的限制成为真正的麻烦的地步。