Using cutting-edge modern technologies for real-time communication, you’ll learn how to architect and build a large-scale distributive system that will act as an expandable collaborative environment, capable of handling thousands of users in real-time, allowing them to work together remotely.

In this talk, using cutting-edge and modern technologies for real-time communication, the audience will be able to learn how to architect and build a large-scale distributive system that will act as an expandable collaborative desktop environment, capable of handling thousands of users in real-time and allowing them to work together remotely. In the end, the audience will be able to apply the concept for engineering any multi-user system that requires a robust state synchronization. The overall idea of the concept revolves around efficient server-side management and discovering a way to robustly update it and distribute it to other machines and client devices. Finding such a strategy is not easy and requires a lot of research, benchmarking, and other relevant techniques in order to achieve the best performance for handling such a large number of users. Connecting the fields of system engineering, software engineering, and engineering management, this talk will be a great introduction into many different projects that can be built on the foundation that this talk will bring to the audience in an interesting and challenging way.

For a number of years, artificial intelligence has been at the top of the technology must-watch list for evolving trends and applications. With our ability to build smart machines that simulate human intelligence, the implications for technological advancement across numerous sectors are endless. So, what could be better than artificial intelligence? Embedded artificial intelligence.

Kafka is a distributed messaging system capable of delivering high performance. In my talk I’ll explain the architecture of a broker and client parts, putting emphasis on design concepts enabling high performance. It will be useful for system design and overall understanding of Kafka.

There is not much information available on the net on Apache Kafka architecture, and I would like to fill this gap. In this talk, I’m going to roughly explain the design of distributed messaging in Kafka. To achieve the state of art IO performance, Kafka is making use of page writeback strategy, zero-copy, along with other optimisations on the client and server sides. To my understanding, these optimisations were the main driver of the design of the whole system, protocol, and client APIs. This talk will focus on the concepts responsible for high bandwidth, and will leave out topics of distributed agents coordination, cluster discovery, etc.

This talk will be useful to architects and system programmers for training system design skills and improving overall understanding of Kafka, as well as to those who are using or considering using Apache Kafka.

The main things we are going to discuss are:
- Which architectural decision is making Kafka performant?
- Meaning of efficiency for Kafka
- How to benchmark Kafka
- Theoretical throughput limit
- Large diagram of a message write path
- Overview and design of Kafka Producer client
- Linux writeback
- Read path diagram
- Kafka Consumer client design
- Summary: what makes Kafka efficient

HTTP/2 is a newer version of HTTP protocol that enhances client-server communication with faster speed and efficiency. It also brings new vulnerabilities to the table. In this talk, we will explore the strengths and weaknesses of HTTP/2 and discuss how to protect against common DoS and DDoS attacks.

HTTP/2 is a major upgrade to the HTTP protocol, introducing new features such as binary framing, multiplexing, and server push, which greatly improve the performance and efficiency of web communication. However, the new protocol also brings new vulnerabilities, especially in the context of DoS and DDoS attacks.

In this talk, we will explore the inner workings of HTTP/2, including its benefits and drawbacks, as well as the potential impact of DoS and DDoS attacks on the protocol. We will also discuss common types of attacks that exploit HTTP/2 weaknesses, such as connection flooding and resource exhaustion, and provide practical tips on how to mitigate these risks. We’ll also discuss specific vulnerabilities in the protocol and techniques for mitigating these attacks, such as rate limiting and traffic analysis. By the end of this talk, attendees will have a better understanding of HTTP/2 and how to protect their websites from DDoS attacks.

Is it possible to build strongly consistent storage systems on top of eventual? The short answer is “yes”, and the long answer is “yes, but not really, but maybe, but it depends.”

The industry has introduced distributed transactions with async replication to overcome the limits of write performance. However, with distributed transactions and replica reads, the eventual consistency has been introduced as a caveat. In this talk, we will observe an opportunity to build a strongly consistent caching system on top of the eventually consistent Redis Cluster.

New iteration of the HTTP protocol brings more challenges than previous upgrades. We now need the UDP transport and a different negotiation method; another trouble is the need for embedded security/encryption. You will learn how to implement this protocol in the network, and most importantly - why.

Plan:

– Intro
-- Main differences between HTTP/3 and previous protocols.
-- UDP as a transport.
-- Encryption differences.
-- Connection ID.
-- Protocol negotiation and fallback to other protocols.
-- Use of HTTP/3 in real networks.
-- All the boxes in between a client and a server.
-- Security issues.
-- Implementation in NGINX.
-- Conclusions and questions.

A WebAssembly runtime is an embeddable virtual machine. This allows platforms to dynamically load and execute third party bytecode without rebuilding their OS and Arch specific binary. While WebAssembly is a W3C standard, there are a lot of mechanics required to do this, and many critical aspects are out-of-scope, left to implementation.

Most presentations discuss WebAssembly at a high level, focusing on how end users write a program that compiles to Wasm, with high-level discussions of how a virtual machine enables this technology. This presentation goes the other way round. This talk overviews a function call beginning with bytecode, its translation to machine code, and finally how it is invoked from host code.

The implementation used for discussion is the wazero runtime, so this will include some anecdotes that affect these stages, as well as some design aspects for user functions that allow them to behave more efficiently. However, we will also indulge in a high-level comparison with other runtimes and similar technologies that in the past tried to solve the same problem.

When you leave, you'll know how one WebAssembly runtime implements function calls from a technical point of view.