Joe Armstrong Quotes

How many machines boot in 60 milliseconds? When did it come wrong?

The Middle man is the thing that imposed Erlang only in the Erlang world. If people try to talk to each other, the complexity of the program is O(N²). But, if we put middle men here, this turns the complexity to O(N).

Middle men, this is the key abstraction in Erlang. This is the model of the world. Everything in the world is processes. When ever you got any problem what so ever, it does not matter what was of problem is, you put this transducer thing in the middle. It translate the way things talk to each other in the outside world and internally.

If you have know idea where the leak is coming from, you'll want call a professional plumber who will have the equipment to locate the pipes in your walls [...] So, he's talking about software!

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.

The nice thing about pipeline is that quite easy to see and you can do all the steps in the pipeline in parallel.

Instead of handy compose, we'll keep compose exactly the same and will write a little function which takes a function that does not have debugging and return the function that does debugging. And we have a function that accept only one argument, the un-debugging version, we'll add another little function that automatically add an argument to it. When we done that, we can bind call compose on it and everything will work and will be nice. And will be peace on the earth and everybody will have a good time.

We could of course redefine compose to a version of compose that work with debugging with debugging things. That would be horrible. That would mean we would need to compose pure functions. We would need to compose functions for debugging and everything on the planet.

Pipelines is the most important word. So a Monad is a pipeline. It allows you to pipe an output of a function to the input of another function. They rediscover the pipe.

The different ways of hiding the state are the things that different functional programming languages offer. In Haskell they call it monads, in Erlang they call it processes.

Object Oriented Programming, this is the art of hiding side effects. If you can do it successfully you can write this in program. If you do it unsuccessfully, you get in a sucking mess.

In pure functional language, you are not allowed to tinker around with the state, So the state go into your function, something should happen and the state comes out as well. In pure functional language, you got in input and the state, and what's come out is the output and the new state.

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.

In Haskell, C or Java, or any these languages, that function composition will fail at compile time. Type system will say: we'll not allow you to compose things together because the types are wrong. But in Erlang, you can do anything you bloody would feel like just found together and know it at run time not at compile time. Some people think that is not so good. Some people think that is pretty cool. I will tell you why it's pretty cool. It's actually late binding, it makes decision late.

Composing computation. Why do we do compose computation? Because We want to make reusable things out of small things. We take small things to make bigger things.