Distributed systems showdown — TLA+ vs real code

Workshop. Lincheck: Testing concurrency on the JVM (part 1)

Serverless nature of Yandex Database

Apache Ignite 3: GridGain everyday work

Data parallelism from a multicore perspective

Workshop. Lincheck: Testing concurrency on the JVM (part 2)

Algorithms for practical distributed agreement

What we talk about when we talk about distributed systems

Designing fast lock-free algorithms by understanding cache coherence dynamics

Workshop: TLA+ in action (part 1)

Theoretical and practical worlds of failure detectors

Simplifying global-scale strong consistency

Workshop: TLA+ in action (part 2)

Workshop: Java Concurrency Stress (JCStress) (part 1)

CAP Theorem — two decades and few clouds later

Workshop: TLA+ in action (part 3)

Workshop: Java Concurrency Stress (JCStress) (part 2)

Fearless global transactions with CockroachDB

Workshop: TLA+ in action (part 4)

Co-designing Raft + thread-per-core execution model for the Kafka-API

The hitchhiker's guide to distributed transactions

Building scalable and flexible cluster managers using declarative programming

The official ten-year retrospective of NewSQL databases

Multithreading in UI application: When some threads are more equal than others

Programming language memory models: Problems, solutions, and directions

Paxos vs Raft: Have we reached consensus on distributed consensus?

CRDTs: The hard parts

Oak: A scalable off-heap allocated key-value map

Efficient and reliable microservices

Safe user-level sharing of memory-mapped resources

Interview and Q&A with Alex Petrov

Wait-free memory reclamation and data structures

Transactional memory

Designing distributed systems with TLA+

Interview and Q&A with Cindy Sridharan

Erasure Coding at Scale

Synchronization primitives can be faster with SegmentQueueSynchronizer

HTAP made live — from the engineering perspective

Distributed and concurrent optimization for machine learning

Scaling distributed ledgers: Achieving arbitrary throughput and sub-second latency

Demystifying Bitcoin

New locks for the old kernel

Tissue vs silicone musings on the future of deep learning hardware and software

Redundancy does not imply fault tolerance: Analysis of distributed storage reactions to single errors and corruptions

Debugging data races

Java threads are losing weight performance review of Project Loom

Extending PostgreSQL to Google Spanner architecture

The Azul Hardware Transactional Memory experience

Weak memory concurrency in C/C++11

Not all ML algorithms go to distributed heaven

Liberating distributed consensus

Go scheduler: Implementing language with lightweight concurrency

Reduce your storage costs with Transient Replication and Cheap Quorums

Accelerating distributed graph analysis by means of probabilistic sketches (and not only them)

Structured concurrency

Yandex Database — how we guarantee fault tolerance

Blockchains and the future of distributed computing

Syncing data across user devices for distributed collaboration

Q & A

Lin-Check: Testing concurrent data structures in Java

Wait-free data structures and wait-free transactions

Distributed transactions in YDB

The H2O distributed K/V algorithm

The cost of distributed transactions between arbitrary databases

Dual data structures