Francesco Cesarini

Francesco Cesarini is a computer scientist and founder of Erlang Solutions Ltd. He is working in the area of distributed systems.

OTP, the Middleware for Concurrent Distributed Scalable Architectures (2012)

 * OTP, the Middleware for Concurrent Distributed Scalable Architectures Recorded at Code Mesh London in 2012


 * When you are writing a massively complex highly distributed system, you need more just than a language, Erlang is just a programming language. You need architectural patterns, you need to start thinking in term of how you distribute your system.


 * What is the point with OTP? First of all, you get much more less code […] Less bugs […] Much more solid and tested code. Much more deep learning curves […] Performances will be slightly impacted due to the layers.

Immutability is everything (2018)

 * Immutability is everything Recorded at Code Motion Rome, in 2018.


 * By learning them, and understanding their paradigms, and by programming in a functional way, you will end up being much more productive and you're becoming much better programmers.


 * There is two ways basically to deal with concurrency. Mutable state, you must have shared memory, you must have threads, you must have mutexes when you access critical sections. If you are dealing with immutable state, what you do is processes will not share memory. The only way for them to share data is through a message passing that needs to copy the data from one process to another. They'll each have their own copy. So, two completely different paradigms, two completely different results.


 * When you call a function with no side effects, what that means is, every time you call that functions with the same set of values, you always get back that same result. That's immutable state. Mutable state, when you're dealing with shared memory, you call a function with a set of values, you don't know what value you're gonna get back. So you got determinism versus non determinism here.


 * All languages will have side effects. They will have some form of mutability. The whole goal is to try to decrease this mutability as much as possible.


 * What you need to do is to make sure your threads become immutable. So you can change a data within a thread, but if you got two threads communicating with each other, you need to mimic this whole message passing approach. You need to copy the data from one threads to another, avoiding having shared state.


 * What the Sunway TaihuLight, Raspberry Pi and Parallela board have in common? It is the heterogeneous multi-cores. So you have different types of cores, and that's the future of the computers we will working on today. The shift in multi-cores is inevitable.


 * Even if your program is highly parallel, your bottleneck will still be the virtual machine, because you still have schedulers, you still need to process and handle and schedule your different processes.


 * You distribute for scale and you replicate for availability.


 * A system which is strongly available means that it is not reliable because of the reliability you might need to take down the machines. On the other hands if you don't worry about the reliability of your data, as long as you've got a value which is not too old, you can go in and distribute it, and scale that way.