I am thrilled to announce that
@ManningBooks
has decided to publish Thinking in Distributed Systems
Writing this book was challenging but rewarding. Your support, your feedback and comments kept me motivated throughout.
Thank you ❤️
I am writing a book on Thinking in Distributed Systems
12 chapters, one chapter per month, full of diagrams, illustrations, and examples.
#ThinkingInDistributedSystems
#Goals2023
Fascinating paper: Event-Based Programming without Inversion of Control demonstrates how to implement a procedure-based programming model atop an event-driven execution model
Great read if you want to explore async programming
Systems Distributed boasts an absolutely incredible line up of speakers, so time to brush up my database skills
@ifesdjeen
, the author of Database Internals, is a speaker, too 🏴☠️
'Principles of Distributed Database Systems' introduced me to the intriguing idea of 'logical' vs 'physical' levels.
A replicated data item x has a number of copies x₁,...,xₙ. We refer to x as logical item and the replicas as physical items.
#ThinkingInDistributedSystems
One year ago I decided to write 𝗧𝗵𝗶𝗻𝗸𝗶𝗻𝗴 𝗶𝗻 𝗗𝗶𝘀𝘁𝗿𝗶𝗯𝘂𝘁𝗲𝗱 𝗦𝘆𝘀𝘁𝗲𝗺𝘀. Today, I'm working on wrapping up the final chapter, all about Cloud & (Micro)Services
Thank you for being part of this journey
❤️❄️
The CAP Theorem is the most famous impossibility result in distributed systems.
However, CAP may also be the most misunderstood statement about distributed systems
So if someone drops the CAP bomb on you, remember what CAP actually says
💣👇
#ThinkingInDistributedSystems
Js is non-blocking i.e. maps virtual threads to one single physical thread & doesn't block when a virtual thread awaits
My toy runtime is blocking i.e. maps a virtual thread to a physical thread & blocks when a virtual thread awaits
Blog post incoming
𝗛𝗼𝘄 𝘁𝗼 𝗴𝗲𝘁 𝘀𝘁𝗮𝗿𝘁𝗲𝗱 𝘄𝗶𝘁𝗵 𝗗𝗶𝘀𝘁𝗿𝗶𝗯𝘂𝘁𝗲𝗱 𝗦𝘆𝘀𝘁𝗲𝗺𝘀 𝗶𝗻 𝟮𝟬𝟮𝟰
The goal is not to simply know what the experts know but to think like the experts think
𝗕𝘂𝗶𝗹𝗱 𝗮 𝗱𝗶𝘀𝘁𝗿𝗶𝗯𝘂𝘁𝗲𝗱 𝘀𝘆𝘀𝘁𝗲𝗺𝘀 𝗯𝗿𝗮𝗶𝗻
A distributed systems brain is
The author masterfully constructs the data structures powering a database from the ground up.
Including the worlds simplest database consisting of two bash functions
A joy to read
Wer Ordnung hält ist nur zu faul zum Suchen
- Designing Data-Intensive Applications,
@martinkl
Time to embrace my dad's favorite proverb and refresh my knowledge on LSM Trees and SSTables
P.S. One look at Dad's office and you'd know he wasn't lazy 👀
Chapter 4 System models and order and time of my book Think Distributed Systems was just released
Now available on MEAP (
@ManningBooks
Early Access Program)
I am thrilled to announce that
@ManningBooks
has decided to publish Thinking in Distributed Systems
Writing this book was challenging but rewarding. Your support, your feedback and comments kept me motivated throughout.
Thank you ❤️
Building failure tolerant distributed systems starts with understanding idempotence
Idempotence refers to the property that requests can be retried without causing unintended consequences
Who is responsible to guarantee idempotence?! The downstream or the upstream?!
I just finished crossing all the t’s and dotting all the i’s, the first chapter of Thinking in Distributed Systems drops Tuesday 📕
I am so excited and at the same time so anxious I don’t think I will get any sleep for the next two nights 😅
I am thrilled to share that I've decided to start my own company in the cloud & distributed system space
🚀
Can't wait to share more details on the new venture and about its vision soon
🎉
#ThinkingInDistributedSystems
#NewBeginnings
4th chapter of Thinking in Distributed Systems just dropped 🚀
We will explore message delivery and message processing
Let's jump into
☝️at-most once,
☝️at-least once, &
✌️exactly once
💌
#ThinkingInDistributedSystems
#Goals2023
I'm so happy about your responses to my book launch, your encouragement has lit up my day ✨
I've tried to reply to everyone who reached out, but if I missed your message, please know your kind words mean a lot.
Thank you for your incredible support
I am thrilled to announce that
@ManningBooks
has decided to publish Thinking in Distributed Systems
Writing this book was challenging but rewarding. Your support, your feedback and comments kept me motivated throughout.
Thank you ❤️
Working on 𝘁𝗵𝗲 𝗳𝗶𝗻𝗮𝗹 𝗰𝗵𝗮𝗽𝘁𝗲𝗿 of Thinking in Distributed Systems. I will share my mental models for
• 𝗰𝗹𝗼𝘂𝗱 𝗰𝗼𝗺𝗽𝘂𝘁𝗶𝗻𝗴
• 𝗰𝗹𝗼𝘂𝗱 𝗻𝗮𝘁𝗶𝘃𝗲 𝗰𝗼𝗺𝗽𝘂𝘁𝗶𝗻𝗴
• 𝘀𝗲𝗿𝘃𝗲𝗿𝗹𝗲𝘀𝘀 𝗰𝗼𝗺𝗽𝘂𝘁𝗶𝗻𝗴
• 𝗺𝗶𝗰𝗿𝗼𝘀𝗲𝗿𝘃𝗶𝗰𝗲𝘀
Thinking about Distributed Systems and Message Loss?!
Although TCP is considered a reliable protocol, TCP will *not* save you!!
📨🕳️👇
#ThinkingInDistributedSystems
#Goals2023
With the CAP Theorem out of the picture, is there a better framework for thinking about tradeoffs in distributed systems?!
My favorite, Invariant confluence, is presented in the paper Coordination Avoidance in Database Systems
(Link in blog)
If you're fascinated by hierarchies, organizations, and systems thinking, I highly recommend Thinking in Systems by Donella Meadows.
A great read for understanding complex systems 🏴☠️
There is a great word in German, Identitätsstiftend, or Identity Establishing - Identity establishing properties are properties that contributes to establishing or defining an identity.
What gives an object identity and integrity, especially if that object is made up of other
If you are into distributed systems
@TigerBeetleDB
is a treasure trove full of concepts to explore 🪙
For example, did you know that the beetle was inspired by the LMAX Architecture?!
Systems Distributed '24 is a wrap, looking forward to Systems Distributed '25 🏴☠️
Next week, I'll share some highlights with references to papers and videos. Join me in exploring distributed systems together
But first, some downtime 🌴
Personally, I do prefer the lens of Set Theory and First Order Logic to reason about concurrent, distributed systems
Check out Leslie Lamport's A Science of Concurrent Programs (draft)
Distributed Computing through Combinatorial Topology offers a unique and fascinating perspective on distributed systems
But I'm finding the combinatorial topology concepts challenging to wrap my head around-Doesn't come easy to me
Amod references one of my favorite papers on the topic, Computational Thinking by Jeannette M. Wing
Computational thinking is using abstraction, modeling the relevant aspects of a problem to make it tractable
❤️
Transactions are rooted in the world of database systems, not in the world of distributed systems.
Why is the topic of transactions so prevalent in distributed systems?
🧐🧵
#ThinkingInDistributedSystems
#Goals2023
Some actions can be made idempotent by frameworks, but not all actions
The paper Fault Tolerance via Idempotence introduces the idempotence monad, making database actions idempotent by recording them within the same transaction
Clever but not universal
I get frustrated by claims of automatic idempotence in frameworks or platforms.
To handle idempotence of arbitrary actions correctly end to end, every upstream component has to cooperate
Anyone claiming otherwise is overpromising and underdelivering
Once you get started, super, super hard to put this book down 📖 🤓
The author explores the nature of building models upon models or abstractions upon abstractions.
The very essence of the creative process in software engineering ♥️
Systems Distributed boasts an absolutely incredible line up of speakers, so time to brush up my database skills
@ifesdjeen
, the author of Database Internals, is a speaker, too 🏴☠️
The 2nd 𝗦𝘆𝘀𝘁𝗲𝗺𝘀 𝗗𝗶𝘀𝘁𝗿𝗶𝗯𝘂𝘁𝗲𝗱 is is officially set in New York City for June 27-28
I'll be presenting 𝗗𝗶𝘀𝘁𝗿𝗶𝗯𝘂𝘁𝗲𝗱 𝗔𝘀𝘆𝗻𝗰 𝗔𝘄𝗮𝗶𝘁, a programming model for distributed applications
Don’t miss out—get your tickets now! 🏴☠️
If you want to master the theory and practice of Failure Tolerance, start with Jim Gray's foundational paper A Transaction Model from 1980
Incredible mental clarity
Link 👇
Distributed Computing through Combinatorial Topology offers a unique and fascinating perspective on distributed systems
But I'm finding the combinatorial topology concepts challenging to wrap my head around-Doesn't come easy to me
I am super excited to publish my latest blog post 𝗧𝗵𝗲 𝗠𝗲𝗰𝗵𝗮𝗻𝗶𝗰𝘀 𝗼𝗳 𝗔𝘀𝘆𝗻𝗰 𝗔𝘄𝗮𝗶𝘁 🏴☠️
I figured a post exploring the mechanics of functions, promises, and the event loop would be a fun read
Link to blog post & repo in replies
Minimal mental models don't have to be vague, minimal mental models can be absolutely precise:
A system contains a race condition if the concurrent composition of its processes contains some interleaving that is considered incorrect. 🏴☠️
Do you want to excel in distributed systems?! My advice: Learn formal methods
How to get started?!
Formal methods are powerful thinking tools, helping you analyze complex problems with accurately and concisely
A few basic concepts are enough to get started to think about
I just finished Chapter 12, the 𝗳𝗶𝗻𝗮𝗹 𝗰𝗵𝗮𝗽𝘁𝗲𝗿 of Thinking in Distributed Systems 🎉
Experiencing a mix of emotions, a touch overwhelmed, but super happy 😭❤️
Literally turning the last page of 2023
#ThinkingInDistributedSystems
Raft Consensus Challenge ⛓️
We have a Raft cluster with 3 nodes, each maintaining a replica of the log.
Which node is the leader for term 3?! What gives it away?!
#ThinkingInDistributedSystems
#ConsensusChallenge
6th chapter of Thinking in Distributed Systems just dropped 🚀
We will explore distributed transactions and the most well-known atomic commit protocol: The 2 Phase Commit Protocol
#ThinkingInDistributedSystems
#Goals2023
I am thoroughly impressed with
@modal_labs
and their developer experience, it's truly incredible
Check out the New York Cab dataset example, analyzing gigabytes of data using
@duckdb
– in parallel, in the cloud, all by adding a python decorator
🔥
Thanks to everyone who expressed interest in the live stream on Event-Driven Architecture 🎉
We'll cover core concepts and defining characteristics, focusing on the fundamentals
Stay tuned for the details 📅
Anybody interested in a live stream on Event-Driven Architecture?
We'll take a principled look at its core concepts, building a solid understanding of its defining characteristics.
No 'why event-driven is better', just the fundamentals
3rd chapter of Thinking in Distributed Systems just dropped 🚀
We will explore failure, failure tolerance, and failure handling
Ready to think about failure?! 🔥🧯
#ThinkingInDistributedSystems
#Goals2023
The next generation of reliable and scalable distributed systems will be based on the fundamental models computation: functions & promises
Introducing Durable Promises, an open standard for reliable and scalable distributed systems
Sometimes idempotence is straightforward e.g. in the case of transactions
The paper Fault Tolerance via Idempotence features an idempotence monad recording the result of a step alongside the step itself
Not into monads? A Python decorator can work too
Any project that promises to guarantee exactly-once processing for you effectively promises to guarantee idempotence of arbitrary side effects for you
That's impossible
Idempotence is an end-to-end guarantee, you need the cooperation of the upstream system(s)
Technologies
While building 𝗗𝗶𝘀𝘁𝗿𝗶𝗯𝘂𝘁𝗲𝗱 𝗔𝘀𝘆𝗻𝗰 𝗔𝘄𝗮𝗶𝘁, I studied lots of academic papers on async await & related concepts
My goal? To craft a programming model that is coherent, guaranteeing a delightful developer experience
Some insightful papers for your weekend
The evolution of concurrent programming models 🧵
Here's a curated list of seminal papers that explore the two dominant models: thread-based & event-based concurrency.
These models converge in async await, combining the best of both worlds.
Maybe I try to faithfully adapt Jim Gray's paper 𝗔 𝗧𝗿𝗮𝗻𝘀𝗮𝗰𝘁𝗶𝗼𝗻 𝗠𝗼𝗱𝗲𝗹 to Durable Function & Durable Promises instead of transactions
𝗔 𝗗𝘂𝗿𝗮𝗯𝗹𝗲 𝗔𝘀𝘆𝗻𝗰 𝗔𝘄𝗮𝗶𝘁 𝗠𝗼𝗱𝗲𝗹
One of the *best* papers I have *ever* read - not being dramatic - is Jim Gray's "A Transaction Model" from 1980
❤️ Crystal clear
❤️ Rigorous yet approachable
I am completely enamored 🫠
I am working on a proof of concept,
@TigerBeetleDB
style.
The POC is written in Golang but does not use Golang's user space concurrency (go functions)
Instead, the POC uses a custom event loop, coroutine-like concurrency, & implements deterministic simulation testing
🔥
One of the *best* papers I have *ever* read - not being dramatic - is Jim Gray's "A Transaction Model" from 1980
❤️ Crystal clear
❤️ Rigorous yet approachable
I am completely enamored 🫠
There are many insightful resources about Event-based Programming-but finding them can be challenging
Protothreads: Simplifying Event-Driven Programming of Memory-Constrained Embedded Systems is a fantastic addition to yesterday's read
I got Transaction Processing: Concepts and Techniques by Jim Gray and Andreas Reuter today 🏴☠️
𝗙𝘂𝗻 𝗙𝗮𝗰𝘁
The ACID acronym was coined by Andreas Reuter and is a pun on the fact that his wife hates sweet things and loves vinegar 🧪
Anybody interested in a live stream on Event-Driven Architecture?
We'll take a principled look at its core concepts, building a solid understanding of its defining characteristics.
No 'why event-driven is better', just the fundamentals
Check out my new blog post introducing 𝗗𝗶𝘀𝘁𝗿𝗶𝗯𝘂𝘁𝗲𝗱 𝗔𝘀𝘆𝗻𝗰 𝗔𝘄𝗮𝗶𝘁
Distributed Async Await extends the traditional async await programming model and makes distributed computing a first-class citizen
Distributed systems require a dual perspective: The global view and local view.
In his dissertation,
@famontesi
calls breaking down the global (choreographic) view into the local (endpoint) views endpoint projection
Great mental model to reason about distributed systems
Jim Gray's paper A Transaction Model is a masterclass in thinking above the code.
With a minimal system and failure model, Gray conveys the essence of transactions with exceptional clarity
Gaining knowledge & understanding doesn't rely on implementing
As software engineers, we romanticize implementing something ourselves-as though implementing guarantees mastery
Yet our learning projects fall flat: buggy, underspecified, unexplored edge cases, leading to misguided conclusions
Think above the code
There are many insightful resources about Event-based Programming-but finding them can be challenging
Protothreads: Simplifying Event-Driven Programming of Memory-Constrained Embedded Systems is a fantastic addition to yesterday's read
Fascinating paper: Event-Based Programming without Inversion of Control demonstrates how to implement a procedure-based programming model atop an event-driven execution model
Great read if you want to explore async programming
Personal update.
After two years, I have decided to leave
@temporalio
. My last day is Friday 5/19
A bittersweet moment, I am sad to leave but I am also excited for the next adventure
First I will take a breath & fight a tear 😮💨 🥲
♥️
Prediction: Within 3 years, Durable Executions a.k.a Workflows as Code will become a commodity.
Every technology stack will offer Durable Executions, either as a library, compiler extension, or runtime extension.
🔥
#DurableExecutions
#DistributedSystems
There are 𝟯 𝗱𝗶𝗳𝗳𝗲𝗿𝗲𝗻𝘁 𝗱𝗶𝗺𝗲𝗻𝘀𝗶𝗼𝗻𝘀 in play:
• Synchronous vs Asynchronous
• Sequential vs Concurrent
• Serial vs Parallel
These terms and concepts are not interchangeable
#ThinkingInDistributedSystems
#Zelda
If you are looking for the ideal blend of approachable introduction & academic rigor check out
@lindsey
's lecture series on distributed systems.
🍸🎓
Today's featured video: Introduction to partitioning & consistent hashing
For my upcoming blog post 𝗧𝗵𝗲 𝗠𝗲𝗰𝗵𝗮𝗻𝗶𝗰𝘀 𝗼𝗳 𝗔𝘀𝘆𝗻𝗰 𝗔𝘄𝗮𝗶𝘁, I relied on numerous sources to come to a sound mental model of Async Await, functions, and promises.
Find a curated collection in the replies 🏴☠️
Mastering Failure Tolerance in Distributed Systems
Part 1
A defining characteristic of distributed systems is the possibility of partial failure [1].
A key requirement is failure tolerance i.e. an execution with failures is equivalent to some execution without failures [2].
A
Turing Awardee Leslie Lamport on time and causality. A concise articulation why time is not linear and why concurrency cannot be fully abstracted
Link in reply
5th chapter of Thinking in Distributed Systems just dropped 🚀
We will explore the magic of transactions: Transactions allow you to pretend that concurrency or failure does not even exist! 🪄 💫
#ThinkingInDistributedSystems
#Goals2023
In his paper "Verifying Strong Eventual Consistency in Distributed Systems",
@martinkl
presents an accurate, concise, and delightfully elegant model of distributed systems.
How accurate you ask? Formally verified with
@isaprover
(My favorite: Section 5)
My 𝗯𝗿𝗲𝗮𝗸𝘁𝗵𝗿𝗼𝘂𝗴𝗵 moment in understanding distributed systems was
@martinkl
's post How to do distributed locking:
A system needs to guarantee global invariants but every component has only local knowledge informing its actions
What was your breakthrough moment?
A billion SMT queries a day by Neha Rungta
SMT solvers are not only used to solve word puzzles but are used by the largest cloud provider to prove correctness to its end users.
I had a lot of fun exploring solving a Word Search puzzle with Python and Z3.
Anybody interested to read about encoding a problem with an SMT solver and finding a solution in the next issue of my newsletter The Weekend Read?!
🌀𝗕𝘂𝗶𝗹𝗱𝗶𝗻𝗴 𝗮 𝗱𝗶𝘀𝘁𝗿𝗶𝗯𝘂𝘁𝗲𝗱 𝘀𝘆𝘀𝘁𝗲𝗺𝘀 𝗯𝗿𝗮𝗶𝗻 🌀
𝗤
How should we think about distributed software systems?!
𝗔
As a 𝗦𝘁𝗮𝘁𝗲 𝗠𝗮𝗰𝗵𝗶𝗻𝗲. The behavior is a sequence of states and a step transitions the distributed system from the previous state
The Terms 𝗮𝘀𝘆𝗻𝗰𝗵𝗿𝗼𝗻𝗼𝘂𝘀 and 𝗻𝗼𝗻-𝗯𝗹𝗼𝗰𝗸𝗶𝗻𝗴 are often used synonymously, however, they are not 🛑
Understanding async and non-blocking requires us to reason across across two levels: execution & runtime
𝗘𝘅𝗲𝗰𝘂𝘁𝗶𝗼𝗻 𝗟𝗲𝘃𝗲𝗹
Asynchronous executions
Distributed transactions, that is, atomic commitment, look a lot like a distributed consensus problem:
All participants must either commit or abort a transaction 👤👤✔️❌
However, atomic commitment is quite different from consensus
👇
#ThinkingInDistributedSystems
#goals2023
A database implementing Viewstamped Replication with Protocol Aware Recovery, zero dependencies, static memory allocation, async i/o, in
@ziglang
Testing every corner case via deterministic simulation testing
When I grow up, I wanna be as cool as
@TigerBeetleDB
🏴☠️✌️
I learn a lot about systems and distributed systems from academic papers - but learning how to read papers is a challenge in itself
How did you get started reading papers, how did you level up?!
#ThinkingInDistributedSystems
#Goals2023
I am looking into the origins of async await and studying "A poor man's concurrency monad"
Adapting to thinking in functions, types, and monads challenges me-but the paper truly is a pearl
Here’s another example of thinking above the code: the TLA+ spec for 2-Phase Commit.
Just 175 lines (mostly comments) represent a complete specification of its behavior, covering each and every edge case.
Beat that with "implementing it yourself"
Jim Gray's paper A Transaction Model is a masterclass in thinking above the code.
With a minimal system and failure model, Gray conveys the essence of transactions with exceptional clarity
Gaining knowledge & understanding doesn't rely on implementing
Working on the final Chpt of Thinking in Distributed Systems, all about Cloud, Serverless, and (Micro)Services
Writing hits different with a snowy background ❄️❤️
#ThinkingInDistributedSystems
The Unreasonable Effectiveness of Consensus in the Distributed Systems
Why is distributed consensus so significant in the context of distributed systems?
Consensus is the bedrock that allows us to 𝗴𝗲𝗻𝗲𝗿𝗶𝗰𝗮𝗹𝗹𝘆 transform a component into a fault-tolerant component.
There are 𝟯 𝗱𝗶𝗳𝗳𝗲𝗿𝗲𝗻𝘁 𝗱𝗶𝗺𝗲𝗻𝘀𝗶𝗼𝗻𝘀 in play:
• Synchronous vs Asynchronous
• Sequential vs Concurrent
• Serial vs Parallel
These terms and concepts are not interchangeable
#ThinkingInDistributedSystems
#Zelda
"Just make your action idempotent". The troubled story of Idempotence
Distributed systems are subject to partial failure. The solution: retries; the prerequisite: idempotence.
To guarantee exactly once processing semantics, we combine at least once processing guarantees and
Durable Executions are not a novel concept, Durable Executions have been around as Sagas
The "breakthrough"? State is being managed on a platform level, transparent to the application level
Check out this visual explanation by
@PatHelland
in Building on Quicksand
Systems Distributed '24 was without a doubt the best conference I’ve attended in my 20+ years career 🏴☠️
Thrilled to present Distributed Async Await to this incredible audience. An unforgettable experience
Systems Distributed '24 is a wrap, looking forward to Systems Distributed '25 🏴☠️
Next week, I'll share some highlights with references to papers and videos. Join me in exploring distributed systems together
But first, some downtime 🌴
Over the next few days, I'll share some mental models and resources about distributed systems that I wish I had known about when starting my journey
𝗟𝗲𝘁'𝘀 𝗯𝘂𝗶𝗹𝗱 𝗮 𝗱𝗶𝘀𝘁𝗿𝗶𝗯𝘂𝘁𝗲𝗱 𝘀𝘆𝘀𝘁𝗲𝗺𝘀 𝗯𝗿𝗮𝗶𝗻 𝘁𝗼𝗴𝗲𝘁𝗵𝗲𝗿
#Goals2024
𝗛𝗼𝘄 𝘁𝗼 𝗴𝗲𝘁 𝘀𝘁𝗮𝗿𝘁𝗲𝗱 𝘄𝗶𝘁𝗵 𝗗𝗶𝘀𝘁𝗿𝗶𝗯𝘂𝘁𝗲𝗱 𝗦𝘆𝘀𝘁𝗲𝗺𝘀 𝗶𝗻 𝟮𝟬𝟮𝟰
The goal is not to simply know what the experts know but to think like the experts think
𝗕𝘂𝗶𝗹𝗱 𝗮 𝗱𝗶𝘀𝘁𝗿𝗶𝗯𝘂𝘁𝗲𝗱 𝘀𝘆𝘀𝘁𝗲𝗺𝘀 𝗯𝗿𝗮𝗶𝗻
A distributed systems brain is
I can't believe it took me this long to realize that a non-distributed, single-process system considering crash failures and recovery shares so many characteristics with distributed systems.
Is a non-distributed app that mitigates process crashes by restarting and recovering a distributed app?!
On crash, a process restarts and recovers. Therefore, the app involves multiple processes (restart) that are coordinated (recover)
A characteristic of distributed systems
If you are interested in exploring 𝗥𝗮𝗰𝗲 𝗖𝗼𝗻𝗱𝗶𝘁𝗶𝗼𝗻𝘀 & 𝗗𝗮𝘁𝗮 𝗥𝗮𝗰𝗲𝘀, I recommend Testing for Race Conditions via SMT Solving
Not only will you find rock solid definitions but also one of the coolest applications of SMT solving
🪨🧊
New video dropped on
@resonatehqio
's YouTube channel
𝗥𝗮𝗰𝗲 𝗖𝗼𝗻𝗱𝗶𝘁𝗶𝗼𝗻𝘀
Frequently race conditions are not formally defined but introduced in terms of an example. In this video, we will explore an actual definition.
Top priority for Resonate is reliability-reflected in our testing strategy
Server Side
💣 Internal Deterministic Simulation Testing
💣 External Simulation Testing
Includes Linearizability checks
SDK Side
💣 Exhaustive Test Case Generation
Based on State Transition Table