This is not a new year’s resolution
crystal-lang.org
crystal-lang.org
I'd be curious to see actual usage numbers as they've changed over time.
Suuuuper fast! (Not that it matters but likely faster than Go[0]).
Single binary builds/deployments (Just like Go).
[0] http://blog.seraum.com/crystal-lang-vs-nodejs-vs-golang-vs-h...
I might be one of the few people who would prefer Crystal remain single threaded and that effort go elsewhere in the language.
I suspect that it's a mix of both, these hours numbers are somewhat pulled out of a hat but the concrete of what we actually want to do and how to go about it is known so they won't be wildly off. The manas guys will know the details though.
That being said, Windows support is likely to be largely done by the community and core team in tandem, as individual modules can be ported one-by-one. There's also the overhead of managing all these open-source contributions which takes time.
Could modern programming languages adopt isolated heaps with message passing like Erlang does? This is the easiest solution to GC pauses and allows other nice features like hot code reloading.
The majority of programming languages invented in the last 10 years don't seem that different from each other. I'd love to see a programming language that combines the strength of C++ and Erlang for soft realtime workloads.
Im going to do some C++
Im going to do some Java
Im going to do some Pony
From _The Beam Book_:
> There are two types of integers in ERTS, small integers and bignums. Small integers fits in one machine word minus four tag bits, i.e. in 28 or 60 bits for 32 and 64 bits system respectively. Bignums on the other hand can be as large as needed (only limited by the heap space) and are stored on the heap, as boxed objects.
Outside of that, I have found Elixir/Erlang to be very resource efficient. And if you need blazing fast math, you can always implement such computations in C and expose it in your Elixir/Erlang application using NIFs. There are a few golden rules to pay attention to in order to avoid danger, but if you do, you can get great speed. I'm currently implementing a Protocol Buffer library in Elixir and expect to make use of this for increased performance once my library is feature complete(if I find performance to be an issue at scale).
I've done some experimentation with hot reloading in c lately, and I'm not sure how isolated heaps is a precondition for code reloading.
I suspect the requirement for erlang style code reloading is a willingness to take an indirection penalty for fully qualified module calls and tail call optimization so that the old module doesn't stay in process stacks. In an OOP language, if you wanted to tie objects to specific versions of modules, you'd have to do some intrusive accounting as well.
I also attempted hot code reloading in perl many years ago; it's a lot easier to do when you've seen it done properly, and there are language facilities for it (fdlopen is a lot nicer to use than exec on a pm). In my use cases (which were single threaded), I was able to write an outside loop that's simple enough that it's not a big deal that it can't be reloaded.
I believe you were thinking about so-called "hipster languages".
If the entire Elixir project and team disappeared tomorrow, I could still write the same software and deploy it to the same (decades-old) BEAM VM.
Crystal is real software that you can use today and build yourself and modify. It's doesn't make sense to accuse it of being vapourware.
> "In the computer industry, vaporware (Brit. vapourware) is a product, typically computer hardware or software, that is announced to the general public but is never actually manufactured nor officially cancelled."
https://en.wikipedia.org/wiki/Vaporware
Ha! It's even made it into Merriam-Webster's!
https://www.merriam-webster.com/dictionary/vaporware
> "a computer-related product that has been widely advertised but has not and may never become available"