What language is it written in...or is it fully bootstrapped?

Ya, apparently it's been around longer than I thought. They have a blog entry [1] announcing the bootstrapping in November of 2013.

[1] http://crystal-lang.org/2013/11/14/good-bye-ruby-thursday.ht...

So is it like RPython...Crystal programs running on Crystal convert other Crystals programs into C to build an interpreter that is then used to run yet other Crystal programs (the ones users write)?

I think it goes to LLVM IR rather than C. It does it's own type inference, so compiling to C after that would preclude many optimizations that it could take advantage of.

How similar to Ruby are they aiming for? Is it possible it will run Rails one day?

Looks very cool. Always loved Ruby, but went to other languages for reasons of speed and ... well, lack of the crufty parts.

But...the fact that it's been bootstrapped means that getting it up and running on Windows will be a bit more of a challenge than if it were written in something that can just be built on Windows (C? Go?). I did find this:

https://github.com/manastech/crystal/issues/26

...but the effort seems to have stalled.

Cross-compilation would fix the bootstrapping problem, and is also important for its own sake; for building code that runs on ARM, for instance (for Android, iOS, etc.).

Looks like neither Windows support or cross-compilation have any advocates on the core team, which is sad.

There's support for cross-compilation, it's even documented:

http://crystal-lang.org/docs/syntax_and_semantics/cross-comp...

But porting stuff to Windows is far from trivial: there's making LLVM work, there's exception handling, string handling (seems it's UTF-16 rather than UTF-8 in some places), etc. It's definitely on our long-term roadmap, it will just take a lot of time and effort.

And ARM is also on our roadmap, hopefully a short/mid term one.

The "beauty of Ruby" part is self evident, assuming you find Ruby beautify.

Is there any documentation to back up the "Faster than Go" statement? I compiled and tested the HTTP server example, and pounded on it with ab. I don't have enough time tonight do an in depth comparison, but it doesn't seem much faster than Go.

On the plus side: the binaries are nice and small, and the memory usage is low.

Search for benchmarks and https://www.youtube.com/watch?v=xbdVs4FhZac to see performance comparisons.

Thanks! I saw the benchmarks compare Crystal to Python, C, Ruby and C++, but I didn't see anything about Go. Which is fine, I guess, but it makes the title feel a bit link baity.

This is a duplicate of https://news.ycombinator.com/item?id=9669166.

Kind of crappy of you to remove it from the front page, I was really interested in the potential discussion on the language.

On local variables (http://crystal-lang.org/docs/syntax_and_semantics/local_vari...) the page says the internal type changes, when a value of a different type is assigned to a variable.

Doesn't this defeat a large advantage that static typing has over dynamic typing -- catching when something is set incorrectly?

I like Ruby, it works well for scripting, and this compiled variant of the language is very interesting. I liked its variant type (e.g. (Char|String|Int)) for instance, and in many other respects it looks great.

What puts me off somewhat is that it seems that Crystal uses the same stupid scoping rules as Ruby. I would not call them insane, but they are kinda funny (compared to normal lexical scoping like in ML or Scheme), and the new language could fix that. [The documentation does not have a section on scoping, so I'm not 100% sure about this issue]. Another strange element of the Ruby syntax that does not make a lot of sense to me is proc.call("blah"). Was that "call" bit really necessary in the new language? Probably, not really.

In any case, my complaints are quite minor, and probably the author considered all pros and contras when making these particular choices. Overall the work looks very interesting. I usually prefer OCaml for my programming, however it's not always a perfect tool and I was trying to find some other language that will work better. So far, nothing could work better, but Crystal is a step in the right direction, I think.

I never liked the Ruby syntax, so the beauty of Ruby is a bit subjective and the title is clearly pure clickbait, 'dissing' go, which is a lot more popular and well known - but when clicking on the link there is not a single mention of it.

That said, it looks like a really cool project, with many nice language features Go is clearly missing. Attacking Go on performance is a bit silly though, this is purely by the choice of being a frontend for LLVM, not by language design. The choice for LLVM is understandable, and at first I thought Go made a mistake here, LLVM is really nice - but it also clearly has it's downsides. On one hand I wish Go had access to the optimization power of LLVM, on the other hand I'm glad it has no dependency on it and is standalone. Thanks to this, cross compiling is a breeze, and adding support for new platforms is entirely controlled by the Go team and it's contributors, although I don't know how they're going to handle iOS support now that Apple switched to LLVM bytecode for application distribution which they then compile to native code on their servers before delivering to the device. Maybe Go can add an LLVM bytecode target, which would mean it could also benefit from it's optimisations.

But in most cases, once you've passed a certain treshold, performance is not that important anymore, and once you're running reasonably fast native code, that should not be a problem anymore. I'm already happy with the current trend of going back to native code instead of thinking that CPU's are fast enough to interpret everything and that memory is cheap.

I also quickly tested compiling a 'hello world' example with both Go and Crystal, and the binary sizes were quite similar:

- Go (1.4.2): 620K

- Crystal: 619K

- Crystal release: 528K

So Crystal is a little bit more compact at first glance, but at first glance not that spectacular. Go is notorious for generating quite big binaries. The thing is however, that Go always produces static binaries - it does everything with it's own stdlib, unless it involves DNS resolving. A quick LDD on the crystal binaries revealed it wasn't a static binary and depended on libc. So I tried compiling the same hello world staticly in crystal, which gave me some warnings and a whole different picture: a whopping 1.8M binary. So more compact? Not necessarily.

Library-wise however, Go is lightyears ahead of Crystal. Go's stdlib is amazing, and there are an surprising amount of 3rd party libraries written in native go. Crystal on the other hand has the advantage of being able to use existing C libraries with ease and little overhead, but this could also be a downside and impact clean library design and consistency in the long run. It not being 100% Ruby compatible and not able to blindly use any Ruby library is a handicap here.

All in all, I think both Go and Crystal could learn from each-other. Go is a bit more mature and has clearly been accepted in the server/sysops space, many new projects there being written in it (docker, consul, etcd, heka, kubernetes, prometheus, influxdb, the grafana backend, ...). For crystal to earn it's place somewhere, it will need a lot of work.