Developer
Hub

Metaprogramming

Code that reads, generates, or transforms other code at runtime or load-time.

Recursion & Tail Recursion

Solving problems by reducing them to simpler versions of themselves, and how to do it without blowing the stack.

Higher-Order Functions

Functions that take other functions as arguments or return them, enabling powerful abstraction.

Closures & Lexical Scope

How functions capture their surrounding environment and why this matters for encapsulation.

Memoization & Dynamic Programming

Trading memory for speed by caching the results of expensive computations.

Pattern Matching

Destructuring and dispatching on data shape rather than explicit branching.

Lazy Evaluation

Deferring computation until the result is actually needed.

Currying & Partial Application

Transforming a multi-argument function into a chain of single-argument functions.

Generators & Iterators

Functions that can pause execution and yield values one at a time.

Decorators & Annotations

Wrapping or augmenting functions, methods, and classes without modifying their source.

Monads & Functors

Composable containers that sequence computations while managing context (errors, async, nulls).

Immutability

Treating data as values that never change in place, only replaced with new versions.

Reflection & Introspection

A program examining and modifying its own structure at runtime.

Code Generation

Automating the creation of boilerplate or repetitive code from templates or specs.

Continuation-Passing Style

Encoding control flow explicitly by passing the "rest of the computation" as a function argument.

Object-Oriented Programming

Organising code around objects that combine state and behaviour.

Functional Programming

Building programs from pure functions and immutable data, avoiding shared state.

Reactive Programming

Modelling asynchronous data streams and propagating change automatically.

Event-Driven Programming

Structuring flow around the production and consumption of events.

Declarative vs Imperative

Describing what you want versus specifying how to achieve it step by step.

Concurrent & Parallel Programming

Managing multiple computations that overlap in time and the hazards that come with it.

Aspect-Oriented Programming

Separating cross-cutting concerns from core business logic.

Logic Programming

Expressing programs as a set of logical facts and rules, letting the engine find solutions.

Procedural Programming

Structuring code as a sequence of instructions grouped into reusable procedures.

Data-Oriented Design

Organising code around data layout and transformation for cache efficiency.

Domain-Driven Design

Centering the codebase on a rich model of the business domain rather than technical layers.

Test-Driven Development

Writing tests before code to drive design and guarantee correctness incrementally.

Behaviour-Driven Development

Specifying software behaviour in human-readable scenarios that act as both docs and tests.

Contract Programming

Defining formal preconditions, postconditions, and invariants that every function must honour.

Naming Conventions

Rules for naming variables, functions, classes, and files that communicate intent clearly.

Code Formatting

Automated and manual formatting practices that reduce cognitive overhead when reading code.

Documentation & Comments

When and how to write comments, and the difference between explaining why vs what.

API Design Guidelines

Principles for designing clean, predictable, and versioned interfaces.

Git Commit Standards

Structuring commits and branches so history tells a legible story.

Code Review Practices

How to give and receive feedback that improves code without damaging collaboration.

File & Directory Structure

Organising code on disk so contributors can navigate without a map.

Error Handling Patterns

Consistent approaches to raising, catching, and surfacing failures.

Test Organisation

Structuring test suites for readability, speed, and sustainable maintenance.

Dependency Management

Selecting, pinning, and auditing third-party packages with intent.

Linting & Static Analysis

Automated tools that catch style violations and common bugs before review.

Changelog Maintenance

Keeping a human-readable record of what changed, for whom, and why.

Authentication & Authorization

Verifying identity and enforcing what authenticated users are permitted to do.

Input Validation & Sanitization

Never trusting input at the boundary, validating shape, type, and intent before processing.

SQL Injection Prevention

Parameterised queries, prepared statements, and why string interpolation in SQL is never acceptable.

XSS & CSRF Protection

Preventing scripts from being injected into pages and cross-site requests from being forged.

Secrets Management

Keeping credentials, API keys, and tokens out of source control and away from the logs.

Rate Limiting & Brute-Force Defence

Throttling requests to protect endpoints from automated abuse.

Dependency Auditing

Keeping the supply chain clean, knowing what your dependencies do and flagging known vulnerabilities.

Encryption at Rest & in Transit

Ensuring data is unreadable without the correct key, whether stored or moving over the wire.

Principle of Least Privilege

Granting only the minimum permissions required for a component or user to do its job.

Security Headers

HTTP response headers (CSP, HSTS, X-Frame-Options) that enforce browser-level protections.

Session Management

Safely issuing, storing, rotating, and invalidating session tokens.

OWASP Top 10

The ten most critical web application security risks, updated regularly by the open community.

Audit Logging

Recording who did what and when, the foundation of forensics and compliance.

Zero Trust Architecture

Never trusting any request by default, regardless of network location, verify every access explicitly.

Penetration Testing Fundamentals

Deliberately probing systems for vulnerabilities before attackers do.

Database Indexing & Query Optimization

How indexes work, when to add them, and how to read query execution plans.

Caching Strategies

In-process caches, Redis, HTTP caching headers, and CDN edge caching, choosing the right layer.

Lazy Loading & Code Splitting

Deferring asset and code loading until actually needed by the user.

Memory Management & Leak Prevention

Understanding how runtimes allocate and reclaim memory, and spotting patterns that prevent reclamation.

Profiling & Benchmarking

Measuring before optimising, tools and approaches for finding the actual bottleneck.

N+1 Query Problem

Identifying and eliminating the most common source of accidental database load in ORM-heavy applications.

Connection Pooling

Reusing database and network connections to reduce overhead at scale.

Async & Non-Blocking I/O

Processing I/O without blocking the thread, keeping CPU utilisation high.

Database Denormalization

Strategically duplicating data to accelerate read queries at the cost of write complexity.

Pagination & Cursor-Based Loading

Fetching data in bounded chunks rather than loading unbounded result sets.

Batch Processing

Grouping operations together to reduce per-unit overhead and network round-trips.

CDN & Edge Computing

Serving assets and executing logic from locations geographically close to the user.

HTTP/2 & gRPC

Multiplexed connections and binary protocols that dramatically reduce request overhead.

Event Loop & Thread Management

How single-threaded runtimes handle concurrency and where blocking calls cause hidden damage.

WebSockets vs Polling

Persistent bidirectional connections versus repeated short-lived requests, knowing which fits.