Joe Armstrong

It would be a fun callback if the demo was a factorial server: https://joearms.github.io/#2013-11-21%20My%20favorite%20Erlang%20Progr…

I really liked Joe Armstrongs GitHub blog here: https://joearms.github.io/ He wanted something that would enable anybody to PR his Wiki and wasnt at the mercy of a server side static site generator engine since the GH one screwed up his links for his former blog. Its simple and works mostly on the client side and gives you an exportable file. Armstrong passed away sometime back sadly and my hope is that GitHub maintains his blog undisturbed. He had a beautiful way of explaining concurrency and software issues that I think anybody could follow. Also for those unaware he was one of the creators of the Erlang programming language.

Made by the same person who brought to you such classics as "MongoDB is Web Scale" and "Node.js Is Bad Ass Rockstar Tech". Also significant enough to be mentioned by Joe Armstrong himself: https://joearms.github.io/

For me (and I've been writing Elixir for probably a decade now...) Joe Armstrong's post here encapsulates it pretty well: https://joearms.github.io/published/2013-11-21-My-favorite-erlang-prog… And for me, what it comes down to, is, doing powerful things in Erlang/Elixir is trivial where it would be really convoluted in other languages. When applied to the right problem, it genuinely makes a whole class of problems evaporate, and that's addicting.

It reminds me of Joe Armstrong's "My favorite Erlang Program": https://joearms.github.io/published/2013-11-21-My-favorite-erlang-prog…

Featured on the front page not too long ago https://joearms.github.io

>functions can now be defined directly in the shell Finally, Joe can stop rolling in his grave, as newbies will no longer have to ask why Erlang forms are not possible to express in the shell. See the "Funs and defs are not the same" section from https://joearms.github.io/#2013-05-31%20A%20week%20with%20Elixir for details

it does. values are immutable in the BEAM, not at language level. The impact of bugs is minimized by compartmentalization. This is done from the lowest level where each data structure is separate and immutable [1] But you can simulate mutability with stateful processes. Directly from Joe Armstrong: https://joearms.github.io/published/2013-11-21-My-favorite-erlang-prog… [1] https://github.com/happi/theBeamBook/blob/3971e8e2d09e3676702a2a5fa8c4…

"The Most Intolerant Wins: The Dictatorship of the Small Minority" by Nassim Nicholas Taleb — https://medium.com/incerto/the-most-intolerant-wins-the-dictatorship-o… "My favorite Erlang program" by Joe Armstrong — https://joearms.github.io/published/2013-11-21-My-favorite-erlang-prog…

Erlang has it built-in, or you can roll it manually, like in [0]. But the biggest problem is not changing the code, it's changing the layout of already existing data — throwing it away is equivalent to killing the process and starting it from scratch. It can't be done automatically, you, as a programmer, must supply an upgrader (and downgrader, for rollbacks) written manually by yourself. [0] https://joearms.github.io/published/2013-11-21-My-favorite-erlang-prog…

Always worth a reread: https://joearms.github.io/published/2013-11-21-My-favorite-erlang-prog…

It also comes from a comment by Joe Armstrong, author of erlang, upon trying tiddlywiki. https://joearms.github.io/#Index Rip Joe

The late Joe Armstrong described the similarly minimal Erlang issue tracking system in this excellent post about MVPs https://joearms.github.io/published/2014-06-25-minimal-viable-program.…

A very useful application of quines: https://tiddlywiki.com/ Learned about it first from Joe Armstrong: https://joearms.github.io/#

It's impossible to choose a favourite, but here's a beautiful snippet, courtesy of Joe Armstrong [0] universal_server() -> receive {become, F} -> F() end. [0] https://joearms.github.io/published/2013-11-21-My-favorite-erlang-prog…

A start: https://joearms.github.io/#2018-12-26%20Fun%20with%20the%20TiddlyWiki

Regarding the "!! Select text -> type in correction -> people see change.", he was putting that in motion with his personal blog: https://joearms.github.io/

If people aren't aware, Joe's blog is full of interesting tidbits: https://joearms.github.io/#Index. I remember reading this one in particular: https://joearms.github.io/#2015-03-12%20The%20web%20of%20names%2C%20ha…

A never-Rails dev here using Elixir/Phoenix, easily the best choice I've made after hearing positive things here on HN. The Elixir community may be an amalgamation of Rails folks looking for better runtime performance and cool new tech, and Erlang folks looking for syntactic sugar and a growing developer community. (I'm neither.) Elixir's author was one of Rails core contributors, which probably also helps in bringing the Rails crowd over. One could think of Elixir as a "better" version of Rails rewritten on top of the Erlang stack, even if Rails and Elixir are apples and oranges under the hood. See also: the inverse of OP's article, the creator of Erlang trying out Elixir (2013) [1] [1] http://joearms.github.io/2013/05/31/a-week-with-elixir.html#head_1

I'm not sure I understand how static types and existing Erlang OTP patterns are supposed to work together. What is the type of a gen_server? It can literally become anything. What is is the type of become messages? http://joearms.github.io/2013/11/21/My-favorite-erlang-program.html

Erlang pretty much blows Node.js out of the water, in terms of sophistication of concurrency primitives (to mention one thing). Erlang is really just syntax on top of BEAM, which is pretty tailored to the language (you'll notice Elixir and Erlang share identical types etc). Elixir adds some nice metaprogramming features, and I love that it exists. Erlang is used for a lot of Important Things in production, and its value to many developers is stability and fault tolerance. Erlang moves slow. It's nice to see a sister language that can more rapidly develop new language features (maybe some of the goods ones will get added to Erlang (: Joe Arms post about Elixir is pretty interesting [1] [1] http://joearms.github.io/2013/05/31/a-week-with-elixir.html

It's worth noting that even Joe Armstrong, who designed Erlang, has said about Elixir: "This is good shit." http://joearms.github.io/2013/05/31/a-week-with-elixir.html

He is blogging on a GitHub pages domain now: http://joearms.github.io/ The new syntax is described in the post "Big changes to Erlang".

The Joe Armstrong blog post linked by another commenter above actually addresses some of this: https://joearms.github.io/#2013-05-31%20A%20week%20with%20Elixir TLDR: GC and runtime behaviour generally are built from the ground up in OTP with this kind of concurrency and programming model in mind. Its advantages can be approximated but not fully replicated in "general purpose" runtimes like the JVM. Consider that the JVM model is for long-running shared memory systems. So its GC in particular is built around that model. Erlang/OTP as I understand is a lot of short lived processes that communicate through messages, sharing little state. Designing a GC for a system like that has entirely different trade-offs. Isolated short lived actors can throw-away their entire memory state at process end, without waiting for a generational collector to discard the garbage, etc. And that's just the GC. In general in a system bolting "actors" onto another shared memory language it's always going to be possible to "escape" that framework and do things in another paradigm. That might be fine for the real world, but it negates some of the advantages that OTP brings to the table.

A flag function that decides a boolean decision could have a signature such as f: context_t -> bool where context_t is a value type containing fields such as: uuid of the current user, uuid of the node or region we are deployed to, the current time, the current version of the application code. Feature flag platforms such as launch darkly can be thought of as a way to manage and deploy new implementations of decision functions into running application processes. E.g. dream up a class of decision functions with the signature f: context_t -> bool that could be serialised and sent over the wire between two machines. For large muddled IT organisations, toggling a flag in a production application by having a developer hardcode it or toggling a flag by changing static application config and redeploying might require 15 minutes of development time followed by days of integration testing and meetings and change approval lead times. In these settings, having some kind of feature flag platform deployed that allows application behaviour to be toggled very rapidly without coupling it to some kind of IT software deployment might let the organisation react and run experiments two or three orders of magnitude faster. Give product managers or "the business" the ability to adjust application configuration live in production with the feature flags without having layers of slow process in the way. If your application contains a large subsystem where some decision or logic is evaluated by…

This was sort of true when computers had few CPUs/cores. It didn't make much of an efficiency difference, it was mostly a question of programming model. It works fine as long as the program is fundamentally I/O bound, but breaks down when it is doing actual work and becomes CPU bound. I have certainly had some horrible experiences debugging multi-threaded C++ programs, and using non-blocking I/O made them safer and easier to reason about because only one thing happens at a time. The non-blocking I/O programming paradigm, however exposes unnecessary "plumbing" to the programmer. What we really want is a concurrency model where we can handle each request as if it was the only thing happening. To the extent that multiple requests need to share resources, we need ways to safely access state with concurrent access. That might be a relational database, mutexes, or software transactional memory. I am currently in the middle of updating a large application written in Twisted Python. async/await and promises can certainly be complex. The Flask approach of using one thread per request is easier to understand. Everyone in the Javascript is in love with async/await, but I can see where that ends: just look at what Twisted was doing 10 years ago. And see that it basically failed due to complexity. The model I like best is Erlang/Elixir. The runtime handles I/O using non-blocking I/O and threads to be efficient. The programmer works in terms of lightweight actors (called "processes",…

When you're talking about type systems, "dynamic" really doesn't make much sense to talk about. It's not like the runtime constructs a typing model out of its observations of the properties of objects' runtime interactions. The notion of there being a "type" to a duck-typed object is purely a theoretical one; in practice, the object just does whatever it wants moment-to-moment, and the runtime has no idea. Consider a generic "proxy" object that can be arbitrarily disconnected and reconnected to objects of different types. These can exist in any duck-typed runtime system. What is such an object's "type", even in the sense of its "runtime type"? There isn't one. There might be a sense in which it has an instantaneous type—a type it has as of a given program world-state—but that information is inaccessible to the runtime, since any probing it might do to ascertain this might also cause the object's instantaneous typing to change in the middle of the probing procedure. (See also: the Universal Server in Erlang [ https://joearms.github.io/published/2013-11-21-My-favorite-erlang-prog… ]. What is this server's "type"?) A type system is something that can make guarantees about the behavior of a program in advance. In that sense, duck-typing isn't really a type system. It's just asking objects questions and then blindly trusting the responses you get. There's nothing but convention guaranteeing that an object that e.g. in Ruby implements `respond_to?` a certain way, will…

Those are all very valid points. However, having witnessed (different shapes of) the wheel being reinvented over the past 2 decades, my take is slightly different: each language/environment has its strengths. If you have the luxury of having a senior team that's decently versed in several environments, then you can have your cake and eat it too: for each tool, micro-service, component... use the right language for that. Then tie it all together on the network. Since the system as a whole is likely to be a network product anyways, embrace it to your advantage. Joe Armstrong wrote a good post[1] about connecting programs a few months ago, that's quite relevant. Node.js is a great environment for many microservices. Got a task to do which is 80% done in some npm module? Make a node.js service around it. Same idea for Perl & CPAN, C libs, Java tools, etc. [1] http://joearms.github.io/2016/01/28/A-Badass-Way-To-Connect-Programs-T…

Joe Armstrong - the creator of erlang would turn his cluster of 1000's of machines to change behaviour. The code is really 5 lines. My favorite Erlang program 21 Nov 2013 The other day I got a mail from Dean Galvin from Rowan University. Dean was doing an Erlang project so he asked “What example program would best exemplify Erlang”. ... The Universal Server Normally servers do something. An HTTP server responds to HTTP requests and FTP server responds to FTP request and so on. But what about a Universal Server? surely we can generalize the idea of a server and make a universal server that which we can later tell to become a specific sever. Here’s my universal server: universal_server() -> receive {become, F} -> F() end. ...then I set up a gossip algorithm to flood the network with become messages. Then I had an empty network that in a few seconds would become anything I wanted it to do. a process in erlang, is nothing but a tail-recursive function. the moment it stops being so - it dies. so here it morphes into F; which can be passed in. more at http://joearms.github.io/2013/11/21/My-favorite-erlang-program.html

> Also, I find Armstrong's fanaticism grating, and am inherently distrustful of anybody who claims that their community and language has all the good ideas. Because odds are, they're wrong. You might find this[0] blog post by Armstrong interesting, wherein he comments on some things that were/are done wrong in Erlang. I would also argue that this 'fanaticism' is made to look more severe as you can find at least 4 different talks where Armstrong argues for the same things over and over. In any case, Armstrong is actually very humble, which I think seems fairly obvious if you actually watch a few talks and read more than a couple of blog posts by him. Could you point to something specific where you feel Armstrong misrepresents a strong side of Erlang, or is it just a general thing? (Edit: Just to add, I think it should be said that the Erlang team created their favorite language and that it probably represents the most useful language in use today to them, so I don't think it's surprising that they'd see more good ideas there than in any other language. On top of that Armstrong is a very straight shooter, it seems, so I think this might be something to take into account.) 0 - http://joearms.github.io/2013/05/31/a-week-with-elixir.html