essay on the history of programming languages

[Stefan Karpinski]

Graydon Hoare (original author of Rust) wrote a truly lovely essay in two parts about the history of programming languages, the predominance of two-language systems – or "Ousterhout-dichotomy languages," as he puts it – Lisp's historical defiance of this dichotomy, Dylan as a successor to Lisp, and finally Julia as a modern successor to Lisp and Dylan:

http://graydon2.dreamwidth.org/3186.html

http://graydon2.dreamwidth.org/189377.html

This is a great read and an edifying historical perspective, regardless of the Julia bit at the end, but may be especially interesting to folks on julia-users.

[John Myles White]

I loved this two-part essay. Highly recommend it to anyone who hasn’t read it.

 — John

[Tobias Knopp]

Indeed, this has been a great read. Thanks for sharing Stefan.

Tobi

[Job van der Zwan]

By the way, is video for the Strange Loop presentation linked near the end ever going to be public?

[Leah Hanson]

Looks like it will be next month: http://www.infoq.com/presentations/julia-dispatch?utm_source=infoq&utm_medium=QCon_EarlyAccessVideos&utm_campaign=StrangeLoop2013

[Job van der Zwan]

I get a different message:

Thank you for attending Strange Loop 2013
This is a restricted presentation that can only be viewed by Strange Loop 2013 attendees!

Which is odd, because I didn't attend in the first place.

[Leah Hanson]

That's the first part of what I saw too. After that, it says "The public release of this presentation will be in the next month.".

[Stefan Karpinski]

This probably because I never submitted a PDF of this talk – it was an IPython notebook, rather than normal slides. I've repeatedly tried to use nbconvert to turn the notebook into a PDF, but Python's package management has defeated me every time, in the process frustrating me greatly, but also making me much happier about Julia's package situation. So if someone who has better python-fu than I do – or happens to have all the requisite Python packages already installed – wants to convert this notebook from .ipynb to some kind of PDF, then I'll send it to Alex Miller and maybe he can get the presentation up on InfoQ. In the meantime, the CodeMesh talk I gave a couple months later covers a lot of the same material: http://vimeo.com/84661077.

[Yee Sian Ng]

Attached.

[Stefan Karpinski]

Thank you! I'll work no getting this posted and hopefully we'll get an InfoQ video soon.

[Ismael VC]

Stepfan, I highly recommend you to use the Anaconda Python Distribution, if you are using Windows! Then you would also need pandoc, MiKTeX and some LaTeX editor to output the PDF. But you are right, Julia's package system is so much better! Genius.

The only thing I don't get is how to install several packages at once, I  wrote a function

julia> function Pkg.add(pkgs::Array{String, 1})
         Pkg.update()

         for pkg in pkgs                                                                              

           Pkg.add(pkg)

         end

       end

add (generic function with 2 methods)

 

julia> Pkg.add(["Arduino", "SymPy"])

ERROR: no method add(Array{ASCIIString, 1})

julia> ASCIIString <: String

true

julia> function Pkg.add(pkgs::Array{ASCIIString, 1})
         Pkg.update()

         for pkg in pkgs

           Pkg.add(pkg)

         end

       end

add (generic function with 3 methods)

 

julia> Pkg.add(["Arduino", "SymPy"])

INFO: Updating METADATA...

to do that, but it fails if the METADATA is updated in the progress. And it's kinda weird, because I saw an example on that in a video from you guys.

(Why does using Array{String, 1} doesnt work?)

[Job van der Zwan]

Looking forward to it!

And thanks for helping out, Yee siang Ng!

[Pablo Zubieta]

Ismael, although ASCIIString is a subtype of String, Array{ASCIIString,1} is not a subtype of Array{String,1}. As far as I understand Julia has been designed this way for practical reasons. You can read about it in the manual's section: Types.

You might want to rewrite your function as

function Pkg.add{T<:String}(pkgs::Array{T, 1})

[Ismael VC]

Thanks for that Pablo! I figured it out, while reading the Multiple Dispatch PDF, I also saw this other way:

function Pkg.add(pkgs::String...)

[Tracy Wadleigh]

Does it count as proper, non-Alanis-style, irony that I found this thread while evaluating Rust as a compliment to Julia, ala Ousterhout's dichotomy? ;-)

[Job van der Zwan]

On Saturday, 19 July 2014 15:01:31 UTC+2, Tracy Wadleigh wrote:

Does it count as proper, non-Alanis-style, irony that I found this thread while evaluating Rust as a compliment to Julia, ala Ousterhout's dichotomy? ;-)

Out of curiousity, what's the use-case your evaluating it for?

[Tracy Wadleigh]

A more robust path to shared memory parallelism. SharedArray is still not a first-class Julia citizen. And, even if it were, memory safety would still be an issue.

[John Myles White]

FWIW, shared memory parallelism is going to improve in Julia in the future.

 -- John

[Tracy Wadleigh]

> FWIW, shared memory parallelism is going to improve in Julia in the future.

I've been hoping it might. The issue thread has been open for more than a year and a half and silent the last six months, so I've been getting antsy.

Maybe I will just continue to bide my time by sticking with C++/OpenMP for certain critical bits until Julia can catch up. (I'd help with this task if I thought I could contribute in any net-positive way.)

Meanwhile, Rust does look like a pretty legit contender to unseat C++. It includes a bunch of features I love from my other favorite language (Haskell), like algebraic data types, pattern matching, and type classes (although extending type classes to higher kinded types is a currently missing must-have), along with a fancy memory model worthy of the multi-core age in which we live. I only wish they might have chosen to borrow a little more heavily from my most favorite feature of Haskell: it's beautiful, beautiful syntax.

[gentlebeldin]

Hmmm, tastes are different, I guess. I love Haskell for its purity and logic, but I've been wary of syntactically meaningful whitespace (aka tabs) since the times of "make". :D

[Stefan Karpinski]

We're actually actively working on multithreading and already have a very early implementation that works on Linux and gets pretty good scaling. There's a lot of work left to be done, but the multithreading thing is going to happen sooner rather than later (I could not have said this with any certainty a month ago). That said, Rust has a very well-developed and presumably mature multithreading story, so if you need it now, Rust may be a better bet. If you can hold off for a while and use C++/OpenMP for the critical parallel bits, multithreading is coming to Julia.