The list of things I read or watched in 2023# 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# 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# 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# 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