6 ms·

I wish them all the best. Julia seems to a good idea -- a high performance language with easy syntax (easy for Python users to jump to Julia), very good feature

I wish them all the best. Julia seems to a good idea -- a high performance language with easy syntax (easy for Python users to jump to Julia), very good features for threading/multiprogramming, good type system... ...here it seem like any other modern language, until you see that Julia has something that many other languages lack: true macros (true metaprogramming.) A big feature. And multiple dispatch on all functions! (a very nice feature that puts it above many other languages in use.) You can even program Julia in s-expressions if you feel like it. (Some argue that Julia should be considered a Lisp dialect.) Compared to the other languages with Python-like, C-like or Algol-like syntax, Julia stands out from them as a more powerful alternative. (If you need more power and flexibility than Julia with good processing speed, i think only Common Lisp will clearly provide it.) A very recommendable language, especially now with this initiative for giving more "enterprise-like" support, and worth looking in depth, if you are also considering moving to Go and Rust.

zbobet2012 9y ago
Julia is a great language, but it is still focused on the numerical computing world and is not "1.0" (language and API's are not locked down). I wouldn't really compare it to Go or Rust at this point. Go is focused on building services at its core (e.g. external event driven workflows). Aka microservices. Rust is focused on being a "traditional" systems programming language. Things like web browsers (duh), office suites, games, etc. Julia is focused on taking the best of R, Python/Numpy, and Matlab. It is a _great_ language. But as far as I can see it's really focused on a different problem space.
- flavio81 9y ago
  If you take a look at the features (esp. macros and multiple dispatch) you can see that is readily extensible for lots of applications. Thus the reason it is also sold as a "general purpose" language. Additonally, the very good support for threading and multiprocessing means it has a good future with services, async IO, and with event-loop web servers (a la node.js and friends). Finally, the focus on fast speed for numerical computation is particularly suited to games (as is the support for threading).
  - jacobolus 9y ago
    > good future with services, async IO, and with event-loop web servers [...] particularly suited to games This all seems extremely unlikely (compared to e.g. widespread success in scientific computing, which is still far from assured). Good luck though.
  - moomin 9y ago
    This sounds like a small thing, but with 1-based arrays, I'd bet more on it taking share from MatLab/R than from Rust or Java.
    - dangjc 9y ago
      I didn't think 1 based arrays would be a big deal, but whenever I try to port code from Julia to almost any other environment (C++, python/numpy, scala, JS), it becomes one of the hardest things to reason about quickly and correctly.
      - ScottPJones 9y ago
        1-based arrays, and column-major layout of arrays annoyed me at first, however, one of the beautiful things is that much of Julia is written in Julia. If you want 0-based (or arbitrary based!) arrays, then simply use the https://github.com/JuliaArrays/OffsetArrays.jl https://github.com/JuliaArrays/OffsetArrays.jl package, and PermutedDimArrays have been added to Base, to handle some of the issues of dealing with row-major (and other sorts of memory layout) matrices.
        moomin 9y ago
        Doesn't this mean that instead you're now dealing with inconsistent data representations?
  - kronos29296 9y ago
    Games are not going anywhere from a mostly C++ code base. New languages get adopted if they are too good to be true or they have enterprise adoption like Go. Even Python took 20 years to reach where it is now. Julia will take a long time to become a general programming language for all purposes. Scientific Computing is a realistic goal just like Golang is a realistic language with Enterprise adoption. It may not be the most elegant language like Lisp but it is practical. (People don't want the perfect solution but one that works most of the time) (P.S I am vaguely quoting this from some anecdote about a discussion on Lisp and C)
- tnecniv 9y ago
  > Julia is a great language, but it is still focused on the numerical computing world and is not "1.0" Word on the street is that Julia is supposed to get a 1.0 announcement at JuliaCon, which started today.
  - KenoFischer 9y ago
    Unfortunately 1.0 is delayed for a couple of months. 0.6 was released yesterday though, which already includes many of the features that were originally scheduled for 1.0.
- ScottPJones 9y ago
  Handling technical/scientific/numeric programming well is rather a hard nut to crack, and that is where the developers of Julia wanted a better solution for their own "greedy" programming needs, but Jeff Bezanson has been clear that it is also for general purpose programming (which is what I use it for). Many Julians are working to improve Julia for places that hadn't yet gotten as much attention (such as database access). I think in a couple of years, the canard of it being a "niche" language will be laid to rest.
Fomite 9y ago
For non-CS scientific computing users, "a high performance language with easy syntax" is a big feature.
- flavio81 9y ago
  Exactly, that's why I think Julia is a good idea. For scientific users used to R or Python, the performance should knock their socks off. (But users doing their work in C, C++ or Fortran will probably see little or no improvement).
  - bokertov 9y ago
    Do we really need Julia given that Python has Numpy which does a lot of the heavy lifting in numerical computation and is pretty fast?
    - Fomite 9y ago
      Numpy is great as long as you're using Numpy. There's lots of aspects of scientific computing that may not be using Numpy.
    - tavert 9y ago
      Numpy is good for vectorized calculations on dense multidimensional arrays of homogenous 64 or 32 bit floating point numbers, or integers. If that describes your problem and you like Python, by all means use numpy. If that doesn't describe your entire problem, you'll need more tools.
    - hpcjoe 9y ago
      It should be understood that numpy is written in C, and is an example of the "2 language problem" that Julia solves rather well. The question really is the converse ... given how deft Julia is with general programming as well as numerically intensive programming, do you really need Python + numpy(C).
    - tnecniv 9y ago
      On top of what others have mentioned, there is something to be said about getting numerical linear algebra tools as native citizens of a language. There are many things I hate about MATLAB, having matrices built into the syntax is nice.
giancarlostoro 9y ago
I have yet to fully jump into Julia but it is one language that has impressed me for a while, and I've seen a good number of them that impress me but Julia has a few things that to this day I think back to like code_native() and how it returns assembly code for whatever you throw at it, might seem trivial to others and y'know you can do it with C too but it's still cool you can just do it. Your description of it makes it very intriguing and makes me want to revisit it.
maimaiml 9y ago
> (If you need more power and flexibility than Julia with good processing speed, i think only Common Lisp will clearly provide it.) Common Lisp is terrible for numerical computing, and the type system is really quite weak IMO.
- flavio81 9y ago
  Maybe it is terrible for you... But good enough for doing numerical computing for the NASA and for Raytheon. The NASA used it for complete command of the Deep Space 1 spacecraft. "The Remote Agent" wasn't just entirely written in Common Lisp, it also won the NASA's Software of the Year Award... https://ti.arc.nasa.gov/tech/asr/planning-and-scheduling/remote-agent/ https://ti.arc.nasa.gov/tech/asr/planning-and-scheduling/rem... "It's one small step in the history of space flight. But it was one giant leap for computer-kind, with a state of the art artificial intelligence system being given primary command of a spacecraft. Known as Remote Agent, the software operated NASA's Deep Space 1 spacecraft and its futuristic ion engine " ... and i don't think they did it without heavy numerical computation. Want another application? Analyzing HDTV video images of the Discovery launch in real-time. Again, NASA. Another one? Mind you, i'm only citing examples where numerical computation is heavily involved... How about simulation of missile defense systems at Raytheon? http://www.lispworks.com/success-stories/raytheon-siglab.html http://www.lispworks.com/success-stories/raytheon-siglab.htm... "SigLab simulates an incoming warhead intercepted by the Exo-atmospheric Kill Vehicle (...) The system is capable of solving any computable system of difference equations. " Another one? "the new version of the complete Piano aircraft analysis tool, used by several major aircraft and engine manufacturers worldwide." http://piano.aero/ http://piano.aero/ As for the "type system being weak", the comment puzzles me, considering that Common Lisp has one of the best (if not the best) OOP system, CLOS. There is an automatic correspondence between objects and types in CLOS so I can argue it has one of the best type systems out there.
  - thebooktocome 9y ago
    I don't dispute the effectiveness of Common Lisp, but > There is an automatic correspondence between objects and types is almost never what is meant by a "strong type system" -- it more commonly means that types are checked at compile time, rather than run time. I don't doubt that any given lisp hacker could slap together a type inference system on top of CLOS, but as far as I can tell it's not built in. So, on the strong-to-weak type system spectrum, I would say: * Idris (lawful good, first-class dependent types) * Haskell (very strong, some support for dependent types) * Java (strong, some generics) * Julia (hybrid, code is analyzed for type inference during JIT, invariant types) * Common Lisp (weak by default, afaict) * Python (very weak) * Javascript (weakest) * PHP5, Perl (chaotic evil)

zbobet2012 9y ago

Julia is a great language, but it is still focused on the numerical computing world and is not "1.0" (language and API's are not locked down). I wouldn't really compare it to Go or Rust at this point. Go is focused on building services at its core (e.g. external event driven workflows). Aka microservices. Rust is focused on being a "traditional" systems programming language. Things like web browsers (duh), office suites, games, etc. Julia is focused on taking the best of R, Python/Numpy, and Matlab. It is a _great_ language. But as far as I can see it's really focused on a different problem space.

flavio81 9y ago
If you take a look at the features (esp. macros and multiple dispatch) you can see that is readily extensible for lots of applications. Thus the reason it is also sold as a "general purpose" language. Additonally, the very good support for threading and multiprocessing means it has a good future with services, async IO, and with event-loop web servers (a la node.js and friends). Finally, the focus on fast speed for numerical computation is particularly suited to games (as is the support for threading).
- jacobolus 9y ago
  > good future with services, async IO, and with event-loop web servers [...] particularly suited to games This all seems extremely unlikely (compared to e.g. widespread success in scientific computing, which is still far from assured). Good luck though.
- moomin 9y ago
  This sounds like a small thing, but with 1-based arrays, I'd bet more on it taking share from MatLab/R than from Rust or Java.
  - dangjc 9y ago
    I didn't think 1 based arrays would be a big deal, but whenever I try to port code from Julia to almost any other environment (C++, python/numpy, scala, JS), it becomes one of the hardest things to reason about quickly and correctly.
    - ScottPJones 9y ago
      1-based arrays, and column-major layout of arrays annoyed me at first, however, one of the beautiful things is that much of Julia is written in Julia. If you want 0-based (or arbitrary based!) arrays, then simply use the https://github.com/JuliaArrays/OffsetArrays.jl https://github.com/JuliaArrays/OffsetArrays.jl package, and PermutedDimArrays have been added to Base, to handle some of the issues of dealing with row-major (and other sorts of memory layout) matrices.
      - moomin 9y ago
        Doesn't this mean that instead you're now dealing with inconsistent data representations?
- kronos29296 9y ago
  Games are not going anywhere from a mostly C++ code base. New languages get adopted if they are too good to be true or they have enterprise adoption like Go. Even Python took 20 years to reach where it is now. Julia will take a long time to become a general programming language for all purposes. Scientific Computing is a realistic goal just like Golang is a realistic language with Enterprise adoption. It may not be the most elegant language like Lisp but it is practical. (People don't want the perfect solution but one that works most of the time) (P.S I am vaguely quoting this from some anecdote about a discussion on Lisp and C)
tnecniv 9y ago
> Julia is a great language, but it is still focused on the numerical computing world and is not "1.0" Word on the street is that Julia is supposed to get a 1.0 announcement at JuliaCon, which started today.
- KenoFischer 9y ago
  Unfortunately 1.0 is delayed for a couple of months. 0.6 was released yesterday though, which already includes many of the features that were originally scheduled for 1.0.
ScottPJones 9y ago
Handling technical/scientific/numeric programming well is rather a hard nut to crack, and that is where the developers of Julia wanted a better solution for their own "greedy" programming needs, but Jeff Bezanson has been clear that it is also for general purpose programming (which is what I use it for). Many Julians are working to improve Julia for places that hadn't yet gotten as much attention (such as database access). I think in a couple of years, the canard of it being a "niche" language will be laid to rest.

Fomite 9y ago

For non-CS scientific computing users, "a high performance language with easy syntax" is a big feature.

flavio81 9y ago
Exactly, that's why I think Julia is a good idea. For scientific users used to R or Python, the performance should knock their socks off. (But users doing their work in C, C++ or Fortran will probably see little or no improvement).
- bokertov 9y ago
  Do we really need Julia given that Python has Numpy which does a lot of the heavy lifting in numerical computation and is pretty fast?
  - Fomite 9y ago
    Numpy is great as long as you're using Numpy. There's lots of aspects of scientific computing that may not be using Numpy.
  - tavert 9y ago
    Numpy is good for vectorized calculations on dense multidimensional arrays of homogenous 64 or 32 bit floating point numbers, or integers. If that describes your problem and you like Python, by all means use numpy. If that doesn't describe your entire problem, you'll need more tools.
  - hpcjoe 9y ago
    It should be understood that numpy is written in C, and is an example of the "2 language problem" that Julia solves rather well. The question really is the converse ... given how deft Julia is with general programming as well as numerically intensive programming, do you really need Python + numpy(C).
  - tnecniv 9y ago
    On top of what others have mentioned, there is something to be said about getting numerical linear algebra tools as native citizens of a language. There are many things I hate about MATLAB, having matrices built into the syntax is nice.

giancarlostoro 9y ago

I have yet to fully jump into Julia but it is one language that has impressed me for a while, and I've seen a good number of them that impress me but Julia has a few things that to this day I think back to like code_native() and how it returns assembly code for whatever you throw at it, might seem trivial to others and y'know you can do it with C too but it's still cool you can just do it. Your description of it makes it very intriguing and makes me want to revisit it.

maimaiml 9y ago

> (If you need more power and flexibility than Julia with good processing speed, i think only Common Lisp will clearly provide it.) Common Lisp is terrible for numerical computing, and the type system is really quite weak IMO.

flavio81 9y ago
Maybe it is terrible for you... But good enough for doing numerical computing for the NASA and for Raytheon. The NASA used it for complete command of the Deep Space 1 spacecraft. "The Remote Agent" wasn't just entirely written in Common Lisp, it also won the NASA's Software of the Year Award... https://ti.arc.nasa.gov/tech/asr/planning-and-scheduling/remote-agent/ https://ti.arc.nasa.gov/tech/asr/planning-and-scheduling/rem... "It's one small step in the history of space flight. But it was one giant leap for computer-kind, with a state of the art artificial intelligence system being given primary command of a spacecraft. Known as Remote Agent, the software operated NASA's Deep Space 1 spacecraft and its futuristic ion engine " ... and i don't think they did it without heavy numerical computation. Want another application? Analyzing HDTV video images of the Discovery launch in real-time. Again, NASA. Another one? Mind you, i'm only citing examples where numerical computation is heavily involved... How about simulation of missile defense systems at Raytheon? http://www.lispworks.com/success-stories/raytheon-siglab.html http://www.lispworks.com/success-stories/raytheon-siglab.htm... "SigLab simulates an incoming warhead intercepted by the Exo-atmospheric Kill Vehicle (...) The system is capable of solving any computable system of difference equations. " Another one? "the new version of the complete Piano aircraft analysis tool, used by several major aircraft and engine manufacturers worldwide." http://piano.aero/ http://piano.aero/ As for the "type system being weak", the comment puzzles me, considering that Common Lisp has one of the best (if not the best) OOP system, CLOS. There is an automatic correspondence between objects and types in CLOS so I can argue it has one of the best type systems out there.
- thebooktocome 9y ago
  I don't dispute the effectiveness of Common Lisp, but > There is an automatic correspondence between objects and types is almost never what is meant by a "strong type system" -- it more commonly means that types are checked at compile time, rather than run time. I don't doubt that any given lisp hacker could slap together a type inference system on top of CLOS, but as far as I can tell it's not built in. So, on the strong-to-weak type system spectrum, I would say: * Idris (lawful good, first-class dependent types) * Haskell (very strong, some support for dependent types) * Java (strong, some generics) * Julia (hybrid, code is analyzed for type inference during JIT, invariant types) * Common Lisp (weak by default, afaict) * Python (very weak) * Javascript (weakest) * PHP5, Perl (chaotic evil)