Slashdot Mirror
Julia Programming Language Receives $600k Donation
jones_supa writes: The Julia programming language has received a $600k donation from Moore Foundation. The foundation wants to get the language into a production version. This has a goal to create more efficient and powerful scientific computing tools to assist in data-driven research. The money will be granted over the next two years so the Julia Language team can move their core open computing language and libraries into the first production version. The Julia Language project aims to create a dynamic programming language that is general purpose but designed to excel at numerical computing and data science. It is especially good at running MATLAB and R style programs.
...are we doomed to forever playing with our own Python?
So they're re-inventing Python?
Your hair look like poop, Bob! - Wanker.
Julia is aimed at people who do math-heavy problems (like computational physics), so that might be why you haven't heard of it. I think it's been on /. before.
I've never used Julia (the computing resources I have access to don't support Julia), but I've been following it, and the language looks pretty impressive: the ease of python/matlab with the speed of fortran/c. It's pretty impressive for a language you can use interactively.
Take a look at the benchmarks on the Julia frontpage and reevaluate your statement.
Look... you can either play with Julia or your Python.
I won't be silenced until Brainfuck gets the recognition it deserves!
The world's burning. Moped Jesus spotted on I50. Details at 11.
Considering that you have now heard of it, apparently that $600k "advertisement" did indeed change that.
It doesn't sound like something that most of us will use based on the problem domain and the other languages mentioned, I'm sure that there are some people who will find it highly useful and create some products that enhance all our lives.
What is actually wrong with you?
Julia is a useful niche language with a sizable community, not some bullshit vanity project. Unfortunately it has not chance of dislodging R, and I'll never understand the decision to make it dynamic, but it fills a role that nothing else does, at the moment.
Also, I have no idea what you think the word "hipster" means, or why you're so angry about it.
sic transit gloria mundi
Sure, but it's not necessarily competing with R. There are a _lot_ of Matlabbers who don't use C interface yet still run uncomfortably lengthy simulations, and for them Julia is hugely advantagous. Static typing would be something of a turnoff when you're coming from something like Matlab where you don't think about types at all in most programs, especially faffing about in the REPL.
http://julialang.org/benchmark...
If you think Java handles 'all tasks' then Julia isn't aimed at you. it's for scientific/numerical computing. Java is terrible at that, in terms of syntax, library support, and speed. Even python is far better than Java for that purpose.
A fool and his hard drive are soon parted.
It appears the ignorance level here on Slashdot has risen too an all time high. With the exception of one or two, none of the have any idea what they are talking about. People should be more careful about bashing things they know absolutely nothing about. Julia is a fairly kickass language and if you are a coder it should be on your radar -- up there with Go, Rust, Elixir, Clojure, etc. Having dabbled in most languages, I'd say it just might be the best of the lot, although I do dislike its module system.
I doubt anyone paid $600K to DICE to post Julia on Slashdot. There are cheaper ways to advertise.
Pick up a Julia Child cookbook and you're get a job in no time.
Au contraire, to me it feels a lot like Matlab re-done from scratch, but getting it right this time. The language is as pleasant as Python to work with, and it has none of the Matlab syntax abominations and unexpected performance bottlenecks.
My first program:
Hell Segmentation fault
Last I heard PyPy wasn't even attempting to get rid of the GIL.
Mind you, I do like Python, but not for multiprocessing. It's better than some choices, but it's hardly good.
(OTOH, when I really looked into Julia a few months ago [how many?] I decided that its way of doing multiprocessing wasn't useful for my purposes, but was instead optimized for array arithmetic.) This is great for most of their target audience, but doesn't fit my purposes which are more closely modeled by independent servers. I was looking for an approach that didn't have so much overhead, but was still passing messages into queues and not waiting for a response. The response, when it appeared, would be in the form of a message passed into the queue held by the originating thread/process/server. A TCP server is overkill, but finding anything simpler isn't straightforwards. (If it helps, the messages passed are immutable in actuality, whether or not conceptually.)
Currently I'm torn between Ruby and Python for speed of development, and I'll probably convert the code to use 0MQ so I can switch out modules for C or C++ code to improve speed. But this is running all around Robin Hood's barn to accomplish something that should be straightforwards. But by using 0MQ I can keep the character handling part out of C/C++, as those languages are truly terrible at handling Unicode.
I think we've pushed this "anyone can grow up to be president" thing too far.
There are some really fascinating - and potentially revitalizing - new languages out there, and these are among the most interesting. Julia is comparable to R running like greased lightening. It deserves attention and $600K. It has C level speed, which is remarkable given its domain. Elm is comparable to Haskell but much more approachable -- especially for web development. Elixir is like Ruby..maybe Ruby goes on a date with Erlang and they fall in love. Kinda functional; kinda something wild. There are some other FASCINATING languages coming out, too. For instance, you might check out red ... keeping in mind how the unknown REBOL did in in the redmonks comparison of conciseness + other compelling strengths.
What i would say is that we are in urgent need of better languages. The hardware, network, and critical deployment goes asymptotic while we mostly get is out-of-proportion bloat and bugs as our languages progress linearly, at best. We desperately need software upgrade in a real sense -- not the sense we generally keep getting with more of the shopworn procedural/object-oriented paradigm.
Julia is revolutionary, and I'm looking forward to it blowing away Matlab. All that's really holding it back is a good garbage collector, and mind-share. The language is truly superior, integrates seamlessly with C (like it is the same language -- there is no two-language problem), and soon C++. Could seriously replace C++ for /most/ things if it were multi-threaded. (There is some work on this, but Julia is designed to be multiprocess -- you can seamlessly shift objects between processes, even if they are on different machines. This is better then threads if you're doing scientific computing.) So Julia even has the potential to be better than D. And it runs as fast C (compiled by clang), and comes with the convenience of a REPL, and a truly beautifully designed.
Julia looks a lot like Matlab, and some Matlab code just runs as is, or requires only minor tweaks. Mathworks has long dominated scientific computing with their awkward and expensive -- but otherwise so convenient -- product. Mathworks is screwed.
Java/C#/python will never be what Julia is.
Like all pain, suffering is a signal that something isn't right
A good functional language that reminds me of the ML language. Looks like a decent replacement for fortran. Mandelbrot numbers appear suspect to me, as by definition, LuaJIT is written in C, and could not have magically performed better than C, unless their C implementation of mandelbrot was really crappy to begin with.
Non sequitur: Your facts are uncoordinated.
Get the language into a production version
I was not aware it was not production ready, and I now understand the fact is was not is a good explanation why it was such a pain to build. The thing embeds numerous third party libraries, and even the full distribution of LLVM.
Any language that purports to be a good for technical computing needs to get away from a forced base for indexing arrays. No, this is not a 0 or 1 problem. Arrays should be numbered from whatever the programmer specifies. The Pascal-type languages including Ada have this feature and it prevents many many errors. Maybe the $600K can buy this, but somehow I doubt it as this fixed-index-base is usually in the mindsets of the language's designers.
I guess it really is true that you can write Fortran in any language.
Organization? You must be joking..
As a physicist, I do a lot of numerical programming. I like julia, but it isn't quite useful to me yet. The problem is that it takes too long to run something the first time you run it in a session, and there's no way to save a compiled binary so I have to take the hit each time I run it. In particular, loading libraries takes too long. Maybe this boost will help it get there.
I doubt that Julia is going to surpass R in a decade as you say. I use R because statisticians like it and contribute every obscure technique into it. Statisticians (for most part) don't seem to care about performance or elegance of the language from an engineering standpoint. R toolbox, for whatever reason, makes sense to them. For most people, R is used more as a statistical shell, rather than a programming language. Do I care whether BASH scripting is elegant or fast? No... just that everything is quickly available from it.
Julia will no doubt be valuable for a subset of statistical techniques where performance matters. I think Julia will become a good extension language for vectorized code. It will perhaps be the next NumPy/Cython, a general-purpose high-level, high-performance language/libraries that everyone can plug into, not just the Python community.
The one problem I had was that it still had a nasty startup time when I last evaluated it an year ago. Gadfly took way too long to import... something like a minute. Its not a problem for interactive use, but painful for scripts. It can be worked around of course. I hope the grant helps.
I believe I read above that with PyCall.jl you can put your Python inside of Julia.
There is a lot more to Matlab's market than you may realize. Simulink is a big deal now. They played their cards well, and got entrenched. Something I wished Wolfram would have done better: strategize.
I heard Julia does JSON.
Human Rights, Article 12: Freedom from Interference with Privacy, Family, Home and Correspondence
I suspect that most people doing scientific computation have heard of Julia. It's a pretty neat language (and has a lot shallower a learning curve than Fortran, which is the big player in the space. If you're not in a field that uses Fortran a lot, Julia probably isn't too relevant to you). I had a student last year work on hoisting bounds checking out of loops to expose better optimisation opportunities for autovectorisation. In combination with Polly, this got a factor of 4-8 speedup for a lot of workloads and also paves the way for things like GPU offloading for critical loops. There are definitely a lot of places where some of that $600K could be spent on small improvements that would give huge improvements to end users.
I am TheRaven on Soylent News
Your enumeration of requirements omits scientific computing, which is the niche where Fortran is currently dominant and Julia is growing.
I am TheRaven on Soylent News
Unfortunately it has not chance of dislodging R,
The places I've seen Julia make the most inroads, it's been displacing Fortran, not R. And anything that displaces Fortran makes me happy.
I am TheRaven on Soylent News
It's aimed at the same niche as Fortran, but comes with memory safety, a REPL environment and a JIT, and good interfacing with other languages (including Fortran) to reuse library code. Fortran is probably still a better choice if you're writing a library that lots of people will use.
I am TheRaven on Soylent News
When I read about Julia I thought that. HIgh level features, beautiful syntax, macros and metaprogramming and has better perfomance than Python and it is better at multiprocessing.
Many people are talking about stuff they don't understand, but I thought my sarcasm was obvious enough.
Democracy Now! - your daily, uncensored, corporate-free
This may read like I'm a Julia fan-boy ... I guess I am.
I found out about Julia from the Machine Learning course from Coursera. Not directly, for at that time it was Octave; the advice given there was "trust me, for machine learning, this syntax is better." Indeed for many machine learning algorithms, the basis of understanding it, is vector and matrix operations. The innovation of Matlab which both Octave, which is essentially a gnu, open-source implementation of Matlab, and Julia is making vector valued variables first class (e.g. M*X, M^-1 where M is a matrix and X is a vector) makes things succinct and clear -- btw M^-1 is a representation of the inverse of M, an O^3 order algorithm in 4 characters?
Now yes, Python has numpy, which is close syntactically, but there are yet other comparisons were is not quite so easy, and Julia has an advantage here in that it's so new that devs are still tolerant of syntax changes -- for instance the behavior of {} was changed between Julia 0.3 and 0.4. And so if there's something new on the horizon that needs a re-org, Julia is better able to handle it.
The other thing of course which Julia and Python and R communities are attempting to do is to figure out the best way to extract the optimizations available from LLVM, and owing to it's close ties to and ability to modify to conform to changes of LLVM, Julia also has an advantage. As I've posted before, expect Julia to be able to scale almost linearly on the Xenon Phi (Knight's Landing+) for HPC linear algebra oriented applications -- expect this by Julia 0.5.