- The cost of async I/O, false assumptions and pride
- Microservices fault and latency tolerance using Netflix Hystrix
- The Image Optimization Technology that Serves Millions of Requests Per Day
- Google still loves disks, should you?
- Fundamentals of Apache Kafka
- Troubleshoot OutOfMemoryError: Unable to Create New Native Thread
- The Heard-Of Model: Computing in Distributed Systems with Benign Failures
- New Compilers Streamline Optimization and Enhance Code Conversion
- 10 Stack Benchmarking DOs and DON’Ts
- A Scalable System for Ingestion and Delivery of Timed Text
- Fastest code is the one not run: Part I – The cost of escaping strings
- Instructors’ Guide to Raft
- I/O matters.
- The design of RavenDB 4.0: You can’t see the map/reduce from all the trees
- Fastest code is the one not run: Part II – Memory management
- Eager Optimization Is The Enemy
- Google’s Transition from Single Datacenter, to Failover, to a Native Multihomed Architecture
- Performance and Scaling in Enterprise Systems
- Garbage Collection Logging: Which Time Matters to the Customer?
- Web Page Performance Death by a Thousand Tiny Cuts
- Production postmorterm: Houston, we have a problem
- A Journey Through How Zapier Automates Billions of Workflow Automation Tasks
- JLBH Examples 2 – Accounting for Coordinated Omission
- Performance Tuning Ideas for Apache Camel
- Java Caching Benchmarks 2016 – Part 1
- Swift Compilation Reporting at Tumblr
- Efficient binary serialization
- Performance & Usage at Instagram
- Locking in WebKit
- Performance Culture
- Fun async tricks for getting better performance
- Scaling NSQ to 750 Billion Messages
- Tools of the Trade for Performance and Load Testing
- How to Make C++ Code Run 90x Faster
- PostgreSQL Scalability: Towards Millions TPS
- A tale of troubleshooting database performance, with Cassandra and sysdig
- JLBH Examples 1 – Why Code Should be Benchmarked in Context
- Displaying Linux Memory
- Building nginx and Tarantool based services
- Is Your Computer Stable?
- Application data caching using SSDs
- High Performance Erlang – Finding Bottlenecks in a CouchDB Cluster #1
- Saving 13 Million Computational Minutes per Day with Flame Graphs
- TIL: clock skew exists
- What does Etsy’s architecture look like today?
- Understanding caching in Postgres – An in-depth guide
- Trie based routing
- Stack Overflow: The Architecture – 2016 Edition
- Egnyte Architecture: Lessons Learned in Building and Scaling a Multi Petabyte Distributed System
- The design of RavenDB 4.0: Replication from server side
- How does perf work? (in which we read the Linux kernel source)
- Logging yourself to death
- What’s the Difference Between BLOCKED, WAITING, And TIMED_WAITING?
- tcpdump is amazing
- Improving Kubernetes Scheduler Performance
- Introduction to Apache Kafka: Distributed Systems, Scalable Architecture, and Messaging Queues
- Mozilla Pushes the Web to New Levels as a Platform for Games
- Scaling to exabytes and beyond
- Creating a Heavy-Duty Balancer With Nginx and Lua
- Detecting Java Race Conditions With Tests, Part 1: Lost Updates
- Profiling in Erlang
- Distributed Consistency and Session Anomalies
- A Patreon Architecture Short
- How do you do capacity planning?
- Coupling in distributed systems
- System loads Web pages 34 percent faster by fetching files more effectively
- Pitfalls of the MyBatis Caches with Apache Ignite
- How Complex Systems Fail
- Solving Intractable Performance Problems Through Vertical Engineering
- An assignment framework for optimizing distributed systems operations on social networks
- The cost of routing in NancyFX
- Message Durability in ActiveMQ 5.x
- Optimal compression rate
- To Compress or Not to Compress, that was Uber’s Question
- Building an anycast network for our CDN
- jcmd: One JDK Command-Line Tool to Rule Them All
- Making asm.js/WebAssembly compilation more parallel in Firefox
- Python vs Copy on Write
- CDNs aren’t just for caching
- I conquered thread pools! For today, at least.
- Small intro to threads, race conditions and locking
- Malice or Stupidity or Inattention? Using Code Reviews to Find Backdoors
- From Node.js to Go
- Interpreting jstat’s Garbage Collection Events
- Understanding Consensus and Paxos in Distributed Systems
- JVM JIT optimization techniques
- The cost of routing
- How to Get Started With JMeter: Part 2 – Building Scripts and Running JMeter
- So You Wanna Go Fast?
- Performance Engineering with React (Part 1)
- Performance Tuning Apache Storm at Keen IO
- Go and Quasar: A Comparison of Style and Performance
- HTTP/HTTPS not working inside your VM? Wait for it.
- Using ltrace to debug a memory leak
- HotSpot Incremental Java Garbage Collector
- Debugging an API Performance Problem From the Real World
- Benchmarking Message Queue Latency
- Cache digests for HTTP/2 Push: lossy compression saves the day again
- Facebook’s new front-end server design delivers on performance without sucking up power
- Starving JMS Consumers in ActiveMQ
- The importance of a data format: Part VII – Final benchmarks
- Apache Spark as a Compiler: Joining a Billion Rows on your Laptop: A deep dive into the Tungsten Engine
- Understanding the Java Garbage Collection Log
- Prepare your distributed system, so you don’t lose money, when it fails
- Optimizing Distributed Actor Systems for Dynamic Interactive Services
- Checking HashMaps with MapClashInspector
- Instruction-level Multithreading to improve processor utilization
- A Beginner’s Guide to Addressing Concurrency Issues
- Load balancing or balancing on the edge of a cliff?
- Benchmarking Fleet Clusters With Rkt And Docker
- Measuring baseline costs
- The deadlock in the fairness assumption
- A workshop on strace & tcpdump
- Fast incremental sort
- Performance of green threads and why it matters
- The Go binary diet
- Autoscaling on Complex Telemetry
- Distributed Dask Arrays
- How We Monitor and Run Kafka At Scale
- When code is suspiciously fast: adventures in dead code elimination
- External API Caching with Varnish & Nginx
- The design of RavenDB 4.0: The implications of the blittable format
- I hate web bloat.
- Design of a Modern Cache
- How to run database integration tests 20 times faster
- How do low latency applications differ for regular applications?
- Structured Concurrency
- How we get high availability with Elasticsearch and Ruby on Rails
- Dive into React Native performance
- Preload: What Is It Good For?
- FairRide: Near-Optimal, Fair Cache Sharing
- Redis vs. Hazelcast – Radargun Puts Them to a Challenge
- Thread pools! How do I use them?
- Is reference counting slower than GC?
- A Short Note on Atomicity and Ordering
- Building a Translation Memory to Improve Machine Translation Coverage and Quality
- 9 Lessons Learned Scaling Hotjar’s Tech Architecture To Handle 21,875,000 Requests Per Hour
- How to avoid wasting megabytes of memory a few bytes at a time
- Profiling mysteries
- How Twitter Handles 3,000 Images Per Second
- Introducing Runway, a distributed systems design tool
- Memory Leaks and Resource Management in Swift and iOS
- How we implemented the video player in Mail.Ru Cloud
- Resilient ad serving at Twitter-scale
- The Platform Advantage of Amazon, Facebook, and Google
- How to derive business value from performance monitoring?
- Making GitLab Faster
- Fixing the Internet for Real Time Applications: Part II
- Writing a very fast cache service with millions of entries in Go
- Managing Mobile Performance Optimization
- Performance Tuning Ideas for Apache Camel
Created
December 14, 2016 06:35
-
-
Save peanutpi/c55a06bac638f4e3fe3470b19b0c6ef1 to your computer and use it in GitHub Desktop.
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment