Hacker News Reader

Comment by mirekrusin | Hacker News Reader

Honest question - why did authors feel like creating new langauge instead of contributing/expanding something that exists, ie. Crystal seems to be extremely close to what Julia offers, or am I wrong? Are there any fundamental decisions that put Julia above Crystal?

View on HN

Julia came before Crystal?

https://github.com/JuliaLang/julia/graphs/contributors

https://github.com/crystal-lang/crystal/graphs/contributors

Also, there's a lot of stuff that Julia has which Crystal doesn't (and vice versa since they focus on very different domains)

Ignoring the Crystal issue that others already answered, why didn't Julia developers instead create a kick-ass JIT for Python or R?

And the answer to that is that the semantics of the language were designed from the start for efficient JIT'ing. Thanks to the language design, Julia can get close to C performance with a comparatively simple JIT approach (resolve types, compile a function statically with LLVM just like C, then use multiple dispatch to select the right function at runtime (simplified, yes, but roughly like this)). Compare this with all the tracing JIT heroics that Javascript implementations or PyPy pull, while still getting performance far from what Julia achieves.

Actually, it will choose the right function to dispatch at compile time. In fact if it will in certain occasions even erase all function call and replace with the final output and even remove unaccessible branches from the generated code.

I'm not really seeing any similarities other than both languages having type inference (which is a pretty standard feature of newer languages and as mentioned, Julia was earlier). Julia is competing with Matlab/R/Numpy. That's not what Crystal is targeting at all. I suppose you could imagine that libraries could be written for Crystal, but except for Python's Numpy, these tend not to go anywhere in practice (Ruby itself has the now mostly dead Sciruby for example).

Crystal and Julia is not alike at all? Crystal is a static compiled OOP language. Julia is dynamic with multiple dispatch, and is not OOP.

The crystal guys should have but their effort into nim or something like it imo

Multiple dispatch is definitely OOP.

https://en.wikipedia.org/wiki/The_Art_of_the_Metaobject_Prot...

https://en.wikipedia.org/wiki/Dylan_(programming_language)

Why didn't the crystal guys put the effort into Julia instead?

Going off of wikipedia, it looks like Julia started in 2012, two years before Crystal.

Reply on news.ycombinator.com