The labs on this site need JavaScript to run. The same content is written out below.

Dev Learning Lab

Pick a question, click Run, and watch how each concept behaves.

A free lab for learning Java, Spring, JPA, database, networking, and security concepts by picking a question and running it

Fundamentals

Before looking at how a concept behaves in detail, these labs show what the concept looks like in code and what happens without it.

Java

• Variables and types — What is a variable, and what does a type decide?
• Methods — What is a method, and how is declaring it different from calling it?
• Classes and objects — How is a class different from an object?
• References — What does it mean to store an object in a variable?
• null — What is null, and why does NullPointerException happen?
• Constructors — What is a constructor, and when does it run?
• static — What is static, and what changes when you add it?
• Inheritance — What does a class inherit through extends?
• Interfaces — What does an interface look like in code, and what does it decide?
• Exceptions — What is an exception, and what does try-catch do?
• Generics — What does the <String> in List<String> do?
• List and Map — What do List and Map hold, and how do you get things out?
• Lambdas — What is a lambda a shorter way to write?
• Streams — What is a stream, and how is it different from a for loop?
• Annotations — What is an annotation, and what happens when you add one?
• Threads — What is a thread, and what does start() do?
• Locks (synchronized) — What is a lock, and what happens without one?
• Thread pools — What is a thread pool, and how is it different from creating a thread every time?
• Compilation and the JVM — How does Java code run?
• File I/O — What do you exchange when you write to and read from a file?
• Libraries and dependencies — What is a library, and what happens when it is missing?

Spring

• Beans — What is a bean, and how does it differ from an object you just created?
• Dependency injection — What does dependency injection do for you?
• AOP and proxies — What is a proxy, and how does Spring step in before and after my method?
• Servlets — Which class is called a servlet?
• Controllers — Which class is called a controller?
• Configuration files — What is a configuration file, and how is it different from writing values in the code?
• JDBC — How does Java code send SQL to the database?
• @Transactional — What does @Transactional group together?
• Spring Boot — What does Spring Boot do for you?
• Test code — What is test code, and who decides whether a test passes or fails?

JPA

• Entities — What is an entity, and how does it differ from an ordinary class?
• Persistence context — What is a persistence context, and what does it do for you?
• Repositories — What is a repository, and who creates the implementation?
• Associations — What is an association, and what does @ManyToOne do for you?
• Lazy fetching — When is an associated object read from the database?
• JPQL — What is JPQL, and how is it different from SQL?

Database

• Tables, rows, and columns — What does a table look like, and what are rows and columns?
• Primary keys — What is a primary key, and what changes without one?
• Foreign keys — What is a foreign key, and what changes without one?
• WHERE — What does WHERE decide, and what happens without it?
• Joins — What does a join attach, and what does ON decide?
• GROUP BY and aggregation — What does GROUP BY group, and what do COUNT and SUM count?
• Indexes — What is an index, and what changes when there is none?
• Transactions — What does a transaction group together, and what do COMMIT and ROLLBACK do?
• Row locks — What happens when two transactions try to change the same row?
• Storage and durability — Does committed data stay after the server is turned off?

Networking

• IP addresses and ports — What do an IP address and a port each point to?
• TCP connections — What does it mean to open a connection, and what happens if you send without one?
• URLs — What parts is a URL made of?
• DNS — What does DNS turn a name into?
• HTTP requests — What does an HTTP request look like as text?
• HTTP methods — How is GET different from POST?
• HTTP responses — What does an HTTP response look like as text?
• Cookies — What is a cookie, and who stores it and who sends it?
• JSON — What does JSON look like, and what mistakes make it unreadable?
• HTTPS — How is HTTPS different from HTTP?
• Proxy servers — What is a proxy server, and what changes when it sits in between?

Security

• Authentication and authorization — How are authentication and authorization different?
• Sessions — What is a session, and where is the logged-in state remembered?
• Tokens — What is a token, and what does the server look at to trust it?
• Hashing — What is a hash, and why do we store passwords as hashes?
• Encryption — What is encryption, and what happens without the key?
• Origins — What is an origin, and why does the browser tell different origins apart?
• Input and injection — What happens when text typed by a user is read as code?

Architecture and operations

• Processes — What is a process, and what is separate when you run a program twice?
• Calling another server — How is a server calling another server different from calling a method?
• Load balancers — If you run several servers, which server does a request go to?
• Caches — What is a cache, and what do you gain and lose by using one?
• Message queues — What is a message queue, and how is it different from calling a server directly?
• Deployment — When does a running server change after you edit the code?
• Git commits and branches — What is a commit, and what does a branch point to?

Java

From syntax to object-oriented programming, collections, threads, and the JVM. See what happens inside when code runs.

Basic syntax

• Variables and types — What is copied when you assign one variable to another?
• Operators and type conversion — Why is 7 / 2 equal to 3 and not 3.5?
• Conditionals and loops — How many times does a loop run, and where does it stop?
• Arrays — Does assigning an array variable copy the array?

Classes and objects

• Classes, objects, and constructors — What happens, and in what order, when you use new?
• static and instance — Why does the value of a change when only b was touched?
• Inheritance and overriding — When does the superclass constructor run when a subclass object is created?
• Polymorphism and method selection — Who decides which method runs, and when?
• Interfaces and abstract classes — Neither can be created with new, so how do they differ?
• Access modifiers and encapsulation — How far do private, protected, and public open up access?
• Inner classes and anonymous classes — How is a class declared inside a class connected to the outer object?
• Immutability and defensive copies — The field is final, but its value changed
• Strategy pattern — What you have to change when one more payment method is added

Commonly used classes

• == and equals — Why is == false when the values are the same?
• equals and hashCode — Why can HashMap not find the key when you override only equals?
• String, StringBuilder — Why is the original unchanged after you call a string method?
• Dates and times — What date do you get when you add one month to January 31?
• Optional — Why does the default-value code in orElse run even when a value is present?

Exceptions

• Exceptions and finally — When an exception is thrown, which blocks run, and in what order?
• Checked and unchecked exceptions — Why do some exceptions keep the code from even compiling unless you handle them?

Generics, enums, and annotations

• Generics — What does the <Integer> in List<Integer> protect you from?
• Enum classes — Why does an enum saved as a number come back as a different constant?
• Annotations — What really happens when you just add an annotation with @?

Collections

• ArrayList and LinkedList — The same operation takes a different amount of work
• Inside HashMap — Where does a HashMap put a key, and how does it find it?
• Kinds of Set and Map — Why do the same values come out in a different order?
• Stack, queue, priority queue — Insertion order and removal order
• Removing during iteration — What happens when you remove elements inside a loop
• Sorting and Comparator — Who decides the sort order, and why is comparing by subtraction wrong?

Lambdas and streams

• Lambda expressions and functional interfaces — When does the code in a lambda expression run?
• Lazy evaluation in streams — A stream does not run in the order in which it is written
• Collecting a stream — Into what shape do you collect the result of a stream?
• Parallel streams and the common pool — Someone else's parallel stream slows down my code

Threads and concurrency

• Processes and threads — Two ways to add more workers
• Creating threads and thread states — Why does calling run() directly not create a new thread?
• Race condition — Why does count++ lose increments?
• Deadlock — Two threads wait for each other, and both stop
• Thread pool — What changes when you add more threads
• Thread count and context switching — Adding threads does not keep making things faster
• Sequential and parallel calls — Several external calls: one after another, or all at once?
• Blocking, non-blocking, and virtual threads — What a thread does while it waits

JVM

• Stack and heap — What happens in memory each time a method is called
• GC and memory leaks — Who reclaims discarded objects, and when?
• JIT warmup — Why are the first requests right after a deployment slow?
• Class loading and initialization — When does the static initializer of a class run?

I/O

• I/O streams and buffers — I called write, so why is the file empty?
• Serialization — What comes back when you restore a saved object?

Spring

The container and dependency injection, AOP and transactions, the path a web request takes, and what Spring Boot does for you.

IoC container and DI

• The Spring container and beans — You never wrote new, so who creates the object and passes it in?
• Bean creation and injection — In what order does Spring create objects and wire them together?
• Singleton beans and state — My order shows someone else's name
• Bean scopes — It is a prototype bean, so why is there only one object?
• Bean lifecycle callbacks — Why is an injected field null when you use it in the constructor?

AOP and proxies

• Proxies and self-invocation — Why does the annotation have no effect?
• AOP: advice and pointcuts — Which methods does advice apply to, and in what order does it run?

Data access and transactions

• Transaction basics — What if the withdrawal went through but the deposit did not?
• Transaction propagation — How far does a rollback reach when an exception is thrown?
• JdbcTemplate and exception translation — What does JdbcTemplate do for you, and what does it translate exceptions to?
• Connection pool and OSIV — Why connections run short even though the queries finish quickly

Web MVC

• Servlets — How an HTTP request reaches Java code
• Spring MVC request flow — How one request reaches the controller, and how it goes back
• Request mapping and parameter binding — How does a value sent in a request become a method parameter?
• Validation — The field has @NotBlank, so why does an empty value still get in?
• REST APIs and message converters — Where does the object returned by a controller become JSON?

Spring Boot

• Spring Boot auto-configuration — Why do beans appear when all you did was add a dependency?
• Configuration precedence — When the same property is set in several places, which value wins?
• Actuator and health checks — What does the health check answer when the connection to the payment provider is lost?

Other features

• Testing — When tests run, what goes into the Spring context, and how many times is it created?
• Calling external APIs and timeouts — When a call to another server gets no answer, how long does it wait?
• Cache abstraction — With @Cacheable on a method, when does the method body not run?
• Security filter chain — Where is it decided whether the response is 401 or 403?

JPA

What it means to store objects in tables: the persistence context, relationships, lazy loading, and when and how many queries are sent.

Getting started

• What JPA solves — When you write the SQL yourself, what do you have to fill in by hand?

Persistence context

• Persistence context — When does JPA send SQL?
• The lifecycle of an entity — Why is the same setName sometimes not applied to the DB?
• Detached entities and merge — Why were other values erased when I only fixed the name with merge?

Entity mapping

• Entity mapping and primary keys — How do the annotations on an entity change the table and the values that are stored?
• Value types and embeddable types — How is a class that groups an address stored in a table, and why make it immutable?

Relationships

• The owning side of a relationship — You added a member to the team's list, so why is the foreign key in the database empty?
• Many-to-one, one-to-many, one-to-one, many-to-many — How do the tables and foreign keys change depending on the kind of relationship?
• Inheritance mapping — In how many tables, and how, are inherited classes stored?
• Cascade and orphan removal — What happens to the children when you save or delete only the parent?

Proxies and fetching

• Proxies and lazy fetching — Is an object received through lazy fetching a real entity?
• N+1 — Why are many queries sent when you load the order list only once?

Queries

• JPQL and fetch joins — What is the difference between join and join fetch?
• Bulk update and delete operations — After one UPDATE changes many rows, why does the entity still have the old value?
• Spring Data JPA — How does a repository work when there is no implementation class?
• Dynamic queries and Querydsl — How do you add a search condition to where only when it is given?

Web applications and performance

• Connection pool and OSIV — Why connections run short even though the queries finish quickly
• Optimistic and pessimistic locking — What if many orders arrive at once for 3 items in stock?
• Querying directly into a DTO — What is the difference between querying entities and copying them, and querying directly into a DTO?

Database

Table design and SQL, indexes and execution plans, transactions and locking, replication and distribution. See how data is stored and read.

Relational model and design

• Tables, keys, and constraints — What data gets in when there are no constraints?
• ER modeling — How do you turn the relationships between entities into tables?
• Normalization — What happens if you do not split the table?

SQL

• SELECT processing order — Why can't you use an alias or an aggregate function in WHERE?
• JOIN and GROUP BY — Do you put the condition in ON or in WHERE?
• Subqueries — Why does NOT IN return no rows at all?
• Window functions — How do you add a rank and a running total without reducing the rows?
• Offset and keyset pagination — Why later pages get slower
• Views, stored procedures, and triggers — Why did the stock go down when you ran one INSERT line?

Indexes and execution plans

• Binary search and B-trees — If the data is sorted, you can discard half at a time
• Indexes and full table scans — Why is the index not used even though it exists?
• Composite and covering indexes — A composite index can be used only in column order
• Reading the execution plan — What should you read in one line of EXPLAIN?
• Join algorithms — How does the database find matching rows when the join column has no index?

Transactions and locking

• Transaction basics — What if the withdrawal went through but the deposit did not?
• Isolation levels — How does data that another transaction is changing look to me?
• Gap locks and next-key locks — Why is an INSERT blocked when I queried a row that does not exist?
• Stock decrement and locks — What if many orders arrive at once for 3 items in stock?
• Deadlocks in the database — When two transactions wait for each other, how does the database end it?

Storage and recovery

• Undo and redo logs — Why does the data survive even if the power goes out right after a commit?
• Buffer pool and pages — Why does reading one row read a whole 16KB page?

Scaling and distribution

• Replication lag and CAP — I just saved it, but the query shows the old value
• Sharding — What happens when you split data across several databases
• Partitioning — When a table is cut into pieces, which pieces does a query read?
• Redis, a key-value store — If one command is slow, everyone waits
• NoSQL and the document model — Split an order into three tables, or put it in one document?

Networking

From typing an address to receiving the response: DNS, TCP, HTTP, TLS, and the machines in between.

The big picture

• From URL to response — What happens when you type a URL in the address bar and press Enter
• Layers and encapsulation — You send 1500 bytes, so why do 1616 bytes cross the wire?

Addresses and names

• URL structure — After I added the search term "A&B" to the URL, the server received only "A"
• DNS — Who knows the IP address of a domain name, and when does a change show up?
• IP addresses and subnets — Are two IP addresses with the same first three numbers on the same network?
• Switches and routers — If the destination IP is the server, why is the frame sent to the router's MAC address?

Transport layer

• Sockets and ports — Of the several programs on one computer, which one receives this data?
• TCP connections and retransmission — When a packet is lost, who notices and sends it again?
• TCP and UDP — If you send data in three pieces, does it arrive in three pieces?
• Flow control and congestion control — How does TCP decide how much to send at a time?

HTTP

• HTTP messages and status codes — This is what a request and a response look like as text
• HTTP/1.1, 2, 3 — What differs between the versions when you fetch 30 files
• Cookies — Showing a name tag, every time, to a server that cannot remember you
• HTTP caching and ETag — Do we have to fetch the same file again?
• Retries and idempotency — No response came back, so the request was sent again
• Redirection — When a server says "go to another address", how does the next request go out?
• Content negotiation and compression — Why do different people get different responses from the same address?
• CORS — Why a request works in Postman but is blocked only in the browser
• Polling, SSE, and WebSocket — Four ways to tell the browser what happened on the server

Secure connections

• TLS handshake — What happens before the https padlock locks

In front of the web server

• Load balancers and scale out — How far does adding servers get you?
• Proxies and reverse proxies — How does a server behind a proxy know who sent the request?
• CDN — The origin was changed, so why do users still get the old file?

Security

Authentication (who you are), authorization (what you are allowed to do), web attacks and defenses, and cryptography.

Authentication

• Sessions and JWT — Where is the login state stored?
• Cookies — Showing a name tag, every time, to a server that cannot remember you
• Password hashing — How well do passwords hold up when the database leaks?
• JWT structure and verification — How does the server trust a token that anyone can read?
• OAuth login flow — What is exchanged when you click "Log in with Kakao"
• Session hijacking and session fixation — Whoever knows the session ID is that user

Authorization

• Security filter chain — Where is it decided whether the response is 401 or 403?
• Access control — If a logged-in user only changes the number in the URL, can they see someone else's order?
• Method security — When does an authorization check on a method run, and when is it skipped?

Web attacks and defenses

• Three web attacks — What happens when you trust input as it is
• CORS — Why a request works in Postman but is blocked only in the browser
• Clickjacking and open redirects — How do you stop your page from being hidden inside another site's page, or your URL from sending users to another site?
• Information leakage — What do error responses and login failure messages tell the outside world?
• Rate limiting — Three meanings of "accept only 5 requests per second"
• Dependencies and the supply chain — How do libraries I never wrote down get into my program, and who decides their versions?

Cryptography

• Hashing, encryption, and signatures — What hides, what checks, and what cannot be undone
• TLS handshake — What happens before the https padlock locks

Architecture and operations

Topics for when traffic grows, when a system is split into services, and when you deploy and monitor it.

High traffic

• Load balancers and scale out — How far does adding servers get you?
• Caching and TTL — How much does a cache reduce database queries, and when do requests pile up again?
• Redis single-threaded execution — If one command is slow, everyone waits
• Rate limiting — Three meanings of "accept only 5 requests per second"

Messaging and asynchronous processing

• Message queue basics — Leave a note instead of calling directly
• Kafka partitions and consumers — I added consumers, so why is the throughput the same?

Splitting into services

• Circuit breaker — If you keep calling a dead service, you go down too
• Saga and outbox — When every service has its own database, how do you get "all succeed or all cancel"?
• Gateway and gradual migration — Breaking up a huge server piece by piece without stopping it

Deployment and operations

• CI/CD pipelines — You push code, and a machine checks and deploys it for you
• Deployment strategies — How to switch to a new version without interrupting the service
• Containers and virtual machines — Why are containers lightweight and quick to start?
• Kubernetes self-healing — When a container dies, what starts it again?

Observability

• Averages and percentiles — The average response time looks fine, so why do users complain that it is slow?
• Distributed tracing — One request is slow, but which service is to blame?

Collaboration

• Merge and rebase — Three ways to combine two branches