BestHub
Sign in
Tagged articles
245 articles
Page 2 of 3
37 Interactive Technology Team
37 Interactive Technology Team
Feb 10, 2023 · Backend Development

Analysis of Golang SQL Connection Pool Mechanism and Usage

The article examines Go’s database/sql connection pool implementation, showing how reusing connections cuts latency, explains idle/in‑use/closed state transitions, details configuration parameters such as MaxIdleConns and MaxOpenConns, demonstrates metric collection via Gorm DBStats for monitoring, and provides a stress‑test illustrating the impact of proper tuning.

Connection PoolGORMGolang
0 likes · 10 min read
Analysis of Golang SQL Connection Pool Mechanism and Usage
21CTO
21CTO
Feb 4, 2023 · Backend Development

What’s New in Go 1.20? Key Features, Performance Boosts, and OS Support

Go 1.20, released six months after 1.19, brings major toolchain, runtime, and library updates—including new slice‑to‑array conversion, unsafe package functions, struct field comparison rules, comparable type enhancements, reduced binary size, build‑flag architecture support, coverage flags, and experimental RISC‑V FreeBSD support—while improving CPU performance by up to 2% and cutting memory overhead.

BackendGoGolang
0 likes · 5 min read
What’s New in Go 1.20? Key Features, Performance Boosts, and OS Support
Top Architect
Top Architect
Jan 7, 2023 · Backend Development

Principles and Practices of Code Review and Software Architecture

The article shares a senior architect's insights on why engineers and leaders must perform code reviews, how to avoid common pitfalls such as duplicated code, premature optimization, over‑encapsulation, and lack of design, and provides concrete best‑practice guidelines and Go code examples to improve software quality.

BackendCode reviewGolang
0 likes · 42 min read
Principles and Practices of Code Review and Software Architecture
Tencent Cloud Middleware
Tencent Cloud Middleware
Nov 21, 2022 · Cloud Native

Mastering High‑Concurrency Rate Limiting: Architectures, Algorithms, and Cloud‑Native Practices

This guide explains how to design, implement, and configure rate‑limiting solutions for high‑traffic flash‑sale scenarios, covering architecture goals, algorithm choices, single‑node vs distributed approaches, cloud‑native gateway settings, scaling with Kubernetes, and practical Go code examples.

Golanghigh concurrencyrate limiting
0 likes · 19 min read
Mastering High‑Concurrency Rate Limiting: Architectures, Algorithms, and Cloud‑Native Practices
Nightwalker Tech
Nightwalker Tech
Nov 18, 2022 · Backend Development

Design and Implementation of an E‑commerce Search Engine Using Go and Elasticsearch

This article presents a comprehensive engineering guide for building a high‑performance e‑commerce search engine with Go (Kratos), Elasticsearch/OpenSearch, Redis, MySQL, and Kafka, covering architecture, index construction, query processing, ranking, user‑guidance features, and future extensions such as recommendation and visual search.

BackendGolange‑commerce
0 likes · 19 min read
Design and Implementation of an E‑commerce Search Engine Using Go and Elasticsearch
dbaplus Community
dbaplus Community
Nov 5, 2022 · Backend Development

How Bilibili Scaled Live Streaming from LAMP to a Multi‑Million‑User Microservice Platform

This article chronicles Bilibili Live's eight‑year journey from a simple LAMP monolith to a sophisticated microservice architecture, detailing the migration to Swoole‑based services, Docker containerization, Golang adoption, hot‑key handling, request amplification mitigation, and the creation of a high‑performance Envoy‑based gateway.

BilibiliDockerEnvoy
0 likes · 25 min read
How Bilibili Scaled Live Streaming from LAMP to a Multi‑Million‑User Microservice Platform
Xingsheng Youxuan Technology Community
Xingsheng Youxuan Technology Community
Oct 28, 2022 · Backend Development

How We Processed 1 Million Images in Sub-Second: Backend Optimization Secrets

Facing a challenge of managing roughly one million server-side images and 180 client images, the TOOSIMPLE team built a high-performance backend using fingerprinting, parallel processing, mmap-SSE2 acceleration, and sparsemap indexing, achieving sub-second response times while ensuring correct ordered display.

GolangHashinglarge-scale data
0 likes · 12 min read
How We Processed 1 Million Images in Sub-Second: Backend Optimization Secrets
Inke Technology
Inke Technology
Oct 20, 2022 · Backend Development

How We Cut 60% of Backend Load with Go’s singleflight and Smart Caching

This article examines how the mic‑queue list in a live‑streaming app caused heavy server load due to three‑second polling, and details a systematic performance‑optimization process—including analysis, reducing I/O, employing Go’s singleflight caching, and switching JSON libraries—to cut resource usage by up to 60% while preserving user experience.

BackendGolangSingleflight
0 likes · 7 min read
How We Cut 60% of Backend Load with Go’s singleflight and Smart Caching
ITPUB
ITPUB
Sep 25, 2022 · Backend Development

How Bilibili Scaled Live Streaming from LAMP to Microservices and Beyond

This article chronicles Bilibili Live's eight‑year journey from a simple LAMP monolith to a sophisticated micro‑service ecosystem, detailing the motivations, architectural decisions, containerization, Golang migration, gateway redesign, hot‑key handling, request amplification mitigation, and operational practices that enabled millions of concurrent viewers.

GolangMicroservicesScalability
0 likes · 26 min read
How Bilibili Scaled Live Streaming from LAMP to Microservices and Beyond
Bilibili Tech
Bilibili Tech
Sep 23, 2022 · Industry Insights

From LAMP to Microservices: Bilibili Live’s 8‑Year Architecture Evolution

This article chronicles Bilibili Live’s eight‑year journey from a simple LAMP monolith to a highly available microservice ecosystem, detailing the technical motivations, design principles, Swoole‑based services, containerization, Golang migration, custom gateways, hot‑key handling, and operational safeguards that enabled millions of concurrent viewers.

BilibiliGolangMicroservices
0 likes · 27 min read
From LAMP to Microservices: Bilibili Live’s 8‑Year Architecture Evolution
IT Architects Alliance
IT Architects Alliance
Sep 8, 2022 · Backend Development

Design and Implementation of a High‑QPS Spring Festival Red Envelope System Simulating 10 Billion Requests

This article describes the design, hardware and software setup, implementation, testing phases, and performance analysis of a Go‑based backend system that simulates a Spring Festival red‑envelope service capable of handling up to 10 billion requests with peak loads of 60 k QPS per server.

BackendGolangPerformance Testing
0 likes · 19 min read
Design and Implementation of a High‑QPS Spring Festival Red Envelope System Simulating 10 Billion Requests
Continuous Delivery 2.0
Continuous Delivery 2.0
Aug 22, 2022 · Fundamentals

Key Principles for Code Review and Software Architecture

This extensive article discusses essential software engineering concepts such as code review value, architectural principles, SOLID, dependency inversion, documentation practices, testing strategies, and practical guidelines for writing maintainable, decoupled, and self‑explanatory code across various programming languages.

Dependency InversionGolangSOLID
0 likes · 44 min read
Key Principles for Code Review and Software Architecture
21CTO
21CTO
Aug 18, 2022 · Cloud Native

Why Go (Golang) Is the Go‑To Language for Cloud‑Native Development

This article explores Go's concise design, strong concurrency model, fast compilation, static binaries, and broad ecosystem, highlighting its ideal fit for cloud‑native applications, distributed services, and command‑line tools while also addressing its limitations and future direction.

Cloud NativeDistributed SystemsGo
0 likes · 12 min read
Why Go (Golang) Is the Go‑To Language for Cloud‑Native Development
Continuous Delivery 2.0
Continuous Delivery 2.0
Aug 18, 2022 · Backend Development

Why Code Review Matters and How to Apply Engineering Best Practices in Backend Development

The article argues that code review is essential for software quality, critiques common shortcomings in engineering practice, and presents principles such as simplicity, composition, transparency, and disciplined logging, illustrated with Go code examples, to guide developers toward maintainable, scalable backend systems.

BackendGolangsoftware design
0 likes · 39 min read
Why Code Review Matters and How to Apply Engineering Best Practices in Backend Development
Alibaba Cloud Developer
Alibaba Cloud Developer
Aug 5, 2022 · Fundamentals

Why Fury Serialization Beats Kryo: 20‑200× Faster Cross‑Language Performance

Fury is a JIT‑based native multi‑language serialization framework that automatically handles shared and cyclic references, offers zero‑copy support, and delivers 20‑200× speed improvements over existing solutions, making it a high‑performance drop‑in replacement for Java, Python, Go, and C++ serialization needs.

Cross-languageGolangPython
0 likes · 38 min read
Why Fury Serialization Beats Kryo: 20‑200× Faster Cross‑Language Performance
Tencent Cloud Developer
Tencent Cloud Developer
Jul 28, 2022 · Backend Development

A Comprehensive Overview of Common Go Tools and Commands

This article surveys the essential Go command‑line utilities—including go help, get, build, install, fmt, env, test, and the extensive go tool suite such as pprof, trace, vet, and doc—while also highlighting popular third‑party tools like Delve, staticcheck, goconvey, go‑swagger, and others for debugging, testing, linting, and performance analysis.

GoGolangcommands
0 likes · 20 min read
A Comprehensive Overview of Common Go Tools and Commands
Bin's Tech Cabin
Bin's Tech Cabin
Jun 24, 2022 · Backend Development

When Timestamp Caching Backfires: Sentinel’s Adaptive Solution Explained

The article examines how naive timestamp caching can increase CPU usage under high concurrency, analyzes implementations in Alibaba’s Cobar and Sentinel, presents performance test results, and explains Sentinel’s adaptive algorithm that switches between cached and direct timestamps based on QPS.

BackendGolangcaching
0 likes · 12 min read
When Timestamp Caching Backfires: Sentinel’s Adaptive Solution Explained
MaGe Linux Operations
MaGe Linux Operations
Jun 6, 2022 · Databases

What Is a Schema? From Databases to Kubernetes Explained

This article explains the concept of a schema—from its Greek origins and psychological meaning to its role as metadata in databases and Kubernetes—detailing different database schema models, Kubernetes resource definitions, and how to extend and register custom schemas in Go.

GolangYAMLdatabase
0 likes · 8 min read
What Is a Schema? From Databases to Kubernetes Explained
MaGe Linux Operations
MaGe Linux Operations
Jun 3, 2022 · Backend Development

How Rewriting Hasura Storage in Go Boosted Performance Fivefold

The Hasura Storage team rewrote their Node.js service in Go, ran k6 benchmarks, and achieved up to five times more request handling, half the memory usage, and significantly lower response times across multiple download scenarios, demonstrating the scalability benefits of Go for backend services.

BackendBenchmarkingGolang
0 likes · 6 min read
How Rewriting Hasura Storage in Go Boosted Performance Fivefold
Shopee Tech Team
Shopee Tech Team
May 5, 2022 · Backend Development

seadt: Golang Distributed Transaction Solution – Design, Integration, and Code Implementation

seadt is a Golang‑based TCC distributed‑transaction framework for Shopee Financial Products that lets initiators run multi‑service operations as if they were local DB actions, providing TM, RM, and TC components, automatic proxy generation, and robust handling of empty commits, rollbacks, hanging branches, and concurrency issues.

Golangdistributed-transactionseadt
0 likes · 32 min read
seadt: Golang Distributed Transaction Solution – Design, Integration, and Code Implementation
IEG Growth Platform Technology Team
IEG Growth Platform Technology Team
Mar 21, 2022 · Backend Development

Optimization of Local Vector Retrieval: Filtering, Storage, and Sorting Strategies

This article presents a comprehensive study of local vector retrieval optimization, covering memory‑based filtering techniques, Redis‑backed vector storage designs, and various sorting algorithms—including radix and heap‑based approaches—to achieve lower latency and higher throughput for large‑scale ad recommendation systems.

GolangSortingbackend optimization
0 likes · 13 min read
Optimization of Local Vector Retrieval: Filtering, Storage, and Sorting Strategies
Tencent Cloud Developer
Tencent Cloud Developer
Mar 14, 2022 · Backend Development

Consistent Hashing Algorithm: Theory, Go Implementation, and Load-Balanced Extension

The article explains consistent hashing—using a circular 2^32 hash ring with virtual nodes to evenly distribute keys across dynamic cache servers—provides a complete Go implementation including host registration, key lookup, and a bounded‑load extension that tracks server load, demonstrates a proxy‑cache setup, and discusses practical testing and production‑grade enhancements.

Distributed SystemsGolangalgorithm
0 likes · 27 min read
Consistent Hashing Algorithm: Theory, Go Implementation, and Load-Balanced Extension
Shopee Tech Team
Shopee Tech Team
Mar 3, 2022 · Backend Development

seadt: A Golang Distributed Transaction Framework for Financial Products

seadt is a self‑developed Golang distributed‑transaction framework for Shopee’s financial products that adopts the TCC model, providing a global Transaction Coordinator, embedded Transaction Managers and Resource Managers via an SDK to ensure atomic two‑phase commits, idempotency, high availability, and eventual consistency in loan‑processing flows, with future Saga support planned.

Financial ServicesGolangSeata
0 likes · 20 min read
seadt: A Golang Distributed Transaction Framework for Financial Products
Radish, Keep Going!
Radish, Keep Going!
Feb 26, 2022 · Backend Development

How to Handle Multiple NICs in Go: Exclude Link‑Local IPs and Bind Traffic

This article explains why Go programs may pick unusable link‑local addresses on machines with multiple network interfaces, shows how to filter them out, and presents three practical solutions—including per‑NIC binding, Docker container isolation, and DNAT/SNAT rules—to control inbound and outbound traffic.

DNATDockerGolang
0 likes · 12 min read
How to Handle Multiple NICs in Go: Exclude Link‑Local IPs and Bind Traffic
IT Services Circle
IT Services Circle
Feb 20, 2022 · Databases

Understanding and Optimizing Database Connection Pools with Go and MySQL

This article explains how improper use of database connection pools can cause service timeouts, demonstrates with Go and MySQL how to configure and test connection pooling, shows performance improvements through reuse, and encourages developers to implement their own pools for better efficiency.

Connection PoolGolang
0 likes · 8 min read
Understanding and Optimizing Database Connection Pools with Go and MySQL
NiuNiu MaTe
NiuNiu MaTe
Feb 10, 2022 · Fundamentals

Master the Proxy Pattern with a Fun Story and Go Example

This article explains the proxy design pattern through an engaging cartoon story, analyzes the roles of client, target, and proxy, discusses its benefits and variations, and shows practical usage examples such as ES6 Proxy, virtual image lazy‑loading, and a Golang implementation.

Design PatternsGolangProxy Pattern
0 likes · 4 min read
Master the Proxy Pattern with a Fun Story and Go Example
IT Architects Alliance
IT Architects Alliance
Feb 9, 2022 · Backend Development

How to Build a 10‑Billion‑Request Red‑Envelope System: Design, Implementation, and Lessons Learned

This article walks through the design and practical implementation of a high‑throughput red‑envelope service capable of handling 10 billion requests, covering target load calculations, hardware and software choices, client‑server coordination, performance testing, monitoring, and key takeaways for building scalable backend systems.

BackendDistributed SystemsGolang
0 likes · 20 min read
How to Build a 10‑Billion‑Request Red‑Envelope System: Design, Implementation, and Lessons Learned
Java Interview Crash Guide
Java Interview Crash Guide
Jan 25, 2022 · Backend Development

How to Simulate 10 Billion WeChat Red‑Packet Requests on a Single Server

This article explains how the author designed and implemented a Go‑based backend that can simulate up to 100 million concurrent users and process billions of red‑packet requests, detailing the hardware setup, performance goals, load‑balancing techniques, monitoring, and the results of multi‑stage stress tests.

Golanghigh-concurrencyred packet
0 likes · 17 min read
How to Simulate 10 Billion WeChat Red‑Packet Requests on a Single Server
Open Source Linux
Open Source Linux
Dec 6, 2021 · Backend Development

Mastering Nginx Load Balancing: Round‑Robin & Weighted Algorithms with Go

This article explains Nginx’s basic round‑robin and weighted round‑robin load‑balancing algorithms, compares their characteristics, and provides complete Go implementations—including configuration snippets, core structs, and test code—to help developers integrate efficient request distribution into their backend services.

GolangRound RobinWeighted Round Robin
0 likes · 10 min read
Mastering Nginx Load Balancing: Round‑Robin & Weighted Algorithms with Go
ByteDance SE Lab
ByteDance SE Lab
Dec 3, 2021 · Backend Development

How ByteDance’s SmartUnit Automates Backend Unit Test Generation

This article details ByteDance Quality Lab’s SmartUnit system, which intelligently generates and validates backend unit tests using AST analysis, genetic algorithms, and instrumentation, achieving automated test creation, high coverage, precise assertions, and seamless CI integration while addressing the high cost and complexity of traditional unit testing.

AutomationGolangTest Generation
0 likes · 17 min read
How ByteDance’s SmartUnit Automates Backend Unit Test Generation
21CTO
21CTO
Nov 28, 2021 · Fundamentals

Why Learning Go (Golang) Is Worth Your Time: Key Benefits and Essentials

This article introduces Go, highlights its concise and clean syntax, showcases core language structures and built‑in tools, explains module creation and cross‑compilation, and demonstrates how to build binaries and WebAssembly modules, making a compelling case for learning Golang.

GoGolangModules
0 likes · 6 min read
Why Learning Go (Golang) Is Worth Your Time: Key Benefits and Essentials
TAL Education Technology
TAL Education Technology
Nov 25, 2021 · Backend Development

Design and Implementation of a Code‑less Distributed Task Orchestration Platform for XES

This article presents a comprehensive design and implementation of a drag‑and‑drop, code‑less workflow orchestration system that abstracts business logic into DAG‑based state machines, detailing architecture, core data structures, Go code examples, and two practical use cases for arithmetic and data‑consumption scenarios.

BackendDistributedGolang
0 likes · 18 min read
Design and Implementation of a Code‑less Distributed Task Orchestration Platform for XES
Xueersi Online School Tech Team
Xueersi Online School Tech Team
Nov 12, 2021 · Backend Development

Code-less Business Process Orchestration: Design, Implementation, and Application

This article presents a code-less business process orchestration framework that transforms static Go code into configurable drag‑and‑drop workflows, detailing the underlying concepts, architecture, core Go data structures, dynamic configuration, and practical deployment examples for distributed task scheduling and execution.

Cloud NativeDistributed SystemsGolang
0 likes · 18 min read
Code-less Business Process Orchestration: Design, Implementation, and Application
Xueersi Online School Tech Team
Xueersi Online School Tech Team
Nov 5, 2021 · Backend Development

Go Unit Testing: Concepts, Practices, and Patterns

This article introduces the testing pyramid, explains unit testing concepts, and provides a step‑by‑step guide for writing Go unit tests using the standard testing package, the AAA pattern, Testify assertions, mocks, and test suites, while highlighting the benefits of fast verification, documentation, and sustainable development.

BackendGolangMock
0 likes · 18 min read
Go Unit Testing: Concepts, Practices, and Patterns
Big Data Technology Architecture
Big Data Technology Architecture
Oct 14, 2021 · Backend Development

Effective Code Review and Software Design Principles for Go Backend Development

This article shares practical insights on why engineers and leaders must conduct code reviews, identifies common causes of poor code such as duplication and premature decisions, and presents concrete design principles—including simplicity, composition, transparency, and disciplined logging—illustrated with Go code examples to help teams build maintainable, high‑quality backend systems.

Backend EngineeringCode reviewGolang
0 likes · 39 min read
Effective Code Review and Software Design Principles for Go Backend Development
FunTester
FunTester
Oct 8, 2021 · Backend Development

Building a Custom Go HTTP Client Wrapper for API Testing

This article walks through creating a reusable Go HTTP client wrapper, demonstrates its use in a test script, shows console output, and integrates a mock server with Moco to enable quick API testing while applying a learning‑by‑doing approach.

APIBackendGo
0 likes · 9 min read
Building a Custom Go HTTP Client Wrapper for API Testing
MaGe Linux Operations
MaGe Linux Operations
Sep 1, 2021 · Backend Development

Master Go Enums with const and iota: A Practical Guide

This article explains how Go implements enumeration using const and the iota counter, provides step‑by‑step code examples, demonstrates alternative type‑based enum patterns, and shows how to add a String method for readable output, helping developers write clean, maintainable constant definitions.

BackendConstantsGolang
0 likes · 5 min read
Master Go Enums with const and iota: A Practical Guide
Tencent Cloud Developer
Tencent Cloud Developer
Aug 30, 2021 · Backend Development

Troubleshooting Golang Memory Leaks: A Production Case Study

The case study walks through debugging a Go production service that regularly spiked to over 6 GB of resident memory, revealing that unbuffered channel leaks, mis‑configured HTTP client timeouts, and ultimately a cgo‑based image‑processing library spawning unmanaged threads caused the leaks, and outlines a systematic troubleshooting workflow.

DebuggingGolangGoroutine
0 likes · 12 min read
Troubleshooting Golang Memory Leaks: A Production Case Study
Cloud Native Technology Community
Cloud Native Technology Community
Aug 17, 2021 · Backend Development

6 Essential Go Tricks to Boost Your Backend Development

This article presents six practical Go techniques—including loop labels for prime number generation, IP address conversion, octal UTF‑8 decoding, a lightweight HTTP utility library, a concise debug logging helper, and a Go‑based httpbin replacement—complete with code examples, usage notes, and visual results.

BackendDebuggingGo
0 likes · 11 min read
6 Essential Go Tricks to Boost Your Backend Development
21CTO
21CTO
Jun 20, 2021 · Backend Development

Which Programming Language Is Best for Building Microservices? A Comparative Guide

This article explains what microservices are, who can benefit from them, and compares five popular programming languages—Go, Java, Python, C++, and Ruby—highlighting their strengths and drawbacks for developing scalable, maintainable microservice architectures.

Backend DevelopmentGolangJava
0 likes · 7 min read
Which Programming Language Is Best for Building Microservices? A Comparative Guide
Top Architect
Top Architect
May 9, 2021 · Backend Development

Principles and Practices for Effective Code Review and Software Architecture

This article shares a senior backend engineer's insights on why code review is essential, common pitfalls that degrade code quality, and a set of concrete principles—ranging from simplicity and composition to transparency and error handling—to guide developers in writing maintainable, scalable Go code and robust system designs.

Code reviewEngineeringGolang
0 likes · 39 min read
Principles and Practices for Effective Code Review and Software Architecture
21CTO
21CTO
Apr 22, 2021 · Fundamentals

Why Code Review Matters: Principles for Writing Better Backend Code

The article explains why engineers and leaders must perform code reviews, outlines common pitfalls such as duplicated code, premature optimization, and poor design, and presents concrete principles—KISS, composition, transparency, and error handling—backed by Go examples and Unix philosophy to help teams produce maintainable, high‑quality software.

Code reviewGolangSoftware Engineering
0 likes · 41 min read
Why Code Review Matters: Principles for Writing Better Backend Code
High Availability Architecture
High Availability Architecture
Apr 7, 2021 · Backend Development

Implementing a Service Registry and Discovery in Go: Design, Code, and Practices

This article explains why service registration and discovery are needed in microservice architectures, outlines the design principles of a registry, provides Go data structures and functions for registering, fetching, renewing, and evicting services, discusses self‑protection mechanisms, and shows how to expose the registry via a Gin‑based HTTP API.

GolangMicroservicesRegistry
0 likes · 21 min read
Implementing a Service Registry and Discovery in Go: Design, Code, and Practices
ITPUB
ITPUB
Mar 24, 2021 · Fundamentals

Mastering Code Review: 12 Principles for Writing Clean, Maintainable Go Code

This article shares a senior engineer's practical philosophy on code review, covering why reviews matter, common pitfalls like duplicated code and premature optimization, and twelve concrete principles—such as simplicity, composition, transparency, and early returns—to help developers write clearer, more maintainable Go programs.

Code reviewGolangSoftware Engineering
0 likes · 41 min read
Mastering Code Review: 12 Principles for Writing Clean, Maintainable Go Code
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Mar 23, 2021 · Cloud Native

How to Build a Scalable Cloud‑Native Log Collection System with Filebeat and Custom Controllers

This article explains the challenges of container log collection in Kubernetes, evaluates log‑agent options, details the design of a custom Filebeat‑based controller architecture, shares performance tuning with Golang, and outlines monitoring and future extensions for a robust cloud‑native logging solution.

FilebeatGolangKubernetes
0 likes · 14 min read
How to Build a Scalable Cloud‑Native Log Collection System with Filebeat and Custom Controllers
Java Architect Essentials
Java Architect Essentials
Mar 3, 2021 · Information Security

Seven Open‑Source OAuth and SSO Projects for Developers

This article introduces seven open‑source OAuth/SSO solutions—including oauth2‑shiro, tkey, MaxKey, spring‑lhbauth, oauth2, oauthserver, and JustAuth—detailing their features, supported protocols, and repository links to help developers implement secure authentication and token management in web and mobile applications.

AuthenticationGolangOAuth
0 likes · 5 min read
Seven Open‑Source OAuth and SSO Projects for Developers
Top Architect
Top Architect
Feb 14, 2021 · Backend Development

An Introduction to Rate Limiting: Concepts, Classifications, and Go Implementation

This article explains the fundamentals of rate limiting, its importance for high‑availability services, various classification dimensions, common algorithms such as fixed‑window, sliding‑window, leaky‑bucket and token‑bucket, and demonstrates practical usage with Go's golang.org/x/time/rate library including code examples and configuration tips.

Distributed SystemsGolangToken Bucket
0 likes · 26 min read
An Introduction to Rate Limiting: Concepts, Classifications, and Go Implementation
Alibaba Cloud Native
Alibaba Cloud Native
Feb 9, 2021 · Backend Development

Integrating Seata‑Golang AT and TCC Modes into Go Microservices

This guide explains how to embed Seata‑Golang’s AT and TCC distributed‑transaction modes into Go microservices, covering global transaction proxy creation, XID propagation via HTTP, Dubbo and gRPC, branch transaction handling, and the required code interfaces and implementations.

AT ModeBackend DevelopmentGolang
0 likes · 10 min read
Integrating Seata‑Golang AT and TCC Modes into Go Microservices
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Jan 31, 2021 · Cloud Native

Solving Cloud‑Native Log Collection: NetEase Lightboat’s Architecture & Insights

This article explains how NetEase’s Lightboat micro‑service platform tackles the challenges of log collection in cloud‑native Kubernetes environments by designing a custom controller, selecting Filebeat as the agent, integrating it via DaemonSet, extending its functionality, and applying Golang performance‑tuning techniques to achieve efficient, observable logging.

FilebeatGolangKubernetes
0 likes · 13 min read
Solving Cloud‑Native Log Collection: NetEase Lightboat’s Architecture & Insights
Code Ape Tech Column
Code Ape Tech Column
Jan 27, 2021 · Backend Development

An Introduction to Rate Limiting: Concepts, Classifications, Algorithms, and Go Implementation

This article introduces rate limiting, explains its purpose and classifications, compares fixed and sliding windows, describes common algorithms such as token bucket, leaky bucket, and counter, and provides detailed Go code examples using the golang.org/x/time/rate library for practical implementation.

GolangToken Bucketleaky bucket
0 likes · 25 min read
An Introduction to Rate Limiting: Concepts, Classifications, Algorithms, and Go Implementation
21CTO
21CTO
Jan 22, 2021 · Fundamentals

Mastering Code Review: 12 Principles for Cleaner, Maintainable Code

This article shares practical insights and principles—from the importance of code review to concrete guidelines like KISS, composition, and transparency—helping developers write higher‑quality, easier‑to‑maintain software while avoiding common pitfalls such as duplication, premature optimization, and over‑engineered designs.

Code reviewGolangSoftware Engineering
0 likes · 44 min read
Mastering Code Review: 12 Principles for Cleaner, Maintainable Code
High Availability Architecture
High Availability Architecture
Dec 31, 2020 · Backend Development

Design and Go Implementation of a Service Circuit Breaker

This article explains the design and Go implementation of a microservice circuit breaker, covering fault‑tolerance mechanisms, state transitions, configurable trip strategies, metrics collection, testing, and deployment patterns such as centralized gateways and service mesh.

Design PatternsGolangMicroservices
0 likes · 20 min read
Design and Go Implementation of a Service Circuit Breaker
Beike Product & Technology
Beike Product & Technology
Dec 19, 2020 · Backend Development

Evolution of Beike Mini‑Program Backend Platform: From PHP to Golang, Microservices, and Cloud‑Native Architecture

The article details the progressive transformation of Beike's mini‑program backend—from rapid PHP prototyping to Golang‑based gateways, microservice decomposition, Redis and TiDB optimizations, and cloud‑native stability measures—illustrating how performance, scalability, and platform‑wide capabilities were systematically enhanced.

BackendGolangMicroservices
0 likes · 16 min read
Evolution of Beike Mini‑Program Backend Platform: From PHP to Golang, Microservices, and Cloud‑Native Architecture
ITPUB
ITPUB
Dec 15, 2020 · Fundamentals

Essential Code Review Principles Every Engineer Should Master

This article compiles practical code‑review guidelines, well‑known architecture principles, and personal engineering habits—covering self‑explaining code, DRY, dependency inversion, error handling, testing strategies, and common pitfalls—to help developers write maintainable, high‑quality software.

Code reviewGolangarchitecture principles
0 likes · 46 min read
Essential Code Review Principles Every Engineer Should Master
Selected Java Interview Questions
Selected Java Interview Questions
Dec 6, 2020 · Fundamentals

Principles and Practices for Effective Code Review and Software Engineering

The article presents a comprehensive guide on why developers and leaders must perform code reviews, identifies common pitfalls such as duplicated code, premature optimization and over‑engineered OOP, and offers concrete principles, model‑design advice, and Golang examples to improve code quality and maintainability.

Code reviewGolangSoftware Engineering
0 likes · 42 min read
Principles and Practices for Effective Code Review and Software Engineering
Architect
Architect
Nov 1, 2020 · Backend Development

Design and Implementation of a High‑QPS Spring Festival Red‑Packet System Simulating 10 Billion Requests

This article details the design, implementation, and performance testing of a Go‑based backend that simulates a Spring Festival red‑packet system capable of handling up to 6 × 10⁴ QPS and one million concurrent connections, demonstrating how to achieve 10 billion request processing in a controlled environment.

GolangLoad TestingQPS
0 likes · 19 min read
Design and Implementation of a High‑QPS Spring Festival Red‑Packet System Simulating 10 Billion Requests
macrozheng
macrozheng
Oct 22, 2020 · Fundamentals

Can Threads Pause and Resume? A Tale of Coroutines Across Java and Go

A whimsical story depicts a GoLang envoy introducing the concept of coroutines to the proud Java empire, contrasting thread blocking, asynchronous callbacks, and cooperative scheduling, and explores how execution contexts can be saved, switched, and resumed without OS intervention.

GolangThreadcoroutine
0 likes · 8 min read
Can Threads Pause and Resume? A Tale of Coroutines Across Java and Go
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Sep 11, 2020 · Backend Development

Backend Technology Stack Selection for Microservices Architecture

This article outlines a comprehensive backend technology selection guide for microservices, covering programming languages, IDEs, frameworks, RPC solutions, distributed transaction tools, API gateways, configuration centers, service discovery, monitoring, logging, database middleware, serialization, build tools, containers, orchestration, and runtime environments.

DockerGolangJava
0 likes · 10 min read
Backend Technology Stack Selection for Microservices Architecture
Top Architect
Top Architect
Sep 9, 2020 · Backend Development

Principles and Practices for Effective Code Review and Software Architecture

This article shares the author's insights on why engineers and leaders must conduct code reviews, identifies common causes of poor code such as duplication and premature decisions, and presents a set of design principles, model‑driven thinking, and concrete Go code examples to help improve software quality and maintainability.

Code reviewGolangSoftware Architecture
0 likes · 44 min read
Principles and Practices for Effective Code Review and Software Architecture
Node Underground
Node Underground
Aug 23, 2020 · Operations

How to Accurately Benchmark API QPS with Hey: A Step‑by‑Step Guide

This article introduces the Hey load‑testing tool, explains how to install and run it with specific QPS settings, analyzes the resulting metrics and charts, and offers practical tips for identifying bottlenecks such as network bandwidth or CPU usage during capacity planning.

API performanceGolangLoad Testing
0 likes · 5 min read
How to Accurately Benchmark API QPS with Hey: A Step‑by‑Step Guide
Programmer DD
Programmer DD
Aug 21, 2020 · Backend Development

How to Simulate 100 Billion Red Packet Requests on a Single Server

This article details a practical approach to building a single‑machine prototype that supports one million concurrent connections and processes up to 60,000 QPS, simulating the massive load of 100 billion WeChat red‑packet requests with Go, Linux, and custom monitoring tools.

GolangLoad Testingdistributed-systems
0 likes · 23 min read
How to Simulate 100 Billion Red Packet Requests on a Single Server
Java Architect Essentials
Java Architect Essentials
Aug 13, 2020 · Backend Development

Design and Implementation of a High‑Throughput WeChat Red Packet System

This article describes the design, implementation, and performance testing of a simulated WeChat red‑packet service capable of handling up to 100 billion requests, detailing target load calculations, hardware and software choices, concurrency strategies in Go, monitoring tools, and experimental results across multiple QPS levels.

GolangLoad Testingbackend-architecture
0 likes · 18 min read
Design and Implementation of a High‑Throughput WeChat Red Packet System
Aikesheng Open Source Community
Aikesheng Open Source Community
Jul 29, 2020 · Operations

Understanding Prometheus Exporters: Operation Modes, Data Format, and a Go Implementation Example

This article explains the purpose and operation modes of Prometheus exporters, details the text-based metric exposition format including HELP, TYPE, and sample lines for counters, gauges, summaries, and histograms, and provides a complete Go example showing how to build, run, and expose a custom exporter with Prometheus client libraries.

GolangMetricsObservability
0 likes · 11 min read
Understanding Prometheus Exporters: Operation Modes, Data Format, and a Go Implementation Example
Beike Product & Technology
Beike Product & Technology
Jul 16, 2020 · Backend Development

Migrating PHP Services to Golang: Performance Optimization and Concurrency Practices

This article details a real‑world migration from PHP to Golang for a high‑traffic mini‑program backend, explaining the performance bottlenecks of PHP, the advantages of Go such as goroutine concurrency and low‑memory footprint, the step‑by‑step implementation, caching strategy, monitoring, tooling, and the measurable latency and stability improvements achieved.

GolangMicroservicesPerformance Optimization
0 likes · 14 min read
Migrating PHP Services to Golang: Performance Optimization and Concurrency Practices
Sohu Tech Products
Sohu Tech Products
Jul 15, 2020 · Backend Development

Design and Implementation of a High‑Performance Global Unique ID Generation Algorithm (Mist) and Service (Medis)

This article analyses the limitations of existing global unique ID solutions such as Snowflake, presents the design of a new high‑performance, time‑independent Mist algorithm with extended lifespan, and describes its practical Redis‑backed service Medis, including performance benchmarks and architectural considerations.

Distributed SystemsGolangglobal unique ID
0 likes · 14 min read
Design and Implementation of a High‑Performance Global Unique ID Generation Algorithm (Mist) and Service (Medis)
21CTO
21CTO
Jun 30, 2020 · Fundamentals

Why Code Review Matters: Lessons from a Golang Committee Member

This article explores the importance of code review for engineers and leaders, examines common pitfalls such as duplicated code and premature optimization, presents core software design principles like KISS and composition, and offers practical guidelines and Golang examples to improve code quality and maintainability.

Code reviewGolangSoftware Engineering
0 likes · 40 min read
Why Code Review Matters: Lessons from a Golang Committee Member
ITPUB
ITPUB
Jun 29, 2020 · Backend Development

Why Code Review Matters: Principles for Writing Better Backend Code

This article shares practical principles and concrete guidelines for effective code review and backend engineering, covering why reviews are essential, common pitfalls like duplicated code and premature optimization, design philosophies such as composition over inheritance, and actionable rules for maintaining clean, maintainable Go codebases.

Code reviewGolangSoftware Engineering
0 likes · 40 min read
Why Code Review Matters: Principles for Writing Better Backend Code
Top Architect
Top Architect
Jun 26, 2020 · Fundamentals

Principles and Practices for Effective Code Review and Software Design

The article shares a senior engineer's insights on why code review is essential, outlines common pitfalls such as duplicated code, premature optimization, and poor design, and presents concrete principles and practical guidelines—including KISS, composition over inheritance, and disciplined logging—to improve code quality and maintainability in large‑scale backend projects.

Code reviewEngineeringGolang
0 likes · 41 min read
Principles and Practices for Effective Code Review and Software Design
Efficient Ops
Efficient Ops
May 20, 2020 · Operations

5 Emerging DevOps Trends to Watch in 2020

The article outlines five major DevOps trends for 2020—including AI‑driven automation, the rise of Golang, serverless architecture, cloud‑native practices, and the growing focus on DevSecOps—explaining how each will reshape software delivery and operational efficiency.

AIDevOpsGolang
0 likes · 7 min read
5 Emerging DevOps Trends to Watch in 2020
ITPUB
ITPUB
May 19, 2020 · Backend Development

How to Install Go on Linux and Set Up VSCode Remote Debugging

This guide walks you through downloading the Go source, manually installing it on a Linux server, configuring workspace and environment variables, and then using VSCode for remote development, debugging, and handling command‑line arguments and environment variables in Go programs.

GolangInstallationRemote Development
0 likes · 10 min read
How to Install Go on Linux and Set Up VSCode Remote Debugging
Liangxu Linux
Liangxu Linux
Mar 29, 2020 · Operations

How to Install Ubuntu on Windows 10 with WSL: A Step‑by‑Step Guide

This guide walks you through enabling the Windows Subsystem for Linux, downloading Ubuntu from the Microsoft Store, completing the installation, updating packages, and adding Go tools, providing screenshots and exact commands so you can develop Linux applications directly on Windows 10.

GolangUbuntuWSL
0 likes · 3 min read
How to Install Ubuntu on Windows 10 with WSL: A Step‑by‑Step Guide
21CTO
21CTO
Mar 6, 2020 · Backend Development

How to Simulate 100 Billion WeChat Red Packet Requests on a Single Server

This article details a backend engineering practice that simulates 100 billion shake‑red‑packet requests by building a single‑machine prototype supporting one million connections, achieving peak QPS of 60 k, and demonstrates the methodology, hardware setup, code design, monitoring, and performance analysis.

BackendGolangLoad Testing
0 likes · 18 min read
How to Simulate 100 Billion WeChat Red Packet Requests on a Single Server