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.
GuideTechnology
13 min read
Starting from a payment system full of if-else branches, this article shows why interfaces and polymorphism exist, how abstract classes differ from interfaces, what default methods are for, and why composition usually beats inheritance. It also previews the idea behind dependency injection.
