Tech Articles
A Deep Dive into Slice and Map Expansion in Go
Explains Go’s slice and map expansion strategies, covering growth triggers, resizing rules, and performance impacts.
Inside Playwright and Puppeteer: From Architecture to Real-World Scenarios
In the field of browser automation, Playwright (by Microsoft) and Puppeteer (by Google) stand as the two most mainstream tools. However, they exhibit significant differences in design philosophy, technical implementation, and applicable scenarios. This article will start with core concepts and provide a comprehensive analysis of the technical characteristics and future directions of these two tools through detailed comparisons, scenario analysis, and limitation breakdowns.
Beyond SOLID: KISS, DRY, and LOD Principles in Go
Explains KISS, DRY, and LOD principles to improve code simplicity, reusability, and low coupling.
Learn How to Write a Mini SQL Parser in Python (Step by Step)
The essence of SQL parsing is to "convert text into structured data", which relies on two core steps: "splitting into Tokens via lexical analysis" and "building an AST via syntactic analysis". Although the simple parser implemented in this article using ply is not sufficient for production environments, it can help you understand the working principles of parsers.
SOLID Design in Go
A practical guide to applying SOLID design principles in Go for robust and testable code.
The Go 1.25 Upgrade: Generics, Speed, and What You Need to Know
Go has taken another significant step forward on its journey of continuous evolution! On August 12, 2025, the Go team officially released version 1.25, bringing a series of exciting new features and performance optimizations. As a regular update every six months, this version not only upholds Go's tradition of prioritizing practicality and stability but also delivers notable improvements in generic support, performance optimization, and standard library enhancement. Let’s dive deep into the highlights of Go 1.25 while reviewing the key updates since Go 1.20.
Understanding Weak Pointers in Go 1.24
Introduction to Go 1.24 weak pointers, their usage, differences from strong references, and common scenarios.
Go unsafe: When to Use It, and Why It’s Dangerous
In the world of Go, "type safety" is a core feature emphasized repeatedly—the compiler acts like a strict doorman, preventing you from force-converting an int pointer to a string pointer and forbidding arbitrary modifications to a slice’s underlying capacity. However, there is one package that deliberately "challenges the rules": unsafe.
Why UUIDs Almost Never Collide: A Python Deep Dive
UUID is an exquisite unique identifier generation scheme. It ensures that identifiers generated in distributed systems almost never repeat through a huge space, well-designed randomness, and the combination of time and space.
From Goroutine to Channel: Understanding Go's CSP Model
Explains Goroutines, Channels, and Go’s CSP model with usage, synchronization, and communication tips.
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.