2023.md

January

• Operator pattern - https://kubernetes.io/docs/concepts/extend-kubernetes/operator/
• Controllers - https://kubernetes.io/docs/concepts/architecture/controller/
• Introducing Operators: Putting Operational Knowledge into Software - https://web.archive.org/web/20170129131616/https://coreos.com/blog/introducing-operators.html
• Best practices for building Kubernetes Operators and stateful apps - https://cloud.google.com/blog/products/containers-kubernetes/best-practices-for-building-kubernetes-operators-and-stateful-apps
• CNCF Operator WHITE PAPER - https://www.cncf.io/wp-content/uploads/2021/07/CNCF_Operator_WhitePaper.pdf
• Why do we need a Database Connection Pool? -every programmer must know - https://medium.com/javarevisited/why-do-we-need-a-database-connection-pool-every-programmer-must-know-9f90e7c8e5af
• Difference in String pool between Java 6 and 7? Answer - https://javarevisited.blogspot.com/2016/07/difference-in-string-pool-between-java6-java7.html
• A deep dive into Kubernetes controllers - https://docs.bitnami.com/tutorials/a-deep-dive-into-kubernetes-controllers
• What is eBPF, anyway, and why should Kubernetes admins care? - https://www.groundcover.com/blog/what-is-ebpf
• What I learnt about Kubernetes Controllers - https://fntlnz.wtf/post/what-i-learnt-about-kubernetes-controller/
• [Backend #56] Why you should send async tasks to Redis within a DB transaction - https://www.youtube.com/watch?v=ZfFxdPbgN88
• Cmputer Networking (Deepdive) - https://www.youtube.com/watch?v=6G14NrjekLQ
• Grafana k8s rollout-operator code walkthrough - https://github.com/grafana/rollout-operator
• We migrated to Rust, but what did we gain? - https://bytebaker.medium.com/we-migrated-to-rust-but-what-did-we-gain-1429d036d0c
• CAP Theorem Simplified | System Design Fundamentals - https://www.youtube.com/watch?v=BHqjEjzAicA
• Operational Use case Patterns for Apache Kafka and Flink — Part 1 - https://medium.com/event-driven-utopia/operational-use-case-patterns-for-apache-kafka-and-flink-part-1-5a0f8742df90
• STATE MACHINES III: TYPE STATES - https://blog.yoshuawuyts.com/state-machines-3/
• How SQLite Scales Read Concurrency - https://fly.io/blog/sqlite-internals-wal/
• How JPMorgan Chase uses Grafana and AI to monitor SLOs, SLIs, and more - https://grafana.com/blog/2023/01/03/how-jpmorgan-chase-uses-grafana-and-ai-to-monitor-slos-slis-and-more/?mdm=social
• Rust Case Study: Community makes Rust an easy choice for npm - https://www.rust-lang.org/static/pdfs/Rust-npm-Whitepaper.pdf
• Bryan Cantrill on What’s Next for Infrastructure, Open Source & Rust - https://www.scylladb.com/2023/01/04/bryan-cantrill-on-whats-next-for-infrastructure-open-source-rust/
• CQRS - https://martinfowler.com/bliki/CQRS.html
• How to Use PHP Extensions - https://www.zend.com/blog/php-development-using-php-extensions#:~:text=Why%20Use%20PHP%20Extensions%3F,to%20your%20application's%20PHP%20binary.
• Seastar: The future<> is Here - https://seastar.io/blog/2018/02/seastar-the-future-is-here/
• Seastar: Futures and Promises - https://seastar.io/futures-promises/
• Continuations Made Simple and Illustrated Denys Duchier - https://www.ps.uni-saarland.de/~duchier/python/continuations.html
• 10 Things I wish I’d known before building a Kubernetes CRD controller - https://omerxx.com/k8s-controllers/
• Extend Kubernetes via a shared informer - https://www.cncf.io/blog/2019/10/15/extend-kubernetes-via-a-shared-informer/
• Event Sourcing - https://medium.com/ssense-tech/event-sourcing-part-i-understanding-what-it-is-core-components-and-common-misconceptions-5dec65f6d61
• The Kubernetes dynamic client - https://caiorcferreira.github.io/post/the-kubernetes-dynamic-client/
• Go (Golang) vs Node JS (Microservices) performance benchmark (Istio - Prometheus - Grafana) - https://www.youtube.com/watch?v=ntMKNlESCpM
• Monitoring on steroids: How JPMorgan Chase uses Grafana for their trading platform to spot issues quickly and proactively - https://grafana.com/go/observabilitycon/2022/monitoring-on-steroids-how-jpmorgan-chase-uses-grafana-for-their-trading-platform-to-spot-issues-quickly-and-proactively/?pg=blog&plcmt=body-txt
• The Kubernetes Operator Framework Book - https://www.amazon.com/Kubernetes-Operator-Framework-Book-management/dp/1803232854
• Practical Networked Applications in Rust, Part 1: Non-Networked Key-Value Store - https://arveknudsen.com/posts/practical-networked-applications-in-rust/module-1/
• Simple leader election with Kubernetes and Docker - https://kubernetes.io/blog/2016/01/simple-leader-election-with-kubernetes/
• Leader election in Kubernetes using client-go - https://itnext.io/leader-election-in-kubernetes-using-client-go-a19cbe7a9a85
• Understanding lockForUpdate and sharedLock in Laravel - https://blog.renoki.org/understanding-lockforupdate-and-sharedlock-in-laravel
• Kubebuilder book - https://book.kubebuilder.io/introduction.html
• The Future of the Web is on the Edge - https://deno.com/blog/the-future-of-web-is-on-the-edge
• Hashicorp: Operating Cadence - https://works.hashicorp.com/articles/operating-cadence
• Kubernetes docs: Leases - https://kubernetes.io/docs/concepts/architecture/leases/
• How to get started with K8s contributions - https://abhii85.hashnode.dev/how-to-get-started-with-k8s-contributions
• Amazon builder's library: Leader Election in Distributed Systems - https://aws.amazon.com/builders-library/leader-election-in-distributed-systems/
• What is leader election in distributed systems? -https://www.enjoyalgorithms.com/blog/leader-election-system-design
• Azure: Leader Election pattern - https://learn.microsoft.com/en-us/azure/architecture/patterns/leader-election
• Elastic: Leader Election, Why Should I Care? - https://www.elastic.co/blog/found-leader-election-in-general
• Keep Your Cache Always Fresh with Debezium! by Gunnar Morling - https://www.youtube.com/watch?v=zOOFMHAjoPI
• every good programmer should know how to code this data structure (its easy) - https://www.youtube.com/watch?v=dti0F7w3yOQ
• Nginx vs Traefik performance benchmark (HTTP - HTTPS - gRPC | Latency - CPU - Memory | Prometheus) - https://www.youtube.com/watch?v=bgcfEW_Yh7E
• Comparing Optimistic and Pessimistic Locking With GO and PostgreSQL - https://hackernoon.com/comparing-optimistic-and-pessimistic-locking-with-go-and-postgresql
• Implementing Your Own Transactions with MVCC - https://levelup.gitconnected.com/implementing-your-own-transactions-with-mvcc-bba11cab8e70
• Transactional memory - https://en.wikipedia.org/wiki/Transactional_memory
• Multiversion concurrency control - https://en.wikipedia.org/wiki/Multiversion_concurrency_control
• Bi-Directional Streaming With GRPC In Golang - https://www.youtube.com/watch?v=IHQNiQlQVXo
• How does videogame AI make its decisions? (FSM, Behaviour Trees, BDI, GOAP) | Bitwise - https://www.youtube.com/watch?v=ValJk15l_y8
• Bully algorithm - https://en.wikipedia.org/wiki/Bully_algorithm
• How Amazon grew an awkward side project into AWS, a behemoth that’s now 4 times bigger than its original shopping business - https://fortune-com.cdn.ampproject.org/c/s/fortune.com/longform/amazon-web-services-ceo-adam-selipsky-cloud-computing/amp/
• Achieving idempotency in the AWS serverless space - https://qasimalbaqali.medium.com/achieving-idempotency-in-the-aws-serverless-space-d0671a521479
• Ring network - https://en.wikipedia.org/wiki/Ring_network
• Zookeeper Atomic Broadcast Protocol (ZAB) and implementation of Zookeeper. - https://www.cloudkarafka.com/blog/cloudkarafka-zab.html#:~:text=What%20is%20ZAB%20(Zookeeper%20Atomic,restoration%20of%20any%20failed%20nodes.
• Scaling a Monolith with 5 Different Patterns - https://www.youtube.com/watch?v=rSCDuZLP9UM
• What is Apache Pinot? (and User-Facing Analytics) | A StarTree Lightboard by Tim Berglund - https://www.youtube.com/watch?v=_lqdfq2c9cQ
• Split-brain, Quorum, and Fencing - https://techthoughts.typepad.com/managing_computers/2007/10/split-brain-quo.html
• What Is Progressive Delivery All About? - https://launchdarkly.com/blog/what-is-progressive-delivery-all-about/
• Installing OpenTelemetry On Kubernetes - https://www.youtube.com/watch?v=D6XtpSCH3Nk
• Zero Allocations And Benchmarking In Golang - https://www.youtube.com/watch?v=QFGbTOsk-Bk
• MySQL Performance Benchmarking: MySQL 5.7 vs MySQL 8.0 - https://severalnines.com/blog/mysql-performance-benchmarking-mysql-57-vs-mysql-80/
• Charset and Collation Settings Impact on MySQL Performance - https://www.percona.com/blog/2019/02/27/charset-and-collation-settings-impact-on-mysql-performance/
• The Engineers Are Bloggers Now - https://www.nytimes.com/2023/01/07/business/uber-engineer-bloggers.html?unlocked_article_code=dzR4qpOXZ8gpfTTyCkq7xitIcXbyR5k9QmIlBgqWzUKcht9wVo8LVAOTuoFkc3eKTkHzZYAMKrFy63GAJ_wyh_yraHRAjn3xMn43WeGSmpasESxUmHz5WSgIZZ-d2OrLewYrgI2szmSVuinQpxLxVvMm88ej6KLcdofzxNliV7OS2cwfYZtwbULf_OB2FGbsOZD2NsN2yUumaj21jRA84mtfllfLLtjaX62E342K8SQU1NpWeWw4EHDEpx3t1AEc8wbcmzaFtG_TeNy6yIWIyzKMkQLq2CAuc8_5e6m_EC9sl0zZyut7b1a9kG_0xEaOnZLl4vNwBuZXl7tSMiNdrxk&smid=share-url
• A better domain events pattern - https://lostechies.com/jimmybogard/2014/05/13/a-better-domain-events-pattern/
• Transactional Outbox pattern with Azure Cosmos DB - https://learn.microsoft.com/en-us/azure/architecture/best-practices/transactional-outbox-cosmos
• Generational indices guide - https://lucassardois.medium.com/generational-indices-guide-8e3c5f7fd594
• What is Computational Storage? - https://www.youtube.com/watch?v=lCuJnhZaTv8
• Data sovereignty is the future of cloud - https://redpanda.com/blog/kafka-redpanda-future
• The Weekend Read - Issue #2 - https://dtornow225.substack.com/p/the-weekend-read-issue-2-961455
• How we built Shadow Indexing, the subsystem powering Redpanda’s tiered storage capabilities - https://redpanda.com/blog/tiered-storage-architecture-shadow-indexing-deep-dive
• Announcing Rust 1.66.1 - https://blog.rust-lang.org/2023/01/10/Rust-1.66.1.html
• Program counter - https://en.wikipedia.org/wiki/Program_counter
• Von Neumann architecture - https://en.wikipedia.org/wiki/Von_Neumann_architecture
• AVI Networks: Subnet Mask - https://avinetworks.com/glossary/subnet-mask/
• Scheduling In Go : Part I - OS Scheduler - https://www.ardanlabs.com/blog/2018/08/scheduling-in-go-part1.html
• Simplifying Redpanda Raft implementation - https://redpanda.com/blog/simplifying-raft-replication-in-redpanda
• Set up and observe a Spring Boot application with Grafana Cloud, Prometheus, and OpenTelemetry - https://grafana.com/blog/2022/04/26/set-up-and-observe-a-spring-boot-application-with-grafana-cloud-prometheus-and-opentelemetry/
• Announcing Grafana Mimir, the most scalable open source TSDB in the world - https://grafana.com/blog/2022/03/30/announcing-grafana-mimir/
• 1 Problem, 24 Programming Languages - https://www.youtube.com/watch?v=U6I-Kwj-AvY
• "I Became A Programmer By Mistake" Says the Creator of C++ 🫢 - https://www.youtube.com/watch?v=OQZhHHq3p1I
• Kubernetes Explained in 6 Minutes | k8s Architecture - https://www.youtube.com/watch?v=TlHvYWVUZyc
• Why innodb_file_per_table is important - https://www.catalyst2.com/knowledgebase/server-management/why-innodb_file_per_table-is-important/#:~:text=The%20innodb_file_per_table%20setting%20defines%20how,to%20%E2%80%9Con%E2%80%9D%20by%20default.
• GCP MySQL: Operational guidelines - https://cloud.google.com/sql/docs/mysql/operational-guidelines
• You DON'T want an In-Memory Event Bus like MediatR - https://www.youtube.com/watch?v=KCvsk5tTP3w
• Buffered VS UnBuffered Channels In Golang - https://www.youtube.com/watch?v=HLGrvgbo-Yk
• ProxySQL, a Google Cloud Platform alternative to SQL database management - https://www.makingscience.com/blog/proxysql-a-google-cloud-platform-gcp-alternative-to-sql-database-management/
• How we achieved MySQL High Availability using ProxySQL - https://exotel.com/blog/achieving-mysql-high-availability-proxysql/
• AWS Lambda now supports Maximum Concurrency for Amazon SQS as an event source - https://aws.amazon.com/about-aws/whats-new/2023/01/aws-lambda-maximum-concurrency-amazon-sqs-event-source/
• KRaft: Apache Kafka Without ZooKeeper - https://developer.confluent.io/learn/kraft/
• Introduction to Amazon RDS Multi-AZ deployments | Amazon Web Services - https://www.youtube.com/watch?v=_MROZtLtCcA
• Rust Powered Polymorphism ⚡️ With Traits - https://www.youtube.com/watch?v=CHRNj5oubwc
• Using an /etc/hosts file for custom domains during development - https://support-acquia.force.com/s/article/360004175973-Using-an-etc-hosts-file-for-custom-domains-during-development#:~:text=The%20%2Fetc%2Fhosts%20file%20contains,before%20making%20a%20website%20live.
• What is Process Mining? - https://www.youtube.com/watch?v=5thuFbUQ7Qg
• Go (Golang) vs Java performance benchmark (Fiber vs Spring Boot | Prometheus | Minio | MongoDB) - https://www.youtube.com/watch?v=8CiErLxdaA8
• Supporting the Use of Rust in the Chromium Project - https://security.googleblog.com/2023/01/supporting-use-of-rust-in-chromium.html
• The Rule Of 2 - https://chromium.googlesource.com/chromium/src/+/master/docs/security/rule-of-2.md
• Controllers and Operators - https://joshrosso.com/docs/2019/2019-10-13-controllers-and-operators/
• Fear and Loathing in Lock-Free Programming - https://medium.com/@tylerneely/fear-and-loathing-in-lock-free-programming-7158b1cdd50c
• How To Avoid Locks (Mutex) In Your Golang Programs? - https://www.youtube.com/watch?v=Ya5KRFrwPug
• Architecture Pitfalls: Don’t use your ORM entities for everything — embrace the SQL! - https://www.blackparrotlabs.io/post/architecture-pitfalls-dont-use-your-orm-entities-for-everything
• Single Writer Principle - https://mechanical-sympathy.blogspot.com/2011/09/single-writer-principle.html
• start to your hacking journey with this video (reverse engineering is IMPORTANT) - https://www.youtube.com/watch?v=gh2RXE9BIN8
• Test-and-set spinlocks - https://geidav.wordpress.com/2016/03/23/test-and-set-spinlocks/
• Async IO on Linux: select, poll, and epoll - https://jvns.ca/blog/2017/06/03/async-io-on-linux--select--poll--and-epoll/
• Transactions in MongoDB, Cassandra, Zookeeper and others - http://rystsov.info/2012/09/01/cas.html
• Writing Kubernetes Custom Controllers - https://cloudark.medium.com/kubernetes-custom-controllers-b6c7d0668fdf
• How To Use A Bytes Buffer In Golang And Make It Even Better? - https://www.youtube.com/watch?v=ENxfg9rS5dc
• RustFest Paris 2018: Building Reliable Infrastructure in Rust by Tyler Neely - https://www.youtube.com/watch?v=hMJEPWcSD8w
• Enable Cross-Account Observability in Amazon CloudWatch | Amazon Web Services - https://www.youtube.com/watch?v=lUaDO9dqISc
• 01 - History of Databases (CMU Databases / Spring 2020) - https://www.youtube.com/watch?v=SdW5RKUboKc
• Strategies To Detect and Respond To Failures in Cloud Applications - https://www.youtube.com/watch?v=NRlGeVTDpGU
• Nginx vs Apache HTTP Server performance benchmark (Prometheus | HTTP | HTTPS | Grafana | Ansible) - https://www.youtube.com/watch?v=Fx8afVZJLd4
• 01 - Course Introduction & Relational Model (CMU Intro to Database Systems / Fall 2021) - https://www.youtube.com/watch?v=v4bU6n97Vr8&list=PLSE8ODhjZXjZaHA6QcxDfJ0SIWBzQFKEG
• Performance Schema: Great Power Comes Without Great Cost - https://dev.mysql.com/blog-archive/performance-schema-great-power-comes-without-great-cost/
• MySQL Connection Handling and Scaling - https://dev.mysql.com/blog-archive/mysql-connection-handling-and-scaling/
• On connections - https://dom.as/2011/08/28/mysql-connection-accept-speed/
• Kubernetes docs: Considerations for large clusters - https://kubernetes.io/docs/setup/best-practices/cluster-large/#:~:text=No%20more%20than%20300%2C000%20total%20containers
• The evolution of software compliance and accreditation in the Department of Defense - https://assets.website-files.com/6030224cd6bd6639e9d922c9/6398ad388c573712eb14d3b4_White%20Paper_%20Evolution%20of%20Software%20Compliance%20%26%20Accreditation%20in%20DoD.pdf
• QUERYING PROMETHEUS - https://prometheus.io/docs/prometheus/latest/querying/basics/#expression-language-data-types
• Introducing LiteFS - https://fly.io/blog/introducing-litefs/
• Prometheus: METRIC TYPES - https://prometheus.io/docs/concepts/metric_types/
• Prometheus: DATA MODEL - https://prometheus.io/docs/concepts/data_model/
• Basics and best practices for getting started with PromQL - https://grafana.com/blog/2021/01/29/basics-and-best-practices-for-getting-started-with-promql/
• New in Grafana 9: The Prometheus query builder makes writing PromQL queries easier - https://grafana.com/blog/2022/07/18/new-in-grafana-9-the-prometheus-query-builder-makes-writing-promql-queries-easier/
• Exploring Prometheus Go client metrics - https://povilasv.me/prometheus-go-metrics/
• Prometheus: HISTOGRAMS AND SUMMARIES - https://prometheus.io/docs/practices/histograms/
• Prometheus: TYPES OF METRICS.- https://prometheus.io/docs/tutorials/understanding_metric_types/
• Consensus Protocols: Two-Phase Commit - https://www.the-paper-trail.org/post/2008-11-27-consensus-protocols-two-phase-commit/
• How summary metrics work in Prometheus - https://grafana.com/blog/2022/03/01/how-summary-metrics-work-in-prometheus/
• Elastic Cloud Services: Scaling Snowflake’s Control Plane - https://www.micahlerner.com/2023/01/19/elastic-cloud-services-scaling-snowflakes-control-plane.html
• How we clone a running VM in 2 seconds - https://codesandbox.io/blog/how-we-clone-a-running-vm-in-2-seconds
• Sneaking By The Rust Borrow Checker - Interior Mutability - https://www.youtube.com/watch?v=HwupNf9iCJk
• Noisy Neighbor antipattern - https://learn.microsoft.com/en-us/azure/architecture/antipatterns/noisy-neighbor/noisy-neighbor
• How Recommender Systems Work (Netflix/Amazon) - https://www.youtube.com/watch?v=n3RKsY2H-NE
• Collaborative Filtering - https://developers.google.com/machine-learning/recommendation/collaborative/basics
• Matrix Factorization - https://developers.google.com/machine-learning/recommendation/collaborative/matrix
• Prototyping a Recommender System Step by Step Part 1: KNN Item-Based Collaborative Filtering - https://towardsdatascience.com/prototyping-a-recommender-system-step-by-step-part-1-knn-item-based-collaborative-filtering-637969614ea
• Build a Recommendation Engine With Collaborative Filtering - https://realpython.com/build-recommendation-engine-collaborative-filtering/#using-python-to-build-recommenders
• What is Geographic DNS Routing? - https://ns1.com/resources/how-geographic-routing-works
• Geolocation routing - https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/routing-policy-geo.html
• Using CloudFront Signed URLs with Built-In Authenticated Access to S3 - https://doordash.engineering/2021/12/14/building-authenticated-access-to-s3/
• Effect system - https://en.wikipedia.org/wiki/Effect_system
• A Programmer-Friendly I/O Abstraction Over io_uring and kqueue - https://tigerbeetle.com/blog/a-friendly-abstraction-over-iouring-and-kqueue/
• Intrusive linked lists - https://www.data-structures-in-practice.com/intrusive-linked-lists/
• Merbridge - Accelerate your mesh with eBPF - https://istio.io/v1.15/blog/2022/merbridge/
• A Database Without Dynamic Memory Allocation - https://tigerbeetle.com/blog/a-database-without-dynamic-memory/
• Memory access on the Apple M1 processor - https://lemire.me/blog/2021/01/06/memory-access-on-the-apple-m1-processor/
• Three Clocks are Better than One - https://tigerbeetle.com/blog/three-clocks-are-better-than-one/
• Next Rust Compiler - https://matklad.github.io/2023/01/25/next-rust-compiler.html
• The RED Method: key metrics for microservices architecture - https://www.weave.works/blog/the-red-method-key-metrics-for-microservices-architecture/
• Jsonnet Training Course - https://jsonnet-libs.github.io/jsonnet-training-course/
• Why Is System Design Interview Important? - https://www.youtube.com/watch?v=EyMRZpgJUuc
• The Log-Structured Merge-Tree (LSM Tree) - https://blog.acolyer.org/2014/11/26/the-log-structured-merge-tree-lsm-tree/
• HYTRADBOI '22 — TigerBeetle's LSM-Forest - https://www.youtube.com/watch?v=yBBpUMR8dHw
• highscalability.com: Paper: Immutability Changes Everything By Pat Helland - http://highscalability.com/blog/2015/1/26/paper-immutability-changes-everything-by-pat-helland.html
• The size of Rust Futures - https://swatinem.de/blog/future-size/
• The network is reliable - https://aphyr.com/posts/288-the-network-is-reliable
• Introduction to continuous profiling - https://www.youtube.com/watch?v=pU6GFVHFPFU&list=PLDGkOdUX1UjqEzcxQrbROMy8DN7MZv_h4&index=2
• New in Grafana Loki 2.4: The Simple Scalable Deployment Mode - https://www.youtube.com/watch?v=M8nYWBpbwWg&list=PLDGkOdUX1UjqEzcxQrbROMy8DN7MZv_h4&index=2
• Grafana Loki 2.3: Easier & Faster Querying - https://www.youtube.com/watch?v=zIdEVNA6YTI&list=PLDGkOdUX1UjqEzcxQrbROMy8DN7MZv_h4&index=3
• ARM vs x86 performance benchmark (amd64 vs arm64 - AWS Graviton - AWS EKS - Kubernetes - Golang) - https://www.youtube.com/watch?v=ndXKHgFIIL4
• Why Uber Fails to Disrupt Transportation - https://www.youtube.com/watch?v=ajHg97qx4r0
• Rust's Witchcraft - https://www.youtube.com/watch?v=MWRPYBoCEaY
• Jepsen: MongoDB - https://aphyr.com/posts/284-call-me-maybe-mongodb
• C++ vs Rust: Tuples - https://www.youtube.com/watch?v=0RsLGM_7ODE
• Jepsen: Riak - https://aphyr.com/posts/285-call-me-maybe-riak
• Paper: CRDTs: Consistency Without Concurrency Control - http://highscalability.com/blog/2010/12/23/paper-crdts-consistency-without-concurrency-control.html
• Jepsen: final thoughts - https://aphyr.com/posts/286-call-me-maybe-final-thoughts
• Sloppy Quorum and Hinted handoff: Quorum in the times of failure - https://distributed-computing-musings.com/2022/05/sloppy-quorum-and-hinted-handoff-quorum-in-the-times-of-failure/
• An introduction to replication - https://distributed-computing-musings.com/2021/12/an-introduction-to-replication/
• Distributed Consensus: Why do we need everyone to agree? - https://distributed-computing-musings.com/2021/12/distributed-consensus-why-do-we-need-everyone-to-agree/
• Distributed Consensus: How to decide what everyone agrees on? - https://distributed-computing-musings.com/2021/12/distributed-consensus-how-to-decide-what-everyone-agrees-on/
• Distributed Consensus: How to deal with disagreement? - https://distributed-computing-musings.com/2021/12/distributed-consensus-how-to-deal-with-disagreement/
• Replication: Challenges in onboarding a new follower - https://distributed-computing-musings.com/2021/12/replication-challenges-in-onboarding-a-new-follower/
• Replication: Handling node failure - https://distributed-computing-musings.com/2021/12/replication-handling-node-failure/
• Split-brain (computing) - https://en.wikipedia.org/wiki/Split-brain_(computing)
• Fencing (computing) - https://en.wikipedia.org/wiki/Fencing_(computing)
• STONITH - https://en.wikipedia.org/wiki/STONITH
• Watchdog timer - https://en.wikipedia.org/wiki/Watchdog_timer
• How does the detour crate work? - https://www.youtube.com/watch?v=aLeMCUXFJwY
• Replication: Synchronous vs Asynchronous replication - https://distributed-computing-musings.com/2022/01/replication-synchronous-vs-asynchronous-replication/
• Replication: Issues with replication lag - https://distributed-computing-musings.com/2022/01/replication-issues-with-replication-lag/
• Behind the scenes of Vercel's infrastructure: Achieving optimal scalability and performance - https://vercel.com/blog/behind-the-scenes-of-vercels-infrastructure
• Suture - Supervisor Trees for Go - https://www.jerf.org/iri/post/2930/
• Error wrapping in Go - https://bitfieldconsulting.com/golang/wrapping-errors
• Grafana Screencasts - https://www.youtube.com/watch?v=zIdEVNA6YTI&list=PLDGkOdUX1UjqEzcxQrbROMy8DN7MZv_h4&index=4
• Building a powerful Double Entry Accounting system - Lucas Cavalcanti - https://www.youtube.com/watch?v=aw6y4r4NAlw
• Design Considerations When Using Transactionality - https://hazelcast.com/blog/design-considerations-when-using-transactionality/
• An Elegant DB Schema for Double-Entry Accounting - https://blog.journalize.io/posts/an-elegant-db-schema-for-double-entry-accounting/
• Tigerbeetle: Design Document - https://github.com/tigerbeetledb/tigerbeetle/blob/main/docs/DESIGN.md
• TigerBeetle - A Million Financial Transactions per Second in Zig - https://www.youtube.com/watch?v=BH2jvJ74npM
• My Rust journey and how to learn Rust - https://blog.moelove.info/my-rust-journey-and-how-to-learn-rust
• Why doesn't Go have variance in its type system? - https://blog.merovius.de/posts/2018-06-03-why-doesnt-go-have-variance-in/
• CI/CD In 5 Minutes | Is It Worth The Hassle? - https://www.youtube.com/watch?v=42UP1fxi2SY
• 2022 in Programming Languages - https://www.youtube.com/watch?v=1Evd69G6ItM
• How Does Encryption Work? - https://www.youtube.com/watch?v=sPJmIeHpWd4
• TigerBeetle raises $6.4M to power the future of financial accounting infrastructure - https://tigerbeetle.com/blog/2023-01-30-series-seed-announcement/
• The Power of 10: Rules for Developing Safety-Critical Code - https://en.wikipedia.org/wiki/The_Power_of_10:_Rules_for_Developing_Safety-Critical_Code
• What is Zig's Comptime? - https://kristoff.it/blog/what-is-zig-comptime/
• Paxos consensus for beginners - https://medium.com/distributed-knowledge/paxos-consensus-for-beginners-1b8519d3360f

February

• Rutgers: Understanding Paxos - https://people.cs.rutgers.edu/~pxk/417/notes/paxos.html
• Guaranteed Scheduling For Critical Add-On Pods - https://kubernetes.io/docs/tasks/administer-cluster/guaranteed-scheduling-critical-addon-pods/
• Pod Priority and Preemption - https://kubernetes.io/docs/concepts/scheduling-eviction/pod-priority-preemption/
• Load Balancers for System Design Interviews - https://www.youtube.com/watch?v=chyZRNT7eEo
• The Hardest Part of Writing Tests is Getting Started - https://shopify.engineering/the-hardest-part-of-writing-tests-is-getting-started
• 8 Key Data Structures That Power Modern Databases - https://www.youtube.com/watch?v=W_v05d_2RTo
• Troubleshooting Kafka with 2000 Microservices | Event Driven - https://www.youtube.com/watch?v=t5lsPZSs01Q
• [Backend #58] Why a bit of delay is good for your async tasks - https://www.youtube.com/watch?v=ILNiZgseLUI
• "Testing Distributed Systems w/ Deterministic Simulation" by Will Wilson - https://www.youtube.com/watch?v=4fFDFbi3toc
• Is This NEW Language BETTER Than Rust? C++? (Zig First Impressions) - https://www.youtube.com/watch?v=zFELcHTki9U
• Carving the Scheduler Out of Our Orchestrator - https://fly.io/blog/carving-the-scheduler-out-of-our-orchestrator/
• Redis replication - https://redis.io/docs/management/replication/
• Redis: Unsafe At Any Speed - https://towardsdatascience.com/redis-unsafe-at-any-speed-f2731f738a25
• Distributed Computing Concepts - https://medium.com/codex/distributed-computing-concepts-f6275078a81
• CAP theorem - https://en.wikipedia.org/wiki/CAP_theorem
• The many faces of consistency - https://blog.acolyer.org/2017/01/12/the-many-faces-of-consistency/
• Jepsen: Redis - https://aphyr.com/posts/283-jepsen-redis
• Jepsen: MongoDB - https://aphyr.com/posts/284-call-me-maybe-mongodb
• Jepsen: MongoDB 3.4.0-rc3 - https://jepsen.io/analyses/mongodb-3-4-0-rc3
• Red5: Live Video Streaming Protocols and the Race to Zero Latency - https://www.red5pro.com/live-video-streaming-protocols-zero-latency-whitepaper/
• Jepsen: On the perils of network partitions - https://aphyr.com/posts/281-call-me-maybe
• Jepsen: Postgres - https://aphyr.com/posts/282-call-me-maybe-postgres
• Designing futures for Rust - http://aturon.github.io/blog/2016/09/07/futures-design/
• gRPC vs Kafka: Which one should you choose? - https://www.youtube.com/watch?v=Qkhfhhn8ALU
• How To Stream Large Files Over TCP In Golang - https://www.youtube.com/watch?v=82oFmY-Qeok
• Bloom is More Complicated Than You Think - https://www.youtube.com/watch?v=ml-5OGZC7vE
• The Golang Scheduler - https://www.kelche.co/blog/go/golang-scheduling/
• Causal Consistency - https://jepsen.io/consistency/models/causal
• Jepsen: Redis-Raft 1b3fbf6 - https://jepsen.io/analyses/redis-raft-1b3fbf6
• A Foolish Consistency: Consul at Fly.io - https://fly.io/blog/a-foolish-consistency/
• Fly.io: Building Clusters With Serf, My New Favorite Thing - https://fly.io/blog/building-clusters-with-serf/#what-serf-is-doing
• Lamport timestamp - https://en.wikipedia.org/wiki/Lamport_timestamp
• Paxos at its heart is very simple - https://blog.the-pans.com/paxos-explained/
• How Redis cluster achieves high availability and data persistence - https://medium.com/@bb8s/how-redis-cluster-achieves-high-availability-and-data-persistence-8cdc899764e8
• Time and Order - https://blog.the-pans.com/time-and-order/
• State Machine and Synchronization - https://blog.the-pans.com/state-machine-and-sync/
• Paxos vs. Quorum-based Consistency - https://blog.the-pans.com/paxos-vs-quorum-based-consistency/
• Understanding Paxos as a Read-modify-write Transaction - https://blog.the-pans.com/understanding-paxos/
• Structural Subtyping in Go - https://www.youtube.com/watch?v=aBhnP6FOvJo
• Stanford: Paxos lecture (Raft user study) - https://www.youtube.com/watch?v=JEpsBg0AO6o
• Thinking distributed systems: Pre­fa­ce - https://book.dtornow.com/assets/chapters/Preface.pdf
• Leslie Lamport: Paxos Made Simple - https://lamport.azurewebsites.net/pubs/paxos-simple.pdf
• Writing a Static Analyser for PHP in Rust - Overview - https://ryangjchandler.co.uk/posts/writing-a-static-analyser-for-php-in-rust-overview
• Envelope Encryption - https://jayendrapatil.com/envelope-encryption/
• Envelope Encryption - Putting Your Encryption Key in an Envelope Is the Safer Option - https://senthilnayagan.com/data-security-and-compliance/2022/envelope-encryption
• What Are the Benefits of Envelope Encryption? - https://support.huaweicloud.com/intl/en-us/dew_faq/dew_01_0054.html
• Kubernetes: Fine Parallel Processing Using a Work Queue - https://kubernetes.io/docs/tasks/job/fine-parallel-processing-work-queue/
• Public Cloud Inter-region Network Latency as Heat-maps - https://medium.com/@sachinkagarwal/public-cloud-inter-region-network-latency-as-heat-maps-134e22a5ff19
• The technology behind GitHub’s new code search - https://github.blog/2023-02-06-the-technology-behind-githubs-new-code-search/
• FileWave: Why we moved from ZeroMQ to NATS - https://synadia.com/blog/filewave-why-we-moved-from-zeromq-to-nats-and-picked-it-over-kafka-and-rabbitmq
• What are dependent types? aka the Calculus of Construction (as a type wizard - https://www.youtube.com/watch?v=cf3hVL1bgNc
• Lamport Clock - https://martinfowler.com/articles/patterns-of-distributed-systems/lamport-clock.html
• Make any algorithm lock-free with this one crazy trick - https://www.the-paper-trail.org/post/2016-05-25-make-any-algorithm-lock-free-with-this-one-crazy-trick/
• User or *User - Do We Need Struct Pointers Everywhere? - https://preslav.me/2023/02/06/golang-do-we-need-struct-pointers-everywhere/
• SharedArrayBuffer warnings in Search Console: Clarifying a new cross-origin isolation security policy - https://searchengineland.com/sharedarraybuffer-warnings-in-search-console-clarifying-a-new-cross-origin-isolation-security-policy-346865
• Lamport TLA+ Course Lecture 1: Introduction to TLA+ (HD) - https://www.youtube.com/watch?v=p54W-XOIEF8
• Lamport TLA+ Course Lecture 2: State Machines in TLA+ (HD) - https://www.youtube.com/watch?v=4snwZl726c4
• Event-Driven Architecture: I do not think it means what you think it means - https://www.youtube.com/watch?v=iAA7PTqs4xY
• Time, Clocks, and the Ordering of Events in a Distributed System - https://lamport.azurewebsites.net/pubs/time-clocks.pdf
• Two-phase commit - https://www.researchgate.net/publication/275155037_Two-Phase_Commit
• The Consequences of Ignoring Memory Safety (but what does that mean) - https://www.youtube.com/watch?v=lxUYZVX_FjQ
• Abstractions to easily swap implementations? Not so fast. - https://www.youtube.com/watch?v=qeJeS-7luo8
• Go internals - The context package - https://www.damianopetrungaro.com/posts/go-internal-context-package/
• The LMAX Architecture - https://martinfowler.com/articles/lmax.html
• Handling Failures From First Principles - https://dominik-tornow.medium.com/handling-failures-from-first-principles-1ed976b1b869
• Paper Summary: Sagas - https://dominik-tornow.medium.com/paper-summary-sagas-395ef2a9a575
• Pattern: Saga - https://microservices.io/patterns/data/saga.html
• Distributed Transactions & Two-phase Commit - https://medium.com/geekculture/distributed-transactions-two-phase-commit-c82752d69324
• MIT Distributed systems: Lecture 12: Distributed Transactions - https://www.youtube.com/watch?v=aDp99WDIM_4
• Testing complex workflows in Go - https://blog.lobocv.com/posts/golang_testing/?utm_source=reddit&utm_medium=blog&utm_campaign=golang&utm_content=testing_advanced_flows
• All your comparable types - https://go.dev/blog/comparable
• Reducing system load with event folding - https://blog.lobocv.com/posts/event_folding/
• Crash recovery in a distributed data storage system - https://www.microsoft.com/en-us/research/publication/crash-recovery-in-a-distributed-data-storage-system/
• Paper Summary: Fundamentals of Fault-Tolerant Distributed Computing - https://dominik-tornow.medium.com/paper-summary-fundamentals-of-fault-tolerant-distributed-computing-53969eaa38f3
• Lamport: Computation and state machines - https://lamport.azurewebsites.net/pubs/state-machine.pdf
• Rutgers: distributed transactions - https://people.cs.rutgers.edu/~pxk/417/notes/transactions.html
• The Elephant was a Trojan Horse: On the Death of Map-Reduce at Google - https://www.the-paper-trail.org/post/2014-06-25-the-elephant-was-a-trojan-horse-on-the-death-of-map-reduce-at-google/
• Distributed systems for fun and for profit - https://book.mixu.net/distsys/
• Exactly-once or not, atomic broadcast is still impossible in Kafka - or anywhere - https://www.the-paper-trail.org/post/2017-07-28-exactly-not-atomic-broadcast-still-impossible-kafka/
• A brief tour of FLP impossibility - https://www.the-paper-trail.org/post/2008-08-13-a-brief-tour-of-flp-impossibility/
• Pub/Sub Best Practices: Features - https://www.youtube.com/watch?v=2-8wgvanQHI
• Distributed systems for fun and profit - https://book.mixu.net/distsys/index.html
• Algebraic Effects for the Rest of Us - https://overreacted.io/algebraic-effects-for-the-rest-of-us/
• Notes on Distributed Systems for Young Bloods - https://www.somethingsimilar.com/2013/01/14/notes-on-distributed-systems-for-young-bloods/
• Tackling Concurrency Bugs with TLA+" by Hillel Wayne - https://www.youtube.com/watch?v=_9B__0S21y8
• Writing high-performance clients for TigerBeetle - https://tigerbeetle.com/blog/2023-02-21-writing-high-performance-clients-for-tigerbeetle/
• Gossip Glomers - https://fly.io/blog/gossip-glomers/
• You Can’t Sacrifice Partition Tolerance - https://codahale.com/you-cant-sacrifice-partition-tolerance/
• What is Zig's “Colorblind” Async/Await? - https://kristoff.it/blog/zig-colorblind-async-await/
• How To Contribute To Open Source Projects - https://www.youtube.com/watch?v=xl8TQfwRLgo
• Why does this Rust program leak memory? - https://www.youtube.com/watch?v=YB6LTaGRQJg

March

• Modern Open Source Messaging: Apache Kafka, RabbitMQ and NATS in Action - https://seroter.com/2016/05/16/modern-open-source-messaging-apache-kafka-rabbitmq-and-nats-in-action/
• The Why and How of Microservice Messaging in Kubernetes - https://dzone.com/articles/microservice-messaging-in-kubernetes
• Kafka vs. Pulsar vs. RabbitMQ: Performance, Architecture, and Features Compared - https://www.confluent.io/kafka-vs-pulsar/
• How To Build A TCP Server With Actors In Golang - https://www.youtube.com/watch?v=XyUsMV6nCCw
• Rajesh K. Karmani, Gul Agha: Actors - http://web.cs.ucla.edu/~palsberg/course/cs239/papers/karmani-agha.pdf
• Dive into MySQL replication protocol - https://medium.com/@siddontang/dive-into-mysql-replication-protocol-cd14791bcc
• Latency Exists, Cope! - https://web.archive.org/web/20181004043647/http://www.addsimplicity.com/adding_simplicity_an_engi/2007/02/latency_exists_.html
• Go basically never frees heap memory back to the operating system - https://utcc.utoronto.ca/~cks/space/blog/programming/GoNoMemoryFreeing
• Using Apache Kafka to process 1 trillion inter-service messages - https://blog.cloudflare.com/using-apache-kafka-to-process-1-trillion-messages/
• Impossibility proofs - https://aphyr.com/posts/310-impossibility-proofs
• Indexing Engine: Index Write Overhead - https://pganalyze.com/docs/indexing-engine/index-write-overhead
• Exactly-once or not, atomic broadcast is still impossible in Kafka - or anywhere - https://www.the-paper-trail.org/post/2017-07-28-exactly-not-atomic-broadcast-still-impossible-kafka/
• Introducing Service Weaver: A Framework for Writing Distributed Applications - https://opensource.googleblog.com/2023/03/introducing-service-weaver-framework-for-writing-distributed-applications.html
• BEWARE of Consumer Lag! Event Driven Architecture Monitoring - https://www.youtube.com/watch?v=jguxDV1gWk8
• Static vs Dynamic dispatch - https://gist.github.com/greister/37289c6eb3629d4fefa7dd0acf6de378
• Lists are Monoids - https://ucsd-progsys.github.io/liquidhaskell-blog/2016/10/06/structural-induction.lhs/
• What is change data capture? - https://www.cockroachlabs.com/blog/change-data-capture/
• When (and why) you should use change data capture - https://www.cockroachlabs.com/blog/why-use-change-data-capture/
• Idempotency and ordering in event-driven systems - https://www.cockroachlabs.com/blog/idempotency-and-ordering-in-event-driven-systems/
• Using sync.Cond To Fix My Lock Free Queue In Golang. - https://www.youtube.com/watch?v=BO029A-3430
• strace feels like magic — let’s fix that (with Rust) - https://www.youtube.com/watch?v=engduNoI6DE
• HOW DISCORD STORES TRILLIONS OF MESSAGES - https://discord.com/blog/how-discord-stores-trillions-of-messages
• But What Is Cloud Native Really All About? - https://www.youtube.com/watch?v=p-88GN1WVs8
• Testing in Production to Stay Safe and Sensible - https://launchdarkly.com/blog/testing-in-production-for-safety-and-sanity/
• 8 Design Patterns EVERY Developer Should Know - https://www.youtube.com/watch?v=tAuRQs_d9F8
• What is a Multitenancy Architecture and Why Is it becoming popular? - https://www.youtube.com/watch?v=x8vtmX4vF9I
• Multi-tenant Architecture for SaaS - https://www.youtube.com/watch?v=e8k6TynqGFs
• My TOP Patterns for Event Driven Architecture - https://www.youtube.com/watch?v=P5hq6iWn_p8
• Consensus Protocols: Two-Phase Commit - https://www.the-paper-trail.org/post/2008-11-27-consensus-protocols-two-phase-commit/
• Consensus Protocols: Three-phase Commit - https://www.the-paper-trail.org/post/2008-11-27-consensus-protocols-two-phase-commit/
• Load shedding in the Nomad eval broker - https://www.hashicorp.com/blog/load-shedding-in-the-nomad-eval-broker
• Grafana Labs: Observability Survey 2023 - https://grafana.com/observability-survey-2023/
• Kubernetes docs: Owners and Dependents - https://kubernetes.io/docs/concepts/overview/working-with-objects/owners-dependents/
• Kubernetes docs: Garbage collection - https://kubernetes.io/docs/concepts/architecture/garbage-collection/#:~:text=Owner%20references%20tell%20the%20control,Kubernetes%20manages%20owner%20references%20automatically
• AWS builders library: Avoiding overload in distributed systems by putting the smaller service in control - https://aws.amazon.com/builders-library/avoiding-overload-in-distributed-systems-by-putting-the-smaller-service-in-control/
• AWS builders library: Leader Election in Distributed Systems - https://aws.amazon.com/builders-library/leader-election-in-distributed-systems/
• A brief history of Consensus, 2PC and Transaction Commit. - http://betathoughts.blogspot.com/2007/06/brief-history-of-consensus-2pc-and.html
• Golang Error Handling Is Better Than You Think! - https://www.youtube.com/watch?v=XCXHzfJZ6CA
• The Registers of Rust - https://without.boats/blog/the-registers-of-rust/
• Why Zig When There is Already C++, D, and Rust? - https://ziglang.org/learn/why_zig_rust_d_cpp/
• Greg Young answers your Event Sourcing questions! - https://www.youtube.com/watch?v=LGjRfgsumPk
• Issue #10 - Queues Don't Fix Overload - https://dtornow225.substack.com/p/issue-10-queues-dont-fix-overload?utm_source=twitter&utm_campaign=auto_share&r=1pyk7m
• Queues Don't Fix Overload - https://ferd.ca/queues-don-t-fix-overload.html
• End-to-end principle - https://en.wikipedia.org/wiki/End-to-end_principle
• Redpanda raison d'etre - https://redpanda.com/blog/redpanda-raison-detre
• Thread-per-core buffer management for a modern Kafka-API storage system - https://redpanda.com/blog/tpc-buffers
• 1024cores: Producer-Consumer Queues - https://www.1024cores.net/home/lock-free-algorithms/queues
• Meet Zig: The modern alternative to C - https://www.infoworld.com/article/3689648/meet-the-zig-programming-language.html
• Zig: In-depth Overview - https://ziglang.org/learn/overview/
• 9 YEARS OF OPEN-SOURCE DATABASE DEVELOPMENT: REVIEWING RQLITE DESIGN CHOICES - https://www.philipotoole.com/9-years-of-open-source-database-development-the-design-docs/
• REPLICATING SQLITE USING RAFT CONSENSUS - https://www.philipotoole.com/replicating-sqlite-using-raft-consensus/
• WHAT I LEARNED FROM PROGRAMMING DATABASES - https://www.philipotoole.com/what-i-learned-from-programming-a-database/
• 20 System Design Concepts Explained in 10 Minutes - https://www.youtube.com/watch?v=i53Gi_K3o7I
• ziglearn.org - https://ziglearn.org/
• It’s Time to Move on from Two Phase Commit - http://dbmsmusings.blogspot.com/2019/01/its-time-to-move-on-from-two-phase.html
• AWS Lambda: Resilience under-the-hood - https://aws.amazon.com/blogs/compute/aws-lambda-resilience-under-the-hood/#
• Paper Notes: Dynamo – Amazon’s Highly Available Key-value Store - https://distributed-computing-musings.com/2022/05/paper-notes-dynamo-amazons-highly-available-key-value-store/
• Sloppy Quorum and Hinted handoff: Quorum in the times of failure - https://distributed-computing-musings.com/2022/05/sloppy-quorum-and-hinted-handoff-quorum-in-the-times-of-failure/
• Thundering Herd/Cache Stampede - https://distributed-computing-musings.com/2021/12/thundering-herd-cache-stampede/
• Magical handler functions in Rust - https://lunatic.solutions/blog/magic-handler-functions-in-rust/
• Patry overview paper: PASTRY - https://www.freepastry.org/PAST/overview.pdf
• Materialized Views: An alternative to full-blown cache systems - https://distributed-computing-musings.com/2022/11/materialized-views-an-alternative-to-full-blown-cache-systems/
• Paper Notes: SWIM(Scalable Weakly-consistent Infection-style Process Group Membership Protocol) - https://distributed-computing-musings.com/2023/01/paper-notes-swimscalable-weakly-consistent-infection-style-process-group-membership-protocol/
• LSM Tree: Data structure powering write heavy storage engines - https://distributed-computing-musings.com/2022/07/lsm-tree-data-structure-powering-write-heavy-storage-engines/
• Replication: Maintaining a Quorum - https://distributed-computing-musings.com/2022/01/replication-maintaining-a-quorum/
• Replication: Introducing leaderless replication - https://distributed-computing-musings.com/2022/01/replication-introducing-leaderless-replication/
• Replication: Handling node failure - https://distributed-computing-musings.com/2021/12/replication-handling-node-failure/
• How does your computer know what time it is and why will it break your distributed systems? - https://distributed-computing-musings.com/2023/03/how-does-your-computer-know-what-time-it-is-and-why-will-it-break-your-distributed-systems/
• Replication: Can we have more than one leader? - https://distributed-computing-musings.com/2022/01/replication-can-we-have-more-than-one-leader/
• Replication: Conflict resolution in multi-leader replication - https://distributed-computing-musings.com/2022/01/replication-conflict-resolution-in-multi-leader-replication/
• Leslie Lamport: Thinking Above the Code - https://www.youtube.com/watch?v=-4Yp3j_jk8Q
• Dead letter queue - https://en.wikipedia.org/wiki/Dead_letter_queue
• Disaster Recovery for Multi-Region Kafka at Uber - https://www.uber.com/en-BR/blog/kafka/
• Some possible reasons for 8-bit bytes - https://jvns.ca/blog/2023/03/06/possible-reasons-8-bit-bytes/
• Use of Formal Methods at Amazon Web Services - https://lamport.azurewebsites.net/tla/formal-methods-amazon.pdf
• STOP! This Is How You Structure Golang Applications - https://www.youtube.com/watch?v=eSDYl-RuHjc
• Exploring TLA+ with two-phase commit - https://brooker.co.za/blog/2013/01/20/two-phase.html
• What is AWS Identity and Access Management Roles Anywhere? - https://docs.aws.amazon.com/rolesanywhere/latest/userguide/introduction.html
• Is it better to split Kafka clusters? - https://developers.redhat.com/articles/2022/03/10/which-better-single-kafka-cluster-rule-them-all-or-many#
• Distributed transaction patterns for microservices compared - https://developers.redhat.com/articles/2021/09/21/distributed-transaction-patterns-microservices-compared#
• Hashicorp's banking story - https://mitchellh.com/writing/my-startup-banking-story
• Listen to Yourself: A Design Pattern for Event-Driven Microservices - https://medium.com/@odedia/listen-to-yourself-design-pattern-for-event-driven-microservices-16f97e3ed066
• (Un) Reliability in messaging: idempotency and de-duplication - https://lostechies.com/jimmybogard/2013/06/03/un-reliability-in-messaging-idempotency-and-de-duplication/
• ACID 2.0 in action - https://lostechies.com/jimmybogard/2013/06/06/acid-2-0-in-action/
• ACID 2.0 - https://www.waitingforcode.com/general-big-data/acid-2-0/read
• Achieving consistency without transaction managers - https://blog.bernd-ruecker.com/achieving-consistency-without-transaction-managers-7cb480bd08c
• Go runtime vs CFS quota - https://vladimir.varank.in/notes/2023/01/go-runtime-vs-cfs-quota/
• Should I take a systems reading course? - https://www.the-paper-trail.org/post/2012-03-09-should-i-take-a-systems-reading-course/
• How to do distributed locking - https://martin.kleppmann.com/2016/02/08/how-to-do-distributed-locking.html
• Change Data Capture + Event Driven Architecture - https://www.youtube.com/watch?v=ARWNnnDGPag
• Isaac Freund: May 2022 Status Update - https://isaacfreund.com/blog/
• Server Name Indication - https://en.wikipedia.org/wiki/Server_Name_Indication
• SOCKS Protocol Version 5 - https://www.rfc-editor.org/rfc/rfc1928
• Three Clocks are Better than One - https://tigerbeetle.com/blog/three-clocks-are-better-than-one/
• Missing CLOCK_BOOTTIME_RAW? - https://lkml.org/lkml/2020/5/8/1707
• Virtual Synchrony - https://people.cs.rutgers.edu/~pxk/417/notes/virtual_synchrony.html
• Must move types - https://smallcultfollowing.com/babysteps/blog/2023/03/16/must-move-types/
• Nil is not nil - https://yourbasic.org/golang/gotcha-why-nil-error-not-equal-nil/
• 11 Essentials For New Software Engineers (From A Principal Engineer) - https://www.youtube.com/watch?v=kmnG5Fy8kEs
• Why you should avoid Date.now() to measure time durations - https://blog.insiderattack.net/how-not-to-measure-time-in-programming-11089d546180
• Exploring the PROXY Protocol - https://seriousben.com/posts/2020-02-exploring-the-proxy-protocol/
• What Is SSL Passthrough? How Does SSL Passthrough Work? - https://www.ssl2buy.com/wiki/ssl-passthrough-work
• NodeJS Architecture - I/O - https://www.youtube.com/watch?v=DaU1-XoANig
• Shard (database architecture) - https://en.wikipedia.org/wiki/Shard_(database_architecture)
• Roy's Technology Diary: Shard - A Database Design - http://technoroy.blogspot.com/2008/07/shard-database-design.html
• Distributed Systems 1.1: Introduction - https://www.youtube.com/watch?v=UEAMfLPZZhE&list=PLeKd45zvjcDFUEv_ohr_HdUFe97RItdiB&index=1
• Distributed Systems 1.2: Computer networking - https://www.youtube.com/watch?v=1F3DEq8ML1U&list=PLeKd45zvjcDFUEv_ohr_HdUFe97RItdiB&index=2
• Distributed Systems 1.3: RPC (Remote Procedure Call) - https://www.youtube.com/watch?v=S2osKiqQG9s&list=PLeKd45zvjcDFUEv_ohr_HdUFe97RItdiB&index=3
• Distributed Systems 2.1: The two generals problem - https://www.youtube.com/watch?v=MDuWnzVnfpI&list=PLeKd45zvjcDFUEv_ohr_HdUFe97RItdiB&index=4
• Distributed Systems 2.2: The Byzantine generals problem - https://www.youtube.com/watch?v=LoGx_ldRBU0&list=PLeKd45zvjcDFUEv_ohr_HdUFe97RItdiB&index=5
• Outliers: Why Some People Succeed and Some Don't - https://www.youtube.com/watch?v=EcMKLwVlpJk
• Everything You Need to Know About DNS (Domain Name System) - https://www.youtube.com/watch?v=27r4Bzuj5NQ
• Consensus Protocols: Three-phase Commit - https://www.the-paper-trail.org/post/2008-11-29-consensus-protocols-three-phase-commit/
• Steve Yegge's rant about Google not having a platform - https://web.archive.org/web/20190319154842/https://plus.google.com/112678702228711889851/posts/eVeouesvaVX
• 276 - OBJETOS VERSUS FUNÇÕES ⚔️⚔️⚔️ | theWiseDev Functional - https://www.youtube.com/watch?v=yz_nNpr_hCc
• How robust are gossip-based communication protocols? - https://www.cs.cornell.edu/lorenzo/papers/p14-alvisi.pdf
• All Postgres Locks Explained | A Deep Dive - https://www.youtube.com/watch?v=URwmzTeuHdk
• The tail at scale - https://abelay.github.io/6828seminar/papers/dean:tailatscale.pdf
• Exploit Development Part 6 - Writing A ROP Decoder - https://www.youtube.com/watch?v=muhqy8tm2nc
• Google cloud: External TCP/UDP Network Load Balancing overview - https://cloud.google.com/load-balancing/docs/network
• Defer blocks and async drop - https://www.ncameron.org/blog/defer-blocks-and-async-drop/
• Arroyo: 10x faster sliding windows: how our Rust streaming engine beats Flink - https://www.arroyo.dev/blog/how-arroyo-beats-flink-at-sliding-windows
• 10+ Scala Concepts you Need to Know - https://www.youtube.com/watch?v=nI57LUpjGrk
• Understand Cloud Load Balancer Like a Senior Engineer - https://medium.com/google-cloud/understand-cloud-load-balancer-like-a-senior-engineer-d4f55f3111fc
• How consistent is eventual consistency? - https://www.the-paper-trail.org/post/2012-01-04-how-consistent-is-eventual-consistency/
• Getting schooled by AI, colleges must evolve - https://muratbuffalo.blogspot.com/2023/03/getting-schooled-by-ai-colleges-must.html
• Bowling your way to the top - https://muratbuffalo.blogspot.com/2017/02/bowling-your-way-to-top.html
• How to go for 10X - How to go for 10X - http://muratbuffalo.blogspot.com/2015/08/how-to-go-for-10x.html
• The Most Beloved Burger for Developers - https://www.youtube.com/watch?v=7swoLEqABhQ
• Introducing Grafana Cloud k6 - https://www.youtube.com/watch?v=HyM4lNZjKqk
• Ensuring rollback safety during deployments - https://aws.amazon.com/builders-library/ensuring-rollback-safety-during-deployments/
• In response to a frontend developer asking about database development - https://letters.eatonphil.com/2023-01-01-letter-to-a-frontend-developer-asking-about-database-development.html
• What's the biggest scam in software development? - https://www.youtube.com/watch?v=QZMAYA19mY4
• I built my own memory profiler (in Rust, on Linux) - https://www.youtube.com/watch?v=DpnXaNkM9_M
• The Birds in Your Code are Dying to Tell You Something - https://www.youtube.com/watch?v=z6gdQt8mjn4
• Is there a drop in software engineer job openings, globally? - https://newsletter.pragmaticengineer.com/p/is-there-a-drop-in-software-engineer?utm_source=substack&utm_medium=email
• The Verification of a Distributed System - https://queue.acm.org/detail.cfm?ref=rss&id=2889274
• Hermetic Servers - https://testing.googleblog.com/2012/10/hermetic-servers.html
• On Ways To Agree, Part 1: DistSys Vocabulary - https://medium.com/databasss/on-ways-to-agree-part-1-links-and-flp-impossibility-f6bd8a6a0980
• Safety and Liveness: Eventual Consistency Is Not Safe - http://www.bailis.org/blog/safety-and-liveness-eventual-consistency-is-not-safe/
• TCP Flow Control - https://www.brianstorti.com/tcp-flow-control/
• Using Rust to Build a 100% ScyllaDB Shard-Aware Application - https://thenewstack.io/using-rust-to-build-a-100-scylladb-shard-aware-application/
• Switch Your Databases To Flash Storage. Now. Or You're Doing It Wrong. - http://highscalability.com/blog/2012/12/10/switch-your-databases-to-flash-storage-now-or-youre-doing-it.html
• Werner Vogels: Eventually Consistent - Revisited - https://www.allthingsdistributed.com/2008/12/eventually_consistent.html
• Martin Kleppmann, Alastair R. Beresford, and Boerge Sving: Online event processing - https://queue.acm.org/detail.cfm?id=3321612
• The Unix process API is unreliable and unsafe - http://catern.com/process.html
• Time-of-check to time-of-use - https://en.wikipedia.org/wiki/Time-of-check_to_time-of-use
• Beyond process supervisors - http://catern.com/supervisors.html
• Introduction To The Actor Paradigm In Golang - https://www.youtube.com/watch?v=EXThuaEzxdc
• Wait-for graph - https://www.cs.colostate.edu/~cs551/CourseNotes/Deadlock/WFGs.html
• Wikipedia: Wait-for graph - https://en.wikipedia.org/wiki/Wait-for_graph#:~:text=A%20wait%2Dfor%20graph%20in,systems%20and%20relational%20database%20systems.
• Pat Helland: Consistently Eventual For many data items, the work never settles on a value. - https://queue.acm.org/detail.cfm?id=3226077
• Evolution and Practice: Low-latency Distributed Applications in Finance The finance industry has unique demands for low-latency distributed systems. - https://queue.acm.org/detail.cfm?id=2770868
• Matklad: Zig and Rust - https://matklad.github.io/2023/03/26/zig-and-rust.html
• Rust's Golden Rule - https://steveklabnik.com/writing/rusts-golden-rule
• Matklad: Call Site Dependency Injection - https://matklad.github.io/2020/12/28/csdi.html
• Riak: What in the hell is HyperLogLog - https://riak.com/posts/technical/what-in-the-hell-is-hyperloglog/index.html?p=13169.html
• 10+ Key Memory & Storage Systems - https://www.youtube.com/watch?v=lX4CrbXMsNQ
• Tigerbeetle: Random fuzzy thoughts - https://tigerbeetle.com/blog/2023-03-28-random-fuzzy-thoughts/
• Ericsson: Packet reordering: The key to efficient high-speed packet processing - https://www.ericsson.com/en/blog/2022/8/packet-reordering-effects-on-packet-processing
• Google cloud tech: What are service accounts? - https://www.youtube.com/watch?v=xXk1YlkKW_k
• oh $%!&, I didn't want to do that! UNDO UNDO UNDO! - https://www.youtube.com/watch?v=8J9qwtooKoI
• Torvalds being rude(what a surprise) - https://lkml.org/lkml/2022/9/19/1105#1105.php
• Rust is a scalable language - https://matklad.github.io/2023/03/28/rust-is-a-scalable-language.html
• YOSHUA WUYTS: Linear types one-pager - https://blog.yoshuawuyts.com/linear-types-one-pager/
• Dominik Tornow: Getting started with small-step operational semantics - https://dominik-tornow.medium.com/getting-started-with-small-step-operational-semantics-9531a35621e0
• WebSockets: Scale at Fractional Footprint in Go - https://www.druva.com/blog/websockets--scale-at-fractional-footprint-in-go
• Life in a Redis Cluster: Meet and Gossip with your neighbors - https://cristian.regolo.cc/2015/09/05/life-in-a-redis-cluster.html
• SimulatedRides: How Lyft uses load testing to ensure reliable service during peak events - https://eng.lyft.com/simulatedrides-how-lyft-uses-load-testing-to-ensure-reliable-service-during-peak-events-644dcb654454
• Dominik Tornow: What is a Saga in Microservices? - https://www.youtube.com/watch?v=0W8BtIwh824
• mcyoung: Atomicless concurrency - https://mcyoung.xyz/2023/03/29/rseq-checkout/
• Grafana Phlare hash rings - https://grafana.com/docs/phlare/latest/operators-guide/architecture/hash-ring/
• Grafana Phlare memberlist and gossip protocol - https://grafana.com/docs/phlare/latest/operators-guide/architecture/memberlist-and-the-gossip-protocol/
• Cassandra and its Accrual Failure Detector - https://ljungblad.nu/post/44006928392/cassandra-and-its-accrual-failure-detector
• Chain replication - http://dsrg.pdos.csail.mit.edu/2013/08/08/chain-replication/
• Observational equivalence and unsafe code - https://smallcultfollowing.com/babysteps/blog/2016/10/02/observational-equivalence-and-unsafe-code/
• Clocks and Causality - Ordering Events in Distributed Systems - https://www.exhypothesi.com/clocks-and-causality/
• Twitter's Recommendation Algorithm - https://blog.twitter.com/engineering/en_us/topics/open-source/2023/twitter-recommendation-algorithm
• Coroutines in less than 20 lines of standard C - https://fanf.livejournal.com/105413.html
• Two trie implementations in Rust (one's super fast) - https://dev.to/timclicks/two-trie-implementations-in-rust-ones-super-fast-2f3m
• A brutally effective hash function in Rust - https://nnethercote.github.io/2021/12/08/a-brutally-effective-hash-function-in-rust.html

April

• An Effective Way To Authorize Handlers In Golang - https://www.youtube.com/watch?v=MmPItr7-MdM
• SouJava na Campus - Evitando Race Conditions em Aplicações Distribuídas - https://www.youtube.com/watch?v=7DYE0mY0CRE
• Caitie McCaffrey on "Distributed Programming in Argus" - https://www.youtube.com/watch?v=-osjxoiP4rg
• How And When To Use io.MultiWriter In Golang!? - https://www.youtube.com/watch?v=g9tv-M-VCpU
• Lunatic: Writing Rust the Elixir way - https://lunatic.solutions/blog/writing-rust-the-elixir-way/
• Lunatic: Writing Rust the Elixir way - 18 months later - https://lunatic.solutions/blog/writing-rust-the-elixir-way-1.5-years-later/
• MERKLE TREES AND THEIR APPLICATION IN GIT - https://ieee.nitk.ac.in/blog/merkle-trees-and-their-application-in-git/
• Multicast - https://en.wikipedia.org/wiki/Multicast
• Cloudflare: Everything you ever wanted to know about UDP sockets but were afraid to ask, part 1 - https://blog.cloudflare.com/everything-you-ever-wanted-to-know-about-udp-sockets-but-were-afraid-to-ask-part-1/
• Cache Systems Every Developer Should Know - https://www.youtube.com/watch?v=dGAgxozNWFE
• Speeding up Queries by Pre-computation & Transformation - https://www.youtube.com/watch?v=hQVisFBAQio
• Database Pages — A deep dive - https://medium.com/@hnasr/database-pages-a-deep-dive-38cdb2c79eb5
• Holey JavaScript Arrays - https://abdulapopoola.com/2020/10/12/holey-javascript-arrays/
• JavaScript Arrays Are Objects - https://abdulapopoola.com/2020/09/30/javascript-arrays-are-objects/
• Array iteration and holes in JavaScript - https://2ality.com/2013/07/array-iteration-holes.html
• Windows Internals - Processes and Threads Explained - Windows Internals - Processes and Threads Explained
• "Making Systems Programming Accessible" by Andrew Kelley - https://www.youtube.com/watch?v=Qncdi-Fg0-I
• How do you choose a suitable gossip protocol for your distributed system? - https://www.linkedin.com/advice/0/how-do-you-choose-suitable-gossip-protocol
• rand( ) isn't doing what you think it does - https://www.youtube.com/watch?v=wDj64pSeQ4I
• Wikipedia: Gossip protocol - https://en.wikipedia.org/wiki/Gossip_protocol
• Martin Fowler: Gossip Dissemination - https://martinfowler.com/articles/patterns-of-distributed-systems/gossip-dissemination.html
• Martin Fowler: Consistent core - https://martinfowler.com/articles/patterns-of-distributed-systems/consistent-core.html
• Martin Fowler: Generation clock - https://martinfowler.com/articles/patterns-of-distributed-systems/generation.html
• Phil Wadler: Featherweight Go - https://www.youtube.com/watch?v=Dq0WFigax_c
• KIP-650: Enhance Kafkaesque Raft semantics - https://cwiki.apache.org/confluence/display/KAFKA/KIP-650%3A+Enhance+Kafkaesque+Raft+semantics#KIP650:EnhanceKafkaesqueRaftsemantics-Non-leaderLinearizableRead
• Scylla docs: Gossip in Scylla - https://docs.scylladb.com/stable/kb/gossip.html
• High scalability: Using Gossip Protocols For Failure Detection, Monitoring, Messaging And Other Good Things - http://highscalability.com/blog/2011/11/14/using-gossip-protocols-for-failure-detection-monitoring-mess.html
• Apple Inc.: Cassandra Internals — Understanding Gossip - https://www.youtube.com/watch?v=FuP1Fvrv6ZQ&list=PLqcm6qE9lgKJkxYZUOIykswDndrOItnn2&index=50
• Martin Fowler: High-water mark - https://martinfowler.com/articles/patterns-of-distributed-systems/high-watermark.html
• Martin Fowler: Write-ahead log - https://martinfowler.com/articles/patterns-of-distributed-systems/wal.html
• Martin Fowler: Low-water mark - https://martinfowler.com/articles/patterns-of-distributed-systems/low-watermark.html
• Martin Fowler: Singular update queue - https://martinfowler.com/articles/patterns-of-distributed-systems/singular-update-queue.html
• Mechanical sympathy: Single writer principle - https://mechanical-sympathy.blogspot.com/2011/09/single-writer-principle.html
• Martin Fowler: Single socket channel - https://martinfowler.com/articles/patterns-of-distributed-systems/single-socket-channel.html
• Hands-Free Kafka Replication: A Lesson in Operational Simplicity - https://www.confluent.io/blog/hands-free-kafka-replication-a-lesson-in-operational-simplicity/
• Can you truste a compiler to optimize your code? - https://matklad.github.io/2023/04/09/can-you-trust-a-compiler-to-optimize-your-code.html
• Inline in Rust - https://matklad.github.io/2021/07/09/inline-in-rust.html
• Loris Cro: Playing the open source game - https://kristoff.it/blog/the-open-source-game/
• Online gradient descent written in SQL - https://maxhalford.github.io/blog/ogd-in-sql/
• Google cloud storage docs: Consistency - https://cloud.google.com/storage/docs/consistency
• The end of a myth: Distributed transactions can scale - http://muratbuffalo.blogspot.com/2023/04/the-end-of-myth-distributed.html
• Silly fast fresh deploys with Rust past 1 - https://www.youtube.com/watch?v=KAKccfVVslk
• Guidance for cell-based architecture on AWS - https://aws.amazon.com/solutions/guidance/cell-based-architecture-on-aws/
• SQL Maxis: Why We Ditched RabbitMQ And Replaced It With A Postgres Queue - https://www.prequel.co/blog/sql-maxis-why-we-ditched-rabbitmq-and-replaced-it-with-a-postgres-queue
• Strict-serializability, but at what cost, for what purpose? - http://muratbuffalo.blogspot.com/2022/08/strict-serializability-but-at-what-cost.html
• Scylla paper: Reducing Complexity With a Self-Optimizing Database - https://lp.scylladb.com/self-optimizing-database-offer.html
• Database internals - https://databass.dev
• Building a system that Junior Developers can be productive in - https://www.youtube.com/watch?v=S0zC0u5tIx8
• Components of recursive functions | Recursion series - https://www.youtube.com/watch?v=44TwrxjfIfo
• Proxy Protocol: what is it and how to use it with Go - https://inkel.github.io/posts/proxy-protocol/
• libuv, but multi-threaded, but not really - http://kprotty.me/2023/04/13/libuv-but-multithreaded-but-not-really.html
• Amazon builder's library: Avoiding fallback in distributed systems - https://aws.amazon.com/builders-library/avoiding-fallback-in-distributed-systems/?did=ba_card&trk=ba_card
• Intro to the Zig Programming Language • Andrew Kelley • GOTO 2022 - https://www.youtube.com/watch?v=YXrb-DqsBNU
• What's a Memory Allocator Anyway? - Benjamin Feng - https://www.youtube.com/watch?v=vHWiDx_l4V0
• TigerBeetle: Magical Memory Tour! (Joran Dirk Greef) - https://www.youtube.com/watch?v=FyGukn77gqA
• BEAM Concurrency in Action • Sasa Juric • YOW! 2022 - https://www.youtube.com/watch?v=A4x6IfceJCM
• Zig's I/O and Concurrency Story - King Protty - Software You Can Love 2022 - https://www.youtube.com/watch?v=Ul8OO4vQMTw
• Distributed Systems 2.3: System models - https://www.youtube.com/watch?v=y8f7ZG_UnGI&list=PLeKd45zvjcDFUEv_ohr_HdUFe97RItdiB&index=6
• Distributed Systems 2.4: Fault tolerance - https://www.youtube.com/watch?v=43TDfUNsM3E&list=PLeKd45zvjcDFUEv_ohr_HdUFe97RItdiB&index=7
• Distributed Systems 3.1: Physical time - https://www.youtube.com/watch?v=FQ_2N3AQu0M&list=PLeKd45zvjcDFUEv_ohr_HdUFe97RItdiB&index=8
• Distributed Systems 3.2: Clock synchronisation - https://www.youtube.com/watch?v=mAyW-4LeXZo&list=PLeKd45zvjcDFUEv_ohr_HdUFe97RItdiB&index=9
• Distributed Systems 3.3: Causality and happens-before - https://www.youtube.com/watch?v=OKHIdpOAxto&list=PLeKd45zvjcDFUEv_ohr_HdUFe97RItdiB&index=10
• Distributed Systems 4.1: Logical time - https://www.youtube.com/watch?v=x-D8iFU1d-o&list=PLeKd45zvjcDFUEv_ohr_HdUFe97RItdiB&index=11
• Cross-site request forgery - https://www.synopsys.com/glossary/what-is-csrf.html
• DOM crimes and feature flags (feat. DevCycle) - https://www.youtube.com/watch?v=-HdTX5AfZ6c
• Efficiency trades off against resiliency - https://blog.nelhage.com/post/efficiency-vs-resiliency/
• GADTs for dummies - https://news.ycombinator.com/item?id=27172843
• sled simulation guide (jepsen-proof engineering) - https://sled.rs/simulation.html
• Silly Fast Fresh Deploys with Rust (Part 2) - https://www.youtube.com/watch?v=umeTH5qZUeQ
• "Testing Distributed Systems w/ Deterministic Simulation" by Will Wilson - https://www.youtube.com/watch?v=4fFDFbi3toc
• The Inner Workings of Distributed Databases - https://questdb.io/blog/inner-workings-distributed-databases/
• Reduce the write amplification of write-ahead logging (WAL) - https://scaleflux.com/reduce-write-amplification-write-ahead-logging/
• The perils of the “real” client IP - https://adam-p.ca/blog/2022/03/x-forwarded-for/
• How to troubleshoot memory leaks in Go with Grafana Pyroscope - https://grafana.com/blog/2023/04/19/how-to-troubleshoot-memory-leaks-in-go-with-grafana-pyroscope/
• CORBA vs. the Fallacies of Distributed Computing - https://serviceweaver.dev/blog/corba.html
• Testing sync at Dropbox - https://dropbox.tech/infrastructure/-testing-our-new-sync-engine
• Designing futures for Rust - http://aturon.github.io/tech/2016/09/07/futures-design/
• Windows Internals - Special Process Types Explained - https://www.youtube.com/watch?v=GhG6Fc__HEE
• Using your Database as a Queue? Good or bad idea? - https://www.youtube.com/watch?v=DOaDpHh1FsQ
• Motivation & Making Money As A Software Engineer - https://www.youtube.com/watch?v=3W8hUM12gQc
• 22 - DuckDB Internals (CMU Advanced Databases / Spring 2023) - https://www.youtube.com/watch?v=bZOvAKGkzpQ
• Building a low latency game server in golang - https://www.youtube.com/watch?v=WBLpjEDNWqE
• APM vs Observability - https://www.youtube.com/watch?v=dXohgVATzDc
• Rust data modelling wih without OOP - https://www.youtube.com/watch?v=z-0-bbc80JM
• Investing in Systems by Natalie Vais - https://www.youtube.com/watch?v=gG4PTvaVG9E
• 10 Math Concepts for Programmers - https://www.youtube.com/watch?v=bOCHTHkBoAs
• How This Miracle Rock Changed the World Forever - https://www.youtube.com/watch?v=VN0p95sNsfo
• "Consistency without consensus in production systems" by Peter Bourgon - https://www.youtube.com/watch?v=em9zLzM8O7c
• What Is a Database? by Jamie Brandon - https://www.youtube.com/watch?v=MqbVoSs0lXk
• Distributed Database Design Decisions to Support High Performance Event Streaming - https://www.scylladb.com/2022/09/21/distributed-database-design-decisions-to-support-high-performance-event-streaming/?utm_medium=social%20media%20-%20organic&utm_source=twitter&utm_term=bg
• Getting the Most out of Lightweight Transactions in ScyllaDB - https://www.scylladb.com/2020/07/15/getting-the-most-out-of-lightweight-transactions-in-scylla/
• Scylladb: Lightweight transactions at lightning speed - https://www.youtube.com/watch?v=Jk1CsRZ7QJc
• Wikipedia: ACID - https://en.wikipedia.org/wiki/ACID
• Two-phase locking - https://en.wikipedia.org/wiki/Two-phase_locking
• Serious Ben: Exploring the PROXY protocol - https://seriousben.com/posts/2020-02-exploring-the-proxy-protocol/#proxy-protocol-version-2
• Malware Development: Processes, Threads, and Handles - https://www.youtube.com/watch?v=aNEqC-U5tHM
• A proposal for more reliable locks using Redis - http://antirez.com/news/77
• Aphyr: the trouble with timestamps - https://aphyr.com/posts/299-the-trouble-with-timestamps
• Martin Kleppmann: How to do distributed locking - https://martin.kleppmann.com/2016/02/08/how-to-do-distributed-locking.html
• Everything you need to know about unsafe.Pointer in Golang - https://www.youtube.com/watch?v=3HgqRW09w4s
• Osa1: My thoughts on OCaml - https://osa1.net/posts/2023-04-24-ocaml-thoughts.html
• Werner Vogels: Eventually consistent - https://queue.acm.org/detail.cfm?id=1466448
• Samwho: Load balancing - https://samwho.dev/load-balancing/
• Scylladb docs: Counters - https://docs.scylladb.com/stable/using-scylla/counters.html
• Werner Vogels: Eventually consistent - https://queue.acm.org/detail.cfm?id=1466448
• A gradual type system for Elixir - https://www.irif.fr/_media/users/gduboc/elixir-types.pdf
• Raft or not? The Best Solution to Data Consistency in Cloud-native Databases - https://milvus.io/blog/raft-or-not.md
• Amazon Aurora under the hood: quorums and correlated failure - https://aws.amazon.com/blogs/database/amazon-aurora-under-the-hood-quorum-and-correlated-failure/
• ScyllaDB 1.7 introduces experimental support for counters - https://www.scylladb.com/2017/04/04/counters/
• Dijkstra: On the cruelty of really teaching computing science - https://www.cs.utexas.edu/users/EWD/transcriptions/EWD10xx/EWD1036.html
• TigerStyle! (Or How To Design Safer Systems in Less Time) by Joran Dirk Greef - https://www.youtube.com/watch?v=w3WYdYyjek4
• AWS re:Invent 2022 - Journey to cell-based microservices architecture on AWS for hyperscale (ARC312) - https://www.youtube.com/watch?v=ReRrhU-yRjg
• Ottertune: The Part of PostgreSQL We Hate the Most - https://ottertune.com/blog/the-part-of-postgresql-we-hate-the-most/
• (zig) Testing and Files as Structs - https://zig.news/aryaelfren/testing-and-files-as-structs-n94
• Martin Kleppmann: Distributed Systems 7.2: Linearizability - https://www.youtube.com/watch?v=noUNH3jDLC0
• Martin Kleppmann: Distributed Systems 4.2: Broadcast ordering - https://www.youtube.com/watch?v=A8oamrHf_cQ&list=PLeKd45zvjcDFUEv_ohr_HdUFe97RItdiB&index=27
• Martin Kleppman: Distributed Systems 4.3: Broadcast algorithms - https://www.youtube.com/watch?v=77qpCahU3fo&list=PLeKd45zvjcDFUEv_ohr_HdUFe97RItdiB&index=13
• What, exactly, is Object-oriented Programming? - https://dev.to/ga_ts/what-exactly-is-object-oriented-programming-5a7a
• Static vs Dynamic dispatch - https://gist.github.com/greister/37289c6eb3629d4fefa7dd0acf6de378
• Modern C++ Won't Save Us - https://alexgaynor.net/2019/apr/21/modern-c++-wont-save-us/
• Martin Kleppmann: Please stop calling databases CP or AP - https://martin.kleppmann.com/2015/05/11/please-stop-calling-databases-cp-or-ap.html
• Conflict-free Replicated Data Types: An Overview - https://arxiv.org/pdf/1806.10254.pdf
• Strings & Palindromes | Recursion Series - https://www.youtube.com/watch?v=n1AUAP7FdXI
• Russ Cox: Go Data Structures: Interfaces - https://research.swtch.com/interfaces
• The Power Of Golang's Decorator Pattern - https://www.youtube.com/watch?v=GipAZwKFgoA

May

• Open Versus Closed: A Cautionary Tale - https://muratbuffalo.blogspot.com/2023/05/open-versus-closed-cautionary-tale.html
• Chapter 9 - Consistency and Consensus (Part Two) - https://timilearning.com/posts/ddia/part-two/chapter-9-2/
• Coda Hale: You Can’t Sacrifice Partition Tolerance - https://codahale.com/you-cant-sacrifice-partition-tolerance/
• Mongodb: What about Durability? - https://www.mongodb.com/blog/post/what-about-durability
• Jeff Hodges: Notes on Distributed Systems for Young Bloods - https://www.somethingsimilar.com/2013/01/14/notes-on-distributed-systems-for-young-bloods/
• Arnon Rotem-Gal-Oz: Fallacies of Distributed Computing Explained - https://arnon.me/wp-content/uploads/Files/fallacies.pdf
• Keynote: Silence is Golden: Coordination-Avoiding Systems Design - https://www.youtube.com/watch?v=EYJnWttrC9k
• CHOOSE BORING TECHNOLOGY CULTURE - https://charity.wtf/2023/05/01/choose-boring-technology-culture/
• A Deep Dive in How Slow SELECT * is - https://www.youtube.com/watch?v=wybjsKtA9hI
• Fly.io: Reliability: It’s Not Great - https://community.fly.io/t/reliability-its-not-great/11253
• Quickwit: Efficient indexing with Quickwit Rust actor framework - https://quickwit.io/blog/quickwit-actor-framework
• Using Rustlang's Async Tokio Runtime for CPU-Bound Tasks - https://www.influxdata.com/blog/using-rustlangs-async-tokio-runtime-for-cpu-bound-tasks/
• Cut Your S3 Spending With Amazon S3 Storage Lens - https://www.youtube.com/watch?v=mJuOtZs3orM
• Rust Kernel Programming - https://coderjoshdk.github.io/posts/Rust-Kernel-Programming.html
• What makes an Aggregate (DDD)? Hint: it's NOT hierarchy & relationships - https://www.youtube.com/watch?v=djq0293b2bA
• L9: Paxos Simplified - https://www.youtube.com/watch?v=SRsK-ZXTeZ0
• Distributed Systems 5.1: Replication - https://www.youtube.com/watch?v=mBUCF1WGI_I&list=PLeKd45zvjcDFUEv_ohr_HdUFe97RItdiB&index=20
• Stabilizing async fn in traits in 2023 - https://blog.rust-lang.org/inside-rust/2023/05/03/stabilizing-async-fn-in-trait.html
• The Most Efficient Struct Configuration Pattern For Golang - https://www.youtube.com/watch?v=MDy7JQN5MN4
• The pendulum swings! Microservices to Monoliths - https://www.youtube.com/watch?v=BFcxgcoO5Ns
• Bootstrapping Uber’s Infrastructure on arm64 with Zig - https://www.uber.com/en-US/blog/bootstrapping-ubers-infrastructure-on-arm64-with-zig/
• Main problems of the multithreaded servers with blocking I/O - https://habr.com/en/articles/676656/
• What is gVisor? - https://gvisor.dev/docs/
• Monoliths are not dinosaurs - https://www.allthingsdistributed.com/2023/05/monoliths-are-not-dinosaurs.html
• Do you understand how "return" ACTUALLY works? (are you SURE?) - https://www.youtube.com/watch?v=e46wHUjNDjE
• Why Apache Kafka Doesn't Need Fsync To Be Safe - https://jack-vanlightly.com/blog/2023/4/24/why-apache-kafka-doesnt-need-fsync-to-be-safe
• Write For Others But Mostly For Yourself - https://jack-vanlightly.com/blog/2022/1/25/write-for-others-but-mostly-for-yourself
• Distributed Consensus Reloaded: Apache ZooKeeper and Replication in Apache Kafka - https://www.confluent.io/blog/distributed-consensus-reloaded-apache-zookeeper-and-replication-in-kafka/
• Why engineers need to be bored. - https://onengineering.substack.com/p/why-engineers-need-to-be-bored?r=1uysoh&utm_campaign=post&utm_medium=web
• Dude, where’s my metadata? - https://fpj.systems/2015/05/28/dude-wheres-my-metadata/
• Hands-Free Kafka Replication: A Lesson in Operational Simplicity - https://www.confluent.io/blog/hands-free-kafka-replication-a-lesson-in-operational-simplicity/
• Fear makes you a worse programmer - https://jvns.ca/blog/2014/12/21/fear-makes-you-a-worse-programmer/
• More Turing-completeness in surprising places - kristerw.blogspot.com/2016/01/more-turing-completeness-in-surprising.html
• Arenas, strings and Scuffed Templates in C - https://www.youtube.com/watch?v=3IAlJSIjvH0
• ECC memory - https://en.wikipedia.org/wiki/ECC_memory
• VOPR'izing TigerBeetle - https://www.youtube.com/watch?v=0esGaX5XekM
• Linearizability versus Serializability - www.bailis.org/blog/linearizability-versus-serializability/
• Raft does not Guarantee Liveness in the face of Network Faults - https://decentralizedthoughts.github.io/2020-12-12-raft-liveness-full-omission/
• When is "ACID" ACID? Rarely. - www.bailis.org/blog/when-is-acid-acid-rarely/
• On hiring, rehiring, and one question to answer them all - https://world.hey.com/jason/on-hiring-rehiring-and-one-question-to-answer-them-all-5db97bcb
• Top 7 Most-Used Distributed System Patterns - https://www.youtube.com/watch?v=nH4qjmP2KEE
• Mastering Dependency Injection In Golang - https://www.youtube.com/watch?v=UX4XjxWcDB4
• Difference between Kafka and Redpanda - Thread per Core Architecture - https://www.youtube.com/watch?v=fluRjLXDf-E
• The Go 1.19 Atomic Wrappers and why to use them - https://medium.com/@deckarep/the-go-1-19-atomic-wrappers-and-why-to-use-them-ae14c1177ad8
• [EN]Real World Applications with the Ruby Fiber Scheduler / Samuel Williams @ioquatix - https://www.youtube.com/watch?v=yXyj9wlkJKM
• Is Sequential IO Dead In The Era Of The NVMe Drive? - https://jack-vanlightly.com/blog/2023/5/9/is-sequential-io-dead-in-the-era-of-the-nvme-drive
• The power of the adversary - https://decentralizedthoughts.github.io/2019-06-07-modeling-the-adversary/
• Interledger Community Call - 25 November 2020 - https://www.youtube.com/watch?v=J1OaBRTV2vs
• The string type is broken - https://mortoray.com/the-string-type-is-broken/
• Open and Closed, Omission and Collapse - https://brooker.co.za/blog/2023/05/10/open-closed.html
• Fixing retries with token buckets and circuit breakers - https://brooker.co.za/blog/2022/02/28/retries.html
• Webinar — Under the Hood of a Shard-per-Core Architecture - https://www.youtube.com/watch?v=Fo1dPRqbF-Q
• Microsoft Azure security evolution: Embrace secure multitenancy, Confidential Compute, and Rust - https://azure.microsoft.com/en-us/blog/microsoft-azure-security-evolution-embrace-secure-multitenancy-confidential-compute-and-rust/
• Julia Evans: Introducing "Implement DNS in a Weekend" - https://jvns.ca/blog/2023/05/12/introducing-implement-dns-in-a-weekend/
• Implementing DNS in a Weeknd - https://implement-dns.wizardzines.com/book/part_1.html
• Sitting on the bench - https://world.hey.com/dhh/sitting-on-the-bench-ba937b84
• Secret To Optimizing SQL Queries - Understand The SQL Execution Order - https://www.youtube.com/watch?v=BHwzDmr6d7s
• Maker's schedule, manager's schedule - www.paulgraham.com/makersschedule.html
• Announcing unsend - https://notgull.github.io/unsend/
• Taking advantage of state machine concepts to organize code - https://balliegojr.github.io/state-machine/
• Database Sharding Explained - https://architecturenotes.co/database-sharding-explained/
• The threshold adversary - https://decentralizedthoughts.github.io/2019-06-17-the-threshold-adversary/
• MySQL Limitations Part 4: One Thread per Connection - https://www.percona.com/blog/mysql-limitations-part-4-one-thread-per-connection/
• "Simulation Testing" by Michael Nygard - https://www.youtube.com/watch?v=N5HyVUPuU0E
• Kora: The Cloud Native Engine for Apache Kafka - https://www.confluent.io/blog/cloud-native-data-streaming-kafka-engine/
• Kafka vs Redpanda Performance - Do the claims add up? - https://jack-vanlightly.com/blog/2023/5/15/kafka-vs-redpanda-performance-do-the-claims-add-up
• Have you replaced your DB because of the Repository Pattern? - https://www.youtube.com/watch?v=EwKhyp2kHME
• Focusing Your Unconscious Mind: Learn Hard Concepts Intuitively (And Forever) - https://www.youtube.com/watch?v=Dm68uFy6gus
• Retries and Saga pattern in Workflows - https://www.youtube.com/watch?v=yqMKr37mGJw
• Golang Performance Hack That Reduces GC Overhead - https://www.youtube.com/watch?v=aThn7jvYvGI
• Getting started with tracing and Grafana Tempo - https://grafana.com/go/webinar/getting-started-with-tracing-and-grafana-tempo-amer/?pg=docs-tempo-latest-getting-started-example-demo-app&plcmt=related
• How I became a software architect... (or not) - https://www.youtube.com/watch?v=6j-PyJ1tFn8
• PHP: a fractal of bad design - https://eev.ee/blog/2012/04/09/php-a-fractal-of-bad-design/
• Efficiency trades off against resiliency - https://blog.nelhage.com/post/efficiency-vs-resiliency/
• A governance system, if you can keep it - https://without.boats/blog/if-you-can-keep-it/
• How Much Memory Do You Need to Run 1 Million Concurrent Tasks? - https://pkolaczk.github.io/memory-consumption-of-async/
• Local Async Executors and Why They Should be the Default - https://maciej.codes/2022-06-09-local-async.html
• Oxidizing OCaml: Locality - https://blog.janestreet.com/oxidizing-ocaml-locality/
• Stream Processing with Kafka - https://hackingwithrust.substack.com/p/stream-processing-with-kafka
• The Power Of Golang's TeeReader Solved My Problem - https://www.youtube.com/watch?v=fGmOKJxlGxY
• Internals of Maps in Golang - https://www.youtube.com/watch?v=ACQs6mdylxo
• Inspecting the map header in Golang - https://www.youtube.com/watch?v=fe_omYMdnKY
• Why Databases Write Ahead - https://aneesh.mataroa.blog/blog/why-databases-write-ahead/
• Tokio, FuturesUnordered, and the Thundering Herd Problem - https://blog.polybdenum.com/2023/05/15/tokio-futuresunordered-and-the-thundering-herd-problem.html
• Eventually Consistent - Revisited - https://www.allthingsdistributed.com/2008/12/eventually_consistent.html
• Top 6 Most Popular API Architecture Styles - https://www.youtube.com/watch?v=4vLxWqE94l4
• How Dropbox Saved Millions By Migrating From On-Prem to AWS - https://www.youtube.com/watch?v=KrkuTQjpvgs

June

• Tunnel SSH Directly To HTTP With GoLang!? - https://www.youtube.com/watch?v=RK5xh7xH1Jw
• HELP! My system is hard to change - https://www.youtube.com/watch?v=jyX7nt1wQwg
• How does HTTP/2 solve the Head of Line blocking (HOL) issue - https://community.akamai.com/customers/s/article/How-does-HTTP-2-solve-the-Head-of-Line-blocking-HOL-issue?language=en_US
• RubyConfTH 2022 - Keynote: A Beginner's Guide to Puma Internals by Nate Berkopec - https://www.youtube.com/watch?v=w4X_oBuPmTM
• QCon London '23 — A New Era for Database Design with TigerBeetle - https://www.youtube.com/watch?v=_jfOk4L7CiY
• What do others do without tests? - https://registerspill.thorstenball.com/p/what-do-others-do-without-tests
• going fast is about doing less - https://www.youtube.com/watch?v=5rb0vvJ7NCY
• How I Structured My Side Project In Go - Sendit.sh - https://www.youtube.com/watch?v=a6Q5KseZ47s
• From Stacks to Trees: A new aliasing model for Rust - https://www.ralfj.de/blog/2023/06/02/tree-borrows.html
• A locking war story - https://sentry.engineering/blog/locking-war-story
• On Raft, briefly - https://www.the-paper-trail.org/post/2013-10-31-on-raft-briefly/
• Writing an interpreter... in OCaml?!? - https://www.youtube.com/watch?v=NjKJ9-ejR6o
• how NASA writes space-proof code - https://www.youtube.com/watch?v=GWYhtksrmhE
• SAVE Your Database With REDIS!!! Write Through Cache Explained! - https://www.youtube.com/watch?v=rNU3afjpTWc
• Writing a SQL database, take two: Zig and RocksDB - https://notes.eatonphil.com/zigrocks-sql.html
• Single Abstract Method Traits - https://mcyoung.xyz/2023/05/11/sam-closures/
• The Rust I Wanted Had No Future - https://graydon2.dreamwidth.org/307291.html
• Top 5 Most-Used Deployment Strategies - https://www.youtube.com/watch?v=AWVTKBUnoIg
• Big Data Processing Using Distributed Maps and AWS Step Functions (S3 + Lambda) - https://www.youtube.com/watch?v=0Zs5s5F_lFc
• Effortless JSON in C++ with folly::dynamic - https://www.youtube.com/watch?v=3XubaLCDYOM
• SQL vs. NoSQL Explained (in 4 Minutes) - https://www.youtube.com/watch?v=_Ss42Vb1SU4
• How to seed a new Microservice with data? - https://www.youtube.com/watch?v=RcVf-R7RZcY
• Mark Zuckerberg: Future of AI at Meta, Facebook, Instagram, and WhatsApp | Lex Fridman Podcast - https://www.youtube.com/watch?v=Ff4fRgnuFgQ
• The Extravagant Business of Cruises - https://www.youtube.com/watch?v=QqQtV7wHSV0
• how Google writes future-proof C++ - https://www.youtube.com/watch?v=6lU11IHfJgo
• Top 5 Cost Optimization Tips Every AWS User Should Know - https://www.youtube.com/watch?v=T-viaT391aQ
• How to Reverse Engineer Go Binaries - GoLang Malware Analysis - https://www.youtube.com/watch?v=cBdY5Y16OR4
• "Clean Architecture" and indirection. No thanks. - https://www.youtube.com/watch?v=_rgH0Kb9Bis
• Amazon GuardDuty Deep Dive - https://www.youtube.com/watch?v=M4aOKikd7-s
• Use Arc Instead of Vec - https://www.youtube.com/watch?v=A4cKi7PTJSs
• GopherCon 2019: Chris Hines - Death by 3,000 Timers: Streaming Video-on-Demand for Cable TV - https://www.youtube.com/watch?v=h0s8CWpIKdg
• everyone can learn assembly QUICKLY (arm64 breakdown) - https://www.youtube.com/watch?v=vhyettT7sdA
• Big O myths busted! (Time complexity is complicated) - https://www.youtube.com/watch?v=7VHG6Y2QmtM
• From Linear Types to Rust - https://www.youtube.com/watch?v=BWuozpQ_Of8
• Why Databases Write Ahead - https://aneesh.mataroa.blog/blog/why-databases-write-ahead/
• Everything You Always Wanted To Know About fsync() - https://blog.httrack.com/blog/2013/11/15/everything-you-always-wanted-to-know-about-fsync/
• "Transactions: myths, surprises and opportunities" by Martin Kleppmann - https://www.youtube.com/watch?v=5ZjhNTM8XU8
• Lambda + SQS Users Should Know About This - https://www.youtube.com/watch?v=0707Py8Jyf0
• Simple Functional Effects with Tag Unions • Richard Feldman • YOW! 2022 - https://www.youtube.com/watch?v=7SidSvJcPd0
• RabbitMQ Is Boring, and I Love It - https://thenewstack.io/rabbitmq-is-boring-and-i-love-it/
• Fault Handling with retry and circuit breaker design patterns by Devlin Duldulao - https://www.youtube.com/watch?v=Uxncuk-vocI
• 🛠️ Windows Virtual Memory Explained 📚 Windows Internals 💻 - https://www.youtube.com/watch?v=CdQ2EYKfB8g
• Distributed isn't Microservices, In-Process isn't a Monolith - https://www.youtube.com/watch?v=qndSXhknxRc
• Anti-corruption Layer for mapping between Boundaries - https://www.youtube.com/watch?v=Dok2Ikcjaro
• Differences between Apache Kafka and Redpanda - Avoid garbage collection - https://www.youtube.com/watch?v=UQ8yrbcTBsY
• everyone can become BIG BRAIN assembly programmers in only 10 minutes. (yes, YOU!) - https://www.youtube.com/watch?v=6S5KRJv-7RU
• LMAX - How to Do 100K TPS at Less than 1ms Latency - https://www.infoq.com/presentations/LMAX/
• Apache Kafka in 6 minutes - https://www.youtube.com/watch?v=-SxtMWxBW1Q
• Is the COST of JavaScript’s GC REALLY that high? - https://www.youtube.com/watch?v=easvMCCBFkQ
• Metaprogramming in Zig and parsing CSS - https://notes.eatonphil.com/2023-06-19-metaprogramming-in-zig-and-parsing-css.html
• Peta-Byte Scale Web Crawler - https://ocaml.org/success-stories/peta-byte-scale-web-crawler
• 10 Tips for Building Resilient Payment Systems - https://shopify.engineering/building-resilient-payment-systems
• Understanding Mergesort: Sorting Made Simple | Recursion Series - https://www.youtube.com/watch?v=-3u1C1URNZY
• Browserless app runtime in Rust - Demo app in Zig - Wasm/WebGPU - https://www.youtube.com/watch?v=VhCgep06-I8
• PostgreSQL reconsiders its process-based model - https://lwn.net/SubscriberLink/934940/3abb2d4086680b78/
• How This One Question Breaks Computers - https://www.youtube.com/watch?v=sG0obNcgNJM
• Code Review & Refactoring to a better design - https://www.youtube.com/watch?v=ka0Ag98_o_g
• Fibers, Oh My! # - https://graphitemaster.github.io/fibers/
• WAL: Everything you want to know - https://www.youtube.com/watch?v=feTihjJJs3g
• How to connect a private data source - https://www.youtube.com/watch?v=9pnf2U3KhG4
• What is Redpanda BYOC? - https://www.youtube.com/watch?v=gVlzsJAYT64
• How To Speak Rust - https://www.youtube.com/watch?v=bu_gulee89Q
• "Functional distributed systems beyond request/response" by Melinda Lu - https://www.youtube.com/watch?v=VWrpnT8rwVY
• Making variables atomic in C - https://www.youtube.com/watch?v=_xX25ThomIo
• NixOS in 60 seconds - https://www.youtube.com/watch?v=Ukglm5KJFa8
• How to Map Files into Memory in C (mmap, memory mapped file io) - https://www.youtube.com/watch?v=m7E9piHcfr4
• The Call Stack and Stack Overflows (example in C) - https://www.youtube.com/watch?v=jVzSBkbfdiw
• Database Auto increment vs UUID - Which is Right for You? - https://www.youtube.com/watch?v=5Xog8d_2um4
• Universal Compaction in RocksDB and me - smalldatum.blogspot.com/2023/06/universal-compaction-in-rocksdb-and-me.html
• Building an MQTT Broker from Scratch with Rust and Lunatic: Part 1 - https://medium.com/@yuriy.voshch/building-an-mqtt-broker-from-scratch-with-rust-and-lunatic-part-1-bff5a2a58f61
• Building an MQTT Broker from Scratch with Rust and Lunatic: Part 2 - https://medium.com/@yuriy.voshch/building-an-mqtt-broker-from-scratch-with-rust-and-lunatic-part-2-8403f8cace09
• My Tips On Hyper-Productivity As A Software Engineer - https://www.youtube.com/watch?v=cY1irhk57w4
• Topics, Partitions and Offsets: Apache Kafka - https://www.youtube.com/watch?v=UHjSP7nxk7g
• Struct packing: No, you're not going crazy. - https://www.youtube.com/watch?v=grk4QUDveFw
• Why fsync(): Losing unsynced data on a single node leads to global data loss - https://redpanda.com/blog/why-fsync-is-needed-for-data-safety-in-kafka-or-non-byzantine-protocols?utm_source=twitter&utm_medium=social&utm_campaign=may16_social&utm_assettype=blog&utm_assetname=fsync
• Wasm + Kubernetes: Beyond Containers - Sean Isom, Adobe & Colin Murphy, Adobe - https://www.youtube.com/watch?v=1_iCimJrLzM
• Understanding Raft - https://arorashu.github.io/posts/raft.html
• Rust fact vs. fiction: 5 Insights from Google's Rust journey in 2022 - https://opensource.googleblog.com/2023/06/rust-fact-vs-fiction-5-insights-from-googles-rust-journey-2022.html
• Your Variables are Not Real. - https://www.youtube.com/watch?v=YO6K5K1TUj4
• "How to Have your Causality and Wall Clocks, Too" by Jon Moore - https://www.youtube.com/watch?v=YqNGbvFHoKM
• Keep Your Network Traffic in AWS with VPC Endpoints | Overview and Tutorial - https://www.youtube.com/watch?v=jo3X_aay4Vs
• Work distribution with Jump Consistent Hashing - https://zacksiri.dev/posts/work-distribution-with-jump-consistent-hashing
• How Rust transforms into Machine Code. - https://www.reddit.com/r/rust/comments/13zdmvc/how_rust_transforms_into_machine_code/
• vDSO - https://en.wikipedia.org/wiki/VDSO
• On the Costs of Syscalls - https://gms.tf/on-the-costs-of-syscalls.html
• Introducing MIR - https://blog.rust-lang.org/2016/04/19/MIR.html
• Single() or First()? Understand the abstractions you use! - https://www.youtube.com/watch?v=bxZ8-Qt3eKk
• Learn How To Write YARA Rules for Malware Detection - https://www.youtube.com/watch?v=zzpz3VYKzUw
• A new era for cluster coordination in Elasticsearch - https://www.elastic.co/blog/a-new-era-for-cluster-coordination-in-elasticsearch
• Sequence IDs: Coming Soon to an Elasticsearch Cluster Near You - https://www.elastic.co/blog/elasticsearch-sequence-ids-6-0
• Repeatable Read vs Snapshot Isolation - https://jaymcor.github.io/notes/isolation_rr_si.html
• WebTransport is a Game Changer Protocol - https://www.youtube.com/watch?v=SEF8VBYlLik
• What if my command was rejected? - https://milestone.topics.it/2023/06/27/reject-commands.html
• Kubernetes NodePort vs LoadBalancer vs Ingress - https://www.youtube.com/watch?v=RQbc_Yjb9ls
• OAuth 2 Explained In Simple Terms - https://www.youtube.com/watch?v=ZV5yTm4pT8g
• Golang Fiber Auth Middleware Setup For My New Side Hustle - https://www.youtube.com/watch?v=b3t8848Tqvg
• Choose the Right Option - https://www.youtube.com/watch?v=6c7pZYP_iIE
• I caught an exception. Now what? - https://particular.net/blog/but-all-my-errors-are-severe
• Tales of a reservation - https://milestone.topics.it/2021/05/05/tales-of-a-reservation.html
• What is the deal with security and distributed systems? - https://milestone.topics.it/2022/11/01/security-and-soa.html
• Demystifying the role of a founding engineer - https://basecase.vc/blog/founding-engineer
• 9 fintech engineering mistakes - https://startupwin.kelsus.com/p/9-fintech-engineering-mistakes
• An Elegant DB Schema for Double-Entry Accounting - https://blog.journalize.io/posts/an-elegant-db-schema-for-double-entry-accounting/

July

• The right way to define a C function with no arguments - https://www.youtube.com/watch?v=VsRs0H4hXEE
• TREE-STRUCTURED CONCURRENCY — 2023-07-01 - https://blog.yoshuawuyts.com/tree-structured-concurrency/
• Myths Programmers Believe about CPU Caches - https://software.rajivprab.com/2018/04/29/myths-programmers-believe-about-cpu-caches/
• Eventual vs Strong Consistency in Distributed Databases - https://hackernoon.com/eventual-vs-strong-consistency-in-distributed-databases-282fdad37cf7
• Accounting For Developers, Part I - https://www.moderntreasury.com/journal/accounting-for-developers-part-i
• Accounting For Developers, Part II - https://www.moderntreasury.com/journal/accounting-for-developers-part-ii
• Accounting for Developers Part III: Building a Lending Marketplace - https://www.moderntreasury.com/journal/accounting-for-developers-part-iii
• What is a Wire Transfer? - https://www.moderntreasury.com/learn/what-is-a-wire-transfer
• What is RTP? - https://www.moderntreasury.com/learn/what-is-rtp
• vTables for Game Hacking & VMT Hooking - https://www.youtube.com/watch?v=HfrBdf-hM28
• API vs. Messaging — How to Choose Which One to Use? - https://betterprogramming.pub/api-vs-messaging-how-to-choose-which-one-to-use-d6634599d2bd
• Kubernetes Basics: Pods, Nodes, Containers, Deployments & Clusters - https://www.youtube.com/watch?v=6IPu3WU_M0o
• Are You Sure You Want to Use MMAP in Your Database Management System? - https://db.cs.cmu.edu/papers/2022/cidr2022-p13-crotty.pdf
• Content-based filtering & collaborative filtering (Building recommendation systems with TensorFlow) - https://www.youtube.com/watch?v=v90un9ALRzw
• What are Business Rules? It's not this. - https://www.youtube.com/watch?v=FbYcIqVmGRk
• Demystifying the Unusual Evolution of the Netflix API Architecture - https://www.youtube.com/watch?v=Uu32ggF-DWg
• A Gentle Introduction to Linear Algebra - https://machinelearningmastery.com/gentle-introduction-linear-algebra/
• Introduction to Amazon Personalize - https://www.youtube.com/watch?v=3gJmhoLaLIo
• Understanding your Data with Amazon Personalize - https://www.youtube.com/watch?v=TEioktJD1GE
• Solving Real World Use Cases with Amazon Personalize - https://www.youtube.com/watch?v=9N7s_dVVWBE
• how do computers create code? - https://www.youtube.com/watch?v=2y1IgW2T8bo
• What if writing tests was a joyful experience - https://blog.janestreet.com/the-joy-of-expect-tests/
• Quickcheck for Core - https://blog.janestreet.com/quickcheck-for-core/
• Basics of Mathematical Notation for Machine Learning - https://machinelearningmastery.com/basics-mathematical-notation-machine-learning/
• A Real Use Case of Goroutines With Package Context In Golang - https://www.youtube.com/watch?v=5QyxqhLnKmM
• Engineering Intensity - https://ruiper.es/posts/engineering_intensity/
• Implementing a Transactional Outbox Pattern with DynamoDB Streams to Avoid 2-phase Commits - https://medium.com/ssense-tech/implementing-a-transactional-outbox-pattern-with-dynamodb-streams-to-avoid-2-phase-commits-ed0f91e69e9
• StatQuest: K-nearest neighbors, Clearly Explained - https://www.youtube.com/watch?v=HVXime0nQeI
• BRIDGING FUZZING AND PROPERTY TESTING — 2023-07-10 - https://blog.yoshuawuyts.com/bridging-fuzzing-and-property-testing/
• 289 - CONFIABILIDADE & ESCALABILIDADE em aplicações com uso intensivo de DADOS | theWiseDev NFR - https://www.youtube.com/watch?v=EXwJwwOJ1UY
• Why ScyllaDB is Moving to a New Replication Algorithm: Tablets - https://www.scylladb.com/2023/07/10/why-scylladb-is-moving-to-a-new-replication-algorithm-tablets/
• A problem so hard even Google relies on Random Chance - https://www.youtube.com/watch?v=lJYufx0bfpw
• Are You Sure You Want to Use MMAP in Your Database Management System? - https://www.youtube.com/watch?v=1BRGU_AS25c
• Digital Wallet - https://www.moderntreasury.com/learn/digital-wallet
• What is ACH? - https://www.moderntreasury.com/learn/what-is-ach
• How simple can a programming language be? - https://www.youtube.com/watch?v=Fg5En6pbsDA
• Kubernetes Deployment vs. StatefulSet vs. DaemonSet - https://www.youtube.com/watch?v=30KAInyvY_o
• How to Optimize Caching for Transactions - https://audreyccheng.com/blog/transaction-caching/
• How to use mongoDB change streams as a powerful event-driven engine - https://dev.to/woovi/how-to-use-mongodb-change-streams-as-a-powerful-event-driven-engine-4d9c
• Making WebAssembly even faster: Firefox’s new streaming and tiering compiler - https://hacks.mozilla.org/2018/01/making-webassembly-even-faster-firefoxs-new-streaming-and-tiering-compiler/
• Life of a Packet [I] - Michael Rubin, Google - https://www.youtube.com/watch?v=0Omvgd7Hg1I
• Data Lakehouse Architecture & Use-Cases - https://www.youtube.com/watch?v=hB6olelYhr0
• Making FinTech systems safe, reliable, and scalable with Redpanda - https://redpanda.com/blog/data-streaming-for-financial-services
• Announcing Rust 1.71.0 - https://blog.rust-lang.org/2023/07/13/Rust-1.71.0.html
• Focusing on "Entities" leads nowhere good. - https://www.youtube.com/watch?v=v5Fss4fCl8c
• How Functions Function - https://www.youtube.com/watch?v=SqT5YglW3qU
• Single vs. Double Entry Accounting - https://www.moderntreasury.com/learn/single-vs-double-entry-accounting
• Bank Reconciliation - https://www.moderntreasury.com/learn/bank-reconciliation
• What is a Ledger? - https://www.moderntreasury.com/learn/what-is-a-ledger
• How Big Is A Character? - https://www.youtube.com/watch?v=BAGcSyrWiPs
• Scylla Summit 2022: The Future of Consensus in ScyllaDB 5.0 and Beyond - https://www.youtube.com/watch?v=LoriHUqrzso
• I Cheated, and Gave Myself Infinite Hearts in Aladdin for SNES (snes rom hacks) - https://www.youtube.com/watch?v=2ZnAS5_0Z3I
• Accounting for Computer Scientists - https://martin.kleppmann.com/2011/03/07/accounting-for-computer-scientists.html
• Andrew Kelley - Practical DOD - https://vimeo.com/649009599
• Anicet Nougaret - Insights from making a DNN & CNN library from scratch in Rust - https://www.youtube.com/watch?v=GjUM8ejy6kE
• What is Database Sharding? - https://www.youtube.com/watch?v=XP98YCr-iXQ
• Handles are the better pointers - https://floooh.github.io/2018/06/17/handles-vs-pointers.html
• Getting Hands on with io_uring using Go - https://developers.mattermost.com/blog/hands-on-iouring-go/
• Implementing Raft: Part 0 - Introduction - https://eli.thegreenplace.net/2020/implementing-raft-part-0-introduction/
• Implementing Raft: Part 1 - Elections - https://eli.thegreenplace.net/2020/implementing-raft-part-1-elections/
• Implementing Raft: Part 2 - Commands and Log Replication - https://eli.thegreenplace.net/2020/implementing-raft-part-2-commands-and-log-replication/
• Implementing Raft: Part 3 - Persistence and Optimizations - https://eli.thegreenplace.net/2020/implementing-raft-part-3-persistence-and-optimizations/
• How do games like Prince of Persia manipulate time? | Bitwise - https://www.youtube.com/watch?v=GYLBCTTyHsI
• What’s new with io_uring - https://kernel.dk/io_uring-whatsnew.pdf
• Hash chain - https://en.wikipedia.org/wiki/Hash_chain
• Things I Wish I Knew Before Building a Ledger - https://www.andriosrobert.com/p/things-i-wish-i-knew-before-building
• Back to Basics: commands, events, and messages - https://milestone.topics.it/2023/05/25/back-to-basics-messages.html
• The looming demise of the 10x developer: Why an era of enthusiast programmers is coming to an end - https://blog.testdouble.com/posts/2023-07-12-the-looming-demise-of-the-10x-developer/
• NumPy vs SciPy - https://www.youtube.com/watch?v=l3s-_8uTBVA
• The basics of the InnoDB undo logging and history system - https://blog.jcole.us/innodb/
• Visualizing the impact of ordered vs. random index insertion in InnoDB - https://blog.jcole.us/2014/10/02/visualizing-the-impact-of-ordered-vs-random-index-insertion-in-innodb/
• Coroutines for Go - https://research.swtch.com/coro
• 290 - SQL ou NoSQL: EIS A QUESTÃO! 🤔 | theWiseDev SQL - https://www.youtube.com/watch?v=mP11yY6uKmg
• Step Function Callbacks with AWS Lambda | Console Tutorial - https://www.youtube.com/watch?v=Uacjxu_AJTI
• Multi-tenant data isolation with PostgreSQL Row Level Security - https://aws.amazon.com/blogs/database/multi-tenant-data-isolation-with-postgresql-row-level-security/
• MySQL Row-Level Security - https://satoricyber.com/mysql-security/mysql-row-level-security/
• Simulation Testing For Liveness - https://tigerbeetle.com/blog/2023-07-06-simulation-testing-for-liveness/
• Basics of Linear Algebra for Machine Learning - https://machinelearningmastery.com/linear_algebra_for_machine_learning/
• Binary Comparisons for Patch Diffing - BinDiff Tutorial - https://www.youtube.com/watch?v=n06QSoICU6c
• How real user monitoring works in Grafana Cloud Frontend Observability - https://www.youtube.com/watch?v=5MfpcwTEQ6g
• Observe your Rust application with Quickwit, Jaeger and Grafana - https://quickwit.io/blog/observing-rust-app-with-quickwit-jaeger-grafana
• DevOps vs SRE vs Platform Engineering | Clear Big Misconceptions - https://www.youtube.com/watch?v=an8SrFtJBdM
• DDD is just giving a $h!t about your Domain - https://www.youtube.com/watch?v=i0aGAdgbG7A
• Bernard Kolobara – Lunatic - Erlang-inspired runtime for WebAssembly - Rust Vienna May 2023 - https://www.youtube.com/watch?v=VhDUGLdj5hY
• Differences between Apache Kafka and Redpanda: Bypass page cache & optimize for direct memory access - https://www.youtube.com/watch?v=ugZkzonAaqs
• Vertical Slice Architecture, not Layers! - https://www.youtube.com/watch?v=L2Wnq0ChAIA
• Sending generated traces to Grafana Tempo - https://www.youtube.com/watch?v=V5GtJRZtZ90
• A Good Rust Stack - https://www.youtube.com/watch?v=pocWrUj68tU
• Make invalid states unrepresentable - https://geeklaunch.io/blog/make-invalid-states-unrepresentable/
• Book Review: Nine Lies About Work - https://www.daviddaly.me/2023/07/book-review-nine-lies-about-work.html
• Building for Failure - https://encore.dev/blog/building-for-failure
• Why fsync(): Losing unsynced data on a single node leads to global data loss - https://redpanda.com/blog/why-fsync-is-needed-for-data-safety-in-kafka-or-non-byzantine-protocols?utm_source=twitter&utm_medium=social&utm_campaign=may16_social&utm_assettype=blog&utm_assetname=fsync
• The big picture: How Google Photos scaled rapidly on Spanner - https://cloud.google.com/blog/products/databases/google-photos-builds-user-experience-on-spanner/
• Full Circle - https://taliaringer.wordpress.com/2023/07/22/full-circle/
• 6 SQL Joins you MUST know! (Animated + Practice) - https://www.youtube.com/watch?v=Yh4CrPHVBdE
• How This Expression Caused a Global Internet Outage - youtube.com/watch?v=DDe-S3uef2w
• Square vs. Stripe - https://www.investopedia.com/articles/personal-finance/021715/square-vs-stripe.asp
• Qual a diferença entre Instituição de Pagamentos e Instituição Financeira?​ - https://www.iugu.com/blog/instituicao-de-pagamentos
• O que são arranjos de pagamentos e para que eles servem? - https://www.iugu.com/blog/o-que-sao-arranjos-de-pagamentos
• Entenda o que é CIP e veja as mudanças para marketplaces - https://www.iugu.com/blog/cip-camara-interbancaria-pagamentos-o-que-e
• Building an an Early Stage Startup: Lessons from Akita Software - https://blog.pragmaticengineer.com/building-an-an-early-stage-startup/
• O que é uma instituição de pagamento regulamentada pelo BACEN? - https://www.iugu.com/blog/instituicao-de-pagamento-regulamentada-bacen
• Como funciona o mercado de Marketplace no Brasil? - https://www.iugu.com/blog/mercado-de-marketplace-no-brasil
• Token triplo: o que é e como protege os pagamentos digitais? - https://www.iugu.com/blog/token-triplo
• Instituições de pagamento - https://www.bcb.gov.br/estabilidadefinanceira/instituicaopagamento
• Arranjo de Pagamentos: O que sua Startup precisa saber sobre esse sistema - https://ndmadvogados.com.br/artigos/arranjo-de-pagamentos-o-que-sua-startup-precisa-saber-sobre-esse-sistema
• Como criar uma Fintech de Pagamentos para Apostas Esportivas? - https://ndmadvogados.com.br/artigos/como-criar-uma-fintech-de-pagamentos-para-apostas-esportivas
• 23 Sistema de Pagamentos Brasileiro – SPB - https://www.youtube.com/watch?v=1BT2l_REaBI
• Instituição de Pagamento: como obter autorização do Banco Central | NDM na Prática - https://www.youtube.com/watch?v=F8Vt675A78w
• Implementing a Regular Expression Engine - https://deniskyashif.com/2019/02/17/implementing-a-regular-expression-engine/
• Amazon EC2 P5 Instances | Amazon Web Services - https://www.youtube.com/watch?v=S8JR50sVong
• Scaling your API with rate limiters - https://stripe.com/blog/rate-limiters
• Scaling your API with rate limiters - https://gist.github.com/ptarjan/e38f45f2dfe601419ca3af937fff574d
• Using load shedding to survive a success disaster—CRE life lessons - https://cloud.google.com/blog/products/gcp/using-load-shedding-to-survive-a-success-disaster-cre-life-lessons
• Top 7 Ways to 10x Your API Performance - https://www.youtube.com/watch?v=zvWKqUiovAM
• Monitor behind a firewall w/ Private Data source Connect on Grafana Cloud (Grafana Office Hours #04) - https://www.youtube.com/watch?v=9oPe1IICE80
• Path to Event-Driven Architecture. Start capturing INTENT! - https://www.youtube.com/watch?v=sPjj8tVKy6M
• A Simpler Way to See Results - https://www.youtube.com/watch?v=s5S2Ed5T-dc
• 10 Postgres tips for beginners - https://postgres.ai/blog/20230722-10-postgres-tips-for-beginners
• 10 Postgres tips for beginners - https://postgres.ai/blog/20230722-10-postgres-tips-for-beginners
• How Large language Models Work - https://www.youtube.com/watch?v=5sLYAQS9sWQ
• Kubernetes Node Selector vs Node Affinity vs Pod Affinity vs Tains & Tolerations - https://www.youtube.com/watch?v=rX4v_L0k4Hc
• why does polymorphism suck? - https://www.youtube.com/watch?v=aq365yzrTVE
• How to read inference rules - https://cohost.org/prophet/post/2248211-how-to-read-inferenc
• Learning about distributed systems: where to start? - muratbuffalo.blogspot.com/2020/06/learning-about-distributed-systems.html
• The Enemy Within: Running Untrusted Code with gVisor - Ian Lewis, Google - https://www.youtube.com/watch?v=1Ib-rfSzDuM
• I often hear people ask why Kubernetes and Firecracker (FC) can’t just be used together. It seems like an intuitive combination, Kubernetes is popular for orchestration, and Firecracker provides strong isolation boundaries. So why aren’t they compatible yet? Read on 🧵 - https://threadreaderapp.com/thread/1238496944684597248.html
• Kata containers limitations - https://github.com/kata-containers/kata-containers/blob/main/docs/Limitations.md
• Kata Containers, gVisor offer more secure container strategies - https://www.techtarget.com/searchitoperations/tip/Kata-Containers-gVisor-offer-more-secure-container-strategies
• How to deploy Kubernetes with Firecracker? - https://www.padok.fr/en/blog/deploy-kubernetes-firecracker
• Secure Compute Part 2: gVisor Runtime on EKS - https://www.verygoodsecurity.com/blog/posts/secure-compute-part-2
• Firecracker Executor for Apache Mesos - https://www.aventer.biz/en/products/mesos-firecracker/
• DynamoDB Users Need To Know About This Update - https://www.youtube.com/watch?v=vizbUmohKKg
• x64 Virtual Address Translation - https://www.youtube.com/watch?v=W3o5jYHMh8s
• Podman vs. Docker - https://www.youtube.com/watch?v=Xx588nbshlM
• So, you want to deploy on the edge? - https://zknill.io/posts/edge-database/
• Turbo docs: Concepts - https://docs.turso.tech/concepts
• What is a warrant canary? - https://www.cloudflare.com/learning/privacy/what-is-warrant-canary/
• What is select skip locked for in postgresql 9.5 - https://www.2ndquadrant.com/en/blog/what-is-select-skip-locked-for-in-postgresql-9-5/
• SANDBOXING CONTAINERS RUN UNTRUSTED CODE IN A CONTAINER - https://www.scip.ch/en/?labs.20211118
• High-throughput stream processing in Rust - https://noz.ai/hash-pipeline/
• BLAKE3 Is an Extremely Fast, Parallel Cryptographic Hash - https://www.infoq.com/news/2020/01/blake3-fast-crypto-hash/

August

• Aplicação do Open Closed Principle: Exemplo prático com metaprogramação mais polimorfismo - https://www.youtube.com/watch?v=-gOR0WXZmYg
• Firecracker: Lightweight Virtualization for Serverless Applications - https://www.usenix.org/system/files/nsdi20-paper-agache.pdf
• SEC02-BP02 Use temporary credentials - https://docs.aws.amazon.com/wellarchitected/latest/framework/sec_identities_unique.html
• 5 Tips for Building Resilient Architecture - https://www.youtube.com/watch?v=gm6Y4vPlOLg
• Containers at the edge: it’s not what you think, or maybe it is - https://blog.cloudflare.com/containers-on-the-edge/
• What is a Point of Presence (PoP) in networking? - https://rahi.io/articles/what-is-a-point-of-presence-pop-in-networking/
• A Programmer-Friendly I/O Abstraction Over io_uring and kqueue - https://tigerbeetle.com/blog/a-friendly-abstraction-over-iouring-and-kqueue/
• Intrusive linked lists - https://www.data-structures-in-practice.com/intrusive-linked-lists/
• Case Study: TigerBeetle Simulator (VOPR) - https://github.com/LAC-Tech/laterbase/blob/master/deterministic_simulation_testing.md
• Dependency Injection, The Best Pattern - https://www.youtube.com/watch?v=J1f5b4vcxCQ
• How to Add AI to Your Apps Faster with Embedded AI - https://www.youtube.com/watch?v=OThahaOga20
• Why Google and Meta Put Billion Lines of Code In 1 Repository? - https://www.youtube.com/watch?v=x3cANGNPyx0
• Cybersecurity Architecture: Response - https://www.youtube.com/watch?v=Jk79QJCxPkM
• What happens before the Backend gets the Request - https://www.youtube.com/watch?v=gSQoA4SYhJY
• Torturing Postgres: extreme autonomous testing for distributed architectures - https://medium.com/@thinkx_/torturing-postgres-extreme-autonomous-testing-for-distributed-architectures-e1c4139ed72e
• FoundationDB or: How I Learned to Stop Worrying and Trust the Database (Markus Pilman, Snowflake) - https://www.youtube.com/watch?v=OJb8A6h9jQQ
• Autonomous Testing and the Future of Software Development - Will Wilson - https://www.youtube.com/watch?v=fFSPwJFXVlw
• How does the Kernel manage backend Connections? - https://www.youtube.com/watch?v=Mc7hAjgFBvY
• Let’s implement a basic leader election algorithm using Go with RPC - https://itnext.io/lets-implement-a-basic-leader-election-algorithm-using-go-with-rpc-6cd012515358
• Pattern: 3rd Party Registration - https://microservices.io/patterns/3rd-party-registration.html
• Let's implement basic service discovery using Go - https://itnext.io/lets-implement-basic-service-discovery-using-go-d91c513883f6
• Most Common Kubernetes Deployment Strategies (Examples & Code) - https://www.youtube.com/watch?v=lxc4EXZOOvE
• As HashiCorp adopts the BSL, an era of open-source software might be ending - https://www.runtime.news/as-hashicorp-adopts-the-bsl-an-era-of-open-source-software-might-be-ending/
• Configure Grafana private data source connect - https://grafana.com/docs/grafana-cloud/connect-externally-hosted/configure-private-datasource-connect/
• Circuit-level gateway - https://en.wikipedia.org/wiki/Circuit-level_gateway
• Dynamic Reverse Tunnels in SSH - https://blog.benpri.me/blog/2019/05/25/dynamic-reverse-tunnels-in-ssh/
• SOCKS5 Proxies Explained - https://www.youtube.com/watch?v=EfOjTkFR1iw
• Git MERGE vs REBASE: Everything You Need to Know - https://www.youtube.com/watch?v=0chZFIZLR_0
• Database Replication Explained (in 5 Minutes) - https://www.youtube.com/watch?v=bI8Ry6GhMSE
• Database Replication Explained - https://towardsdatascience.com/database-replication-explained-5c76a200d8f3
• Fundamentals of Neural Networks - https://wandb.ai/site/articles/fundamentals-of-neural-networks
• Gradient Descent: All You Need to Know - https://hackernoon.com/gradient-descent-aynk-7cbe95a778da
• Apriori — Association Rule Mining In-depth Explanation and Python Implementation - https://towardsdatascience.com/apriori-association-rule-mining-explanation-and-python-implementation-290b42afdfc6
• is it wrong to use numbers in your code? (low level code review) - https://www.youtube.com/watch?v=cjarxeW9_Wo
• Storing money in MySQL (the right way) - https://www.youtube.com/watch?v=fhwEFZ34c7g
• SOCKS - https://en.wikipedia.org/wiki/SOCKS
• SOCKS 5 — A Proxy Protocol - https://medium.com/@nimit95/socks-5-a-proxy-protocol-b741d3bec66c
• Backward Compatibility, Go 1.21, and Go 2 - https://go.dev/blog/compat
• Containers at the Edge - https://www.youtube.com/watch?v=LBx56Q10G3Q
• How a startup loses its spark - https://blog.johnqian.com/startup-spark
• The Bitter Lesson - www.incompleteideas.net/IncIdeas/BitterLesson.html
• Kubernetes and Platform Engineering Part 1: k8s Operators - https://www.youtube.com/watch?v=1i9C-QWQUE8
• 294 - Concorrência na CLEAN ARCHITECTURE | theWiseDev NFR - https://www.youtube.com/watch?v=QEJUAInPKjw
• Your CPU May be FASTER than You Think - https://www.youtube.com/watch?v=WgTr79htuM4
• A Real World Project Use Case Of Golang's Sync.WaitGroup - https://www.youtube.com/watch?v=96scGqEV0pc
• Why we use the Linux kernel's TCP stack - https://blog.cloudflare.com/why-we-use-the-linux-kernels-tcp-stack/
• Cloud Computing without Containers - https://blog.cloudflare.com/cloud-computing-without-containers/
• Career advice for young system programmers - https://glaubercosta-11125.medium.com/career-advice-for-young-system-programmers-c7443f2d3edf
• Distributed Transactions at Scale in Amazon DynamoDB - https://muratbuffalo.blogspot.com/2023/08/distributed-transactions-at-scale-in.html
• DynamoDB's Best Feature: Predictability - https://brooker.co.za/blog/2022/01/19/predictability.html
• Why do we use the Linux kernel's TCP stack? - jvns.ca/blog/2016/06/30/why-do-we-use-the-linux-kernels-tcp-stack/
• Top 6 Load Balancing Algorithms Every Developer Should Know - https://www.youtube.com/watch?v=dBmxNsS3BGE
• Understanding Transaction Isolation in DynamoDB: From Concepts to Conflicts - https://blog.calvinsd.in/understanding-transaction-isolation-in-dynamodb
• Timestamp-based Algorithms for Concurrency Control in Distributed Database Systems - https://muratbuffalo.blogspot.com/2022/11/timestamp-based-algorithms-for.html
• Fantastic Learning Resources - https://matklad.github.io/2023/08/06/fantastic-learning-resources.html
• CONSENSUS: BRIDGING THEORY AND PRACTICE - https://web.stanford.edu/~ouster/cgi-bin/papers/OngaroPhD.pdf
• Viewstamped Replication Made Famous - Joran Greef - https://www.youtube.com/watch?v=qeWyc8G-lq4
• Revisiting Viewstamped Replication with Brian Oki and James Cowling - https://www.youtube.com/watch?v=ps106zjmjhw
• How To Identify File Types - File Format Analysis Tools - https://www.youtube.com/watch?v=xwpNYpFRLf0
• Kubernetes Canary Deployment (Manual vs Automated) - https://www.youtube.com/watch?v=fWe6k4MmeSg
• What is gained and lost with 63-bit integers? - https://blog.janestreet.com/what-is-gained-and-lost-with-63-bit-integers/
• What Rust Discovered - https://www.youtube.com/watch?v=v6RxJsk8otY
• Starting my own hobby language (again) - https://www.youtube.com/watch?v=2bvltIjqrRg
• The Dark Side of .reserve() - https://www.youtube.com/watch?v=algDLvbl1YY
• Stop using COUNT(id) to count rows - https://www.youtube.com/watch?v=H6juZ8c_Nu8
• Tooling for Tooling - https://uptointerpretation.com/posts/tooling-for-tooling/
• Solutions Architect Interview - How Do CDNs Work? (with Salesforce SA) - https://www.youtube.com/watch?v=j9KT9geE5SU
• Your CPU May be FASTER than You Think - https://www.youtube.com/watch?v=WgTr79htuM4
• Kubernetes and Platform Engineering Part 2: Cluster API - https://www.youtube.com/watch?v=K1fGoWCoeSs
• Data Consistency Between Microservices - https://www.youtube.com/watch?v=uKURpE12Mgo
• Viewstamped Replication explained - https://blog.brunobonacci.com/2018/07/15/viewstamped-replication-explained/
• A Proxy Protocol - https://medium.com/@nimit95/socks-5-a-proxy-protocol-b741d3bec66c
• So Long, Twitter and Reddit - https://andrewkelley.me/post/goodbye-twitter-reddit.html
• Getting into formal specification, and getting my team into it too - https://brooker.co.za/blog/2022/07/29/getting-into-tla.html
• Simple Simulations for System Builders - https://brooker.co.za/blog/2022/04/11/simulation.html
• Stateful Property Testing in Rust - https://blog.readyset.io/stateful-property-testing-in-rust
• Exactly-Once Semantics Are Possible: Here’s How Kafka Does It - https://www.confluent.io/blog/exactly-once-semantics-are-possible-heres-how-apache-kafka-does-it/
• Viewstamped Replication: The Less-Famous Consensus Protocol - https://brooker.co.za/blog/2014/05/19/vr.html
• Everything You Always Wanted To Know About fsync() - https://blog.httrack.com/blog/2013/11/15/everything-you-always-wanted-to-know-about-fsync/
• Why we built Restate - https://www.restate.dev/blog/why-we-built-restate/
• EC2 Enhanced Networking Tutorial - https://www.youtube.com/watch?v=DsNEtIS_q_E
• Top 5 Most Used Architecture Patterns - https://www.youtube.com/watch?v=f6zXyq4VPP8
• Want to build a good API? Here's 5 Tips for API Design. - https://www.youtube.com/watch?v=HBH6qnj0trU
• 5 Strong Opinions On Everyday Rust - https://www.youtube.com/watch?v=8j_FbjiowvE
• Durable Objects: Easy, Fast, Correct — Choose three - https://blog.cloudflare.com/durable-objects-easy-fast-correct-choose-three/
• Serverless Workflows with Durable Functions and Netherite - https://arxiv.org/pdf/2103.00033.pdf
• "Formal Modeling and Analysis of Distributed Systems" by Ankush Desai (Strange Loop 2022) - https://www.youtube.com/watch?v=5YjsSDDWFDY
• The Time Traveler's Guide to Distributed Applications - https://qianli.dev/blog/timetravel
• Kubernetes and Platform Engineering Part 3: Crossplane - https://www.youtube.com/watch?v=CPjAiYSoBRE
• Emulation Fundamentals - Writing A Basic x86 Emulator - https://www.youtube.com/watch?v=HPrqOIdNlrQ

September

• Farewell EC2-Classic, it’s been swell - https://www.allthingsdistributed.com/2023/09/farewell-ec2-classic.html
• Building a Firecracker-Powered Course Platform To Learn Docker and Kubernetes - https://iximiuz.com/en/posts/iximiuz-labs-story/
• The Power Of Struct Embedding And Interfaces In Golang - https://www.youtube.com/watch?v=fXZJu_JuH0A
• Beginners Should Think Differently When Writing Golang - https://www.youtube.com/watch?v=PyDMqgOkiR8
• How to Get Transactions Between (Almost) Any Data Stores - https://petereliaskraft.net/blog/epoxy
• How to do Distributed Transactions the RIGHT way? Microservices - https://www.youtube.com/watch?v=vGOEO6mO674
• "Workflows, a new abstraction for distributed systems" by Dominik Tornow (Strange Loop 2022) - https://www.youtube.com/watch?v=V_5WeVmyhzg
• Domain Modeling Gone Wrong - Part 2 - https://www.youtube.com/watch?v=2Tvb1fA3PLQ
• dbdb: etcd - https://dbdb.io/db/etcd
• Shuffle Sharding: Massive and Magical Fault Isolation - https://aws.amazon.com/blogs/architecture/shuffle-sharding-massive-and-magical-fault-isolation/
• System Design: Apache Kafka In 3 Minutes - https://www.youtube.com/watch?v=HZklgPkboro
• Serializability - https://jepsen.io/consistency/models/serializable
• Strict Serializability - https://jepsen.io/consistency/models/strict-serializable
• Linearizability - https://jepsen.io/consistency/models/linearizable
• What is Linearizability in Distributed System? - https://hongilkwon.medium.com/what-is-linearizability-in-distributed-system-db8bca3d432d
• Towards Inserting One Billion Rows in SQLite Under A Minute - https://avi.im/blag/2021/fast-sqlite-inserts/
• You Cannot Have Exactly-Once Delivery - https://bravenewgeek.com/you-cannot-have-exactly-once-delivery/
• Pagination in MySQL - https://www.youtube.com/watch?v=zwDIN04lIpc
• Free your API. Misconceptions are holding you back! - https://www.youtube.com/watch?v=nS8XHgMvqNo
• Understanding Consensus - https://bravenewgeek.com/understanding-consensus/
• Algorithms You Should Know Before System Design Interviews - https://www.youtube.com/watch?v=xbgzl2maQUU
• Distributed consensus - https://shachaf.net/w/consensus
• are "smart pointers" actually smart? - https://www.youtube.com/watch?v=tSIBKys2eBQ
• There is plenty of room at the bottom - https://muratbuffalo.blogspot.com/2021/08/there-is-plenty-of-room-at-bottom.html
• Raft does not Guarantee Liveness in the face of Network Faults - https://decentralizedthoughts.github.io/2020-12-12-raft-liveness-full-omission/
• What is Zig's “Colorblind” Async/Await? - https://kristoff.it/blog/zig-colorblind-async-await/
• A Gentle Introduction to LLVM IR - https://mcyoung.xyz/2023/08/01/llvm-ir/
• Single-Decree Paxos - https://mwhittaker.github.io/blog/single_decree_paxos/
• I Wrote A String Type - https://mcyoung.xyz/2023/08/09/yarns/
• Little Computer 3 - https://en.wikipedia.org/wiki/Little_Computer_3
• LC3 Instruction Set Architecture - https://winniewjeng.github.io/organization%20&%20programming/2020/06/09/Instruction-Set-Architecture/
• LC3 Machine Instruction - https://winniewjeng.github.io/organization%20&%20programming/2020/06/08/LC3-Machine-Instruction/
• What is a spinlock? //Source Dive// 002 - https://www.youtube.com/watch?v=ZE9OODanrDA
• Sign extension - https://en.wikipedia.org/wiki/Sign_extension
• Use your database to power state machines - https://blog.lawrencejones.dev/state-machines/
• ZooKeeper: Zab vs. Paxos - https://cwiki.apache.org/confluence/display/ZOOKEEPER/Zab+vs.+Paxos
• University of Washington: Replicated State Machines Primary-Backup - https://courses.cs.washington.edu/courses/cse552/19au/notes/lect3.pdf
• Princeton: Replication State Machines via Primary-Backup Replication - https://www.cs.princeton.edu/courses/archive/spring22/cos418/docs/L11-rsm-pb.pdf
• MIT 6.824: Lecture 4: Primary-Backup Replication - https://www.youtube.com/watch?v=M_teob23ZzY
• Large Language Models from scratch - https://www.youtube.com/watch?v=lnA9DMvHtfI
• Large Language Models: Part 2 - https://www.youtube.com/watch?v=YDiSFS-yHwk
• Searching by location in MySQL - https://www.youtube.com/watch?v=QgnCB8X_sN4
• why do header files even exist? - https://www.youtube.com/watch?v=tOQZlD-0Scc
• Alternative to the Outbox Pattern? Not so fast. - https://www.youtube.com/watch?v=cuQ9zuNF1cI
• Container Loading in AWS Lambda - https://brooker.co.za/blog/2023/05/23/snapshot-loading.html
• JDK 21 LTS - All Features Explained! - https://www.youtube.com/watch?v=bgxuSIhkQZg
• 4x shorter WebGPU access from Wasm, featuring Nelua, Zig, & Rust - https://www.youtube.com/watch?v=I-tN3dS2zwA
• Fixing For Loops in Go 1.22 - https://go.dev/blog/loopvar-preview
• Another way to check pointers at runtime in C - https://www.youtube.com/watch?v=xCxI2GIFdZo
• RabbitMQ vs. Kafka – An Architect’s Dilemma (Part 1) - https://eranstiller.com/rabbitmq-vs-kafka-an-architects-dilemma-part-1
• RabbitMQ vs. Kafka – An Architect’s Dilemma (Part 2) - https://eranstiller.com/rabbitmq-vs-kafka-an-architects-dilemma-part-2
• 295 - LOCK otimista no CASO DE USO | theWiseDev CleanArch - https://www.youtube.com/watch?v=e6cxVjv5rN0
• Transactions: Write skew & why we need serialization? - https://distributed-computing-musings.com/2022/02/transactions-write-skew-why-we-need-serialization/
• Transactions: Introduction to serializability techniques - https://distributed-computing-musings.com/2022/02/transactions-introduction-to-serializability-techniques/
• Transactions: Two-phase Locking - https://distributed-computing-musings.com/2022/02/transactions-two-phase-locking/
• Transactions: Serializable Snapshot Isolation - https://distributed-computing-musings.com/2022/02/transactions-serializable-snapshot-isolation/
• Best Developer Interview Question - https://www.youtube.com/watch?v=h1w4X3CmRH4
• How to create an alert rule in Grafana 10.1 - https://www.youtube.com/watch?v=nPdzomH6bno
• New flame graph features for continuous profiling data in Grafana 10.1 - https://www.youtube.com/watch?v=bezFLhbzDOM
• How to to filter trace spans in Grafana 10.1 - https://www.youtube.com/watch?v=VP2XV3IIc80
• Grafana 10.1: TraceQL query results streaming - https://www.youtube.com/watch?v=7BRapaDM_2c
• Understand Paxos with Rust, Automerge, and TLA+ — Part 1: The Synod. - https://medium.com/@polyglot_factotum/understand-paxos-with-rust-automerge-and-tla-part-1-the-synod-371df5f16f45
• Loki Log Context Query Editor in Grafana 10 - https://www.youtube.com/watch?v=t6SG-w_bVss
• What is Podman? How is it Different Than Docker? - https://www.youtube.com/watch?v=5WML8gX2F1c
• Relational Databases vs Time Series Databases - https://www.influxdata.com/blog/relational-databases-vs-time-series-databases/
• Linux network ring buffers - https://medium.com/coccoc-engineering-blog/linux-network-ring-buffers-cea7ead0b8e8
• How do databases execute expressions? - https://notes.eatonphil.com/2023-09-21-how-do-databases-execute-expressions.html
• Rustonomicon: Poisoning - https://doc.rust-lang.org/nomicon/poisoning.html
• Make Kubernetes and Platform Engineering Easier Part 2 Monitoring and Observability - https://www.youtube.com/watch?v=RjtT1Q7DpmQ
• Make Kubernetes and Platform Engineering Easier Part 4: Application Workflows - https://www.youtube.com/watch?v=YPuAAS3lba8
• ORMs can lead to FAT domain models. Slim them down! - https://www.youtube.com/watch?v=4UZXUc9jmHc
• Adding Nested Loops Makes this Algorithm 120x FASTER? - https://www.youtube.com/watch?v=QGYvbsHDPxo
• Mark Zuckerberg: First Interview in the Metaverse | Lex Fridman Podcast #398 - https://www.youtube.com/watch?v=MVYrJJNdrEg
• Faster database indexes (straight from the docs) - https://www.youtube.com/watch?v=5aezDBaNfcc
• Containerization Strategy - https://www.youtube.com/watch?v=iLyBEEkm5e0
• why do void pointers even exist? - https://www.youtube.com/watch?v=t7CUti_7d7c
• The Pros and Cons of Encrypted Client Hello - https://www.youtube.com/watch?v=1ezrBsJCVqw
• Why Do You Only Get Motivated After Midnight? | Night Owls - https://www.youtube.com/watch?v=jiIhOgpOWcA
• Why You Should Be Ashamed Of Yourself - https://www.youtube.com/watch?v=COHThDr1uvg
• Server Name Indication (SNI) TLS Extension Explained - https://www.youtube.com/watch?v=manTiXESYG0
• 50 years later, is Two-Phase Locking the best we can do? - concurrencyfreaks.blogspot.com/2023/09/50-years-later-is-two-phase-locking.html

October

• LULA vs CAMPOS NETO; SELIC CAI MAIS?; TRUMP FAVORITO nas ELEIÇÕES; CHINA DESPEJANDO TREASURIES - https://www.youtube.com/watch?v=ToU30U0vHz8
• Use your database to power state machines - https://blog.lawrencejones.dev/state-machines/
• What to know before debating type systems - https://blogs.perl.org/users/ovid/2010/08/what-to-know-before-debating-type-systems.html
• Hyperdrive: making databases feel like they’re globa - https://blog.cloudflare.com/hyperdrive-making-regional-databases-feel-distributed/
• Pitch Practice with Paul Buchheit and Sam Altman at Startup School SV 2016 - https://www.youtube.com/watch?v=fcyf9z4gSeI
• Kevin Hale - How to Pitch Your Startup - https://www.youtube.com/watch?v=17XZGUX_9iM
• Avoid These Tempting Startup Ideas - https://www.youtube.com/watch?v=GMIawSAygO4
• How Future Billionaires Get Sh*t Done - https://www.youtube.com/watch?v=ephzgxgOjR0
• Tips For Technical Startup Founders | Startup School - https://www.youtube.com/watch?v=rP7bpYsfa6Q
• How to Get Your First Customers | Startup School - https://www.youtube.com/watch?v=hyYCn_kAngI
• Startup Business Models and Pricing | Startup School - https://www.youtube.com/watch?v=oWZbWzAyHAE
• Should You Start A Startup? | Startup School - https://www.youtube.com/watch?v=BUE-icVYRFU
• How to Build An MVP | Startup School - https://www.youtube.com/watch?v=QRZ_l7cVzzU
• The Best Way To Launch Your Startup | Startup School - https://www.youtube.com/watch?v=u36A-YTxiOw
• Using Conditional Put to Solve MongoDB Concurrency Issues - https://dev.to/woovi/using-conditional-put-to-solve-mongodb-concurrency-issues-405a
• Most Important Lifestyle Habits Of Successful Founders - https://www.youtube.com/watch?v=0IShllkCHtY
• How to Get and Evaluate Startup Ideas | Startup School - https://www.youtube.com/watch?v=Th8JoIan4dg
• Design Tinder - System Design Interview (with TikTok Senior Engineer) - https://www.youtube.com/watch?v=iyLqwyFL0Zc
• How to do distributed locking - https://martin.kleppmann.com/2016/02/08/how-to-do-distributed-locking.html
• The Two Mindsets That Can KILL Your Startup - https://www.youtube.com/watch?v=lJausFj_Dto
• Which Sales Strategy Is Best For Your Startup? - https://www.youtube.com/watch?v=o1HFZ8P4rA8
• How To Talk To Users | Startup School - https://www.youtube.com/watch?v=z1iF1c8w5Lg
• The rule of three/five/zero - https://en.cppreference.com/w/cpp/language/rule_of_three
• Turning Your Users Into Paying Customers - https://www.youtube.com/watch?v=9pQJXR0Tcos
• How Startup Fundraising Works | Startup School - https://www.youtube.com/watch?v=zBUhQPPS9AY
• Advantages Of A First-Time Founder - https://www.youtube.com/watch?v=bp_kMA-eTsE
• Why Are There So Many Foundation Models? - https://www.youtube.com/watch?v=QPQy7jUpmyA
• INT(11) is a lie - https://www.youtube.com/watch?v=xYl67AvQci8
• Co-Founder Mistakes That Kill Companies & How To Avoid Them - https://www.youtube.com/watch?v=dlfjs_eEEzs
• Open Sourcing Ferrocene - https://ferrous-systems.com/blog/ferrocene-open-source/
• Raft is so fetch: The Raft Consensus Algorithm explained through "Mean Girls" - https://www.cockroachlabs.com/blog/raft-is-so-fetch/
• The Secrets To Setting Smarter Goals - https://www.youtube.com/watch?v=rE2XaBGHN2I
• Top Ways Startups Waste Money - https://www.youtube.com/watch?v=BtzUo6vL3Iw
• What Basic Game Theory Teaches Us About Startups - https://www.youtube.com/watch?v=gUuQsMERjUc
• Setting KPIs and Goals | Startup School - https://www.youtube.com/watch?v=6DTK9yDP6p0
• Save Your Startup During an Economic Downturn - https://www.youtube.com/watch?v=0OVSTWozvfY
• App Configuration, where does it go? Config files, env vars, external service? - https://www.youtube.com/watch?v=mukJVR-GRcQ
• Where Do Great Startup Ideas Come From? – Dalton Caldwell and Michael Seibel - https://www.youtube.com/watch?v=Jcuqq48CNj8
• Announcing Rust 1.73.0 - https://blog.rust-lang.org/2023/10/05/Rust-1.73.0.html
• AWS PrivateLink for Grafana Cloud - https://www.youtube.com/watch?v=0lreDtiLtwk
• The Advantages Of Queues On Logs - https://jack-vanlightly.com/blog/2023/10/2/the-advantages-of-queues-on-logs
• Deep dive on how static files are served with HTTP (kernel, sockets, file system, memory, zero copy) - https://www.youtube.com/watch?v=rIcahiIklSk
• WebSocket vs. Server-sent Events: A Performance Comparison - https://www.timeplus.com/post/websocket-vs-sse
• DesignGuru Review - Is Grokking Advanced System Design Interview Course Worth it? - https://javarevisited.blogspot.com/2022/07/educative-review-is-grokking-advanced-system-design-interview.html#axzz8Efgvehe5
• The Design and Implementation of Userland Exec - https://grugq.github.io/docs/ul_exec.txt
• Demystifying Consistent Hashing: A Key to Scalable and Efficient Data Distribution - https://theefficientdev.blog/2023/09/09/demystifying-consistent-hashing-a-key-to-scalable-and-efficient-data-distribution/
• Startup Experts Reveal Their Top Productivity Advice - https://www.youtube.com/watch?v=nF_YWdz6S0Y
• CS168: The Modern Algorithmic Toolbox Lecture #1: Introduction and Consistent Hashing - https://web.stanford.edu/class/cs168/l/l1.pdf
• Amazon DynamoDB: A Scalable, Predictably Performant, and Fully Managed NoSQL Database Service(2022) - https://www.usenix.org/system/files/atc22-elhemali.pdf
• Web caching with consistent hashing - https://cs.brown.edu/courses/csci2950-u/f10/papers/chash99www.pdf
• Thread-per-core - https://without.boats/blog/thread-per-core/
• Thread-per-core - https://without.boats/blog/thread-per-core/
• why are switch statements so HECKIN fast? - https://www.youtube.com/watch?v=fjUG_y5ZaL4
• A shallow survey of OLAP and HTAP query engines - https://www.scattered-thoughts.net/writing/a-shallow-survey-of-olap-and-htap-query-engines/
• How to Get Startup Ideas - https://www.youtube.com/watch?v=uvw-u99yj8w
• What Does It REALLY Mean To Do Things That Don't Scale? – Dalton Caldwell and Michael Seibel - https://www.youtube.com/watch?v=4RMjQal_c4U
• The Ugly Truth About Social Network Startups - https://www.youtube.com/watch?v=vAu-oqF5IdQ
• ScyllaDB Ring Architecture - Overview - https://opensource.docs.scylladb.com/stable/architecture/ringarchitecture/
• Should You Follow Your Passion? – Dalton Caldwell and Michael Seibel - https://www.youtube.com/watch?v=KWNNmPCF-Xs
• How To Build Product As A Small Startup - Michael Seibel - https://www.youtube.com/watch?v=kzVvjKLdAbk
• How to make memory read-only in your C programs. - https://www.youtube.com/watch?v=AYSISa95oJE
• CSE138 (Distributed Systems) L15: introduction to sharding; consistent hashing - https://www.youtube.com/watch?v=uNQGP0yupn0&list=PLNPUF5QyWU8PydLG2cIJrCvnn5I_exhYx&index=20
• The Cult of Conformity in Silicon Valley - https://www.youtube.com/watch?v=ia7IKW0yuG0
• Startup Experts Share Their Investor Horror Stories - https://www.youtube.com/watch?v=ljVan7CGBiE
• Grafana documentary series | Preview 1 - https://www.youtube.com/watch?v=qORB9GAqgbU
• Startup Experts Reveal Their Favorite Pivot Stories - https://www.youtube.com/watch?v=DmehFuCMtvc
• Should You Quit Your Job At A Unicorn? - https://www.youtube.com/watch?v=chAoH_AeGAg
• "Integration Events" is a terrible name. Call them... - https://www.youtube.com/watch?v=qf-BSAhbrWw
• Using Retrieval Augmented Generation with a Large Language Model Chatbot - https://www.youtube.com/watch?v=XctooiH0moI
• How to Get Good at Small Talk, and Even Enjoy It - https://www.youtube.com/watch?v=IRG-YubP1rw
• The WORST Domain Modeling Mistakes! - https://www.youtube.com/watch?v=uIfGIlD3lnw

November

• How To NOT Get Screwed As A Software Engineer - https://www.youtube.com/watch?v=fcfVjd_oV1I
• Failing Startups : Maybe I should get a job - https://www.indiehackers.com/post/failing-startups-maybe-i-should-get-a-job-653e1efd52
• Cross shard transactions at 10 million requests per second - https://dropbox.tech/infrastructure/cross-shard-transactions-at-10-million-requests-per-second
• Let's implement a basic hotel reservation system with 2PC using pessimistic and optimistic locks in Go - https://blog.stackademic.com/lets-implement-a-basic-hotel-reservation-system-with-2pc-using-pessimistic-and-optimistic-locks-in-581256d142e8
• Postgres: PREPARE TRANSACTION - https://www.postgresql.org/docs/current/sql-prepare-transaction.html
• Building a Streaming Platform in Go for Postgres - https://blog.peerdb.io/building-a-streaming-platform-in-go-for-postgres
• Using MySQL to stop freeloaders (in only 8 minutes) - https://www.youtube.com/watch?v=goC5BdyCvms
• You don't need NoSQL (use MySQL) - https://www.youtube.com/watch?v=QZBxgX2OWbI
• Towards Modern Development of Cloud Applications - https://dl.acm.org/doi/pdf/10.1145/3593856.3595909
• Diamond Architecture - How to build HUMONGOUS Apps FAST! - Part 5 - Less Boilerplate Please - https://www.youtube.com/watch?v=SQengjF8gXs
• Essence of Domain-Driven Design (DDD) - https://www.youtube.com/watch?v=Y0txTmT3k7M
• Event-Driven Architecture lost its way - https://www.youtube.com/watch?v=YusVrd9rHJU
• Paper Notes: Bitcask – A Log-Structured Hash Table for Fast Key/Value Data - https://distributed-computing-musings.com/2023/01/paper-notes-bitcask-a-log-structured-hash-table-for-fast-key-value-data/
• Wikipedia: readahead - https://en.wikipedia.org/wiki/Readahead
• Manpage: readahead - https://man7.org/linux/man-pages/man2/readahead.2.html
• P99 CONF 2023 | A Deterministic Walk Down TigerBeetle’s main() Street by Aleksei Kladov - https://www.youtube.com/watch?v=AGxAnkrhDGY
• why yelling at your code makes it better (software fuzzing explained) - https://www.youtube.com/watch?v=diUiwAEPjcQ
• Complex database indexing strategies - https://www.youtube.com/watch?v=IcIkjfXoHV4
• Domain Modeling Gone Wrong - Part 1 - https://www.youtube.com/watch?v=0EQCcALt9Cc
• Domain Modeling Gone Wrong - Part 2 - https://www.youtube.com/watch?v=2Tvb1fA3PLQ
• If your service doesn't own data, it's NOT a service. - https://www.youtube.com/watch?v=S46f1-0ciHA
• Transactions Are Not Locks - https://www.benburwell.com/posts/transactions-are-not-locks/
• Rust: Polonius update - https://blog.rust-lang.org/inside-rust/2023/10/06/polonius-update.html
• How to Detect Threads & Bypass Anti-Cheat Detection - https://www.youtube.com/watch?v=KzD_nc5B_8w
• Storing feature flags as JSON (with indexing) - https://www.youtube.com/watch?v=cDzrY-QW4Ck
• Message Queue From Scratch In Golang With Only STD LIB - https://www.youtube.com/watch?v=99OEUGbk3vc
• Store 8 feature flags in 1 integer (Bitwise operations in MySQL) - https://www.youtube.com/watch?v=Kf8SWqljM18
• Criptografia na Prática - Certificados, BitTorrent, Git, Bitcoin - https://www.youtube.com/watch?v=iAA8NrfQtHo
• What Makes The Top 10% Of Founders Different? - Michael Seibel - https://www.youtube.com/watch?v=ZtfTOuSHGg8
• Let's Build A Distributed CAS Storage In Golang - https://www.youtube.com/watch?v=d_pVmR_0p0E
• Why Checked Exceptions Failed - https://borretti.me/article/why-checked-exceptions-failed
• P2P Protocol In Golang For My Distributed CAS - https://www.youtube.com/watch?v=TFkOzuUz6Wo
• Announcing Rust 1.74.0 - https://blog.rust-lang.org/2023/11/16/Rust-1.74.0.html
• Saving a SaaS on the weekend - https://www.youtube.com/watch?v=kkjAxSViOAA
• Build a Monolith and Deploy like Microservices? Maybe with Service Weaver - https://www.youtube.com/watch?v=Srt_8a5Nam0
• Building and operating a pretty big storage system called S3 - https://www.allthingsdistributed.com/2023/07/building-and-operating-a-pretty-big-storage-system.html
• Distributed CAS Storage In Golang - RPC Networking - https://www.youtube.com/watch?v=_5RrYWKbyVg
• Uncensored Models - https://erichartford.com/uncensored-models
• Coding TCP Transport For My P2P Distributed Storage In GO - https://www.youtube.com/watch?v=-Ung58PHgus
• Streaming Large Files In Golang But Distributed - https://www.youtube.com/watch?v=3mO5MUbCzKQ
• Your database will break in 2038 (or sooner) - https://www.youtube.com/watch?v=d6HaTHkXqcQ
• Neural Networks From Scratch in Rust - https://www.youtube.com/watch?v=DKbz9pNXVdE
• Episode 001: Intro and (Absence of) Message Parsing - https://www.youtube.com/watch?v=hPUL8Xo6MJw
• Two Ways To Do Dynamic Dispatch - https://www.youtube.com/watch?v=wU8hQvU8aKM
• How Do You Convince Someone to Join Your Startup? - Dalton Caldwell - https://www.youtube.com/watch?v=N8deM6B4eE4
• The magic of content-addressable storage - https://hal.science/hal-02559031v1/file/content-addressable-storage-preprint.pdf
• There is No Now: Problems with simultaneity in distributed systems - https://queue.acm.org/detail.cfm?id=2745385
• Database enums are weird - https://www.youtube.com/watch?v=ej8jzMloE_4
• Pizza Wars: The Exorcism of Papa John’s - https://www.youtube.com/watch?v=6eAcykBJsUM
• Kubernetes Autoscaling: HPA vs. VPA vs. Keda vs. CA vs. Karpenter vs. Fargate - https://www.youtube.com/watch?v=hsJ2qtwoWZw
• interrupts is threads - https://onevariable.com/blog/interrupts-is-threads/
• MIT 6.824: Distributed systems - Lecture 4: Primary-Backup Replication - https://www.youtube.com/watch?app=desktop&v=M_teob23ZzY&amp%3Bfeature=youtu.be
• ZooKeper wiki: Zab vs. Paxos - https://cwiki.apache.org/confluence/display/ZOOKEEPER/Zab+vs.+Paxos
• The Postgres replication dilemma - https://medium.com/@hnasr/the-postgres-replication-dilemma-72bef6cc4599
• Inside logical replication in PostgreSQL: How it works - https://www.postgresql.fastware.com/blog/inside-logical-replication-in-postgresql
• The cost and benefit of synchronous replication in PostgreSQL and YugabyteDB - https://dev.to/yugabyte/the-cost-and-benefit-of-synchronous-replication-in-postgresql-and-yugabytedb-2ej0
• How I became a machine learning practitioner - https://blog.gregbrockman.com/how-i-became-a-machine-learning-practitioner
• It’s time to become an ML engineer - https://blog.gregbrockman.com/its-time-to-become-an-ml-engineer
• My path to OpenAI - https://blog.gregbrockman.com/my-path-to-openai
• What Is Platform Engineering - https://www.youtube.com/watch?v=JP8-9WXBcgg
• Top 8 Most Popular Network Protocols Explained - https://www.youtube.com/watch?v=P6SZLcGE4us
• You don't* need JOINs - https://www.youtube.com/watch?v=5hsl47I3svw
• Writing Tests For My Distributed File Storage In Golang - https://www.youtube.com/watch?v=MKwYkV9JWLw
• Everything You Know About MongoDB is Wrong! - https://www.mongodb.com/developer/products/mongodb/everything-you-know-is-wrong/
• Why async Rust? - https://without.boats/blog/why-async-rust/
• What is a MESSAGE QUEUE and Where is it used? - https://www.youtube.com/watch?v=oUJbuFMyBDk
• Basic Amazon SQS architecture - https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-basic-architecture.html
• The Big Little Guide to Message Queues - https://sudhir.io/the-big-little-guide-to-message-queues
• Using the expand and contract pattern for schema changes - https://www.prisma.io/dataguide/types/relational/expand-and-contract-pattern
• Andrej Karpathy: [1hr Talk] Intro to Large Language Models - ctwe
• Tim Brady - How Much Equity Should I Give My First Employees? - https://www.youtube.com/watch?v=B2QdN0-fAbw
• Implement Raft in Rust - https://www.pingcap.com/blog/implement-raft-in-rust/
• What is a Multiraft? - https://sergeiturukin.com/2017/06/09/multiraft.html
• Scaling Raft - https://www.cockroachlabs.com/blog/scaling-raft/
• Elasticell: Multi-Raft - https://elasticell.readthedocs.io/en/latest/architecture/multi-raft/
• TiKV: Multi-raft - https://tikv.org/deep-dive/scalability/multi-raft/
• Raft or not? The Best Solution to Data Consistency in Cloud-native Databases - https://milvus.io/blog/raft-or-not.md
• Dan Lüdtke: Implementing Distributed Consensus - https://www.usenix.org/sites/default/files/conference/protected-files/srecon19apac_slides_ludtke.pdf
• Distributed consensus made simple (for real this time!) - https://decentralizedthoughts.github.io/2021-09-30-distributed-consensus-made-simple-for-real-this-time/
• Machine Learning Interview - Design Spotify Recommendations - https://www.youtube.com/watch?v=vyZMYlGBSBM
• Vertical Slice Architecture Myths You Need To Know! - https://www.youtube.com/watch?v=TfMArQnepco
• Database Replication Explained - https://towardsdatascience.com/database-replication-explained-5c76a200d8f3
• Paxos, Raft, EPaxos: How Has Distributed Consensus Technology Evolved? - https://www.alibabacloud.com/blog/paxos-raft-epaxos-how-has-distributed-consensus-technology-evolved_597127
• It’s About Time! - https://brooker.co.za/blog/2023/11/27/about-time.html
• How Git Works: Explained in 4 Minutes - https://www.youtube.com/watch?v=e9lnsKot_SQ
• Many to many relationships in MySQL - https://www.youtube.com/watch?v=csLHXmVLGbs
• Announcing the new Amazon S3 Express One Zone high performance storage class - https://aws.amazon.com/blogs/aws/new-amazon-s3-express-one-zone-high-performance-storage-class/
• S3 Express is All You Need - https://www.warpstream.com/blog/s3-express-is-all-you-need
• The Golang Function Nobody Talks About - https://www.youtube.com/watch?v=INcV8kNlDPM
• How To Build A Tech Startup With No Technical Skills - https://www.youtube.com/watch?v=ZpKu2wvquWg
• Write throughput differences in B-tree vs LSM-tree based databases? - https://www.reddit.com/r/databasedevelopment/comments/187cp1g/write_throughput_differences_in_btree_vs_lsmtree/
• LSM Tree: Data structure powering write heavy storage engines - https://distributed-computing-musings.com/2022/07/lsm-tree-data-structure-powering-write-heavy-storage-engines/
• WiredTiger: Btree vs LSM - https://github.com/wiredtiger/wiredtiger/wiki/Btree-vs-LSM
• How OmniPaxos handles partial connectivity - and why other protocols can’t - https://omnipaxos.com/blog/how-omnipaxos-handles-partial-connectivity-and-why-other-protocols-cant/
• Raft does not Guarantee Liveness in the face of Network Faults - https://decentralizedthoughts.github.io/2020-12-12-raft-liveness-full-omission/
• Design an Amazon S3 or Object Storage - https://www.youtube.com/watch?v=vTPR6fIgC-I
• All Web Services API What are the benefits and drawbacks of using token bucket or leaky bucket for API rate limiting? - https://www.linkedin.com/advice/0/what-benefits-drawbacks-using-token-bucket-leaky

December

• Design a Metrics Aggregation System | Time Series Database Design | Prometheus - https://www.youtube.com/watch?v=SCmN2Sr7fqE&list=PL4kInuyvT-Aw_Bz7l33AwTHXDgD3s0nkv&index=3
• How I add millions of rows to MySQL (for performance testing) - https://www.youtube.com/watch?v=ywp9Z0xZPzo
• The Story of Grafana | Episode 1: Democratize Metrics | Grafana Documentary - https://www.youtube.com/watch?v=k3RQVyeYdO8
• How to (and how not to) design REST APIs - https://www.youtube.com/watch?v=60F8rzP5nQo
• How I read a research paper - https://muratbuffalo.blogspot.com/2013/07/how-i-read-research-paper.html
• Why is Jepsen Written in Clojure? - https://aphyr.com/posts/367-why-is-jepsen-written-in-clojure
• Benchmarking the fastest possible MySQL query - https://www.youtube.com/watch?v=KZoS1fEPx5Q
• iMessage, explained - https://jjtech.dev/reverse-engineering/imessage-explained/
• How Price’s Law Applies to Everything - https://nielsbohrmann.com/prices-law/
• Traces to metrics: Ad hoc RED metrics in Grafana Tempo - https://www.youtube.com/watch?v=xOolCpm2F8c
• Introduction to opam Switches - https://ocaml.org/docs/opam-switch-introduction#introduction-to-opam-switches
• Introduction to the OCaml Toplevel - https://ocaml.org/docs/toplevel-introduction
• Announcing Rust 1.74.1 - https://blog.rust-lang.org/2023/12/07/Rust-1.74.1.html
• Advice from the CEO of Shopify, Tobias Lütke - https://www.youtube.com/watch?v=prHmUW4JIms
• Redeveloping TCP from the ground up - https://hannes.robur.coop/Posts/TCP-ns
• Design HashSet - Leetcode 705 - https://www.youtube.com/watch?v=6eAKScpknHQ
• TiDB Internal (II) – Computing - https://www.pingcap.com/blog/tidb-internal-computing/
• Ocaml docs: Modules - https://ocaml.org/docs/modules#abstract-types
• The unfair way I got good at Leetcode - https://www.youtube.com/watch?v=GPIuPRqDGG8
• Reducing tail latencies with automatic cooperative task yielding - https://tokio.rs/blog/2020-04-preemption
• How Akka Works: 'Exactly Once' Message Delivery - https://www.lightbend.com/blog/how-akka-works-exactly-once-message-delivery
• Which 🐘PostgreSQL problems are solved with 🚀YugabyteDB - https://dev.to/yugabyte/which-postgresql-problems-are-solved-with-yugabytedb-2gm
• Life of a HTTP request, as seen by my toy web server - https://tia.mat.br/posts/2014/10/06/life_of_a_http_request.html
• On some subtleties of Paxos - https://www.the-paper-trail.org/post/2012-11-03-on-some-subtleties-of-paxos/
• Consensus Protocols: A Paxos Implementation - https://www.the-paper-trail.org/post/2009-02-09-consensus-protocols-a-paxos-implementation/
• Consensus, Two Phase and Three Phase Commits - https://medium.com/@balrajasubbiah/consensus-two-phase-and-three-phase-commits-4e35c1a435ac
• Is Scalable OLTP in the Cloud a Solved Problem? (CIDR 2023) - https://muratbuffalo.blogspot.com/2023/01/is-scalable-oltp-in-cloud-solved.html
• Jeff Dean: Designs, Lessons and Advice from Building Large Distributed Systems - https://www.cs.cornell.edu/projects/ladis2009/talks/dean-keynote-ladis2009.pdf
• Modern hinted handoff - https://www.datastax.com/blog/modern-hinted-handoff
• Amazon Aurora Under the Hood: Quorum Reads and Mutating State - https://aws.amazon.com/blogs/database/amazon-aurora-under-the-hood-quorum-reads-and-mutating-state/
• HAT, not CAP: Introducing Highly Available Transactions - www.bailis.org/blog/hat-not-cap-introducing-highly-available-transactions/
• Back to Basics: service boundaries, autonomous components, and coupling - https://milestone.topics.it/2023/05/17/back-to-basics-boundaries.html
• 😱 Status quo stories: Alan thinks he needs async locks - https://rust-lang.github.io/wg-async/vision/submitted_stories/status_quo/alan_thinks_he_needs_async_locks.html
• Let's #TalkConcurrency Panel Discussion with Sir Tony Hoare, Joe Armstrong, and Carl Hewitt - https://www.youtube.com/watch?v=37wFVVVZlVU
• Students' Guide to Raft - https://thesquareplanet.com/blog/students-guide-to-raft/
• Instructors' Guide to Raft - https://thesquareplanet.com/blog/instructors-guide-to-raft/
• How Much Equity to Give Your Cofounder - Michael Seibel - https://www.youtube.com/watch?v=9NhEBVPlJs4
• Abandoning Async - rgrinberg.com/posts/abandoning-async/
• Getting Started with Lwt threads - https://mirage.io/docs/tutorial-lwt
• Lwt manual - https://ocsigen.org/lwt/latest/manual/manual
• TCP Server and Client in OCaml - https://medium.com/@aryangodara_19887/tcp-server-and-client-in-ocaml-13ebefd54f60
• Non-Send Futures When? - https://matklad.github.io/2023/12/10/nsfw.html
• The Big Problem With "Serverless" - https://www.youtube.com/watch?v=10kVndpDKvA
• The effect of Random UUID on database performance - https://www.youtube.com/watch?v=OAOQ7U0XAi0
• How does fork work with open files? - https://www.youtube.com/watch?v=SThwp5ijh6o
• Why Riak - https://web.archive.org/web/20181021220147/http://docs.basho.com/riak/1.4.8/theory/why-riak/
• Introduction - https://pgrandinetti.github.io/compilers/page/introduction/
• Can I Get a Job After I Study Compilers? - https://pgrandinetti.github.io/compilers/page/can-i-get-a-job-in-compilers/
• Why There Are So Many Programming Languages? - https://pgrandinetti.github.io/compilers/page/why-so-many-programming-languages/
• The Story of Grafana | Episode 2: Community | Grafana Documentary - https://www.youtube.com/watch?v=lbBQk_QPnEs
• RAND is too slow (in MySQL) - https://www.youtube.com/watch?v=wTcpZWPHl6w
• Design de API's Resilientes: Explorando Técnicas de Idempotência - https://www.youtube.com/watch?v=bnRZTi3C_JM
• The Real Hidden Cost of a Request - https://www.youtube.com/watch?v=MN2jIUonuQQ
• IT in Three: What is RAID? - https://www.youtube.com/watch?v=Aa0RTgxJJy8
• How databases store data on disk? - https://www.youtube.com/watch?v=haz2h7_xFDk
• Divide and Conquer: The Art of Breaking Down Problems | Recursion Series - https://www.youtube.com/watch?v=ib4BHvr5-Ao
• Why create Index blocks writes - https://www.youtube.com/watch?v=ykVumkmkbik
• How Databases Store and Retrieve Data - https://siemens.blog/posts/how-databases-store-and-retrieve-data/
• The unreasonable generality of feed-forward neural networks (a tribute) - https://www.youtube.com/watch?v=EXbgUXt8fFU
• Simple introduction to monads in OCaml - https://www.cryptologie.net/article/578/simple-introduction-to-monads-in-ocaml/
• OCaml has some new shiny syntax - https://jobjo.github.io/2019/04/24/ocaml-has-some-new-shiny-syntax.html
• A Tutorial to OCaml -ppx Language Extensions - https://victor.darvariu.me/jekyll/update/2018/06/19/ppx-tutorial.html
• Let syntax, and why you should use it - https://blog.janestreet.com/let-syntax-and-why-you-should-use-it/
• Mitchell reflects as he departs HashiCorp - https://www.hashicorp.com/blog/mitchell-reflects-as-he-departs-hashicorp
• What Are the Differences Between Programming Languages - https://pgrandinetti.github.io/compilers/page/what-are-the-differences-in-programming-languages/
• Jeff Bezos: Amazon and Blue Origin | Lex Fridman Podcast #405 - https://www.youtube.com/watch?v=DcWqzZ3I2cY
• Leaving Sourcegraph - https://registerspill.thorstenball.com/p/leaving-sourcegraph
• Let's build a distributed Postgres proof of concept - https://notes.eatonphil.com/distributed-postgres.html
• FoundationDB: CAP Theorem - https://apple.github.io/foundationdb/cap-theorem.html
• FoundationDB: Fault Tolerance - https://apple.github.io/foundationdb/fault-tolerance.html
• Key Startup Metrics | Startup School - https://www.youtube.com/watch?v=_mKeVGSqQac
• Design a Blob Storage | Facebook F4 | Warm Storage - https://www.youtube.com/watch?v=zx9pz1IklUE&list=PL4kInuyvT-Aw_Bz7l33AwTHXDgD3s0nkv&index=13
• Two new MySQL expressions - https://www.youtube.com/watch?v=NZqFiBDQG1s
• Partial Return Address Overwrite - Exploit Dev 10 - https://www.youtube.com/watch?v=fqsSAqbNFfo
• Design Metrics Aggregation System | LSM Tree Storage | Scaling - https://www.youtube.com/watch?v=7qfVRn4lFXY
• Memory layout and mechanics of arrays and slices | Golang | intermediate level - https://www.youtube.com/watch?v=RVTfPy_NELc
• A Close Look at a Spinlock - https://blog.regehr.org/archives/2173
• Database Fundamentals - https://tontinton.com/posts/database-fundementals/
• Learn In Public - https://www.swyx.io/learn-in-public
• "Simple Made Easy" (12-minute redux) by Rich Hickey (2011) - https://www.youtube.com/watch?v=F87PtAoJNtg
• the hidden structure you've been using all along - https://www.youtube.com/watch?v=CRTR5ljBjPM
• Diving into Kafka Internals with David Jacot - https://www.youtube.com/watch?v=d89W_GzWnRw
• Ocaml docs: Mutability, loops, and imperative programming - https://ocaml.org/docs/mutability-loops-and-imperative
• Introducing Solid Queue - https://dev.37signals.com/introducing-solid-queue/
• Eio -- Effects-Based Parallel IO for OCaml - https://github.com/ocaml-multicore/eio
• Replication: Introducing leaderless replication - https://distributed-computing-musings.com/2022/01/replication-introducing-leaderless-replication/
• How to Hook Steam Overlay Tutorial - 64-bit IMGUI Hook - https://www.youtube.com/watch?v=z7zUMieOO98
• WHAT IS HOOKING? - https://www.youtube.com/watch?v=KY2Y7Zn3HW0
• How to Be Great? Just Be Good, Repeatably - https://blog.stephsmith.io/how-to-be-great/
• Locking In On Concurrency Control - https://www.youtube.com/watch?v=PyxadX8yrsI
• How are memories stored in neural networks? | The Hopfield Network #SoME2 - https://www.youtube.com/watch?v=piF6D6CQxUw
• The Log: What every software engineer should know about real-time data's unifying abstraction - https://engineering.linkedin.com/distributed-systems/log-what-every-software-engineer-should-know-about-real-time-datas-unifying
• malloc sucks so i wrote my own heap in C - https://www.youtube.com/watch?v=CulF4YQt6zA
• Rich Hickey: Deconstructing the Database - https://www.youtube.com/watch?v=Cym4TZwTCNU
• The Design of Datomic - Rich Hickey - https://www.youtube.com/watch?v=Pz_NvY1kw6I
• Does P = NP? | Complexity Theory Explained Visually - https://www.youtube.com/watch?v=rK3xcRYLWeg
• Datomic: Immutable database for new web architecture (S03E08) - https://www.youtube.com/watch?v=VlNeWWcIQI4
• What I Wish Someone Had Told Me - https://blog.samaltman.com/what-i-wish-someone-had-told-me
• The dark side of inlining and monomorphization - https://nickb.dev/blog/the-dark-side-of-inlining-and-monomorphization/
• How do Video Game Graphics Work? - https://www.youtube.com/watch?v=C8YtdC8mxTU
• How do I Set, Clear, and Toggle a Single Bit? - https://www.youtube.com/watch?v=F9742wnBWRc
• Datomic overview - https://docs.datomic.com/pro/overview/introduction.html
• Internals of Interfaces in Golang | Intermediate level - https://www.youtube.com/watch?v=x87Cs9vU4Fk
• Dear Functional Bros - https://www.youtube.com/watch?v=nuML9SmdbJ4
• Memory Allocation - https://samwho.dev/memory-allocation/
• The secret lives of data: Raft - https://thesecretlivesofdata.com/raft/
• How does B-tree make your queries fast? - https://blog.allegro.tech/2023/11/how-does-btree-make-your-queries-fast.html
• Cursed C++ Casts - https://www.youtube.com/watch?v=SmlLdd1Q2V8
• A simple, arena-backed, generic dynamic array for C - https://nullprogram.com/blog/2023/10/05/
• Essential Matrix Algebra for Neural Networks, Clearly Explained - https://www.youtube.com/watch?v=ZTt9gsGcdDo
• Alex Petrov: Algorithms Behind Modern Storage Systems - https://queue.acm.org/detail.cfm?id=3220266
• Life Beyond Distributed Transactions - https://queue.acm.org/detail.cfm?id=3025012
• Performance Engineering on Hard Mode with Andrew Hunter - https://signals-threads.simplecast.com/episodes/performance-engineering-on-hard-mode-with-andrew-hunter-fxhCMIkB
• Kubernetes Tutorial: Container vs. Pod vs. Deployment vs. StatefulSet & More - https://www.youtube.com/watch?v=4MEgCP7h8UU
• Kubernetes Tutorial: Container vs. Pod vs. Deployment vs. StatefulSet & More - https://www.youtube.com/watch?v=4MEgCP7h8UU
• Announcing Rust 1.75.0 - https://blog.rust-lang.org/2023/12/28/Rust-1.75.0.html
• A Machine Learning Primer: How to Build an ML Model - https://www.youtube.com/watch?v=Vx2DpMgplEM
• The value of canonicity - https://building.nubank.com.br/the-value-of-canonicity/
• An introduction to the basic principles of Functional Programming - https://www.iamtk.co/an-introduction-to-the-basic-principles-of-functional-programming