Articles
Getting to Know Generic Associated Types in Rust
Dive into Generic Associated Types: the gateway to higher-kinded types in Rust.
Golang Metaprogramming: Why You Should Try in 2025
Although the Go language does not directly provide metaprogramming features, with the help of mechanisms and tools such as code generation, reflection, interfaces, and type assertions, developers can achieve metaprogramming effects, manipulate the code during the programming process, improve the level of abstraction of the code, and enhance the understandability and maintainability of the code. However, when using these techniques, it should be noted that they may introduce complexity and increase the performance overhead at runtime. In reflection operations, various potential errors and boundary conditions should be handled carefully to ensure the stability and efficiency of the code.
Understanding Generics in Rust: A Complete Guide
A comprehensive overview of using generics in Rust functions, structs, enums, and methods.
Deep Dive into Fastify: The High-Performance Node.js Web Framework
Fastify is an efficient and fast Node.js web framework designed to provide optimal performance. Although it is relatively new, it has won the favor of many developers due to its high performance and low overhead. Fastify offers a concise development experience, supports fast routing and a plugin architecture, making it easy for developers to build and expand applications.
Rust’s Atomics Explained: The Indivisibles of Concurrency
An in-depth guide to atomic types, operations, and memory ordering in Rust concurrency.
Go vs Rust/C++: A Comparison of Goroutines and Coroutines
Through an in-depth analysis of stackful and stackless coroutines, we have a clearer understanding of their underlying implementations. Although stackful and stackless coroutines are named according to the context storage mechanism, their essential difference lies in whether they can be suspended in any nested function. This difference determines that stackful coroutines have higher freedom when suspended and are more convenient in terms of being compatible with existing synchronous code; while stackless coroutines, although limited in the freedom of suspension, have higher performance and better memory management capabilities. In practical applications, the appropriate type of coroutine should be selected according to specific needs.
Fearless Concurrency in Rust: Taming Threads Without Losing Sleep
An introduction to Rust's fearless concurrency model with threads, channels, and shared state.
HTTP 1.0 vs 1.1 vs 2.0: A Deep Dive Comparison
HTTP (HyperText Transfer Protocol) is the most widely used network protocol on the Internet, and all WWW files need to follow this standard. Its original design goal was to provide a method for publishing and receiving HTML pages, which is used to transfer hypertext from a WWW server to a local browser, and it uses port 80 by default. When an HTTP client initiates a request, it will establish a TCP connection to the specified port of the server (port 80 by default).
Why You Might Be Using Go’s Equality Operator Wrong
This article comprehensively and in-depth introduced the detailed details of the `==` operation in Go language, covering the behavior of the `==` operation under different data types, the comparison rules of special types, and the impact brought by uncomparable types. It is hoped that through the elaboration of this article, it can help the majority of developers to more accurately and deeply understand and apply the `==` operation in Go language, and avoid various problems caused by insufficient understanding of it in actual programming.
Beginner's Guide to Concurrent Programming in Rust
First steps into concurrent programming in Rust using threads and async
Build a Web App Using Pure Python (No Flask, No Django, No Frameworks!)
Those who have written Python web applications, especially those who have carried out online deployments, must have heard of the WSGI protocol. It defines the data exchange interface between Python's web servers and web applications. This description may be rather abstract, so let's explain it in detail through practical examples below.
Async Programming in Rust: Composing Futures with join!, try_join!, and select!
Learn to run multiple Rust Futures concurrently using join!, try_join!, and select! macros.
The 5 Most Popular Node.js Web Frameworks in 2025
In 2025, the above backend frameworks have stood firm in the market. Whether you choose Express.js for its simplicity, Nest.js for its structure, Adonis.js for its productivity, or Koa.js for its elegance, choosing the right framework is crucial. It always depends on your requirements. It is essential to understand your project requirements and, based on that, select the appropriate framework. Additionally, keeping an eye on the latest trends, new features of existing frameworks, and new frameworks is crucial for the success of your backend development journey in 2025.
Async Programming in Rust: Stream Trait and Its Design
Learn how to use and implement asynchronous streams in Rust using the Stream trait.
Negroni vs. Other Go Middleware Solutions: What Makes It Unique?
Negroni is a very valuable library in Go language HTTP service development. For those who pursue efficient, flexible, and easy-to-maintain Web application development, Negroni is undoubtedly an excellent tool worthy of in-depth understanding and widespread application.
Async Programming in Rust: Futures, Executors, and Task Scheduling
Learn how Rust executes async tasks using Futures, Executors, and the Waker mechanism.
Go & Gorilla/Mux: Everything You Need to Build a Web App
This article introduces the lightweight and powerful routing library `gorilla/mux`. It supports a rich variety of request matching methods, and sub-routes greatly facilitate route management. Since it is compatible with the standard library `net/http`, it can be seamlessly integrated into programs using `net/http` and make use of the middleware resources written for `net/http`. In the next article, we will introduce `gorilla/handlers` — some commonly used middleware.
Understanding Async/Await in Rust
An introduction to Rust's async/await, explaining Futures, executors, and concurrency with practical examples.
Validator: Advanced Struct and Field Validation For Go
The leapcell library (validator) is very rich in functions and relatively simple and convenient to use. The constraint conditions introduced in this article are just the tip of the iceberg of its powerful functions. This library has a wide range of applications in the field of software development, especially web development. It is recommended that developers have an in-depth understanding and mastery of it to improve the efficiency and accuracy of data validation and ensure the security and stability of the system.
Implementing a Rule Engine in Go with Govaluate
Although the operations and types supported by govaluate are limited, it can still implement some interesting functions. For example, you can write a web service that allows users to write their own expressions, set parameters, and let the server calculate the results.
How to Use `json.MarshalIndent` in Golang
Format JSON in Golang with `json.MarshalIndent` for better readability.
Understanding Getters in Go
Go encourages direct field access, using getters only when necessary.
How to Copy a Struct in Golang
Shallow copy is simple, but deep copy is necessary for reference types.
Understanding Bitwise Operations in Go
Bitwise operations in Go improve efficiency in arithmetic, masking, and binary data handling.
Iterating Over Maps in Go: Methods, Order, and Best Practices
Efficiently iterate over maps in Go using `for`-`range`, handling unordered iteration and sorting when needed.
Understanding Global Variables in Go
Avoid excessive use of global variables in Go to maintain modularity and testability.
Why Using UUID as a Primary Key in MySQL Can Hurt Performance
UUID primary keys may cause index fragmentation, slow queries, and storage overhead in MySQL.
Go Flag Library: A Complete Guide to CLI Arguments
`flag` is used to parse command-line options. People with experience using Unix-like systems should be familiar with command-line options. For example, the command `ls -al` lists detailed information about all files and directories in the current directory, where `-al` is the command-line option.
Gopsutil: Efficient System Monitoring in Go
The gopsutil library provides convenience for us to obtain local machine information, and it handles the compatibility issues between different systems well, providing a unified interface. There are also several sub-packages, such as `net` and `docker`, which are not introduced here due to space limitations. Users who are interested can explore them on their own.
Understanding jemalloc: A Rust Performance Booster
Learn how jemalloc optimizes memory management
How to Manage Go Versions with ASDF
Guide to installing and managing Go versions using ASDF efficiently.
Building an Efficient Web Scraper in Golang
Efficiently build responsible Go web scrapers using Colly, concurrency, and policy compliance.
Understanding Constructors in Go
Go uses factory functions for struct initialization and validation.
Exploring TUI Libraries in Go
Overview of key Go libraries for developing robust and interactive TUIs.
Why Choose Go Over Ruby on Rails?
Go excels in scalability and performance, while Rails suits rapid development.
Implementing Linked Lists in Go
Guide to implementing and using linked lists in Go.
Exploring Graphics Libraries in Go
Overview of Go's graphics libraries for drawing, visualization, and GUI development.
How to Delete from a Map in Golang
Efficient ways to delete elements from a Golang map.
Handling Command Line Arguments in Golang
Learn how to handle command line arguments in Golang using `os.Args`, `flag`, and `pflag`.
How to Read Rust Source Code Effectively: A Practical Approach
An essential guide to navigating Rust’s source code
Type-Safe SQL in Go with sqlc
The interfaces provided by the `database/sql` standard library in the Go language are relatively low-level. This requires us to write a large amount of repetitive code. This substantial amount of boilerplate code is not only cumbersome to write but also error-prone. Sometimes, if you modify the field type, you may need to make changes in many places; if you add a new field, you also need to modify the places where the `select *` query statement was previously used. If there are any omissions, it may lead to a panic during runtime. Even if you use an ORM library, these issues cannot be completely resolved! That's where sqlc comes in! sqlc can generate type-safe and idiomatic Go interface code based on the SQL statements we write, and we just need to call these methods.
How Rust Lost the Race to Go?
In today's programming world, both Go and Rust are highly regarded programming languages. Developed by Google, Go is renowned for its simplicity, efficiency, and excellent concurrency performance. It is commonly used for building network services, cloud computing platforms, and more. Rust, promoted by Mozilla, is famous for its memory safety and high performance, and it has a wide range of applications in areas such as system programming and embedded development. This article will conduct a detailed comparison of the code writing in Go and Rust from multiple aspects.
Deep Dive into Rust’s Smart Pointers
Learn how Rust's smart pointers ensure safe memory allocation, ownership, and concurrency.
TypeScript Meets Go: Understanding the 10x TypeScript
The code name of the new TypeScript migration project is Corsa. The old codebase, Strata, was once the initial code name of TypeScript, which began in the internal development stage at the end of 2010 or the beginning of 2011. The initial team consisted of Steve Lucco, Anders Hejlsberg, and Luke. Steve wrote the original prototype compiler, extracting and modifying the scanner and parser from the JavaScript engine of Internet Explorer. It was a C# codebase used for the proof of concept.
Rust Error Handling Deep Dive: Beyond Result and Option
A practical approach to Rust error handling: methods, patterns, and custom error strategies.
Mastering `fmt.Fprintf` in Go: A Guide to Formatted Output
`fmt.Fprintf` in Go enables efficient, formatted output to diverse destinations.
Understanding Anonymous Structs in Golang
Anonymous structs in Go simplify temporary data handling but can reduce readability if overused.
Machine Learning in Golang: An Overview of Popular Libraries and Examples
An introduction to machine learning in Go with key libraries and examples.