Articles

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.

DaDaniel Hayes#golang

How Rust Lost the Race to Go?

Mar 15, 2025

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.

DaDaniel Hayes#golang

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

Mar 14, 2025

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.

JaJames Reed#golang

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.

Implementing Queues in Go

Explores Go queue implementations using slices, linked lists, channels, and libraries.

Understanding Go Build Tags

Go build tags enable conditional file inclusion based on platforms or custom configurations.

Working with Base64 in Go

Guide to Base64 encoding and decoding in Go.

Understanding `strconv.Atoi` in Golang

How to convert strings to integers in Go using `strconv.Atoi`.

Understanding Timers in Go

Go timers schedule delayed tasks, and proper handling ensures efficient operations.

How to Import a Local Package in Golang

Guide on importing local packages in Go using Go modules.

Understanding Golang's Format Strings

A guide to Go's `fmt` package for formatting strings, numbers, and customizing output.

Understanding the 'break' Statement in Go

How to use Go's `break` statement in loops and switch statements.

Understanding Golang Ticker: A Guide to Timed Operations

Golang's `time.Ticker` schedules periodic tasks and requires proper stopping to manage resources.

Redis Data Types Explained: When and How to Use Them

Explore Redis data types with practical examples and usage scenarios for backend optimization.

Understanding Python Type Annotations: An In-Depth Look at the typing Module

The `typing` module injects the powerful ability of static type annotations into Python, significantly improving the readability and maintainability of the code. Through this article's detailed introduction to the basic concepts, common types, advanced types, and type checking tools of type annotations, it is hoped that readers can have a deep understanding and proficient mastery of the usage methods of the `typing` module. In actual Python project development, the reasonable application of type annotations can effectively reduce potential errors, improve the quality of the code, and make the development process more efficient and reliable. Whether it is a small project or a large project, type annotations can bring many benefits to developers and are worthy of wide application in daily programming.

DaDaniel Hayes#python

Is net/http Enough, or Do You Need Gin?

Mar 11, 2025

In the Go language, although net/http provides basic HTTP functions, its design goal focuses on simplicity and generality rather than providing advanced features and a convenient development experience. When handling HTTP requests and building web applications, net/http is insufficient in the face of complex routing rules; for some common operations such as logging and error handling, it is difficult to achieve a pluggable design; in terms of binding request data to structures, net/http does not provide convenient operations, and users need to implement them manually.

JaJames Reed#golang

Rust Data Structures Guide: Vectors, HashMaps, Sets, and More

Mar 09, 2025

An overview of Rust's essential data structures: Vec, HashMap, HashSet, and more.

Understanding Panic in Go: Causes, Recovery, and Best Practices

Panic in Go halts execution; use `recover` to handle it and prefer explicit error handling.

Working with YAML in Go

Go supports YAML processing via `go-yaml/yaml` and `goccy/go-yaml`, enabling parsing and generation.

Handling XML in Go

Efficiently process XML in Go using `encoding/xml` for parsing, generation, and streaming.

GrGrace Collins#programming

OAuth 2.0 Explained: A Journey from Zero to Hero

Mar 09, 2025

OAuth is an open network standard for authorization that is widely used globally, and the current version is 2.0. This article will provide a concise and easy-to-understand explanation of the design concept and operation process of OAuth 2.0 based on RFC 6749.

Understanding Go's syscall Package

Go’s `syscall` package enables OS interaction but is deprecated in favor of `golang.org/x/sys`.

Understanding Private Fields in Go

Private fields in Go ensure encapsulation; bypassing them risks maintainability.

Error Wrapping in Go: Enhancing Debugging and Maintainability

Go’s native error wrapping enhances debugging by preserving context and improving error handling practices.

Understanding Rust Closures: A Practical Look at Fn, FnMut, and FnOnce

Rust closure traits explained: How Fn, FnMut, and FnOnce handle variable capture and ownership.

AWK Beginner's Guide

DaDaniel Hayes#programming

AWK is a built-in text processing tool in Linux systems, specializing in handling structured text (e.g., logs, CSV files). It reads files line by line, processes data by fields, and supports simple programming logic.

Understanding Type Conversion in Go

Go enforces explicit type conversion for safety and clarity.

A Guide to Golang Cache Libraries

Comparison of Golang caching libraries, their performance, expiration management, and best use cases.

Understanding Buffered Channels in Go

Buffered channels enable asynchronous goroutine communication and improve concurrency but require careful buffer sizing.

Understanding @ in Rust: Best Practices and Use Cases

A deep dive into Rust’s @ symbol for efficient and expressive pattern matching.

JSON, YAML, TOML, or XML? The Best Choice for 2025