Skip to content
Velloreth

#performance

Posts tagged with “performance”.

28 posts

01

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.

02

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.

03

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.

04

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.

05

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.

06

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.

07

CSS Animations: A Practical Introduction

CSS animations run without JavaScript and perform well when you animate the right properties. Learn keyframes, timing, and accessibility.

08

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.

09

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.

10

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.

11

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.

12

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.

13

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.

14

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.

15

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.

16

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.

17

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.

18

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.

19

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.

20

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.

21

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.

22

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.

23

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.

24

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.

25

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.

26

How CDNs Actually Work

Anycast, BGP, cache hierarchies, and cache keys — the actual machinery behind content delivery networks, explained without the marketing layer.

27

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.

28

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.