Browse
Every topic, by subject. Each one comes as a quick overview, a full video, a podcast or slides.
Why polished web apps fail disabled users, and how a five-way audit (keyboard, screen reader, 400% zoom, voice and mobile) finds what automated linters miss.
Who accessibility is for: the social model of disability, how screen readers, magnifiers, switches and voice control work, and how browsers build the accessibility tree.
Page structure assistive tech can navigate: landmarks, heading outlines, reading order that matches the screen, accessible names, skip links and visible focus rings.
Designing for low vision and cognition: contrast and forced colours, 400% zoom and text spacing, plain language, reduced motion and timeouts that wait for people.
Forms everyone can finish: persistent labels and fieldsets, calm error summaries instead of disabled buttons, native controls, autofill and passkeys for accessible sign-in.
Interfaces that change without leaving people behind: announcing route changes, polite live regions instead of toasts, native dialogs with inert, and touch and gesture alternatives.
Accessible content and media: writing alt text with the WAI decision tree, data tables that survive mobile layouts, captions, transcripts and audio description.
Why a perfect Lighthouse score can hide an unusable app: what automated scanners catch, a 15-minute manual check, screen-reader pairings and paid research with disabled users.
Keeping a product accessible after launch: accessibility in design tokens and handoff, clear ownership, judging vendor VPATs, avoiding overlays and adding CI gates.
A React lab: replacing clickable divs with real buttons, useId for stable ARIA links, Slot and asChild, headless primitives like Radix and React Aria, and role-based tests.
A focus management lab: roving tabindex toolbars, 2D grids, dialog and popover focus, where focus goes when an item is deleted, and scroll-margin under sticky headers.
A charts lab: making canvas and SVG charts accessible with the Chartability checks, patterns as well as colour, keyboard point navigation, sonification and synced data tables.
A native mobile lab: SwiftUI and Jetpack Compose semantics, merging cards into one screen-reader stop, custom actions for gestures, and layouts that hold up at the largest text sizes.
Why minimalist interfaces exhaust real users, and how to tell predictive models like Fitts's law and GOMS from psychological tendencies and rules of thumb, across Norman's two gulfs.
How people choose: cognitive load, what Hick's law really predicts, the choice-overload and three-click myths, information scent, sensible defaults and progressive disclosure.
How people act: Fitts's law and the steering law, target sizes and thumb zones, keyboard and gesture alternatives, and undo instead of warnings to catch slips.
How people perceive: Gestalt grouping by proximity, similarity and common region, Prägnanz, a strict salience budget for the von Restorff effect, and how beauty hides usability flaws.
How people understand and remember: Jakob's law and mental models, why the magic number seven is a myth, recognition over recall, and helping people resume unfinished tasks.
How people experience time: the 0.1, 1 and 10 second limits, the Doherty threshold, INP and layout shift, skeletons, spinners and progress bars, and optimistic UI that stays honest.
How people experience progress: the goal-gradient effect, endowed progress, the peak-end rule, streaks that motivate without nagging, and fair cancellation flows free of deceptive patterns.
Applying the principles together: Tesler's law of conserved complexity, Postel's law and its limits, forgiving forms on strict back ends, and settling trade-offs with testing.
Why computers struggle to produce true randomness, where entropy comes from, and why Math.random() must never generate passwords or tokens.
Why a network can't guarantee a message arrives exactly once, and how idempotency keys and deduplication stop a retry from charging a card twice.
How recursion uses the call stack, why deep recursion crashes production servers, and when tail-call optimisation or an explicit loop is the fix.
The difference between concurrency and parallelism, and why even single-threaded async code can have race conditions.
How distributed systems agree on one truth, why naive Redis locks corrupt data in a split-brain, and how quorums and fencing tokens prevent it.
Why 0.1 + 0.2 isn't exactly 0.3, how IEEE 754 floating point packs numbers into 53 bits of precision, and why money should never be a float.
How text really works, from bytes and code points to emoji, and how Unicode quirks break string lengths, passwords and security checks.
Why invalidating a cache is so hard, from CPU caches to CDNs, and how stale data, stampedes and private-data leaks follow when you "just add a cache".
How programming languages reclaim memory: garbage collection's pauses and costs versus Rust's ownership and borrowing, and when each wins.
How zero-knowledge proofs let you prove something without revealing it, from zk-SNARKs to real deployments, and why "zero-knowledge login" is often a trap.
Turing's halting problem and Rice's theorem: why no tool or AI can ever guarantee code is bug-free, and what bounded checks can still promise.
How visitors judge a site in about 50 milliseconds, the six levers of visual polish, and how to audit a page like a designer before changing a pixel.
How scale, contrast and grouping tell the eye where to look first, why everything shouting means nothing is heard, and how to fix a page in grayscale.
Why HSL misleads your eyes, how perceptual colour (OKLCH) and real contrast checks (WCAG 2.2, APCA) work, and why tinted neutrals beat pure grey.
Building a colour scheme that holds up: the 60-30-10 rule, 50–950 colour ramps, semantic colour tokens, and the rules of a good dark mode.
How to read and choose typefaces: classifications, letter anatomy, pairing fonts with intent, and small OpenType details like tabular figures.
Type scales and comfortable text: modular and fluid font sizes, the ideal line length, leading and tracking that change with size, and balanced headings.
Spacing that creates rhythm: a 4px/8px scale, tighter space inside groups than between them, and using whitespace instead of borders and boxes.
Grids and alignment that make layouts feel intentional: keylines, asymmetric splits, aligned card rows, optical centring and when to break the grid.
Choosing and using images, icons and illustration: art direction, focal cropping, consistent aspect ratios, readable text over photos and one icon style.
Designing controls people understand: signifiers, a clear button hierarchy, links that look like links, scannable cards and calm single-column forms.
Depth, surfaces and motion: elevation levels, softer layered shadows, matching corner radii, and small animations that feel quick and purposeful.
Layouts that adapt to their space with container queries and fluid type, and accessibility that sharpens design: contrast, touch targets and focus rings.
Keeping a site consistent with a small design system: an interface inventory, three tiers of design tokens, and rules that tools and AI agents can follow.
The series in practice: a six-pass redesign of one website, starting in grayscale for most of the polish, then rendered in three distinct brand styles.
Modern data management encompasses a diverse ecosystem of specialized technologies, ranging from document-based platforms like MongoDB to high-performance analytic engines like ClickHouse.
Why transactional (OLTP) and analytical (OLAP) databases are built so differently, from row versus column storage to how each runs queries.
Warehouses, data lakes and lakehouses compared, and how open table formats like Apache Iceberg and Delta bring database features to files on S3.
Modern distributed databases and key-value stores, such as Amazon DynamoDB, Redis, ScyllaDB, MongoDB, PostgreSQL, and Neo4j, utilize diverse architecture patterns and data modeling strategies to achieve high…
Modern data architectures increasingly rely on event streaming and change data capture to synchronize and process information across distributed systems.
How vector databases store and search embeddings, how their indexes trade accuracy for speed, and when Postgres with pgvector is enough.
What goes wrong once a database is live: replication, failover, backups and concurrency, and how distributed databases fail in production.
Modern data architecture requires balancing system stability and operational simplicity against the desire for advanced technical features.
A map of the rules for data and AI products, and why a single app can fall under GDPR, ePrivacy, US state laws and the EU AI Act at once.
GDPR for product and engineering teams: lawful bases, people's data rights, and why a privacy policy on its own doesn't make processing lawful.
What counts as personal data, why hashing an email address isn't anonymisation, and how to design data stores that stay private.
The rules on cookies and trackers, why most cookie banners aren't compliant, and how to build consent that is.
The US privacy patchwork: California and other state laws, why ad pixels can count as selling data, and how to turn the rules into code.
What the EU AI Act requires: risk categories, banned practices, duties for providers and deployers, and the compliance deadlines.
Using personal data in AI features: who is controller and who is processor when you call an LLM API, the legal bases, and privacy-safe designs.
A practical pre-launch checklist for privacy and AI compliance that brings the series together for startups and product teams.
How software delivery moved from waterfall to Agile to AI-assisted work, and why each shift kept running into the same problems.
Why Agile came about, what Royce's "waterfall" paper actually warned against, and how Agile itself turned into bureaucracy.
Effective software delivery requires a balance of project cadence, workflow limits, and rigorous engineering practices, as highlighted by frameworks like Scrum, Kanban, and Extreme Programming (XP).
Modern software development practices emphasize agile methodologies that move away from traditional command-and-control models and rigid, feature-driven roadmaps in favor of empowered product teams focused on delivering…
Modern software engineering requires continuous deployment and integration, where development teams rely on automated pipelines to frequently merge, build, and test code changes with minimal manual intervention.
Modern software development increasingly relies on AI coding agents and spec-driven methodologies to streamline project creation and maintenance.
Whether Agile still fits when AI writes much of the code, what AI-assisted development changes, and why it can slow teams down.
A map of how a modern AI system fits together, from training a transformer to serving it in production, and where each lesson in the series goes deeper.
How neural networks represent meaning as embeddings, how backpropagation adjusts millions of weights, and why training needs far more memory than inference.
How attention lets a transformer relate every token to every other, why that cost grows quadratically, and the tricks, like the KV cache, that keep it fast.
What scaling laws say about model size and data, how RLHF shapes a model's behaviour, and where today's reasoning models come from, risks included.
Building advanced language model applications requires overcoming the limitations of naive retrieval through sophisticated preprocessing and search architectures.
Why large language models hit a memory wall, and how quantisation and LoRA shrink models and fine-tuning so they fit and run fast on real GPUs.
How AI agents plan and call tools, how the Model Context Protocol (MCP) connects them to data and services, and when a plain workflow beats an agent.
Follow one HTTPS request through DNS, CDNs, load balancers and containers to the app and back: the map for the rest of the series.
How DNS resolution works, how BGP routes traffic across the internet, and why anycast often beats DNS-based failover.
How HTTP caching and CDNs work, what Cache-Control really means, and how a small drop in cache hit rate can overwhelm your servers.
How web application firewalls, DDoS mitigation and rate limiting protect the edge, and how attackers get around them.
How Layer 4 and Layer 7 load balancers and reverse proxies work, and why HTTP/2 changes how traffic should be balanced.
How containers really work using Linux namespaces and cgroups, and how Kubernetes networking connects pods and services.
Modern distributed systems achieve high availability through redundancy, utilizing multiple servers, Availability Zones, and cellular architectures to prevent localized failures from cascading.
Effective web architecture requires careful management of data-tier scaling, connection pooling, and caching strategies to prevent catastrophic cascading failures.
A map of web security that traces most vulnerabilities back to a few root causes and shows where each lesson goes deeper.
Modern transport layer security protocols, specifically TLS 1.3, provide essential confidentiality, integrity, and authentication while eliminating historical vulnerabilities found in outdated encryption methods.
How browsers keep sites apart: the same-origin policy, CORS and Content Security Policy, and what each one actually protects.
How cross-site scripting (XSS), CSRF and prototype pollution work, and why default defences still let them through.
These technical and standards-based sources outline comprehensive guidelines for implementing secure digital identity services, OAuth 2.0 protocols, and Web Authentication (WebAuthn) APIs.
How SQL injection, server-side request forgery and HTTP request smuggling exploit differences in how servers parse input.
Securing APIs: broken object-level authorisation (BOLA), why WAFs miss API breaches, and zero-trust authorisation on the server.
Modern decision models, such as TypeSafe AI's Jev, Cloudflare Clef, and open-source adapters like Kev-9B, represent a shift from traditional generative language models toward rapid, task-specific evaluation.
Carroll's surreal journey through a world of logical nonsense — what it reveals about the absurdity of adult rules seen through a child's ruthless logic.
Dickens's tight ghost story about the economics of compassion — how Scrooge's transformation is not sentimental but brutally rational.
Modern organizations must carefully evaluate and select digital experience platforms and headless content management systems to achieve seamless omnichannel content delivery across diverse touchpoints.
Ibsen's explosive drama — Nora Helmer's awakening from the comfortable cage of Victorian marriage and the door slam that shook European theatre.
Melville's monumental novel of obsession, the sea, and the unknowable — dissected for what it actually is, and whether the journey is worth it.
Conan Doyle's consulting detective examined as a cognitive system — how Holmes's methods of observation and deduction became a template for modern analytical thinking.
Jonathan Swift's 1729 satire A Modest Proposal explained: how its deadpan irony attacks the treatment of Ireland's poor, and why it still shocks readers today.
An introduction to AI: how machines learn through supervised, unsupervised and reinforcement learning, and the technical infrastructure behind modern AI.
James Clear's Atomic Habits in brief: how small 1% changes compound into lasting habits, what works in practice, and where critics push back on the book.
Dr. Shamini Jain's biofield science explained: research on healing, consciousness and the body's energy fields, from her book Healing Ourselves.
The rapid advancement of artificial intelligence and machine learning has made the creation and alteration of synthetic media inexpensive, swift, and remarkably convincing, posing severe cybersecurity and misinformation…
How the way choices are presented shapes our decisions: the psychology of decision-making, and frameworks people and organisations use to choose better.
The security-audit-skill is an open-source coding-agent tool developed by Cloudflare designed to transform artificial intelligence agents into systematic security auditors.
A HAR (HTTP Archive) file is a JSON-formatted log that records a web browser's interactions with a website, capturing essential network traffic data such as headers, cookies, payloads, and request timings.
Evolver is an enterprise technology company that provides advanced artificial intelligence solutions, consulting, and decision intelligence platforms to both government agencies and major corporations.
How large language models power browser extensions that summarise, translate and help you write, and the trade-offs that come with them.
LogFlow Pro is an advanced diagnostic and visualization software designed to bridge the gap between raw AWS CloudWatch logs and actionable engineering insights.
Viktor Frankl's Man's Search for Meaning and logotherapy: how finding purpose helps people endure suffering and lead meaningful lives.
How the Model Context Protocol works, with hosts, clients and servers, and how AI applications use it to discover tools, call them and fetch context.
MPP and x402 compared: how AI agents and machines pay each other, with native settlement and machine-to-machine authentication for the emerging M2M economy.
OLAS Network and the agent economy: how autonomous AI agents work as independent economic peers, using blockchain for trustless settlement and identity.
The science behind rapid image cycling for visualisation: flicker fusion, the stroboscopic effect, and how human and animal eyes perceive fast-changing images.
This research introduces the fiberbot, a miniature, polymer-based robotic fiber designed to improve the precision of minimally invasive surgery.
Shakespeare's Romeo and Juliet explored: its themes, the psychology of its young lovers, the social pressures that doom them, and how the play is performed.
Streaming data with Apache Flink and Spark: how Flink's distributed engine handles stateful stream and batch processing, and how the two compare.
Thomas Erikson's Surrounded by Idiots: four colour-coded behaviour types based on William Marston's DISC theory, and how to communicate with each one.
The ADKAR change model from Jeff Hiatt and Prosci: Awareness, Desire, Knowledge, Ability and Reinforcement, plus its strengths, weaknesses and use.
Arnold Bennett's "How to Live on 24 Hours a Day" argues that time is humanity's most equally distributed yet poorly managed resource, directly challenging the common excuse of lacking adequate hours.
The idea of a fourth wave across many fields: a major historical shift toward integration, advanced technology and global change, and what it means for us.
Shawn Achor's The Happiness Advantage: how positive psychology and a shift in mindset can improve performance, success and well-being.
Available through Project Gutenberg, the classic 19th-century novel Little Women by Louisa May Alcott is a popular free digital text.
Coordination Science explained: a mathematical theory of how multiple agents coordinate, rather than treating the organisation itself as the unit of analysis.
The Meditations of Marcus Aurelius: the Stoic emperor's private reflections, with an introduction and his surviving letters with his tutor Fronto.
Charles Duhigg's The Power of Habit: how keystone habits like exercise, planning, mindfulness and sleep set off wider change in your life and work.
Agentic commerce explained: the protocols that let AI agents discover products, work with online stores and complete purchases on a shopper's behalf.
Inside the inference scaling paradigm — how modern LLMs reason, route between models, build internal world models, and what that means for systems that use them.
Tolstoy's dissection of Russian society — Anna's affair read not as romance but as a collision between individual desire and a social order that tolerates no deviation.
The evolution of API design — from REST conventions through GraphQL flexibility to type-safe RPC frameworks, and the trade-offs that should drive the decision.
Dostoevsky's final and greatest novel — faith, doubt, patricide, and three brothers as archetypes of the human condition: intellect, passion, and saintliness.
Augustine's monumental defence of Christianity after Rome's fall — the argument that earthly power is always temporary, but the divine city endures.
Dumas's grand revenge epic — Edmond Dantès's transformation from wronged innocent to patient, methodical destroyer of the men who betrayed him.
Dostoevsky's psychological masterpiece — Raskolnikov's theory that extraordinary men are above morality, and how the weight of guilt dismantles it.
Ending the specificity wars — BEM, utility-first, cascade layers, and a framework for choosing your CSS architecture based on team size and project scale.
Cervantes's accidental masterpiece — the first modern novel, read as a study in idealism vs reality and what happens when a man weaponises delusion.
Wilde's Faustian tale of beauty, corruption, and the portrait that bears the cost of a life lived without conscience.
Shelley's founding text of science fiction — the ambition of creation, the horror of abandonment, and whether Victor or his creature is the real monster.
Twain's great American novel — a raft trip down the Mississippi as a dissection of freedom, hypocrisy, and the moral education of a boy the South failed to corrupt.
Brontë's radical portrait of female independence — a governess who refuses to trade her self-respect for security, love, or social position.
Hugo's monumental argument about justice, mercy, and whether society's laws serve its people — told through Jean Valjean's lifelong pursuit by an immovable system.
How to actually measure whether an LLM is getting better — evaluation frameworks, chain-of-thought strategies, thinking token costs, and the 2026 reasoning landscape.
George Eliot's panoramic study of provincial life — ambition, marriage, and the quiet tragedy of intelligent people trapped by the limits of their world.
Tolle's guide to presence — the case that the ego and its addiction to past and future is the primary source of human suffering.
Mental models for building with React — the component model, reconciliation, hooks, concurrent features, and how React compares to the broader UI framework landscape.
Hardy's indictment of Victorian sexual politics — a woman crushed by a society that invented her fall, then punished her for it.
Montgomery's underrated masterpiece — Valancy Stirling's radical escape from family tyranny when a death sentence liberates her from the fear of others' opinions.
Fitzgerald's autopsy of the American Dream — Jay Gatsby's reinvention as a case study in how the pursuit of an idealised past destroys everything in the present.
Homer's epic of war, glory, and grief — read as a study in the cost of ego, the randomness of fate, and why Achilles's rage is still the most human thing in ancient literature.
Beyond basic types — structural typing, discriminated unions, advanced generics, utility types, and how to make impossible states unrepresentable in TypeScript.
The invisible infrastructure of the browser — HTTP/2, HTTP/3, caching strategies, storage APIs, and what happens before your JavaScript even runs.
Speed as a revenue variable — Core Web Vitals, INP, critical path rendering, and the practical techniques that actually move the needle for real users.
Practical defence for web developers — CSRF, JWT pitfalls, SQL injection, XSS, and the architectural patterns that prevent the OWASP top 10 from becoming your problem.
Brontë's violent, obsessive love story — stripped of romance and read as a gothic study in class resentment, revenge, and the destructive force of fixation.
Production-grade engineering for AI agents — skills, workflows, and architecture patterns for senior engineers building reliable AI systems.
Bram Stoker's gothic masterpiece examined through modern eyes — Victorian technology, obsession, predation, and the data that brought down a monster.
Stevenson's tale of duality, respectability, and the monstrous self — exploring what the novella reveals about Victorian repression and human psychology.
Austen's razor-sharp comedy of manners — a cutthroat strategic game of marriage, money, and social positioning dressed up as romance.