Technology

Authenticating API clients: API keys, sessions, bearer tokens, JWTs and mutual TLS, and which one suits each kind of caller.

Beginner to Advanced12 cards · 8 qnot started

The building blocks of a web system: DNS, CDNs, application servers and databases, and the path a request takes through them.

Beginner to Intermediate11 cards · 8 qnot started

REST and resource design: naming the things an API exposes and the paths that reach them, with filtering, sorting and actions that are not plain updates.

Beginner to Advanced11 cards · 7 qnot started

HTTP caching for APIs: telling clients and CDNs how long to keep a response, and using ETags to skip unchanged downloads and to stop two clients overwriting each other.

Beginner to Advanced11 cards · 8 qnot started

OAuth 2.0 and OpenID Connect: letting an application act for a user without their password, and learning who that user is.

Beginner to Advanced11 cards · 7 qnot started

Elementary sorting: bubble, selection and insertion sort traced pass by pass, and the one place each still beats an O(n log n) algorithm.

Intermediate11 cards · 5 qnot started

Linear-time sorting: counting, radix and bucket sort, which beat the comparison bound by reading the keys' values, and the inputs each one needs.

Intermediate to Advanced11 cards · 5 qnot started

Shortest paths in weighted graphs, in algorithms: Dijkstra's algorithm, Bellman-Ford and Floyd-Warshall, and how weights and pairs choose between them.

Intermediate to Advanced11 cards · 6 qnot started

Java methods: declaring and calling them, signatures, parameters and arguments, pass-by-value, and overloading.

Beginner to Intermediate10 cards · 6 qnot started

Java inheritance: what extends gives a subclass, constructor order, overriding against overloading, super, private fields and final.

Intermediate to Advanced10 cards · 5 qnot started

Java exceptions: try, catch and finally, checked and unchecked exceptions, catching, declaring and wrapping, and try-with-resources.

Beginner to Advanced10 cards · 6 qnot started

Java streams: pipelines over a source, lazy evaluation, map and flatMap, collectors, single use, and when parallel streams pay.

Intermediate to Advanced10 cards · 6 qnot started

Load balancers, reverse proxies and API gateways: the three kinds of server that sit in front of yours, and the one job each is for.

Beginner to Intermediate10 cards · 5 qnot started

Client-server communication: polling, server-sent events, WebSockets and webhooks, chosen by who sends and how often.

Beginner to Intermediate10 cards · 5 qnot started

Software architectural styles: monoliths, layers, microservices, events and serverless, and the team and product each one fits.

Beginner to Advanced10 cards · 5 qnot started

HTTP on the wire: what a request and response look like, and what HTTP/2 and HTTP/3 change about the connection under them.

Beginner to Advanced10 cards · 6 qnot started

How WebSocket, server-sent events and WebRTC keep a connection open, who may send on it, and how each one survives a drop.

Beginner to Advanced10 cards · 6 qnot started

HTTP methods for APIs: what GET, POST, PUT, PATCH and DELETE promise, and which are safe to repeat.

Beginner to Intermediate10 cards · 7 qnot started

API contracts: the fields, types and formats a client and server agree on, written down so machines can check them.

Beginner to Advanced10 cards · 7 qnot started

Protecting an API: the common API security risks, object-level checks, rate limits a client can act on, and what CORS does and does not do.

Beginner to Advanced10 cards · 8 qnot started

Hash tables: the data structure that turns a key into an array index to find values in expected constant time, and what collisions, growth and bad keys do to it.

Beginner to Intermediate10 cards · 6 qnot started

Dynamic programming: solving a problem from the answers to its overlapping subproblems, top-down with memoisation or bottom-up with a table.

Intermediate to Advanced10 cards · 6 qnot started

Breadth-first and depth-first search in algorithms, and what they find: components, cycles, bipartite graphs and unweighted shortest paths.

Intermediate to Advanced10 cards · 6 qnot started

Java variables and types: primitives and references, what assignment copies, the eight primitive types, money, and what the compiler checks.

Beginner to Intermediate9 cards · 5 qnot started

Java operators: how operand types choose what a symbol does, identity versus equality, short-circuiting, precedence and increments.

Beginner to Intermediate9 cards · 5 qnot started

Choosing which code runs with if and switch, repeating it with Java's four loop forms, and the boundary mistakes in both.

Beginner to Intermediate9 cards · 5 qnot started

Java strings: immutability, why String methods return new strings, the string pool, equals against ==, and building text with StringBuilder.

Beginner to Intermediate9 cards · 5 qnot started

Java classes and objects: classes as descriptions, creating objects with new, constructors, this, and static against instance members.

Beginner to Intermediate9 cards · 6 qnot started

Java polymorphism: how the runtime object chooses which overridden method runs, what the declared type decides, hiding, casts and instanceof.

Intermediate to Advanced9 cards · 5 qnot started

Java memory: the stack and the heap, what keeps an object alive for the garbage collector, the two memory errors, and leaks.

Intermediate to Advanced9 cards · 5 qnot started

How a HashMap works: hashing to a bucket, collisions, resizing, the three map classes, and null keys.

Intermediate to Advanced9 cards · 5 qnot started

Sorting your own types in Java: Comparable for the natural order, Comparator for the rest, and the two ways a comparator goes wrong.

Intermediate to Advanced9 cards · 5 qnot started

Java generics: type parameters, what the compiler checks, type erasure, wildcards, and what erasure forbids.

Intermediate to Advanced9 cards · 5 qnot started

Java lambdas and functional interfaces: passing behaviour as an argument, the four core interfaces, method references and captured variables.

Intermediate to Advanced9 cards · 5 qnot started

Why shared state breaks between threads: race conditions, non-atomic operations, visibility, and choosing volatile, atomics or locks.

Intermediate to Advanced9 cards · 5 qnot started

Locks in Java: what synchronized guarantees, which object it locks, reentrancy, ReentrantLock, and what a lock cannot protect.

Intermediate to Advanced9 cards · 5 qnot started

Executors and futures: running tasks on a thread pool, getting results back, CompletableFuture, and shutting a pool down.

Intermediate to Advanced9 cards · 5 qnot started

Requirements and trade-offs: deciding what a system must do and how well, so a design has something to be checked against.

Beginner to Intermediate9 cards · 5 qnot started

Caching: keeping copies of frequent reads close, deciding when they go stale, and the ways a cache can take a system down.

Beginner to Advanced9 cards · 8 qnot started

Scaling a web system up or out: bigger machines or more of them, what has to be stateless first, and what autoscaling cannot catch.

Beginner to Advanced9 cards · 5 qnot started

Message queues and publish/subscribe: handing work off without waiting, and choosing between one reader and many.

Beginner to Intermediate9 cards · 6 qnot started

Design rot and the SOLID principles: why working object-oriented code becomes hard to change, and the five principles that answer it.

Beginner to Intermediate9 cards · 7 qnot started

The Liskov substitution principle in SOLID: a subclass must work anywhere its parent does, keeping every promise the parent makes.

Beginner to Intermediate9 cards · 5 qnot started

The dependency inversion principle in SOLID: make business rules depend on abstractions they own, so databases and services can be swapped and faked in tests.

Beginner to Intermediate9 cards · 5 qnot started

The Factory Method pattern: letting subclasses decide which class of object to create, so the code that uses the object never names it.

Intermediate to Advanced9 cards · 4 qnot started

The Builder pattern: constructing a complex object step by step, so a constructor with a dozen optional parameters is never needed.

Intermediate to Advanced9 cards · 4 qnot started

The Singleton pattern: guaranteeing a class has exactly one instance with a global access point, and why it is the most criticised of the 23.

Intermediate to Advanced9 cards · 4 qnot started

The Proxy pattern: a stand-in with the same interface as a real object that controls when and whether calls reach it, and the self-call it never sees.

Intermediate to Advanced9 cards · 4 qnot started

The Strategy pattern: putting each interchangeable algorithm behind one interface so the caller chooses it, and why in Python the strategy is often a function.

Intermediate to Advanced9 cards · 4 qnot started

The Observer pattern: letting many objects subscribe to one and be told when it changes, and the listener that is never unsubscribed.

Intermediate to Advanced9 cards · 4 qnot started

The Command pattern: turning a request into an object that can be queued, logged or undone, and what each command must remember to undo itself.

Intermediate to Advanced9 cards · 4 qnot started

The Template Method pattern: fixing the order of an algorithm's steps in a base class and letting subclasses supply the steps that differ.

Intermediate to Advanced9 cards · 4 qnot started

The Iterator pattern: walking a collection one element at a time without knowing how it is stored, and why a Python generator can be walked only once.

Intermediate to Advanced9 cards · 4 qnot started

The Visitor pattern: adding operations over a fixed set of classes as separate visitor classes, how double dispatch finds the right method, and why a new element class is costly.

Intermediate to Advanced9 cards · 4 qnot started

HTTP status codes for APIs: choosing the code that tells a client what happened and what to do next.

Beginner to Intermediate9 cards · 7 qnot started

Asynchronous APIs: answering a long job with 202 Accepted and a status to check, and sending signed webhooks a receiver can trust.

Beginner to Advanced9 cards · 5 qnot started

Versioning an API: telling breaking changes from safe ones, and retiring an old version without stranding its clients.

Beginner to Advanced9 cards · 6 qnot started

REST, GraphQL and gRPC: what each API style exposes, and how to choose one for an integration.

Beginner to Advanced9 cards · 5 qnot started

Arrays and strings: why reading by index is instant, why inserting in the middle is not, and how a dynamic array grows without slowing every append.

Beginner to Intermediate9 cards · 4 qnot started

Linked lists: nodes joined by references, so inserting and deleting is a rewire instead of a shift, at the price of reading by position.

Beginner to Intermediate9 cards · 4 qnot started

Stacks and queues: the two data structures defined by the order items leave in, last in first out or first in first out, and how to build each cheaply.

Beginner to Intermediate9 cards · 4 qnot started

Binary Search Trees: keeping keys in order so that search, insert and delete each follow one path, and why insertion order decides the cost.

Beginner to Advanced9 cards · 6 qnot started

Heaps: a complete binary tree stored in an array that always gives the smallest or largest item first, the data structure behind every priority queue.

Beginner to Intermediate9 cards · 5 qnot started

Binary search: finding a value in a sorted array by halving the range at every step, with the invariant, the midpoint and the boundaries that make it correct.

Intermediate9 cards · 5 qnot started

Quicksort: sorting by partitioning around a pivot, fast on average, slow on the inputs a bad pivot meets, and the source of quickselect.

Intermediate to Advanced9 cards · 4 qnot started

Backtracking: building every candidate solution one choice at a time, undoing each choice, and pruning branches that cannot succeed.

Intermediate to Advanced9 cards · 4 qnot started

Knapsack and grid dynamic programming: filling a table over items and capacities, or over the cells of a grid, and the loop orders that change the answer.

Intermediate to Advanced9 cards · 4 qnot started

Sequence dynamic programming in algorithms: longest common subsequence, edit distance and longest increasing subsequence, each a table over prefixes.

Intermediate to Advanced9 cards · 4 qnot started

Minimum spanning trees in algorithms: the cut property, Kruskal's algorithm with union-find, Prim's algorithm with a heap, and why neither gives shortest paths.

Intermediate to Advanced9 cards · 4 qnot started

Java arrays: a fixed run of values under one name, creating and filling one, zero-based indexes, and why an array cannot grow.

Beginner to Intermediate8 cards · 5 qnot started

Java interfaces and abstract classes: naming a capability, sharing state, default methods, and choosing between the two.

Intermediate to Advanced8 cards · 5 qnot started

Java encapsulation: private fields, the four access levels, references that leak through getters and constructors, and composition against inheritance.

Intermediate to Advanced8 cards · 5 qnot started

Java equals, hashCode and toString: the defaults every object inherits, the contract between equals and hashCode, and how hash maps lose keys.

Intermediate to Advanced8 cards · 6 qnot started

The Java Collections Framework: List, Set and Queue, what each promises, and which type to declare a variable with.

Intermediate to Advanced8 cards · 5 qnot started

ArrayList vs LinkedList: two lists with the same methods and opposite costs, how an ArrayList grows, and removing while iterating.

Intermediate to Advanced8 cards · 6 qnot started

Sets and queues: collections that decide what counts as a duplicate and what comes out next, and which class to use.

Intermediate to Advanced8 cards · 5 qnot started

Java Optional: a return type that puts possible absence in the signature, how to unwrap it, and where it does not belong.

Intermediate to Advanced8 cards · 5 qnot started

Java threads: starting work that runs alongside your code, the states a thread passes through, and platform vs virtual threads.

Intermediate to Advanced8 cards · 5 qnot started

Deadlock in Java: how two locks taken in opposite orders stop a program, the four conditions, lock ordering, livelock and starvation.

Intermediate to Advanced8 cards · 5 qnot started

Back-of-the-envelope estimation: turning users and their actions into requests a second, storage and downtime, before choosing a single part.

Beginner to Intermediate8 cards · 6 qnot started

API pagination with offsets and cursors: returning large results a page at a time without skipping rows or slowing down.

Beginner to Intermediate8 cards · 5 qnot started

The single responsibility principle in SOLID: give each class one reason to change, by splitting it along the people who ask for changes.

Beginner to Intermediate8 cards · 4 qnot started

The open/closed principle in SOLID: add new behaviour as new code, without editing classes that already work.

Beginner to Intermediate8 cards · 4 qnot started

The interface segregation principle in SOLID: give each client a small interface holding only the methods it calls.

Beginner to Intermediate8 cards · 4 qnot started

What design patterns are: named, reusable solutions to recurring object-oriented design problems, how the 23 classic ones are grouped, and when one costs more than it saves.

Beginner to Intermediate8 cards · 5 qnot started

Reading UML class diagrams: the boxes, lines and arrowheads every design pattern is drawn with, and how each relationship looks in code.

Beginner to Intermediate8 cards · 5 qnot started

The Abstract Factory pattern: creating whole families of related objects through one interface, so a program can switch every product at once.

Intermediate to Advanced8 cards · 4 qnot started

The Prototype pattern: creating new objects by copying a configured one, and the shallow copy trap that comes with it.

Intermediate to Advanced8 cards · 4 qnot started

The Adapter pattern: wrapping an existing class so it fits the interface a client already expects, without changing either side.

Intermediate to Advanced8 cards · 4 qnot started

The Decorator pattern: adding behaviour to an object by wrapping it in others with the same interface, and how it differs from Python's @ syntax.

Intermediate to Advanced8 cards · 5 qnot started

The Facade pattern: one simple interface in front of a complex subsystem, with the subsystem's classes still there for the cases the facade does not cover.

Intermediate to Advanced8 cards · 4 qnot started

The Composite pattern: treating a single object and a group of objects the same way, as in files and folders.

Intermediate to Advanced8 cards · 4 qnot started

The Bridge pattern: splitting what something is from how it is done into two hierarchies, so they grow without multiplying classes.

Intermediate to Advanced8 cards · 4 qnot started

The Flyweight pattern: sharing the common part of many small objects so that a program holding millions of them still fits in memory.

Intermediate to Advanced8 cards · 4 qnot started

The State pattern: giving each state of an object its own class, so behaviour changes when the state changes, and deciding which class chooses the next state.

Intermediate to Advanced8 cards · 4 qnot started

The Chain of Responsibility pattern: passing a request along a chain of handlers until one deals with it, and ending every chain with an answer for requests nobody accepts.

Intermediate to Advanced8 cards · 4 qnot started

The Mediator pattern: routing the communication between many objects through one coordinator, and counting the links it removes.

Intermediate to Advanced8 cards · 4 qnot started

The Memento pattern: saving an object's state as a snapshot only that object can read, so it can be restored later, and keeping the snapshots from filling the memory.

Intermediate to Advanced8 cards · 4 qnot started

The Interpreter pattern: representing each rule of a small language as a class, evaluating a sentence as a tree of those objects, and knowing that parsing is a separate job.

Intermediate to Advanced8 cards · 4 qnot started

API error responses: one error format a client can branch on, with enough detail to fix the request and nothing an attacker can use.

Beginner to Intermediate8 cards · 5 qnot started

Big O notation: how to describe the way a data structure operation's cost grows with its input, and why constants and smaller terms drop out.

Beginner to Intermediate8 cards · 5 qnot started

Analysing complexity: reading the time and space a function needs from its loops, its recursion and the built-in calls hidden inside them.

Beginner to Intermediate8 cards · 5 qnot started

Recursion: writing a function that calls itself on a smaller input, tracing it through the call stack, and replacing it with a loop when it runs too deep.

Beginner to Intermediate8 cards · 5 qnot started

Binary Trees: naming the parts of a tree, traversing it in four orders, counting height in edges, and writing functions that combine two subtrees' answers.

Beginner to Intermediate8 cards · 4 qnot started

Graph representations: storing vertices and edges as an adjacency list or an adjacency matrix, and choosing between them by how many edges there are.

Beginner to Intermediate8 cards · 4 qnot started

Divide and conquer: designing an algorithm by splitting a problem, solving the parts recursively and combining them, then reading its cost from a recurrence.

Intermediate to Advanced8 cards · 4 qnot started

Merge sort: the sorting algorithm that splits an array in half, sorts each half and merges them, in O(n log n) time on every input.

Intermediate8 cards · 4 qnot started

Choosing a sorting algorithm: picking a sort by memory, stability, worst case and keys, the n log n limit on comparison sorts, and built-in sorts.

Intermediate to Advanced8 cards · 4 qnot started

Greedy algorithms: taking the locally best choice at every step, proving it with an exchange argument, and disproving it with a counterexample.

Intermediate to Advanced8 cards · 4 qnot started

Ordering tasks so every dependency comes first, in algorithms: Kahn's algorithm, depth-first finishing times, and how each one finds a cycle.

Intermediate to Advanced8 cards · 4 qnot started

Solving an unseen problem: a fixed sequence of steps from clarifying the input to tracing the code, so a coding problem never starts from a blank page.

Intermediate to Advanced8 cards · 5 qnot started

Hash map patterns: complements, counts and canonical keys that turn a search inside a loop into one lookup, and the array used as its own hash map.

Intermediate to Advanced8 cards · 4 qnot started

Two pointers: walking a sorted array from both ends, or rewriting it in place with a read and a write pointer, and the precondition each needs.

Intermediate to Advanced8 cards · 4 qnot started

Sliding window: keeping a running answer for a contiguous run as it slides, with a fixed size or one that grows and shrinks, and the inputs that break it.

Intermediate to Advanced8 cards · 5 qnot started

Prefix sums: precomputing running totals so any range sum is one subtraction, and counting the runs that hit a target with a hash map.

Intermediate to Advanced8 cards · 4 qnot started

Monotonic stack: finding the next greater or smaller element of every position in one pass, with a stack kept in order.

Intermediate to Advanced8 cards · 4 qnot started

Bit manipulation: reading and changing single bits with AND, OR, XOR and shifts, and where Python, Java and TypeScript give different answers.

Intermediate to Advanced8 cards · 4 qnot started

Fast and slow pointers: two pointers moving at different speeds that find a list's middle, detect a cycle and locate where the cycle starts.

Intermediate to Advanced8 cards · 4 qnot started

Linked list reversal: reversing a linked list in place with three references, and reversing part of a list or groups of nodes with a dummy node.

Intermediate to Advanced8 cards · 4 qnot started

Intervals: merging, inserting and intersecting ranges after sorting them by start, and counting the most that overlap at once.

Intermediate to Advanced8 cards · 4 qnot started

Modified binary search: binary search on a condition instead of a value, on a rotated array, and over the possible answers to a problem.

Intermediate to Advanced8 cards · 4 qnot started

Heap patterns: keeping the top K items, merging sorted lists and tracking a running median with one heap or two.

Intermediate to Advanced8 cards · 4 qnot started

Tree patterns: solving binary tree problems by passing values down or returning them up, level by level, or through both subtrees at once.

Intermediate to Advanced8 cards · 4 qnot started

Grid traversal: treating a grid of cells as a graph for breadth-first and depth-first search, flood fills and searches from many starting cells.

Intermediate to Advanced8 cards · 4 qnot started

Graph modelling: finding the vertices and edges hidden in a problem's wording, then solving it with a search, a topological sort or union-find.

Intermediate to Advanced8 cards · 4 qnot started

Optimising a solution: finding the step that dominates a solution's cost and removing it with a standard move, and knowing when to stop.

Intermediate to Advanced8 cards · 4 qnot started

Wiring beans together: constructor injection, stereotype annotations, choosing between two candidates, and @Bean methods.

Intermediate to Advanced7 cards · 5 qnot started

Bean scopes and lifecycle callbacks: how many instances of a bean exist, how long each lives, and who cleans it up.

Intermediate to Advanced7 cards · 4 qnot started

Handling errors consistently in a REST API: custom exceptions, @ExceptionHandler, @RestControllerAdvice, status codes and one error body.

Intermediate to Advanced7 cards · 5 qnot started

Spring Data JDBC vs Spring Data JPA: persistence context, dirty checking, lazy loading, aggregates, and when to choose each.

Intermediate to Advanced7 cards · 4 qnot started

The JPA entity lifecycle: the four states an entity can be in, the operations that move it, and when its SQL runs.

Advanced7 cards · 5 qnot started

Transactions with @Transactional: what it wraps, when it rolls back, why self-calls skip it, and REQUIRES_NEW.

Intermediate to Advanced7 cards · 4 qnot started

Caching in Spring Boot: @Cacheable, @CachePut and @CacheEvict, cache keys, caching strategies, and the default provider's limit.

Intermediate to Advanced7 cards · 5 qnot started

System design heuristics: matching a pressure such as read-heavy traffic or global users to the pattern that answers it.

Intermediate to Advanced7 cards · 5 qnot started

Applying the SOLID principles together: diagnosing a class that breaks several, refactoring it safely behind tests, and knowing when to stop.

Intermediate to Advanced7 cards · 5 qnot started

Designing an API end to end: from requirements to reviewed endpoints, errors and a contract for one feature.

Intermediate to Advanced7 cards · 6 qnot started

Tries: a tree with one node per letter, which answers whether any stored word starts with a prefix in time that ignores how many words there are.

Beginner to Intermediate7 cards · 3 qnot started

Union-find in data structures: tracking which items share a group with a parent array, merging groups, and counting components and detecting cycles in a graph.

Intermediate to Advanced7 cards · 3 qnot started

Choosing a data structure: listing a program's operations and their frequency, picking the structure that makes them cheap, and the built-ins Python, Java and TypeScript provide.

Intermediate to Advanced7 cards · 4 qnot started

Heapsort: sorting in place in O(n log n) time on every input by building a heap and extracting its largest item, one at a time.

Intermediate7 cards · 3 qnot started

Choosing between divide and conquer, dynamic programming, greedy and backtracking in algorithms, by how a problem's subproblems behave.

Intermediate to Advanced7 cards · 3 qnot started

Graph connectivity in algorithms: strongly connected components with Kosaraju's two passes, bridges and articulation points from low values, and choosing the tool.

Intermediate to Advanced7 cards · 3 qnot started

Choosing a pattern: reading the cues in a coding problem's wording to pick the pattern that fits, and telling a real cue from a keyword.

Intermediate to Advanced7 cards · 4 qnot started

How a Java program runs: what javac produces, what the java command and the JVM do with it, and why one build runs on every machine.

Beginner to Intermediate6 cards · 5 qnot started

What a Spring bean is, the two interfaces behind the container, and the fixed lifecycle every bean follows.

Beginner to Intermediate6 cards · 4 qnot started

What Spring Boot adds to Spring: @SpringBootApplication, auto-configuration, and the conditions that decide which beans it creates.

Intermediate to Advanced6 cards · 4 qnot started

Spring Boot starters and the embedded server: one dependency instead of a dozen, and a web server inside your own jar.

Intermediate to Advanced6 cards · 4 qnot started

Configuring a Boot application: where a property can come from, which source wins, profiles, and binding properties into code.

Intermediate to Advanced6 cards · 4 qnot started

Mapping HTTP requests to controller methods: verbs and paths, reading request data, and choosing the response.

Intermediate to Advanced6 cards · 4 qnot started

Validating request input with Bean Validation: constraint annotations, @Valid, and field-by-field error responses.

Intermediate to Advanced6 cards · 4 qnot started

Spring Data repositories: CRUD without SQL, queries derived from method names, @Query, and what save() really does.

Intermediate to Advanced6 cards · 4 qnot started

Finding why a Spring Boot API is slow: the N+1 query problem, slow remote calls, and measuring before optimising.

Intermediate to Advanced6 cards · 4 qnot started

Idempotency keys: letting a client retry a payment or an order after a timeout without it happening twice.

Beginner to Advanced6 cards · 4 qnot started

Combining data structures: an LRU cache from a hash map and a doubly linked list, a set with O(1) random picks from an array and a map, and keeping both parts in step.

Intermediate6 cards · 3 qnot started

Dependency injection: why a class should be handed its dependencies instead of creating them, shown without Spring first.

Beginner5 cards · 4 qnot started

Choosing a creational design pattern: telling Factory Method, Abstract Factory, Builder, Prototype and Singleton apart, and when a plain constructor is enough.

Intermediate to Advanced5 cards · 4 qnot started

Choosing a structural design pattern: telling Adapter, Decorator, Facade, Proxy, Composite, Bridge and Flyweight apart by what each wrapper is for.

Intermediate to Advanced5 cards · 4 qnot started

Choosing a behavioural design pattern: telling Strategy, State, Template Method, Command, Observer, Mediator, Chain of Responsibility and Decorator apart by who decides and how many objects take part.

Intermediate to Advanced5 cards · 5 qnot started

How TCP delivers reliably: the handshake, sequence numbers, flow and congestion control, and what one lost segment costs.

Beginner to Advanced11 cards · 6 qnot started

IP addresses and subnets: reading CIDR blocks, telling private addresses from public ones, and dividing a range into networks that do not overlap.

Beginner to Advanced10 cards · 7 qnot started

Routing: how routers choose the next hop for a packet, how ping and traceroute see the path, and how the internet routes between networks.

Beginner to Intermediate10 cards · 6 qnot started

TLS: how HTTPS encrypts a connection and proves the server's identity, and how to read a certificate error.

Beginner to Advanced10 cards · 6 qnot started

HTTP on the wire: what a request and response look like, and what HTTP/2 and HTTP/3 change about the connection under them.

Beginner to Advanced10 cards · 6 qnot started

How WebSocket, server-sent events and WebRTC keep a connection open, who may send on it, and how each one survives a drop.

Beginner to Advanced10 cards · 6 qnot started

The OSI model: the seven network layers from cable to application, and how each wraps the data of the layer above it.

Beginner to Intermediate9 cards · 7 qnot started

The physical and data link layers: how bits cross one cable or radio link, and how MAC addresses, switches and ARP deliver a frame to the next device.

Beginner to Intermediate9 cards · 6 qnot started

Ports, TCP and UDP: how the transport layer delivers data to the right program, and when to choose a reliable stream or a fast datagram.

Beginner to Intermediate9 cards · 5 qnot started

DNS: how a domain name becomes an IP address, which record types exist, and why a change takes time to reach everyone.

Beginner to Intermediate9 cards · 6 qnot started

A network request end to end: every step of opening a web page, and how to find the layer where a failing request breaks.

Beginner to Advanced9 cards · 7 qnot started

The building blocks of a web system: DNS, CDNs, application servers and databases, and the path a request takes through them.

Beginner to Intermediate11 cards · 8 qnot started

Client-server communication: polling, server-sent events, WebSockets and webhooks, chosen by who sends and how often.

Beginner to Intermediate10 cards · 5 qnot started

Running a container from an image: docker run, publishing a port, and finding out why a container stopped.

Beginner to Intermediate6 cards · 5 qnot started

Load balancers, reverse proxies and API gateways: the three kinds of server that sit in front of yours, and the one job each is for.

Beginner to Intermediate10 cards · 5 qnot started

Back-of-the-envelope estimation: turning users and their actions into requests a second, storage and downtime, before choosing a single part.

Beginner to Intermediate8 cards · 6 qnot started

Spring Data JDBC vs Spring Data JPA: persistence context, dirty checking, lazy loading, aggregates, and when to choose each.

Intermediate to Advanced7 cards · 4 qnot started

The JPA entity lifecycle: the four states an entity can be in, the operations that move it, and when its SQL runs.

Advanced7 cards · 5 qnot started

Transactions with @Transactional: what it wraps, when it rolls back, why self-calls skip it, and REQUIRES_NEW.

Intermediate to Advanced7 cards · 4 qnot started

Spring Data repositories: CRUD without SQL, queries derived from method names, @Query, and what save() really does.

Intermediate to Advanced6 cards · 4 qnot started

API pagination with offsets and cursors: returning large results a page at a time without skipping rows or slowing down.

Beginner to Intermediate8 cards · 5 qnot started

The building blocks of a web system: DNS, CDNs, application servers and databases, and the path a request takes through them.

Beginner to Intermediate11 cards · 8 qnot started

Software architectural styles: monoliths, layers, microservices, events and serverless, and the team and product each one fits.

Beginner to Advanced10 cards · 5 qnot started

Caching: keeping copies of frequent reads close, deciding when they go stale, and the ways a cache can take a system down.

Beginner to Advanced9 cards · 8 qnot started

Scaling a web system up or out: bigger machines or more of them, what has to be stateless first, and what autoscaling cannot catch.

Beginner to Advanced9 cards · 5 qnot started

The building blocks of a web system: DNS, CDNs, application servers and databases, and the path a request takes through them.

Beginner to Intermediate11 cards · 8 qnot started

System design heuristics: matching a pressure such as read-heavy traffic or global users to the pattern that answers it.

Intermediate to Advanced7 cards · 5 qnot started

Back-of-the-envelope estimation: turning users and their actions into requests a second, storage and downtime, before choosing a single part.

Beginner to Intermediate8 cards · 6 qnot started

Caching: keeping copies of frequent reads close, deciding when they go stale, and the ways a cache can take a system down.

Beginner to Advanced9 cards · 8 qnot started

Scaling a web system up or out: bigger machines or more of them, what has to be stateless first, and what autoscaling cannot catch.

Beginner to Advanced9 cards · 5 qnot started

Requirements and trade-offs: deciding what a system must do and how well, so a design has something to be checked against.

Beginner to Intermediate9 cards · 5 qnot started

Load balancers, reverse proxies and API gateways: the three kinds of server that sit in front of yours, and the one job each is for.

Beginner to Intermediate10 cards · 5 qnot started

Client-server communication: polling, server-sent events, WebSockets and webhooks, chosen by who sends and how often.

Beginner to Intermediate10 cards · 5 qnot started

Message queues and publish/subscribe: handing work off without waiting, and choosing between one reader and many.

Beginner to Intermediate9 cards · 6 qnot started

The build cache: why a rebuild is fast or slow, how to order a Dockerfile to keep it fast, and what it leaves on disk.

Intermediate to Advanced7 cards · 3 qnot started

Running a container from an image: docker run, publishing a port, and finding out why a container stopped.

Beginner to Intermediate6 cards · 5 qnot started

Building your own image: writing a Dockerfile, running docker build, and naming the result with tags.

Beginner to Intermediate6 cards · 3 qnot started

What a container is: a program that shares the host's kernel, started from a read-only image.

Beginner5 cards · 3 qnot started

Which files survive a container: the writable layer, and the bind mounts and volumes that keep data after it is gone.

Beginner to Intermediate5 cards · 3 qnot started

Load balancers, reverse proxies and API gateways: the three kinds of server that sit in front of yours, and the one job each is for.

Beginner to Intermediate10 cards · 5 qnot started

Load balancers, reverse proxies and API gateways: the three kinds of server that sit in front of yours, and the one job each is for.

Beginner to Intermediate10 cards · 5 qnot started

Message queues and publish/subscribe: handing work off without waiting, and choosing between one reader and many.

Beginner to Intermediate9 cards · 6 qnot started

Scaling a web system up or out: bigger machines or more of them, what has to be stateless first, and what autoscaling cannot catch.

Beginner to Advanced9 cards · 5 qnot started

Software architectural styles: monoliths, layers, microservices, events and serverless, and the team and product each one fits.

Beginner to Advanced10 cards · 5 qnot started

Which files survive a container: the writable layer, and the bind mounts and volumes that keep data after it is gone.

Beginner to Intermediate5 cards · 3 qnot started

What a container is: a program that shares the host's kernel, started from a read-only image.

Beginner5 cards · 3 qnot started

Running a container from an image: docker run, publishing a port, and finding out why a container stopped.

Beginner to Intermediate6 cards · 5 qnot started