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

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: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).