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.
GuideTechnology
11 min read
How one Java class can build on another, how overriding changes behaviour at runtime, how overloading is chosen at compile time, and why inheritance is easy to misuse. With the constructor-order trap, field hiding and the exact differences interviewers ask about.
GuideTechnology
12 min read
Why object-oriented programming exists and how Java expresses it: classes as blueprints, objects as instances, constructors, access modifiers, static versus instance members, and encapsulation as a way to protect the rules of your data. Built around a bank account that cannot go wrong.
GuideTechnology
13 min read
How to make a Java program choose and repeat: if, switch (old statement and modern expression), the loop forms, and how to organise code into methods. Includes the pass-by-value rule that interviewers love and the scope rules that cause mysterious compile errors.
GuideTechnology
15 min read
How Java stores and combines data: primitive types versus references, what happens when a number overflows, why integer division surprises people, how casting and conversion work, when to use var, and how arrays hold a fixed number of values.
GuideTechnology
15 min read
What Java actually is, how a .java file becomes a running program, what the JDK, JRE and JVM each do, and how to compile and run your first program. Plus the full roadmap of this 41-article course, from zero to a tested Spring Boot API.
GuideTechnology
14 min read
Turn the course into interview performance: an eight-week practice plan, how to run timed solo drills and mock interviews, a self-scoring rubric that separates SDE-1 and SDE-2 expectations, a drill sheet for the twelve classic problems, ten new practice problems to test transfer, common failure patterns, and the complete job-ready checklist.
GuideTechnology
17 min read
An educational design for searching a billion web pages: a polite, distributed crawler with a URL frontier and robots.txt, deduplication, building an inverted index with batch processing, document-partitioned shards and replicas, scatter-gather query serving with result caching and tail-latency control, ranking from relevance and link signals, freshness tiers, failures and safety.
GuideTechnology
16 min read
Design an online store from product pages to delivery: a catalogue and search served from caches and event-fed indexes, carts in a key-value store, inventory reservations with expiry, a checkout saga across inventory and payment, oversell prevention, and a flash sale that survives a thousandfold spike with a waiting room, bucketed stock and isolation from normal shopping.
GuideTechnology
17 min read
Design a food delivery platform where every order coordinates three parties in real time: restaurant discovery and menus as cached read models, an idempotent checkout, an order state machine driven by a saga with timeouts and compensations, dispatching delivery partners timed to food readiness, batching, live tracking, notifications, dinner-peak load, failures and the trade-offs between them.
GuideTechnology
18 min read
Design the core of a ride-hailing app: ingesting hundreds of thousands of driver location updates per second, a geospatial index of available drivers, matching riders to drivers with offers and timeouts, never assigning one driver twice, a trip state machine, live tracking for riders, city-based partitioning, payments, failures, privacy and fraud.
GuideTechnology
15 min read
Design an on-demand video platform: resumable uploads straight to object storage, a parallel transcoding pipeline that splits videos into chunks and renditions, adaptive bitrate streaming with HLS-style segments and manifests, CDN delivery at terabits per second, storage tiering, view counting, failures, content safety and the metrics that matter to viewers.
GuideTechnology
19 min read
Design the payment platform behind checkout and refunds, where correctness matters more than speed: payment intents and attempts, an explicit state machine, idempotency at every hop, asynchronous confirmation through verified webhooks, a double-entry ledger with a runnable example, reconciliation against provider reports, refunds, provider failover, fraud and PCI scope, and an audit trail.
GuideTechnology
16 min read
Design ticketing for concerts and matches where thousands of people want the same seats at the same moment: seat inventory modelling, holds with expiry, atomic all-or-nothing seat claims, idempotent payment and confirmation, what happens when payment succeeds after a hold expires, virtual waiting rooms for big on-sales, hot inventory, bots, failures and the invariant that a seat is never sold twice.
