Articles
Building a Template Engine from Scratch (Like Jinja2 or Django Templates)
It is hoped that through this simple academic example, you can have a preliminary understanding of the working principle of the template engine. Although this code is still far from being production-level, it can serve as a basis for developing more complete tools.
How to Use `range` as a `foreach` in Go
Use Go's `range` to iterate like `foreach` across common data types.
Understanding Go's `fallthrough`: How and When to Use It
How Go’s `fallthrough` works and why it must be used carefully.
How to Copy a File in Go (Golang)
A practical guide to copying files in Go using `io.Copy` and `os` utilities.
Domain-Driven Design Made Simple: A Developer's Perspective
A hands-on guide to Domain-Driven Design with real-world code comparisons.
HTMX: Rethinking the Frontend - Forget React
HTMX has reopened the door to front-end development for non-front-end engineers. If you are not developing applications with extremely high interactivity like spreadsheets or Google Maps, basically, you can make good use of HTMX to replace the existing front-end development frameworks and return to the lightweight front-end development mode centered around HTML. With HTMX, you don't need to struggle with whether to implement the client as a SPA or an MPA. You can choose the most suitable way for routing, display data in the most natural way, and let users interact with the data (whether it is creating, reading, updating, deleting, or other operations).
How to Pretty Print Structs in Go
Quickly format Go structs with `fmt`, JSON, or `spew` for better readability.
How to Uninstall Golang from Windows, macOS, and Linux
Step-by-step guide to completely uninstall Go from any OS.
How to Get the Current Working Directory in Python
Simple ways to get the current working directory in Python using `os` and `pathlib`.
In-Depth Guide to Redis Persistence Mechanisms
Explains Redis-based delayed queues, challenges, solutions, and advanced usage patterns.
Go’s sync Package: A Set of Concurrency Synchronization Techniques
The types in the `sync` standard library package play a crucial role in the concurrent programming of the Go language. Developers need to reasonably select and correctly use these synchronization types according to specific business scenarios and requirements, so as to write efficient, reliable and thread-safe concurrent programs. At the same time, when writing concurrent code, it is also necessary to have an in-depth understanding of various concepts and potential problems in concurrent programming, such as data races, deadlocks, etc., and ensure the correctness and stability of the program in a concurrent environment through sufficient testing and verification.
Understanding `defaultdict` in Python
Simplifies key handling in Python dictionaries using default values.
Enhancing Python Applications with Tenacity: A Guide to Robust Retry Mechanisms
Flexible Python retry library for building fault-tolerant applications.
Mastering Command-Line Interfaces with Python argparse
Build user-friendly CLIs in Python using `argparse`’s powerful features.
Redis Delayed Queues Made Simple
Explains Redis-based delayed queues, challenges, solutions, and advanced usage patterns.
Next.js vs PHP: A Side-by-Side Code Comparison for Web Development
Nextjs and writing business code directly in PHP pages each have their own characteristics. Nextjs is suitable for building modern and highly interactive web applications, and it performs excellently in performance optimization, component reuse, and development efficiency, but it requires a higher level of front-end technology stack from developers; PHP, with its simple and direct approach, has certain advantages in quickly building dynamic web pages and handling traditional business logic. However, developers need to be more cautious in terms of code maintainability and security. When choosing, developers should comprehensively consider factors such as the specific requirements of the project, the team's technical capabilities, and future extensibility to select the most suitable technical solution for web business development.
Understanding the `__str__` Method in Python
Define `__str__` to make Python objects print-friendly and readable.
Understanding `__init__.py` in Python Packages
Role and benefits of `__init__.py` in Python packages.
How to Perform Matrix Multiplication in Python
Matrix multiplication in Python using NumPy and `@` operator.
The Lifecycle of an INSERT Statement in MySQL
Detailed breakdown of MySQL's internal steps when handling an INSERT query.
Under the Hood: FastAPI Is Just Starlette + Pydantic
The combination of Starlette and Pydantic can build high-performance and feature-rich APIs without relying on the encapsulation of FastAPI. Starlette provides a flexible ASGI application foundation, supporting core functions such as asynchronous processing, middleware, and WebSocket; Pydantic focuses on data validation and serialization. Although FastAPI simplifies the development process, directly using Starlette and Pydantic allows developers to have a deeper understanding of the underlying principles, make highly customized adjustments according to project requirements, and show stronger adaptability in complex scenarios.
How to Iterate Through a List in Python
Practical ways to iterate through Python lists efficiently.
Exponentiation in Python: A Practical Guide
Python’s exponentiation tools: `**`, `pow()`, and `math.pow()` simplified.
Understanding "Does Not Equal" (`!=`) in Python
How Python's `!=` operator works and when to use it.
How to Generate Random Integers in Python
Overview of methods to generate random integers in Python.
Comparing Strings in Python
Basic and advanced techniques for comparing strings in Python.
How to Sort a Dictionary by Value in Python
Sort Python dictionaries by value using `sorted()` and lambdas.
Understanding Redis Cluster: How Clients Access the Right Shard
Overview of Redis Cluster architecture, sharding, and how clients locate the right node
Understanding `None` in Python: The Equivalent of `null`
`None` is Python’s way to represent "no value" safely and clearly.
How to Round Numbers in Python
Rounding in Python: built-in, math, decimal, and NumPy methods.
Understanding Floor Division in Python
Python's `//` operator performs floor (integer) division.
Understanding the `or` Operator in Python
How Python's `or` operator evaluates conditions and returns results.
Understanding Python's `replace()` Method for String Manipulation
Basic use and behavior of Python's `replace()` method.
A Comprehensive Guide to Python Visualizers for Learning and Debugging
Visualize Python code execution for better learning and debugging.
Redis Distributed Locks: 10 Common Mistakes and How to Avoid Them
Common Redis distributed lock pitfalls and how to avoid them in real-world applications.
How to Append One List to Another in Python
Different ways to append lists in Python and when to use them.
Understanding Python's `.split()` Method
Python `.split()` splits strings efficiently for parsing and processing.
How to Uninstall Python: A Comprehensive Guide
Safely uninstall Python without harming your system.
How to Flatten a List of Lists in Python
Common ways to flatten Python lists efficiently.
How to Add Elements to a Set in Python
How to use `add()` and `update()` to manage Python sets.
Understanding `try` and `except` in Python
Python `try`-`except` helps manage and handle errors cleanly.
Deep Dive into JWT: Build FastAPI Authentication in Pure Python
Through the above steps, you have learned how to use JWT for authentication in FastAPI. JWT provides a secure and convenient way to manage user identities, making authentication between distributed systems more efficient. In practical applications, you can adjust the generation and verification logic of JWT according to your needs, such as adding an expiration time, customizing claims, etc.
MySQL Table Locking: What Happens When You Add a Column or Index?
How MySQL handles table locks when adding columns or indexes
Quicktemplate for Go: Like Jinja2 for Python, but Never html/template
Recently, when organizing the code of our project, I found that the code for many activities was very similar in structure and the functions it provided. To facilitate future development, I spent some time writing a tool for generating code frameworks to minimize repetitive work. The code itself is not complex and is closely related to the project code, so I won't go into details here. During this process, I found that the Go standard template libraries `text/template` and `html/template` were rather restrictive and inconvenient to use. I learned from GitHub about the third-party template library `quicktemplate`, which is powerful, has a simple syntax, and is easy to use. Today, we're going to introduce `quicktemplate`.
Python Module Management: A Practical Guide
Efficient tools and structure improve Python module management.
How to Import Modules from Another Directory in Python
Ways to import Python modules from external directories.
A Practical Guide to Python Virtual Environments: Comparison and Usage
Comparison and guide for Python virtual environments.
How to Update Python: A Comprehensive Guide
Steps and tools to safely update Python across OSes.