Ahh I love my programming drama in the morning.
Just wanted to point out this, since no one else has, I think. Your default value slashes are the wrong way around. It would be def foo(x \\ 1, y \\ 2), which would not be mixed up with a typical C++ style comment. But even if it was //, there’s plenty of other things you can mix up in Elixir if you think all languages look like C++. 
Dude, Erlang has been like this for more than 3 decades. Elixir just adds different kind of syntax and toolings and web frameworks on top of it. We say Elixir as functional programming language, because it has no class, no object, no pointer as well. Just simple functions, in and out.
Jose Valim wants to bring the power of Erlang and OTP, but he wants it to be like that, the Elixir. The surface syntax looks like Ruby, Phoenix web framework kinda looks like Rails.
I’ve been coding Elixir in the last 4 years, and haven’t found a single monad or currying or for loop (even Haskell don’t have for loop as well, CMIIW). I love Elixir, because it has no monads and other functional aspects that are really hard to explain to other devs coming from OO/imperative.
And that is, Elixir code should be optimized for reading and understanding. There is a huge amount of effort on making an official Elixir code formatter.
If you are looking for pure functional programming language, I’m sorry, then Erlang and Elixir are probably not for you.
Well, TBH even Java that is marketed as OO from a very long time ago, is not pure OO. You want pure OO? Go get some Smalltalk.
Looking for OTP tutorials try Learn You Some Erlang for Great Good (online or as a book).
OTP is covered in most introductory/intermediate Elixir books.
If you are looking for pure functional programming language
In my understanding that is the silliest mistake, a developer can make: to look for the language to be fully compliant with some specific fashionable/hipe paradigms. What is the benefit of being “pure functional programming language”—well, none.
Careful now. I am not here to insult anyone I am just expressing my first impressions while trying to get a grip of the true nature of Elixir.
If I had to pin point the problem with my post it would be that I had all these notions and expectations on what features a FP should have and then when I realized Elixir didn’t I felt frustrated and I think that shows on the original post.
However, jumping from that to you are not making posts with good faith is a long jump and one that I believe is rather unfair. I am not here to tell you that Elixir sucks and language X is better or the other way around. I mean, going to an Elixir forum and complain that Elixir is bad because reason A, B, C would be rather unproductive, don’t you think?
Try to give me some time and know me better, who knows, you might like me ! ( or not? I’ll leave that up to you )
And now, after reading over 20 replies I completely understand this 
Also, thanks for the resources, can’t wait to get started !
Easy there champion! That is in the " Elixir Weirdness ( aka, stuff you will eventually get used to )" section. Which means that it is only strange to me because of my background. Which means I am aware of it, and thus it’s only a matter of getting used to. Not a big deal
I just wondered if someone else from a similar Java / C# / Javascript background had the same experience or thought when they started with Elixir.
This is actually something I value a lot. But while watching Thinking like an Erlanger I got this idea that syntax is secondary ( no one cares if it looks pretty or readable ) and that thinking is the principal part. As in protocols matter, how you implement them doesn’t ( as long as they work ).
Perhaps I miss-interpreted something? Could you show me some light on this ?
You are correct Sir ! ( also why I eventually left Java and God forbid I ever return … )
This OTP thing looks important. Will look into it !
Replied in your article
If you want to use the list Monad, you could use the base syntax [1, 2, 3] as the unit mechanism for putting values into the monad, then use the functions of the List or the Enum modules to manipulate the values in the monad. You could bind multiple functions together using the pipeline operator if you like.
If you want to use a the Maybe or Result monad, a common technique is to use a tuple. A tuple of {:ok, value} might represent the Some or Just value, while either a tuple of {:error, term} represents. If you like you could also use {:some, term} and :none as the appropriate values. To bind them together you would commonly use a with statement in order to get the short-circuit behavior common to that monad. Something similar could be used for most variations on the State monad.
If I wanted to use a “clock face arithmetic” monad, for example, I would use judicious application of integer division and the rem function (for modulo arithmetic). I would probably bind the functions together using the pipeline operator again.
My point, of course, is that Elixir is currently full of Monads and there is nothing that would stop any particular developer from creating any monad they need to use. To your point there no concept of a Monad “typeclass”. There is not type-based facility, with syntax support, for treating Monads as a first-class construct, but there is plenty of facility to use monads in the language.
Weird is in the eye of the beholder, of course, but let me see if I can explain why this is the case. Elixir uses separate contexts to bind named functions and variables. This, as I understand it, means that Elixir is a “LISP 2” language. Here is a code sample:
defmodule DotSyntaxExample do
def ambiguous(x) do
IO.puts("I am in the ambiguous named function #{inspect x}")
end
def entry_point() do
ambiguous = fn (y) -> IO.puts "I am in the ambigous variable. #{y}" end
ambiguous("Hello")
ambiguous.("World")
end
end
DotSyntaxExample.entry_point()
# λ <521>$ elixir Ambiguous.exs
# I am in the ambiguous named function "Hello"
# I am in the ambigous variable. World
In this contrived example, when you are in the context of the entry_point function, there is a binding in the space of named functions for ambiguous and the function itself creates a binding to a variable named ambiguous that happens to lead to an anonymous function.
At the call site I need to tell the system which of the two I am interested in calling, the named function, or the value in the variable. For that reason, Elixir uses the .() syntax to indicate that I want to use the variable binding instead of the named function binding.
What I mean by weird, is that when compared to how you call normal functions in Elixir. Your example illustrates this in perfection:
ambiguous("Hello")
ambiguous.("World")
Now I get why you need .() in this example. It is a disambiguation.
However when currying ( in he article I presented and in here ) it seems that the only way to use dynamic functions is to bind them, which results in the syntax .(), instead of the more natural ().
But perhaps I am mistaken? Perhaps there is a way to call anonymous functions when currying that doesn’t require binding ? ( and thus promotes the usage of the () syntax ? )