Tech Articles
Build a Docusaurus-like Site with FastAPI: Step 5 - Handling Static Files
This post shows how to serve static files, like images referenced in Markdown, by mounting an `assets` directory in FastAPI, fixing broken links.
Build a Docusaurus-like Site with FastAPI: Step 4 - Parsing Frontmatter
This guide shows how to use python-frontmatter in FastAPI to parse Markdown metadata, like 'title', and dynamically pass it to a Jinja2 template instead of hardcoding it.
Optimizing Web Server JSON Performance with Byte Slice Reuse
Discover how leveraging Go's sync.Pool for byte slice recycling can significantly boost the JSON encoding and decoding performance of your web servers, reducing memory allocations and GC pressure.
The Subtle Pitfalls of context.Value and Optional Arguments
Exploring why context.Value is not the ideal mechanism for passing optional parameters in Go, despite its allure.
Common Go Web Development Pitfalls Global State and Default HTTP Clients
This article delves into two prevalent anti-patterns in Go web development – abusing `init()` for global state initialization and the issues associated with the default `http.Get` client – offering insights and best practices to avoid them.
Build a Docusaurus-like Site with FastAPI: Step 3 - Code Highlighting
This guide shows how to add code syntax highlighting to a FastAPI docs site using Pygments and `python-markdown` extensions, including setting up static CSS.
The Opinionated Structure of Go Projects
While the "Standard Go Project Layout" repository offers a widely referenced structure for Go projects, it may not be the optimal choice for many web applications. This article explores why its design principles, though well-intentioned, can introduce unnecessary complexity and cognitive overhead for typical web services, and offers alternative perspectives on project organization.
Deep Dive into Go's HTTP Client Transport Layer
Explore the nuances of Go's `http.Client` Transport layer, covering connection pooling, Keep-Alives, and mTLS for robust and secure HTTP communication.
Go Code Generation Evolved - The Interplay of `go:generate` and Generics
Exploring the evolving landscape of Go code generation, examining the role of `go:generate` amidst the rise of generics and whether one truly replaces the other.
Demystifying Postgres EXPLAIN Is Sequential Scan Always a Performance Blocker
Explores the nuances of PostgreSQL's sequential scan, challenging the common misconception that it's inherently bad and demonstrating scenarios where it's efficient.
Build a Docusaurus-like Site with FastAPI: Step 2 - Render Markdown
This article guides you through rendering Markdown files in a FastAPI application by installing `python-markdown`, creating a new route, and passing the converted HTML to a Jinja2 template.
Deep Dive and Migration Guide to Go 1.21+'s Structured Logging with slog
This article provides a comprehensive comparison of `slog` with existing Go logging solutions and offers practical guidance for migrating to `slog` for structured, efficient logging in Go applications.
Understanding and Mitigating Database Connection Exhaustion in High-Concurrency Web Applications
Explores why web applications face database connection exhaustion under high concurrency, detailing underlying mechanisms, common pitfalls, and practical solutions with code examples.
Choosing Your Test Double The Right Way in Go
This article explores the trade-offs between using httptest.NewServer for integration testing and mock service interfaces for unit testing in Go, offering practical guidance and code examples to help developers make informed decisions for robust and efficient testing strategies.
Build a Docusaurus-like Site with FastAPI: Step 1 - HTML Template
This guide explains the first step in building a documentation site with FastAPI: setting up the project and using Jinja2 to render a dynamic HTML template.
The Silent Killer Understanding NULL's Impact on Database Performance
NULL doesn't just mean "no value"; it has profound implications for how databases operate, especially when it comes to indexes, COUNT(), and JOINs. This article explores these often-overlooked effects and provides practical insights into mitigating them.
Dynamic Dispatch and Dependency Injection with Trait Objects in Rust Web Services
Explore how Rust's trait objects enable dynamic dispatch and dependency injection in web services, enhancing flexibility and testability.
Event Sourcing with a Single Database Table A Simplified Approach
This article explores implementing event sourcing using only a database table for event logging, offering a simpler alternative to Kafka while detailing its principles, implementation, and practical use cases with code examples.
Zero-Cost String Handling in Rust Web APIs with Cow
Explore how to leverage `Cow<'static, str>` for efficient and zero-cost string management in Rust web APIs, optimizing performance without unnecessary allocations.
Build Your Own Forum with FastAPI: Step 10 - Categories
This article explains how to add a "Categories" feature to a FastAPI forum by updating database models, modifying routes, and updating templates to organize posts by topic.
Choosing the Optimal UUID Type for PostgreSQL Primary Keys
This article thoroughly examines UUID v1, v4, and v7 as primary key candidates for PostgreSQL, explaining their characteristics, practical implications, and offering a data-backed recommendation for optimal database performance and scalability.
Unveiling Garde: Modern Validation in Rust with Trait-Based Design
Explore Garde, a modern, trait-based validation library for Rust, and witness its practical application within Axum and Actix web frameworks. This article delves into Garde's design principles, showcasing how it streamlines data validation for robust and maintainable Rust applications.
The Silent Killer of Databases - Why Logical Deletion Harms More Than Helps
This article delves into the common misconception of using `is_deleted = true` for data deletion, explaining why it's a harmful anti-pattern and proposing robust, maintainable alternatives for managing "deleted" data.
Understanding Send and Sync in Rust Async Handlers
Diving deep into why Rust's async handlers often complain about Send/Sync traits and how to properly address thread safety in concurrent code.
Build Your Own Forum with FastAPI: Step 9 - Upload Images
This guide details adding S3 image uploads to a FastAPI forum. It covers backend logic with `boto3`, database model changes, and updating FastAPI routes and HTML templates.
The Great Primary Key Debate for Modern Web Applications
A deep dive into the pros and cons of UUIDs, BIGINTs, and Natural Keys for primary key selection in modern web applications, exploring their implications on scalability, performance, and development.
Unveiling Observability: Tracing with Spans, Events, and Tower-HTTP in Rust
This article delves into the Rust `tracing` crate, elucidating its core concepts of spans and events, and demonstrates practical integration with `tower-http` for enhanced observability in web services.
Stream Processing with io.Reader and io.Writer in Go Web Development
This article delves into how io.Reader and io.Writer interfaces enable efficient stream processing for requests and responses in Go web applications, improving performance and memory usage.
Choosing Between Postgres Materialized Views and Redis Application Caching
This article delves into the critical decision-making process for leveraging Postgres materialized views versus Redis application-level caching, helping developers select the optimal data acceleration strategy for their applications.
Crafting Custom Extractors in Axum and Actix Web
Explore the power of `FromRequest` in Axum and Actix Web for building ergonomic and reusable custom extractors, enhancing code clarity and maintainability in Rust web applications.
Crafting Custom Errors and HTTP Status Codes in Go APIs
This article delves into the best practices for defining custom error types in Go APIs and mapping them elegantly to appropriate HTTP status codes, enhancing error handling and API clarity.
Build Your Own Forum with FastAPI: Step 8 - Full Text Search
This guide adds a powerful full-text search to a FastAPI forum using PostgreSQL's `tsvector`, SQL triggers, and a new search route.
Why Database Triggers Often Lead to Trouble
This article delves into the reasons why database triggers should generally be avoided, emphasizing the placement of business logic outside the database for better maintainability and scalability.
Actix's Actor Model - A Web Request Panacea or Pitfall?
Exploring the suitability of Actix's Actor Model for handling web requests in Rust, discussing its benefits, complexities, and real-world implications.
Decoding the Intricacies of JSON with json.RawMessage and Custom Unmarshaling
Explore how json.RawMessage and custom UnmarshalJSON in Go empower developers to handle complex and evolving JSON structures with grace and efficiency, preventing data loss and enhancing flexibility.
Achieving Robust Multi-Tenant Data Isolation with PostgreSQL Row-Level Security
Explore how PostgreSQL's Row-Level Security (RLS) offers a database-native solution for ensuring strict data isolation in multi-tenant applications, moving beyond application-level enforcement.
Build Your Own Forum with FastAPI: Step 7 - Permissions
This guide implements a permission system for the FastAPI forum, adding admin roles and a user-banning feature with model updates and protected routes.
Active Record and Data Mapper in Rust ORMs
A deep dive into the architectural philosophies of Sea-ORM (Active Record) and Diesel (Data Mapper), exploring their design, implementation, and use cases in the Rust ecosystem.
Understanding and Debugging Goroutine Leaks in Go Web Servers
This article delves into common scenarios causing goroutine leaks in Go web servers, explains the underlying mechanisms, and provides practical methods for detection and resolution.
Authentication or Authorization Deciding the Right Fit for Your Backend
Navigating the complexities of user identity and access control is a common challenge for backend developers. This article demystifies OIDC and OAuth 2.0, helping you choose the appropriate solution for authentication or authorization in your applications.
Understanding Pin in Rust Async for Web Developers
Delve into the core concept of `Pin` in Rust's async ecosystem, explaining why it's crucial for web developers building performant and safe asynchronous applications.
Build Your Own Forum with FastAPI: Step 6 - Comments and Replies
This guide details adding comment and reply functionality to a FastAPI forum by updating database models, creating a new `post_detail.html` template, and implementing backend routes.
Efficiently Orchestrating External API Calls with Go Fans
Discover how Go's Fan-In, Fan-Out pattern unlocks powerful concurrency for processing data from multiple external APIs, enhancing performance and scalability.
Designing Observable APIs from the Ground Up
Integrating logging, metrics, and tracing into API design processes for robust and maintainable backend systems.
Accelerating Rust Web App Builds
Exploring the reasons behind slow Rust web application compilation and how to dramatically speed it up using sccache, cargo-watch, and advanced linkers like lld/mold.
Choosing Your PostgreSQL Connection Proxy
A deep dive into PgBouncer and Pgpool-II, two popular connection pooling solutions for PostgreSQL, exploring their features, use cases, and how to select the right one for your needs.
Build Your Own Forum with FastAPI: Step 5 - Editing Posts
This tutorial explains how to add a secure post-editing feature to a FastAPI forum. It covers creating templates, adding API routes, and verifying user ownership before allowing edits.
From Monolith to Modularity Refactoring Go Web Applications
This article delves into the crucial process of refactoring a monolithic Go web application, initially housed in a single main.go file, into a modular, maintainable, and scalable project structure. It covers the rationale behind this transformation, core concepts, practical implementation steps with code examples, and the significant benefits reaped.