reading-material
List of some useful blogs, books, courses, papers etc. :books:
https://github.com/agrim123/reading-material
Last synced: 6 days ago
JSON representation
-
Containers
-
Kubernetes :construction:
-
More
-
Docker
-
-
Courses
-
More
-
Security Papers
- The Twelve-Factor App
- Laws of UX
- Design Patterns
- Semantic Versioning 2.0.0
- The Clean Architecture
- Modern Software Over-Engineering Mistakes
- JVM Profiler: An Open Source Tool for Tracing Distributed JVM Applications at Scale
- DevOps, SRE, and Platform Engineering
- Detecting the use of "curl | bash" server side
- PHP The Wrong Way
- DESIGN PATTERNS
- Hacker's guide to Neural Networks
- CQRS
- The language of choice
- Gossip Protocol Explained
- Memory Allocation
- The Mind behind Linux
- Password storage in source control
- Difference b/w Integration and Unit Tests
- Return to the Source
- Ask HN: “Write your own” or “Build your own” software projects
- Software Testing Anti-patterns
- Clojure - the perfect language to expand your brain?
- International Journal of Proof-of-Concept or Get The Fuck Out
- Making a virtual machine in Google Sheets
- How Did Software Get So Reliable Without Proof?
- The Danger of “Simplicity”
- See Python, See Python Go, Go Python Go
- Programmer's critique of missing structure of operating systems
- Enabling Machine Learning with Apache Flink - Sherin Thomas
- High-Throughput, Thread-Safe, LRU Caching
- Sorting 1 million 8-decimal-digit numbers with 1 MB of RAM
- Mathematical attack on RSA
- In defence of swap: common misconceptions
- Epigrams on Programming
- Choose Boring Technology
- How to stop procrastinating by using the Fogg Behavior Model
- Andrei Pangin - Everything you wanted to know about Stack Traces and Heap Dumps
- The Life of a Data Byte
- How To Design A Good API and Why it Matters
- The 13 immutable reads on choosing what to work on
- The Duct Tape Programmer
- The Hitchhiker’s Guide to Compression
- Parsing Algorithms
- Intentionally leaking AWS keys
- Dream Deploys: Atomic, Zero-Downtime Deployments
- Intro to Threads and Processes in Python
- Unreliability At Scale
- Extreme HTTP Performance Tuning: 1.2M API req/s on a 4 vCPU EC2 Instance
- Reverse Proxy, HTTP Keep-Alive Timeout, and sporadic HTTP 502s
- A Solution to HTTP 502 Errors with AWS ALB
- Gunicorn vs Python GIL
- Gunicorn Worker Types: How to choose the right one
- A brief description of the architecture of Gunicorn
- “Don’t Mock What You Don’t Own” in 5 Minutes
- The History of Pets vs Cattle and How to Use the Analogy Properly
- Scalable WebSocket Architecture
- Unified Streaming And Batch Pipelines At LinkedIn
- Millions of active WebSockets with Node.js
- Anything can be a message queue if you use it wrongly enough
- See this page fetch itself, byte by byte, over TLS
- Six Ways to Crash Elasticsearch
- Building a high performance JSON parser
- Upsert in SQL
- All you need to know about the Google File System
-
- The Absolute Minimum Every Software Developer Absolutely, Positively Must Know About Unicode and Character Sets (No Excuses!)
- Epigrams in programming
- A better zip bomb
- The Forgotten History of OOP
- Race Condition vs. Data Race
- A byte’s not 8 bits.
- Why stack grows down
- Queryparser, an Open Source Tool for Parsing and Analyzing SQL
- Essays on programming I think about a lot
- lzop vs compress vs gzip vs bzip2 vs lzma vs lzma2/xz benchmark, reloaded
- The Differences Between Interpreter and Compiler Explained
- Branch predictor: How many "if"s are too many? Including x86 and M1 benchmarks!
- A list of everything that could go in the \<head\> of your document
- A few notes on AWS Nitro Enclaves: Attack surface
- Epigrams in programming
- Exploring How Cache Memory Really Works
- Control and Processing Software
- Taking a Look at Compression Algorithms
- Building Cloud Storage from Scratch
-
-
JS
-
Pilot Run
-
Advanced Concepts
- Lazy, composable, and modular JavaScript
- Essential Image Optimization
- A cartoon intro to WebAssembly
- What makes WebAssembly fast?
- What is a Closure?
- this in JS
- How to Fix the ES6 `class` keyword
- What is the Difference Between Class and Prototypal Inheritance?
- Douglas Crockford: Really. JavaScript.
- Composing Software
- The Dao of Immutability
- JavaScript engine fundamentals: Shapes and Inline Caches
- What is a Promise?
- Circular dependencies in JavaScript
- Hoisting in Javascript
- Async-Await
- Await and Async Explained with Diagrams and Examples
- Javascript : The Curious Case of Null >= 0
- Elements of JavaScript Style
- Headless Chromium
- Rich JavaScript Applications – the Seven Frameworks
- Why does Google prepend while(1); to their JSON responses?
- What is `this`? The Inner Workings of JavaScript Objects
- Responsible JavaScript
- JavaScript Event Loop And Call Stack Explained
- Looking into assembly code of coercion
- The Lost Art of the Makefile
- Streams—The definitive guide
- Hoisting in Javascript
- Javascript : The Curious Case of Null >= 0
- Hoisting in Javascript
- Javascript : The Curious Case of Null >= 0
- Hoisting in Javascript
- Javascript : The Curious Case of Null >= 0
- Hoisting in Javascript
- Javascript : The Curious Case of Null >= 0
- Hoisting in Javascript
- Javascript : The Curious Case of Null >= 0
- Hoisting in Javascript
- Javascript : The Curious Case of Null >= 0
- Hoisting in Javascript
- Javascript : The Curious Case of Null >= 0
- Hoisting in Javascript
- Javascript : The Curious Case of Null >= 0
- Hoisting in Javascript
- Javascript : The Curious Case of Null >= 0
- Hoisting in Javascript
- Javascript : The Curious Case of Null >= 0
- Hoisting in Javascript
- Javascript : The Curious Case of Null >= 0
- Hoisting in Javascript
- Javascript : The Curious Case of Null >= 0
- Hoisting in Javascript
- Javascript : The Curious Case of Null >= 0
- Hoisting in Javascript
- Javascript : The Curious Case of Null >= 0
- Hoisting in Javascript
- Javascript : The Curious Case of Null >= 0
- Hoisting in Javascript
- Javascript : The Curious Case of Null >= 0
- Hoisting in Javascript
- Javascript : The Curious Case of Null >= 0
- Hoisting in Javascript
- Javascript : The Curious Case of Null >= 0
- Hoisting in Javascript
- Javascript : The Curious Case of Null >= 0
- Hoisting in Javascript
- Javascript : The Curious Case of Null >= 0
- Hoisting in Javascript
- Javascript : The Curious Case of Null >= 0
- Hoisting in Javascript
- Javascript : The Curious Case of Null >= 0
- Hoisting in Javascript
- Javascript : The Curious Case of Null >= 0
- Hoisting in Javascript
- Javascript : The Curious Case of Null >= 0
-
v8
-
React, Redux
-
JS Books
-
-
Functional Programming
-
Go
-
Go Pilot run
-
More
- Applied Go
- Optimizing M3: How Uber Halved Our Metrics Ingestion Latency by (Briefly) Forking the Go Compiler
- Data Race Patterns in Go
- Interfaces in Go
- Go Data Structures: Interfaces
- Golang Has Generics
- Go-tcha: When nil != nil
- SOLID Go Design
- Simple techniques to optimise Go programs
- A whirlwind tour of Go’s runtime environment variables
- How we optimized our DNS server using go tools
- Writing a very fast cache service with millions of entries in Go
- Go, without package scoped variables
- How to generate a random string of a fixed length in Go?
- Building efficient statsd library in Go
- Gopher Puzzlers
- Visually Understanding Worker Pool
- Life of an HTTP request in a Go server
- Send data from file without loading into memory
- Optimizing Large File Transfers in Linux with Go - An Exploration of TCP and Syscall
- Pardon the Interruption: Loop Preemption in Go 1.14
- Mastering WebSockets With Go
- proposal: arena: new package providing memory arenas
- A Tale of Two `rand`s
-
Go Internals
- Scheduler Tracing In Go
- Everything about Go: internals, concurrency, compiler, or packages available in the Go community.
- How does the go build command work?
- Introducing the Go Race Detector
- String interning in Go
- Interning strings in Go
- Arrays, slices (and strings): The mechanics of 'append'
- Go’s hidden #pragmas
- Detecting Race Conditions With Go
- The Go scheduler
- Analysis of the Go runtime scheduler
- Go's work-stealing scheduler
- Golang’s Real-time GC in Theory and Practice
- runtime: Large maps cause significant GC pauses
- How We Saved 70K Cores Across 30 Mission-Critical Services (Large-Scale, Semi-Automated Go GC Tuning @Uber)
- A Guide to the Go Garbage Collector
- Avoiding high GC overhead with large heaps
- Go compiler internals
- The Go Memory Model
- Memory Leaking Scenarios
- Memory Order Guarantees in Go
- GO MEMORY MANAGEMENT
- Contiguous stacks in Go
- Memory Optimizations for Go Systems
- A few bytes here, a few there, pretty soon you’re talking real memory
- Golang escape analysis
- Are large slices more expensive than smaller ones?
- There is no pass-by-reference in Go
- Allocation efficiency in high-performance Go services
- An attempt at visualizing the Go GC
-
Concepts
- Go Concurrency from the Ground Up
- How Goroutines Work
- Concurrency is not Parallelism
- Concurrency in golang and a mini Load-balancer
- Channels in Go
- Go Concurrency Patterns
- Concurrent programming, with examples
- Slow down your code with goroutines
- How to Gracefully Close Channels
- Go channels on steroids
- Go’s Extended Concurrency: Semaphores (Part 1)
- Channel Axioms
- Go Concurrency Patterns: Pipelines and cancellation
- Using contexts to avoid leaking goroutines
- Why is a Goroutine’s stack infinite ?
- Advanced Go Concurrency Patterns
- sync.RWMutex
- Profiling Go
- Profiling and optimizing Go web applications
- pprof
- go tool trace
- pprof++: A Go Profiler with Hardware Performance Monitoring
-
Networking with Go
-
-
System Design
-
Guides
- Principles of chaos engineering
- A Brief History of High Availability
- Timeouts, retries, and backoff with jitter
- Metcalfe's law
- What is Kappa Architecture?
- Microservices — architecture nihilism in minimalism's clothes
- Failing over without falling over
- Why are services slow sometimes?
- If at first you don't get an answer...
- Understanding Connections & Pools
- The Big Little Guide to Message Queues
- MonolithFirst
- Exponential Backoff And Jitter
- What we talk about when we talk about System Design
- Real Time Presence Platform System Design
-
Netflix
- Mastering Chaos - A Netflix Guide to Microservices
- AWS re:Invent 2015: A Day in the Life of a Netflix Engineer (DVO203)
- How we scaled nginx and saved the world 54 years every day
- Building fast.com
- AWS re:Invent 2017: How Netflix Tunes Amazon EC2 Instances for Performance (CMP325)
- Edge Authentication and Token-Agnostic Identity Propagation
- Building fast.com
- Edge Authentication and Token-Agnostic Identity Propagation
- Building fast.com
- Edge Authentication and Token-Agnostic Identity Propagation
- Building fast.com
- Edge Authentication and Token-Agnostic Identity Propagation
- Building fast.com
- Edge Authentication and Token-Agnostic Identity Propagation
- Building fast.com
- Edge Authentication and Token-Agnostic Identity Propagation
- Building fast.com
- Edge Authentication and Token-Agnostic Identity Propagation
- Building fast.com
- Edge Authentication and Token-Agnostic Identity Propagation
- Building fast.com
- Edge Authentication and Token-Agnostic Identity Propagation
- Building fast.com
- Edge Authentication and Token-Agnostic Identity Propagation
- Building fast.com
- Edge Authentication and Token-Agnostic Identity Propagation
- Building fast.com
- Edge Authentication and Token-Agnostic Identity Propagation
- Edge Authentication and Token-Agnostic Identity Propagation
- Building fast.com
- Building fast.com
- Building fast.com
- Building fast.com
- Building fast.com
- Building fast.com
- Building fast.com
- Building fast.com
- Building fast.com
- Building fast.com
- Building fast.com
- Building fast.com
- Building fast.com
-
Scalability
-
Systems
- Billions of Messages a Day - Yelp's Real-time Data Pipeline
- Uber: Why Uber Engineering Switched from Postgres to MySQL
- Intelligent DNS based load balancing at Dropbox
- Airbnb: Avoiding Double Payments in a Distributed Payments System
- (A few) Ops Lessons We All Learn The Hard Way
- How Discord Stores Trillions Of Messages
- Dropbox: How we migrated Dropbox from Nginx to Envoy
- Part 1 - Prefetching data
- Part 2 - Pushing data directly to the client rather than waiting for the client to request the data
- Part 3 - Cache-first rendering
- Part 4 - Code size and execution optimizations
- The WhatsApp Architecture Facebook Bought For $19 Billion
- How We Developed DingTalk: Implementing the Message System Architecture
- Redis Explained
- Part 2 - Pushing data directly to the client rather than waiting for the client to request the data
- Part 3 - Cache-first rendering
- Part 4 - Code size and execution optimizations
- Part 2 - Pushing data directly to the client rather than waiting for the client to request the data
- Part 3 - Cache-first rendering
- Part 4 - Code size and execution optimizations
- Part 2 - Pushing data directly to the client rather than waiting for the client to request the data
- Part 3 - Cache-first rendering
- Part 4 - Code size and execution optimizations
- Part 2 - Pushing data directly to the client rather than waiting for the client to request the data
- Part 3 - Cache-first rendering
- Part 4 - Code size and execution optimizations
- Part 2 - Pushing data directly to the client rather than waiting for the client to request the data
- Part 3 - Cache-first rendering
- Part 4 - Code size and execution optimizations
- Part 2 - Pushing data directly to the client rather than waiting for the client to request the data
- Part 3 - Cache-first rendering
- Part 4 - Code size and execution optimizations
- Part 2 - Pushing data directly to the client rather than waiting for the client to request the data
- Part 3 - Cache-first rendering
- Part 4 - Code size and execution optimizations
- Part 2 - Pushing data directly to the client rather than waiting for the client to request the data
- Part 3 - Cache-first rendering
- Part 4 - Code size and execution optimizations
- Part 2 - Pushing data directly to the client rather than waiting for the client to request the data
- Part 3 - Cache-first rendering
- Part 4 - Code size and execution optimizations
- Part 2 - Pushing data directly to the client rather than waiting for the client to request the data
- Part 3 - Cache-first rendering
- Part 4 - Code size and execution optimizations
- Part 2 - Pushing data directly to the client rather than waiting for the client to request the data
- Part 3 - Cache-first rendering
- Part 4 - Code size and execution optimizations
- Part 2 - Pushing data directly to the client rather than waiting for the client to request the data
- Part 3 - Cache-first rendering
- Part 4 - Code size and execution optimizations
- Part 2 - Pushing data directly to the client rather than waiting for the client to request the data
- Part 3 - Cache-first rendering
- Part 4 - Code size and execution optimizations
- Part 2 - Pushing data directly to the client rather than waiting for the client to request the data
- Part 3 - Cache-first rendering
- Part 4 - Code size and execution optimizations
- Part 2 - Pushing data directly to the client rather than waiting for the client to request the data
- Part 3 - Cache-first rendering
- Part 4 - Code size and execution optimizations
- Part 2 - Pushing data directly to the client rather than waiting for the client to request the data
- Part 3 - Cache-first rendering
- Part 4 - Code size and execution optimizations
- Part 2 - Pushing data directly to the client rather than waiting for the client to request the data
- Part 3 - Cache-first rendering
- Part 4 - Code size and execution optimizations
- Part 2 - Pushing data directly to the client rather than waiting for the client to request the data
- Part 3 - Cache-first rendering
- Part 4 - Code size and execution optimizations
- Part 2 - Pushing data directly to the client rather than waiting for the client to request the data
- Part 3 - Cache-first rendering
- Part 4 - Code size and execution optimizations
- Part 2 - Pushing data directly to the client rather than waiting for the client to request the data
- Part 3 - Cache-first rendering
- Part 4 - Code size and execution optimizations
- Part 2 - Pushing data directly to the client rather than waiting for the client to request the data
- Part 3 - Cache-first rendering
- Part 4 - Code size and execution optimizations
- Part 2 - Pushing data directly to the client rather than waiting for the client to request the data
- Part 3 - Cache-first rendering
- Part 4 - Code size and execution optimizations
- Part 2 - Pushing data directly to the client rather than waiting for the client to request the data
- Part 3 - Cache-first rendering
- Part 4 - Code size and execution optimizations
- Part 2 - Pushing data directly to the client rather than waiting for the client to request the data
- Part 3 - Cache-first rendering
- Part 4 - Code size and execution optimizations
-
AWS
- The Hitchhiker's Guide to AWS ECS and Docker
- Everything You Need To Know About Networking On AWS
- Deep Dive on Amazon ECS Cluster Auto Scaling
- Designing scalable API on AWS spot instances
- AWS IAM Policies in a Nutshell
- What You Need to Know About IOPS
- Why was a query to my Amazon RDS MySQL DB instance blocked when there is no other active session?
- Things you wish you didn't need to know about S3
-
Event driven Architecture
-
Cloudflare
-
-
More Books
-
Random
- The Phoenix Project: A Novel about IT, DevOps, and Helping Your Business Win
- What is the single most influential book every programmer should read? [closed
- Ask HN: What language-agnostic programming books should I read ?
- A handbook for making programming languages
- An Illustrated Book of Bad Arguments
- An illustrated introduction to computational thinking
- A Reading List For the Self-Taught Computer Scientist
- A handbook for making programming languages
-
Software Development
-
-
Linux
-
Git Internals
- Basic Linux Privilege Escalation
- Myths Programmers Believe about CPU Caches
- Killing processes that don't want to die
- The 101 of ELF files on Linux: Understanding and Analysis
- UNIX Syscalls
- htop explained
- Linux Insides
- chmod Tutorial
- Orphan vs Zombie vs Daemon Processes
- inetd Vs xinetd in linux
- rm -rf remains
- What happens when you start a process on Linux?
- How does the system shutdown of a linux kernel work internally?
- The Definitive Guide to Linux System Calls
- grep your way to freedom
- Linux file descriptors
- How statically linked programs run on Linux
- File Types in Linux
- Threads and fork(): think twice before mixing them
- Loading and ptrace'ing a process on Linux
- Understanding glibc malloc
- Systemd as tragedy
- Rethinking PID 1
- What is Overcommit? And why is it bad?
- Your terminal is not a terminal: An Introduction to Streams
- How fast are Unix domain sockets?
- Linux namespaces
- Why should text files end with a newline?
- What has to happen with Unix virtual memory when you have no swap space
- The Linux Scheduler: a Decade of Wasted Cores
- Linux Log Files that are Located under /var/log Directory
- “zero copy networking” vs “kernel bypass”?
- Understanding cgroups
- The brokenness of the sendfile() system call
- Systemd is not Magic Security Dust
- Pushing the Limits of Kernel Networking
- eBPF
- Process resource limits under the hood
- Queueing in the Linux Network Stack
- inetd Vs xinetd in linux
- inetd Vs xinetd in linux
- inetd Vs xinetd in linux
- inetd Vs xinetd in linux
- inetd Vs xinetd in linux
- inetd Vs xinetd in linux
- inetd Vs xinetd in linux
- inetd Vs xinetd in linux
- inetd Vs xinetd in linux
- inetd Vs xinetd in linux
- The real power of Linux executables
- inetd Vs xinetd in linux
- inetd Vs xinetd in linux
- inetd Vs xinetd in linux
- inetd Vs xinetd in linux
- inetd Vs xinetd in linux
- inetd Vs xinetd in linux
- inetd Vs xinetd in linux
- inetd Vs xinetd in linux
- inetd Vs xinetd in linux
- inetd Vs xinetd in linux
- inetd Vs xinetd in linux
- inetd Vs xinetd in linux
- inetd Vs xinetd in linux
- inetd Vs xinetd in linux
-
Linux Security
- Dirty Cow
- Explaining Dirty COW local root exploit - CVE-2016-5195
- Linux Firewall Tutorial: IPTables Tables, Chains, Rules Fundamentals
- Security Tips for Linux Servers
- Three kinds of memory leaks
- Running Untrusted Programs in Linux
- Do sudo and .profile/.bashrc enable trivial privilege escalation?
- How to break out of a chroot() jail
-
Bash
-
SSH
-
BPF
-
-
Git
-
Networking Books :books:
- Git Hooks
- Pro Git
- Making Commit in past
- What’s Wrong With Git? - Git Merge 2017
- Git Aliases of the Gods!
- High-level Problems with Git and How to Fix Them
- Rebase with history -- implementation ideas
- How bad can it git? Characterizing secret leakage in public GitHub repositories
- git add --patch and --interactive
- Commits are snapshots, not diffs
- The Thing About Git
-
Git Internals
-
-
Distributed Systems
-
Tor Papers
- In Search of an Understandable Consensus Algorithm
- Raft: Understandable Distributed Consensus
- Please stop calling databases CP or AP
- Fallacies of distributed computing
- Distributed Systems for fun and profit
- CAP Theorem: Revisited
- CAP Theorem
- You Can’t Sacrifice Partition Tolerance
- The network is reliable
- Designing Distributed Systems: Patterns and Paradigms for Scalable, Reliable Services
- Consistency Models
- Introduction to Distributed System Design
- HTTP is obsolete. It's time for the Distributed Web
- Rack Model
- If you need a global lock in your distributed system, then you're already in trouble
- Is Redlock Safe? Reply to Redlock Analysis
- Towards Robust Distributed Systems
- How to beat the CAP theorem
- FLP and CAP aren't the same thing
- An Illustrated Proof of the CAP Theorem
- Distributed systems theory for the distributed systems engineer
- Consensus Protocols: Two-Phase Commit
- Consensus Protocols: Three-phase Commit
- Consensus Protocols: Paxos
- Notes on Paxos
- Keeping CALM: When Distributed Consistency Is Easy
- Brewer’s Conjecture and the Feasibility of Consistent, Available, Partition-Tolerant Web Services
- Thinking about Availability in Large Service Infrastructures
- Questioning the Lambda Architecture
- Avoiding fallback in distributed systems
- Managing Critical State: Distributed Consensus for Reliability
- Is Raft more modular than MultiPaxos?
- Paxos, Raft, EPaxos: How Has Distributed Consensus Technology Evolved?
- Hinted Handoff
- Gossip Protocol - Broadcast Algorithm Distributed Systems
- Consistent Hashing Explained
- The Design Patterns for Distributed Systems Handbook
-
-
Useful Command Line Tools
- Pass: Simple password manager using gpg and ordinary unix directories
- fd: A simple, fast and user-friendly alternative to find
- sshuttle - Transparent proxy server that works as a poor man's VPN.
- peerflix
- tldr
- jq
- mkcert
- curl statistics made simple
- kaf: Modern CLI for Apache Kafka
- SCM breeze: Adds numbered shortcuts to the output git status, and much more
- Rofi: A window switcher, application launcher and dmenu replacement
-
Rust
-
Internet
-
Random
- High Performance Browser Networking
- Network Protocols – Programmer's Compendium
- How Does the Internet Work?
- The Law of Leaky Abstractions
- HAProxy
- How to win at CORS
- The future of the open internet
- How Wi-Fi Works
- How to crawl a quarter billion webpages in 40 hours
- The world in which IPv6 was a good design
- The Non-complexity of /etc/nsswitch.conf
- What is Envoy
- Kerberos: The Network Authentication Protocol
- curl HTTP cheat sheet
- cURL security anti-patterns
- Staying out of TTL hell
- Stateful vs Stateless Authentication
- The perils of the “real” client IP
-
Protocols
- HTTP Security Headers - A Complete Guide
- How WebSockets Work
- Websockets 101
- How HTTPS works ...in a comic!
- A cartoon intro to DNS over HTTPS
- Employing QUIC Protocol to Optimize Uber’s App Performance
- Let's code a TCP/IP stack
- What Is BGP? | BGP Routing Explained
- HTTP/3 explained
- HTTP
- Capturing HTTP Packets
- HTTPS in the real world
- How does HTTPS actually work?
- Designing Headers for HTTP Compression
- The First Few Milliseconds of an HTTPS Connection
- The HTTP part 1 - Let's start small
- How HTTPS Works in Layman's Terms - TLS 1.2 and 1.3
- HTTP Caching
- The Evolution of HTTP – HTTP/2 Deep Dive
- Comparing HTTP/3 vs. HTTP/2 Performance
- HTTP/3 Deep Dive
- How does SSL/TLS work?
- What is TLS (Transport Layer Security)?
- Even faster connection establishment with QUIC 0-RTT resumption
- A Detailed Look at RFC 8446 (a.k.a. TLS 1.3)
- Discussion: UDP in web
- When TCP sockets refuse to die
- Messing With Telnet
- How TCP Sockets Work
- How Does TCP Work?
- Once Again on TCP vs UDP
- Nagle's algorithm
- 40 millisecond bug
- TCP Performance problems caused by interaction between Nagle’s Algorithm and Delayed ACK
- What every developer should know about TCP
- What I learned attempting the TCP Reset attack
- DNS in One Picture
- The Web Developer's Guide to DNS
- The uncertainty of measuring the DNS
- DNS Encryption Explained
- How DNS Works
- Beyond DNS over HTTPS: Trustless DNS Privacy
- THE TWO-NAPKIN PROTOCOL
- Playing battleships over BGP
- WebSockets for fun and profit
- The WebSocket Protocol: RFC 6455
- HTTP and Websockets: Understanding the capabilities of today’s web communication technologies
- WebSockets - A Conceptual Deep Dive
- How HTML5 Web Sockets Interact With Proxy Servers
- How Do Websockets Work?
- What are Long-Polling, Websockets, Server-Sent Events (SSE) and Comet?
- Building realtime apps with Go and WebSockets: client-side considerations
- WebRTC for the Curious
- Journey to HTTP/2
- HTTP3
- QUIC
- HTTP/3: the past, the present, and the future
-
Webservers
-
Advanced Data Structures
-
Web Caching
-
Load Balancing
- GLB: GitHub's open source load balancer
- What Is Load Balancing?
- Understanding Nginx HTTP Proxying, Load Balancing, Buffering, and Caching
- Introduction to modern network load balancing and proxying
- Load Balancing TLS Connections: Tradeoffs
- Introduction to modern network load balancing and proxying
- Introduction to modern network load balancing and proxying
- Introduction to modern network load balancing and proxying
- Introduction to modern network load balancing and proxying
- Introduction to modern network load balancing and proxying
- Introduction to modern network load balancing and proxying
- Introduction to modern network load balancing and proxying
- Introduction to modern network load balancing and proxying
- Introduction to modern network load balancing and proxying
- Introduction to modern network load balancing and proxying
- Introduction to modern network load balancing and proxying
- Introduction to modern network load balancing and proxying
- Introduction to modern network load balancing and proxying
- Introduction to modern network load balancing and proxying
- Introduction to modern network load balancing and proxying
- Introduction to modern network load balancing and proxying
- Introduction to modern network load balancing and proxying
- Introduction to modern network load balancing and proxying
- Introduction to modern network load balancing and proxying
- Introduction to modern network load balancing and proxying
- Introduction to modern network load balancing and proxying
- Introduction to modern network load balancing and proxying
- Introduction to modern network load balancing and proxying
- Introduction to modern network load balancing and proxying
-
NAT
-
Networking Books :books:
-
-
Security
-
Crypto
- Myths about /dev/urandom
- A Stick Figure Guide to the Advanced Encryption Standard (AES)
- How To Safely Store A Password
- So, You Want To Learn To Break Ciphers
- Alice & Bob : A History of The World’s Most Famous Cryptographic Couple
- Implementing AES
- An Intensive Introduction to Cryptography
- First SHA1 Collision
- Bcrypt Step by Step
- Bcrypt
- Why shouldn't we roll our own?
- How to securely hash passwords?
- So you want to roll your own crypto?
-
Attacks
- Mirai Botnet
- SQL Attack Constraint Based
- DNS Reconnaissance – DNSRecon
- What is a DDoS Attack?
- Server Side Request Forgery (SSRF)?
- All you need to know about SYN floods
- "kernel: Possible SYN flooding on port X. Sending cookies" is logged
- SSL Strip for Newbies
- Cold Boot Attack
- Heartbleed Bug
- Shellshock
- POODLE
- Format string attack
- Off-by-one error
- EFAIL
- HTTP Desync Attacks: Request Smuggling Reborn
- The SSL FREAK vulnerability explained
- Abusing HTTP hop-by-hop request headers
- How does a TCP reset attack work
- Cracking the lens: targeting HTTP's hidden attack-surface
- Web Cache Entanglement: Novel Pathways to Poisoning
- Reading Data via CSS Injection
- Network Ingress Filtering: Defeating Denial of Service Attacks which employ IP Source Address Spoofing
- SAD DNS Explained
- Hidden OAuth attack vectors
- HTTP request smuggling
-
Guides
- The definitive super list for "Google Hacking"
- Buffer Overflow
- What “hacking” competitions/challenges exist?
- Beware of strncpy() and strncat()
- Lessons learned and misconceptions regarding encryption and cryptology
- GOT and PLT for pwning
- A Look at The Draft for JWT Best Current Practices
- Advanced web security topics
- Don't publicly expose .git
- The State Of Software Security In 2019
- Now you C me, now you don't: An introduction to the hidden attack surface of interpreted languages
- Simple Bugs With Complex Exploits
-
Security Papers
-
Tools
-
-
Kafka
-
Tor Papers
- The Log: What every software engineer should know about real-time data's unifying abstraction
- Disaster Recovery for Multi-Region Kafka at Uber
- "Apache Kafka and the Next 700 Stream Processing Systems" by Jay Kreps
- Kafka and Zookeeper with Docker
- A Guide To The Kafka Protocol
- The Unofficial Kafka Rebalance How-To
- High Performance Kafka Producers
- \_\_consumer_offsets topic in kafka
- Vertically scaling Kafka consumers
- Apache Kafka Rebalance Protocol, or the magic behind your streams applications
- Apache Kafka Supports 200K Partitions Per Cluster
- It’s Okay To Store Data In Apache Kafka
- A Practical Introduction to Kafka Storage Internals
- KIP-500: Replace ZooKeeper with a Self-Managed Metadata Quorum
- Understanding Kafka with Factorio
- Kora - Serverless Kafka
- Squeezing the firehose: getting the most from Kafka compression
-
-
Database
-
MySQL
- Read Consistency with Database Replicas
- SQL vs NoSQL
- One Giant Leap For SQL: MySQL 8.0 Released
- MongoDB is to NoSQL like MySQL to SQL — in the most harmful way
- Building Robust Systems with ACID and Constraints
- Database Internals
- Things I Wished More Developers Knew About Databases
- Maximizing MongoDB Performance on AWS
- Inconsistent thoughts on database consistency
- UUIDs are Popular, but Bad for Performance
- Mysql 8.0: UUID support
- Practical Problems with Auto-Increment
- Why UUID7 is better than UUID4 as clustered index in RDBMS
- Why UUID7 is better than UUID4 as clustered index in RDBMS
- Why UUID7 is better than UUID4 as clustered index in RDBMS
- Why UUID7 is better than UUID4 as clustered index in RDBMS
- Why UUID7 is better than UUID4 as clustered index in RDBMS
- Why UUID7 is better than UUID4 as clustered index in RDBMS
- Why UUID7 is better than UUID4 as clustered index in RDBMS
- Why UUID7 is better than UUID4 as clustered index in RDBMS
- Why UUID7 is better than UUID4 as clustered index in RDBMS
- Why UUID7 is better than UUID4 as clustered index in RDBMS
- Why UUID7 is better than UUID4 as clustered index in RDBMS
- Why UUID7 is better than UUID4 as clustered index in RDBMS
- Why UUID7 is better than UUID4 as clustered index in RDBMS
- Why UUID7 is better than UUID4 as clustered index in RDBMS
- Why UUID7 is better than UUID4 as clustered index in RDBMS
-
PostgreSQL
- Herding elephants: Lessons learned from sharding Postgres at Notion
- Secure PostgreSQL
- How Postgres Makes Transactions Atomic
- PostgreSQL LISTEN/NOTIFY
- Zero downtime Postgres upgrades
- Postgres TOAST: The Greatest Thing Since Sliced Bread?
- PostgreSQL reconsiders its process-based model
- How to Manage Connections Efficiently in Postgres, or Any Database
- Optimizing Database Design: PostgreSQL Data Type Selection Best Practices and More
- An Overview of Distributed PostgreSQL Architectures
- Geographically distributed Postgres for multi-tenant applications
-
Sharding
-
ClickHouse
-
-
Spark
-
Rails
-
Regex
-
Tor Papers
-
-
Haskell
-
Fun
-
Privacy
-
C
-
Blogs
-
Data Structures and Algorithms
-
Algorithms
- Introduction to Algorithms
- Complexity of Python Operations
- Heap Algorithm
- Linked lists are still hard
- Understanding Dijkstra's Algorithm
- How to think in graphs
- Ask HN: What's your favorite elegant/beautiful algorithm?
- Algorithms Behind Modern Storage Systems
- The Knuth-Morris-Pratt Algorithm in my own words
- Why is processing a sorted array faster than processing an unsorted array?
- 10 Optimizations on Linear Search
- Understanding Dijkstra's Algorithm
-
Data Structures
-
Advanced Data Structures
-
-
OS dev
-
Ruby
-
Tor
-
ClickHouse
-
Tor Papers
-
-
OAuth
-
Monitoring
-
Prometheus
-
More
- Telltale: Netflix Application Monitoring Simplified
- Understanding the Top 5 Redis Performance Metrics
- Telltale: Netflix Application Monitoring Simplified
- Telltale: Netflix Application Monitoring Simplified
- Telltale: Netflix Application Monitoring Simplified
- Telltale: Netflix Application Monitoring Simplified
- Telltale: Netflix Application Monitoring Simplified
- Telltale: Netflix Application Monitoring Simplified
- Telltale: Netflix Application Monitoring Simplified
- Telltale: Netflix Application Monitoring Simplified
- Telltale: Netflix Application Monitoring Simplified
- Telltale: Netflix Application Monitoring Simplified
- Telltale: Netflix Application Monitoring Simplified
- Telltale: Netflix Application Monitoring Simplified
- Telltale: Netflix Application Monitoring Simplified
- Telltale: Netflix Application Monitoring Simplified
- Telltale: Netflix Application Monitoring Simplified
- Telltale: Netflix Application Monitoring Simplified
- Telltale: Netflix Application Monitoring Simplified
- Telltale: Netflix Application Monitoring Simplified
- Telltale: Netflix Application Monitoring Simplified
- Telltale: Netflix Application Monitoring Simplified
- Telltale: Netflix Application Monitoring Simplified
- Telltale: Netflix Application Monitoring Simplified
- Telltale: Netflix Application Monitoring Simplified
- Telltale: Netflix Application Monitoring Simplified
-
-
x vs y :hocho:
-
Papers
-
Random
- How Professional Hackers Understand Protected Code while Performing Attack Tasks
- Papers We Love
- Communicating Sequential Processes
- Reflections on Trusting Trust
- Hints on programming language design
- The Fault Tolerance of Botnets
- Paradigm Shift in Software Development
- Cloak of Visibility
- The Impact of Thread-Per-Core Architecture on Application Tail Latency
- Zanzibar: Google’s Consistent, Global Authorization System
- Hints on programming language design
- The Fault Tolerance of Botnets
- Paradigm Shift in Software Development
-
-
Reading Material
Programming Languages
Categories
System Design
160
Internet
115
JS
89
Go
85
More
84
Linux
83
Security
60
Database
46
Distributed Systems
37
Monitoring
33
Git
20
Data Structures and Algorithms
19
Kafka
17
Containers
14
More Books
13
Papers
13
Useful Command Line Tools
11
Tor
10
C
8
Functional Programming
8
Rust
7
OS dev
6
Fun
5
x vs y :hocho:
5
Courses
4
Privacy
4
Haskell
4
Rails
4
Spark
3
Ruby
2
Reading Material
2
OAuth
2
Regex
2
Blogs
1
Sub Categories
Systems
86
Security Papers
76
Advanced Concepts
76
Tor Papers
73
Git Internals
73
Protocols
57
More
54
Random
43
Netflix
42
Go Internals
30
Load Balancing
29
Guides
27
MySQL
27
Attacks
26
Concepts
22
Books
20
Networking Books :books:
13
Crypto
13
Algorithms
12
ClickHouse
11
PostgreSQL
11
Linux Security
8
JS Books
8
AWS
8
Scalability
7
Advanced Data Structures
7
Prometheus
7
BPF
6
Docker
6
Bash
6
Pilot Run
6
Cloudflare
5
Software Development
5
Go Pilot run
5
Webservers
5
Networking with Go
4
Kubernetes :construction:
4
Tools
4
Sharding
3
React, Redux
3
SSH
3
v8
3
Web Caching
2
NAT
1
Data Structures
1
Event driven Architecture
1
Keywords
linux
3
macos
2
cli
2
command-line
2
windows
2
terminal
2
courses
1
filesystem
1
regex
1
rust
1
search
1
tool
1
android
1
bsd
1
cheatsheet
1
cheatsheets
1
console
1
documentation
1
examples
1
help
1
aws
1
azure
1
books
1
cloud-providers
1
deploy-kubernetes
1
docker
1
enterprise-kubernetes-products
1
google-cloud
1
google-kubernetes
1
kubernetes
1
kubernetes-cluster
1
kubernetes-sources
1
machine-learning
1
meetup
1
minikube
1
monitoring-kubernetes
1
resource
1
schedule
1
awesome
1
awesome-list
1
computer-science
1
html
1
html5
1
list
1
meta-tags
1
reference
1
seo
1
twitter-cards
1
web-development
1
curl
1