GuideTechnology
46 min read
Secure the Job Application Tracker API: hash passwords with bcrypt, log in with signed JWT access tokens, enforce that users can only reach their own data, configure CORS and CSRF correctly, keep secrets out of the code, and prove each protection with tests and real requests.
GuideTechnology
35 min read
Add interviews to job applications and meet the real problems of JPA: relationship mapping, lazy loading and its exception, the N+1 query problem measured and fixed, what @Transactional does and does not do, and optimistic locking that stops lost updates, all tested on PostgreSQL.
GuideTechnology
29 min read
Replace the in-memory repository with a real PostgreSQL database using JPA, Hibernate and Spring Data: map an entity, manage the schema with Flyway migrations, understand the persistence context and dirty checking, write queries, and read the SQL Hibernate actually generates, including a real failure only PostgreSQL revealed.
GuideTechnology
30 min read
Build the first version of the Job Application Tracker API: a layered Spring Boot application with controller, service, repository, request and response DTOs, Bean Validation, paging and filtering, problem-details errors and tests, then exercise every endpoint over real HTTP.
GuideTechnology
15 min read
Learn what Spring Boot adds to Spring: the project structure, starters, auto-configuration and how it backs off, the embedded server, typed configuration with validation, profiles and the order in which configuration sources win, all run on a real Spring Boot 4.1 application.
GuideTechnology
18 min read
Understand dependency injection and inversion of control from first principles: wire objects by hand, build a tiny container, then see the real Spring container create beans, resolve ambiguity, manage scopes and lifecycle, and fail with the errors you will actually meet.
GuideTechnology
20 min read
Understand what actually travels between a client and a Java backend: the HTTP request and response, methods and their guarantees, status codes, headers, JSON and how Java maps to it, and how to design a clean REST API, with real captured traffic and real JSON mapping.
GuideTechnology
30 min read
Take the Expense Tracker CLI and add a PostgreSQL repository behind the same interface: an idempotent schema, a transactional bulk import, a connection pool, one shared contract test for every implementation, a fat jar, and an honest review.
GuideTechnology
25 min read
Learn JDBC, the standard way Java programs use a relational database: connecting with a driver, running queries with PreparedStatement, mapping rows, preventing SQL injection, transactions, error codes, batching and connection pooling, with every program run against PostgreSQL 18.
GuideTechnology
21 min read
Learn the SQL that backend developers use every day on PostgreSQL: tables and constraints, inserting, querying, joining and grouping data, transactions and isolation, indexes and query plans, and normalisation, with every statement run on a real PostgreSQL server.
GuideTechnology
29 min read
Build your first complete Java application: a command-line expense tracker with a clear design, money handled correctly, a file-based repository behind an interface, automated tests, a Maven build, and a runnable jar, then review it honestly.
GuideTechnology
16 min read
Learn to write reliable unit tests in Java with JUnit: structure, assertions, exception and parameterised tests, test lifecycle, then test doubles and Mockito, and the honest limits of mocking, all run in a real Maven project.
GuideTechnology
11 min read
A practical Git workflow for Java developers: the three areas, commits and good messages, branches, merging and resolving conflicts, pull requests, a correct .gitignore for Maven projects, and what to do when a secret is committed.
GuideTechnology
15 min read
Learn what a build tool does and how Maven does it: the standard project layout, the pom.xml, dependencies and scopes, transitive dependencies, the build lifecycle, plugins, and the common failures, all checked against a real project.
GuideTechnology
18 min read
A method for finding bugs instead of guessing: read compiler errors and stack traces properly, form and test hypotheses, use breakpoints and stepping in a debugger, log usefully at the right level, and reach for thread dumps and heap dumps when the problem is a hang or a leak.
GuideTechnology
16 min read
How to read and write files in modern Java with Path and Files, why character encoding matters, how to stream large files safely, how to avoid path traversal, and what Java serialization really is, why it is risky, and what to use instead.
GuideTechnology
16 min read
The concurrency tools you should actually use: thread pools with ExecutorService, Callable and Future, producer-consumer with BlockingQueue, ConcurrentHashMap and friends, CompletableFuture pipelines, and virtual threads from Java 21, including what they do and do not do.
GuideTechnology
15 min read
Concurrency taught from the problems: lost updates, visibility and deadlock. Threads and the Java Memory Model, race conditions and atomicity, synchronized, volatile, atomic classes and locks, with runnable demonstrations and honest advice on what each tool does and does not guarantee.
GuideTechnology
16 min read
A working mental model of the Java Virtual Machine: how classes are loaded and initialised, what lives on the stack and the heap, how garbage collection decides what to free and why memory leaks still happen, and what the JIT compiler does. Each simplification is marked, and common myths are corrected.
GuideTechnology
12 min read
Why null causes so many bugs, what Optional is actually for, how to use map, flatMap, orElse, orElseGet and orElseThrow, and the common misuses (fields, parameters, get without a check). Optional is a tool for return values, not a universal replacement for null.
GuideTechnology
13 min read
How to process collections declaratively with Java Streams: filter, map, flatMap, sorted, reduce and collect, grouping and partitioning, why streams are lazy and single-use, what parallel streams really cost, and an honest guide to when a plain loop is the better choice.
GuideTechnology
12 min read
How Java lets you pass behaviour as a value: lambda expressions, functional interfaces and the standard Predicate, Function, Consumer and Supplier, the four kinds of method reference, composing functions, why captured variables must be effectively final, and how lambdas replace the older anonymous classes.
GuideTechnology
13 min read
What the angle brackets mean and why they exist. Generic classes and methods, bounded types, why List of Integer is not a List of Number, wildcards with extends and super, the PECS rule that makes them make sense, and type erasure with its practical consequences.
GuideTechnology
12 min read
How to sort objects with Comparable and Comparator, how queues, deques and priority queues work, why ArrayDeque replaces the legacy Stack, and a decision guide with complexity and memory trade-offs for choosing the right collection.
GuideTechnology
14 min read
How Java stores key-value pairs, and how HashMap finds a value in constant time: hashing, buckets, collisions, resizing and treeification, explained with a small map you build yourself. Plus LinkedHashMap, TreeMap, the everyday Map methods, and the mistakes that corrupt a map.
GuideTechnology
12 min read
How Java's collections framework is organised, how ArrayList and LinkedList really differ, what makes a Set unique, how to remove items safely while iterating, and the confusing differences between List.of, Arrays.asList and unmodifiable views. Includes sequenced collections from Java 21.
GuideTechnology
12 min read
How Java reports and handles errors: the exception hierarchy, checked versus unchecked exceptions and why opinions differ, try, catch, finally and try-with-resources, custom exceptions, exception chaining, and the habits that separate good exception handling from swallowed errors.
GuideTechnology
12 min read
How to model data precisely in modern Java: enums for fixed sets of values, records for immutable data carriers, and sealed types with pattern matching for a closed set of alternatives. Each is introduced from the bug it prevents, and compared with the older style you will still see.
GuideTechnology
13 min read
Why Java strings are immutable and what the string pool really is, when to use StringBuilder, how Unicode makes length surprising, how text blocks and formatting work, and how to handle dates and times with java.time instead of the old Date and Calendar. Includes testable time with Clock.
GuideTechnology
12 min read
Why two objects that look identical are not equal by default, what == really compares, how to write equals and hashCode correctly, why mutable keys break HashSet and HashMap, and how immutability makes all of this safer. Includes the Integer cache surprise and the contracts interviewers ask about.
