# Tech.ish Thoughts

> A technical blog covering software engineering, JVM performance, distributed systems,
> and modern web development. Written by practitioners for practitioners.

Tech.ish Thoughts publishes in-depth technical articles, tutorials, and deep-dives
into backend systems, off-heap algorithms, GraphQL federation, blockchain, and more.
All articles include production-tested code examples and real-world benchmarks.

## Articles

- [A gentle introduction to observability](https://techishthoughts.com/posts/2025/12/gentle-introduction-to-observability/): Learn the core concepts of observability, why logs, metrics and traces matter and how tools like OpenTelemetry, Prometheus and Grafana improve your system reliability
- [Understanding Communication Protocols: A Comprehensive Guide](https://techishthoughts.com/posts/2025/06/understanding-communication-protocols/): Comprehensive analysis of communication protocols from historical perspectives to modern implementation considerations across all network layers.

## Series: Polyglot GraphQL Federation

- [Part 1 — Polyglot GraphQL Federation: Part 1 - The Monolith's Breaking Point](https://techishthoughts.com/posts/2026/03/graphql-federation-part-1-why-federation/): Why monolithic GraphQL APIs collapse under the weight of growing teams and domains. An introduction to GraphQL Federation 2 and the architecture behind a polyglot e-commerce platform.
- [Part 2 — Polyglot GraphQL Federation: Part 2 - Three Languages, One Schema](https://techishthoughts.com/posts/2026/03/graphql-federation-part-2-polyglot-subgraphs/): How Java, Go, and TypeScript each implement GraphQL Federation 2 subgraphs with entity resolution, schema directives, and database-per-service isolation in a real e-commerce platform.
- [Part 3 — Polyglot GraphQL Federation: Part 3 - When GraphQL Meets gRPC and REST](https://techishthoughts.com/posts/2026/04/graphql-federation-part-3-hybrid-protocols/): GraphQL is not the only protocol in a federated platform. This article explores how gRPC handles internal Java-to-Java communication while REST powers Stripe payment integration in Go.
- [Part 4 — Polyglot GraphQL Federation: Part 4 - Kong, Apollo Router, and Query Planning](https://techishthoughts.com/posts/2026/04/graphql-federation-part-4-gateway-layer/): How two gateways compose into a secure, observable API layer with intelligent query planning across subgraphs.
- [Part 5 — Polyglot GraphQL Federation: Part 5 - Observability Across the Stack](https://techishthoughts.com/posts/2026/05/graphql-federation-part-5-observability/): Implement end-to-end observability for polyglot GraphQL federation with OpenTelemetry, Tempo, Prometheus, Loki, Alloy, and Pyroscope, including tail sampling, SLOs, and cross-signal correlation.

## Series: Object Detection from Scratch

- [Part 1 — Object Detection from Scratch: Part 1 - Why This Project Is Worth Building](https://techishthoughts.com/posts/2026/03/object-detection-part-1-why-this-project-matters/): Why a Magic: The Gathering card detector is a serious engineering project, not a toy demo. Part 1 frames the product problem, the architecture, and the technical journey ahead.
- [Part 2 — Object Detection from Scratch: Part 2 - Dataset, Labels, and the Reality of Training Data](https://techishthoughts.com/posts/2026/04/object-detection-part-2-dataset-labels/): Part 2 examines the dataset behind the MTG detector: splits, YOLO labels, class design, annotation noise, and why data quality sets the real performance ceiling.

## Series: Off-Heap Algorithms in Java

- [Part 1 — Off-Heap Algorithms in Java: The Ring Buffer Foundation](https://techishthoughts.com/posts/2025/11/off-heap-ring-buffer/): From a naive heap-based queue to an off-heap ring buffer with dramatically better throughput, tail latency, and GC behavior for high-frequency trading workloads.
- [Part 2 — Wait-Free SPSC Queues in Java](https://techishthoughts.com/posts/2025/11/off-heap-spsc-queue/): How to replace synchronized queue handshakes with a wait-free Single-Producer Single-Consumer ring buffer that uses precise memory ordering instead of locks.
- [Part 3 — Lock-Free MPSC Queues: Production-Grade Implementation](https://techishthoughts.com/posts/2026/01/off-heap-mpsc-queue-production/): A deep-dive into building production-grade Multi-Producer Single-Consumer lock-free queues in Java, with VarHandle, CAS operations, and real-world benchmarks.
- [Part 3 — Lock-Free MPSC Queues in Java](https://techishthoughts.com/posts/2025/11/off-heap-mpsc-queue/): How to replace locked many-producer queues with a lock-free Multi-Producer Single-Consumer ring buffer coordinated entirely by CAS and sequence numbers.
- [Part 4 — Lock-Free MPMC Queues: Dual Contention Mastery](https://techishthoughts.com/posts/2026/01/off-heap-mpmc-queue-production/): Master the complexity of Multi-Producer Multi-Consumer lock-free queues with per-slot sequence numbers, dual CAS coordination, and work-stealing thread pool integration.
- [Part 4 — MPMC Queues in Java: The Final Boss](https://techishthoughts.com/posts/2025/11/off-heap-mpmc-queue/): How to build a dual-CAS Multi-Producer Multi-Consumer ring buffer in Java that scales on both ends without collapsing under lock contention.
- [Part 5 — The Disruptor Pattern: Multi-Stage Event Processing Pipelines](https://techishthoughts.com/posts/2026/01/off-heap-disruptor-pattern-production/): Implement LMAX Disruptor-style event processing with sequence barriers, multi-stage pipelines, and batch processing for ultra-low latency systems.
- [Part 5 — Event Pipelines in Java: The LMAX Disruptor Pattern](https://techishthoughts.com/posts/2025/11/off-heap-event-pipeline/): How to chain SPSC queues into a high-throughput event pipeline, following the LMAX Disruptor pattern for multi-stage processing with sub-microsecond latency.
- [Part 6 — Wait-Free Telemetry: Never-Blocking Observability](https://techishthoughts.com/posts/2026/01/off-heap-wait-free-telemetry-production/): Build wait-free telemetry buffers that never block producers, with overwrite semantics for high-frequency trading observability that doesn't impact system performance.
- [Part 7 — Sharded Processing: Per-Core Isolation for Zero Contention](https://techishthoughts.com/posts/2026/01/off-heap-sharded-processing-production/): Eliminate contention entirely with per-CPU-core sharded buffers, thread affinity, and isolated processing lanes for maximum parallelism.
- [Part 9 — K-FIFO Queues: Relaxed Ordering for Maximum Throughput](https://techishthoughts.com/posts/2026/01/off-heap-kfifo-queue-production/): Trade strict FIFO ordering for dramatically higher throughput with K-FIFO queues, segmented buffers, and probabilistic fairness for metrics collection.
- [Part 10 — Batch Processing: Amortized I/O for Audit Persistence](https://techishthoughts.com/posts/2026/01/off-heap-batch-processing-production/): Amortize disk I/O costs with double-buffered batch processing, continuous flushing, and regulatory-compliant audit logging for trading systems.

## Series: Actor Model on the JVM

- [Part 1 — The Actor Model on the JVM: Part 1 - OOP and the Rise of Concurrency Challenges](https://techishthoughts.com/posts/2025/02/actor-model-jvm-part-1-oop-concurrency-challenges/): Explore the evolution of Object-Oriented Programming and its challenges in concurrent programming, setting the stage for understanding the Actor Model as a solution.
- [Part 2 — The Actor Model on the JVM: Part 2 - The Pitfalls of Shared State](https://techishthoughts.com/posts/2025/03/actor-model-jvm-part-2-pitfalls-shared-state/): Deep dive into the specific problems that arise when dealing with shared mutable state in multithreaded environments and why traditional synchronization approaches fall short.
- [Part 3 — The Actor Model on the JVM: Part 3 - The Final Chapter](https://techishthoughts.com/posts/2025/07/actor-model-jvm-part-3-final-chapter/): Complete implementation guide to the Actor Model with advanced patterns, testing strategies, and real-world lessons learned from building scalable concurrent systems.

## Series: Blockchain Foundations

- [Part 1 — What is Blockchain, How Does It Work and Why Does It Matter?](https://techishthoughts.com/posts/2024/12/what-is-blockchain-how-does-it-work/): Understanding Blockchain: The Technology Behind a Decentralised Future. Comprehensive guide to blockchain technology, its mechanisms, and real-world impact.
- [Part 2 — Building an Escrow Marketplace Smart Contract: A Beginner's Guide to Solidity](https://techishthoughts.com/posts/2025/04/building-escrow-marketplace-smart-contract/): Learn how to build a secure escrow marketplace smart contract using Solidity and Foundry, enabling trustless transactions between buyers and sellers.

## Pages

- [About](https://techishthoughts.com/about/): About Tech.ish Thoughts and the team
- [Contributors](https://techishthoughts.com/contributors/): Meet the authors
- [Tags](https://techishthoughts.com/tags/): Browse articles by topic
- [Series](https://techishthoughts.com/series/): Multi-part article series
- [RSS Feed](https://techishthoughts.com/feed.xml/): Subscribe via RSS

## Optional

- [Privacy Policy](https://techishthoughts.com/privacy/): Privacy policy
- [Terms of Service](https://techishthoughts.com/terms/): Terms of service
- [Design System](https://techishthoughts.com/design-system/): Component showcase