I was on the Julia train full-force until I started using it more heavily. My sense is that the benchmarks are a little misleading.
These benchmarks give a little flavor of what I'm talking about: https://github.com/kostya/benchmarks
If you look at them, you'll see that Julia is indeed crazy fast in some cases. But in other cases, the performance is kind of middling. The native threads implementation of matmul is obscenely fast, but the "pure Julia" implementation is pretty slow--faster than R or Python for sure, but not in the same ballpark as C.
You could argue "well, why would you not use the native threads implementation in that case?" However, for someone implementing a routine in Julia, the implementation would be the pure one. That's the point.
With something like Rust, or Crystal, or Nim, what is promised is basically what you get: something in the ballpark of C. But with Julia, I feel like it's kind of unpredictable.
The problem is that the slow parts end up being a bottleneck that slows down the rest of the code, and that slow code is slow enough that it's not worth it relative to C or Python/R. That is, if you're writing heavy numerics, when you get to 20x slower than C, you might as well write it in C (or Rust or Crystal or Nim), and wrap Python or R around it, because that 20x is enough to kill it. At that point you might as well go with the established language even though it's 100x slower as an interface, and use something fast for the heavy lifting.
Crystal I can't say much about. It seems great, but the "everything is an object" makes me nervous--I tend to get anxious about inheritance because it drives me nuts. Nim seems more attractive to me. But who knows--it's also not like you can't have more than one language out there.
As for OOP, I feel like that's more a matter of preference. I don't buy the functional is better (generally speaking not specific situations where it might be). But I could be wrong, I just don't see evidence, only anecdotal claims by fans of functional programming (which doesn't mean they're wrong only that I'm not convinced). To be fair, they have arguments against OOP in favor of functional, but I'm not personally sold. Or maybe I just like Ruby and it's approach to OOP.
I wouldn't say I'm a functional purist (at least so far), but inheritance in particular has caused me some headaches in the past. I like Rust's approach to all of that, but it's much lower level.
Honestly, if Crystal ended up taking over the programming world, I wouldn't mind. Its a very nice language with a lot of advantages over what people are using now.
I never understood the phrase compiled language.
Crystal sacrifices some of Ruby's metaprogramming capabilities for performance and static type assurances.
[08/2011] Release of version 1.9 of the Compcert C compiler. Novelties include a reference C interpreter and stronger semantic preservation results.
Question for anyone handing out unofficial legal opinions:
This one is dual-licensed. There are a small kerfuffle of custom licenses that say "no commercial use", but everything is also variously covered by the GPL (v2 or later), LGPL v3, and BSD 3-clause.
Ref: https://github.com/AbsInt/CompCert/blob/master/LICENSE
I'm curious if I could use this in a commercial setting if I perfectly comply with the various GPL and BSD licenses.
If I could, that could be a problem for this group, because the repo readme (at https://github.com/AbsInt/CompCert) explicitly states "this is not free software."
C script supported : just add '#!/usr/local/bin/tcc -run' at the first line of your C source, and execute it directly from the command line.
FWIW, I think tcc compiles into RAM, then jmp-s to the result. Pretty much just eliminates the creation of an output file.
The core matrix-y stuff can pretty much all be ported to Python with similar or better perfomance, especially using Numba.
Python is fine, but I do like having matrices as first-party language members -- that's just a nitpick though. I'm starting a new project soon that I intend to do in Julia because it seems to have everything I like from Python and MATLAB combined.
And then there is Ruby 3.0, which will have concurrency and (optional) static types according to Matz. But that's slated for 2020.
Julia because it offers a nice, performant alternative to Python & R in data science, while avoiding Java & C++. It has some really nice features like multiple dispatch and the ability to run R, Python, Fortran and C code inside of it, so you can use libraries like Numpy in Julia.