Aleksandr Tavgen

Amount of data that web scale systems produce is constantly growing.

Proliferating of mobile and smart devices moves requirements towards the sky in terms of throughput, and in the same way we want to operate on data flow in near real time fashion. Near future will bring the 5G standard, and more and more IoT devices will produce more and more data. It is not only related to the software systems, but physical devices as well. Today, projects in the areas of logistics and smart cities are our new reality. And as a result, we need systems that can drink from a firehose.

Building a high-performance streaming platform is not an easy task and the CAP theorem makes it even more challenging. Having unpredictable network delays means that we can receive signals from the past.

And there is always a tradeoff between performance and consistency. There is a lot of streaming frameworks such as Storm and Flink, but they have some fundamental limitations that sometimes make their usage problematic.

This talk is centered on the architectural challenges and best approaches in building high-performance event-driven streaming systems, and covers topics such as:

• Reactive and Functional revolution
• Data-centric thinking and Functional approach on architectural level
• Reactive programming on service level with non-blocking execution
• Events as a state change and what is CQRS and when we need that?
• Streaming architectures as combined functions (Pattern Matching vs. Contracts/Protocols)
• CAP theorem and related problems
• Do we always need Kafka and what are the alternatives?
• Common architectural patterns for high-speed stream processing
• Performance measurements for different approaches with an explanation

Discussion on the best architectural approaches is illustrated by examples of the challenges of building a streaming platform for observability on large scale for timeseries data. Example case is implemented as Java microservices with Reactive Streams, Message Queue and Time-Series storage.

One of the key trends in software infrastructure in 2019 is Observability.

It has gained a lot of attention recently. Some say that this is overhyped and there is a lot of jokes around it

• Why call it monitoring? - Because that’s not sexy anymore.
• “The new Chuck Norris of DevOps.”

But taking things seriously, we are in the middle of a paradigm shift.

The main paradigm shift came from the fields of infrastructure and architecture. Cloud architectures, microservices, Kubernetes, and immutable infrastructure changed the way companies build and operate systems.

As a result of the adoption of these new ideas, the systems we have built have become more and more distributed and ephemeral.

Virtualization, containerization and orchestration frameworks are responsible for providing computational resources and handling failures, and create an abstraction layer for hardware and networking.

As we are moving towards abstracting away from the underlying hardware and networking, we must focus on ensuring that our applications work as intended in the context of our business processes.

The main issue is that the amount of possible problems in production cannot be fully covered with tests in any way. Most of the problems arising in a mature and stable system are “unknown unknowns” that are related not only to the software development itself, but also to the real world.

A lot of companies have failed in their attempts to build modern telemetry on top of their systems. A lot of anti-patterns have been developed.

This presentation will uncover common anti-patterns and explain the essentials needed to build an observability, with a lot of pitfalls on the way.

• Why the 9 billion metrics that Uber collects is a failure? Why sometimes less is better?
• What is the cost of an incident/outage and why the dashboards are sometimes useless?
• What are the main issues when operating on scale and what makes your DevOps happy?
• Why we are not ready yet for fully automated solutions and why deep learning doesn’t fit large-scale operation?

This presentation will show some of the approaches which reduced Customer Detection of incidents to some insignificant percentage on scale, using applied Machine Learning built on top of Open Source products. It will cover topics from metrics as a low-resolution representation of system dynamics, to high-resolution distributed tracing (OpenTracing and OpenTelemetry), and events as a logical unit of work, with real production examples.”