# PRABHAT.DEV


## Posts

- [Kafka vs RabbitMQ: When to Choose Each](https://prabhat.dev/kafka-vs-rabbitmq-when-to-choose/): Choose Kafka or RabbitMQ by retention, replay, routing, ordering, retries, and delivery semantics. Includes Share Groups, Streams, and failure diagrams.
- [How LLMs Generate Text: Logits, Temperature, Top-k, and Top-p](https://prabhat.dev/how-llms-generate-text/): A beginner-friendly guide to next-token generation, with worked probability examples, clear diagrams, and deeper lessons on sampling, correctness, and reproducibility.
- [Embeddings & Vector Spaces: What They Actually Mean](https://prabhat.dev/embeddings-vector-spaces/): A plain-English guide to how text becomes numbers, why similar vectors help search, and where matches can go wrong, with diagrams and optional Python examples.
- [PostgreSQL 19 SQL/PGQ: Graph Queries](https://prabhat.dev/postgresql-19-sql-pgq-graph-queries/): PostgreSQL 19 SQL/PGQ adds a graph-query layer over relational tables. Learn how it works, where it fits, and why Neo4j still matters.
- [GitHub Copilot: Zero to Hero - The Complete 2026 Field Guide](https://prabhat.dev/github-copilot-zero-to-hero/): A complete field guide to GitHub Copilot in 2026. Covers every primitive - copilot-instructions.md, AGENTS.md, extensions, MCP, coding agent, hooks, permissions, context management - then advances into Copilot CLI, /fleet multi-agent workflows, model configuration, scheduling, and security best practices. Language and framework agnostic.
- [Claude Code: Zero to Hero - The Complete 2026 Field Guide](https://prabhat.dev/claude-code-zero-to-hero-the-complete-2026-field-guide/): A complete field guide to Claude Code in 2026. Covers every primitive CLAUDE.md, skills, MCP, subagents, hooks, permissions - then advances into headless pipelines, git worktrees, multi-agent teams, model configuration, scheduling, plugins, and security best practices. Language and framework agnostic.
- [Architecture Explained: 9 Essential Concepts for AI Engineers](https://prabhat.dev/transformer-architecture-explained/): Every LLM you work with today is a Transformer. Understanding the architecture does not mean implementing it. It means knowing why context placement affects your prompts, why RAG needs two separate model calls, and why bigger models know more facts. This post breaks down nine core concepts - self-attention, Q/K/V, multi-head attention, FFN, layer norm, residual connections, positional encoding, and encoder vs decoder - using plain English analogies and visual diagrams. No math, no ML history, no prior knowledge assumed.
- [Tokenization Explained: How Text Is Processed Before It Reaches an LLM](https://prabhat.dev/tokenization-explained-how-text-is-processed-before-it-reaches-an-llm/): Tokenization is the process that converts raw text into numbers before it reaches a language model. This post breaks down how UTF-8 encoding and Byte Pair Encoding (BPE) work together - with real examples, token split tables, and a look at why tokenization affects API pricing, context limits, and model behaviour.
- [ZGC vs. G1: Picking the Right Garbage Collector for High-Throughput](https://prabhat.dev/zgc-vs-g1-garbage-collector/): Choosing the right GC can make or break your JVM application's performance. A practical comparison of G1 and ZGC — latency, throughput, memory footprint, and when to use each one in production.
- [Understanding Structured Concurrency in Java](https://prabhat.dev/understanding-structured-concurrency-in-java/): Structured concurrency simplifies concurrent programming by managing tasks within a clear scope. Introduced in Java 19, it ties thread lifecycles to their scope, ensuring better error propagation, resource safety, and scalability. This paradigm shift makes Java concurrency easier to write, debug, and maintain, addressing traditional concurrency challenges effectively.
- [WebAssembly: Unlocking High-Performance Applications in the Browser](https://prabhat.dev/webassembly-unlocking-high-performance-applications-in-the-browser/): WebAssembly (Wasm) enhances web performance by allowing resource-intensive applications like gaming, video processing, and scientific simulations to run efficiently in browsers. Wasm complements it by handling performance-critical tasks, making it a powerful tool for creating high-performance web applications.
- [Functional Logging in Scala with Odin](https://prabhat.dev/functional-logging-in-scala-with-odin/): Functional logging in Scala with Odin using Cats-Effect, featuring structured logs, async logging, file loggers, minimal levels, and contextual effects.
- [Mastering Clean Code: A Guide to Writing Maintainable Software](https://prabhat.dev/mastering-clean-code-a-guide-to-writing-maintainable-software/): Discover how Robert C. Martin's "Clean Code" empowers developers to write clear, maintainable, and efficient software through essential best practices.
- [Mastering Git Branching Strategies: Why They Matter and How to Implement Them](https://prabhat.dev/mastering-git-branching-strategies-why-they-matter-and-how-to-implement-them/): We explores essential Git branching strategies like Feature Branching, Git Flow, GitHub Flow, and Trunk-Based Development, highlighting their significance in software development. It outlines the benefits of structured branching, such as improved collaboration, code quality, and efficient project management. Practical commands for each strategy are provided to help teams streamline workflows and enhance productivity, ultimately leading to more successful project outcomes.
- [Essentials for Securing Your API](https://prabhat.dev/essentials-for-securing-your-api/): Securing APIs is crucial to protect data and ensure trust. Key strategies include enforcing HTTPS, implementing strong authentication, rate limiting, input validation, using an API gateway, applying least privilege, rotating API keys, monitoring activity, configuring CORS, and using versioning. These measures enhance security and protect against unauthorized access, abuse, and potential attacks.
- [Why Monolith Is Not a Bad Idea](https://prabhat.dev/why-monolith-is-not-a-bad-idea/): Monolithic architecture is a practical choice for new projects, especially in Java, offering simplicity, ease of development, testing, and data consistency while reducing operational overhead. Successful companies like Basecamp, Shopify, and GitHub have effectively utilized monoliths. Starting with a monolith allows for a gradual transition to microservices, providing a strong foundation without premature complexity.
- [Understanding References and Borrowing in Rust](https://prabhat.dev/understanding-references-and-borrowing-in-rust/): The blog delves into Rust's concepts of references and borrowing, explaining how they allow functions to access values without transferring ownership. It covers mutable references, the dot operator, and Rust’s borrowing rules, especially in multithreaded scenarios. With a focus on memory safety and efficiency, the content highlights Rust's robust approach to managing references and ensuring safe concurrency.
- [Understanding Ownership in Rust: A Deep Dive](https://prabhat.dev/understanding-ownership-in-rust-a-deep-dive/): Rust's ownership model, central to its memory safety, ensures that each value has a single owner, preventing data races and memory leaks. When a value moves to a new variable, the original becomes invalid. Rust provides cloning for deep copies and offers references for more efficient, idiomatic memory management.
- [Understanding Strings in Rust: A Comprehensive Guide](https://prabhat.dev/understanding-strings-in-rust-a-comprehensive-guide/): Rust offers various string types, including &str for immutable slices and String for mutable, heap-allocated text. It also provides platform-specific and C-style strings like OsStr, OsString, CString, and CStr. Rust handles text using UTF-8 encoding, requiring proper methods for character access.
- [Control Flow in Rust: A Comprehensive Guide](https://prabhat.dev/control-flow-in-rust-a-comprehensive-guide/): Rust's control flow includes if, loop, while, and for constructs. if expressions return values without semicolons, loop supports infinite iterations, while checks conditions, and for iterates over collections and ranges. Rust’s approach emphasizes type safety and efficient execution.
- [Understanding Compound Types in Rust](https://prabhat.dev/understanding-compound-types-in-rust/): Rust’s compound types include tuples and arrays. Tuples group multiple values of different types and have a fixed size, while arrays hold multiple values of the same type and are also fixed in length. Both types are essential for organizing and managing data efficiently in Rust.
- [Exploring Scalar Types in Rust: A Detailed Guide](https://prabhat.dev/exploring-scalar-types-in-rust-a-detailed-guide/): Rust's scalar types include integers, floating-point numbers, booleans, and characters. Integers are signed or unsigned, floats have 32 or 64-bit precision, and booleans represent true/false. Characters are 4-byte Unicode values. Understanding these types is key to writing efficient and safe Rust code.
- [Understanding the SpringApplication.run Method in Spring Boot](https://prabhat.dev/understanding-the-springapplication-run-method-in-spring-boot/): We explore the process triggered by the SpringApplication.run() method in Spring Boot. You'll learn how the SpringApplication instance is initialized, how the environment and application context are prepared, and the key steps leading to the application's final startup. By understanding these mechanics, you'll gain a deeper insight into Spring Boot's efficient and seamless application launch process.
- [Understanding Functions in Rust: A Comprehensive Guide](https://prabhat.dev/understanding-functions-in-rust-a-comprehensive-guide/): Functions in Rust, declared with the fn keyword, follow snake case naming and can have typed parameters. The last expression without a semicolon is automatically returned, making the code concise. Flexible declaration order and clear return types contribute to writing efficient, maintainable Rust code essential for robust applications.
- [Introduction to Rust: A Journey into Safe and Fast Systems Programming](https://prabhat.dev/introduction-to-rust-a-journey-into-safe-and-fast-systems-programming/): Rust is a modern systems programming language known for its speed, memory safety, and thread safety. It combines the performance of low-level languages like C++ with the ease of high-level languages like Python. Created by Graydon Hoare at Mozilla, Rust addresses C++'s shortcomings, making it ideal for projects like Firefox Quantum. Rust’s package manager, Cargo, simplifies project management, while features like immutability, shadowing, and strict compile-time checks ensure safe and efficient code development.
- [Dynamic Environment Configuration in Spring Boot Using Profiles](https://prabhat.dev/dynamic-environment-configuration-in-spring-boot-using-profiles/): Learn how to use Spring Boot profiles to manage environment-specific services and configurations, ensuring flexibility and reducing deployment errors.
- [Building a Robust FIX Server with Java and QuickFix/J](https://prabhat.dev/building-a-robust-fix-server-with-java-and-quickfix-j/): Build a Robust FIX Server with Java & QuickFix/J: A comprehensive guide to creating efficient, secure, and compliant electronic trading applications.
- [Negative Space Programming](https://prabhat.dev/negative-space-programming/): When we think about programming, we often focus on what we write—the lines of code, the algorithms, the data structures.

## Pages

- [Cats Effect & fs2 Series](https://prabhat.dev/cats-effect-fs2/): A practical series on structured concurrency, resource safety, streaming, supervision, and production Scala systems with Cats Effect and fs2.
- [TypeScript for Backend Engineers](https://prabhat.dev/typescript-for-backend-engineers/): A practical series on TypeScript, Node.js, runtime boundaries, and production backend systems, written for backend engineers who already know how to build software.
- [Series](https://prabhat.dev/series/): In-depth series on the topics I care most about — each one built to take you from zero to production-ready.
- [GenAI Engineering Series](https://prabhat.dev/genai-series/): A structured series on building real AI systems — RAG pipelines, agents, LLM tooling, and production patterns.
- [Side Projects](https://prabhat.dev/side-projects/): Things I build outside of work — experiments, tools, and ideas I'm willing to ship.
- [Contact](https://prabhat.dev/contact/): I’m always open to thoughtful conversations about Scala, distributed systems, AI engineering, and building reliable software.
- [Newsletter](https://prabhat.dev/newsletter/): Deep dives on Scala, distributed systems, AI engineering, and the craft of building production software.
- [Uses](https://prabhat.dev/uses/): Senior Technical Architect working remotely.
- [Projects](https://prabhat.dev/projects/): A selection of projects from my 10+ years across fintech, enterprise, and distributed systems — what I built, the stack I used, and what my role actually was.
- [404 — Page Not Found](https://prabhat.dev/404-page/): The link might be broken or the page may have moved. Head back to the homepage or browse all articles below.
- [Blogs](https://prabhat.dev/blogs/): Structured concurrency simplifies concurrent programming by managing tasks within a clear scope.
- [My Projects](https://prabhat.dev/my-projects/): Developing business logic.
- [Terms of Service](https://prabhat.dev/terms-of-service/): These Terms of Service ("Terms") govern your access to and use of the website https://prabhat.dev (the "Site").
- [About Me](https://prabhat.dev/about-me/): Senior Technical Architect building backend, distributed, and AI-enabled systems.
- [Home](https://prabhat.dev/): New: AI Engineering Series is live.
- [Privacy and Cookie Policy](https://prabhat.dev/privacy-policy/): This Privacy and Cookie Policy explains how I collect, use, share, and protect information when you visit prabhat.dev, subscribe to the newsletter, or contact me.

## Optional

- [Agent (MCP protocol)](websites-agents.hostinger.com/prabhat.dev/mcp)

[comment]: # (Generated by Hostinger Tools Plugin)