Elixir vs Go

I liked it very much, I skimmed some parts, but it’s rather informative and I don’t have the feeling it’s biased.

Looks nice, reading it.

Comments as I read it. ^.^

Due to immutable data, common operations such as for-loops aren’t available because incrementing a counter isn’t an option.

Well it ‘is’ available, just not in the form they expect as you carry state along a TCO or so. Perhaps word it as Due to immutable data, common imperative operations such as for-loops aren’t available in the usual imperative forms because there is no mutation of a variable. or so?

although the Enum library provides common iterative patterns in a manner that is comfortable.

Many already find recursion comfortable, if not more comfortable than iteration, so this sentence seems a little accusatory to me. ^.^

Using a hash pattern as an argument, that function will only be called if a hash with a key of data is passed in that has a nested hash which contains a nifty key that has a value of “bob” and an other_thing key. The variable other would be set to its value.

A hash? Is this referencing perl? o.O? I think you mean map, also internally it is not a hash-map last time I saw the implementation, so even describing it as a hash-map would not be accurate.

def example_pattern({ "data" => { "nifty" => "bob", "other_thing" => other}})
  IO.puts other
end

Also, your example, even though you were speaking of 'hash’es is not a map, it is a compilation error as it looks like you are mixing tuples and key/value referencing (which you cannot do in tuples). Also, the IO.puts other form I think is deprecated, you should have parenthesis like IO.puts(other).

Even though Go allows functions to be called by a specific interface type, g.area(), it’s essentially the same thing as calling area(g).

Not entirely. Go scopes out so you could have different area’s in different interface ‘trees’ as well as they are turned into an, as I recall, log(N) dispatcher to the correct implementation if the interface cannot be resolved or to built-in function pointers on the interface otherwise, it might be more accurate to change the area(g) to be something like g.__dispatchTable[area]() or something like that as pseudo-code.

Elixir can’t reuse the patterns as easily, but the pattern is always defined in the exact place where it is used.

Well there are libraries to handle that, or you could do it yourself via macro’s, but it is doable to reuse patterns and quite effective as well. ^.^

Strong typing essentially means dynamic typing where the compiler can catch virtually every type, with the exception of ambiguous arguments in a pattern match

I… do not think so? As I recall:

• Type castability?:
  • Strong typing: Types cannot be transparently cast from one to another (Elixir, OCaml, C++, Python, …)
  • Weak typing: Types can be transparently cast from one to another (Javascript, Visual Basic, …)
• Type liveness?:
  • Dynamic typing: The compiler does not know the types, they exist at runtime, this cannot be optimized as well as static types
  • Static typing: The compiler knows all types at compile-time and can optimize code and shrink memory usage based on that information

Elixir is thus a Strong Dynamically typed language, but your above description sounds like Static typing. Elixir, however, does have dialyzer, which can do a form of Success typing over the calls, but it is not static nor can the BEAM optimize based on that information nor can the compiler catch type errors.

Cooperative versus prescheduling

In this section you describe how cooperative scheduling works with Go, but do not go into near as much detail about how preemptive (not prescheduling) in Elixir works. Also it is preemptive, not prescheduling.

Go programmers have the ability to insert runtime.Gosched() in their code to force more check-ins with the scheduler as a precautionary measure for potential problem code. Run-time enforcement allows more trust of third-party libraries and real-time systems.

The beam has similar calls as well, including ones that can entirely reset the operating memory of a process as well (hibernate) and operate only on the next passed in parameters and such

Also note that functions must be inside modules in Elixir.

No they don’t, you can spawn anonymous functions too, your example even shows that. ^.^

Go calls them channels, while Elixir has inboxes.

Technically Erlang calls it the Process Mailbox I’ve seen everywhere.

Wrappers include Task for simple async/await style calls; Agent for concurrent processes which maintain and update a shared state; GenServer for more complex custom logic.

Actually Task and Agent are not OTP parts, they do not even fit into the OTP supervision tree unless you do it manually. Those are more simple abstractions over spawn, not really parts of OTP I’d personally say.

Elixir inboxes default to unlimited messages but can utilize Task.async_stream to define max concurrency for an operation and blocking senders in the same way as limited buffers on a channel.

Ehhh, not unlimited, rather the more full a mailbox the more the system pauses things trying to put messages into the mailbox of that process, so as a process gets overwhelmed with messages it slows scheduling everything else trying to put ‘into’ that process (but none others) as it tries to catch up. And the Task thing is something different entirely, maybe should be removed?

Elixir processes have their own isolated heap spaces which are individually reclaimed when the process finishes

Might also be good to mention Elixir has a GC but it only runs over a single process (not pausing anything else unlike Go’s GC) and only when the process starts getting large, else no GC may ever be run on a process at all.

I’m getting busy again, will keep reviewing later if I remember (or poke me).

Hrm, what do you mean by this? Sure, they are not part of OTP, but they are OTP compliant processes. You can put them in a supervision tree as easy (or as hard) as a GenServer. And they are definitely more than abstractions over spawn. For example, an Agent is a GenServer.

I liked article very much

I have question: Can we run Go program from Elixir?

About clustering you mostly put Go application into container and orchestration service will take of it. Go very well fits into containers ecosystems. You can use with go http://www.grpc.io/

You could add sections:

####Tooling:

https://github.com/uber/go-torch

###usage

• Docker
• https://kubernetes.io/
• https://prometheus.io/
• system tools

Nice projects:

Also worth mention
http://www.infoworld.com/article/3154624/application-development/google-boosts-python-by-turning-it-into-go.html

True, but that is not how I see most people use them, I think once have I seen a Task put in a Supervisor tree. That’s fine in the doc then.

Will definitely submit edits this evening. Thank you for the editorial review.

Okay, edit’s submitted and hopefully will be tweaked first thing tomorrow because it’s on the front page of HN right now.

Based on your review I asked them to change prescheduling to preemptive scheduling, hash to map (I have spent too much time in perl that it’s a reflex at this point) and an update to the code sample to fix the %{} on the pattern and the puts(other) part.

Most of the rest I left just based on sheer brevity sake. Unlimited-ish on the mailbox. I did mention elsewhere that the process heap is reclaimed independently while Go use’s a system wide GC. For the “functions inside modules” part I was really talking about defining functions.

On the typing subject, I linked to an Elixir Conf presentation on Dialyzer to further explain that part. I should probably have mentioned Dialyzer by name but it’s one of those tools that has no drawback to using it, gets used in generally every project and I didn’t want to confuse the reader with compiler + tool they’ve never heard of and won’t understand without further explanation.

That was a very interesting article, thank you.

Erlang was developed to power phone systems (OTP stands for Open Telephony Protocol) and currently powers about half of them on the planet.

Is there a source for the “about half of them”?

While I agree with you personally, I believe that this is very much a matter of opinion.

But your post does make me wonder about something else: Does Go have a way to do metaprogramming?

Emphatically no. Go is a simple language, and metaprogramming is complex. You can generate go code from a build script, but that’s about it.