#performance
Posts tagged with “performance”.
28 posts
Big-O Notation Explained With Real Code Examples
Big-O notation describes how an algorithm's cost grows as input grows. Learn the common classes, how to read them, and the mistakes beginners make.
Caching Strategies: Cache-Aside, Write-Through and TTL
A cache trades freshness for speed. Learn the strategies, the invalidation problem, and the patterns that avoid a stampede.
Code Splitting: Shipping Less JavaScript
Split a bundle so a page loads only the code it needs. Learn the route split, the dynamic import, and how to measure the result.
Connection Pooling Explained for Developers
Opening a connection is expensive, so a pool reuses them. Learn the sizing, the exhaustion, the timeout, and the serverless trap.
Core Web Vitals: LCP, INP and CLS Explained
LCP, INP and CLS measure loading, interactivity and visual stability. Learn the thresholds, the causes, and how to improve each one.
Critical CSS Explained: Faster First Paint
Inlining the above-the-fold CSS removes a render-blocking request. Learn how to extract it, inline it, and load the rest asynchronously.
CSS Animations: A Practical Introduction
CSS animations run without JavaScript and perform well when you animate the right properties. Learn keyframes, timing, and accessibility.
CSS Transforms: Translate, Rotate, Scale and Skew
CSS transforms move, rotate, scale and skew elements without affecting layout. Learn the functions, the origin, 3D, and performance.
Data Structures Every Developer Should Know
A practical tour of the data structures you actually use: arrays, hash maps, sets, stacks, queues, trees, heaps and graphs, with real trade-offs.
Database Indexes Explained: B-Tree, Composite and Covering
An index trades write speed and space for read speed. Learn the B-tree, the composite index, the covering index and the query plan.
Database Indexing Explained With Examples
An index trades write speed and space for read speed. Learn how a B-tree works, when an index is used, and the common mistakes.
Edge Functions: Running Code Close to the User
Edge functions run in many locations near the user. Learn the model, the limits, the cold start and when a serverless function is better.
Event Delegation Explained: One Listener for Many Elements
Attach one listener to a parent instead of hundreds to children. Learn the bubbling, the target, and the pitfalls to avoid.
Handling Large Files in Git: LFS and Alternatives
Git is bad at large binaries. Learn why, how Git LFS works, and how to clean a repository that already has them.
Hash Tables Explained: How O(1) Lookup Really Works
Hash tables turn keys into array indexes with a hash function. Learn how they work, how collisions are handled, and why lookups are O(1) on average.
HTTP Caching Headers: Cache-Control Explained
Cache-Control, ETag and Vary decide what a browser and a CDN cache. Learn the directives, the revalidation, and the common mistakes.
JavaScript Bundlers Explained: What They Actually Do
A bundler resolves imports, transforms code and writes a file the browser can load. Learn the graph, the loaders, and the output.
JavaScript Performance: Practical Optimisation Tips
Most JavaScript is fast enough. Learn where the real bottlenecks are, how to measure, and the optimisations that actually matter.
Lazy Loading Images: Faster Pages With One Attribute
loading=lazy defers an offscreen image. Learn the attribute, the LCP trap, the placeholder, and the sizes attribute.
Load Testing Basics: Finding Your Limits
A load test finds the point where a system degrades. Learn the metrics, the test types, and how to run one without breaking production.
Mobile-First CSS: Why and How to Write It
Mobile-first means the base styles target small screens and larger screens add complexity. Learn the approach, the benefits, and the pitfalls.
The N+1 Query Problem: Finding and Fixing It
One query becomes N+1. Learn how it happens, how to detect it, and the eager loading, batching and join fixes.
Sorting Algorithms Compared: Which One and Why
Compare bubble, insertion, merge, quick, heap and counting sort on time, space and stability, and learn which one your language actually uses.
Time vs Space Complexity: The Trade-Off Explained
Almost every performance decision trades time for memory. Learn how to reason about the trade-off, when each side wins, and how to measure it.
Server-Side Rendering vs Static: Choosing Wisely
Static generation and SSR compared on cost, caching, freshness, failure modes, and personalization — plus a decision framework and migration path.
How CDNs Actually Work
Anycast, BGP, cache hierarchies, and cache keys — the actual machinery behind content delivery networks, explained without the marketing layer.
Why Your Tests Are Slow (And How to Fix Them)
A practical guide to diagnosing slow test suites: startup costs, database fixtures, sleeps, e2e scope, parallelism, and the budgets that keep suites fast.
Edge Computing: Where It Helps and Where It Doesn't
Edge computing moves code closer to users. It wins for latency-sensitive request paths and loses for heavy compute, state, and anything needing a region.