Jeff Bezanson PhD - Githubissues

stevengj commented 10 years ago

One of the core Julia authors, @JeffBezanson, has become a problematic developer. He needs to graduate from MIT, ideally by January 2015. Dependencies:

[x] Thesis proposal.
[x] Thesis outline.
[x] Meeting with thesis committee.
[x] Rough draft sent to advisor(s).
[x] Schedule defense.
[x] Final draft sent to committee.
[x] Defense.
[x] Alcohol.

This is a priority issue, to ensure that arms are not broken and to guarantee long-term viability of the Julia project.

cc: @alanedelman, @jiahao, @StefanKarpinski, @ViralBShah, @samanamarasinghe, @gjs

Edit (VS): This issue is closed with the following thesis. I am putting it up here, since many people will be interested in finding it. https://github.com/JeffBezanson/phdthesis/blob/master/main.pdf

simonbyrne commented 9 years ago

One example is inequality comparison with MathConst (representing irrational numbers) in PR #9198:

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

FloatingPoint vs MathConst compares the float with the float above/below the constant
Rational{T} vs MathConst (for bounded integer types T) finds the closest rational representable by the type; then based on whether it is above or below the true irrational type.

What makes this feasible is easy access to the Rational and BigFloat functionality at compile time. Although it might be possible using something like a macro preprocessor, it would require essentially two implementations of all the functionality.

JeffBezanson commented 9 years ago

I have a small update on this issue. The document is now open to the public: https://github.com/JeffBezanson/phdthesis

Today I'm releasing a sort-of draft by self-imposed deadline. It's not much of a draft; many pieces are entirely missing. I also claim no responsibility for anything that is inside TeX comments, or present only in the past version history :)

All feedback welcome! In particular, if you have nice examples of julia code that show off the language well, especially anything that would be hard to do without it. Always looking for good non-trivial multiple dispatch examples.

johnmyleswhite commented 9 years ago

Thanks for making this public. I was surprised when I tried to follow a link SGJ used and hit a 404.

andreasnoack commented 9 years ago

Maybe the triangular matrix arithmetic could be an example of the usefulness of Julia's multiple dispatch. Here UpperTriangular+UpperTriangular=UpperTriangular, but UpperTriangular+LowerTriangular=Matrix.

We also talked about promotion of element types. I like that you can avoid promotion when it is not necessary, e.g.

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

I can't say how specific this is to Julia, but as we saw, it appeared that at least Eigen will not manage promotion, but require that the element types are stable under the linear algebra operation.

stevengj commented 9 years ago

Jeff is going into the final stretch now, we hope, so feedback on and corrections to his thesis (see the abovementioned github repository) would be especially welcome now.

Feel free to submit PRs for typos, missing references, etc.

yuyichao commented 9 years ago

@stevengj Should we expect an announcement of the defense schedule here?

stevengj commented 9 years ago

Yes.

ScottPJones commented 9 years ago

I hope he has a job lined up at MIT already... (or anywhere where he'll continue the great Julia work)... reading his thesis now... great stuff, IMO!

mschauer commented 9 years ago

@andreasnoack A bit esoteric, but anyway funny: Define a arrow matrix ring type and apply the Cholesky factorization from base to see what the structure of a cholesky factorization of an arrow matrix of arrow matrices looks like. https://gist.github.com/mschauer/c325ff89cd378fe7ecd6 ("A" Arrow matrix, "F" full matrix, "L" Lower half arrow").

JeffBezanson commented 9 years ago

@ScottPJones thanks!!

Defense scheduled: Wed May 13, 1pm Stata D-463.

jiahao commented 9 years ago

@JeffBezanson are you planning to have it recorded through replay.csail.mit.edu?

JeffBezanson commented 9 years ago

...maybe I'd rather forget about it... :)

ihnorton commented 9 years ago

Isn't that what the last checkbox is for?

ScottPJones commented 9 years ago

Are you really sure you should be giving the address out? You might get mobbed by fan boys, who want signed copies of your thesis! :grinning:

timholy commented 9 years ago

I've already got my tickets. I hear the price is already up to $800 on the black market.

ScottPJones commented 9 years ago

Stata D-463 wasn't there in my day... (I've only been there to visit friends and for the NE Database Day)... Is it going to be big enough? Surely he's going to need 10-250!

JeffBezanson commented 9 years ago

Officially D-463 fits 48 chairs. If we think that won't be enough, we can look into getting a bigger room.

ScottPJones commented 9 years ago

I seriously don't think you really appreciate what you've done! If all of your fans showed up, maybe 10-250 wouldn't be big enough... book Kresge now!

stevengj commented 9 years ago

Abstraction in Technical Computing

PhD Candidate: Jeff Bezanson
Thesis Supervisor: Prof. Alan Edelman
Thesis Committee: Prof. Steven Johnson, Prof. Saman Amarasinghe, Prof. Gerry Sussman
Date: Wednesday May 13, 2015
Time: 1pm
Location: MIT campus, 32-D463

Array-based programming environments are popular for scientific and technical computing. These systems consist of built-in function libraries paired with high-level languages for interaction. Although the libraries perform well, it is widely believed that scripting in these languages is necessarily slow, and that only heroic feats of engineering can at best partially ameliorate this problem.

This thesis argues that what is really needed is a more coherent structure for this functionality. To find one, we must ask what technical computing is really about. This thesis suggests that this kind of programming is characterized by an emphasis on operator complexity and code specialization, and that a language can be designed to better fit these requirements.

The key idea is to integrate code _selection_ with code _specialization_, using generic functions and data-flow type inference. Systems like these can suffer from inefficient compilation, or from uncertainty about what to specialize on. We show that sufficiently powerful type-based dispatch addresses these problems. The resulting language, Julia, achieves a Quine-style "explication by elimination" of many of the productive features technical computing users expect.

ScottPJones commented 9 years ago

Will there be printed copies of his thesis available for spectators?

yuyichao commented 9 years ago

Maybe signed copies

ScottPJones commented 9 years ago

That's what I'm hoping for... I figure I can get some big bucks on Ebay selling an autographed copy in 10-15 years (when I'll really need it to pay off my kids' college education... esp. if they go where they have said they want to go... :grinning: )

aviks commented 9 years ago

Good luck, Jeff!

mikewl commented 9 years ago

Good luck! If I was in the area I would be one of the fanboys @ScottPJones mentions

Gnimuc commented 9 years ago

@ScottPJones :+1:

mbauman commented 9 years ago

Break a leg, Jeff!

johnmyleswhite commented 9 years ago

Good luck, Jeff!

xianyi commented 9 years ago

Good luck! @JeffBezanson

yuyichao commented 9 years ago

@JeffBezanson Good Luck!!

Hopefully I can get a seat.

wlbksy commented 9 years ago

good luck

MithrandirMiles commented 9 years ago

I told him he should have booked 10-250!

Sent from my iPhone

On May 13, 2015, at 11:53 AM, Yichao Yu notifications@github.com wrote:

@JeffBezanson Good Luck!!

Hopefully I can get a seat.

— Reply to this email directly or view it on GitHub.