Programming Languages

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

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

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

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

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

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

Intermediate to Advanced7 cards · 5 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 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 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 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 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 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 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

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

Beginner5 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 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 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 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 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 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 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

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

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 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 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

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 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 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 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 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 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 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 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

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 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 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 Mediator pattern: routing the communication between many objects through one coordinator, and counting the links it removes.

Intermediate to Advanced8 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

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

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 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 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 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 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

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 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 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 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 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 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 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 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 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

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