Fred Hébert

I write it fully acknowledging that programming language flamewars are pointless, but this article just shows that you don't even have to try hard to create a biased comparison.

Here's the essential difference between Go and Erlang: Go gets most of the things right, Erlang gets way too much wrong.

So what does Go gets right but Erlang doesn't:

* Go is fast. Erlang isn't

* Go has a non-surprising, mainstream syntax. You can pick it up in hours. Erlang - not so much.

* Go has a great, consistent, modern, bug-free standard library. Erlang - not so much.

* Go is good at strings. Erlang - not so much.

* Go has the obvious data structures: structs and hash tables. Erlang - no.

* Go is a general purpose language. Erlang was designed for a specific notion of fault tolerance - one that isn't actually needed or useful for 90% of the software but every program has to pay the costs

* Go has shared memory. Yes, that's a feature. It allows things to go fast. Purity of not sharing state between threads sounds good in theory until you need concurrency and get bitten by the cost of awkwardness of having to copy values between concurrent processes

So sure, if you ignore all the major faults of Erlang (http://damienkatz.net/2008/03/what_sucks_abou.html, http://www.unlimitednovelty.com/2011/07/trouble-with-erlang-or-erlang-is-ghetto.html, http://ferd.ca/an-open-letter-to-the-erlang-beginner-or-onlooker.html, http://sacharya.com/tag/erlang-sucks/) it compares very favorably to Go.

You…

I couldn’t agree more. Security is almost always user hostile (speaking from a UX perspective). I am NOT advocating that we remove security for obvious reasons (a hacked app is also user hostile). HOWEVER - if we can just acknowledge that security is antithetical to an easy to use, user friendly app then we can make appropriate decisions moving forward.

One of my favorite sayings is “if you are not careful, you are going to secure yourself right out of business”. Ease of use is a real thing, and if you don’t figure out a way to make a secure app that is also very easy to use, someone else will and your pleas of “but it is not secure” are going to fall on deaf ears.

Honestly, baseline security is part of “essential complexity” https://ferd.ca/complexity-has-to-live-somewhere.html. Essential complexity can’t be removed, but it CAN be moved around. Right now we are talking about the essential complexity of managing security through managing a user’s session length. The advocated solution is to make sessions short so that they expire quickly. This seems to remove all “accidental complexity” so that we are only dealing with the essential complexity. But this is misleading. There is still complexity in juggling those short sessions. As a designer you think this solution is simple, but what you have done is moved that essential complexity over to your users. THEY must now manage the impact of short sessions. The complexity does not go away, you just moved it to your users, hence…

I'm all for bending your text editor to your will, but a few of these tips gloss over the core of vim: the shortcut language it offers and the composability of its parts of speech [1].

For example, remapping the paste key to paste + move to end is cool, but `ppppp` to paste 5 times circumvents vim's killer repetition. Want to paste 100 copies? (hopefully you do this rarely). Just type `100p` and you're done. I won't bother typing out the obvious sequence of repeated `p` presses, but you get the drift.

Also, remapping v to progressively select larger surrounding text objects will keep you from learning that you can perform any action on the 3rd parent curly braces by following the action with the text object `3a{` or `3a}`. Select it: `v3a{`, delete it: `d3a{`, comment it out `gc3a{` ([2]), whatever. If there's an action in vim you can perform it on a text object which can usually start with some count.

I really do mean language, too. When I'm using vim, I feel a lot more like I'm communicating with my computer than trying to figure out how to do what I want to do.

The actions are there: delete, change, select. The direct objects are there: braces, this line, line number N, end of this word, the next character C, this paragraph. The prepositions are there: inside, outside, up to (inclusive, exclusive).

Heck, the sensible defaults feel a whole lot like the "understood" words that you can leave out of sentences. Instead of "navigate to line 30", you can just use the…

The idea sounds related to the distinction between essential and accidental complexity.

https://ferd.ca/complexity-has-to-live-somewhere.html

I really like the article above in that complexity does have to live somewhere. If you have a hard problem to solve, there is a minimum level of complexity (essential complexity) that can't be further reduced, only moved from one place to another.

And yet we often add accidental complexity by making bad choices (thinking of you, microservices). If your choice is bad enough, you get all the disadvantages (challenges with distributed systems, complicated debugging), but without any advantages (a distributed monolith doesn't get you any deployment or team independence).

Telling one from the other, well, is something I'd like to learn and that seems to require both experience and some sort of intuition.

I'm the author of this article.

If you find it interesting, here are some links to a couple other articles I've really enjoyed on the topic:

# Queues don't fix overload

http://ferd.ca/queues-don-t-fix-overload.html

# There is no happy path in programming

http://multithreaded.stitchfix.com/blog/2016/01/29/no-happy-path-in-programming/

Also, if you're looking for a whole book on systems thinking, albeit in a more general context, it's worth checking out "Thinking in Systems: A Primer" by Donella H. Meadows.

Once you start thinking about this stuff it's impossible to not see it everywhere. But for programmers, ops people, etc. that's a good thing... because our jobs depend on it.

Agreed on all parts.
The Erlang and OTP manuals were very nicely written, and I was able to reason about most aspects of the system pretty well from reading them.

I did a bit more research after writing up my comment (my mind got a bit too focused on it to let it go) and found this great resource about handling various system load scenarios: https://ferd.ca/handling-overload.html

I'll +1 your pragmatic comment on not adopting tools just because they're there.

Again I no longer work in Erlang, but I find the systems, architecture, and problem solving particularly interest piquing.

Now I'm off to look up production use-cases where Mnesia was the most pragmatic solution.