Please create an account to participate in the Slashdot moderation system

 



Forgot your password?
typodupeerror
Compare cell phone plans using Wirefly's innovative plan comparison tool ×
Programming The Almighty Buck

Julia Programming Language Receives $600k Donation 106

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.
This discussion has been archived. No new comments can be posted.

Julia Programming Language Receives $600k Donation

Comments Filter:
  • by AnontheDestroyer ( 3500983 ) on Wednesday November 18, 2015 @05:13PM (#50957893)

    ...are we doomed to forever playing with our own Python?

  • 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.

    So they're re-inventing Python?

    • Re:So . . . (Score:5, Informative)

      by Beck_Neard ( 3612467 ) on Wednesday November 18, 2015 @05:19PM (#50957921)

      Not at all. Julia is just-in-time compiled to native code. You can basically get C-like performance in pure julia: http://julialang.org/benchmark... [julialang.org]

      There's also a powerful type system and lisp-style macros, along with support for parallel programming and lightweight threads, allowing you to do stuff like: https://gist.github.com/anj1/2... [github.com]

      (that's just a toy example, of course)

      • by HiThere ( 15173 )

        Added to which they've removed Python's GIL. But the documentation doesn't make it clear how to get a character's General Category, despite the fact that many of the functions use it in deriving their answer (e.g., isalnum). This would be a real annoyance were I seriously considering using it.

        • import Base.UTF8proc.category_code

          category_code('')

          • by HiThere ( 15173 )

            Hmmm... I'd looked under string and character documentation, but didn't find a reference to that function. Not surprising given where they chose to stash it, but it strikes me as an unreasonably obscure location. Surely character should have at least a cross reference. (Well, perhaps it did and I missed it. I wasn't seriously considering switching to Julia. And perhaps the locations would have been obvious to someone who was acquainted with the code. Even I could tell it was being used in some functio

    • Take a look at the benchmarks on the Julia frontpage and reevaluate your statement.

      • IIRC, the MATLAB results have improved a lot since they last posted these. Also don't forget that these benchmarks emphasize lower-level tasks. People use MATLAB and R for the higher-level functions they provide. I've generally found MATLAB's built-in higher level functions to be pretty quick and convenient. R is a language for statistics and so is pretty specialised; it almost doesn't belong on that list. I'm surprised at Octave's bad showing.
        • I found that MATLAB's emphasis on vectorization forces you into a form of coding that is not always useful or productive. Sure, it's better to use a*b when multiplying matrices, but stuff like this? :

          cell2mat(arrayfun(@(K) accumarray(C, F(:,K), [], @mean), 1:size(F,2), 'Uniform', 0))

          come on. It pays to have a language where you can write out a clear explicit loop if you want to and not worry about performance.

          • I never write MATLAB code that. If it looks like that then just write it as a loop. Over the last few years they've really sorted out the looping and you should see little speed difference between the arrayfun and loop approaches.
            • True, Matlab has included a just-in-time compiler, but the language has limitations and the compiler isn't as mature as Julia's (LLVM). Devectorized code often runs _faster_ in Julia, sometimes much faster. In Julia, vectorization is just a way of invoking BLAS functions when appropriate - as it should be.

              • Yes, MATLAB isn't the fastest language out there, but it's still no slouch. Its main advantage comes from the rich collection of functions in its toolboxes and this what Julia lacks. If you need more speed in MATLAB you have can write MEX functions in C or C++.
    • No they are not. Python has a two-language problem, for a starters. Also, Python is a pain in the neck for scientific computing, which is my day job, btw. Also Julia is soon to work seamlessly with both C and C++ (like, include header, load library, and execute code without any bindings or nonsense). Julia has the potential to be properly threaded, but is really aimed at being seamlessly multi-process. That mean seamlessly moving data between processes -- even on different computers and networks. This is se
  • as a jaded sysadmin im in the wrong business. Ive learned perl and python and bash and even picked up a case of php along the way but if all it takes for hipsters to belch a half a million dollars at me is a language? then this is where it begins, slashdot.

    My language is called twerk-cankle. It was named after a dance that comes from a small island in the osowhatwhocares islands and is ritually performed with great efficiency. my classes are called palpatisms and you instantiate them by using the pe
    • by MightyMartian ( 840721 ) on Wednesday November 18, 2015 @05:23PM (#50957963) Journal

      I won't be silenced until Brainfuck gets the recognition it deserves!

    • by glwtta ( 532858 ) on Wednesday November 18, 2015 @05:44PM (#50958093) Homepage
      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.
      • 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.
      • 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.

  • Eek the Ignorance! (Score:2, Informative)

    by TR NS ( 4242885 )
    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.
  • 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 ar
  • 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.
    • Julia is more related to the lisp family of programming languages than ML. Some have said that Julia is just another lisp (albeit with a nifty dynamic type system supporting type families and polymorphism).

  • 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.

  • by iliketrash ( 624051 ) on Wednesday November 18, 2015 @10:36PM (#50959931)

    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 couldn't agree more, especially for a language that deals with math and linear algebra. When accessing submatrices of matrices and doing advanced linear algebra manipulations, using 0 based offsets leads to far more natural indexing, reduces the need to constantly subtract and re-add 1, and leads to fewer chances to make silly errors.
    • by Mr.CRC ( 2330444 )
      There have already been extensive discussions about this, and from what I've seen starting indexing at 1 is likely to stick in Julia. Feel free to search for this matter yourself.
  • I guess it really is true that you can write Fortran in any language.

  • 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.

  • 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.
  • 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 [coursera.org]. 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 va

RAM wasn't built in a day.

Working...