
The Crystal Programming Language - sndean
https://github.com/crystal-lang/crystal
======
sdogruyol
I've been using and contributing to Crystal since 2015 and i can easily say
that it's really great potential. It's simple, fast and productive from day 1.

I wrote a web framework ([http://kemalcr.com/](http://kemalcr.com/)) and it's
in production without any problem for more than 1 year on a big scale app. You
can check my slides for some interesting graphs
([http://www.slideshare.net/sdogruyol/kemal-
rubyconfbrasil-201...](http://www.slideshare.net/sdogruyol/kemal-
rubyconfbrasil-2016))

Also be sure to check out
[http://crystalshards.xyz/](http://crystalshards.xyz/) to discover Crystal
projects(shards).

~~~
RX14
What a surprise to see crystal at the top of HN again! I've been using and
contributing to crystal since 2015 too, and I've come to really love the
language and community. A big thank you to all the community for being so
welcoming!

What I've felt with crystal is that I find it an immensely practical language.
Maybe that stems from the compiler being written in crystal. The stdlib has so
many things in that make everyday work in the language a joy. For example
JSON/YAML/DB.mapping which help you map objects between JSON, YAML and the DB
(they're also really fast). Including a standard, performant http stack in the
stdlib is a breath of fresh air. The performance of evented io in general is
really nice. The concurrency story (channels + fibers) is simple, and doesn't
show itself when not required (looking at you nodejs). Most of all, the type
system gets out of your way and usually only shows itself when you're making a
mistake.

~~~
stcredzero
_What I 've felt with crystal is that I find it an immensely practical
language. Maybe that stems from the compiler being written in crystal._

The question is, how easy is it to make syntax-driven tools? One thing that
Ruby never did quite as well as Smalltalk was having low cost of entry for
creating language parsing tools on the language itself. (At one time, there
were multiple online study groups of multiple people trying to parse Ruby
working for over a year. With Smalltalk, you can start hand-coding a top-down
parser in the morning and be mostly done in the afternoon.)

 _Most of all, the type system gets out of your way and usually only shows
itself when you 're making a mistake._

Sounds ideal!

~~~
RX14
> The question is, how easy is it to make syntax-driven tools?

You can actually require the lexer and parser portions of the compiler in
crystal code, and get an AST from a file relatively easily. The crystal
compiler then has tools for easily walking the AST.

------
ChuckMcM
Go's PASCAL. :-)

Interesting language, looks especially interesting for rapidly throwing things
together. Add a solid API to a window system toolkit and you've got a logical
successor to Visual Basic.

Write an editor, cross compiler for some other language, and a shell in it.
That will tell you if it is a good "systems" language.

Write a distributed service, a web application, and a database in it. That
will tell you if it is a good "web" language.

Write a physics simulator, a responsive AI, and a real time user interaction
model in it. That will tell you if it is a good "game" language.

Write a convolution, a linear regression, and a monte carlo simulation in it.
That will tell you if it is a good "modeling" language.

In my Christmas wishlist is a language that I can write a good 3D CAD package
in. The current choice is C++ but that can be really clumsy in many ways. Such
a language would have a strong linear algebra library and a boolean solids
package. Nobody is working in that problem space from a language perspective
as far as I can tell.

~~~
cbcoutinho
Linear Algebra is already a solved problem - there's no need to rewrite the
many established C/C++/Fortran code that has been optimized for linear algebra
over the last 40 years.

Why re-write what has already been done? Stand on the shoulders of giants.

~~~
sanxiyn
> Why re-write what has already been done?

Because we can do better. For example, look at Mir GLAS, written in D.

[https://github.com/libmir/mir-glas](https://github.com/libmir/mir-glas)

~~~
cbcoutinho
At a first glance, it looks like the way they're optimizing the BLAS/LAPACK
implementations is by making it CPU architecture specific - the same game that
IMKL plays. That's probably why they are reaching the same performance as MKL
as well.

Good to see they aren't reinventing the wheel, and openly expressing
inspiration from Numpy is also a nice touch.

------
sergiotapia
Last year's discussion for those interested:
[https://news.ycombinator.com/item?id=10014178](https://news.ycombinator.com/item?id=10014178)

This language definitely deserves your attention. It's fast, it's easy on the
eyes, and it produces native code. A real workhorse language.

Want Go's speed but hate Go's if err nil verbosity? Check out Crystal.

~~~
AstralStorm
Does it even have built in concurrency?

~~~
RX14
Crystal has an excellent concurrency story built into the stdlib which is on
by default. All io is evented by default, with events being fed into the fiber
scheduler. The nice thing is that the concurrency and evented io is built just
using the stdlib in crystal itself, so it's readable and shows that crystal is
quite powerful.

You can read more here: [https://crystal-
lang.org/docs/guides/concurrency.html](https://crystal-
lang.org/docs/guides/concurrency.html)

~~~
AstralStorm
Lack of parallelism will cause similar problems to what python faces due to
global interpreter lock, killing performance. It is 2017 (almost), parallelism
should be available in any new programming language.

~~~
RX14
Parallelism isn't easy, so the core team is expending time to get it done
correctly and released before 1.0. Crystal doesn't have anything like the GIL,
and the compiler already enforces some simple rules, like type flow not being
available on instance variables because they could be changed on another
thread. You can't expect the world from any new project straight away.

------
tbrock
I just played around with it. Wow!

Last time this came up on HN I shrugged it off but after playing around with
it a bit as a former Ruby programmer I'm in love.

Super simple to compile a little binary and it's blazing fast when I run it. I
think I'll be donating some money.

Bonus: Running `crystal init app <appname>` dumps out an opinionated starter
project layout for you complete with travis.yml, test specs, and README. Maybe
it's the old Rubyist in me that digs a little convention but this is certainly
a refreshing departure from JavaScript madness.

~~~
yxhuvud
You also have 'crystal tool format' for some more opinionating.

~~~
tbrock
Love it! Go flavored ruby.

------
bootload
_" The compiler is written in Crystal."_

If there is any stress test worth noticing it's this. 98.2% of the code is
written in Crystal.

------
qume
I write aviation software (i.e. running real time in aircraft) - not safety
related in any way - and I use Ruby.

I use it because iterating quickly and being super productive means I can do
more myself and keep the team small. And it's worked brilliantly.

So throw this into the mix and my world just got a whole lot better. It's like
these folk designed this for my project.

Good luck guys!

~~~
kornish
Sounds really interesting! Have you written anywhere about how you got
involved in that? I'd be curious to know how one sells into the airline
industry.

When you say "not safety related in any way", do you mean that your code runs
on auxiliary systems, like the entertainment platform?

~~~
qume
It's software to tell the pilot where to go (who in turn uses the autopilot
quite often), and software to point the camera in the right direction and
trigger cameras (pointing at the ground).

All up it's 9 processes talking to each other over zeroMQ.

Most are ruby, the camera and IMU are C++. Due to using a simple messaging
system I can throw other languages in. Only one part uses any significant CPU
and maybe Crystal can help with that. Should be easy to port over.

~~~
ritonlajoie
do you have a website ?

~~~
qume
[http://ground.vu/](http://ground.vu/)

------
elihu
Huh, this is in interesting feature: [https://crystal-
lang.org/docs/syntax_and_semantics/union_typ...](https://crystal-
lang.org/docs/syntax_and_semantics/union_types.html)

If you have code paths that set a particular variable to different types, it
promotes the type of the variable to a union. I'm not convinced that's a good
idea, but then I don't usually use dynamically typed languages; perhaps this
is the most natural way to do static typing for people who come from languages
like Ruby.

~~~
yxhuvud
In practice, it accomplishes two things. It is the tool used to catch null
pointer exceptions at the compile stage and it is what allows you to write
duck typed interfaces.

~~~
iheartmemcache
RE: NPE's - I have a feeling that'll be abused just like void * and
interface{}. People will just start throwing Nil around everywhere as a catch-
all. You need a stronger construct like Option<T>, Maybe, language-level
nullable types, or a mechanism for the caller to handle it dynamically (a la
unwind-protect/conditions).

The problem you end up getting is basically the dual of the 'expression
problem'. You get easy type expandability with class augmentation by these
semantics, but any client of the type is subsequently bound to deal with any
augmentation of the type. (I.e., if in the method defining class 'a', you
insert an elseif in between the consequent and the alternative of type Bool,
you now just extended the class signature of 'a' to Int32 | String | Bool.
Assuming all consumers of 'a' need exhaustive handling, you've opened your
class and extended its functionality at the expense of code which had
previously satisfied the dependencies to consume 'a' safely.

Crystal still remains a real interesting project to follow. I haven't examined
the Crystal type system too carefully, but the concept of Parent+ as virtual
types is an interesting concept that is certainly worth exploring.

~~~
RX14
Because crystal's nil type can have methods on, it already feels like an
Option<T> with `#try`. We've had a lot of discussion about nil handling, but
haven't come up with a better solution yet. Simple patterns like `return/raise
unless foo` can protect the rest of a method body from nil without adding
indentation.

------
new299
Seems like there's a new language popping up every few weeks. This seems
strange when the trend in human languages seems to be towards a single common
tongue, or at least a common lingua franca.

The same seems true of mathematics. At least in the parts that get commonly
taught, we trend toward a common representation.

In programming, it seemed like we might move toward a core "C-like" syntax
with various derivatives, for a while.

But now we seem to be moving toward a world where everyone wants to create
their own domain-specific language.

I can't help but long for a common tongue. One which allows developers in
different domains to understand at least the functionality, if not the
motivation without having to learn a new language.

~~~
thegenius2000
I couldn't disagree more strongly. DSLs are at the heart of efficient
programming because they encourage separation of concerns; that's why the Unix
shell is so powerful, fundamentally it's a collection of different programming
languages with well-defined interfaces for communication.

Secondly, personally speaking I've never had much difficulty understanding
programming languages I'm unfamiliar with provided their syntax is
sufficiently similar to those I use. For example, I've never much worked in
Ruby but glancing at Crystal there's nothing really confusing about its
syntax. Yes, we see new languages popping up here almost weekly, but we don't
see new paradigms: usually most of the stuff here is procedural and on
occasion it's functional. Furthermore, having seen the remarkable benefits the
introduction of different paradigms has had for the community at large (think
about a world without LISP for a moment) I for one believe we should encourage
the development of new and strange ideas; most of them will fail, but every so
often we might get a new world.

~~~
LordWinstanley
>>I've never had much difficulty understanding programming languages I'm
unfamiliar with provided their syntax is sufficiently similar to those I
use...

Oddly enough, I've just been thinking the opposite. I've been looking for a
compiled language to learn, to add to my basic tinkering knowledge of Python.

From my shortlist of Crystal, Go and Nim, I opted to look at Nim first, as it
has the most Python like syntax. I've actually found that to be a hindrance.
Nim's close enough to Python that it fooled me into thinking it would be a
doddle to learn, but just different enough that I constantly run into
compilation errors from assuming [yes, I know!] that basic language constructs
will be written the same in Nim as they are in Python and then falling foul of
some subtle difference.

I'm actually considering moving my sights to Crystal or Go now, in the belief
that they'll be different enough from Python for my brain to jolt out of
'muscle memory' mode and pay more attention to taking in the 'new stuff'.

~~~
staticassertion
Just learn C or C++. There are way more materials for learning them, and it's
certainly different from python. You'll learn things that you would never
learn while writing Python, which is the goal.

If you know C++ and Python, you can pick up most mainstream languages. If you
learn a more functional language afterwards, you'll basically be able to pick
up anything.

------
qume
Try searching the web to see if/how it works with Gems. Go on, I dare you...
'ruby crystal gem', 'crystal gem', ...

For that matter, crystal vs elixr.

Kind of wishing all these projects just had made up names.

~~~
yxhuvud
Crystal use something they call shards. They are extremely basic though and
are really waiting for someone to write a more full-featured package manager.

~~~
adjkant
It looks like the point still stands.

First google result:
[http://terraria.gamepedia.com/Crystal_Shard](http://terraria.gamepedia.com/Crystal_Shard)

~~~
dqv
Just add "programming" to the end of the search and it won't give you any
gemstones or cartoons.

------
stevemk14ebr
I wonder how Ruby will compete with this. Crystal basically seems like Ruby
3.0 to me (major improvement is speed, btw Ruby is currently on 2.*).

~~~
eropple
Pretty easily. Crystal looks like Ruby, but it doesn't feel like Ruby or work
like Ruby. It seems fine, in a very Golang "it works for projects where you
need to fling a blob of binary somewhere" sort of way, but it's not remotely
as dynamic-as-a-language as Ruby (and that dynamism is precisely _why_ I use
Ruby), nor is it dynamic-as-a-platform--something like CLR assembly loading or
Java classloading to get a statically-typed, reflective representation that
gives me something similar. And you might not need that, and it's totally
cool. But Ruby enables a lot of things Crystal, as designed, seems unable to.

It's not bad. It's fine. Not the pejorative, dismissive sort of "fine", but
fine. But it's not Ruby. Ruby is slow in large part because Ruby does _hard
things_. Some of them aren't really advisable, from a perf perspective--but
they are from a human perspective, and Ruby preferring humans over computers
is a huge feature for me.

~~~
rubyfan
You sum up my finding on Crystal really nicely.

I wish I could upvote your comment more than once.

Crystal is nice but I've found simple dynamic things to be a challenge. I
haven't looked in a few months but I wasn't able to do this

 _a = []

a << 1

a << "two"_

Same with hashes. This broke some things for me and ended up feeling like I
wanted to program in Ruby but there were all these gotchas.

If I have to break the mental expectations I have for writing something to get
the performance needed, then I'm fine to switch gears and write Java or C in
order to get it.

~~~
RX14
You seem to make the assumption that crystal's purpose is to be for ruby
developers, and as soon as it deviates from ruby, you've switched gears and
might as well use Java or C.

I don't think that's the case. Crystal takes its syntax from ruby because it's
easy to write, easy to read, and familiar, it doesn't have to be the same as
ruby in semantics. In fact that's impossible because it's statically typed
(which I personally prefer to ruby).

If you're going to resort to Java or c for speed, why not use crystal? Crystal
beats Java and c on expressivity of type system, expressivity of code (less
boilerplate) and performance per unit effort (at least on common tasks). So
the question is why Java or c? They both certainly have larger and more mature
ecosystems, and if you have compute-heavy workloads they'll probably win out
on performance, but why do you instantly make the leap from crystal != ruby to
"might as well use java/c"?

~~~
RX14
Actually, I'll expand on that and say that crystal isn't "static typing for
rubyists", its more like "the best bits of ruby applied to static typing".
There's a big difference in that the bits of ruby that crystal chooses to take
may not be the parts that are most familiar to rubyists. That it is so similar
to ruby is a huge complement to ruby in that there was so much that the team
wanted to take.

The hardest part of learning crystal for rubyists is unlearning their ruby
habits when working on crystal. Once you're over that hill you might find
crystal a wonderful language in its own right.

~~~
rubyfan
I agree and that's my original point, in order to use Crystal I need to
unlearn things. I guess I'm lazy enough that the performance benefit isn't a
big enough benefit for me to trade off the flexibility of Ruby.

Nothing against Crystal, I think it's great but it would almost have been
better coming to Crystal from something other than Ruby.

------
oelmekki
An interesting thing: [https://github.com/crystal-
lang/crystal/blob/master/src/conc...](https://github.com/crystal-
lang/crystal/blob/master/src/concurrent.cr#L31-L57)

Looks like they took the Fiber concept of ruby and made it into something like
goroutines, with channels handling.

~~~
sdogruyol
You can take a look at Crystal for Rubyists
([http://www.crystalforrubyists.com/book/chapter-08.html](http://www.crystalforrubyists.com/book/chapter-08.html))
for more info on Channels and Fibers.

~~~
oelmekki
Actually, I'm now a golang developer, so there are no big surprise, here ;)

------
wcarron
I'm by no means a very experienced programmer, but what was the motivation
behind choosing `nil` over `null`? Seems like, from my inexperienced
perspective, it was just designed to add unneeded idiosyncratic
syntax/semantics to distinguish it from Ruby and/or C.

Can't comment on anything more than that right now. Have yet to dive very deep
into it.

~~~
atombender
There are probably as many languages using "nil" as there are ones that call
it "null".

Nil: Ruby, Go, Oberon, Modula-2, Swift, various Pascal dialects, Lisp?.

Null: C/C++, Java, Rust, JavaScript, Ada.

Then, of course, there's Python with None.

~~~
kibwen
Rust deliberately doesn't have anything in the language called "null" (there's
`std::ptr::null()`, but that's for C interop). The only thing that fits the
bill here is the unit type/empty tuple, `()`, which is sometimes called "nil".

~~~
lobster_johnson
I know, but it's "std::ptr::null", not "std::ptr::nil", which was the point of
this discussion. (Clearly it has a concept of null pointers, even if they're
used in a more limited manner than other languages.)

~~~
kibwen
But you can't use `std::ptr::null()` in the same way that you use null in the
other languages mentioned there. It's literally just there for C interop, and
it's called that because that's the terminology that C uses.

For finding an analogue for the typical null use case in Rust, one would use
the `None` variant of the `Option` enum.

~~~
yberreby
Nitpick: `std::ptr::null()` is not _just_ there for C interop. It's also
useful when writing pure Rust unsafe code.

~~~
Gankro
Can confirm, used null all the time in Rust. The raw pointers are important
native Rust constructs, although they do skew to supporting C idioms as much
as possible (e.g. `* const T` and `* mut T` is basically a worthless
distinction within Rust itself).

------
Doctor_Fegg
Wow. Genuinely fast: benchmarks usually somewhere between C++ and Java, orders
of magnitude better than Ruby.
[https://github.com/kostya/benchmarks/blob/master/README.md](https://github.com/kostya/benchmarks/blob/master/README.md)

~~~
AstralStorm
Try something that is more its weight, like Rust.

------
agentgt
I thought about using Crystal for some roguelike game I wanted to program (but
alas with a new baby do not have the time for anymore).

The reason being that it is OOP. I eschew OOP (particularly for biz software
which is my day job) but have to admit OOP still is a pretty good fit for UI
and video game programming. I tried some reactive FP game programming and I
just didn't make as much progress as I would have liked.

I tried googling for some roguelike crystal programmed games and didn't find
any yet (it is difficult because crystal has lots of conflicts particularly
with rpg like games)....

------
desireco42
I am really invested heavily in ruby, I've been using it for years, like 10+.
I should be natural target group for this, yet, while I appreciate all the
features, I really feel that something like Elixir is better suited for
future.

Also, even though I spent years writing ruby, I don't have problem switching
to other languages.

~~~
unusximmortalis
Can you give details why you "feel" that way about Elixir?

~~~
tbrooks
I feel the same way about Elixir here's why:

\- docs

\- testing

\- Slack chan, IRC, mailing list

\- package manager (Hex)

\- build tool (Mix)

\- web framework (plug & Phoenix)

\- db framework (ecto)

\- books from major publishers (manning, pragprog, etc.)

\- ElixirConf

\- ancillary teaching (ElixirSips, LearnElixir, Elixir Fountain, etc.)

\- helpful blogposts and stack overflow answers

All these things sum up to lower barriers of entry when trying a new language.
Elixir has it in spades. It's really easy to pick up and learn the syntax and
predicates of the language (BEAM, OTP, etc.)

Even though Crystal is closer to Ruby in syntax and Ruby __can be __valid
Crystal -- Elixir still feels easier, because there is less work to be done
with learning everything else.

~~~
desireco42
Without taking anything from Crystal, because there is nothing wrong with
Crystal...

Elixir has so many superstars working on/with it.

------
Turing_Machine
I'm sorry if I'm missing this, but what's the distribution story? Does it
produce stand-alone binaries? In other words, can you just distribute the
generated binary without requiring the user to install a runtime package or a
bunch of libraries or whatever?

~~~
yxhuvud
It produces standalone binaries. I'm not certain the cross compilation story
is in place yet though.

~~~
RX14
To expand on that, it produces dynamically linked binaries so you do need
libevent, libpcre, libgc etc. when you want to run crystal binaries. We hope
to get the number of runtime dependencies down in the future.

~~~
faaq
But, Also you can try static linking :-)

\--link-flags="static"

The output binary is bigger than dynamic linked and it would needs some dev
libraries before compile.

~~~
Turing_Machine
Sure, it's going to be bigger. Not a problem, as long as it works. :-)

Requiring the user to install a separate bunch of dependencies adds a huge
amount of distribution friction vis-a-vis just shipping a stand-alone
application bundle, especially in this day of app stores. Being able to avoid
that is very important, IMO.

Probably anyone reading this isn't going to be daunted by having to install
some extra stuff, but for the average user it's a real pain.

------
sdegutis
Sounds like it has most of the same goals as Swift. I wonder how they compare?

~~~
devmunchies
They are both LLVM languages. But I remember reading that Swift was just
barely slower because of the reference pointing or something. Obviously I'm
not a reliable source for performance metrics.

------
reednj
I find ruby plenty fast enough for sites in the 1k/min requests range, but I
have serious problems getting it to run fast enough with websockets. Even 40
concurrent websockets connections through ruby is enough to bring down my
hosts.

Does anyone have any experience using this with websockets? How does it
perform?

~~~
RX14
Crystal has websockets built into the standard library, and as with almost
everything built in crystal it uses evented io. Here's a benchmark:
[http://serdardogruyol.com/benchmarking-and-scaling-
websocket...](http://serdardogruyol.com/benchmarking-and-scaling-websockets-
handling-60000-concurrent-connections-with-kemal)

------
z3t4
It looks very nice, I like that you can have beautiful syntax and performance
at the same time.

But it lacks a modular interface for modules and libraries that does not
import hidden/global variables. They should look at NodeJS for inspiration.

~~~
RX14
Ruby is quite a large language with a large ecosystem of libraries, but I have
never seen or heard of major issues with module name clashes. Libraries tend
to have quite unique names and stick to their modules. Crystal works pretty
much the same, so I personally don't think a change is needed.

------
stOneskull
Looks good.

I don't like all the 'end' statements though.

~~~
asterite
Here are the reasons for 'end': [https://github.com/crystal-
lang/crystal/wiki/FAQ#why-isnt-th...](https://github.com/crystal-
lang/crystal/wiki/FAQ#why-isnt-the-language-indentation-based)

~~~
stOneskull
"there's no point in trying to suggest changing the language to an
indentation-based one"

Ok. Bit of a bummer though.

------
rad_gruchalski
Very nice. Something to keep an eye on.

------
stewbrew
Can I create a shared library with it? Can it be used to write a ruby
extension?

~~~
RX14
The answer is technically yes but you probably don't want to. Crystal comes
with a managed runtime and gc, which are particularly unsuited for use in a
shared library. However you can export c functions (it's a hidden feature) and
they do work.

Creating a ruby extension in crystal also works and there are a number of
libraries which attempt to allow you to do this (too many in fact). They do
the hard work of getting crystal to play nice with the ruby extension api for
you.

------
faaq
What are the issues or features that crystal needs to solve before 1.0?

~~~
vjdhama
One would be parallelism. Not sure if the maintainers want to target that
though before 1.0 .

~~~
asterite
We do, and we will. We are working on it :-)

------
thewhitetulip
How does this compare with Go? tech and non tech things?

~~~
faaq
The first item is the syntax, Go use braces while Crystal is Ruby based
syntax.

Go has full parallelism support. Crystal is WIP.

Go has Windows support. Crystal is WIP.

Crystal and Go performance are very similar.

Go is backed by Google and his community since 2009.

Crystal is backed by Manas.tech and his community since 2012.

Go has full featured IDEs like
[https://www.jetbrains.com/go/](https://www.jetbrains.com/go/)

I hope to have Crystal IDE support after 1.0 :-)

~~~
thewhitetulip
So I'm happy with Go as long as Crystal gets more features

------
cosarara97
Thoughts on the conservative garbage collector? How often is it a problem?

~~~
RX14
Crystal uses libgc, from the readme: [0]

"Since the collector does not require pointers to be tagged, it does not
attempt to ensure that all inaccessible storage is reclaimed. However, in our
experience, it is typically more successful at reclaiming unused memory than
most C programs using explicit deallocation. Unlike manually introduced leaks,
the amount of unreclaimed memory typically stays bounded."

Having used the language for a year, I've never really had an issue with the
gc other than with really large (think 100mb+),infrequrnt, single allocations
which get "stuck" and don't get returned to the OS after. This is a by product
of the gc being unable to move objects to compact the heap. This situation can
usually be rectified by loading a large file as a stream instead of loading it
all into memory. Crystal has excellent tools for working with streams (see IO
module) however, so it's not that big of a deal.

------
iamgopal
Why language differ syntactically? I understand different platform, runtime,
optimisation needs etc. But why syntax ? C is sufficient for most logical
implementations, at most we will need hierarchy of implementations but why
parallel indecipherable syntax?

~~~
chrisseaton
> C is sufficient for most logical implementations

How do you know this to be true? You don't - it's just an opinion. And that's
why we have different syntaxes - because they're driven by different opinions.
If you could prove that one syntax was more effective than all the others -
for every purpose that people needed - then you could ask why everyone wasn't
doing it that one way.

------
wildchild
Ruby?

~~~
RX14
No, actually Crystal.

------
imaginenore
Floats defaulting to Float64 instead of Float32 seems wasteful.

~~~
faaq
Untyped number literals is the second issue with more number of +1 reactions.

[https://github.com/crystal-
lang/crystal/issues/2995](https://github.com/crystal-lang/crystal/issues/2995)

------
AstralStorm
Not strong enough of a package. Add some features to sell it. Safety, design
features, testing support, concurrency and more...

~~~
hamandcheese
You must not have taken a very close look because the concurrency story is
already great (and will one day turn in to a great parallel story), the built
in testing library has a very useful set of assertions and an RSpec like BDD
syntax, and safety far exceeds Ruby -- the compiler knows the type of all
variables and won't ever let you make an "undefined method foo for Nil class"
type of error.

~~~
AstralStorm
It is a library, not a part of the language. I can have a great testing
library in any language. By language I mean actual language, keywords,
syntactic constructs. Formal logic descriptions even.

I haven't looked closely enough, the concurrency looks decent but it's not as
integrated as in certain other modern langs (e.g. Go, Erlang or certain other
FP languages, even certain ones riding on JS)

It is sad to see something this outdated starting up now...

