Tech Articles
How FastAPI Works Under the Hood: ASGI and Routing Explained
When we talk about Python asynchronous web frameworks, FastAPI is undoubtedly the brightest star in recent years. It has gained widespread acclaim for its impressive performance, automatic API documentation generation, and type hint support. But have you ever wondered: what magic lies behind this powerful framework?
Why Axum Could Be the Future of Rust Web Development
If you're a Rust developer, you've undoubtedly heard of Axum. This web framework, introduced by the Tokio team, has rapidly become a community favorite in just a few years, boasting over 22k GitHub stars—far surpassing other frameworks of the same era. What makes Axum stand out? What unique advantages does it offer compared to predecessors like Actix-web and Rocket? Today, we'll delve into this phenomenal framework.
Efficient Go Concurrency Using select
Understand Go's select to coordinate goroutines and channels effectively.
any vs interface{} in Go: What’s the Real Difference?
In a recent team discussion, someone claimed "any and interface{} in Go are identical." Technically, they're right—Go's official definition makes any an alias for interface{}
NestJS in 2025: Still Worth It for Backend Developers?
In 2025, amid the ever-proliferating landscape of JavaScript backend frameworks, NestJS remains the unrivaled leader in enterprise-level application development. Since its initial release in 2017, this Node.js-based framework has not only withstood the pressure from predecessors like Express and Koa but also fended off challenges from rising stars such as Fastify and Adonis. Instead, it has amassed over 60k stars on GitHub, securing a spot among the world's top 5 backend frameworks. What enables NestJS to break the "three-year cycle" curse of frontend frameworks? What irreplaceable reasons make it a top choice in 2025?
Infinite Uses of Go's Empty Struct
Explore Go's zero-size struct type: definition, behavior, and practical uses in sets, channels, and interfaces.
Why Django Is Still the Web Dev King in 2025
In the fast-paced world of web development, where new frameworks emerge seemingly every other day, Django has maintained its relevance and popularity since its inception. As we enter 2025, a question on many developers' minds remains: why should we still use Django? Let's explore the reasons in detail.
Python Web Framework Wars: Flask’s Legacy vs FastAPI’s Future
In the universe of Python web development, Flask and FastAPI shine like two brilliant stars, each representing distinct development philosophies. Flask is renowned for its lightweight flexibility as a "micro-framework," while FastAPI has sparked a new trend in API development with its asynchronous support and type safety. This article will delve into a comparison of these two frameworks across ecosystem, asynchronous programming, and development experience, revealing their scene through abundant examples to help developers make informed choices for different project requirements.
Go's Functional Options Pattern
Learn how Go's functional options pattern enhances flexibility, readability, and extensibility in function signatures.
Actix vs Axum vs Rocket: The Battle of Rust Web Frameworks
In the dynamic landscape of web development, Rust has emerged as a formidable language, celebrated for its memory safety, high performance, and concurrency capabilities. As the Rust ecosystem continues to expand, a diverse array of web frameworks has surfaced, each boasting unique features and trade-offs. This in-depth exploration compares some of the most popular Rust web frameworks, examining their architectures, performance traits, and ecosystem support.
Why Go Won't Simplify Error Handling
After three failed attempts, Go team confirms no future error handling syntax changes, focusing on tooling improvements.
Your Rust Is Too Slow - 20 Practical Ways to Optimize Your Code
Rust, as a performance-focused systems programming language, has demonstrated excellent performance in many scenarios. However, to fully unleash Rust's potential and write efficient code, it's necessary to master some performance optimization techniques. This article will introduce 20 practical tips for Rust performance optimization, with specific code examples to aid understanding.
Go in Production: 20 Must-Know Performance Tuning Tips
As an engineer who has spent years building backend services with Go, I'm keenly aware of the language's immense performance potential. But potential needs to be properly unlocked. There's a world of difference between merely implementing a feature and building a system that runs stably and efficiently under high concurrency. Poor coding habits and a disregard for underlying mechanics can easily negate the performance advantages Go offers at the language level.
sync.Once: Go's Simple Pattern for Safer Concurrency
In Go concurrent programming, ensuring an operation is executed only once is a common requirement. As a lightweight synchronization primitive in the standard library, sync.Once solves this problem with an extremely simple design. This article takes you to a deep understanding of the usage and principles of this powerful tool.
Rate Limiting in Go: Implementing the Token Bucket Algorithm
The Token Bucket Algorithm provides a flexible and efficient way to implement rate limiting and traffic shaping in a wide range of applications. Its ability to handle both steady traffic and sudden bursts makes it particularly valuable in real-world systems where traffic patterns are often unpredictable.
The Dark Side of Python’s eval() (and When It’s Actually Useful)
`eval()` is a powerful yet controversial built-in function in Python. Its working principle is to parse, compile, and execute Python code passed as a string, and it is widely used in scenarios such as dynamic expression calculation and dynamic data structure processing. However, `eval()` also has risks such as security vulnerabilities and performance loss, so caution is required when using it.
Understanding sync.Once in Go
Learn how to use sync.Once for concurrency-safe, lazy initialization in Go.
How to Implement Enum Types in Go
Learn how to create and use enums in Go without native enum support.
Understanding SQL Common Table Expressions (CTEs)
CTEs simplify, organize, and enable recursive SQL queries efficiently.
Understanding SQL Aggregate Functions
SQL aggregate functions simplify data summarization and analysis.
How to Rank Data in SQL: An Introduction to Window Functions
SQL ranking functions help order and analyze data with or without grouping.
A Comprehensive Guide to iota in Go
Explains Go’s iota, its uses in constants, enums, and bitwise operations, with tips and best practices.
A Practical Guide to Go’s Timer and Ticker
Explains Go’s Timer and Ticker with usage, differences, and resource management tips.
Build a Pure Node.js Search Engine from Scratch Using Only Node.js
In the era of information explosion, search engines have become the core tool for people to access information. From Google to Bing, these large-scale search engines are backed by complex technical architectures, but their core principles can be implemented using basic technology stacks. This article will guide you through building a TF-IDF algorithm-based English search engine from scratch using pure Node.js, without any third-party libraries, storing the inverted index in CSV files. Through this practice, you will gain a deep understanding of the core mechanisms of information retrieval and master key technologies in text processing, weight calculation, and index construction.
From Cache Breakdown to Robustness: singleflight in Go
Learn how Go’s singleflight package prevents cache breakdown and optimizes concurrent database access.
Build a Search Engine in Pure Python, Step by Step — No Dependencies Needed
Through this article, we've built a TF-IDF-based English search engine from scratch without relying on any third-party libraries, and stored the key inverted index in CSV format. This process has allowed us to gain an in-depth understanding of the core principles and implementation details of search engines, including key steps such as document preprocessing, inverted index construction, TF-IDF calculation, and query processing. While this implementation is relatively simple, it covers the basic framework of modern search engines. On this foundation, you can further expand the functionality and optimize performance to build a more powerful retrieval system. Whether for academic research or practical applications, understanding these basic principles is an important step in deepening your knowledge of information retrieval technology. We hope this article has opened the door to the field of information retrieval for you, inspiring your interest and desire to explore search engine technology. In this era of information explosion, mastering information retrieval technology not only helps us obtain information more efficiently but also provides a solid foundation for research in fields such as data mining and artificial intelligence.
Understanding Grouping in SQL Queries
Grouping in SQL helps summarize and analyze data efficiently.
Understanding CTEs (Common Table Expressions) in SQL
CTEs simplify, organize, and enhance complex SQL queries.
Understanding Condition Statements in SQL
Condition statements enable precise, efficient data filtering in SQL.
How to Build a Event Bus in Go
A practical guide to building a simple event bus in Go using publish-subscribe patterns and channels.
Clean Architecture in Go Using go-clean-arch
Explains how to implement Clean Architecture in Go with practical examples from the go-clean-arch project.
Log Rotation and File Splitting in Go: Insights from logrus, zap, and slog
Comparative analysis of log rotation and file splitting with Go logging libraries logrus, zap, and slog.
How to Rename a Column in SQL
Different SQL databases require different commands to rename columns.
How to Add a Column in a Table Using SQL
Add columns to SQL tables using the `ALTER TABLE` statement.
PyTorch Lightning: Simplifying Deep Learning Research and Production
PyTorch Lightning simplifies deep learning research and scalable model deployment.
Hands-on with Go’s slog Package
Learn how to use Go’s slog package for clear, structured, and customizable application logs.
How to Download and Install PyTorch
Step-by-step guide for installing PyTorch on any system.
How to Install PyTorch Using Pip
Install PyTorch easily using pip and verify your setup for smooth deep learning.
A Practical Overview of PyTorch Geometric for Graph Neural Networks
PyTorch Geometric enables fast, flexible graph deep learning with scalable, research-friendly features.
Effective Error Handling in Go’s Gin Framework
Best practices for error management and real-time error tracking in Gin-powered Go web services.
How to Install PyTorch Using Conda
Use Conda and official commands for reliable PyTorch installation.
Understanding PyTorch DataLoader: Efficient Data Loading for Deep Learning
PyTorch DataLoader enables efficient, flexible, and scalable deep learning data handling.
TensorFlow vs PyTorch: A Comparative Analysis for 2025
PyTorch leads in research; TensorFlow excels in production deployment.
Comparing MVC and DDD Layered Architectures in Go: A Detailed Guide
A comprehensive comparison of MVC and DDD layered architectures in Go, with structure, examples, and practical guidance.
Boost Go Performance Instantly with Sync.Pool Explained
In concurrent programming, the frequent creation and destruction of objects can lead to significant performance overhead. The `sync.Pool` mechanism in Go language effectively reduces memory allocation and garbage collection pressure through object reuse strategies. This article will provide a comprehensive analysis of this high-performance component, covering usage scenarios, core principles, and practical optimizations.
Learning Go Testing from Kubernetes
A practical guide to unit testing, mocking, and TDD in Go, inspired by real-world Kubernetes practices.
Learning Go Engineering Practices from Kubernetes
Key Go engineering lessons from Kubernetes: efficient concurrency, modular architecture, abstraction, and decoupled component design.
Learning Code Readability from Kubernetes
Practical lessons on naming and commenting for clearer, more maintainable code, inspired by Kubernetes source.