An Introduction to Crystal | Hacker News Reader

An Introduction to Crystal

blog.oisinaylward.me

> Crystal’s build times are reasonable. Compiling my project Azula takes ~16s with the release flag. Compiling our barebones project above takes ~8s.

8s to compile a hello world is "reasonable"? Am I missing something?

this is with the release flag! normal compiling is a good bit quicker - sorry, should've mentioned that!

> Am I missing something?

One of its main competitors hasn't exactly been up to Turbo Pascal levels with their own compiliation performance.

Not to mention memory intensiveness. Compiling a medium sized project (https://github.com/iv-org/invidious) on a DigitalOcean $5/mo droplet will throw an out-of-memory error unless I give it a few gigs of swap space

It's not the Hello World that takes 8s to compile, it's the author's project Azula (https://github.com/azula-lang/azula)

It's not an actual hello world. "puts "hello world"" compiles in 0.7s in debug mode. In release mode it takes 7s with cold cache and 0.6s with warm for me.

The biggest selling point of Crystal is being a very high level language, but at the same time very performant. Think of a Ruby variant with Go speed.

I would like to have something similar for Python.

nim-lang

I’ve heard the compiler is very slow. Is it? Go has a crazy fast compiler.

GP meant Go run-time speed, not its compiler’s.

This is true, Crystal does compile pretty slowly, but this is the cost of its great static type system. The balance between Crystals expressiveness and performance is truly wonderful and a joy to program with

Have you taken a look at Nim? https://nim-lang.org

Not yet, but I have it on my watchlist. I wait for wider (rust-like) adoption of Nim, because most of my programming tasks are heavily dependent on the ecosystem and requires a fair amount of libraries.

Do you have any specific libraries that you are missing? The packages list [1] has almost 1600 packages.

Also, the FFI in Nim is basically just declaring some C function as a `proc`. So, wrapping existing C libraries is as easy as Cython for Python. You can even jump start things by running `c2nim` on a header file.

[1] https://github.com/nim-lang/packages

We use the Neo4j graph database quite extensively, so a Neo4j driver / client SDK would be nice. And for intra service messaging we need a google cloud pubsub client library.

Not sure how well it works (and I have no setup to test), but there is this [1]. It's pretty old and Nim has evolved quite a bit in the last 4 years. It probably doesn't compile, but it might not be hard to spruce it up (not that this would be a great "intro project"). { EDIT: Open source is often pretty thankless. It might be that if you asked nicely of that repo owner that he would do the sprucing! :-) }

I know there are a few different protobuf impls floating around. Not sure how much google pubsub needs beyond that. It's probably not so far away. Maybe you can be the one to do the pubsub wrapper. :-) (I'm only trying to encourage, not enlist/conscript.)

[1] https://github.com/cmacmackin/nim-neo4j

I appreciate your effort, I also have a hacker spirit / hands on mentality for my own hobby projects. But in this case I simply cannot "sell" it to my team. We really need something already production ready with community support behind it.

Ok. Well, then...maybe your next hobby project should be in Nim. :-)

Yup, I'll consider that.

Oh, and, FWIW, most of the time Nim code runs much faster than Go. More like C/C++/Rust speed.

Yeah crystal is an awesome language

> I would like to have something similar for Python.

For anything 'scientific' there is Julia (with PyCall and RCall).

Julia is not just for scientific computing, though a lot of it's ecosystem is built up for that. It's a general purpose language.

That said, it's a completely different language from Python, so the comparison to Ruby/Crystal is not very apt.

> I would like to have something similar for Python.

Depending on the application, F# is a fantastic alternative to Python if you want some succinct code (with advanced types too) and fast runtime performance.

I'm really quite enchanted with Crystal. There are some amazing projects written in it including

an alternate youtube frontend https://github.com/iv-org/invidious

and an OS written in Crystal https://github.com/ffwff/lilith

I've played with Crystal a number of times and love it. It ticks a lot of the boxes for what I want in a language.

However, there seemed to be some confusion about whether the language could continue with inferred types or whether you'd need to annotate yourself - and what that would mean for compile speeds. I'm hoping those concerns can be resolved

Having written a Ruby (not Rails) app that would benefit from Crystal's speed and typechecking (and made a start on a conversion) I worry that the language won't find a niche that ensures its long term survival. Is there any area where Crystal is likely to provide a compelling solution when compared to other languages?

The absolute killer would be having a (ideally automatic) way to port existing Ruby applications to Crystal, and thus also tap into the existing ecosystem around Ruby. Though in order for that to really take off, they'd need to be able to port Rails too, which is probably quite tricky (considering how much metaprogramming Rails does for its "magic").

Absolutely and given the resources that firms spend on servers running Rails (GitHub, Shopify etc) I could see the effort being put into it - if it's possible. I suspect the metaprogramming issue is really tricky though.

I think for this to have a realistic chance, you have to have some effort on the rails side to reduce the meta-programming. I doubt that’s going to happen.

It is certainly possible to port Ruby applications to Crystal without a total rewrite, but the addition of static types in and of itself means you may be surprised at how much fiddling is required to get the compiler to approve your code.

Having done some of this agree 100% with the "surprised at how much fiddling is required".

I think in practice that Crystal will have to carve out its own niche distinct from Ruby - and I'm not sure whether the Ruby like syntax is much of an advantage against competing languages.

It doesn't have to beat other languages, it just has to enable new domains for people who only like ruby like languages to be successful.

It’s niche is being a high level typed language with extremely nice syntax, while having speed that competes with Rust/Go and others. The best thing that can happen is for it to get its own life away from Ruby.

Just to clarify I meant niche as in use / market. I agree on the characteristics - where does it 'win' though vs Go / Rust which are already well established. I don't see any movement from those communities to even try Crystal.

Well, it wins for those of us who dislike Go/Rust syntax. Crystal is much easier to read/write than Go/Rust (Yes, I know that the majority of programmers like it the other way).

I hope you're right as I much prefer ruby syntax too!

I just think that maybe rubyists overstate the attractions of the 'programmer friendly' nature of ruby a bit as outside of rails it's lost out vs Python for example. And Rails is popular because of the web app DSL that it provides (and so relies on Ruby Metaprogramming which crystal doesn't have).

I use Ruby for work all the time and Crystal for hobby projects and I still haven’t used Rails or Ruby’s meta programming, but I have used Crystals macros.

Crystal is a really nice language to me. If it had some large ecosystem behind it and wasn't boring I'd be able to use it to replace my other preferred boring languages of Java (strong engineering focus and long standing systems) and Ruby (beautiful to write and super productive).

Crystal is a static type language but has really good type inference. You can go pretty far without writing a single line abouttype.

I made https://pix.fastloop.xyz entirely in Crystal: https://github.com/yeo/pix/tree/master/src

Reply on news.ycombinator.com