Java Platform Architecture & Memory

- JVM architecture: class loader subsystem, runtime data areas, execution engine, interpreter vs JIT (C1/C2)

- JRE vs JDK vs JVM; OpenJDK distributions in practice

- Compilation flow: .java → javac → .class bytecode → loading → verification → JIT → native execution; reading bytecode with javap -c

- Stack vs heap: frames, locals, references vs objects; Metaspace, string pool, constant pool

- Where StackOverflowError and OutOfMemoryError actually come from

- Encapsulation, inheritance, polymorphism (static vs dynamic dispatch), abstraction

- Interfaces vs abstract classes; default/static/private interface methods; sealed classes

- Pass-by-value semantics — why "Java is always pass-by-value" and what that means for references

- Immutability & records; equals/hashCode/toString done right

- Exceptions: checked vs unchecked, try-with-resources, handling anti-patterns

- Optional — intended use and misuse; pattern matching for switch / instanceof

- Generic classes and methods; bounded type parameters

- Wildcards: ? extends / ? super and the PECS rule

- Type erasure — what survives to runtime, bridge methods, why new T() is impossible

- Pitfalls: raw types, generic arrays, heap pollution, overload clashes after erasure

- Hierarchy: Iterable → Collection → List / Set / Queue; why Map sits outside

- ArrayList internals: backing array, growth factor, System.arraycopy, amortized O(1) append

- LinkedList: node overhead, cache locality — real complexity vs measured benchmarks (JMH demo)

- Legacy classes: Vector (method-level synchronization, 2× growth) and Stack — why they survive in old code, why new code uses ArrayList / ArrayDeque, and what "synchronized but not thread-safe for compound actions" means

- Collections.synchronizedList vs Vector vs CopyOnWriteArrayList

- equals()/hashCode() contracts and what breaks in a HashSet when they're violated

- HashSet vs LinkedHashSet vs TreeSet; NavigableSet (floor/ceiling/subsets)

- Comparable vs Comparator; Comparator.comparing(...).thenComparing(...); consistency-with-equals in sorted sets

- Iterators: Iterator/ListIterator, fail-fast & ConcurrentModificationException, safe removal (removeIf)

- Arrays.asList vs List.of vs List.copyOf; views vs copies; unmodifiable wrappers

- HashMap internals: hash spreading, buckets, collision handling, treeification thresholds (8/6), resizing, load factor

- LinkedHashMap (insertion vs access order — building an LRU cache); TreeMap / NavigableMap

- Hashtable: full-table locking, no null keys/values, why it's legacy - Hashtable vs HashMap vs ConcurrentHashMap as an interview classic

- ConcurrentHashMap: per-bin synchronization & CAS, atomic compute/merge/putIfAbsent, weakly-consistent (fail-safe) iterators vs fail-fast

- Queues: Queue/Deque contracts (offer/poll/peek vs throwing variants); ArrayDeque as stack and queue

- PriorityQueue: binary heap, ordering guaranteed only at poll(), comparator-driven

- BlockingQueue family: ArrayBlockingQueue, LinkedBlockingQueue, DelayQueue, SynchronousQueue - producer/consumer pattern live demo

- EnumMap / EnumSet; choosing the right collection — decision table by access pattern, ordering, concurrency

- Implement a simplified MiniHashMap: buckets, resize, collision handling — then break it by mutating a key after insertion and explain the lost entry

- Benchmark ArrayList vs LinkedList vs Vector middle-insertion and iteration with JMH; defend the numbers with cache-locality arguments

- Producer/consumer pipeline on ArrayBlockingQueue; swap in SynchronousQueue, explain the change

- Build an LRU cache from LinkedHashMap in 15 lines

Deliverable: repo with the four exercises, JMH results table, one-page "which collection when" write-up.

- 10 questions / 60 min:  (JVM, generics, collections internals — Vector/Hashtable included), 5 code-reading snippets, 5 "choose the right collection and justify" cases

- Pass ≥ 70% · one retake · 1-on-1 result review with mentor

- Lambdas and method references; capturing semantics ("effectively final")

- Functional interfaces: Function, Supplier, Consumer, Predicate; writing your own

- Stream API: intermediate vs terminal operations, laziness, short-circuiting

- Collectors: groupingBy, partitioningBy, toMap, downstream collectors

- Parallel streams — when they help, when they hurt; when a plain loop is better

- Thread lifecycle; Runnable vs Callable; daemon threads

- Java Memory Model in practice: visibility, ordering, volatile, happens-before

- synchronized (intrinsic locks), ReentrantLock, ReadWriteLock; atomics and CAS

- ExecutorService & thread-pool sizing (CPU-bound vs IO-bound); rejection policies

- CompletableFuture: composition, error handling, timeouts

- Virtual threads (Java 21) — what changes and what doesn't

- Deadlock, livelock, starvation: producing and diagnosing each with thread dumps

- Object lifecycle; reachability; strong / soft / weak / phantom references

- Generational hypothesis: minor vs major vs full GC, stop-the-world pauses

- Collectors compared: Serial, Parallel, G1, ZGC — trade-offs and defaults

- Memory leaks: static caches, listeners, ThreadLocal; heap-dump analysis (Eclipse MAT / VisualVM)

- OutOfMemoryError triage workflow

- Bank-transfer simulator that deadlocks by design; capture thread dump, identify the cycle, fix with lock ordering

- Rewrite with ExecutorService + CompletableFuture; run on virtual threads, compare throughput

- Leak hunt: provided app leaks via ThreadLocal — find it with a heap dump

Deliverable: fixed simulator + short post-mortem (dump excerpt, root cause, fix rationale).

- 10 questions / 60 min: stream pipeline outputs, JMM visibility scenarios, executor sizing, GC log reading

- Pass ≥ 70% · one retake

SQL Query Fundamentals & Joins

- SELECT / INSERT / UPDATE / DELETE; WHERE, AND/OR, ORDER BY, LIMIT/OFFSET

- IN vs EXISTS vs ANY; NULL three-valued logic and its traps

- Subqueries: scalar, correlated, derived tables; CTEs (WITH)

- INNER / LEFT / RIGHT / FULL / CROSS joins; self-joins; anti-joins (NOT EXISTS)

- Filtering in ON vs WHERE on outer joins — the classic bug

- COUNT / SUM / AVG / MIN / MAX; GROUP BY semantics; HAVING vs WHERE

- Window functions: ROW_NUMBER, RANK, LAG/LEAD, running totals; top-N-per-group pattern

- PRIMARY KEY, FOREIGN KEY (+ ON DELETE behaviors), UNIQUE, NOT NULL, CHECK

- Normalization 1NF→3NF; deliberate denormalization; surrogate vs natural keys; UUID vs sequence

- B-Tree mechanics; composite indexes and the leftmost-prefix rule; covering, partial, unique indexes

- When an index is ignored: functions on columns, leading wildcards, low selectivity

- Reading EXPLAIN (ANALYZE): scan types, join strategies, row estimates

- BEGIN / COMMIT / ROLLBACK; ACID unpacked with concrete failure stories

- Isolation levels: read committed → repeatable read → serializable; dirty/non-repeatable/phantom reads

- MVCC in PostgreSQL; row locks, SELECT … FOR UPDATE; deadlocks and retry strategy

- Seeded mini-bank schema (~2M rows): 12 progressively harder query tasks ending in window functions; every answer ships with EXPLAIN ANALYZE + one-line plan justification

- Two terminals, one account row: produce a lost update under read committed; fix three ways (atomic UPDATE, FOR UPDATE, serializable + retry)

- Force a deadlock, read the server log, implement the retry

Deliverable: SQL answer set + plans, concurrency exercise as a reproducible script.

- 20 questions / 35 min: 8 "what does this query return" (NULL and outer-join traps), 6 MCQ indexing/transactions, 6 written queries against a given schema

- Pass ≥ 70% · one retake

Spring Boot Fundamentals

- Spring vs Spring Boot; IoC container, bean lifecycle, constructor injection as the default

- Auto-configuration: @ConditionalOn…, reading the condition report

- application.yml, profiles, externalized config, @ConfigurationProperties + validation

- ORM concepts; entity lifecycle (transient → managed → detached → removed); persistence context & first-level cache

- @Entity, @Id, @GeneratedValue strategies — identity vs sequence and why it matters for batching

- Relationships: @OneToMany, @ManyToOne, @ManyToMany; owning side, mappedBy

- LAZY vs EAGER; LazyInitializationException and its real fixes

- Cascade types, orphan removal; @Enumerated(STRING), @Embedded/@Embeddable

- Dirty checking & flush modes; equals/hashCode for entities

- N+1: detecting in logs; fixing with JOIN FETCH, @EntityGraph, batch size or DTO projection

- Schema migrations with Liquibase/Flyway — why ddl-auto is not a migration strategy

- @Transactional: proxies, self-invocation trap, readOnly, rollback rules

- Propagation (REQUIRED, REQUIRES_NEW, NESTED — real use cases); isolation mapping to the DB

- Optimistic locking (@Version) vs pessimistic locking (@Lock); retry patterns

- JpaRepository; derived queries and their limits; JPQL vs native, @Modifying

- Pagination & sorting (Pageable); projections (interface & record); Specification overview

- @RestController, request/response mapping, DTOs vs entities at the boundary

- CRUD conventions: status codes, idempotency, pagination contract, versioning basics

- Bean Validation (@Valid, custom validators); global error contract with @RestControllerAdvice + Problem Details

- OpenAPI/Swagger; declarative HTTP clients (Feign / RestClient)

- Test pyramid: JUnit 5 + Mockito (services); @DataJpaTest (repositories); @SpringBootTest + MockMvc (web slice)

- Testcontainers: real PostgreSQL in integration tests; why H2-only suites lie

- Actuator: health groups, metrics, info; structured logging and correlation ids

- Images vs containers; layers and caching; registries

- Production Dockerfile for Spring Boot: multi-stage build, layered jars, non-root user, JVM memory flags in containers

- Docker Compose: app + PostgreSQL + Redis with healthchecks, networks, volumes

- 12-factor recap: config via env, logs to stdout, statelessness

- Hunt the N+1: repo with five hidden JPA performance bugs (N+1, EAGER cascade storm, missing index, chatty mapping, transaction-less lazy access) — find with SQL logging + EXPLAIN, fix, prove before/after query counts

- Error-contract kata: upgrade a naive CRUD API — validation, Problem-Details body, correct status codes, optimistic-lock conflict handling, pagination; verified by a provided newman suite

- Ship it: multi-stage Dockerfile + Compose stack (service, PostgreSQL, Liquibase on boot, healthchecks) — docker compose up from clean clone to passing smoke test

Deliverable: three merged MRs, each describing what was broken and how the fix was proven.

- 10 questions / 60 min: entity-lifecycle and flush scenarios, propagation cases, fetch-strategy choices, "find 3 problems in this Dockerfile"

- Pass ≥ 70% · one retake

AI-Assisted Development

- How LLMs work — just enough: tokens, context windows, why models hallucinate

- Prompting for developers: constraints and context, not vibes; iterating instead of accepting draft #1

- Agentic workflows in Claude Code: explore → plan → implement → verify; letting the agent run tests and read failures

- Project memory (CLAUDE.md): encoding team conventions so the agent follows them

- AI code review: pre-MR review of your own diff; judging what the model flags

- Test generation done right: the human owns the assertions; mutation-testing AI-written tests

- Tool integrations (MCP): the agent reaching your DB schema, tickets, observability (demo)

- Calling Claude from Spring Boot: structured output, tool use; RAG in one diagram; cost/latency budgeting, prompt caching, model tiers

- Guardrails in a bank: what never goes into a prompt (secrets, customer data); verification culture — AI code gets the same review bar as human code; where AI is weak today (novel architecture, subtle concurrency, security-critical code)

- Pair-build with an agent: add a non-trivial feature to your Phase-C service using Claude Code end-to-end (plan → implement → tests → self-review), logging every correction; group debrief

- AI code-review duel: review a planted-bug MR by hand, then with an AI reviewer; compare findings, false positives, misses; co-write the team's "AI review checklist"

- Closing quiz: 15 questions / 25 min, scenario-based ("the model claims X — how do you verify?", data-safety cases) — counts as Assessment V

Deliverable: feature MR + correction log + team checklist.

- Mini payment service, built like production: Spring Boot + PostgreSQL + Liquibase + Docker Compose — accounts, transfers with optimistic locking, paginated history, Problem-Details error contract