Reactive Systems & MicroServices Architecture
You need to implement a fault-tolerant, scalable, soft, real-time system with requirements for high availability. It has to be event driven and react to external stimulus, load, and failure. It must always be responsive. You have heard many success stories that suggest Erlang is the right tool for the job. And indeed it is - but while Erlang is a powerful programming language, on its own, it's not enough to group these features together and build complex reactive systems. To get the job done correctly, quickly, and efficiently, you also need middleware, reusable libraries, tools, design principles, and a programming model that tells you how to architect and distribute your system.
In this tutorial, we will look at the steps needed to design scalable and resilient systems. The lessons learnt apply to Erlang, but are in fact technology agnostic and could be applied to most stacks, including Scala/AKKA, Elixir/OTP and others.
Outline/Structure of the Workshop
- Distribution: This section covers how to break up your system into manageable microservices. How do you collect these micro services into nodes, which together form distributed architectural patterns, giving you your end-to-end system? What network connectivity do you use to let them communicate with each other?
- Interfaces and state: This section covers how you define your service interfaces. What data and state do you distribute across your nodes, clusters, and data centers? And if requests fail across nodes, what is your recovery strategy?
- Availability: You need at least two computers to make a fault-tolerant system. When dealing with fault tolerance, you have to make decisions about resilience and reliability. This section covers techniques needed to make sure your system never fails and the trade-offs you need to make in your design.
- Scalability: When you picked your distributed pattern, decided how to distribute your data, and made choices on fault tolerance, resilience, and reliability, you also made trade-offs on scalability. This section covers the decisions you have to make and how they affect scalability, as well as how to deal with capacity planning, load regulation, and back pressure.
- Visibility: This section covers the importance of visibility on both a business level and a system level. To achieve five-nines availability, you need preemptive support and automation. To trigger automation, you need to know the state of your system and be able to react to it as quickly as possible. This includes metrics, alarms, and notifications.
- We will look at the steps needed to design scalable and resilient systems.
- The lessons learnt apply to Erlang, but are in fact technology agnostic and could be applied to most stacks, including Scala/AKKA, Elixir/OTP and others.
Developers and Architects building high scalability applications
schedule Submitted 3 years ago
People who liked this proposal, also liked:
Francesco Cesarini - An Introduction to Erlang - From behind the TrenchesFrancesco CesariniFounder & Technical DirectorErlang Solutions
schedule 3 years agoSold Out!
Erlang is a programming language designed for the Internet Age, although it pre-dates the Web. It is a language designed for multi-core computers, although it pre-dates them too. It is a “beacon language”, to quote Haskell guru Simon Peyton-Jones, in that it more clearly than any other language demonstrates the benefits of concurrency-oriented programming. In this talk, I will introduce Erlang from behind the trenches. By introducing the major language constructs, describe their benefits and discuss the problems Erlang is ideal to solve. I will be doing so from a personal prospective, with anecdotes from my time as an intern at the Ericsson computer science lab at a time when the language was being heavily influenced and later when working on the OTP R1 release.
Francesco Cesarini - Concurrent Languages are FunctionalFrancesco CesariniFounder & Technical DirectorErlang Solutions
schedule 3 years agoSold Out!
The functional paradigm has been influencing mainstream languages for decades, making developers more efficient whilst helping reduce software maintenance costs. As we are faced with a programming model that needs to scale on multi-core architectures, concurrency becomes critical. In these concurrency models, the functional programming paradigm will become even more evident. To quote Simon Peyton Jones, future concurrent languages will be functional; they might not be called functional, but the features will be.
Using his 20 years of programming and teaching Erlang/OTP, Francesco will walk through the functional programming features that make implementations of the actor model viable in the Erlang ecosystem. These are features we might take for granted or do not think about, but have laid the foundation of multi-core and distributed programming, influencing programming languages, old and new.