cotalks.dev

Hydra

YouTube: link

|

Videos (59)

C++ Russia 2022 & Hydra 2022 closing

Roundtable: Concurrency

Interview with Andrey Fomichev

Interview with Vadim Tsesko

Vladislav Stolyarov — Is there life without RTTI or how to write your own dynamic_cast

Artem Aliev — Distributed transactions implementation trade-offs

Vadim Tsesko — OK S3

Stanislav Sidristij — Thread pools: variety of algorithms and features

Andrey Fomichev, Ilnaz Nizametdinov — Parallel Asynchronous Replication b/t YDB Database Instances

Vitaly Aksenov — What about Binary Search Trees?

C++ Russia 2022 & Hydra 2022 in-person opening

Anton Malakhov — Fusing Efficient Parallel For Loops with a Composable Task Scheduler

Pavel Emelyanov — Exploring Traffic Jams in Your Data Flows

Janna Burman — Self-stabilizing Population Protocols

Summing Up Online Hydra 2022

Hydra's Heads: Dmitriy Ivanov

Alexander Kirsanov — Making a desktop IDE distributed and collaborative

Roundtable: Cloud Databases as a Service

Nikita Koval — Intro to Concurrent Programming 3/3: Relaxed Data Structures for Parallel Algorithms

Nikita Koval — Intro to Concurrent Programming 2/3: Modern Queues and Flat Combining

Sergey Petrenko, Boris Stepanenko: Solving Raft's practical problems in Tarantool. What, how and why

Ilya Kokorin — HTAP Workloads: Challenges and Solutions

Alexander Filatov — Java PathFinder: going to Mars without bugs and deadlocks

Petr Kuznetsov — A sledgehammer to crack a nut: why blockchain is not (always) a good idea

Hydra's Heads: Vladimir Ozerov

Konstantin Osipov — Scaling Raft

Hydra's Heads: Petr Kuznetsov

Hydra's Heads: Anton Podkopaev

Raphael Carvalho — Building state-of-art LSM-tree compaction in ScyllaDB

Nikita Koval — Intro to Concurrent Programming 1/3: Classic Stack and Queue Algorithms

Satyam Shekhar — Pragmatic Code Generation for Efficient Execution

Hydra 2022 Online Conference Opening

Maria Sokolova — Workshop. Lincheck: Testing concurrency on the JVM (Part 1)

Markus Kuppe — Workshop: TLA+ in action (Part 1)

Maria Sokolova — Workshop. Lincheck: Testing concurrency on the JVM (Part 2)

Markus Kuppe — Workshop: TLA+ in action (Part 3)

Markus Kuppe — Workshop: TLA+ in action (Part 4)

Markus Kuppe — Workshop: TLA+ in action (Part 2)

Andrey Fomichev — Serverless nature of Yandex Database

Aleksey Shipilev — Workshop: Java Concurrency Stress (JCStress). Part 3

Aleksey Shipilev — Workshop: Java Concurrency Stress (JCStress). Part 2

Aleksey Shipilev — Workshop: Java Concurrency Stress (JCStress). Part 1

Irfan Sharif — The hitchhiker's guide to distributed transactions

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

Lalith Suresh — Building scalable and flexible cluster managers using declarative programming

Mike Kowalski — CAP Theorem — two decades and few clouds later

Nathan VanBenschoten — Fearless global transactions with CockroachDB

Adam Morrison — Designing fast lock free algorithms by understanding cache coherence dynamics

Andras Gerlits — Simplifying global-scale strong consistency

Lena Hall — Theoretical and practical worlds of failure detectors

Alvaro Videla — What we talk about when we talk about distributed systems

Jack Vanlightly — Distributed systems showdown — TLA + vs real code

Maurice Herlihy — Data parallelism from a multicore perspective

Naama Ben-David — Algorithms for practical distributed agreement

Andy Pavlo — The official ten-year retrospective of NewSQL databases

Martin Kleppmann — CRDTs: The hard parts

Heidi Howard — Paxos vs Raft: Have we reached consensus on distributed consensus?

Sergey Kuksenko — Java threads are losing weight performance review of Project Loom

Martin Kleppmann — Syncing data across user devices for distributed collaboration

Talks by Martin Kleppmann