

Elixir, a functional metaprogramming-aware language built on the Erlang VM - jacquesm
http://elixir-lang.org/

======
rubyrescue
i've started using Elixir for all my side projects. It's very satisfying to
use and as it sits on Erlang/OTP, you get all the power of Erlang, all the
libraries, etc. It still means it's not great for math; it's too slow just
like Erlang. But it has all the concurrency and stability of Erlang/OTP in a
new, sexy, non-prolog language.

Further, Jose Valim (the language creator) is incredibly talented as a
developer and has made rapid progress in iterating the language, and responds
quickly to suggestions. The mailing list is also picking up momentum, folks
are contributing ideas for how to make the language great.

Yuri (yrashk) has spearheaded the efforts around a package manager -
<http://expm.co/> which allows all Erlang Rebar packages plus Elixir packages.
Still missing is "binary" package support but that's been a gripe about Erlang
for a long time.

I believe in Erlang/OTP and I really believe Elixir has a bright future. In a
few years there will be folks who build Elixir apps and don't bother to learn
Erlang. This could really freak out the Erlang "old guard" - many are friends
of mine - but they don't really care that much, as Erlang has has always been
a niche musical instrument and Elixir is Erlang's ticket to Carnegie Hall.

------
devinus
For anybody interested, Elixir was accepted into Google Summer of Code 2013 as
part of the BEAM Community of projects: <http://beamcommunity.github.io/>

If you're a student, check out our project ideas here:
[https://github.com/beamcommunity/beamcommunity.github.com/wi...](https://github.com/beamcommunity/beamcommunity.github.com/wiki/Project:-Elixir)

------
colanderman
1) Where is the language documentation? The "Docs" section only seems to
address the libraries. Libraries are uninteresting if you're designing a new
language.

2) How does Elixir address the problems that Javascript-style metaprogramming
(i.e. first-class definitions) cause for automatic program analysis? Erlang
has some great analysis tools (e.g. Dialyzer) precisely because it's simple.

3) How is Elixir's first-class definition approach more useful than multi-
stage programming (such as MetaOCaml: <http://www.metaocaml.org/>), principled
syntax extension (such as CamlP4: <http://pauillac.inria.fr/camlp4/>), or
second-class higher-order modules (such as OCaml's functors), each of which
are inherently more amenable to automatic analysis?

4) Almost every "old" computer language has slowly moved _away_ from
unprincipled metaprogramming precisely because it's difficult to reason about,
for both humans and computers. (C, JavaScript, and Python, to name a few, all
have unprincipled metaprogramming facilities, which have been, over time,
relegated to specific use patterns to maintain coder sanity.) What do we hope
to gain from a new language whose _raison d'être_ is based on this feature?

(P.S. All these points seem to apply equally well to Joe Armstrong's "erl2".)

~~~
jeremyjh
1) The language introduction is found under the Getting Started link:
<http://elixir-lang.org/getting_started/1.html>

2) Dialyzer works fine on Elixir beam files. You can specify type & spec
attributes just like in Erlang.

If macros worry you unduly, then Elixir is not for you. I personally prefer to
use macros than type lots of boilerplate code, but yes there are some
downsides.

edit: Actually I should have said reading and typing - reading boilerplate is
much worse than writing it. Judicious use of macros can clarify intent for
someone reading the code.

~~~
colanderman
1) A language introduction is not documentation, and is certainly not
specification. It's difficult to discuss a new language when you have to guess
how it works based on a handful of examples.

2) Dialyzer is a complete, not sound program analyzer. i.e. it will never
produce a false positive, but it may allow incorrect programs through. By
making definitions first-class, Elixir's module language becomes Turing-
complete, moving a whole new class of bugs into Dialyzer's "false negative"
category.

This problem doesn't exist with second-class definition systems such as
OCaml's, because the definition language is not Turing-complete: all
definitions and modules may be checked at compile time.

3) I'm not sure where macros come into play? Are you using "macros" to mean
"higher-order programming tools"? If so, you're misunderstanding me -- I use
metaprogramming tools all the time; I simply prefer ones which aren't Turing-
complete and are therefore amenable to analysis.

~~~
davidw
> It's difficult to discuss a new language when you have to guess how it works
> based on a handful of examples.

It sounds like you are more interested in "CS friendly" languages, rather than
"get stuff done" languages. Erlang and Elixir tend toward the latter category.

I'm generalizing a lot, and that's not to say a language can't be both, but
Erlang was born of a practical need, and I think that Elixir is similar: it's
not meant to be the most beautiful language out there, it's meant to be a bit
more user-friendly way of utilizing the power of Erlang and OTP.

In terms of a specification, have a look at Elixir's test suite. Given that
it's still being hacked on, it's probably not set in stone.

~~~
colanderman
_It sounds like you are more interested in "CS friendly" languages, rather
than "get stuff done" languages._

It sounds like you think there's no overlap (despite your next paragraph).

Additionally: "CS friendliness" is more pragmatic than you think. Automatic
refactoring and automatic code analysis are two huge pragmatic wins (think:
saving developer time) that are made possible only by paying heed to
analyzability of code.

 _Erlang and Elixir tend toward the latter category._

Erlang is my current favorite language. You may not realize it, but it is one
of the most "CS friendly" mainstream languages that exist. The fact that it is
almost entirely defined by "functional programming" + "actor model" is a big
part of this. The existence of Dialyzer is a testament to its amenability to
automatic analysis.

 _In terms of a specification, have a look at Elixir's test suite._

A test suite isn't a specification (though it's a lot closer than a tutorial):
all computer languages contain infinities (e.g. expressions can be arbitrarily
large); test suites cannot express infinities.

And a test suite certainly isn't a reference document. A good language
reference document says "here are all the forms of the language, here is what
they all mean". The Erlang Reference Manual is a very good example of such a
document.

(I'm not trying to be a bear; "There is no language documentation" is a
perfectly acceptable answer for me; it just means there is no way for me to
discuss the specific benefits Elixir may have.)

~~~
davidw
> The Erlang Reference Manual is a very good example of such a document.

Erlang has had quite a bit longer to produce such a document, though, hasn't
it?

Why bother doing that when you're still fiddling with the language?

In terms of CS friendliness, I get the impression that Haskell is far more
popular with that crowd in that it has more things of interest to people doing
language hacking. Erlang has "functional" and "actors", but not a lot of other
stuff that seems to be of interest to the CS crowd, like types.

> "There is no language documentation" is a perfectly acceptable answer for
> me; it just means there is no way for me to discuss the specific benefits
> Elixir may have

No way at all? I think you can tell a lot about a language without some kind
of formal documentation.

~~~
colanderman
_Why bother doing that when you're still fiddling with the language?_

To me, that sounds entirely backward :) I've never implemented a language I
haven't already designed "on paper". (Why bother? With a good reference
document, you can write and test programs in your head. Implementation is
tedious; I only want to do that once.)

 _In terms of CS friendliness, I get the impression that Haskell is far more
popular […]_

It is. I don't really know why. Haskell has a lot of libraries and a good
compiler, but it's otherwise pretty boring. Its type system is nothing special
(OCaml and Mercury have very similar but more interesting systems, notably
w/r/t subtyping), monadic I/O is one of the silliest contortions I've seen
(uniqueness types in Mercury and Clean are much easier to work with), and
laziness isn't all that useful (it _is_ useful but I've never missed not
having it).

(I say this with all respect to the Haskell designers: it's a very _good_
language, and they successfully met their self-imposed goal of being fully
functional; I just happen to think that that goal led to Haskell being
ultimately boring.)

 _Erlang has "functional" and "actors", but not a lot of other stuff that
seems to be of interest to the CS crowd, like types._

That's exactly it. It _doesn't_ have a lot of stuff. The language is
incredibly simple, EVERYTHING is explicit, it doesn't encourage first-class
metaprogramming, and it ships with its own parser and pretty-printer. That's a
CS researcher's dream. That's why Dialyzer (which is better than many, if not
most, built-in type systems) can exist. You don't need a built-in type system
if your language is simple and analyzable enough to admit a 3rd-party one.

 _No way at all? I think you can tell a lot about a language without some kind
of formal documentation._

Sadly, all I can tell from the tutorial and front page is "Elixir has some
kind of metaprogramming that's probably based on Ruby or Javascript". Like I
said, I'm a huge fan of metaprogramming done right, but that hinges on lots of
specific language details that aren't clearly documented.

Without specifics, any discussion about Elixir's metaprogramming features
might as well be a discussion about Javascript's or Ruby's, because that's all
I have to go on.

~~~
aninhumer
> monadic I/O is one of the silliest contortions I've seen (uniqueness types
> in Mercury and Clean are much easier to work with)

As far as I can see they're all basically the same thing. You enforce sequence
by creating a chain of notional "real world" values. I can't say I've used
Clean or Mercury extensively, but as far as I can see they just make you pass
around that value explicitly. That doesn't really seem like it would be
"easier to work with".

~~~
ralfn
> That doesn't really seem like it would be "easier to work with".

1\. You dont need monadic versions of all non monadic functions. You dont need
fmap, you can just use map.

2\. It means there is a well defined order of execution (i.e. The order does
not "emerge" as in Haskell, instead it is defined and verified by type system)

It is much much easier to work. In Haskell you feel forcedto separate io from
transformation as much as posible. Often you end with either repeating ourself
a lot (writing oth mondic as non monadic versions) ir you venture out in monad
transformers, which imho is the "goto" of Haskell. (How to turn your code in
unreadable unmaintainable spagetti). The cognitive overload is never worth it.

Ps. Uniqueness types are not just about IO. Rust uses them as well. They are
about sharing. Haskells needs an IO () type because without a monad it has no
defined order of execution, and it cant prevent you from "forking the world"
when working with outside references.

If Haskell could prevent you (by using uniqueness) i doubt they would have
used monads for IO. (Although they can be usefull in other areas).

------
gingerlime
Using python and ruby, Elixir looks much more "familiar" than the erlang
syntax. Yet I was always curious about things like the actor model,
lightweight processes and the high availability aspects of erlang.

Is it wise/advisable to start with Elixir without knowing erlang, or is it
better to learn erlang first?

~~~
yrashk
I would recommend to start learning Elixir and diving into Erlang as necessary
(and yes, you will find it necessary)

------
zen_boy
Are there any beginner friendly articles about Elixir?

I've been mainly doing web programming with Ruby and want to understand how
Elixir is useful and why I would choose it over something else.

~~~
davidw
The big reason to use something like Elixir, Erlang, or of course Node.js or
other things of that ilk is if you're using a lot of web sockets, streaming,
or that kind of thing. With Rails, a connection that stays open is (unless
they've changed it recently) going to hog a whole Rails process, which is a
lot of resources to tie up.

A secondary reason might be if you're doing pretty much everything in
Javascript on the front end, a lighter server process is probably going to
work out better in terms of resource usage. Myself, I'd probably still opt for
Rails while developing, just because it's so fast to get something up and
running with, and you're going to need to do stuff like authentication server
side anyway.

If you want something that's vaguely familiar, you might have a look at
Chicago Boss. It doesn't do as much as Rails, but it's fairly easy to get up
and running, and the guy who built it is very friendly and helpful:
<http://www.chicagoboss.org/>

~~~
zen_boy
How does Elixir/Erlang compare to Go?

~~~
klibertp
It doesn't.

Big runtime, VM, no mutable state (really), no direct access to memory,
pattern matching, exceptions, no side effects other than sending messages, no
destructive assignment, single assignment variables - that's an incomplete and
subjective list of Erlang features. How much of it is even comparable to what
Go offers?

~~~
davidw
> It doesn't.

Sure it does: they're both programming languages that people use to get stuff
done.

Erlang is far more robust than Go at this point in time, from what I can see,
and much more mature - its history goes back some 20+ years. It has a bunch of
stuff for distributed, concurrent, fault-tolerant computing that is, in some
ways, the best in the business. However, it also brings with it an accretion
of warts that it has brought with it over the years, starting with a syntax
that most people do not find easy. Go is very new, still being worked on, and,
as klibertp says, is quite a different beast in many ways.

My thinking is along these lines: if you want something rock solid, use
Erlang. If you want something that's "pretty good", and getting better, Go
might work out well for you.

------
FlyingSnake
Previous discussion on HN <https://news.ycombinator.com/item?id=5099861>

I would be interested in knowing the downsides of using Elixir and its
comparison with Go-lang.

------
mjackson
If you're interested in doing web stuff with Elixir, check out Dynamo:
<https://github.com/elixir-lang/dynamo>

It's a web framework developed and maintained by the Elixir core team, and
I've had fun playing with it recently. It already supports a lot of the most
common tasks when doing web development including request routing, parsing of
parameters and cookies, and pre/post-request hooks.

------
zura
Can anyone recommend some good materials (books/articles/tutorials) about a
new language implementation for Erlang VM?

~~~
davidw
Probably the best thing is to look at the existing ones: Elixir, and maybe
Reia, although I think that effort has stopped.

I get the impression that the underlying VM is fairly Erlang specific, so that
it's going to be difficult to do a language that doesn't come out looking at
least something like Erlang, but I've never looked closely.

------
steele
[https://github.com/evanmiller/ChicagoBoss/blob/master/README...](https://github.com/evanmiller/ChicagoBoss/blob/master/README_ELIXIR)
exciting

