I really like Elixir.

Not only does it have a clean, pleasant syntax, macros, but it has all the good parts from Erlang, namely:

* BEAM VM (isolated heaps, very well tuned scheduler, concurrent garbage collection)

* Pattern matching, once you've tried it, it is hard to go back.

* Ability to call Erlang code

BEAM VM is really a secret gem and many didn't get a chance to play with it because they didn't like Erlang's syntax (personally, I do like Erlang's syntax, but I think many don't). Well there is little excuse now.

If you like DSLs and macros (yes, yes, I know it makes many people scared) this you can do neat stuff like these projects:

https://github.com/elixir-lang/ecto -- DSL to query databases

  InputStream in = new FileInputStream( "./test/lox/test/zooinventory.xml" );
  Document doc = LOXHandler.load( in );
  List<Element> animals = doc.find( "Inventory/Animal" );
  System.out.println( "animals found: " + animals.size() );

  for( Element animal : animals )
  {
    String habitat = animal.findFirstString( "Habitat" );
    String lifestyle = animal.findFirstString( "Lifestyle" );
    ...
  }

  ...

  // Actual example of some globbing
  List<Element> names = doc.find( "Inventory/*/Name" );
  System.out.println( "names found: " + names.size() );

Ever since I started getting into Clojure, I've been getting interested in these other functional programming languages. Lately I've been checking out Elixir. I don't know what draws me to it (most likely the pretty website and logo :P, and partly because I hate the Java ecosystem). I want to get into it as well, but I just don't see myself using it for anything? I mean for the types of problems I'm capable of solving, Clojure (and Python) seems to be sufficient. To me, it seems Erlang (and thus Elixir) only offers its advantages when building really large distributed systems. Is there any other use case for Erlang/Elixir?

I'm still going to be reading up on Erlang/Elixir for fun and to expand on how I approach problems, but right now I only associate Erlang with large distributed systems and I want to add other stuff to that association.

Here is a write up about Elixir by Joe Armstrong (he had a little something to do with Erlang)

http://joearms.github.io/2013/05/31/a-week-with-elixir.html

It's interesting to see Elixir mentioned more and more. I don't _quite_ see the use-case for it, but I'm so content with Erlang I'm almost surely not the audience the language targets. Will be fun to see if Elixir builds its own community or if Elixir folks slowly filter into the Erlang community as a whole.

- - -

EDIT

It occurs to me that the HN crowd might like Lisp Flavored Erlang: http://lfe.github.io/ It's a lisp-2 written by Robert Virding, co-creator of Erlang, and is backed by a great group of folks.

If you liked the nice simple assert, you can get an imitation in Python tests using py.test: http://pytest.org/latest/assert.html

Source code:

    def test_function():
         assert f() == 4

Output:

        def test_function():
    >       assert f() == 4
    E       assert 3 == 4
    E        +  where 3 = f()

Here's how it works: http://pytest.org/latest/assert.html#assert-details -- when importing the test module, all simple asserts are rewritten (which has some limitations if side effects are involved).

No more verbose self.assertTheItemIsInThisList(item, list) at least.

I recently started programming in Elixir. I chose to rewrite the customized Hubot instance I'm running at my company from the ground up in it - it's been a great way to learn the language, and especially OTP.

OTP is really what makes Elixir (and Erlang for that matter) so impressive. Supervised, lightweight processes just seems so obvious as a solution to fault tolerance and concurrency - coming from C#, where doing multi-threaded programming is error-prone at best, Elixir/OTP is a dream. I do miss the type system from C# or Scala, but type specifications help to mitigate the loss.

The one other feature that has been really pleasing to work with is pattern matching. Scala is the only other language I've used with some form of it, and after using Elixir/Erlang's pattern matching, Scala's seems deficient in comparison. It's an insanely powerful construct, I wish more languages had it.

A couple months ago I got into Project Euler and decided to tackle all of the problems with Elixir. It was a great way to learn syntax and performance nuances. Definitely a tool that I enjoy using and will be keeping up with.

    if(condition, do: a, else: b)

looks like a function, but that implies Elixir does lazy evaluation so that only one of a or b gets evaluated. Or is something else going on?

Edit: The below is actually wrong

> For years I’ve wanted to be able to write my own control flow structures, such as an each...else that runs an else block if the each is empty (Handlebars templates have this).

Actually, python does have a (little-known) `for...else` structure that does what you want.

http://psung.blogspot.ca/2007/12/for-else-in-python.html

Pot, meet kettle. Or whatever the positive version of that is. http://steve-yegge.blogspot.com/2006/04/lisp-is-not-acceptab...

Someone should probably point out that it's homoiconic too.

I'm very interested in Elixir but I'm having trouble understanding the benefit of the 'upcase' example at the end of the article. Compared to a single function with a conversion table, a function per character seems like a tremendous amount of overhead.

Is the purpose of implementing upcase this way to make it more easily parallelizeable in the map/reduce sense?

How Elixir offer type check - compile time parameter validity check on each specialized types - or similar feature?

Is this type inferencing language?

Learning me some Elixir now and I like it. I wish anonymous functions didn't have different call syntax though.

FWIW, Groovy also has those smart asserts. They're nice. Not a big enough deal that i'd start a feature list with them, but nice.

Too bad the lists aren't counting lists and are dumb cons cells. :(

Has a cool Leiningen (clojure) inspired build/dependency tool.

Wow, that center-aligned text is hard to read!

I tried to like Erlang, but the syntax turned me off.

Elixir was just what I needed. Makes the power of Erlang accessible. I like Elixir's docs, tooling, and syntax, and look forward to seeing it progress.

> Is there any other use case for Erlang/Elixir?

Yes, the use case is usually for highly concurrent system. There just happen to be quite a few of those in recent years. Multiple things happening at the same time colloquially speaking. Now it won't be good for fast concurrent problems, like say multiplying matrices, or computing FFT, you'd use a GPU and Fortran for that perhaps. But think of large game server with multiple worlds, and players trading with each other. Think of a large distributed database (like Riak). Think of the backend of large VOIP systems with multiple calls happening at the same time. Or maybe a large chat system (Ejabberd).

Erlang as a general purpose programming language is also interesting. It forces you to think about problems in a different way. Actually 2 ways: -- functional and using actors.

Also, its primary characteristic and design goal is fault tolerance. That was #1 item on the TODO list when it was designed. It is one of the very few languages and systems that has that as the primary goal. Many of the other features -- concurrency, isolation, run-time code upgrade, immutability of data structures, kind of fall out of that. So that is another general area that you might consider where using it makes sense.

On types -- many criticize Erlang for not having a static type system. Not all is lost. Erlang has a way to analyze its types using dialyzer. It is a success typing system. http://erlang.org/doc/reference_manual/typespec.html . The more you annotate the code the better it gets. Dialyzer will not catch all the errors BUT when it complains, it is guaranteed to be an error.

To go hand in hand with that. It has very neat (3rd) party testing tools available. One of the most interesting ones are for Property Tests. These allow you to specify model constraint on your code and it will automatically generate tests to try to find failing use cases that break the constraint.

Anyway, hopefully this gives a bit more of an idea.

To go hand in hand with that, on the testing side it has