Flirting with Elixir

I'm getting quite tired of this "Every functional language I can't precisely describe is like Haskell" sentiment. It's the "tastes like chicken" of programming languages. Then again, the original article is remarkably devoid of content, so I suppose it's only fitting.

Interestingly, avoidance of excessive magic is a large reason why I stick to vanilla Erlang.

> I've had a fling with Go

I've used Go for quite a few things, but it never felt quite right. I've come to like some of the tooling around the language while hating the language itself.

What really turned me away from Go was its community. There are a lot of people who think that they're smarter than everybody else for using a "systems language". Disagreement with the status quo is often fought back with religious indignation. Any decisions made by the language designers are obviously right, and you just need to accept that and do what you're told. I've found a lot of sexism and vitriol too. I've heard similar stories from others, but we could just be unlucky.

Elixir on the other hand has made it a goal to have a nice and welcoming community. That might change as it gains steam, but because of the leadership shown by community leaders, I doubt it will.

This is a sentiment I don't understand at all. Why wouldn't you delve into the source code of tools you use? I do this with almost all the tools I use, be it languages or libraries (obviously I don't use non-opensource ones if I can avoid it). Looking inside libraries teaches you quite a lot and isn't even that difficult, especially if your editor+language combination support "Jump to Definition".

I think we'd be much better off, as an industry, if people learned to appreciate code reading. This would make writing readable code more desirable in the first place, which would be really great.

And BTW, Django has a really good looking codebase. You shouldn't start your reading with SQL compiler in the ORM, but, for example, class-based and generic views are a nice starting point. Another related codebase I can recommend is Django Rest Framework - really a must read for pythonistas who use Django.

> using large libraries feels too much like magic

That's actually my biggest gripe with Elixir. The fact that it happens on compile time (using) and not at runtime doesn't make its magic less magical. And it's very often not documented appropriately. The docs or examples tell you to `use` a module and that's it - you don't know what symbols are imported, let alone what the module macros will do with your code. And it's hard to tell by just looking at the module in question, because - macros. I can deal with it, but in general Elixir should either document its macros better or make things much more explicit.

> I've had a fling with Go, I really like some of its ideas, namely static linking, native compilation, no exceptions, easy deploy

Take a look at OCaml. All the features you mention and a non-brain dead type system on top of that. Multicore is a problem, but I hear it's improving fast.

> It's a mix between Haskell without purity and types and Clojure without parens, with a Ruby-style syntax and a battle-tested framework for concurrency and distributed computing.

That's probably the least flattering description of Elixir I've ever read. Haskell without purity and types would be utterly broken and useless. Similarly for Clojure and sexps. Elixir is neither - it is a nice langauge in its own right.

> I know I talk like a fanboy [...]

Well, I like Elixir too, there's nothing wrong with it. Really, Elixir has many nice features and a great potential; it's still growing, I think, and needs a bit more time to really mature, but is a viable choice for some projects already.

[1] - https://groups.google.com/forum/#!topic/lisp-flavoured-erlan...

I think one of the biggest things for us is that, primarily, we run Rails on the frontend and Scala on the backend. Elixir is exciting because we could potentially replace a lot of our frontend stuff with it, while not being terribly far from Ruby syntax. It's "approachable". On the flipside, it's potentially taking our Ruby code and making it more functional, getting closer to our Scala side of things. It's a very nice middle ground.

In that regard, a lot of us here do feel very excited about Elixir, and so I think that comes through as a lot of hype. We're looking at it through the lens of what it could do for us, and we're naturally excited about that. :)

Elixir macros are like Scheme macros; they're fully hygienic (no variable namespace issues), and they evaluate at compile time. The main difference is that Scheme's main syntax construction is the linked list, and Elixir uses a richer data structure, almost equivalent to JSON. Aside from the particular structure the macro's manipulating, the concepts are the same.

Elixir macros are also used idiomatically to allow "smart" loading of modules, e.g. specifying additional code to run in the caller's context rather than the callee's. They fit nicely for this purpose.