Tech Articles
Understanding File Globbing in Go
Go’s `filepath.Glob` simplifies file pattern matching, but for advanced globbing, use third-party packages.
Exploring Golang Backend Frameworks
Golang’s backend frameworks offer high performance, scalability, and simplicity for web development.
Deep Dive into Rust Traits: Inheritance, Composition, and Polymorphism
A guide to Rust traits, covering definition, implementation, inheritance, composition, and polymorphism.
Understanding Go's Abstract Syntax Tree (AST)
Go's AST enables source code analysis, transformation, and tooling development.
Generating Random Numbers in Go
Guide to generating random numbers in Go using `math/rand` and seeding techniques.
Understanding Golang JSON Tags
Golang JSON tags customize struct field encoding, supporting options like `omitempty`, `-`, and `string`.
Understanding Generic Functions in Go
Go generics enhance flexibility, reusability, and type safety in function design.
Understanding Golang's Garbage Collector
Go’s concurrent GC efficiently manages memory using mark-and-sweep with minimal pause times.
Understanding Classes in Go
Go replaces classes with structs, methods, and interfaces to simplify software design.
Understanding Dictionaries in Go: The `map` Data Structure
Go maps efficiently store key-value pairs but require initialization and have unpredictable iteration order.
Understanding Closures in Go: Capturing Variables for Flexible Functions
Closures in Go enable flexible, encapsulated, and dynamic function behaviors.
How to Check if an Array Contains a Specific Element in Go
Check for element existence in Go using iteration or maps for efficiency.
Understanding Struct Inheritance in Go
Go replaces traditional inheritance with struct composition and interfaces for flexibility.
Understanding the `omitempty` Tag in Go's JSON Encoding
The `omitempty` tag removes empty fields in Go's JSON encoding, affecting struct handling.
Understanding the `goto` Statement in Go
The `goto` statement in Go enables jumps but should be used sparingly for readability.
Goose: A Database Migration Tool for Go
Goose simplifies and automates database migrations in Go projects.
Understanding Global Variables in Go
Global variables in Go offer convenience but require careful use to avoid issues.
How to Copy a Slice in Go
Methods to copy Go slices using `copy` and `append`, with considerations for shallow and deep copies.
Mastering Time Parsing in Go with `time.Parse`
Go’s `time.Parse` requires a reference time format for accurate string-to-time conversion.
Writing to Files in Go: A Comprehensive Guide
Writing files in Go requires choosing the right method (`os`, `bufio`), managing resources, and handling errors.
How to Replace Substrings in Go Using `strings.Replace`
Learn how to replace substrings in Go using `strings.Replace` and `strings.NewReplacer`.
Boosting Go Testing Efficiency with Mockery
Mockery enhances Go testing by automating mock generation, integrating with Testify, and supporting CI/CD.
Building APIs with Goa: A Design-First Framework for Go Developers
Goa streamlines API development with a design-first approach and automated code generation.
Efficient File Reading in Go: Techniques and Best Practices
Go provides multiple file reading methods, with `bufio` offering the best performance for large files.
Understanding Enums in Go: Using `iota` for Enumerated Constants
Go uses `iota` to create enums, enhancing readability and switch-case logic.
Simulating a Do-While Loop in Golang
Golang lacks `do...while`, but `for` loops can achieve similar behavior.
How to Clean Go: A Guide to Keeping Your Go Environment Tidy
Learn how to use `go clean` to manage Go’s build artifacts and caches efficiently.
Understanding Go Timers: Timer and Ticker in Action
Go's `Timer` and `Ticker` efficiently manage delayed and periodic tasks.
How to Exclude a Directory as a Package in Golang
Exclude Golang directories by removing `.go` files, using build constraints, or IDE settings.
How to Exclude Files from `go get` in Golang
Use build constraints and `go.mod` to exclude files and directories from `go get` in Go.
Rust’s Copy vs. Clone: What's the Difference?
Explains Rust’s Copy and Clone traits, their differences, implementation, and best practices.
Why SQLAlchemy 2.0 Is the Most Powerful Python ORM Yet
SQLAlchemy is the most popular Object Relational Mapping (ORM) in the Python ecosystem. It has an elegant design and is divided into two parts: the underlying Core and the upper-level traditional ORM. In most ORMs in Python and even in other languages, a good hierarchical design has not been implemented. For example, in Django's ORM, the database connection and the ORM itself are completely mixed together.
Building a Go Web Server from Scratch
An HTTP Server, as understood from its name, is a server that supports the HTTP protocol. While a Web Server, in addition to supporting the HTTP protocol, may also support other network protocols. This article will focus on introducing several common ways to write a Web Server using the official package of Golang.
How to Organize a Large-Scale Rust Project Effectively
Best practices for organizing Rust projects, from basic crate structures to complex workspaces.
Memory Ordering in Rust: A Guide to Safe Concurrency
A practical introduction to Rust’s Ordering for atomic operations and reliable concurrency.
Rescript: The Best JavaScript Alternative in 2025
This language itself has many remarkable features, such as a more robust type system, more pure functional programming support, powerful language features, and a compiler written in a native language with extremely high performance. Of course, it also has corresponding disadvantages. This article will focus on introducing ReScript's powerful features, its surrounding ecosystem, and its integration with React, which is most closely related to our daily use.
Golang Timer Precision: How Precise Can It Get?
In the world of Golang, timers have a wide range of application scenarios. However, the question of exactly how precise they are has always been a concern for developers. This article will delve deep into the management of the timer heap in Go and the mechanism for obtaining time at runtime, thus revealing to what extent we can rely on the accuracy of timers.
Enhancing Multithreading in Rust: Advanced Arc Optimization
Techniques to enhance Rust's multithreading performance by refining Arc and lock usage.
Deep Dive into Hugo: The Ideal Static Blog Framework
Hugo is a static website page generation tool written in Golang, and its efficiency is much higher than that of Jekyll written in Ruby. You can directly download the binary package from Github, and after decompression, add it to the PATH environment variable to use it.
Go: Performance of RwMutex vs Mutex Across Multiple Scenarios
In the field of software development, testing the performance of Golang locks is a practical task. Recently, a friend raised a question: when performing thread-safe read and write operations on a slice, should one choose a read-write lock (rwlock) or a mutex lock (mutex), and which lock has better performance? This question has triggered an in-depth discussion.
Choosing the Right Message Push Strategy: A Comprehensive Guide
A comparison of message push strategies to help you choose the right solution for your needs.
Go Compiler Performance Optimization Tips and Tricks
Compilation optimization refers to the use of various technical means during the compilation process to improve the execution efficiency and resource utilization efficiency of the generated code. The Go language compiler will automatically perform some basic optimizations. However, through reasonable code design and compilation parameter settings, the program performance can be further improved.
Rust Release Optimization: How to Build Small and Fast Binaries
Learn how to optimize Rust compilation for minimal size, maximum speed, or a balance of both.
Macros and Functions in Rust: When to Use Which?
A practical guide to choosing between Rust macros and functions for clean, efficient, and maintainable code.
Why Protobuf Should Dominate the Data Format Ecosystem
With its efficiency (in terms of size) and professionalism (professional types), Protobuf should have a higher coverage in the future data transmission field.
Go Panic and Recover Explained in Depth: Everything You Need to Know!
In the Go language, there are two keywords that often appear in pairs — panic and recover. These two keywords are closely related to defer. They are both built-in functions in the Go language and provide complementary functions.
Optimizing Resource Loading with fetchpriority
Optimize resource loading with fetchpriority to improve web performance and user experience. Engineering
ErrGroup: Go's Hidden Gem for Concurrent Programming
`errgroup` is an official extended library that adds error handling capabilities on the basis of `sync.WaitGroup`, providing functions such as synchronization, error propagation, and context cancellation. Its `WithContext` method can add a cancellation function, `SetLimit` can limit the number of concurrency, and `TryGo` can try to start a task. The source code is ingeniously designed and worthy of reference.