Mutability × Time: The Compound Risk series.
Proven techniques for containing the compound risk of mutable state over time. From theoretical patterns to a successful real-world refactoring that eliminated invisible coupling.
Mutability × Time: The Compound Risk series.
Why components become secretly coupled through shared mutable state. Examines how invisible dependencies erode trust and create debugging nightmares separated by both code and time.
Mutability × Time: The Compound Risk series.
The anatomy of object decay over time. Examines how instances progress through Birth, Initialization, Drift, Contamination, and Corruption—and why each stage compounds the previous problems.
Mutability × Time: The Compound Risk series.
Why longer-lived mutable instances become exponentially more dangerous over time. Explores the counterintuitive relationship between object longevity and system reliability through a real-world state management failure.
Developing a successful software architecture is simple, but it’s not easy. Understanding QARs and then understanding and making the trade-offs that will maximally satisfy the QARs takes insight and experience, much of which has to be gathered through iterative experimentation on the architecture itself. The process itself is simple, but the trade-offs that need to be considered are often tough, and there are seldom easy answers.
Far from a controversial choice, Kafka is now a technology developers and architects are adopting with enthusiasm. And it’s often not just a good choice, but a technology enabling meaningful improvements in complex, evolvable systems that need to respond to the world in real time. But surely it's possible to do wrong! In this talk, we'll look at common mistakes in event-driven systems built on top of Kafka: -Deploying Kafka when an event-driven architecture is not the best choice. -Ignoring schema management. Events are the APIs of event-driven systems! -Writing bespoke consumers when stream processing is a better fit. -Using stream processing when you really need a database. -Trivializing the task of elastic scaling in all parts of the system. It's highly likely for medium- and large-scale systems that an event-first perspective is the most helpful one to take, but it's early days, and it's still possible to get this wrong. Come to this talk for a survey of mistakes not to make. Lecture took place on Wednesday 25th August 2021 at 13:30 in Room 1 Tim Berglund is a teacher, author, and technology leader with Confluent, where he serves as the Senior Director of Developer Advocacy. He can frequently be found at speaking at conferences in the United States and all over the world. He is the co-presenter of various training videos on topics ranging from Git to Distributed Systems to Apache Kafka. He tweets as @tlberglund, blogs very occasionally at http://timberglund.com, and lives in Littleton, CO, USA with his wife, their three children having grown up. Topics covered: -What is Event-Driven Architecture -Data Mesh Principles -Scaling -State management
Best practices for beautiful intelligible code - PyCon 2015