Forge your software development skills.
Practical learning content in Turkish and English.
Java
Java Basics
String
The first topic in the Java Basics category: `String`'s IMMUTABLE design, the string pool and the `==` vs `equals()` trap, the O(n^2) cost of `+` concatenation vs. `StringBuilder`'s amortized O(1) (with a real, warmed-up measurement), `String.format()`/text blocks (Java 15+), and helper methods like split/join/replace/trim/strip.
Arrays
The second topic in the Java Basics category: arrays' fixed-size, contiguous-memory structure, multi-dimensional arrays (including jagged arrays), the `Arrays` utility class (sort/binarySearch/equals/fill/copyOf), array covariance and the `ArrayStoreException` trap, `Arrays.asList()` being a view, and varargs.
Scanner
The third topic in the Java Basics category: `Scanner`'s token-based reading model, the classic `nextInt()` + `nextLine()` trap, custom delimiters via `useDelimiter()`, reading from a `File`, a real performance difference between `Scanner` and `BufferedReader`, and `InputMismatchException`/`NoSuchElementException` exception handling.
Wrapper Classes & Autoboxing
The fourth topic in the Java Basics category: the object counterparts of primitive types (Integer/Double/Boolean, etc.), autoboxing/autounboxing, Integer caching (-128..127) and the `==` trap, why unboxing a null wrapper throws a real NullPointerException, autoboxing's performance cost in tight loops, and how wrapper classes make generic collections possible.
File Reading
The fifth topic in the Java Basics category (the reading half of File I/O): `Path`/`Files` basics, `Files.readAllLines()`/`Files.readString()`, line-by-line reading with `BufferedReader`, `Files.lines()` being lazy and Closeable, searching a file for a word, and the real difference between `NoSuchFileException` and `FileNotFoundException`.
File Writing
The sixth topic in the Java Basics category (the writing half of File I/O): `Files.writeString()`/`Files.write()`, appending with `StandardOpenOption.APPEND`, writing with `BufferedWriter`, copying files with `Files.copy()`, `Files.createDirectories()`, the standard pattern for deleting a directory tree, and writing a CSV file.
Reflection
Accessing and dynamically using class, field, method, and constructor information at runtime in Java.
Date & Time API
The java.time package in Java; LocalDate/LocalTime/LocalDateTime, Instant, ZonedDateTime/OffsetDateTime, Duration/Period/ChronoUnit, formatting/parsing, time zones, and migrating from legacy Date/Calendar.
Exceptions
Introduction to Exceptions
What an exception actually is -- why it exists (the problems with return-value-based error signaling), a short history of Java's checked exception design decision, the message/cause/stack trace an exception object carries, what happens when an exception goes uncaught, reading a stack trace and propagation, and the common runtime exception triggers (NullPointerException, ArrayIndexOutOfBoundsException, NumberFormatException). The first of 7 lessons in this series -- try/catch mechanics come next.
Try-Catch and Finally
The actual mechanism for handling an exception: the basic try-catch block, multiple catch blocks (matching in order, the superclass/subclass ordering restriction), multi-catch with | (Java 7+), finally running unconditionally every time, and how a return/throw inside finally silently overrides whatever try/catch was about to produce. The 2nd lesson in the Exception Handling series.
Exception Hierarchy
The inheritance relationship between Throwable, Error, Exception, and RuntimeException -- how every exception descends from a single shared root, how a catch block can target any ancestor of a type (polymorphic catching), and how to query that hierarchy at runtime with instanceof. The 3rd lesson in the Exception Handling series.
Checked vs Unchecked Exceptions
The difference between a checked exception's compiler-enforced throws/catch contract and an unchecked exception's (the RuntimeException family) complete lack of that requirement -- when to choose which, wrapping a checked exception as unchecked with the cause parameter, and the restriction that an overriding method's throws declaration can only be NARROWED. The 4th lesson in the Exception Handling series.
Throw and Throws
The difference between the throw statement handing a Throwable instance to the JVM at runtime and the throws declaration being a purely compile-time contract -- fail-fast validation, rethrowing a caught exception as a different type with the cause parameter, and a checked exception propagating unhandled through a call chain. The 5th lesson in the Exception Handling series.
Creating and Throwing Custom Exceptions
Defining your own exception type by extending Exception (checked) or RuntimeException (unchecked) -- adding fields that carry extra context, mirroring Throwable's four standard constructors, and building your own small exception hierarchy with a shared custom base class. The 6th lesson in the Exception Handling series.
Exception Handling Best Practices
Practices built on top of the previous six lessons' mechanics -- the anti-patterns of using exceptions for control flow and swallowing them, catching in the right order from specific to broad, and only catching where a genuinely useful response is possible. The 7th and final lesson in the Exception Handling series, closing with a recap of the whole series.
Generics
Introduction to Generics
Why generics exist (the pre-generics raw type/cast/ClassCastException problem), how type safety is enforced at compile time, generic classes and interfaces, and the type parameter naming convention. The 1st lesson in the Generics series.
Generic Methods
Generic methods that declare their own type parameter independent of whether their class is generic -- method type parameters, multiple type parameters, type inference, and explicit type witnesses. The 2nd lesson in the Generics series.
Bounded Type Parameters
Upper bounds (`<T extends ...>`), multiple bounds joined with `&`, bounding with classes and with interfaces, and how bounding a type parameter expands which methods can be called on it. The 3rd lesson in the Generics series.
Wildcards
The unbounded wildcard (`<?>`), the upper bounded wildcard (`<? extends T>`), the lower bounded wildcard (`<? super T>`), the difference between the three, and the PECS (Producer Extends, Consumer Super) rule -- the most commonly misunderstood part of Java generics, walked through step by step with real examples. The 4th lesson in the Generics series.
Generics with Collections
Generic collections like List<T>, Set<T>, and Map<K,V>, type safety with collections, why List<Object> is NOT List<String> (the full treatment of generics invariance), and type inference with the diamond operator and var. The 5th lesson in the Generics series.
Type Erasure and Generic Limitations
What type erasure is, what happens to generic types at runtime, why `new T()` and generic arrays aren't allowed, static members and generics, and how generics' runtime limitations actually surface in practice (raw types, unchecked warnings, heap pollution). The 6th and final lesson in the Generics series.
Control Flow
if / else
The first topic in the new Control Flow category: the basics of `if`/`else`, `else if` chains, nested conditions, the six comparison operators (`==`/`!=`/`<`/`>`/`<=`/`>=`) with decimal number and `String` comparison pitfalls, the `&&`/`||`/`!` logical operators and short-circuit evaluation, and the ternary operator.
switch
The second topic in the Control Flow category: classic `case`/`break` syntax and the fall-through trap, the modern arrow (`->`) syntax, switch EXPRESSIONS and `yield`, multiple labels with enum exhaustiveness checking, and using `switch` with `String`/enum.
for Loop
The third topic in the Control Flow category: the classic three-part (init;condition;update) `for` syntax, exiting early with `break`, skipping a step with `continue`, deliberate/unintentional infinite loops, multiple variables via comma-separated init/update, and classic index-based array iteration.
Enhanced for Loop
The fourth topic in the Control Flow category: the for-each syntax over arrays/collections, its three real limitations (no index access, the loop variable being a copy plus structural changes throwing ConcurrentModificationException, and no parallel iteration of multiple collections), and when to use it versus classic `for`.
while & do-while Loops
The fifth topic in the Control Flow category: basic `while` syntax, `do-while`'s run-at-least-once body, while vs do-while comparison, break/continue, a Scanner-based input validation loop, and a worked example: the Number Guessing Game.
Nested Loops
The sixth and final topic in the Control Flow category: basic nested for loops, 2D array traversal, how unlabeled break/continue only affect the innermost loop, labeled break/continue, and O(n²) performance awareness.
Collections
Lists
The first topic in the Collections category: the `List` interface, the performance difference between `ArrayList` and `LinkedList` shown with a real warmed-up measurement, immutable lists via `List.of()`/`Collections.unmodifiableList()`/`List.copyOf()`, safe iteration with `Iterator`/`ListIterator`, sorting with `List.sort(Comparator)`, and `subList()`/`toArray()`.
Sets
The second topic in the Collections category: the `Set` interface and its no-duplicates guarantee, the differences between `HashSet`/`LinkedHashSet`/`TreeSet`, `NavigableSet` methods, why the `equals()`/`hashCode()` contract is critical for `HashSet` (with a real bug example), set operations (union/intersection/difference), and a real performance measurement comparing List/HashSet/TreeSet.
Maps
The third topic in the Collections category: the `Map<K,V>` interface (each key once, mapped to a value), the differences between `HashMap`/`LinkedHashMap`/`TreeMap`, `NavigableMap` methods, immutable maps (`Map.of()`/`Map.copyOf()`), Java 8's modern API (`getOrDefault()`/`computeIfAbsent()`/`merge()`), and a real performance measurement comparing `entrySet()` and `keySet()+get()`.
Queues & Collections Utility
The final topic in the Collections category: the `Queue`/`Deque` interfaces (offer()/poll()/peek() vs add()/remove()/element()), why `ArrayDeque` is preferred over `LinkedList`/`java.util.Stack` as both a queue and a stack, a real discovery that `PriorityQueue` is heap-based and its toString() is NOT sorted, and the `Collections` utility class's static methods like sort/shuffle/max/binarySearch.
Object-Oriented Programming
Interface
Defining behavior contracts in Java; default/static/private methods and sealed interfaces.
Abstract Class
Abstract classes that share common state and behavior in Java; constructors, the Template Method pattern, and abstract class vs interface.
Inheritance
Inheritance in Java; extends, the constructor chain, method overriding, field hiding, upcasting/downcasting, and composition vs inheritance.
Polymorphism
Polymorphism in Java; method overloading, overload resolution rules, covariant return types, polymorphism vs inheritance, and the Strategy pattern via composition.
Concurrency
Threads
Threads in Java; creating threads (Thread/Runnable), the thread lifecycle, thread methods, race conditions, synchronized, volatile, wait/notify, Atomic classes, ReentrantLock, and deadlock.
Functional Interfaces & Streams
Lambda Expressions
The full syntax of lambda expressions: parameter-writing rules, expression body vs. block body, the compiler inferring a lambda's type from context (target typing), capturing effectively final variables, and how a lambda differs from an anonymous inner class.
Built-in Functional Interfaces
The ready-made interfaces in java.util.function: Predicate<T>, Function<T,R>, Consumer<T>, Supplier<T>, UnaryOperator<T>, BinaryOperator<T>. The four method reference forms: Class::staticMethod, object::instanceMethod, Class::instanceMethod, Class::new.
Stream API Fundamentals
The fundamentals of the Stream API: what a Stream is, moving from a Collection to a Stream, the three stages of a pipeline (source/intermediate/terminal). Intermediate operations: filter(), map(), flatMap(), distinct(), sorted(), peek(), limit(), skip(). Lazy evaluation and a stream's single-use nature.
Terminal Operations
The terminal operations that trigger a stream pipeline and produce a result: forEach(), reduce(), count(), min()/max(), findFirst()/findAny(), anyMatch()/allMatch()/noneMatch(), toList()/toArray(). Short-circuiting behavior and count()'s source-size optimization.
Collectors
The ready-made collect() recipes the Collectors class offers: toList()/toSet(), joining(), groupingBy() (with counting()/mapping() as downstream collectors), partitioningBy(), toMap(). The three parts of a Collector: supplier, accumulator, combiner.
Optional
Optional<T>: expressing the possibility of an absent value in the type system. Creating with of()/ofNullable()/empty(), orElse() vs. orElseGet() (eager vs. lazy), orElseThrow(), map()/flatMap(), ifPresent()/ifPresentOrElse(), filter().
Primitive & Parallel Streams
Avoiding autoboxing cost with IntStream/LongStream/DoubleStream, the boxed()/mapToInt() bridges. Running in parallel with parallelStream(), the forEach() vs. forEachOrdered() ordering difference, a non-thread-safe shared state pitfall, when to use it, and why it is not always faster.
Spring Boot
Spring Core
Dependency Injection & IoC
Inversion of Control, Dependency Injection, and constructor/setter/field injection in plain Java -- no Spring required.
Spring IoC Container & Bean Lifecycle
BeanFactory/ApplicationContext, the bean lifecycle, @PostConstruct/@PreDestroy, bean scopes, @Lazy, and resolving circular dependencies.
Component Scanning & Configuration
@Component/@Service/@Repository/@Controller stereotypes, @ComponentScan, @Autowired (field/setter/constructor), @Qualifier, and @Primary.
Spring Boot Auto-Configuration & Properties
@SpringBootApplication, the @Conditional family (@ConditionalOnClass/@ConditionalOnMissingBean/@ConditionalOnProperty), @Value, @ConfigurationProperties, @Profile, and ApplicationEvent/@EventListener.
Transaction Management
The proxy-based mechanism behind @Transactional, rollback rules, propagation (REQUIRED/REQUIRES_NEW), the self-invocation pitfall, isolation levels, readOnly, TransactionTemplate, and @TransactionalEventListener.
Spring MVC
Spring MVC Fundamentals
DispatcherServlet, the MVC pattern (Model/View/Controller), and the difference between @Controller and @RestController.
Mapping Annotations & HTTP Methods
@RequestMapping and its five shortcuts (@GetMapping/@PostMapping/@PutMapping/@PatchMapping/@DeleteMapping), consumes/produces, and the safe/idempotent semantics of HTTP methods.
Path Variables & Request Parameters
Reading data from a request's URL and headers with @PathVariable, @RequestParam, and @RequestHeader; the difference between a path variable and a query parameter.
Request and Response Handling
Turning a request body into an object with @RequestBody, taking full control of a response with ResponseEntity, HTTP status codes, and content negotiation.
Validation & Exception Handling
Bean Validation (@NotBlank, @Size, @Email, @Pattern) with @Valid, cascading for nested objects, @ExceptionHandler, @RestControllerAdvice, and standardized error handling with RFC 7807 ProblemDetail.
Spring MVC Views and Thymeleaf
Three ways to carry data to the view with Model, ModelMap, and ModelAndView; Thymeleaf's "natural templating" philosophy; Thymeleaf variable/link/message expressions (@{...}, #{...}, and dollar-brace variable access); th:if, th:each, th:fragment; SpringEL selection expressions (.?[...] / #vars); and MVC vs. REST, with reference to this project's own layout.
Advanced Spring MVC
HandlerInterceptor (preHandle/postHandle/afterCompletion) and the Filter vs. Interceptor distinction; registering interceptors and configuring global CORS with WebMvcConfigurer; same-origin policy, the preflight request, and @CrossOrigin; file uploads with MultipartFile and size limits.
REST API Design
The risks of returning an entity directly and the DTO pattern; pagination, sorting, and filtering with Pageable/Page/Sort and query parameters; URI versioning vs. header versioning; idempotency and making POST idempotent with the Idempotency-Key header; HATEOAS (a quick look).
Testing in Spring MVC
Web layer tests with MockMvc and @WebMvcTest; faking dependencies with @MockitoBean; verifying with model(), view(), and jsonPath(); testing request bodies, path variables/query params, validation errors, and multipart uploads; real tests of this project's own HomeController and TopicController.
Microservices
Microservices Fundamentals
The limits of monolithic architecture, the core characteristics of microservice architecture, defining service boundaries (bounded context), database per service, and a quick look at the CAP theorem and Conway's Law -- a conceptual introduction with no code.
Microservice Configuration
Configuring a single Spring Boot microservice (order-service) from the ground up: its own entry point, its own application.yml (port, application name, database), a REST controller as the API contract, the service layer, the domain model, and a health check.
Inter-Service Communication
Adding a second microservice (inventory-service) next to order-service and connecting the two with a synchronous REST call via Spring's RestClient: stock checking, error handling (what happens when a service is down), and separating DTOs between services. Links to the category's real, runnable Practical Project.
Service Discovery & Eureka
order-service now finds inventory-service by NAME instead of a hardcoded URL: the Eureka Server (a central registry), the Eureka Client (spring.application.name becoming the discovery key), direct queries with DiscoveryClient, calling by name with a @LoadBalanced RestClient, heartbeats/eviction/self-preservation mode, and why Eureka picks the AP side of the CAP theorem.
API Gateway
order-service and inventory-service becoming reachable to external clients through a single entry point: setting up a separate api-gateway application with Spring Cloud Gateway, the route predicate/URI/filter trio, discovery-based routing through Eureka with lb://, writing a custom GlobalFilter (the course's first reactive code), and why system-wide concerns like correlation ids belong at the gateway while business logic stays in the service.
Resilience4j
Taking order-service's inventory-service calls beyond manual try/catch error handling: applying Resilience4j's @CircuitBreaker (a CLOSED/OPEN/HALF_OPEN state machine) and @Retry annotations to ResilientStockClient, what fallback methods do when the circuit opens, why Spring's proxy mechanism doesn't work through self-invocation, and how a rate limiter/bulkhead protects against a different risk than a circuit breaker.
Configuration Management
Centralizing configuration every service has kept in its own application.yml so far, using Spring Cloud Config: setting up a separate config-server application with @EnableConfigServer, a Config Repository deciding what's genuinely worth centralizing, becoming a Config Client with spring.config.import, environment-specific overrides through profiles, refreshing configuration without a restart via @RefreshScope, and why secrets should never be stored in plain text.
Event-Driven Architecture & Kafka
Removing the time-coupling and direct-knowledge-coupling created by every inter-service call in this category being synchronous so far, using Kafka: topic/partition concepts, order-service publishing OrderPlacedEvent with KafkaTemplate, inventory-service reacting with @KafkaListener, when to choose synchronous vs. asynchronous, why at-least-once delivery requires every consumer to be idempotent, and the JSON serialization choice.
Distributed Transactions
Closing the gap the Event-Driven Architecture & Kafka lesson deliberately left open -- what happens to an order order-service already committed if inventory-service can't reserve stock: why Two-Phase Commit is rare in microservices, the Saga pattern (local transactions plus compensating actions), building a two-way saga flow with choreography and StockReservationFailedEvent, why compensation isn't a rollback, and how the Outbox pattern closes the risk of an event never being published.
Observability
Closing two threads the API Gateway and Resilience4j lessons deliberately left open: actually propagating the correlation id into order-service's own logs (MDC) and its outgoing calls to inventory-service, structured (JSON) logging, metrics with Micrometer/Actuator, how distributed tracing builds on the same correlation id concept, and how Resilience4j already integrates with Micrometer automatically.
Security
Closing the unconditional trust every lesson in this category has assumed so far: introducing Spring Security into the course for the first time, the authentication vs. authorization distinction, JWT's self-contained nature, validating JWTs INDEPENDENTLY at both api-gateway and order-service (zero trust), role-based authorization, and propagating identity across services the same way the correlation id already is.
Deployment
How this category's localhost assumption, present in every lesson so far, actually gets deployed in the real world: small images with multi-stage Dockerfiles, orchestrating the whole system (eureka-server, config-server, api-gateway, order-service, inventory-service, Kafka) in one docker-compose file, environment-variable configuration in containers, why depends_on isn't enough without a health check, and a brief, honest look at Kubernetes.
Advanced Spring
Java Bean Validation
Builds on Spring MVC's "Validation & Exception Handling" lesson -- sign constraints (@Positive/@PositiveOrZero/@Negative/@NegativeOrZero), date/time constraints (@Past/@Future/@PastOrPresent/@FutureOrPresent), precise decimal bounds (@DecimalMin/@DecimalMax/@Digits), customizing validation messages, custom constraint annotations with ConstraintValidator for cross-field validation, and validation groups. The 1st lesson in the Advanced Spring series.
Exception Handling
Builds on Spring MVC's "Validation & Exception Handling" and this category's "Java Bean Validation" -- what MethodArgumentNotValidException actually carries, turning validation failures into a ProblemDetail (including cross-field failures), custom ProblemDetail properties, mapping domain exceptions to the right HTTP status code (400/404/409/422/500), centralizing with ResponseEntityExceptionHandler, and safe error responses that don't leak internal details. The 2nd and final lesson in the Advanced Spring series.
Task Execution & Scheduling
Builds on the thread-pool foundation "Threads" covers at the language level -- Spring's TaskExecutor abstraction, background work with @Async and @EnableAsync, why self-invocation breaks @Async (the SAME proxy pitfall as "Transaction Management"), scheduling with @Scheduled's fixed rate/fixed delay/initial delay/cron expressions, and configuring scheduling's own separate thread pool (TaskScheduler). The 3rd lesson in the Advanced Spring series.
Spring Batch
Why large-scale batch processing needs a structure `@Scheduled` alone can't provide -- the Job/Step/chunk-oriented processing mental model, ItemReader/ItemProcessor/ItemWriter through a single CSV-to-database order import example, the JobParameters/JobInstance/JobExecution distinction, restartability via the JobRepository, skip/retry fault tolerance, and practical integration with `@Scheduled`. The 4th lesson in the Advanced Spring series.
Spring Data JPA
JPA, Hibernate, and Spring Data JPA
Starting from the problem of persisting a Java object into a database, this lesson builds the ORM → JPA (specification) → Hibernate (implementation) → Spring Data JPA (repository abstraction) → Spring Boot (auto-configuration) mental model using this project's own Topic/TopicRepository classes. The 1st lesson in the Spring Data JPA category.
Entities and the Repository Abstraction
@Entity/@Id/@GeneratedValue/@Column mapping, plus @Table/@Enumerated/nullable-unique constraints/the no-args-constructor requirement/entity vs. DTO/equals()-hashCode() (concisely), and what each tier of the Repository → CrudRepository → PagingAndSortingRepository → JpaRepository hierarchy actually contributes -- using this project's own Topic/Category/TopicRepository classes. The 2nd lesson in the Spring Data JPA category.
Query Methods and JPQL with @Query
How Spring Data JPA derives a query from a repository method's name (findBy/existsBy/countBy, And/Or/OrderBy), writing JPQL with @Query and named parameters, @Modifying for bulk updates/deletes, join fetch, and when to reach for a native query -- using this project's own real repositories. The 3rd lesson in the Spring Data JPA category.
Pagination, Sorting, and Projections
How the Pageable/Sort "REST API Design" resolves at the controller level actually becomes a real LIMIT/OFFSET plus count query at the repository level, sorting with findAll(Sort)/derived methods, and interface-based and record/constructor-expression projections that return only the fields a query needs instead of a whole entity -- using this project's own Topic/TopicTranslation classes. The 4th lesson in the Spring Data JPA category.
Dynamic Queries with Specifications
Delivers on the optional filtering "REST API Design" left in memory, pushing it into the database -- the Specification interface as a thin wrapper around JPA's own Criteria API (Root/CriteriaQuery/CriteriaBuilder/Predicate), JpaSpecificationExecutor, combining conditions with Specification.where/and/or, and combining with real pagination via findAll(Specification, Pageable) -- using this project's own Topic entity. The 5th lesson in the Spring Data JPA category.
Relationships, Fetching, and the N+1 Problem
@OneToMany/@ManyToMany mapping (beyond the @ManyToOne already covered in full in "Transaction Management"), cascade types (PERSIST/MERGE/REMOVE/ALL) and orphanRemoval, a concrete demonstration of the N+1 problem, and three different fixes with @EntityGraph/batch fetching/projections -- using this project's own Topic/Category/QuizQuestion classes. The 6th lesson in the Spring Data JPA category.
The Persistence Context and Locking
Why dirty checking, already covered in full in "Transaction Management," actually works -- the persistence context itself, entity lifecycle states (transient/managed/detached/removed), the first-level cache, persist/merge/detach, flush timing -- and what happens when two transactions touch the same row: optimistic locking with @Version, pessimistic locking with @Lock. The 7th lesson in the Spring Data JPA category.
Auditing in Spring Data JPA
Starting from this project's own real QuestionIngestService's hand-written LocalDateTime.now() pattern, this lesson covers @CreatedDate/@LastModifiedDate, wiring @EntityListeners(AuditingEntityListener.class) + @EnableJpaAuditing together, @CreatedBy/@LastModifiedBy, AuditorAware<T>, and sharing audit fields with @MappedSuperclass. The 8th lesson in the Spring Data JPA category.
Testing Spring Data JPA Repositories
@DataJpaTest and TestEntityManager, only named in "Testing in Spring MVC" -- closing the gap this project's own Mockito-mocked service tests leave open (nothing verifies a query actually works); testing a derived query method and a custom @Query, and embedded test database vs. real PostgreSQL vs. Testcontainers, grounded in this project's own application-test.yml comment. The 9th and final lesson in the Spring Data JPA category.
React
React Fundamentals
What Is React?
What React is, why it exists, the difference between a library and a framework, what an SPA is, and where React is used -- in plain language, with no code yet.
Creating a React Application
Node.js and npm, creating a new project with Vite, project structure, package.json, npm run dev, and the difference between development and production.
JSX
What JSX is, how it differs from HTML, embedding JavaScript with curly braces { }, attributes and className, JSX rules, and a quick look at conditional rendering.
Components & Props
Components
What a component is, how to write one as a function, how to use (render) it, the naming rule, and reusability -- with simple examples.
Props
What props are, sending data from parent to child, using multiple props, destructuring, default values, and how props differ from regular function parameters.
Component Composition
The children prop, nesting components, and the difference between composition and inheritance -- with a reusable Card component mini project.
State & Events
Events
React's event system -- onClick, defining event handlers, onChange, onSubmit, and the event object -- with simple examples.
State
What state is, how to define it with useState, how to update it, updating based on the previous state, and state immutability -- with simple examples.
Conditional Rendering
Showing different UI based on a condition with if, a ternary (? :), and the && operator, and returning different components based on a condition -- with simple examples.
Lists & Keys
Rendering a list with map(), what the key prop is, why it matters, and the most common mistake -- using the index as the key -- with simple examples.
Hooks
What Are Hooks?
What a hook is, why hooks exist, the Rules of Hooks, and their relationship to function components -- with simple examples.
useEffect
What a side effect is, how to run one with useEffect, the three uses of the dependency array, the cleanup function, and the common infinite loop mistake -- with simple examples.
useRef
DOM references, persistent values across renders, useRef vs useState, and using useRef together with useEffect -- with simple examples.
useMemo & useCallback
What memoization is, caching a calculation's result and an object reference with useMemo, caching a function reference with useCallback, and when NOT to use them -- with simple examples.
Custom Hooks
What a custom hook is, the use prefix and naming rule, using the same hook more than once, and a useFetch example -- with simple examples.
Forms
Controlled Components
What a controlled component is, binding an input to state with value and onChange, using the same pattern for checkboxes/selects -- with simple examples.
Form Handling
Submitting a form with onSubmit, managing multiple fields with a single state object, validation, and displaying error messages -- with simple examples.
Routing
React Router Basics
Adding page navigation to a React app with react-router -- BrowserRouter, Routes, Route, Link, NavLink, and a Not Found page for undefined URLs, with simple examples.
Route Parameters & Navigation
Putting variable values inside a URL (route parameters), reading them with useParams, building nested routes with Outlet, and programmatic navigation with useNavigate -- with simple examples.
API & Data Fetching
Fetching Data
Fetching and sending data to a server in React with fetch -- GET, POST, PUT, DELETE, loading and error handling, with simple examples.
React + REST API
Connecting React to a REST API -- separating the API layer into an api.js module, managing listing, creating, and deleting together, with simple examples.
State Management
Sharing State
Situations where more than one component needs the same state -- lifting state up and the props drilling problem, with simple examples.
Context API
React's built-in solution to props drilling -- createContext, useContext, Provider, and wrapping context in a custom hook, with simple examples.
Advanced React
React Performance
Preventing unnecessary re-renders with React.memo, useMemo, and useCallback, and measuring render times with React's Profiler component -- with simple examples.
Error Boundaries
Class components that catch errors during rendering in React: getDerivedStateFromError, componentDidCatch, the scope of error boundaries, and what they don't catch, with simple examples.
Lazy Loading & Code Splitting
Loading components later with React.lazy, route-based code splitting, using lazy with named exports, and conditional lazy loading -- with simple examples.
Suspense
Suspense's fallback prop, nested Suspense boundaries, integrating Suspense with React 19's use() hook, and what Suspense doesn't do automatically -- with simple examples.
Portals
Rendering components to a different DOM node with react-dom's createPortal -- modals, event bubbling behavior, and setting up a portal target, with simple examples.
Testing
Component Testing
Setting up Vitest and React Testing Library, your first test with render+screen, querying with getByRole/getByLabelText, jest-dom matchers, and testing conditional rendering -- with simple examples.
User Interaction Testing
Realistic interaction simulation with user-event, testing clicks and typing, verifying form submission with vi.fn(), and testing asynchronous UI updates with findBy* -- with simple examples.
Production
Build & Deployment
Making a production build with npm run build, environment variables in Vite (VITE_ prefix, .env), and deploying a fully static React app to Vercel -- with simple examples.
React + Spring Boot Deployment
Deploying React to Vercel, a real Spring Boot REST API to Render (Docker), managing the backend address with environment variables, and production CORS configuration -- with simple examples.
Artificial Intelligence
AI Fundamentals
What Is Artificial Intelligence?
A clear map of what AI actually means -- narrow vs. general AI, how it differs from traditional software, and where Machine Learning, Deep Learning, and Generative AI fit.
Machine Learning
What Machine Learning actually is -- the difference between training and inference, the three types of learning (supervised, unsupervised, reinforcement), and how overfitting and underfitting can make training go wrong.
Deep Learning
How neural networks are structured -- layers, weights, activation functions -- how training works via backpropagation, and a brief look at CNN/RNN/transformer architectures.
Generative AI
How Generative AI differs from discriminative models, how text/image generation actually works, a preview of Large Language Models, and the critical distinction between fluency and correctness.
Large Language Models
How Large Language Models Work
What an LLM mechanically is, pretraining and knowledge cutoff, the difference between base and instruction-tuned models, and a first look at in-context learning and context.
Tokens and Context Windows
What tokens and tokenization are, the hard limit of the context window, what happens when context fills up, and truncation/summarization/retrieval strategies for managing limited context.
Prompting and Prompt Engineering
Prompt structure (system/user/assistant roles), zero-shot and few-shot prompting, effective prompt-writing practices, and an introduction to common techniques like chain-of-thought.
LLM Capabilities and Limitations
What LLMs are genuinely strong at, why hallucination happens, the effect of knowledge cutoff, reasoning limits, and how bias in training data gets reproduced.
Tools & MCP
Tools and Function Calling
The tool use / function calling mechanism that lets an LLM request real code execution: the tool-calling loop, defining a tool, and how tool use differs from an "agent."
Introduction to MCP
What the Model Context Protocol (MCP) is, the N x M integration problem it solves, the host/client/server roles, and the tools/resources/prompts primitives a server can expose.
MCP Architecture
The JSON-RPC 2.0 message format MCP uses, the stdio and Streamable HTTP transports, the initialize/discover/invoke connection lifecycle, and capability negotiation.
Building an MCP Server
Building a real, runnable MCP server and client with the official TypeScript SDK: project setup, defining tools with registerTool, connecting over an in-memory transport, and real output.
AI Agents
What Is an AI Agent?
What defines an AI agent: the observe-decide-act loop, how it differs from a single tool call, and the autonomy spectrum.
Agent Planning and Reasoning Patterns
Concrete patterns for an agent's "decide" step: ReAct, plan-and-execute, reflection, and when a loop should actually stop.
Controlling Agent Behavior
The guardrails that make running an agent loop safe: step limits, human-in-the-loop approval, least privilege, and observability.
Building an AI Agent in TypeScript
Build a real, running agent loop: a deterministic, explicitly simulated decision step genuinely calling the real MCP tools from "Building an MCP Server."
AI Development Tools
AI-Assisted Software Development with Claude Code
Analyze, plan, implement, test, and review a real Spring Boot feature in a real Claude Code terminal session: Plan Mode, the permission model, and bugs actually caught along the way.
PostgreSQL
PostgreSQL Foundations
PostgreSQL and the Relational Model
What a relational database actually is, what PostgreSQL is specifically, the Spring Boot → Spring Data JPA → Hibernate → SQL → PostgreSQL stack, and how a call to this project's own real TopicRepository travels through it -- no SQL syntax yet, just the mental model. The 1st lesson in both the PostgreSQL course and its PostgreSQL Foundations category.
Connecting to PostgreSQL: psql and a Real Spring Boot DataSource
Run PostgreSQL locally with Docker, connect directly with psql, and see what this project's own Spring Boot DataSource configuration actually means at the PostgreSQL level. The 2nd lesson in the PostgreSQL Foundations category.
Databases, Schemas, Tables, and Basic SQL Syntax
The server → database → schema → table hierarchy, CREATE TABLE syntax read through this project's own real V1__init_schema.sql, column definitions/constraints, SQL comments, and a first distinction between DDL and DML. The 3rd lesson in the PostgreSQL Foundations category.
PostgreSQL Data Types
INTEGER/BIGINT/BIGSERIAL, VARCHAR/TEXT, BOOLEAN, and DATE/TIMESTAMP/TIMESTAMPTZ -- how each one maps to its corresponding Java field type (Long/String/boolean/LocalDateTime) in this project's own real Topic/TopicTranslation/Question entities. The 4th lesson in the PostgreSQL Foundations category.
Constraints and Keys
PRIMARY KEY, FOREIGN KEY and referential integrity, ON DELETE CASCADE vs. RESTRICT (with a real contrast from this project's own quiz_question_link table), composite UNIQUE, CHECK constraints, and how BIGSERIAL PRIMARY KEY connects to GenerationType.IDENTITY. The 5th lesson in the PostgreSQL Foundations category.
Inserting, Updating, and Deleting Data
INSERT/UPDATE/DELETE, with this project's own real INSERT ... SELECT and UPDATE ... WHERE migrations, RETURNING, ON CONFLICT (upsert), and how Flyway guarantees this project's migrations never need ON CONFLICT. The 6th lesson in the PostgreSQL Foundations category.
SELECT and Filtering
The basic shape of SELECT, naming columns explicitly instead of SELECT *, comparison/logical operators, LIKE pattern matching, IN/BETWEEN, and why NULL can only be filtered with IS NULL, not = -- on this project's own real topic/category table. The 7th lesson in the PostgreSQL Foundations category.
Sorting, Limiting, and Pagination
ORDER BY, LIMIT/OFFSET, and NULLS FIRST/LAST -- what Pageable/Sort/Page<T>, already covered in the Spring Data JPA course, actually compiles down to underneath, on this project's own real topic table. The 8th lesson in the PostgreSQL Foundations category.
JOINs
INNER/LEFT/RIGHT/FULL JOIN, with this project's own real topic→category→course chain and its real TopicRepository.findBySlugWithCategoryAndCourse JPQL join fetch -- plus a real LEFT JOIN example finding topics not yet published in English. The 9th lesson in the PostgreSQL Foundations category.
Aggregation and GROUP BY
COUNT/SUM/AVG/MIN/MAX, GROUP BY, and HAVING -- entirely new material with no equivalent in Spring Data JPA's Pageable/Sort/projection vocabulary -- with this project's own real "topics per category" LEFT JOIN + GROUP BY query. The 10th and FINAL lesson in the PostgreSQL Foundations category.
Advanced PostgreSQL
Subqueries, CTEs, and Window Functions
Scalar and correlated subqueries, chained WITH (CTEs), and window functions (ROW_NUMBER, RANK, PARTITION BY) -- computing across rows without collapsing them the way GROUP BY does, with this project's own real topic table. The 1st lesson in the Advanced PostgreSQL category.
PostgreSQL-Specific Data Types: UUID, JSON/JSONB, and Arrays
UUID (as an alternative to BIGSERIAL, with trade-offs), JSON vs. JSONB, querying JSONB with ->/->>/@>, and arrays (ANY/@>/unnest) -- honestly noting this project's real schema uses none of them, with illustrative examples grounded in this project's own domain. The 2nd lesson in the Advanced PostgreSQL category.
Indexes and Query Performance with EXPLAIN
EXPLAIN/EXPLAIN ANALYZE, Seq Scan vs. Index Scan, CREATE INDEX with this project's own real idx_topic_category B-tree index, partial/expression indexes, and revisiting OFFSET's cost with keyset pagination. The 3rd lesson in the Advanced PostgreSQL category.
Transactions and Concurrency in PostgreSQL
Real BEGIN/COMMIT/ROLLBACK in psql, MVCC explained mechanically (xmin/xmax), row-level locking with SELECT ... FOR UPDATE, and a deadlock produced and explained on purpose -- without repeating "Transaction Management"'s isolation coverage. The 4th and FINAL lesson in the Advanced PostgreSQL category -- completing 14/14 topics in the PostgreSQL course.
Git & GitHub
Git Fundamentals
Git Fundamentals
What Git is, how it differs from GitHub, and the working tree/staging area/repository mental model -- via git init, status, add, commit, diff, and log. The 1st lesson in both the Git & GitHub course and its Git Fundamentals category.
Working With Commits
Writing good commit messages, browsing history with git log/git show, git commit -am, and understanding that git commit --amend creates a NEW commit rather than editing the existing one in place. HEAD and HEAD~1/HEAD~2 references.
Undoing Changes
Undoing working tree changes with git restore, the difference between git reset's soft/mixed/hard modes, and safely undoing shared commits with git revert. The relationship between HEAD, staging area, and working tree, and the data-loss risk of git reset --hard.
Branches & Merging
Creating, deleting, and renaming branches, switching with git switch, the difference between a fast-forward merge and a merge commit, an introduction to merge conflicts, and a realistic Spring Boot feature branch workflow. Why git switch is preferred over git checkout.
GitHub & Remotes
What a remote is, how git clone/push/fetch/pull work, the difference between fetch and pull (fetch: download without integrating, pull: fetch + integrate), tracking branches and git push -u, and synchronizing local and remote branches.
Pull Requests
What a Pull Request is, how to create/review/approve one through a realistic feature branch workflow, the difference between merge and squash-and-merge, deleting branches after merge, and branch protection rules.
Advanced Git
Rebase & Squash
What rebase is, how it differs from merge, squashing/reordering/rewording commits with git rebase -i, resolving rebase conflicts, the danger of rewriting shared history, and the difference between git push --force and --force-with-lease.
Merge Conflicts
What a merge conflict is, how to read conflict markers (<<<<<<<, =======, >>>>>>>), how to resolve one with real Java code examples, the same mechanics during both merge and rebase, and safely canceling with git merge --abort/git rebase --abort.
Stash
Saving uncommitted changes aside with git stash, the difference between apply and pop, multiple and named stashes, git stash drop/clear, and stashing untracked files. A realistic "interrupted mid-feature, need to switch tasks" scenario.
Advanced Git & Best Practices
git cherry-pick, git reflog (especially as a recovery mechanism for lost commits), git blame, aliases, good branch/commit conventions, and a comparison tying together merge/rebase/squash/revert. Git best practices for a development team.
Practical Git & GitHub Workflow
A closing lesson that ties together everything taught across the course in one continuous, realistic Spring Boot scenario: clone, feature branch, commit/amend, push, Pull Request, review feedback, rebasing onto main, resolving a conflict, force-with-lease, and squash and merge.
Docker
Docker Fundamentals
What Is Docker?
What Docker is, how containers differ from virtual machines, the difference between an image and a container, the Docker Engine, and Docker Hub. The 1st lesson in both the Docker course and its Docker Fundamentals category.
Docker CLI Fundamentals
docker pull, docker images, docker run, docker ps, docker logs, docker exec, docker stop/start, and docker rm -- walked through via the full lifecycle of a PostgreSQL container, with real examples.
Docker Images and Dockerfiles
What a Dockerfile is, the FROM, WORKDIR, COPY, RUN, EXPOSE instructions, the difference between CMD and ENTRYPOINT, and building an image with docker build -- via a generic, minimal web server example.
Dockerizing a Spring Boot Application
Choosing a JRE vs JDK base image for a Spring Boot JAR, .dockerignore, multi-stage builds, and container-aware JVM memory sizing -- via this project's own real learning-platform application.
Docker in Practice
Docker Networking
Why the default bridge network doesn't support name resolution between containers, creating user-defined networks with docker network create, container-to-container communication by name, and why localhost means something different inside a container.
Docker Volumes
Why containers are ephemeral, named volumes, mounting a volume with docker run -v, where PostgreSQL stores its data, named volumes vs. bind mounts, and verifying persistence with a deliberate test.
Docker Compose
docker-compose.yml, services, depends_on, Compose's automatic service-name networking, and volumes -- reducing everything "Docker Networking" and "Docker Volumes" did by hand to one file and docker compose up.
Production Docker for Java Applications
Faster rebuilds with layer caching, a non-root user, a Dockerfile HEALTHCHECK, waiting for real dependency readiness with Compose's depends_on: condition: service_healthy, and production configuration/secrets.
The Practical Project: Spring Boot + PostgreSQL with Docker
Every piece this course covered -- multi-stage Dockerfile, non-root user, HEALTHCHECK, Docker Compose, named volume, automatic networking -- brought together in one small, complete Spring Boot + PostgreSQL task tracker application. The closing lesson of the course.