- Computer networking: A top-down approach - https://www.amazon.com/Computer-Networking-Top-Down-Approach-7th/dp/0133594149/ref=sr_1_1?crid=190Y8HTAJ1WE1&keywords=Computer+networking&qid=1653914903&sprefix=computer+networki%2Caps%2C279&sr=8-1
- Book: Operating Systems: Three Easy Pieces - https://pages.cs.wisc.edu/~remzi/OSTEP/
- OSS: Contribute to tokio - https://github.com/tokio-rs/tokio/pulls?q=is%3Apr+author%3APoorlyDefinedBehaviour
- OSS: Contribute to Rust - https://github.com/rust-lang/rust/pulls?q=is%3Apr+author%3APoorlyDefinedBehaviour
- Paper: Actor Model of Computation - https://arxiv.org/vc/arxiv/papers/1008/1008.1459v8.pdf
- System Design Interview – An insider's guide - https://www.amazon.com.br/System-Design-Interview-Insiders-English-ebook/dp/B08B3FWYBX
- OSS: Contribute to tokio - https://github.com/tokio-rs/tokio/pulls?q=is%3Apr+author%3APoorlyDefinedBehaviour
- Book: Kafka: The definitive guide 2
- Book: I love logs
- CS168: The Modern Algorithmic Toolbox Lecture #1: Introduction and Consistent Hashing http://theory.stanford.edu/~tim/s16/l/l1.pdf
- The Go Programming Language and Environment - https://cacm.acm.org/magazines/2022/5/260357-the-go-programming-language-and-environment/fulltext
- HOTP: An HMAC-Based One-Time Password Algorithm https://datatracker.ietf.org/doc/html/rfc4226
- High scalability: Amazon architecture http://highscalability.com/amazon-architecture
- Building Prefixy: A prefix search with distributed prefix hash trees https://prefixy.github.io/
- How We've Scaled Dropbox https://www.youtube.com/watch?v=PE4gwstWhmc
- Dynamo: Amazon's highly available Key-value store https://github.com/papers-we-love/papers-we-love/blob/f28b9c9f6c52a81aa9e60521c794f1c3aeafa9a7/datastores/dynamo-amazons-highly-available-key-value-store.pdf
- Distributed hash tables https://www.researchgate.net/profile/Klaus-Wehrle/publication/220978596_7_Distributed_Hash_Tables/links/00b7d521d0548d8d32000000/7-Distributed-Hash-Tables.pdf?origin=publication_detail
- High scalability: Designing Tinder http://highscalability.com/blog/2022/1/17/designing-tinder.html
- Tinder's Move to Kubernetes - Chris O'Brien & Chris Thomas, Tinder - https://www.youtube.com/watch?v=o3WXPXDuCSU
- Martin Fowler: Circuit Breaker -https://martinfowler.com/bliki/CircuitBreaker.html
- Netflix: Fault Tolerance in a High Volume, Distributed System - https://netflixtechblog.com/fault-tolerance-in-a-high-volume-distributed-system-91ab4faae74a
- Tinder: Geosharded Recommendations Part 1: Sharding Approach - https://medium.com/tinder-engineering/geosharded-recommendations-part-1-sharding-approach-d5d54e0ec77a
- Tinder: How Tinder delivers your matches and messages at scale - https://medium.com/tinder-engineering/how-tinder-delivers-your-matches-and-messages-at-scale-504049f22ce0
- High Scalability: Google Architecture - http://highscalability.com/blog/2008/11/22/google-architecture.html
- SEDA: An Architecture for Well-Conditioned, Scalable Internet Services - http://www.sosp.org/2001/papers/welsh.pdf
- Cassandra - A Decentralized Structured Storage System - https://www.cs.cornell.edu/projects/ladis2009/papers/lakshman-ladis2009.pdf
- GopherCon 2016: Rob Pike - The Design of the Go Assembler - https://www.youtube.com/watch?v=KINIAgRpkDA
- Go's work-stealing scheduler - https://rakyll.org/scheduler/
- The Go scheduler - https://morsmachine.dk/go-scheduler
- Let's assess Kubernetes - https://morsmachine.dk/kubernetes
- The Go netpoller - https://morsmachine.dk/netpoller
- How does the golang scheduler work? - https://www.quora.com/How-does-the-golang-scheduler-work/answer/Ian-Lance-Taylor
- How Goroutines Work - https://blog.nindalf.com/posts/how-goroutines-work/
- Scalable Go Scheduler Design Doc - https://docs.google.com/document/d/1TTj4T2JO42uD5ID9e89oa0sLKhJYD0Y_kqxDv3I3XMw/edit#heading=h.mmq8lm48qfcw
- Consul: Gossip protocol - https://www.consul.io/docs/architecture/gossip
- ScyllaDB: SSTables - https://www.scylladb.com/glossary/sstable/
- Goroutines, threads, and thread IDs - https://dunglas.fr/2022/05/goroutines-threads-and-thread-ids/
- SSTable and Log Structured Storage: LevelDB - https://www.igvita.com/2012/02/06/sstable-and-log-structured-storage-leveldb/
- Measuring & Optimizing I/O Performance - https://www.igvita.com/2009/06/23/measuring-optimizing-io-performance/
- Kubernetes in Action - https://www.amazon.com/Kubernetes-Action-Marko-Luksa/dp/1617293725
- Course: AWS Solutions Architect
- ZooKeeper: Wait-free coordination for Internet-scale systems - https://www.usenix.org/legacy/event/atc10/tech/full_papers/Hunt.pdf
- Implementing Fault-Tolerant Services Using the State MachineApproach: A Tutorial - https://www.cs.cornell.edu/fbs/publications/SMSurvey.pdf
- MIT 6.824: Distributed Systems - Lecture 8 - Zookeeper - https://www.youtube.com/watch?v=pbmyrNjzdDk&list=PLrw6a1wE39_tb2fErI4-WkMbsvGQk9_UB&index=8
- MIT 6.824: Distributed Systems - Lecture 9: More Replication, CRAQ - https://www.youtube.com/watch?v=IXHzbCuADt0&list=PLrw6a1wE39_tb2fErI4-WkMbsvGQk9_UB&index=9
- OK MIT 6.824: Distributed Systems - Lecture 10: Cloud Replicated DB, Aurora - https://www.youtube.com/watch?v=jJSh54J1s5o&list=PLrw6a1wE39_tb2fErI4-WkMbsvGQk9_UB&index=11
- UUIDs are Popular, but Bad for Performance — Let’s Discuss - https://www.percona.com/blog/2019/11/22/uuids-are-popular-but-bad-for-performance-lets-discuss/
- New UUID Formats RFC - https://www.ietf.org/id/draft-peabody-dispatch-new-uuid-format-03.html
- Containers From Scratch • Liz Rice • GOTO 2018 - https://www.youtube.com/watch?v=8fi7uSYlOdc
- Local Async Executors and Why They Should be the Default - https://maciej.codes/2022-06-09-local-async.html
- Introducing Glommio, a Thread-per-Core Crate for Rust & Linux - https://www.datadoghq.com/blog/engineering/introducing-glommio/
- Data Race Patterns in Go - https://eng.uber.com/data-race-patterns-in-go/
- Caches in Rust - https://matklad.github.io/2022/06/11/caches-in-rust.html
- Five things that make Go fast - https://dave.cheney.net/2014/06/07/five-things-that-make-go-fast
- Async cancellation: a case study of pub-sub in mini-redis - http://smallcultfollowing.com/babysteps/blog/2022/06/13/async-cancellation-a-case-study-of-pub-sub-in-mini-redis/
- Everything Is Broken: Shipping rust-minidump at Mozilla – Part 1 - https://hacks.mozilla.org/2022/06/everything-is-broken-shipping-rust-minidump-at-mozilla/
- Fun with Histograms - Prometheus Basics - https://bryce.fisher-fleig.org/prometheus-histograms/
- Go’s new sorting algorithm: pdqsort - https://medium.com/@code-jitsu/gos-new-sorting-algorithm-pdqsort-822053d7801b
- How io_uring and eBPF Will Revolutionize Programming in Linux - https://www.scylladb.com/2020/05/05/how-io_uring-and-ebpf-will-revolutionize-programming-in-linux/0/
- Netlifx: Performance Under Load - https://netflixtechblog.medium.com/performance-under-load-3e6fa9a60581
- Sizedness in Rust - https://github.com/pretzelhammer/rust-blog/blob/master/posts/sizedness-in-rust.md
- A study on Modern Messaging Systems- Kafka, RabbitMQ and NATS Streaming - https://arxiv.org/pdf/1912.03715.pdf
- Two-phase commit protocol - https://en.wikipedia.org/wiki/Two-phase_commit_protocol
- Builders in Rust - https://www.shuttle.rs/blog/2022/06/09/the-builder-pattern
- The Beginner’s Guide to iptables, the Linux Firewall - https://www.howtogeek.com/177621/the-beginners-guide-to-iptables-the-linux-firewall/
- Cloudflare outage june 21 - https://blog.cloudflare.com/cloudflare-outage-on-june-21-2022/
- Numberly: Learning Rust the Hard Way for Kafka + ScyllaDB in Production - https://www.scylladb.com/2022/06/23/numberly-learning-rust-the-hard-way-for-kafka-scylladb-in-production/
- Worse is Better - Richard P. Gabriel - https://www.dreamsongs.com/WorseIsBetter.html
- The Grug Brained Developer A layman's guide to thinking like the self-aware smol brained - https://grugbrain.dev/
- Notes on Luca Palmieri's Zero to Production in Rust - https://bitemyapp.com/blog/notes-on-zero2prod-rust/
- Exploring How the ScyllaDB Data Cache Works - https://www.scylladb.com/2018/07/26/how-scylla-data-cache-works/
- Multiversion concurrency control - https://en.wikipedia.org/wiki/Multiversion_concurrency_control
- Lisp machine - https://en.wikipedia.org/wiki/Lisp_machine
- Address space - https://en.wikipedia.org/wiki/Address_space
- Memory Paging - https://en.wikipedia.org/wiki/Memory_paging
- How stacks are handled in Go - https://blog.cloudflare.com/how-stacks-are-handled-in-go/
- Complexity - https://www.ncameron.org/blog/complexity/
- Akka: Phi accrual failure detector - https://doc.akka.io/docs/akka/current/typed/failure-detector.html
- Data Chef/Data Mesh - https://drive.google.com/drive/folders/1bTytJX9foLpv8lcX7qCETUIT2wm_e23S
- Load balancing in gRPC - https://github.com/grpc/grpc/blob/master/doc/load-balancing.md
- More than you've ever wanted to know about errors in Rust - https://www.shuttle.rs/blog/2022/06/30/error-handling
- Stack machine - https://en.wikipedia.org/wiki/Stack_machine
- Adventures in AWS Lambda Land – a Migration Gone Well - https://spacelift.io/blog/aws-lambda-migration
- iFood Benefícios - Chapter Backend #9 - Observabilidade por Patrick Machado - https://www.youtube.com/watch?v=oEavh_TTBRw&list=PLmBkVYfdwar-hvigv6Tkqli4cK27b3QKt&index=21
- Windows Internals, Part 1: System Architecture, Processes, Threads, Memory Management, and More - https://www.amazon.com.br/Windows-Internals-Book-User-Mode/dp/0735684189
- Practical Reverse Engineering: x86, x64, ARM, Windows Kernel, Reversing Tools, and Obfuscation - https://www.amazon.com/Practical-Reverse-Engineering-Reversing-Obfuscation-ebook/dp/B00IA22R2Y
- Why We Run Managed CockroachDB on Kubernetes - https://www.cockroachlabs.com/blog/managed-cockroachdb-on-kubernetes/
- Julia Evans - A few things I've learned about Kubernetes - https://jvns.ca/blog/2017/06/04/learning-about-kubernetes/
- Julia Evans - A container networking overview - https://jvns.ca/blog/2016/12/22/container-networking/
- Vmware: What is Software-Defined Networking (SDN)? - https://www.vmware.com/topics/glossary/content/software-defined-networking.html
- Large-scale cluster management at Google with Borg - https://storage.googleapis.com/pub-tools-public-publication-data/pdf/43438.pdf
- ScyllaDB: Why Disney+ Hotstar Replaced Redis and Elasticsearch with ScyllaDB Cloud - https://www.scylladb.com/2022/06/28/why-disney-hotstar-replaced-redis-and-elasticsearch-with-scylladb-cloud/
- VMware: What is virtual networking? - https://www.vmware.com/topics/glossary/content/virtual-networking.html
- VMware: What is Cloud Architecture? - https://www.vmware.com/topics/glossary/content/cloud-architecture.html
- Seastar - https://seastar.io/
- Shared-nothing architecture - https://en.wikipedia.org/wiki/Shared-nothing_architecture
- Building the Real-Time Big Data Database: Seven Design Principles behind Scylla - https://lp.scylladb.com/real-time-big-data-database-principles-offer.html
- Scaling memcache at Facebook - https://www.usenix.org/system/files/conference/nsdi13/nsdi13-final170_update.pdf
- Internet disruptions overview for Q2 2022 - https://blog.cloudflare.com/q2-2022-internet-disruption-summary/
- Hive ransomware gets upgrades in Rust - https://www.microsoft.com/security/blog/2022/07/05/hive-ransomware-gets-upgrades-in-rust/
- Superficial simplicity - https://arrdem.com/2022/07/04/superficial_simplicity/
- Roy Fielding's Misappropriated REST Dissertation - https://twobithistory.org/2020/06/28/rest.html
- Building Journeys - https://onesignal.com/blog/building-journeys/
- Functional programming is finally going mainstream - https://github.com/readme/featured/functional-programming
- Assembly 2: Calling convention - https://cs61.seas.harvard.edu/site/2018/Asm2/
- The ins and outs of networking in Google Container Engine and Kubernetes (Google Cloud Next '17) - https://www.youtube.com/watch?v=y2bhV81MfKQ&t=1s
- Coinbase - Operating efficiently at scale - https://blog.coinbase.com/operating-efficiently-at-scale-e6e2378d3d4
- ScyllaDB - NoSQL and NewSQL: A Comparison of Distributed Database Systems - https://lp.scylladb.com/nosql-to-newsql-distributed-database-wp-offer.html
- ScyllaDB - Lightweight Transactions - https://docs.scylladb.com/using-scylla/lwt/
- ScyllaDB Ring Architecture - Overview - https://docs.scylladb.com/architecture/ringarchitecture/
- SSTable and Log Structured Storage: LevelDB - https://www.igvita.com/2012/02/06/sstable-and-log-structured-storage-leveldb/
- Heroku: Efficient Use of PostgreSQL Indexes - https://devcenter.heroku.com/articles/postgresql-indexes
- Coding Horror - All Abstractions Are Failed Abstractions - https://blog.codinghorror.com/all-abstractions-are-failed-abstractions/
- How to speed up the Rust compiler in July 2022 - https://nnethercote.github.io/2022/07/20/how-to-speed-up-the-rust-compiler-in-july-2022.html
- Igvita - Protocol Buffers, Avro, Thrift & MessagePack - https://www.igvita.com/2011/08/01/protocol-buffers-avro-thrift-messagepack/
- ScyllaDB: Scylla Hinted Handoff - https://docs.scylladb.com/stable/architecture/anti-entropy/hinted-handoff
- Cassandra - A Decentralized Structured Storage System - https://www.cs.cornell.edu/projects/ladis2009/papers/lakshman-ladis2009.pdf
- How to speed up the Rust compiler in July 2022 - https://nnethercote.github.io/2022/07/20/how-to-speed-up-the-rust-compiler-in-july-2022.html
- IBM: OLAP vs OLTP - https://www.youtube.com/watch?v=iw-5kFzIdgY
- Design a proximity service (Yelp, Google places, etc.) | System Design - https://www.youtube.com/watch?v=M4lR_Va97cQ
- Bare metal, virtual machines, or containers? - https://www.youtube.com/watch?v=Jz8Gs4UHTO8
- tcpdumping my NodeJS app - https://www.youtube.com/watch?v=g_tmQ5G-T2w
- Raft in Scylla - https://www.youtube.com/watch?v=n_NItGXGcCs
- Fixing the Next Thousand Deadlocks: Why Buffered Streams Are Broken and How To Make Them Safer - https://blog.polybdenum.com/2022/07/24/fixing-the-next-thousand-deadlocks-why-buffered-streams-are-broken-and-how-to-make-them-safer.html
- JWST: MAXIMIZING EFFICIENCY AND MINIMIZING GROUND SYSTEMS - https://www.stsci.edu/~idash/pub/dashevsky0607rcsgso.pdf
- Amazon DynamoDB: A Scalable, Predictably Performant, and Fully Managed NoSQL Database Service - https://www.usenix.org/system/files/atc22-elhemali.pdf
- Aurora Serverless V2 Setup Tutorial with Postgres - https://www.youtube.com/watch?v=0R4s1Al0F1c
- CPU Utilization is Wrong - https://www.brendangregg.com/blog/2017-05-09/cpu-utilization-is-wrong.html
- ScyllaDB’s Approach to Improve Performance for CPU-bound workloads - https://www.scylladb.com/2017/07/06/scyllas-approach-improve-performance-cpu-bound-workloads/
- Blog luizalabs: Staged Event Driven Architecture (SEDA) - https://medium.com/luizalabs/staged-event-driven-architecture-seda-bbe272d79cd9
- The 4 Types Of Prometheus Metrics - https://tomgregory.com/the-four-types-of-prometheus-metrics/#counters
- Evolving Distributed Tracing at Uber Engineering - https://eng.uber.com/distributed-tracing/
- Consistency Level explained in 5min - https://www.youtube.com/watch?v=aK3-kosfqts
- Consistency Level explained in 5min - https://www.youtube.com/watch?v=aK3-kosfqts - https://drive.google.com/file/d/15l-9wlD75A56F0w7p2IpwlQrHbqBtfsN/view
- p99 config - Async Rust In Practice: Performance, Pitfalls, Profiling -https://www.p99conf.io/2022/08/02/async-rust-in-practice-performance-pitfalls-profiling/
- Spanner, TrueTime & The CAP Theorem - https://static.googleusercontent.com/media/research.google.com/en//pubs/archive/45855.pdf
- Facebook Blog: MyRocks: A space- and write-optimized MySQL database - https://engineering.fb.com/2016/08/31/core-data/myrocks-a-space-and-write-optimized-mysql-database/
- Let's talk skiplist - https://ketansingh.me/posts/lets-talk-skiplist/
- CockroachDB: The Resilient Geo-Distributed SQL Database - https://dl.acm.org/doi/pdf/10.1145/3318464.3386134
- Development of the domain name system - http://www.cs.cmu.edu/~dga/15-744/S07/papers//dns.pdf
- Maglev: A Fast and Reliable Software Network Load Balancer - https://static.googleusercontent.com/media/research.google.com/en//pubs/archive/44824.pdf
- 'I would have found this bug with E2E tests' is a fallacy! - https://www.effective-software-testing.com/finding-more-bugs-via-e2e-tests-is-a-fallacy
- Kent Beck: Geographic Compensation Will Lose - https://geekincentives.substack.com/p/geographic-compensation-will-lose
- Wikipedia: Copy-on-write - https://en.wikipedia.org/wiki/Copy-on-write
- Architecturenotes: Redis explained - https://architecturenotes.co/redis/
- Rob Pike’s simple C regex matcher in Go - https://benhoyt.com/writings/rob-pike-regex/
- Fly.io: SQLite Internals: Pages & B-trees - https://fly.io/blog/sqlite-internals-btree/
- StaffEng: Work on what matters - https://staffeng.com/guides/work-on-what-matters
- Lara Hogan: WHAT DOES SPONSORSHIP LOOK LIKE? - https://larahogan.me/blog/what-sponsorship-looks-like/
- StaffEng: Guides / What do Staff engineers actually do? - https://staffeng.com/guides/what-do-staff-engineers-actually-do
- StaffEng: Does the title even matter? - https://staffeng.com/guides/does-the-title-even-matter
- MapReduce: Simplified Data Processing on Large Clusters - https://static.googleusercontent.com/media/research.google.com/en//archive/mapreduce-osdi04.pdf
- Google - Design patterns for container-based distributed systems - https://s3.amazonaws.com/systemsandpapers/papers/design-container-based-systems.pdf
- Meta - InfERL: Scalable and Extensible Erlang Static Analysis - https://scontent.fnvt7-1.fna.fbcdn.net/v/t39.8562-6/298206731_612452000237878_2778852866576233295_n.pdf?_nc_cat=100&ccb=1-7&_nc_sid=ad8a9d&_nc_ohc=77Ac0y51ktgAX9RqkYO&_nc_ht=scontent.fnvt7-1.fna&oh=00_AT_ggdR0P5QkKBWQIalHPuXLapYvDaqmX2lgAumeodLGsQ&oe=63014933
- Kafka: a Distributed Messaging System for Log Processing - http://notes.stephenholiday.com/Kafka.pdf
- Rust in Perspective - https://people.kernel.org/linusw/rust-in-perspective
- How Rust optimizes async/await I - https://tmandry.gitlab.io/blog/posts/optimizing-await-1/
- Inside the Pinecone - https://www.pinecone.io/learn/inside-the-pinecone/
- STATE MACHINES II - https://blog.yoshuawuyts.com/state-machines-2/
- Guide to OpenTelemetry Distributed Tracing in Rust - https://www.aspecto.io/blog/distributed-tracing-with-opentelemetry-rust/
- Under the hood: How we built API versioning for LinkedIn Marketing APIs - https://engineering.linkedin.com/blog/2022/-under-the-hood--how-we-built-api-versioning-for-linkedin-market
- Memcached Architecture - Crash Course with Docker, Telnet, NodeJS - https://www.youtube.com/watch?v=NCePGsRZFus
- Fuzzing Go APIs for SQL Injection - https://blog.fuzzbuzz.io/fuzzing-go-apis-for-sql-injection/
- Pricing at Lyft - https://eng.lyft.com/pricing-at-lyft-8a4022065f8b
- The Secret Sauce Behind NoSQL: LSM Tree - https://www.youtube.com/watch?v=I6jB0nM9SKU
- Back to Basics: Running MS SQL Database Service on AWS - https://www.youtube.com/watch?v=JqZbcSctRDg
- Mocking Rust 🤪 and Testing 🧪 - https://www.youtube.com/watch?v=8XaVlL3lObQ
- Embedded Rust Runs on EVERYTHING, Including the Raspberry Pi | Baremetal Rust Tutorial - https://www.youtube.com/watch?v=jZT8APrzvc4
- Wiremock: async HTTP mocking to test Rust applications - https://www.lpalmieri.com/posts/2020-04-13-wiremock-async-http-mocking-for-rust-applications/
- Avinetworks: What is Load Balancing? - https://avinetworks.com/what-is-load-balancing/
- Avinetworks: Cloud load balancing - https://www-stage.avinetworks.com/glossary/cloud-load-balancing/
- Why functions are turing complete (Lambda Calculus) - https://www.youtube.com/watch?v=m32kbFXBRR0
- Announcing Unreal Rust - https://maikklein.github.io/unreal-rust-1/
- Carlos Fenollosa: After self-hosting my email for twenty-three years I have thrown in the towel. The oligopoly has won. - https://cfenollosa.com/blog/after-self-hosting-my-email-for-twenty-three-years-i-have-thrown-in-the-towel-the-oligopoly-has-won.html
- What is Distributed Tracing? A Friendly Guide for Developers - https://www.aspecto.io/blog/guide-to-distributed-tracing/
- Aaron Turon: Zero-cost futures in Rust - https://aturon.github.io/blog/2016/08/11/futures/
- Bits of Architecture: What is Computer Architecture? - https://www.youtube.com/watch?v=Q6FpHbRUdgg
- [rust-dev] Abandoning segmented stacks in Rust - https://mail.mozilla.org/pipermail/rust-dev/2013-November/006314.html
- Rust RFC: Remove runtime(green threads) - https://github.com/aturon/rfcs/blob/remove-runtime/active/0000-remove-runtime.md
- Bits of Architecture: The System Software Abstraction - https://www.youtube.com/watch?v=7TeBx27_i0s
- Design Patterns: Who gives a 💩? - https://www.youtube.com/watch?v=V-2Ad5zg3D8
- Type 1 and Type 2 Hypervisors: What Makes Them Different - https://medium.com/teamresellerclub/type-1-and-type-2-hypervisors-what-makes-them-different-6a1755d6ae2c
- Rust on Rails (write code that never crashes) - https://www.youtube.com/watch?v=sbVxq7nNtgo
- Rust in Production at Figma - https://www.figma.com/blog/rust-in-production-at-figma/
- What it feels like when Rust saves your bacon - http://smallcultfollowing.com/babysteps/blog/2022/06/15/what-it-feels-like-when-rust-saves-your-bacon/
- Modeling graphs in Rust using vector indices - http://smallcultfollowing.com/babysteps/blog/2015/04/06/modeling-graphs-in-rust-using-vector-indices/
- Bytes of Architecture: Compilation Phases with GCC - https://www.youtube.com/watch?v=h0J6xWCGldQ
- Bits of Architecture: Core Ideas in Computer Architecture - https://www.youtube.com/watch?v=x42yv8LbMXQ
- i made my embedded rust less bad (it was REALLY gross) - https://www.youtube.com/watch?v=mPB3dCWlZVY
- Rust Powered Database SurrealDB (It's Pretty Ambitious) - https://www.youtube.com/watch?v=DPQbuW9dQ7w
- What is the Windows API? What is Windows.h? - https://www.youtube.com/watch?v=S4lQwJawOzI
- Tech Talk: What is Public Key Infrastructure (PKI)? - https://www.youtube.com/watch?v=0ctat6RBrFo
- How Rust Helps You Prevent Bugs - https://polyfloyd.net/post/how-rust-helps-you-prevent-bugs/
- https://cloud.google.com/blog/products/application-modernization/why-david-yach-loves-go
- Scale-to-zero Minecraft Server With Terraform and Fly Machines - https://fly.io/blog/scale-to-zero-minecraft/
- My solution for designing a resilient system in an event-driven pipeline - https://medium.datadriveninvestor.com/my-solution-for-designing-a-resilient-system-in-an-event-driven-pipeline-d1396711d423
- How we built Pingora, the proxy that connects Cloudflare to the Internet - https://blog.cloudflare.com/how-we-built-pingora-the-proxy-that-connects-cloudflare-to-the-internet/
- Thundering herd problem - https://en.wikipedia.org/wiki/Thundering_herd_problem
- Why does one NGINX worker take all the load? - https://blog.cloudflare.com/the-sad-state-of-linux-socket-balancing/
- The Golden Age of PL Research - https://semantic-domain.blogspot.com/2022/09/the-golden-age-of-pl-research.html?m=1
- Building for the 99% Developers - https://future.com/software-development-building-for-99-developers/
- Google testing blog: Code Coverage Best Practices - https://testing.googleblog.com/2020/08/code-coverage-best-practices.html
- Gradient Descent Explained - https://www.youtube.com/watch?v=i62czvwDlsw
- Ten challenges for Rust - https://www.ncameron.org/blog/ten-challenges-for-rust/
- Complexity - https://www.ncameron.org/blog/complexity/
- 252 - Objetos Elegantes: MAIS ENFÁTICO QUE O UNCLE BOB! 😱 | https://www.youtube.com/watch?v=8SfcLTXUl5A
- I Spent 48 HOURS on Cloud Functions and Discovered THIS!!! - https://www.youtube.com/watch?v=I0vJDmw6P4c
- Bytes of Architecture: Execution Time Breakdown - https://www.youtube.com/watch?v=jziqesTOncU
- Bits of Architecture: Semiconductor Manufacturing - https://www.youtube.com/watch?v=pWEgGJ0lw-c
- Bits of Architecture: High-Level Computer Organization - https://www.youtube.com/watch?v=Ms4YOVbiyaQ
- Open Source Explained - https://www.youtube.com/watch?v=PVD1LNDxOnc
- RISC vs CISC | Computer Architecture - https://www.youtube.com/watch?v=bTCuFmY0sUg
- DTO - Para que servem? Onde Utilizar? - https://www.youtube.com/watch?v=_-5kmlDDyms
- Choosing a Compute Option on AWS - https://www.youtube.com/watch?v=buKoMUR9t84
- Database System Architecture - Part 1 - https://www.youtube.com/watch?v=8_W5JT7Jz2Y
- View Smartphone Traffic with Wireshark on the Same Network [Tutorial] - https://www.youtube.com/watch?v=Hl0IpoS503A
- How is Technical Debt created? Is it Always BAD? - https://www.youtube.com/watch?v=f2XkeDZnn4E
- Epoll is fundamentally broken 1/2 - https://idea.popcount.org/2017-02-20-epoll-is-fundamentally-broken-12/
- Epoll is fundamentally broken 2/2 - https://idea.popcount.org/2017-03-20-epoll-is-fundamentally-broken-22/
- A brief history of select(2) - https://idea.popcount.org/2016-11-01-a-brief-history-of-select2/
- Select is fundamentally broken - https://idea.popcount.org/2017-01-06-select-is-fundamentally-broken/
- History of Actors - https://eighty-twenty.org/2016/10/18/actors-hopl
- This is a video about a video(decoders, codecs, etc) - https://www.youtube.com/watch?v=ztYNir9BDoY
- How to stop using If-else and make your code more readable - https://itnext.io/how-to-stop-using-if-else-and-make-your-code-more-readable-9d1cd97c68bf
- What is data engineering - https://blog.pragmaticengineer.com/what-is-data-engineering/
- The Pragmatic Engineer: What is data engineering pt 2
- Airflow: a workflow management platform - https://medium.com/airbnb-engineering/airflow-a-workflow-management-platform-46318b977fd8
- McDonald’s event-driven architecture: The data journey and how it works - https://medium.com/mcdonalds-technical-blog/mcdonalds-event-driven-architecture-the-data-journey-and-how-it-works-4591d108821f
- FUTURES CONCURRENCY IV: JOIN ERGONOMICS — 2022-09-19 - https://blog.yoshuawuyts.com/futures-concurrency-4/
- Const Eval (Un)Safety Rules - https://blog.rust-lang.org/2022/09/15/const-eval-safety-rule-revision.html
- How To Choose The Right Database? - https://www.youtube.com/watch?v=kkeFE6iRfMM
- Don't Make This ONE SIMPLE MISTAKE When Learning to Code in C (it'll be the END...ian) (endianness) - https://www.youtube.com/watch?v=_yRW4nQFrB8
- History of DBMS - https://www.youtube.com/watch?v=DKUJY9WgnIM
- Next steps for Rust in the kernel - https://lwn.net/SubscriberLink/908347/da67a5162d1bc4a3/
- Wasmtime Reaches 1.0: Fast, Safe and Production Ready! - https://bytecodealliance.org/articles/wasmtime-1-0-fast-safe-and-production-ready
- What is AWS Secrets Manager | Amazon Web Services - https://www.youtube.com/watch?v=-9nOyaM3kZk
- Announcing the Keyword Generics Initiative - https://blog.rust-lang.org/inside-rust/2022/07/27/keyword-generics.html
- There is no “software supply chain” - https://iliana.fyi/blog/software-supply-chain/
- What is a Data Warehouse? - https://www.mozartdata.com/post/data-warehouse
- Star schema vs. OBT for data warehouse performance - https://www.fivetran.com/blog/star-schema-vs-obt
- Understanding the Snowflake Query Optimizer - https://teej.ghost.io/understanding-the-snowflake-query-optimizer/
- A minimal distributed key-value database with Hashicorp's Raft library - https://notes.eatonphil.com/minimal-key-value-store-with-hashicorp-raft.html
- The 3 A's of Open Source Security - https://www.youtube.com/watch?v=baZH6CX6Zno
- Rust & Wasm (Safe and fast web development) - https://www.youtube.com/watch?v=P4LMfkFLRsI
- The impossible case of pitching rust in a web dev shop - https://flakm.github.io/posts/rust_why_dev_shop/
- Rust 2024...the year of everywhere? - https://smallcultfollowing.com/babysteps/blog/2022/09/22/rust-2024-the-year-of-everywhere/
- Announcing Rust 1.64.0 - https://blog.rust-lang.org/2022/09/22/Rust-1.64.0.html
- Introducing LiteFS - https://fly.io/blog/introducing-litefs/
- Many Small Queries Are Efficient In SQLite - https://www.sqlite.org/np1queryprob.html
- How (memory) safe is zig? - https://www.scattered-thoughts.net/writing/how-safe-is-zig/
- Turing tarpit - https://en.wikipedia.org/wiki/Turing_tarpit
- An opinionated map of incremental and streaming systems - https://www.scattered-thoughts.net/writing/an-opinionated-map-of-incremental-and-streaming-systems
- I'm All-In on Server-Side SQLite - https://fly.io/blog/all-in-on-sqlite-litestream/
- One process programming notes (with Go and SQLite) - https://crawshaw.io/blog/one-process-programming-notes
- The Hierarchy Is Bullshit (And Bad For Business) - https://charity.wtf/2022/09/23/the-hierarchy-is-bullshit-and-bad-for-business/
- Globally Distributed Postgres - https://fly.io/blog/globally-distributed-postgres/
- Why Rust is actually good for your car. - https://medium.com/volvo-cars-engineering/why-volvo-thinks-you-should-have-rust-in-your-car-4320bd639e09
- The Typestate Pattern in Rust - http://cliffle.com/blog/rust-typestate/
- Finding the Optimal Level of Challenge: Lessons from Psychology in Optimizing Retention and Engagement - https://www.nbianalytics.com/finding-optimal-level-of-challenge/
- Sealed traits protect against downstream implementations (C-SEALED) - https://rust-lang.github.io/api-guidelines/future-proofing.html#sealed-traits-protect-against-downstream-implementations-c-sealed
- First steps with Docker + Rust - https://dev.to/rogertorres/first-steps-with-docker-rust-30oi
- Why Use a Pool? - https://docs.rs/sqlx/latest/sqlx/struct.Pool.html#why-use-a-pool
- How to create small Docker images for Rust - https://kerkour.com/rust-small-docker-image
- Default VPCs - - https://docs.aws.amazon.com/vpc/latest/userguide/default-vpc.html
- IPv4, CIDR, and VPC Subnets Made Simple! - https://www.youtube.com/watch?v=z07HTSzzp3o
- Classless Interdomain Routing (CIDR) - https://www.youtube.com/watch?v=Q1U9wVXRuHA
- Go runtime: 4 years later - https://go.dev/blog/go119runtime
- Hierarchy and the workplace - https://sysadmin1138.net/mt/blog/2022/09/hierarchy-and-the-workplace.shtml
- Your CTO Should Actually Be Technical - https://blog.southparkcommons.com/your-cto-should-actually-be-technical/
- Rusts Axum style magic function params example - https://github.com/alexpusch/rust-magic-function-params
- Bytes of Architecture: Performance Profiling Basics - https://www.youtube.com/watch?v=cE0QFcpCj_M
- How Does Live Streaming Platform Work? (YouTube live, Twitch, TikTok Live) - https://www.youtube.com/watch?v=7AMRfNKwuYo
- Alguns conceitos matemáticos fundamentais para o estudo de algoritmos - https://www.youtube.com/watch?v=IkS8AqBXSZA
- ArrayCast Episode 36 BTS: Array Programming Language Venn Diagram - https://www.youtube.com/watch?v=qEywreN02ng
- Race Conditions Can Be Useful for Parallelism - https://shwestrick.github.io/2022/09/27/useful-races.html
- Representations of Binary Numbers - https://www.youtube.com/watch?v=-CEJXDeDsAQ
- Subnets for your VPC - https://docs.aws.amazon.com/vpc/latest/userguide/configure-subnets.html
- How Amazon VPC works - https://docs.aws.amazon.com/vpc/latest/userguide/how-it-works.html#vpc-ip-addressing
- Scheduling Amazon ECS tasks - https://docs.aws.amazon.com/AmazonECS/latest/developerguide/scheduling_tasks.html
- Bits of Architecture: The Power Wall - https://www.youtube.com/watch?v=fBX-U8Ucww0
- Dropbox: Rewriting the heart of our sync engine - https://dropbox.tech/infrastructure/rewriting-the-heart-of-our-sync-engine
- Crane: Uber’s Next-Gen Infrastructure Stack - https://www.uber.com/en-BR/blog/crane-ubers-next-gen-infrastructure-stack/
- Head-of-line blocking - https://en.wikipedia.org/wiki/Head-of-line_blocking
- TCP head of line blocking - https://http3-explained.haxx.se/en/why-quic/why-tcphol
- Virtual output queueing - https://en.wikipedia.org/wiki/Virtual_output_queueing
- Uber’s Next Gen Push Platform on gRPC - https://www.uber.com/en-BR/blog/ubers-next-gen-push-platform-on-grpc/
- Resiliency in Distributed Systems - https://blog.pragmaticengineer.com/resiliency-in-distributed-systems/
- Add examples to your Rust libraries - http://xion.io/post/code/rust-examples.html
- Why Everyone Cares About Snowflake - https://www.youtube.com/watch?v=njttWa08pwo
- Bits of Architecture: The Multi-Core Era - https://www.youtube.com/watch?v=wX4-7rakCXU
- [Backend #51] Add authorization to protect gRPC API - https://www.youtube.com/watch?v=_jqNs3d99ps
- Clean Architecture: Trabalhando com output #cortesfullcycle - https://www.youtube.com/watch?v=SqX0vZ9LmZ8
- Bytes of Architecture: Multithreading Basics - https://www.youtube.com/watch?v=aA6Yc0MvqJU
- Deduping and Storing Images at Uber Eats - https://www.uber.com/en-BR/blog/deduping-and-storing-images-at-uber-eats/
- Evolving Schemaless into a Distributed SQL Database - https://www.uber.com/en-BR/blog/schemaless-sql-database/
- What is Quantum Safe? - https://www.youtube.com/watch?v=1lTA2n142Mk
- HTTP3 explained - https://http3-explained.haxx.se/
- Quer saber o que é um NP-Completo? Então precisa entender, antes, o que é "Redução" e "Completude" - https://www.youtube.com/watch?v=9iSz5o4BFm8
- The coolest OSS project you've never heard of: NATS Getting started! - https://www.youtube.com/watch?v=hjXIUPZ7ArM
- Containers vs VMs: What's the difference? - https://www.youtube.com/watch?v=cjXI-yxqGTI
- 254 - Pra quê uma camada de CASOS DE USO (OU DE SERVIÇOS)?!?! 🤔 | theWiseDev CleanArch - https://www.youtube.com/watch?v=ug6DWF3a9WI
- Tech Talk: What's Next in Open Source - https://www.youtube.com/watch?v=v8rrNHF4JSw
- Memory management unit - https://en.wikipedia.org/wiki/Memory_management_unit
- Translation lookaside buffer - https://en.wikipedia.org/wiki/Translation_lookaside_buffer
- Our not-so-magic journey scaling low latency, multi-region services on AWS - https://www.atlassian.com/engineering/aws-scaling-multi-region-low-latency-service
- Strong and weak typing - https://en.wikipedia.org/wiki/Strong_and_weak_typing
- Harvard architecture - https://en.wikipedia.org/wiki/Harvard_architecture
- Instruction cycle - https://en.wikipedia.org/wiki/Instruction_cycle
- Easily Redrive SQS DLQ Messages | Step by Step Tutorial - https://www.youtube.com/watch?v=65NFikq8dU4
- How to Add User Access to the AWS Billing Console - https://www.youtube.com/watch?v=CAjXGraoGkQ
- DynamoDB Table Import from S3 | Step by Step Tutorial - https://www.youtube.com/watch?v=FIYQXOIbm0U
- Do you need a Distributed Transaction? Working through a Design Problem - https://www.youtube.com/watch?v=Trl4--FO7Yo
- Uber’s Real-Time Push Platform - https://www.uber.com/en-BR/blog/real-time-push-platform/
- Exploratory Data Analysis - https://www.youtube.com/watch?v=QiqZliDXCCg
- EP26: Proxy vs reverse proxy - https://blog.bytebytego.com/p/ep25-proxy-vs-reverse-proxy?utm_source=email
- Bits of Architecture: The Binary Representation of Integers - https://www.youtube.com/watch?v=-UtESS4NEcI
- Employing QUIC Protocol to Optimize Uber’s App Performance - https://www.uber.com/en-BR/blog/employing-quic-protocol/
- Buy Now, Pay Later: Echoes of the 2008 Recession - https://www.youtube.com/watch?v=R1JaMRpcDrQ
- Bits of Architecture: Integer Arithmetic Basics - https://www.youtube.com/watch?v=fYMeYrIWnOc
- Bits of Architecture: RISC-V Instruction Formats - https://www.youtube.com/watch?v=UcX9JlJSS8M
- What is the Y Combinator? - https://www.youtube.com/watch?v=qzsxO79zxS8
- Bytes of Architecture: The RISC-V Interpreter - https://www.youtube.com/watch?v=KsWQi_Z5lAg
- Rust RFC: 0000-remove-runtime.md - https://github.com/aturon/rfcs/blob/remove-runtime/active/0000-remove-runtime.md
- Go design doc: Contiguous stacks - https://docs.google.com/document/d/1wAaf1rYoM4S4gtnPh0zOlGzWtrZFQ5suE8qr2sD8uWQ/pub
- Paper: Fibers under the magnifying glass - https://www.open-std.org/JTC1/SC22/WG21/docs/papers/2018/p1364r0.pdf
- Engineering a more robust Raft group reconfiguration - https://redpanda.com/blog/raft-protocol-reconfiguration-solution?utm_source=twitter&utm_medium=social&utm_campaign=sep29_social&utm_assettype=blog&utm_assetname=raft_reconfiguration&utm_version=929
- Uber blog: How Ringpop from Uber Engineering Helps Distribute Your Application - https://www.uber.com/en-BR/blog/ringpop-open-source-nodejs-library/
- RalfJung: Minirust - https://github.com/RalfJung/minirust
- How can I assign a static IP address to my Amazon EC2 Windows instance? - https://www.youtube.com/watch?v=gWfJ-5FFztI
- Containers From Scratch • Liz Rice • GOTO 2018 - https://www.youtube.com/watch?v=8fi7uSYlOdc
- Quirks of Rust's token representation - https://nnethercote.github.io/2022/10/05/quirks-of-rusts-token-representation.html
- How Uber is Measuring Engineering Productivity - https://newsletter.pragmaticengineer.com/p/uber-eng-productivity
- EVERY ACHIEVEMENT HAS A DENOMINATOR - https://charity.wtf/2022/10/03/every-achievement-has-a-denominator/
- Elixir blog: My Future with Elixir: set-theoretic types - https://elixir-lang.org/blog/2022/10/05/my-future-with-elixir-set-theoretic-types/
- Hard Mode Rust - https://matklad.github.io/2022/10/06/hard-mode-rust.html
- The Newtype Pattern in Rust - https://www.worthe-it.co.za/blog/2020-10-31-newtype-pattern-in-rust.html
- The Scoop #27: Meta’s Historic Growth Challenge - https://newsletter.pragmaticengineer.com/p/the-scoop-27?utm_source=post-email-title&publication_id=458709&post_id=76857916&isFreemail=false&utm_medium=email
- Kotlin/Native Memory Management Roadmap - https://blog.jetbrains.com/kotlin/2020/07/kotlin-native-memory-management-roadmap/
- Avoiding allocations in Rust to shrink Wasm modules - https://nickb.dev/blog/avoiding-allocations-in-rust-to-shrink-wasm-modules/
- Entendendo de uma vez por todas o princípio de Liskov - https://www.youtube.com/watch?v=tIcfvP9jf9k
- Rust makes cents (Speed is a FEATURE) [RUST-11] - https://www.youtube.com/watch?v=4dvf6kM70qM
- Process Memory Basics for Reverse Engineers - Tracking Memory With A Debugger - https://www.youtube.com/watch?v=eWYENJ5kG00
- Why does Win32 even have Fibers? - https://learn.microsoft.com/en-us/archive/blogs/larryosterman/why-does-win32-even-have-fibers
- LEVEL UP Your C Debugging Skills with THIS Technique Using GDB (its hard CORE) - https://www.youtube.com/watch?v=3T3ZDquDDVg
- McDonald’s Journey to Event-Driven Architecture - https://www.youtube.com/watch?v=kV0V3NEz7tA
- Run queue - https://en.wikipedia.org/wiki/Run_queue
- Is the Startup Grind Really Necessary? - https://thenewstack.io/is-the-startup-grind-really-necessary/
- The Battle of the Schedulers: FreeBSD ULE vs. Linux CFS - https://www.usenix.org/system/files/conference/atc18/atc18-bouron.pdf
- Kubernetes vs. OpenShift - https://www.youtube.com/watch?v=ZsOR8RkAOwI
- Postgres WASM by Snaplet and Supabase - https://supabase.com/blog/postgres-wasm
- Differences between Cache and Registers (Computer Architecture) - https://www.youtube.com/watch?v=ku9iPjMCArM
- Estruturas de dados - https://www.youtube.com/watch?v=IKfBGkUVKSg
- When to use Go's RWMutex - https://petsta.net/posts/rwmutex/
- How the largest open source companies got their first 1k community members - https://pchase.substack.com/p/how-the-largest-open-source-companies
- Friction Between Product and Engineering; Lack of trust and collaboration slowing down product growth - https://martinfowler.com/articles/bottlenecks-of-scaleups/03-product-v-engineering.html
- Go proposal: redefining for loop variable semantics - golang/go#56010
- Hussein Nasser: When NodeJS I/O Blocks - https://medium.com/@hnasr/when-nodejs-i-o-blocks-327f8a36fbd4
- Big-O Notation - Everything you need to Know - https://www.youtube.com/watch?v=BgLTDT03QtU
- Inside NGINX: How We Designed for Performance & Scale - https://www.nginx.com/blog/inside-nginx-how-we-designed-for-performance-scale/amp/
- What we learned supporting 1M rpm with 10 ms latency using Apache Ignite at iFood - https://ignite-summit.org/2022-november/sessions/393297
- Push-based Outbox Pattern with Postgres Logical Replication - https://event-driven.io/pl/push_based_outbox_pattern_with_postgres_logical_replication/
- "What is ScyllaDB?" Defining a NoSQL Database in 1 Minute - https://www.youtube.com/watch?v=MWFWM_LcouY
- The Senior Shift - https://skamille.medium.com/the-senior-shift-315f56b79d5
- Are we reference yet? C++ references in Rust - https://medium.com/@adetaylor/are-we-reference-yet-c-references-in-rust-72c1c6c7015a
- RAII: Compile-Time Memory Management in C++ and Rust - https://www.thecodedmessage.com/posts/raii/
- Spotify Technology: How Spotify Works - http://pansentient.com/2011/04/spotify-technology-some-stats-and-how-spotify-works/
- Buffer underrun - https://en.wikipedia.org/wiki/Buffer_underrun
- Why Rust? - https://www.rerun.io/blog/why-rust
- Zero-copy - https://en.wikipedia.org/wiki/Zero-copy
- What Zero-copy Serialization Means? - https://brunocalza.me/what-zero-copy-serialization-means/
- Sendfile (a system call for web developers to know about!) - https://jvns.ca/blog/2016/01/23/sendfile-a-new-to-me-system-call/
- What is SRE (site reliability engineering)? - https://www.redhat.com/en/topics/devops/what-is-sre
- Site Reliability Engineers: “We solve cooler problems” - https://careers.google.com/stories/site-reliability-engineering-profile-google/
- What is Site Reliability Engineering (SRE)? - https://www.youtube.com/watch?v=ztIIcXNzMN4
- Bits of Architecture: Basic Processor Design - https://www.youtube.com/watch?v=2JwylD1RZ5w
- Basic Caching Techniques Explained - Spatial, Temporal, Distributed, Write-Through, Write-Back,Aside - https://www.youtube.com/watch?v=ccemOqDrc2I
- Google's Journey from Java to Kotlin for Server Side Programming by James Ward , Brad Hawkes , John - https://www.youtube.com/watch?v=o14wGByBRAQ
- Why we're leaving the cloud - https://world.hey.com/dhh/why-we-re-leaving-the-cloud-654b47e0
- Why we're leaving the cloud - https://world.hey.com/dhh/why-we-re-leaving-the-cloud-654b47e0 - https://techcrunch.com/2022/10/19/dont-worry-uber-will-find-a-way-to-advertise-to-you/
- Skyfall: eBPF agent for infrastructure observability - https://engineering.linkedin.com/blog/2022/skyfall--ebpf-agent-for-infrastructure-observability?ref=Architecture+Notes-newsletter
- Why you should understand (a little) about TCP - https://jvns.ca/blog/2015/11/21/why-you-should-understand-a-little-about-tcp/
- Data Race Patterns in Go - https://www.uber.com/en-BR/blog/data-race-patterns-in-go/
- Why is Clean Architecture so Popular? - https://www.youtube.com/watch?v=g0XmFpmvsDk
- From Turbo Pascal to Delphi to C# to TypeScript, an interview with PL legend Anders Hejlsberg - https://www.youtube.com/watch?v=6udlQakSXZY
- Binary Heap e HeapSort - O que são e COMO FUNCIONAM (passo-a-passo) - https://www.youtube.com/watch?v=-nq88TldUX0
- What happens if you write a TCP stack in Python? - https://jvns.ca/blog/2014/08/12/what-happens-if-you-write-a-tcp-stack-in-python/
- Reading and Writing Data with Rust's TcpStream - https://thepacketgeek.com/rust/tcpstream/reading-and-writing/
- A Guide to Consistent Hashing - https://www.toptal.com/big-data/consistent-hashing
- Consistent hashing explained - https://ably.com/blog/implementing-efficient-consistent-hashing
- What Is Apache Spark? - https://www.youtube.com/watch?v=VZ7EHLdrVo0
- Web-native Rust apps (what will YOU build?) [RUST-12] - https://www.youtube.com/watch?v=y10jJX35shE
- Bits of Architecture: Introduction to Pipelining - https://www.youtube.com/watch?v=nADNqazDK3M
- Como Funciona o Wireshark? - Protocolo TCP - https://www.youtube.com/watch?v=Xpw4o0Gds0E
- How Prime Video updates its app for more than 8,000 device types - https://www.amazon.science/blog/how-prime-video-updates-its-app-for-more-than-8-000-device-types
- Writing a HashMap in Rust without unsafe - https://ecton.dev/writing-a-hashmap-without-unsafe/
- Rust's Most Important Containers 📦 10 Useful Patterns - https://www.youtube.com/watch?v=f82wn-1DPas
- Tech Talk: Personal Disaster Quiz + Passwordless Authentication - https://www.youtube.com/watch?v=iU7frYhy35E
- Don't be fooled! That's NOT an Aggregate in Domain Driven Design - https://www.youtube.com/watch?v=LyRvB6m_uoA
- Why functional programmers should care about Rust - https://www.worthe-it.co.za/blog/2018-02-11-why-functional-programmers-should-care-about-rust.html
- ETA Phone Home: How Uber Engineers an Efficient Route - https://www.uber.com/en-BR/blog/engineering-routing-engine/
- Docker launches a first preview of its WebAssembly tooling - https://techcrunch.com/2022/10/24/docker-launches-a-first-preview-of-its-webassembly-support/
- Why You Should Live A Psychologically Rich Life - https://www.youtube.com/watch?v=BEB_uQ98SO4
- Proxy vs Reverse Proxy (Real-world Examples) - https://www.youtube.com/watch?v=4NB0NDtOwIQ
- Bits of Architecture: RISC-V Processor Implementation Details - https://www.youtube.com/watch?v=qocfc2LQD9I
- What is AWS Private Certificate Authority? | Amazon Web Services - https://www.youtube.com/watch?v=9-Mj7NNEzlY
- Optimizer 2.0 - Desk check - 2021-08-19 - https://drive.google.com/drive/u/0/folders/1VIdyZXaqYDOwMYwgr1hjDn0Bsw2M5ecr
- Optimizer 2.0 - Desk check - 2021-09-15 - https://drive.google.com/drive/u/0/folders/1VIdyZXaqYDOwMYwgr1hjDn0Bsw2M5ecr
- Optimizer 2.0 - Desk check - 2021-09-22 - https://drive.google.com/drive/u/0/folders/1VIdyZXaqYDOwMYwgr1hjDn0Bsw2M5ecr
- Single-threaded async Rust - https://grod.es/posts/single-threaded_async_rust
- In search of performance - how we shaved 200ms off every POST request - https://gocardless.com/blog/in-search-of-performance-how-we-shaved-200ms-off-every-post-request/
- How We Built Uber Engineering’s Highest Query per Second Service Using Go - https://www.uber.com/en-BR/blog/go-geofence-highest-query-per-second-service/
- Making a change to SQLite source code - https://brunocalza.me/making-a-change-to-sqlite-source-code/
- How to speed up the Rust compiler in October 2022 - https://nnethercote.github.io/2022/10/27/how-to-speed-up-the-rust-compiler-in-october-2022.html
- Anatomy of a Production App - System Design - https://www.youtube.com/watch?v=akXP6pC0piE
- The Big Tech Hiring Slowdown Is Here and it will Hurt - https://blog.pragmaticengineer.com/big-tech-hiring-slowdown/
- Optimizer 2.0 - Desk check - 2021-10-06 - https://drive.google.com/drive/u/0/folders/1VIdyZXaqYDOwMYwgr1hjDn0Bsw2M5ecr
- What is a data lake? - https://aws.amazon.com//big-data/datalakes-and-analytics/what-is-a-data-lake/
- Tired of Layers? Vertical Slice Architecture to the rescue! - https://www.youtube.com/watch?v=lsddiYwWaOQ
- How does the detour crate work? - https://www.youtube.com/watch?v=aLeMCUXFJwY
- How To Trigger a Lambda Function on a Timer - Step by Step Tutorial - https://www.youtube.com/watch?v=aDqxCYRDQNI
- SQLite Internals: Pages & B-trees - https://fly.io/blog/sqlite-internals-btree/
- Optimizer 2.0 - Desk check - 2021-11-10 - https://drive.google.com/drive/u/0/folders/1VIdyZXaqYDOwMYwgr1hjDn0Bsw2M5ecr
- Optimizer 2.0 - Desk check - 2021-11-24 - https://drive.google.com/drive/u/0/folders/1VIdyZXaqYDOwMYwgr1hjDn0Bsw2M5ecr
- Explain Like I'm 5: Presto - https://www.youtube.com/watch?v=BGqIkiUtKHY
- Relational Query Languages - https://www.youtube.com/watch?v=KpbyPhJqIf0
- Optimizer 2.0 - Desk check - 2022-01-05 - https://drive.google.com/drive/u/0/folders/1VIdyZXaqYDOwMYwgr1hjDn0Bsw2M5ecr
- Bits of Architecture: Pipeline Hazards - https://www.youtube.com/watch?v=RO6RzEzCXVQ
- Bits of Architecture: RISC-V Pipelined Architecture - https://www.youtube.com/watch?v=Vr33OKh7TkE
- S3 system design | cloud storage system design | Distributed cloud storage system design - https://www.youtube.com/watch?v=UmWtcgC96X8
- Open-sourcing the new TypeScript type checker - https://kdy1.dev/posts/2022/10/open-sourcing-stc
- A New ScyllaDB Go Driver: Faster Than GoCQL and Its Rust Counterpart - https://www.scylladb.com/2022/10/12/a-new-scylladb-go-driver-faster-than-gocql-and-its-rust-counterpart/
- Shaving 40% Off Google’s B-Tree Implementation with Go Generics - https://www.scylladb.com/2022/04/27/shaving-40-off-googles-b-tree-implementation-with-go-generics/
- Rust: nomicon - Drop flags - https://doc.rust-lang.org/nomicon/drop-flags.html
- networking in c but without all those pesky sockets - https://www.youtube.com/watch?v=dpXKe-dw0uk
- Entendendo filas e processamento em segundo plano - https://www.youtube.com/watch?v=bko2yCg1ubY
- AWS Lambda and Secrets Manager Tutorial in Python - https://www.youtube.com/watch?v=pt9nAS4PVBI
- What is Transport Layer Security (TLS)? - https://www.cloudflare.com/learning/ssl/transport-layer-security-tls/
- What is an SSL certificate? - https://www.cloudflare.com/learning/ssl/what-is-an-ssl-certificate/
- What is IP spoofing? - https://www.cloudflare.com/learning/ddos/glossary/ip-spoofing/
- What is edge computing? - https://www.cloudflare.com/learning/serverless/glossary/what-is-edge-computing/
- What is streaming? | How video streaming works - https://www.cloudflare.com/learning/video/what-is-streaming/
- What is live streaming? | How live streaming works - https://www.cloudflare.com/learning/video/what-is-live-streaming/
- What is a video CDN? - https://www.cloudflare.com/learning/video/what-is-video-cdn/
- What is HTTP Live Streaming? | HLS streaming - https://www.cloudflare.com/learning/video/what-is-http-live-streaming/
- What is HDS streaming? | HLS vs. HDS - https://www.cloudflare.com/learning/video/what-is-http-dynamic-streaming/
- What is MPEG-DASH? | HLS vs. DASH - https://www.cloudflare.com/learning/video/what-is-mpeg-dash/
- What does buffering mean? | Buffering in video streaming - https://www.cloudflare.com/learning/video/what-is-buffering/
- What is latency? | How to fix latency - https://www.cloudflare.com/learning/performance/glossary/what-is-latency/
- What is Ransomware? - https://www.youtube.com/watch?v=lIsWpCMBxHQ
- The Secret Sauce Behind NoSQL: LSM Tree - https://www.youtube.com/watch?v=I6jB0nM9SKU
- Can MapReduce solve planning problems? - https://www.optaplanner.org/blog/2014/03/03/CanMapReduceSolvePlanningProblems.html
- False assumptions for the Vehicle Routing Problem - https://www.optaplanner.org/blog/2013/08/06/FalseAssumptionsForVRP.html
- Apache Kafka 3.3 Replaces ZooKeeper with the New KRaft Consensus Protocol - https://www.infoq.com/news/2022/10/apache-kafka-kraft/
- What is an Internet exchange point? | How do IXPs work? - https://www.cloudflare.com/learning/cdn/glossary/internet-exchange-point-ixp/
- Greedy randomized adaptive search procedure - https://en.wikipedia.org/wiki/Greedy_randomized_adaptive_search_procedure
- GRASP - https://pt.wikipedia.org/wiki/GRASP
- Optimizer 3.0 Desk check 17-05-2022
- Microsoft named a Leader in 2022 Gartner® Magic Quadrant™ for Cloud Infrastructure and Platform Services - https://azure.microsoft.com/en-us/blog/microsoft-named-a-leader-in-2022-gartner-magic-quadrant-for-cloud-infrastructure-and-platform-services/
- Here's Why Tribalism Trumps Truth - https://www.psychologytoday.com/us/blog/tech-happy-life/202009/heres-why-tribalism-trumps-truth
- Tech Talk From Open Source Project to Product - https://www.youtube.com/watch?v=7_gRjg7DIUw
- The Rust Programming Language for Game Tooling - https://www.youtube.com/watch?v=GtRo-eF8-TE
- What is API Gateway? - https://www.youtube.com/watch?v=6ULyxuHKxg8
- LinkedIn BizOps Interview Guide - https://www.youtube.com/watch?v=8RCfp397Ga8
- Untangling Lifetimes: The Arena Allocator - https://www.rfleury.com/p/untangling-lifetimes-the-arena-allocator
- C++ From Scratch: What is C++? - https://www.youtube.com/watch?v=dsW6ely8H1Y
- Tangaroa: a Byzantine Fault Tolerant Raft - https://www.scs.stanford.edu/14au-cs244b/labs/projects/copeland_zhong.pdf
- A memory-efficient data structure for geolocation history - https://denisidoro.github.io/posts/data-structure-geolocation-history/
- Building a crawler in Rust: Synchronization (Atomic Types and Barriers) - https://kerkour.com/rust-crawler-synchronization-atomic-types-barrier
- Building a crawler in Rust: Implementing the crawler - https://kerkour.com/rust-crawler-implementation
- Building a crawler in Rust: Design and Associated Types - https://kerkour.com/rust-crawler-associated-types
- Something is Weird About C, and its Getting People Hacked (buffer overflows explained) - https://www.youtube.com/watch?v=fjMrDDj47E8
- Base [q2]: Linked Lists - https://www.youtube.com/watch?v=gAijHHlyD5s
- In Defense Of Linked Lists - https://www.rfleury.com/p/in-defense-of-linked-lists
- My review of the System Design book - https://ahmet.im/blog/system-design-book-review/
- Anycast - https://en.wikipedia.org/wiki/Anycast
- Vector clock - https://en.wikipedia.org/wiki/Vector_clock
- Why Cassandra Doesn’t Need Vector Clocks - https://www.datastax.com/blog/why-cassandra-doesnt-need-vector-clocks
- Vector Clocks - https://sookocheff.com/post/time/vector-clocks/
- Local search (optimization) - https://en.wikipedia.org/wiki/Local_search_(optimization)
- Anytime algorithm - https://en.wikipedia.org/wiki/Anytime_algorithm
- WTF Buffet Architecture? - https://www.youtube.com/watch?v=8B445kqSKwg
- DynamoDB GetItem vs Query API - https://www.youtube.com/watch?v=twxM7WTfhGs
- Memory safety in C++, Zig, & Rust (part 1) - https://www.youtube.com/watch?v=qeiRGbYCD-0
- Bits of Architecture: Introduction to Forwarding/Bypassing - https://www.youtube.com/watch?v=aVEA3WKyfYs
- Weighted Sum Method – Multi Criteria Decision Making - https://www.geeksforgeeks.org/weighted-sum-method-multi-criteria-decision-making/
- Why Vector Clocks are Easy - https://riak.com/why-vector-clocks-are-easy/
- Why Vector Clocks Are Hard - https://riak.com/why-vector-clocks-are-hard/
- Lightweight transactions in Cassandra 2.0 - https://www.datastax.com/blog/lightweight-transactions-cassandra-20
- On the cruelty of really teaching computing science - https://www.cs.utexas.edu/users/EWD/transcriptions/EWD10xx/EWD1036.html
- Learning about distributed systems: where to start? - http://muratbuffalo.blogspot.com/2020/06/learning-about-distributed-systems.html
- Foundational distributed systems papers - http://muratbuffalo.blogspot.com/2021/02/foundational-distributed-systems-papers.html
- Amazon Redshift Re-invented - http://muratbuffalo.blogspot.com/2022/09/amazon-redshift-re-invented.html
- Announcing async-backtrace - https://tokio.rs/blog/2022-10-announcing-async-backtrace
- Property-Based Testing in Rust with Arbitrary - https://www.greyblake.com/blog/property-based-testing-in-rust-with-arbitrary/
- Go WebAssembly Internals - Part 1 - https://dev.to/x1unix/go-webassembly-internals-part-1-14aj
- Thread-Local State in Go, Huh? - https://puzpuzpuz.dev/thread-local-state-in-go-huh
- LongAdder and LongAccumulator in Java - https://www.baeldung.com/java-longadder-and-longaccumulator#dynamic-striping
- Boxes, Heaps, and Stacks - Tim McNamara - Rust Linz, September 2022 - https://www.youtube.com/watch?v=DEE1GKMbtgw
- System Design Interview - Top K Problem (Heavy Hitters) - https://www.youtube.com/watch?v=kx-XDoPjoHw
- An effective matching algorithm with adaptive tie‑breaking strategy for online food delivery problem - https://link.springer.com/content/pdf/10.1007/s40747-021-00340-x.pdf
- Scoped threads in Rust, and why its async counterpart would be unsound - https://wishawa.github.io/posts/thread-scoped-async/
- Events: Fat or Thin - https://codesimple.blog/2019/02/16/events-fat-or-thin/
- Events on the Outside vs Events on the Inside - https://codesimple.blog/2021/03/14/events-on-the-outside-vs-events-on-the-inside/
- What is BGP? | BGP routing explained - https://www.cloudflare.com/learning/security/glossary/what-is-bgp/
- Is BGP Safe Yet? No. But we are tracking it carefully - https://blog.cloudflare.com/is-bgp-safe-yet-rpki-routing-security-initiative/
- Type Layout - https://doc.rust-lang.org/reference/type-layout.html
- What is an origin server? | Origin server definition - https://www.cloudflare.com/learning/cdn/glossary/origin-server/
- What happens in a TLS handshake? | SSL handshake - https://www.cloudflare.com/learning/ssl/what-happens-in-a-tls-handshake/
- Live video just got more live: Introducing Concurrent Streaming Acceleration - https://blog.cloudflare.com/introducing-concurrent-streaming-acceleration/
- What is H.264? | Advanced Video Coding (AVC) - https://www.cloudflare.com/learning/video/what-is-h264-avc/
- Doing a math assignment with the Lean theorem prover - https://ahelwer.ca/post/2020-04-05-lean-assignment/
- mmap(1Tb): A Rust arena allocator (ab)using Linux overcommit - https://vgel.me/posts/mmap-arena-alloc/
- Generational indices guide - https://lucassardois.medium.com/generational-indices-guide-8e3c5f7fd594
- Understanding Trade-Offs in Distributed Messaging - https://dzone.com/articles/understanding-trade-offs-in-distributed-messaging
- Two Generals' Problem - https://en.wikipedia.org/wiki/Two_Generals%27_Problem
- Eventual consistency - https://en.wikipedia.org/wiki/Eventual_consistency
- Conflict-free replicated data type - https://en.wikipedia.org/wiki/Conflict-free_replicated_data_type
- SQLite: Past, Present, and Future - http://muratbuffalo.blogspot.com/2022/09/sqlite-past-present-and-future.html
- Testing CRDTs in Rust, From Theory to Practice - https://www.ditto.live/blog/testing-crdts-in-rust-from-theory-to-practice
- Prometheus: The Documentary - https://www.youtube.com/watch?v=rT4fJNbfe14
- Eventually consistent - https://dl.acm.org/doi/pdf/10.1145/1435417.1435432
- The assignment problem - https://hungarianalgorithm.com/assignmentproblem.php
- The Hungarian algorithm: An example - https://hungarianalgorithm.com/examplehungarianalgorithm.php
- Scaling PostgresML to 1 Million Requests per Second¶ - https://postgresml.org/blog/scaling-postgresml-to-one-million-requests-per-second/
- Device file - https://en.wikipedia.org/wiki/Device_file#Pseudo-devices
- Design and implementation of the Second extended filesystem - https://web.stanford.edu/class/cs240/old/sp2014/readings/ext2_design.pdf
- Reliable multicast - https://en.wikipedia.org/wiki/Reliable_multicast
- Tech Talk: ArgoCD + Tekton = Better GitOps - https://www.youtube.com/watch?v=nOtxRNQAKXA
- A Jane Street Software Engineering Mock Interview with Grace and Nolen - https://www.youtube.com/watch?v=VfbFJISCP3g
- Cisco Packet Tracer | Everything You Need to Know - https://www.youtube.com/watch?v=qZB_biPOBwA
- why async fn in traits are hard - https://smallcultfollowing.com/babysteps/blog/2019/10/26/async-fn-in-traits-are-hard/
- A GC-FRIENDLY GO INTERNING CACHE - https://words.filippo.io/dispatches/certificate-interning/
- The bubble has popped for unprofitable software companies - https://world.hey.com/dhh/the-bubble-has-popped-for-unprofitable-software-companies-2a0a5f57
- MySQL vs MongoDB - https://www.youtube.com/watch?v=OdgZ0jr4jpM
- The Networking behind clicking a link - https://medium.com/@hnasr/the-networking-behind-clicking-a-link-b2ce36b7cf14
- GopherCon 2022: Katie Hockman - Fuzz Testing Made Easy - https://www.youtube.com/watch?v=7KWPiRq3ZYI
- Introducing the AWS Lambda Telemetry API - https://aws.amazon.com/blogs/compute/introducing-the-aws-lambda-telemetry-api/
- Rust Is Boring (Why Rust?) [RUST-13] - https://www.youtube.com/watch?v=oY0XwMOSzq4
- Cache me if you can: A Look at Common Caching Strategies, and how CQRS can Replace the Need in the First Place - https://medium.com/ssense-tech/cache-me-if-you-can-a-look-at-common-caching-strategies-and-how-cqrs-can-replace-the-need-in-the-65ec2b76e9e
- Cache stampede - https://en.wikipedia.org/wiki/Cache_stampede
- Introducing Amazon EventBridge Scheduler - https://aws.amazon.com/blogs/compute/introducing-amazon-eventbridge-scheduler/
- Hashed and Hierarchical Timing Wheels: Data Structures for the Efficient Implementation of a Timer Facility - http://www.cs.columbia.edu/~nahum/w6998/papers/sosp87-timing-wheels.pdf
- Hashed and Hierarchical Timing Wheels - https://paulcavallaro.com/blog/hashed-and-hierarchical-timing-wheels/
- How Uber is monitoring 4,000 microservices with its open sourced Prometheus platform - https://www.cncf.io/case-studies/uber/
- Xilem: an architecture for UI in Rust - https://raphlinus.github.io/rust/gui/2022/05/07/ui-architecture.html
- Build applications of any size on Cloudflare with the Queues open beta - https://blog.cloudflare.com/cloudflare-queues-open-beta/
- Building a scheduling system with Workers and Durable Objects - https://blog.cloudflare.com/building-scheduling-system-with-workers-and-durable-objects/
- System Design: Designing a Distributed Job Scheduler - https://levelup.gitconnected.com/system-design-designing-a-distributed-job-scheduler-6d3b6d714fdb
- System Design — Design a distributed job scheduler (Keep It Simple Stupid Interview series) - https://www.linkedin.com/pulse/system-design-distributed-job-scheduler-keep-simple-stupid-ismail/
- Do you have enough Complexity for a Domain Model (Domain Driven Design)? - https://www.youtube.com/watch?v=L1foFiqopIc
- Setting Up Prometheus And Grafana on AWS EKS (Getting Started) - https://www.youtube.com/watch?v=S41v1lVThds
- "Building a Distributed Task Scheduler With Akka, Kafka, and Cassandra" by David van Geest - https://www.youtube.com/watch?v=s3GfXTnzG_Y
- How PlanetScale Boost serves your SQL queries instantly - https://planetscale.com/blog/how-planetscale-boost-serves-your-sql-queries-instantly
- Google Coding Interview with a Meta Intern - https://www.youtube.com/watch?v=46dZH7LDbf8
- What is Middleware? - https://www.youtube.com/watch?v=1oWPUpMheGk
- Hyper polish period - https://seanmonstar.com/post/701008919383932928/hyper-polish-period
- The distributed computing manifesto - https://www.allthingsdistributed.com/2022/11/amazon-1998-distributed-computing-manifesto.html
- How to centralize thousands of data sources with Grafana: Inside Adform’s observability system - https://grafana.com/blog/2022/11/18/how-to-centralize-thousands-of-data-sources-with-grafana-inside-adforms-observability-system/?mdm=social
- Announcing axum 0.6.0 - https://tokio.rs/blog/2022-11-25-announcing-axum-0-6-0
- On Automata in Rust - https://radekmie.dev/blog/on-automata-in-rust/
- Writing a kernel driver with Rust. - https://not-matthias.github.io/posts/kernel-driver-with-rust/
- Domain Events and Event Sourcing go hand in hand? Not Exactly! - https://www.youtube.com/watch?v=dJBTNksQzys
- How we can make it easy? An example with code - https://www.effective-software-testing.com/how-can-we-make-it-easy-illustrated-with-code
- You DON'T always need Interfaces for Testing & Mocking - https://www.youtube.com/watch?v=2oRofOH2NT4
- What is RPC? gRPC Introduction - https://www.youtube.com/watch?v=gnchfOojMk4
- Memory Safe Languages in Android 13 - https://security.googleblog.com/2022/12/memory-safe-languages-in-android-13.html
- Observability Engineering - https://www.amazon.com.br/Observability-Engineering-Achieving-Production-Excellence/dp/1492076449
- How We Built Fly Postgres - https://fly.io/blog/how-we-built-fly-postgres/
- computers are horrible at division (a painful discovery) - https://www.youtube.com/watch?v=ssDBqQ5f5_0
- Threads and messages with Rust and WebAssembly - https://www.tweag.io/blog/2022-11-24-wasm-threads-and-messages/
- Postgres: a better message queue than Kafka? - https://dagster.io/blog/skip-kafka-use-postgres-message-queue
- The database as queue anti-pattern - http://mikehadlow.blogspot.com/2012/04/database-as-queue-anti-pattern.html
- Bits of Architecture: Forwarding Logic - https://www.youtube.com/watch?v=sDSGqEdQ9tA
- What the heck is the event loop anyway? | Philip Roberts | JSConf EU - https://www.youtube.com/watch?v=8aGhZQkoFbQ
- How does AI find its path and beat you at chess? | Bitwise - https://www.youtube.com/watch?v=TwblsSL3-js
- How to design a serverless app - https://www.youtube.com/watch?v=ertbL2Rxbvk
- You might not need a CRDT - https://driftingin.space/posts/you-might-not-need-a-crdt
- Quickwit 0.4: Distributed indexing with Kafka, K8s-native, and more! - https://quickwit.io/blog/quickwit-0.4/
- How CRDTs make multiplayer text editing part of Zed's DNA - https://zed.dev/blog/crdts
- Rust in Production at Figma - https://www.figma.com/blog/rust-in-production-at-figma/
- Onwards to the Core: etcd - https://www.mgasch.com/2021/01/listwatch-part-1/
- The Anatomy of Kubernetes ListWatch(): Prologue - https://www.mgasch.com/2021/01/listwatch-prologue/
- QoS, "Node allocatable" and the Kubernetes Scheduler - https://www.mgasch.com/2017/10/sched-reconcile/
- A complete guide to managing Grafana as code: tools, tips, and tricks - https://grafana.com/blog/2022/12/06/a-complete-guide-to-managing-grafana-as-code-tools-tips-and-tricks/?mdm=social
- Events, the DNA of Kubernetes - https://www.mgasch.com/2018/08/k8sevents/
- A few things I've learned about Kubernetes - https://jvns.ca/blog/2017/06/04/learning-about-kubernetes/
- https://jvns.ca/blog/2017/06/04/learning-about-kubernetes/ - https://jvns.ca/blog/2016/12/22/container-networking/
- How does the Kubernetes scheduler work? - https://jvns.ca/blog/2017/07/27/how-does-the-kubernetes-scheduler-work/
- Iptables basics - https://jvns.ca/blog/2017/06/07/iptables-basics/
- Kubernetes deep dive: API Server - part 1 - https://cloud.redhat.com/blog/kubernetes-deep-dive-api-server-part-1
- Kubernetes Deep Dive: API Server – Part 2 - https://cloud.redhat.com/blog/kubernetes-deep-dive-api-server-part-2
- Kubernetes Deep Dive: API Server – Part 3a - https://cloud.redhat.com/blog/kubernetes-deep-dive-api-server-part-3a
- Underpaid Programmers - https://geekincentives.substack.com/p/underpaid-programmers
- What even is a kubelet? - https://kamalmarhubi.com/blog/2015/08/27/what-even-is-a-kubelet/
- Notes about ETCD - https://pierrezemb.fr/posts/notes-about-etcd/
- How a production outage in Grafana Cloud's Hosted Prometheus service was caused by a bad etcd client setup - https://grafana.com/blog/2020/04/07/how-a-production-outage-in-grafana-clouds-hosted-prometheus-service-was-caused-by-a-bad-etcd-client-setup/
- A Byzantine failure in the real world - https://blog.cloudflare.com/a-byzantine-failure-in-the-real-world/
- Diving into ETCD's linearizable reads - https://pierrezemb.fr/posts/diving-into-etcd-linearizable/
- A deep dive into Kubernetes controller - https://docs.bitnami.com/tutorials/a-deep-dive-into-kubernetes-controllers
- Hub-and-Spoke Architecture - https://polarising.com/blog/hub-spoke-architecture/
- Kubewatch, an example of Kubernetes custom controller - https://docs.bitnami.com/tutorials/kubewatch-an-example-of-kubernetes-custom-controller
- Rust, Tauri, and React: Our Technology choices for a desktop app in 2022 - https://www.highflux.io/blog/rust-tauri-react-developing-desktop-app-2022
- Understanding Kubernetes controllers part I – queues and the core controller loop - https://leftasexercise.com/2019/07/08/understanding-kubernetes-controllers-part-i-queues-and-the-core-controller-loop/
- Understanding Kubernetes controllers part II – object stores and indexers - https://leftasexercise.com/2019/07/11/understanding-kubernetes-controllers-part-ii-object-stores-and-indexers/
- Understanding Kubernetes controllers part III – informers - https://leftasexercise.com/2019/07/15/understanding-kubernetes-controllers-part-iii-informers/
- Understanding Kubernetes controllers part IV – putting it all together - https://leftasexercise.com/2019/07/18/understanding-kubernetes-controllers-part-iv-putting-it-all-together/
- K8s — Controller Manager - https://medium.com/geekculture/k8s-controller-manager-9177b383593b
- FSharp - Category Theory - Monoid - https://www.garethrepton.com/Category-Theory-Monoids/
- What is ArgoCD - https://www.youtube.com/watch?v=p-kAqxuJNik
- Google Cloud Fundamentals for AWS Professionals - https://www.cloudskillsboost.google/course_sessions/1920400/documents/341868
- Kubernetes Controllers | Complete Guide for 2022 - https://www.containiq.com/post/kubernetes-controllers
- Don't Fail Publishing Events! Event Driven Architecture Consistency - https://www.youtube.com/watch?v=tcePbob8rrY
- SSL, TLS, HTTPS Explained - https://www.youtube.com/watch?v=j9QmMEWmcfo
- On-Demand Compute - https://fly.io/laravel-bytes/on-demand-compute/
- Kubernetes Controller Manager: A Gentle Introduction - https://komodor.com/learn/controller-manager/
- How MVCC databases work internally - https://kousiknath.medium.com/how-mvcc-databases-work-internally-84a27a380283
- Jepsen: etcd 3.4.3 - https://jepsen.io/analyses/etcd-3.4.3
- Linearizability - http://jepsen.io/consistency/models/linearizable
- Sequential Consistency - http://jepsen.io/consistency/models/sequential
- Strict Serializability - http://jepsen.io/consistency/models/strict-serializable
- Latest Jepsen Results against etcd 3.4.3 - https://etcd.io/blog/2020/jepsen-343-results/
- Consensus - https://people.cs.rutgers.edu/~pxk/417/notes/content/consensus.html
- A Year-End Letter from our Executive Director - https://letsencrypt.org/2022/12/05/ed-letter-2022.html
- New in Go 1.20: wrapping multiple errors - https://lukas.zapletalovi.com/posts/2022/wrapping-multiple-errors/
- Deep dive into the internals of an immutable database, immudb - https://aly.arriqaaq.com/diving-into-the-internals-of-an-immutable-database/
- How etcd works with and without Kubernetes - https://learnk8s.io/etcd-kubernetes
- Kubernetes vs. Docker: It's Not an Either/Or Question - https://www.youtube.com/watch?v=2vMEQ5zs1ko
- A Guide to Kubernetes Etcd: All You Need to Know to Set up Etcd Clusters - https://superuser.openstack.org/articles/a-guide-to-kubernetes-etcd-all-you-need-to-know-to-set-up-etcd-clusters/
- How Time Series Databases Work—and Where They Don't - https://www.honeycomb.io/blog/time-series-database
- Misadventures with Kube DNS - https://blog.sophaskins.net/blog/misadventures-with-kube-dns/
- The Chubby lock service for loosely-coupled distributed systems - https://static.googleusercontent.com/media/research.google.com/en//archive/chubby-osdi06.pdf
- Two Beautiful Rust Programs - https://matklad.github.io//2020/07/15/two-beautiful-programs.html
- Lenses and Prisms - https://rust-unofficial.github.io/patterns/functional/lenses.html
- What Is GraphQL? REST vs. GraphQL - https://www.youtube.com/watch?v=yWzKJPw_VzM&t=7s
- What if I told you that Relational Databases are in fact Event Stores? - https://event-driven.io/pl/relational_databases_are_event_stores/
- Rust in 2023 - https://www.ncameron.org/blog/rust-in-2023/
- PostgreSQL vs MySQL - https://www.youtube.com/watch?v=btjBNKP49Rk
- Essential Google Cloud Infrastructure: Foundation - https://www.cloudskillsboost.google/course_templates/50
- Heads-Up: Amazon S3 Security Changes Are Coming in April of 2023 - https://aws.amazon.com/blogs/aws/heads-up-amazon-s3-security-changes-are-coming-in-april-of-2023/
- Shopify Embraces Rust for Systems Programming - https://shopify.engineering/shopify-rust-systems-programming
- Announcing Rust 1.66.0 - https://blog.rust-lang.org/2022/12/15/Rust-1.66.0.html
- The Kubernetes Book: 2022 Edition - https://www.amazon.com.br/Kubernetes-Book-Version-November-English-ebook/dp/B072TS9ZQZ
- What is SaaS Backup? - https://www.youtube.com/watch?v=yG1ng3vEVPU
- Hey, Junior Dev! This is is how your "Sr." Devs built a mess. - https://www.youtube.com/watch?v=f2XkeDZnn4E
- "I NEED data from another service!"... Do you really? - https://www.youtube.com/watch?v=anL-RGKz_Ak
- Process vs Thread | Popular Interview Question - https://www.youtube.com/watch?v=4rLW7zg21gI
- What is a Protocol? (Deepdive) - https://www.youtube.com/watch?v=d-zn-wv4Di8
- Getting started with Grafana Mimir - https://www.youtube.com/watch?v=pTkeucnnoJg
- What is Grafana Mimir? - https://grafana.com/oss/mimir/#:~:text=Grafana%20Mimir%20is%20an%20open,Labs%20and%20announced%20in%202022.
- User Datagram Protocol - https://www.ietf.org/rfc/rfc768.txt
- A Guide to Using Raw Sockets - https://www.opensourceforu.com/2015/03/a-guide-to-using-raw-sockets/
- Eliminating cold starts with Cloudflare Workers - https://blog.cloudflare.com/eliminating-cold-starts-with-cloudflare-workers/
- Wide-column Database - https://www.scylladb.com/glossary/wide-column-database/
- NoSQL wide-column stores demystified - https://blog.logrocket.com/nosql-wide-column-stores-demystified/
- MercadoLibre Grows with Go - https://go.dev/solutions/mercadolibre
- Introducing the Docker+Wasm Technical Preview - https://www.docker.com/blog/docker-wasm-technical-preview/
- What is Anycast? - https://www.thousandeyes.com/learning/techtorials/anycast
- What is the Border Gateway Protocol (BGP)? - https://www.thousandeyes.com/learning/glossary/bgp-border-gateway-protocol
- What is a Content Delivery Network (CDN)? - https://www.thousandeyes.com/learning/glossary/cdn-content-delivery-network
- What is a Domain Name and How Does DNS work? - https://www.thousandeyes.com/learning/techtorials/dns-domain-name-system
- Using Anycast for Internet Services - https://www.thousandeyes.com/blog/using-anycast-for-internet-services
- Wheels up for Waymo as we expand our 24/7 rider-only territories - https://blog.waymo.com/2022/12/wheels-up-for-waymo-as-we-expand.html
- Concurrent observer pattern in Go - https://rebelsource.dev/blog/concurrent-observer-pattern-in-go/MqTnjdkcE
- Hello, Video Codec! - https://blog.tempus-ex.com/hello-video-codec/
- Different Device Types/Modes in Bluetooth - https://www.youtube.com/watch?v=67lDhhgLXTo
- From C ➡️ C++ ➡️ Rust - https://www.youtube.com/watch?v=wGCWlI4A5z4
- Universally Unique Lexicographically Sortable Identifier - https://github.com/ulid/spec
- Sharding & IDs at Instagram - https://instagram-engineering.com/sharding-ids-at-instagram-1cf5a71e5a5c
- 10 Tips for Building Resilient Payment Systems - https://shopify.engineering/building-resilient-payment-systems
- The 2^120 Ways to Ensure Unique Identifiers - https://firebase.blog/posts/2015/02/the-2120-ways-to-ensure-unique_68
- Building and Testing Resilient Ruby on Rails Applications - https://shopify.engineering/building-and-testing-resilient-ruby-on-rails-applications
- TCP over IP Anycast - Pipe dream or Reality? - https://engineering.linkedin.com/network-performance/tcp-over-ip-anycast-pipe-dream-or-reality
- Starting Greenfield Project? Here's where to start. - https://www.youtube.com/watch?v=WXalcPX8ak4
- How do Hard Disk Drives Work? 💻💿🛠 - https://www.youtube.com/watch?v=wtdnatmVdIg
- Database Caching for System Design Interviews - https://www.youtube.com/watch?v=6GY1akbxyEo
- Rust vs Common C++ Bugs - https://geo-ant.github.io/blog/2022/common-cpp-errors-vs-rust/
- Extending Kubernetes: Elevate Kubernetes with Extension Patterns, Operators, and Plugins - https://www.amazon.com/Extending-Kubernetes-Extension-Patterns-Operators/dp/1484270940
- OTP DNS queries in Elixir: Advent of Elixir day 24 - https://www.youtube.com/watch?v=5zaOencPLsw
- What is OSI Model | Real World Examples - https://www.youtube.com/watch?v=0y6FtKsg6J4
- Using Postgresql Advisory Locks for Leader Election - https://jeremydmiller.com/2020/05/05/using-postgresql-advisory-locks-for-leader-election/
- Advisory Locks in PostgreSQL - https://hashrocket.com/blog/posts/advisory-locks-in-postgres
- Rust Port Sniffer v2 - Update - https://www.youtube.com/watch?v=RhFZxkxkeIc
- How Shopify’s engineering improved writes by 50% with ULID - https://www.youtube.com/watch?v=f53-Iw_5ucA
- Concurrency Deep Dive: Code Strategies for High Traffic Applications - https://nathanpeck.com/concurrency-deep-dive-strategies-for-high-traffic-applications/
- What You Need to Know About the RunC Container Escape Vulnerability - https://thenewstack.io/what-you-need-to-know-about-the-runc-container-escape-vulnerability/
- Debunking the cloud's 'noisy neighbor' myth - https://www.infoworld.com/article/3073503/debunking-the-clouds-noisy-neighbor-myth.html
- Root your Docker host in 10 seconds for fun and profit - https://www.electricmonk.nl/log/2017/09/30/root-your-docker-host-in-10-seconds-for-fun-and-profit/
- Resource exhaustion attack - https://en.wikipedia.org/wiki/Resource_exhaustion_attack
- Concurrency Compared: AWS Lambda, AWS App Runner, and AWS Fargate - https://nathanpeck.com/concurrency-compared-lambda-fargate-app-runner/
- Service Mesh: What it is and why it matters? - https://techblost.com/service-mesh-what-it-is-and-why-it-matters/
- The Talk You've Been Await-ing for - https://www.youtube.com/watch?v=NNwK5ZPAJCk
- How to make a Kernel Driver - Setup & Hello World - Kernel1 - https://www.youtube.com/watch?v=9h1FsOISwX0
- Grafana Labs in 2022: Top 10 moments of the year - https://grafana.com/blog/2022/12/27/grafana-labs-top-10-moments-2022/?mdm=social
- Go (Golang) vs. Rust: (HTTP/REST API in Kubernetes) Performance Benchmark - https://www.youtube.com/watch?v=QWLyIBkBrl0
- Kubernetes 1.26: Job Tracking, to Support Massively Parallel Batch Workloads, Is Generally Available - https://kubernetes.io/blog/2022/12/29/scalable-job-tracking-ga/
- Finalizers - https://kubernetes.io/docs/concepts/overview/working-with-objects/finalizers/
- Owners and Dependents - https://kubernetes.io/docs/concepts/overview/working-with-objects/owners-dependents/
- Why Kubernetes secrets take so long to update? - https://ahmet.im/blog/kubernetes-secret-volumes-delay/
- Pitfalls reloading files from Kubernetes Secret & ConfigMap volumes - https://ahmet.im/blog/kubernetes-inotify/
- Podman: A more secure way to run containers - https://opensource.com/article/18/10/podman-more-secure-way-run-containers
- Container Security: Fundamental Technology Concepts that Protect Containerized Applications - https://www.amazon.com/Container-Security-Fundamental-Containerized-Applications/dp/1492056707
- The HIDDEN Challenge of Microservices: UI Composition - https://www.youtube.com/watch?v=ILbjKR1FXoc
- How to Build Custom Prometheus Exporter? (Step-by-Step - Real-world Example - Parse Log + HTTP) - https://www.youtube.com/watch?v=3wT0zSsQb58
- The world of PostgreSQL wire compatibility - https://datastation.multiprocess.io/blog/2022-02-08-the-world-of-postgresql-wire-compatibility.html
- The state of HTTP in 2022 - https://blog.cloudflare.com/the-state-of-http-in-2022/
- Use Kubernetes Gateway API for Mesh (Service-to-Service Communication - Istio - Kiali - Prometheus) - https://www.youtube.com/watch?v=joyucBMNrmw
- A Matter of Time: Evolving Clock Sync for Distributed Databases - https://www.yugabyte.com/blog/evolving-clock-sync-for-distributed-databases/
- What is Distributed SQL? - https://www.yugabyte.com/tech/distributed-sql/
- What are Distributed ACID Transactions? - https://www.yugabyte.com/tech/distributed-acid-transactions/
- What is Database Sharding? - https://www.yugabyte.com/tech/database-sharding/
- What is the Raft Consensus Algorithm? - https://www.yugabyte.com/tech/raft-consensus-algorithm/
- Building a more accurate time service at Facebook scale - https://engineering.fb.com/2020/03/18/production-engineering/ntp-service/
- GopherCon 2017: Liz Rice - A Go Programmer's Guide to Syscalls - https://www.youtube.com/watch?v=01w7viEZzXQ
- How does Computer Memory Work? 💻🛠 - https://www.youtube.com/watch?v=7J7X7aZvMXQ
- Spot the Docker difference - https://medium.com/microscaling-systems/spot-the-docker-difference-9f99adcc4aaf
- How we scaled our new Prometheus TSDB Grafana Mimir to 1 billion active series - https://grafana.com/blog/2022/04/08/how-we-scaled-our-new-prometheus-tsdb-grafana-mimir-to-1-billion-active-series/?mdm=social
- Grafana Mimir hash rings - https://grafana.com/docs/mimir/latest/operators-guide/architecture/hash-ring/?pg=blog&plcmt=body-txt
- Being a Grafanista: a look from inside - https://pracucci.com/being-a-grafanista-a-look-from-inside.html