Julia Language Co-Creators Win James H. Wilkinson Prize For Numerical Software (mit.edu)

An anonymous reader writes: Three co-creators of the MIT-incubated Julia programming language are the recipients of the 2019 James H. Wilkinson Prize for Numerical Software. With origins in the Computer Science and Artificial Intelligence Laboratory (CSAIL) and the Department of Mathematics, Julia is a programming language created in 2009 by Jeff Bezanson PhD '15, former MIT Julia Lab researchers Stefan Karpinski, and Viral B. Shah, and professor of mathematics Alan Edelman. The prize will be awarded to Bezanson, Karpinski, and Shah "for the creation of Julia, an innovative environment for the creation of high-performance tools that enable the analysis and solution of computational science problems."

Released publicly in 2012, Julia has over 3 million downloads and is used in over 1,500 universities for scientific and numerical computing. "I am proud of the intellectual contributions of the Julia Lab, which applies the latest in computer science to science and engineering problems, while engaging interdisciplinary collaborations all over campus and beyond," said Edelman. "Julia is increasingly the language of instruction for scientific computing at MIT."

Comments

Languages are not that important

[gweihir]

Libraries are. On the other hand, every real expert can learn a programming language in a week or two, so special-purpose languages have merit.

Re:Languages are not that important

[ShanghaiBill]

On the other hand, every real expert can learn a programming language in a week or two

This is only true for "normal" programming languages that are a series of instructions executed in sequence, with standard control instructions such as loops and conditional branches. So all you have to do is learn some new syntax.

But many programmers have difficulty learning languages that don't fit that paradigm, such as Prolog and Verilog.

Re:Languages are not that important

[phantomfive]

C++ isn't a language. It's five languages.

Re:Languages are not that important

[Anonymous Coward]

The phrase "cluster fuck" was invented to describe the C++ language.

Re:Languages are not that important

[ShanghaiBill]

That is why I said "real expert".

How do you know if an expert is "real"? Does he also have to be a Scotsman?

Verilog does not quite count IMO, as learning it is not so hard, but doing useful hardware in it requires additional knowledge.

Verilog is a Turing complete language. Most Verilog programs are not hardware descriptions, they generate FPGA bitstreams.

Re:Languages are not that important

[Anonymous Coward]

On the contrary, this is one of those cases where the language matters, I think. Julia's plan is pairing Matlab's ease of use with C-level performance, and you simply don't get there without some serious design effort on the language and its standard library. The authors have various examples on why you can't simply take Matlab and improve its compiler; for instance, the type stability of sqrt.

Octave should just close shop

[Anonymous Coward]

It's old and buggy. Half the libraries are broken because they are never updated to match the new releases. It's a mess. It's time to pull the plug on Octave.

Julia came along at just the right time

Re:Dijkstra is rolling

[Anonymous Coward]

If you prefer 0-based indexing, you might find it more intuitive, but I assure you there are those of us who find 1-based indexing more intuitive, especially when you consider the differences between ordinality and cardinality. The amount of explanation that seems to go into showing new programmers how 0-based indexing works suggests it really isn't all that intuitive after all.

The thing that comes 1st is at array position 1. The thing that comes 0th... doesn't exist, so why reserve an array position for it? Why should the 4th and 7th items appear at positions 3 and 6, that's so ugly. Yes, we count from 0, but counting suggests quantity which could have fractional values. Perhaps you'd say time starts at 0, but then which index should t=1.75 go into? Fine, arrays are implemented as memory offsets from a starting position, but do we really need to know how the machine implements it to use it? Off-by-one errors happen regardless of what index you use. And I disagree with Dijkstra's suggestion that half-open intervals are more elegant, personally if I say Monday to Friday or 1 to 10, I mean fully inclusive intervals. I have much respect for Dijkstra, but I not everything he said should be taken as gospel.

I'm a mathematician, and I don't think it's a coincidence that many of the languages used by mathematicians (Fortran, R, Matlab, Octave, Maple, Mathematica, and now Julia) are all 1-based. We tend to have better implemented multidimensional arrays, so there's less worry about indexing them manually (I've done multidimensional arrays by hand in C++ for numerical programming, it wasn't the most fun experience).

Re: Dijkstra is rolling

[Anonymous Coward]

In dutch we have a separate word for closed ranges like monday to friday. English needs to get with the times.

Re:Dijkstra is rolling

[Desler]

The thing that comes 0th

No, it's "The thing that comes at offset 0." Array indexes are offsets.

Re: creimer's phat bootay is hot as phuck!!! HNNNN

[niftymitch]

"Why is everyone so interested in Julia?
"At some high level, Julia seems to solve what Steven Johnson (MIT) described at EuroSciPy on Friday as 'the two-language problem'. It's also known as Outerhout's dichotomy. Basically, there are system languages (hard to use, fast), and scripting languages (easy to use, slow). Attempts to get the best of boths worlds have tended to result in a bit of a mess. Until Julia.
(https://agilescientific.com/blog/2014/9/4/julia-in-a-nutshell.html)

https://en.wikipedia.org/wiki/...
"the language-agnostic design of LLVM has since spawned a wide variety of front ends: languages with compilers that use LLVM include ActionScript, Ada, C#,[4][5][6] Common Lisp, Crystal, CUDA, D, Delphi, Fortran, Graphical G Programming Language,[7] Halide, Haskell, Java bytecode, Julia, Kotlin, Lua, Objective-C, OpenGL Shading Language, Pony,[8] Python, R, Ruby,[9] Rust, Scala,[10] Swift, and Xojo."

While Julia is not running on JVM it should be noted that a recent update to the JVM helps it be an interesting compiler target.
See: Java 7 JVM implements JSR 292: Supporting Dynamically Typed Languages[7] on the Java Platform, a new feature which supports dynamically typed languages in the JVM. This feature is developed within the Da Vinci Machine project whose mission is to extend the JVM so that it supports languages other than Java. (https://en.wikipedia.org/wiki/Java_virtual_machine)

LLVM