Slashdot Mirror
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."
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."
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.
Most ACs are not even worth the keystrokes to insult them. Be generically insulted by this and ignored otherwise.
Much of the world would love to see open-source Computational Fluid Dynamic and Finite Element Method solutions. Some cool things can come of it, such as a placing a built-in Julia interpeter in a data visualization program such as Paraview (or ImageJ) Now that Java is irrevocably fucked, I would like to see a Julia library that will mimic OpenProcessing, because we need a good graphic set and the mouse. There are some charting/graphic Julia libraries, but I am not aware of anything that will do what Processing currently does, though I do not like Processing as a language because of things like: Final for constants. Oracle made sure we got on-board with abandoning Java.
https://www.youtube.com/c/BrendaEM
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
Unlike Matlab with its bizarre idiosyncrasies, Julia actually has solid Lisp heritage.
Ezekiel 23:20
Well R is a fine choice if its extensive stats libs have something you need. It's hard to beat R for esoteric stats packages.
However, Octave is a broken piece of shit.
nt.
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).
In dutch we have a separate word for closed ranges like monday to friday. English needs to get with the times.
No, it's not. Also, in a metalanguage, you're not limited in for what target environments you can write code. There's no reason you couldn't write DSP code in it if you wanted. Found this in ten seconds, for example. Likewise, there have been Lisp-based hardware definition languages. There's no specific semantics imposed on all your code, which is what makes all this possible - you can define your own semantics for parts or the whole of your code if you decide that the value of this is greater than the effort expended.
Ezekiel 23:20
As a fellow mathematician, I think that you are finding 1-based indexing is more intuitive just because you are used to it. The examples you make reinforce it --- "the 0th thing" is just a naming convention. Even if you don't consider programming at all, it would make sense if the whole mathematics were rewritten with 0-based indexing. When you think about it, there's a lot of spurious -1's in various computations and formulas that just disappear if you use zero-based indexing and intervals of the form [a,b). It is something similar to applying functions to the right rather than to the left --- it's a counterintuitive change because of the way we all learned mathematics, but it makes perfect sense in isolation and it is actually slightly better.
Also, another elegant point is that ranges resemble a lot the 'nested empty set' construction of natural numbers that appears in ZFC: if 0=\emptyset, 1 = {0} 2 = {0, 1}, ... , then for each natural n Python's notation range(n) = {0,1,...n-1} simply coincides with n. Neat.
Python has homoiconic macros and multiple dispatch generic functions these days? Also, did you look into the source code?
Ezekiel 23:20
The thing that comes 0th
No, it's "The thing that comes at offset 0." Array indexes are offsets.
"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
Truth is stranger than fiction, but it is because Fiction is obliged to stick to possibilities; Truth isn't. Mark Twain.
Many calculus and discrete operations start at 0 and accumulate to N.
And some start at 1, and some start at 2. Some only use the even or odd terms. Including a zero can be a problem sometimes, e.g. Dirichlet series (like the Rieman zeta function) start at 1 because otherwise you're beginning by dividing by zero.
Should exponents start at 1 or at 0?
Exponents can be any real number, it doesn't matter where you start.
However modeling algorithms with 1-based indexes necessitates positing the existence of the end of the collection being a non-data object, an extra.
The Julia programmer doesn't have to worry about any theoretical extra points, or even what the indices are doing.
C++ STL iteration has begin and end iterators for its collections...
Maybe, but Julia isn't C++. I've done plenty of mathematical modelling in C++, it's a lot more painful than in Julia. Every time I've had a situation where 0-based indexing helped in C++, it turned out that Julia had a better way of doing it anyway that avoided the issue.
The zeroth element is extremely convenient in a hardware-facing (compiled) language, as its address offset of of 0 points directly to the first data element in an array.
How the hardware handles the data should be largely irrelevant. It doesn't even matter for performance, since you can simply offset all addresses by 1 and then it's entirely transparent. All that should be the compiler's job, leaving the abstraction to the programmer.
Is Julia a Lisp?
https://juliacomputing.com/blo...
If it is, how does it distinguish itself from previous attempts at Lisp Without So Darned Many Parenthesis?
The beloved C language and Unix OS (FreeBSD, Linux being what is current) were once characterized as the crude, Worse-is-Better New Jersey approach (Bell Labs) that "gets stuff done" as opposed the MIT approach that wins the sort of awards that are the subject of the GP.
The closest anyone had come to turning the tide on Worse-is-Better is Java, or at least until January 2019 when Mr. Ellison starts charging rent, which isn't a Lisp. Whereas Java has light-years of distance in its semantics from C, it adopted its syntax without apology as a way of popularizing it on the idea that C-style curly braces for block delimiter, ordinary parenthesis in for and if statements, semicolon statement terminator had become so pervasive so why buck-the-standard?
Java is also not a Lisp -- it has its clunky Reflection for duck-type method invocations along with class loaders, that allow you to update a running application without taking it down by loading a replacement class and then let the old class get garbage collected when all of the old objects are dereferenced -- but it doesn't go full MIT because everyone knows you don't go full MIT and expect wide adoption?
OK, I understand the shade thrown on Larry Ellison, but this Julia thing is trying to be the Next Java judging by all the jokes cracked on Slashdot of the next thing being corporate recruiters requiring 10-years experience in it to land a job? That was originally a Java joke.
So what does Julia do better than Java (Juptyer notebook == Java applet?)? How long will it be before Julia becomes a security risk that campus sysadmins will attempt to wipe from university servers used in instruction?
If MATLAB is what Julia is meant to supersede, MATLAB is Java. The reason MATLAB is so slow to launch is that it is loading a JVM and a whole stuff-ton of Java class libraries? That the Command Window and Figure Windows are Swing JFrames? That you can create instances of Java classes from the Command Line and invoke their methods? That the Figure Window export to graphics file format choices is implemented with the SLAC/CERN FreeHEP consortium's VectorGraphics Java classes?
Is the Julia team's idea of a clean-sheet-of-paper design is such a better idea than MATLAB layered on top of Java using the JNI to link to the massive body of FORTRAN and C-language numerical libraries? MATLAB is a repackaging and a rebranding of an enormous amount of an existing software ecosystem.
I suppose that you also use rulers that start at 1 cm or 1 inch?
Avantslash: low-bandwidth mobile slashdot.
I suppose that you also use rulers that start at 1 cm or 1 inch?
Of course not, that's counting (or measuring, with some notion of quantity), not ordering. And on a ruler after 0 you get 0.1 (1mm), or 1/16, not 1.
If you're storing some elements in your array (e.g. [0.0, 0.3, 10.5, 2.7, 10.3]), then the elements are stored in some order and you're looking for the nth element in the array, in which case the 1st element is 0.0, the 2nd is 0.3, the 3rd is 10.5 etc. You're not measuring distance from the start of items with some width given in bytes (okay, that's how the machine underneath happens to be doing it, but it could choose to store things in a different way (e.g. Clojure handles its arrays as trees), and still give you the results you're looking for).
This. You should be able to define an array from -17 to 666 if that fits the problem domain better and allows cleaner code.
Confucius say, "Find worm in apple - bad. Find half a worm - worse."
I went to a meetup a few years ago where some of its developers presented Julia. I left at the break because it was clear that this was yet another mutt offspring of a couple of popular scientific languages - R and Matlab - without even a vague idea of grammar or consistency. Also, yet another language that works with arrays but does not know how to treat them as first-class citizens. "An array? Let's start a loop!"
The initial comment about language not mattering could have come from anyone who thinks all languages should look like C - mainly because most of them do. Get outside your little box - take a look at LISP or J or K or APL, for instance. Language does matter but mono-lingual people have no idea that it does - see, e.g. Feynman notation.
The most interesting thing I got from the half of the presentation I saw was when I noticed that in their performance comparisons between Julia and other languages was that Javascript was the winner or one of the best for many of their examples. I imagine the language has improved since then but not in any way that makes an important difference since their primary emphasis was on speed of execution.
Still waiting for the rest of you to show even a sign of catching up....