Joe Armstrong Quotes

The cornerstones of fault tolerant programming are to isolate errors to make sure if one thing crash it does not crash anything else. That's what the processes in operating system do.

What did it work for this guy and not for me? Well, it's because machines were in different states when we performed those operations. The number of possible state of the machine is a really great number.

Sometimes changing one line of legacy code is incredibly difficult than totally rewriting the entire stuff.

In Erlang, F(G(X)) is used for small steps. Pipes are used for big steps. The big steps semantics is processes. It's messages between processes. Processes are used for big computation. When you got F(G(X)) is a small step, and we map small steps on the same core. We map big steps on processes. Processes map on multi-core. The system just does it for you.

Let me just say something about pipes. The great UNIX philosophy was: the output of my program should be the input to your program, to compile things together.

Hidden state in object so in any object programming language means you can't compose things. Hidden state is a just state effect stopping you to composing things.

I was using Smalltalk and I never actually go through this boundary of sort of simulating the class structure in my head so that I can program itself. It was painful, I used to chose the changelog to find things, I regret you did it.

Google knows everything about us but we know nothing about Google.

Object oriented programming asked you to put things into categories, into classes. Concurrency oriented programming asks you to identify the concurrency and the problem. The concurrence in the problem is a property of the real world. If you are doing real world modeling you can see it, you can smell it, you can eat it

If you imagine the combination of petabytes memories with LiFi and communication at tens of gigabits per second but the combination and like 10,000 Cray-Ones and a little thing like your fingernail everywhere in every single light bulb that’s like an atomic bomb hitting software. What we’re going to do with it, nobody’s got a clue.

If you managed to scale horizontally, you can scale.

Don't be deluded into thinking that is sort of ultimately fault tolerant. You can only provision it for the faulty things that might happen and then for a large class of things it could happen.

So what's wrong with the shell? and what's wrong with Erlang? It's not LISP!

Meta-Programming Erlang is not really easy because of the way the trees are parsed.

One of the things we’ve forgotten, is the importance of protocols and not describing them accurately.