Julia: 杰夫·贝赞森博士

cc @fperez谁也对这个悬而未决的问题感兴趣

附上支持资料。

作为一个程序问题，关闭它可能需要在单独的存储库中工作。 论文也许应该包含在 Base 中，以便其他人更容易做出贡献。

最后一个任务的顺序也具有误导性； 它实际上会在整个过程中频繁发生。

+1 将其包含在 Base 中，或者至少包含在julia/doc/thesis中。 或者可能是theses以适应未来的需求。

（请继续打开一个论文分支，杰夫。）

最后一个任务的顺序也具有误导性； 它实际上会在整个过程中频繁发生。

*也已经复发

我期待着出席_Close issue_仪式。

我无法在本地重现此问题； 它是麻省理工学院特有的吗？

Julia 的核心作者之一 @JeffBezanson已成为有问题的开发者学者

这是博士论文的github版本吗？ Jeff 必须在他的提案中打开 PR，委员会将决定是否合并...

+Inf 快速解决这个问题！

几个月前我在 IPython repo 上遇到了同样的问题，希望它在 32 天前得到修复。
我很确定这涉及到咖啡、烦人的文书工作以及由于手提钻而在最后一刻改变计划。

祝你好运 ！

更新：杰夫会见了他的论文委员会，并给了我们一个粗略的大纲。

很高兴听到正在取得进展！

但是git log --date=short --all --since=22.days.ago --author="Jeff Bezanson"仍然让人想知道他是如何有时间写论文的。 要么，要么他是个超级英雄。 实际上，从头开始：我们都知道他是超级英雄，所以没关系。

涉及 juliatypes.jl 的提交记录了我们描述 Julia 类型系统的尝试，这与论文工作直接相关。

类型系统的工作似乎已经触动了一些神经： https ://twitter.com/plt_hulk/status/535045242920378369

我有点怀疑这是对 Jeff 工作的直接回应，尽管我可能是错的。 不管怎样，都很搞笑的推文。

@jiahao ，我的评论大多是开玩笑的——我有点想知道这件事。 一方面，当我为演示而润色某些东西时，我往往会有很多提交。

@timholy幽默指出。 :)

如果不提我们当地的理论合作者@jeanqasaur制作并发布在推特上的可爱的马格利特致敬，那就太失职了：

“类型的背叛”有一个很好的戒指，不是吗？

这很有趣。

爱它！

寻求帮助：Jeff 正在寻找展示多个调度（可能还有分阶段函数）的好例子，在没有这些特性的语言中，事情会变得更难/更慢。

是， show ？

（也许是分阶段的功能）

subarray.jl和subarray2.jl应该很好用。 设计文档位于http://docs.julialang.org/en/latest/devdocs/subarrays/

我认为 Distributions 包确实使多次调度看起来很有用。 拥有rand(Gamma(1, 1), 5, 5)与rand(Normal(0, 1), 3)之类的东西在没有性能成本的情况下由于多次分派而在表达能力上取得了巨大的进步。

我看不出这是最好的例子，因为它确实在炫耀
单发。 它和你的Gamma(1,1).rand(5,5)有什么不同
会使用更传统的 OO 语言（如 Python 或 Java）吗？

2014 年 12 月 19 日星期五下午 1:39，John Myles White [email protected]
写道：

我认为 Distributions 包确实使多次调度看起来
有用。 拥有像 rand(Gamma(1, 1), 5, 5) 与 rand(Normal(0, 1),
3) 在没有性能成本的情况下极大地提高了表现力，因为
多次调度。

—
直接回复此邮件或在 GitHub 上查看
https://github.com/JuliaLang/julia/issues/8839#issuecomment -67678367。

好的。 将其替换为使用分析结果计算 KL 散度的示例： kl(Normal(0, 1), Normal(0, 1))与kl(Normal(0, 1), Gamma(1, 1)) 。

我还应该补充一点，在我在#8235 的最初帖子中，有一些关于没有分阶段函数的生活会是什么样子的潜在有用的统计数据。 带回家的消息：通过维度 8 生成所有方法导致 > 5000 个单独的方法，并且需要超过 4 分钟的解析和降低时间（即，编译 Julia 时有 4 分钟的延迟）。 相比之下，stagedfunction 实现加载速度很快，当然甚至可以超过 8 个维度。

与单调度相比，它仍然展示了其他 OO 语言所描述的统一：函数与方法。 您可以对比 python 的 sorted(a) 与 a.sort()。 与“传统”OO 语言相比，它极大地改变了函数与类“关联”的含义。

您可以指出它如何取代对静态变量和实例变量的需求，因为您可以在实例或类型上分派。 当我可以使用计算机时，我可能会从最近的一些 IRC 对话中获得更多想法。

我有一个fmap的实现。 这会遍历几个数组和
对每组元素应用一个函数。 这个实现其实是
非常慢，因为数组的数量可以是任意的。 为了使它有用，
我已经为各种数量的人手动创建了这个专业化
参数yss 。 我一直想为此编写一个分阶段的函数，
但还没有这样做。

分阶段的函数需要特别评估map调用
产生f的参数。

-埃里克

function fmap{T,D}(f::Function, xs::Array{T,D}, yss::Array...;
                   R::Type=eltype(f))
    [<strong i="18">@assert</strong> size(ys) == size(xs) for ys in yss]
    rs = similar(xs, R)
    <strong i="19">@simd</strong> for i in 1:length(xs)
        <strong i="20">@inbounds</strong> rs[i] = f(xs[i], map(ys->ys[i], yss)...)
    end
    rs::Array{R,D}
end

2014 年 12 月 19 日星期五下午 12:46，Steven G. Johnson <
通知@github.com> 写道：

寻求帮助：杰夫正在寻找可以展示多个
调度（可能还有分阶段的功能），这将是很多的事情
没有这些功能的语言更难/更慢。

直接回复此邮件或在 GitHub 上查看
https://github.com/JuliaLang/julia/issues/8839#issuecomment -67671331。

埃里克·施奈特[email protected]
http://www.perimeterinstitute.ca/personal/eschnetter/

抱歉，忽略我代码中函数签名中对eltype(f)的调用，
那是不标准的。

-埃里克

2014 年 12 月 19 日星期五下午 3:08，Erik Schnetter [email protected]
写道：

我有一个fmap的实现。 这会遍历几个数组和
对每组元素应用一个函数。 这个实现其实是
非常慢，因为数组的数量可以是任意的。 为了使它有用，
我已经为各种数量的人手动创建了这个专业化
参数yss 。 我一直想为此编写一个分阶段的函数，
但还没有这样做。

分阶段函数需要特别评估map调用
产生f的参数。

-埃里克

function fmap{T,D}(f::Function, xs::Array{T,D}, yss::Array...;
                   R::Type=eltype(f))
    [<strong i="26">@assert</strong> size(ys) == size(xs) for ys in yss]
    rs = similar(xs, R)
    <strong i="27">@simd</strong> for i in 1:length(xs)
        <strong i="28">@inbounds</strong> rs[i] = f(xs[i], map(ys->ys[i], yss)...)
    end
    rs::Array{R,D}
end

2014 年 12 月 19 日星期五下午 12:46，Steven G. Johnson <
通知@github.com> 写道：

寻求帮助：杰夫正在寻找可以展示多个
调度（可能还有分阶段的功能），这将是很多的事情
没有这些功能的语言更难/更慢。

直接回复此邮件或在 GitHub 上查看
https://github.com/JuliaLang/julia/issues/8839#issuecomment -67671331。

埃里克·施奈特[email protected]
http://www.perimeterinstitute.ca/personal/eschnetter/

埃里克·施奈特[email protected]
http://www.perimeterinstitute.ca/personal/eschnetter/

@timholy ，既然 Matlab 和 NumPy 也有子数组/切片，为什么我们可以争辩说在这里多次分派是必不可少的？

易于实施？ 据我所知，您可以用任何语言模拟多次调度，因此它对任何事情都不是必需的。

建议我们还没有决定想要的东西也许不好。 在https://github.com/JuliaLang/julia/issues/9297中，有一个提案允许我们同时拥有高效的 UTF-8 缓冲区位置和方便的无孔索引，以便您可以在需要时进行方便的算术运算。 正则表达式和搜索将返回包装的内部索引，但s[2]可以给出第二个字符，而不管用于编码第一个字符的字节数。

他们可以制作有效的AbstractArrays子数组/切片，还是他们的实现仅适用于连续的内存块？ 如果您可以假设您的父数组具有连续的内存，这不是一个非常难以解决的问题。 当你不做这个假设时，它会变得更有趣。

是的，这就是我们正在寻找的关键特性：不仅可以通过多个调度和/或分段函数很好地完成某些事情，而且在其他语言中缺乏这些特性使得该特性的实现更加困难（理想情况下，这么多甚至没有人尝试过）。

@timholy ，NumPy 数组的特点是每个维度都有一个固定的步幅，不一定是连续的（基本上相当于我们的DenseArray ）。 此属性在切片下保留，因此切片本身可以被切片等等。

在这些方面，aberrant 对 IRC 提出了一些很好的问题。 我试图只提取下面的相关评论（从不相关的对话和通知中）：

2014-12-10 (EST)
11:41 aberrant: “Organizing methods into function objects rather than having named bags of methods “inside” each object ends up being a highly beneficial aspect of the language design.”
11:41 aberrant: why?
12:20 Travisty: aberrant: I can’t speak for them, but I imagine that the argument is that it’s a nice separation of concerns. I have data (which I will represent with types) and routines for operating on that data (which I will represent as functions), and rather than having some routines belong to specific types, they are kept separate
12:21 aberrant: Travisty: I sort of understand the argument, but I’m not sure I agree with it :)
12:22 Travisty: aberrant: Yeah, sure. This is the sort of thing that may be hard to argue about from first principles, and it may be useful to look at examples. I think one place where this design simplified things was in impementing the standard mathematical functions on all of the numeric types, and dealing with conversion
12:22 Travisty: I’m not sure, but I think the solution in julia is quite elegant because of this design and it would be a bit trickier to do it in the traditional OOP setting
12:23 aberrant: Travisty: perhaps. I need to think about it some more. I really like pure OO, and this is a bit of a change that I need to wrap my head around.
...
12:54 vtjnash: julia has a convention that a method name will end in a ! to signify that the method will mutate one of it's arguments
12:56 aberrant: that’s one thing I sorely miss in python. foo.sort() vs foo.sorted() always confused me.
12:57 vtjnash: except that in python, isn't it sort(foo) vs sorted(foo) ?
12:57 aberrant: it might be :)
12:58 aberrant: no
12:58 aberrant: it’s foo.sort vs sorted(foo)
12:58 vtjnash: ah
12:58 aberrant: foo.sort modifies foo in place.
12:58 aberrant: see?
12:58 aberrant: that’s what I mean.
12:58 vtjnash: well, anyways, that's an unintentional example of why . oriented programming is a pain
12:58 aberrant: sort(foo) vs sort!(foo) makes much more sense.
12:59 vtjnash: python made a reasonable choice there
12:59 vtjnash: and tries to help you remember
12:59 vtjnash: but it still was forced to make some decision

2014-12-14 (EST)
15:25 aberrant: there’s no way to do type constants, I guess?
15:25 aberrant: http://dpaste.com/18AEHBG
15:25 aberrant: like that
15:27 vtjnash: no. that declares a local variable inside the type (can be seen by the constructors and other methods in there)
15:27 vtjnash: instead, define `y(::Foo) = 6`
15:28 aberrant: is that mutable?
15:29 aberrant: hm, yeah, that’s not what I want though.
15:29 aberrant: but I guess I can use it.
15:30 vtjnash: not what you want, or not what other languages do?
15:31 vtjnash: multiple dispatch in julia allows you to collapse 4 or 5 or more different constructs needed by other OO languages into one abstraction
15:33 aberrant: oh, I see how it works.
15:33 aberrant: well, it’s a function and therefore more overhead
15:33 aberrant: basically, I want to set the “bitwidth” of an IPv4 address to be 32, and the “bitwidth” of an IPv6 address to be 128, and then be able to write a function that takes ::IPAddr and uses the appropriate bitwidth.
15:34 aberrant: I can do this with the function, but it seems like overhead to have a function return a constant.
15:35 aberrant: e.g., http://dpaste.com/3RXRCAG
15:36 vtjnash: don't assume that a function has more overhead
15:36 vtjnash: in this case, it would actually have less overhead
15:54 aberrant: wow, ok
15:54 aberrant: I don’t see how, but I’ll take your word for it :)
15:59 vtjnash: inlining
...
18:04 aberrant: there’s no way to associate a constant inside a type?
18:04 aberrant: it would make my life a whole lot easier.
18:04 mlubin: aberrant: t.constant or constant(t) is just a syntax difference
18:04 mlubin: julia uses the latter
18:05 aberrant: mlubin: the issue is that you have to instantiate the type first.
18:05 aberrant: mlubin: I need the equivalent of a class property.
18:05 mlubin: constant(::Type{Int32}) = 10
18:05 mlubin: constant(Int32)
18:05 aberrant: oh. wow.
18:06 Travisty: The only member of Type{T} is T, which is why this works
18:06 mlubin: mind=blown? ;)
18:06 aberrant: yeah
18:06 aberrant: that’s jacked up
18:07 aberrant: there’s NO WAY I would have ever thought of that on my own :(
18:07 mlubin: once you see it for the first time it becomes a lot more intuitive
18:07 aberrant: ipaddrwidth(::Type{IPv4}) = uint8(32)
18:08 aberrant: w00t
18:10 aberrant: can I do a const in front of that?
18:11 Travisty: I don’t think so, but usually when julia generates code, it should be inlined so that just the constant uint8(32) appears, instead of a function call

如果您正在寻找更多示例： https ://github.com/JuliaLang/julia/pull/7291

网络代码从 6K C++ 减少到大约 1K Julia 非常好。 最初的性能基准表明它是原生 C++ 的 2 倍以下。

您知道有多少种语言可以要求实现 printf，从运算符（+-*/、Int、Float）到数字输出格式、语言本身以及 libc 版本的一小部分范围内的基准测试？ 也许是 C++？ C 甚至不能声明这一点（它没有运算符重载）。

Python/MATLAB/等。 或许可以声称这一点，但您是否曾尝试在 MATLAB 中使用字符串运算符？

这是一个非常有趣的讨论，我想补充几点：

• 似乎没有真正回答的是 Julia 如何与 C++ 中的多态性进行比较。 在 C++ 中，可以通过模板实现静态多态性，也可以通过 OO 实现动态多态性。 但是后者需要一个 vtable 并且总是慢一点，尤其是在紧密循环中调用这些东西时。 出于这个原因，永远不会重载数组访问运算符，因为这不会很快。 例如，Eigen 使用静态多态性。
• 在 Julia 中，虚拟函数和非虚拟函数之间没有目的地，我们仍然没有性能损失。 我的理解是，最大的优势是 Julia 可以“动态”生成代码，因此仍然可以生成快速代码，而在 C++ 运行时意味着不能再修改生成的代码。 此外，在 Julia 中，我们能够在运行时进行内联。 所以没有函数调用开销。 而在 Julia 中，我们不必考虑所有这些，因为它是自动完成的
• 一件大事（再次）是：泛型没有开销，也没有 C++ 所具有的所有痛苦（查看编译时间）如何实现泛型有不同的方法，恕我直言 Julia 使用与 C# 相同的模型，所以这可能不是全新的（对于杰夫斯论文）。 但我仍然认为这可以在论文中讨论。

解释多重调度的有效性有多难，这本身就很有趣。

很高兴我们现在在同一页面上。 是的，我们的新子数组不依赖于跨步，也不需要线性索引（尽管他们可以使用它，并且如果它恰好是有效的，默认情况下会这样做）。 因此它们对任何 AbstractArray 都有效，并且还支持“非跨步”（ Vector{Int}索引）视图。

为了澄清起见，我主要将我们的新子数组作为分阶段函数的示例，而不是多次分派。 也就是说，如果没有多次调度，当前方案将在构造步骤中崩溃：我们为slice(::AbstractArray, ::UnitRange{Int}, ::Int, ::Vector{Int})和slice(::AbstractArray, ::Int, ::UnitRange{Int}, ::UnitRange{Int})等调用完全不同的构造函数方法。这些构造函数是由分阶段函数生成的，但是我们需要多次调度才能使系统正常工作。

如果没有单独的函数，可变参数构造函数必须面对这样一个事实：循环遍历索引元组中的条目不是类型稳定的：要在循环中处理单个索引，您必须将它们分配给一个命名的标量变量，并且该变量是即使输入元组可以，也保证不会是良好类型的。 当然，staged 函数做得更多：几乎所有的“硬”决策——我们是将其作为切片维度丢弃还是保留它，对对象的内部表示有何影响？ ---可以在编译时进行，将运行时构造函数减少为非常微不足道的操作。 碰巧的是，每种输入类型组合的特定琐碎操作都不同，因此要利用这种琐碎性并加快构建速度，您需要调用为每种输入类型组合定制的不同方法。 这就是为什么你需要分阶段的函数和多次分派。

就个人而言，我怀疑如果不结合分阶段函数和多次分派，我们所做的事情是否可行，并且 julia 现在可能拥有所有语言中最灵活和最有效的数组视图。 但我并没有假装对这个问题进行过任何形式的实际研究。

这让我想知道我是否应该编写我们的 SubArrays 以供发布——看起来我们确实有一些新的东西。

@StefanKarpinski ：让我们自我批评：也许我们还没有写出来？

@timholy我实际上在这里看到了两件事，分阶段的函数（我不得不承认没有完全理解）以及 Julia 如何适应 C++ 虚函数与模板世界（C# 和 Java 在这里相似）。

对于 C++ 比较，做计时和实验证明我们可以达到编译时多态性（我相信我们做到了）将是非常有趣的

一段时间以来，我想阐述的另一件事是 Julia 在 C++ 概念 (lite) 方面与 C++ 的比较。 我们拥有的子类型是 C++ 概念的很大一部分。

是否甚至需要编写一堆 C++ 代码并运行计时来检查这一点？

A = rand(3,5)
<strong i="6">@code_llvm</strong> slice(A, 2, :)
<strong i="7">@code_llvm</strong> slice(A, :, 2)

那里基本上只有加载和存储操作（即内存访问）。

@timholy我确实认为值得写下来。 我相信（但尚未验证）许多实现 Nd 数组的系统在前几个维度上都有专门的实现，然后通常会退回到一些缓慢的东西，而新的实现不应该是这种情况。

另一个相关案例是编写一个高效的稀疏 Nd 存储（数组是常见的特殊情况）。

蒂姆，

是的，确实查看生成的汇编代码是一个很好的工具。 但我仍然认为这必须在更大的背景下进行比较，其中（在 C++ 实现中）必须考虑虚函数。

我的猜测是，并不是multiple dispatch这么快，而是我们可以在运行时内联，从而将虚函数（我们的泛型函数）转换为有效的指令，而无需函数调用间接。

如果这是真的（如果我错了，请纠正我@JeffBezanson @vtjnash @stevengj @timholy ） multiple dispatch中的倍数不是 Julia 蜂鸣得如此之快的原因，而是一个整洁的副作用，可以制定某些代码更好（单次调度受到限制）

我可能只是不理解，但我不确定你所做的区分。 在 Julia 中，“内联”和“运行时”似乎并没有真正结合在一起。 内联是在类型推断期间执行的，即在编译时。 多重分派用于为推断类型选择适当的方法。

这里的困惑是 C++ 的“编译时间”和“运行时间”不能与 Julia 相比。 Codegen 可以在“运行时”期间发生，所以是的，我认为当我执行include("myscript.jl")内联时。 即使从 C++ 的角度来看“运行时”不是正确的词，它也是“运行时”。

不同类型的调度就像一个 vtable 但更通用，不是吗？

这让我想知道我是否应该编写我们的 SubArrays 以供发布——看起来我们确实有一些新的东西。

这与标准主题有点远，但您可以考虑提交给 JSS。 我们需要更多 Julia 文章。

如果 Tim 写一篇博客文章来描述这项工作，我会很高兴，因为它会让很多人跟上进度。 JSS 是一个好主意，也许已经在数据框架和分布中完成的一些基础工作也值得写出来？ 我当然会喜欢阅读它。

好吧，让我想到它的大部分内容都已经写出来了：http: //docs.julialang.org/en/latest/devdocs/subarrays/。 对于出版物，您可能希望了解更多细节，但这触及了相当多的主要大图点。

对于@stevengj提出的关于多次分派的问题，我想说如果没有多次分派，在 julia 中编写我们的基础库是非常困难的。 我说的是这里的每个人都已经知道的事情，并且想知道这是否不是一个令人信服的例子，因为这里提到的原因。

数字操作和转换/促销等细节与多次调度错综复杂地联系在一起。 由于多重分派本质上是在编译器中将类型推断暴露给代码中使用类型的方式，因此我们能够编写一个通用且快速的数值基础库。 引用您所做的声明 - 它有助于将策略制定从编译器和库中分离出来。 例如， @JeffBezanson曾经向我展示了 Scheme 规范如何将 1/3 的空间用于数字细节。

许多解释系统通常最终具有通用类型并在运行时检查其对象的类型以决定执行哪些代码。 然后，它们通常在每种类型的基础库中使用 C/C++/Fortran 单独实现，从而导致代码库庞大且难以调试。 通常这些是通过外部宏系统生成的，但越来越多地使用 C++ 模板避免了这个特定问题。 在这些情况下，仍然存在两种语言和类型推断的问题。

在某种程度上，向量化是多少科学语言分摊了在运行时确定类型和进行适当代码选择的成本。 在 Julia 中，结合类型推断、多重分派和泛型编程，我们的成本显着降低，允许我们编写泛型去向量化代码 - 没有类型的 C。

一个例子是与 PR #9198 中的MathConst （代表无理数）的不等式比较：

https://github.com/JuliaLang/julia/pull/9198/files#diff -e247e18c426659d185379c7c96c1899dR29

• FloatingPoint vs MathConst将浮点数与常量上方/下方的浮点数进行比较
• Rational{T} vs MathConst （对于有界整数类型T ）找到该类型可表示的最接近的有理数； 然后根据它是高于还是低于真正的非理性类型。

使这可行的原因是在编译时可以轻松访问Rational和BigFloat功能。 尽管使用宏预处理器之类的东西可能是可能的，但它基本上需要所有功能的两个实现。

我有一个关于这个问题的小更新。 该文件现已向公众开放： https ://github.com/JeffBezanson/phdthesis

今天我要在自己设定的截止日期前发布一份草稿。 这不是一个草稿。 许多部分完全丢失。 我也声称对 TeX 评论中的任何内容或仅存在于过去版本历史记录中的任何内容不承担任何责任 :)

欢迎所有反馈！ 特别是，如果你有很好的 julia 代码示例，可以很好地展示语言，尤其是任何没有它就很难做到的事情。 一直在寻找良好的非平凡多次调度示例。

感谢您公开此信息。 当我尝试跟随 SGJ 使用的链接并点击 404 时，我感到很惊讶。

也许三角矩阵算术可以是 Julia 的多重分派有用的一个例子。 这里UpperTriangular+UpperTriangular=UpperTriangular ，但是UpperTriangular+LowerTriangular=Matrix 。

我们还谈到了元素类型的提升。 我喜欢你可以在不必要的时候避免促销，例如

julia> Base.LinAlg.UnitLowerTriangular(ones(Int, 3, 3))\[1,2,3]
3-element Array{Int64,1}:
 1
 1
 1

julia> Base.LinAlg.UnitLowerTriangular(ones(Int, 3, 3))\[1,2,3.0]
3-element Array{Float64,1}:
 1.0
 1.0
 1.0

我不能说这对 Julia 来说有多具体，但正如我们所见，似乎至少 Eigen 不会管理提升，而是要求元素类型在线性代数运算下是稳定的。

我们希望 Jeff 现在进入最后阶段，因此现在特别欢迎对他的论文（参见上述 github 存储库）的反馈和更正。

随意提交 PRs 以解决拼写错误、缺少参考资料等。

@stevengj我们应该期待在这里公布防守时间表吗？

是的。

我希望他已经在麻省理工学院找到了一份工作......（或任何他将继续伟大的 Julia 工作的地方）......现在阅读他的论文......很棒的东西，IMO！

@andreasnoack有点深奥，但无论如何很有趣：定义箭头矩阵环类型并从基础应用 Cholesky 分解，以查看箭头矩阵的箭头矩阵的 Cholesky 分解的结构是什么样的。 https://gist.github.com/mschauer/c325ff89cd378fe7ecd6（“A ”箭头矩阵，“F”全矩阵，“L”下半箭头“）。

@ScottPJones谢谢！！

防御安排：5 月 13 日星期三下午 1 点 Stata D-463。

@JeffBezanson你打算通过 replay.csail.mit.edu 记录它吗？

...也许我宁愿忘记它... :)

这不是最后一个复选框的用途吗？

你真的_确定你应该给出地址吗？ 你可能会被粉丝们围攻，他们想要你论文的签名副本！ :咧嘴笑:

我已经拿到票了。 我听说黑市上的价格已经高达 800 美元。

Stata D-463 在我那个年代不在那里...（我只是去拜访朋友和参加 NE 数据库日）...它会足够大吗？ 他肯定需要10-250！

官方 D-463 可容纳 48 把椅子。 如果我们认为这还不够，我们可以考虑换一个更大的房间。

我真的不认为你真的很感激你所做的一切！ 如果您的所有粉丝都出现了，也许 10-250 还不够大……现在就预订 Kresge！

技术计算中的抽象

• 博士生：杰夫·贝赞森
• 论文导师：Alan Edelman 教授
• 论文委员会：Steven Johnson 教授、Saman Amarasinghe 教授、Gerry Sussman 教授
• 日期：2015 年 5 月 13 日星期三
• 时间：下午1点
• 地点：麻省理工学院校园，32-D463

_基于数组的编程环境在科学和技术计算中很受欢迎。 这些系统由内置函数库和用于交互的高级语言组成。 尽管这些库表现良好，但人们普遍认为，用这些语言编写脚本必然很慢，而且只有英勇的工程壮举才能最好地部分改善这个问题。_

_这篇论文认为，真正需要的是这个功能的更连贯的结构。 要找到一个，我们必须问技术计算的真正含义。 本论文认为这种编程的特点是强调操作符复杂性和代码专业化，并且可以设计一种语言来更好地满足这些要求。_

_关键思想是集成代码_ _选择_ _与代码_ _专业化_，_使用泛型函数和数据流类型推断。 像这样的系统可能会因编译效率低下，或者不确定要专注于什么而受到影响。 我们展示了足够强大的基于类型的调度解决了这些问题。 由此产生的语言 Julia 实现了对技术计算用户期望的许多生产性功能的 Quine 式“消除解释”。

他的论文有印刷版吗？

也许签名副本

这就是我所希望的……我想我可以在 10 到 15 年内在 Ebay 上卖一份亲笔签名的副本（那时我真的需要它来偿还我孩子的大学教育……尤其是。如果他们去他们说他们想去的地方...... ：咧嘴笑：）

祝你好运，杰夫！

祝你好运！ 如果我在该地区，我会成为@ScottPJones提到的粉丝之一

@斯科特琼斯：+1：

打断一条腿，杰夫！

祝你好运，杰夫！

祝你好运！ @JeffBezanson

@JeffBezanson祝你好运！！

希望我能得到一个座位。

祝你好运

我告诉他他应该预订10-250！

从我的iPhone发送

2015 年 5 月 13 日上午 11 点 53 分，于一超[email protected]写道：

@JeffBezanson祝你好运！！

希望我能得到一个座位。

—
直接回复此邮件或在 GitHub 上查看。

祝你好运！

同上！

幸运的是，我早早地得到了一个座位......我是对的（像往常一样：咧嘴笑：）他真的应该预订一个更大的房间！

恭喜

固定的。

还有一个复选框未选中。 最好开始工作。

:shipit: :tropical_drink: :beers: :cocktail: :tada: ！

：竖起大拇指：

恭喜，贝赞森博士！

恭喜，杰夫！

+1

布拉沃

最后一个复选框现在已经填满了肯塔基波旁威士忌。

祝贺杰夫！

2015 年 5 月 13 日星期三下午 1:44，Mike Nolta [email protected]
写道：

+1

—
直接回复此邮件或在 GitHub 上查看
https://github.com/JuliaLang/julia/issues/8839#issuecomment -101772806。

恭喜！

恭喜杰夫！ :啤酒: :啤酒: :微笑:

这太棒了！ 恭喜，杰夫。 ：烟花：

好消息。 祝贺你，杰夫！

恭喜！

恭喜

哇哇恭喜杰夫！

恭喜，贝赞森博士！

感谢您发布照片，@ScottPJones。 @jiahao ，我想你也有一些照片？

祝贺杰夫。 你以这个 PHD 结尾的工作影响了我们中的许多人。 它将对科学计算产生巨大影响！ 摇滚吧！

祝贺。

伟大的！

恭喜杰夫！！

太棒了，恭喜！！

恭喜 Bezanson 博士！

论文，对于那些想偷看的人：

https://github.com/JeffBezanson/phdthesis/blob/master/main.pdf

恭喜！

恭喜！

恭喜！

恭喜：+1：

我不知道为什么 GitHub 决定旋转我所有的图片，但它们就在这里。

问题闭幕式视频：http: //youtu.be/hGpLOZX6CEY

恭喜你，杰夫！ 如果你在西雅图，让我给你买杯祝贺酒。 :)

恭喜杰夫。 庆祝您作为一个社区的工作感觉非常好。

恭喜！

@jiahao ，可能值得重新运行Julia 的最新世界作为致谢页面的补充材料 :)

谢谢大家。

不幸的是，我的论文实际上并没有完成，但希望很快就会......

我还有几张照片，我醒来后会把它们发给杰夫（为了他的母亲，一位非常好的女士！）_Dr._ Bezanson 如果愿意，可以将它们张贴在这里...

尚未完成？？？ Gerry 有没有要求你删除所有该死的“语法”，让他用 s 表达式写作？

@JeffBezanson使用 mac 不是我期望看到的图片！

耶！

恭喜

池塘这边的所有粉丝都做得很好。

尚未完成？？？ Gerry 有没有要求你删除所有该死的“语法”，让他用 s 表达式写作？

你成功了！ 我不是在开玩笑。 但他会满足于可选的 s-expr 模式。

演讲结束后我一直在和他交谈......他喜欢你的东西，但真的不关心所有的语法......只是_so_很多......他让我想起了Scheme手册有多小:grinning: 当我让他上 6.001 [第一学期它被教] 时，我们不得不在 MacLisp 中实现一个小型 Scheme 解释器......因为 Scheme 是如此之小，它是相当可行的......

我相信你可以很快地把它淘汰掉，带着那瓶波旁威士忌（如果还有剩下的话！;-)）

说到方案手册的长度，这很有趣：其中很大一部分专门用于记录数字的行为，而在 Julia 中，这是在库中定义的。 Julia 可能是一种比 scheme 更小的核心语言（当然，除非你将 LLVM 规范装订到它上面）。

不管是赞成还是反对，都过分强调语法！ 另请查看http://www.schemers.org/Documents/Standards/R5RS/HTML/ 的第 7.1 节。 方案语法比人们想象的要复杂！

Julia 可能是一种比 scheme 更小的核心语言（当然，除非你将 LLVM 规范装订到它上面）。

是的，朱莉娅的骨头很好！

是时候挖掘旧的@sexpr宏了吗？

恭喜你毕业了，恭喜你和 Julia 一起取得了成就！

:cake: 恭喜！

恭喜@JeffBezanson！

恭喜:)

:+1:

@boyers！ 好久不见！

想你们 ：）

恭喜！

只是一个问题：PDF 在 ToC 中没有链接，在 pdf 元数据中也没有可浏览的索引。
为什么 MIT 毕业的编译器作者在序言中添加 \usepackage{hyperref} 如此困难？

那是因为您应该阅读整个内容，而不仅仅是跳过。 ;-)

但是，是的，hyperref 将使这更容易获得。

如果您添加链接，我保证您会阅读整个内容：P

恭喜。 自由等待着。

恭喜，贝赞森博士！

@nicola-gigante，您可以提出拉取请求：微笑：。

我们可以游说获得最佳论文奖吗？

http://awards.acm.org/doctoral_dissertation/nominations.cfm

恭喜！！！

@jpfairbanks - 好主意！ 不过，它必须由他的论文顾问提交……纠缠艾伦·埃德尔曼，我想……

是的，它需要顾问的提名和 5 封支持信。 基于
这个问题我认为至少有5个人认为他应得的。

是否仅限于 5 封支持信？ 而且，真正认为他应得的人数至少要多几个数量级！

@JeffBezanson ：恭喜！

@alanedelman ：我认为@jpfairbanks有一个很好的观点，Jeff 应该获得ACM 博士论文奖的提名。

@JeffBezanson做得好，当之无愧！

@ScottPJones “此外，应包括至少 3 封，不超过 5 封来自该领域专家的支持信，他们可以提供额外的见解或论文影响的证据。”

也许 Gerry 会给他写一个（在他添加了 s-expr 模式之后！）:grinning:

黑客新闻首页 :-) 恭喜，杰夫。

@nicola-gigante 你说得对，我会添加 hyperref。

再次感谢大家。 您的所有赞赏都是最终的奖励。

@jiahao这是因为他们有浏览器不关心的EXIF旋转数据。 大多数时候。 如果图片是它自己的窗口，Chrome 只关心 EXIF 数据。 右键单击并“在新选项卡中打开”以查看它们的正确方向。

您可以使用 EXIF 元数据剥离器将其取下并以“正确”方式旋转它们。

+1 ACM 论文奖提名。

提名截止日期为 2015 年 10 月 31 日。

http://awards.acm.org/doctoral_dissertation/nominations.cfm

我不喜欢 ACM 要求向他们转让版权和独家出版权。 无论如何，它仍然是有价值和有声望的。

恭喜！

独家出版权！？！ 我有一份亲笔签名的副本（或两个……需要一个在 10 到 15 年内在 e-bay 上出售，另一个留给我自己：咧嘴笑：）……必须在它被锁定之前得到它ACM！
（当然，这可能意味着它可以在 ACM 的数字图书馆供会员使用）

一旦论文交给我签字，我就全心全意
提名论文获得各种奖项:-)

2015 年 5 月 17 日星期日上午 8:49，Scott P. Jones通知@github.com
写道：

独家出版权！？！ 我有签名副本（或
两个...需要一个在 10 到 15 年内在 e-bay 上出售，另一个留给自己 [图片：
:grinning:])...必须在它被 ACM 锁定之前得到它！
（当然，这可能意味着它可以在 ACM 的
会员数字图书馆）

—
直接回复此邮件或在 GitHub 上查看
https://github.com/JuliaLang/julia/issues/8839#issuecomment -102801616。

@JeffBezanson 没有评论...我_希望_他正在庆祝（更多地检查他的最后一个框），并且在他获得 s-expr 模式工作之前没有被 GJS 锁在某个房间里！

恭喜！

恭喜，@JeffBezanson！

（迟来的）恭喜！

更新：刚刚提交了文件。 提交的版本是https://github.com/JeffBezanson/phdthesis/tree/876be73a5aab9b034fac3eb9ea9d8f96713f786f 。

我敢肯定它在很多方面都存在不足。 那好吧。 希望那里没有什么不好的。

好的。 恭喜你真正完成了你的博士学位。

祝贺你，杰夫！ 伟大的成就。 我相信你很高兴一切都结束了。

我已经发现你的论文填补了 Julia 文档中的一些漏洞，所以它显然会非常有用。 所有文件都有缺陷； 我们其他人都对这些优势印象深刻！ 恭喜！

并感谢您分享！

哇！ 祝贺你完成了答辩和论文，以及他们所代表和代表的所有其他工作。 很高兴拥有这个里程碑来表彰您已完成的所有事情。 我希望你骄傲！

@JeffBezanson我希望您计划休息几天来放松和庆祝，或者您可能计划通过类型系统大修或其他方式来庆祝。 :-)

很高兴新的 pdf 具有 hyperref - 对于那些想要浏览的人。 我们还应该将它列入 Julia 出版物列表。