BestHub
Sign in
Tagged articles

golang

253 articles · Page 2 of 3
Continuous Delivery 2.0
Continuous Delivery 2.0
Aug 14, 2023 · Backend Development

Principles and Practices of Code Review: Insights from a Tencent Backend Engineer

This article shares a Tencent backend engineer's extensive experience with code review, outlining why engineers and leaders should practice it, identifying common pitfalls such as duplicated code and premature optimization, and presenting concrete principles, model design advice, and Go code examples to improve software quality.

backendgolang
0 likes · 40 min read
Principles and Practices of Code Review: Insights from a Tencent Backend Engineer
Architects Research Society
Architects Research Society
Jul 9, 2023 · Backend Development

Top 10 Backend Frameworks for Web Development in 2023

This article reviews the ten most popular backend frameworks for 2023—including Spring Boot, Django, Express.js, ASP.NET Core, Laravel, Ruby on Rails, Fiber, CakePHP, Flask, and Play—explaining their key features, language ecosystems, and recommended learning resources for developers of all levels.

JavaNode.jsPHP
0 likes · 12 min read
Top 10 Backend Frameworks for Web Development in 2023
Amap Tech
Amap Tech
Jun 15, 2023 · Backend Development

Golang Unit Testing Plugin: Design, Implementation, and Best Practices

The Golang Unit Testing Plugin 3.0 unifies scripts, uses containerized resources, supports all Go versions, provides precise AST‑based incremental coverage, and generates detailed HTML reports, enabling developers to select the plugin in Aone Lab and automatically compile, test, collect coverage, and upload results, dramatically reducing integration effort and improving CI efficiency across dozens of applications.

CI/CDPluginUnit Testing
0 likes · 8 min read
Golang Unit Testing Plugin: Design, Implementation, and Best Practices
Didi Tech
Didi Tech
May 26, 2023 · Big Data

Design and Optimization of Didi's Spatial‑Temporal Supply‑Demand System

Didi’s redesigned Spatial‑Temporal Supply‑Demand System replaces a single‑Redis bottleneck with a multi‑cluster routing layer, semantic sharding, multi‑level caching and delayed queues, achieving higher horizontal scalability, fault isolation, ~30 % latency reduction, increased cache hit rates, fewer query nodes, and faster, code‑free feature configuration.

Storage Optimizationconfiguration managementdistributed systems
0 likes · 19 min read
Design and Optimization of Didi's Spatial‑Temporal Supply‑Demand System
Tencent Cloud Developer
Tencent Cloud Developer
May 5, 2023 · Backend Development

Golang vs Java: Syntax, Concurrency, Exception Handling, GC and Ecosystem Comparison

While Go offers concise syntax, non‑intrusive interfaces, lightweight goroutine concurrency, a simple three‑color garbage collector and a small native binary footprint, Java provides a mature object‑oriented model, extensive libraries, generational GC and robust tooling, making the optimal language choice depend on project performance, ecosystem and development speed requirements.

Backend DevelopmentJavaconcurrency
0 likes · 28 min read
Golang vs Java: Syntax, Concurrency, Exception Handling, GC and Ecosystem Comparison
MaGe Linux Operations
MaGe Linux Operations
Apr 9, 2023 · Backend Development

Build a Go HTTP Proxy from Scratch: Full Guide with Code

Learn how to implement a functional HTTP/HTTPS proxy in Go, covering proxy concepts, forward and reverse types, protocol specifics, header transformations, and a complete, runnable code example that listens on TCP, parses requests, connects to target servers, and forwards traffic.

HTTP proxyNetwork Programmingbackend
0 likes · 11 min read
Build a Go HTTP Proxy from Scratch: Full Guide with Code
IT Services Circle
IT Services Circle
Mar 9, 2023 · Backend Development

Interview Experience and Preparation Guide for Backend Engineer Positions at ByteDance, MiHoYo, Futu, and Yuanfudao

The author shares a detailed recap of interview preparation, processes, technical questions, and personal reflections from recent backend engineering interviews at several top Chinese tech companies, highlighting the importance of solid fundamentals, Go knowledge, and systematic study resources.

CareerCloud NativeDatabases
0 likes · 19 min read
Interview Experience and Preparation Guide for Backend Engineer Positions at ByteDance, MiHoYo, Futu, and Yuanfudao
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 PoolGORMMetrics
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.

GoReleasebackend
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.

backendbest practicescode review
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.

High concurrencygolangrate 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.

Search Enginebackende-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.

HashingLarge-Scale Datagolang
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.

CachingLive StreamingSingleflight
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.

Live StreamingMicroservicesarchitecture
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.

BilibiliLive StreamingMicroservices
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.

Simulationbackenddistributed-systems
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 InversionSOLIDdesign principles
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 NativeGoStatic Binaries
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-languagePythonZero‑copy
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.

CommandsGogolang
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.

CachingSentinelbackend
0 likes · 12 min read
When Timestamp Caching Backfires: Sentinel’s Adaptive Solution Explained
Volcano Engine Developer Services
Volcano Engine Developer Services
Jun 23, 2022 · Backend Development

How ByteDance’s Kitex Revolutionized Golang RPC for High‑Performance Microservices

This article chronicles ByteDance's transition from Python to Go, the shortcomings of the first‑generation Kite RPC framework, and the design, features, performance advantages, open‑source journey, and real‑world deployment lessons of the next‑generation Kitex framework for scalable microservices.

KitexMicroservicesOpenSource
0 likes · 16 min read
How ByteDance’s Kitex Revolutionized Golang RPC for High‑Performance Microservices
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.

MetadataYAMLdatabase
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.

Benchmarkingbackendgolang
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.

TCCdistributed transactiongolang
0 likes · 32 min read
seadt: Golang Distributed Transaction Solution – Design, Integration, and Code Implementation
Cyber Elephant Tech Team
Cyber Elephant Tech Team
Apr 27, 2022 · Backend Development

How We Scaled an Ad‑Serving Engine 10× with Go and Microservices

This article details the five‑year evolution of a commercial advertising platform, the performance and architectural challenges it faced, the step‑by‑step Go‑based microservice reconstruction, and the resulting tenfold improvements in capacity, latency, and cost efficiency.

Ad TechMicroservicesbackend
0 likes · 11 min read
How We Scaled an Ad‑Serving Engine 10× with Go and Microservices
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.

FilteringRedisbackend 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.

CachingConsistent Hashingalgorithm
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.

SeataTCCfinancial services
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.

DNATDockerSNAT
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.

Proxy Patterndesign patternses6
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.

High concurrencybackenddistributed systems
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.

Simulationgolanghigh-concurrency
0 likes · 17 min read
How to Simulate 10 Billion WeChat Red‑Packet Requests on a Single Server
21CTO
21CTO
Jan 20, 2022 · Backend Development

Building a Backend to Handle 100 Billion Red‑Packet Requests: 1M‑User Simulation

This article details a practical backend design and stress‑test that simulates 1 million concurrent users handling 100 billion WeChat red‑packet requests, covering load calculations, Go‑based implementation, QPS targets, monitoring, and performance analysis.

High concurrencyLoad Simulationbackend
0 likes · 19 min read
Building a Backend to Handle 100 Billion Red‑Packet Requests: 1M‑User Simulation
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.

Round RobinWeighted Round Robingolang
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.

AutomationTest GenerationUnit Testing
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.

GoModulesWebAssembly
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.

DistributedOrchestrationState Machine
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 NativeOrchestrationState Machine
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.

MockUnit Testingbackend
0 likes · 18 min read
Go Unit Testing: Concepts, Practices, and Patterns
MaGe Linux Operations
MaGe Linux Operations
Oct 15, 2021 · Backend Development

Unlocking Go Closures: How Escape Analysis Powers Their Implementation

This article explains Go's closure mechanism, showing how functions capture surrounding variables, how the compiler's escape analysis moves those variables to the heap, and how closures are internally represented as structs containing a function pointer and captured environment.

Escape Analysisbackendclosures
0 likes · 6 min read
Unlocking Go Closures: How Escape Analysis Powers Their Implementation
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 Engineeringarchitecturebest practices
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.

APIGoHTTP
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.

Enumbackendconstants
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.

CGOGoroutinedebugging
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.

GoHTTPIP Conversion
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 DevelopmentJavaMicroservices
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 reviewdesign principlesengineering
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.

best practicescode reviewdesign principles
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.

MicroservicesRegistrygolang
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.

clean codecode reviewdesign principles
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.

cloud-nativefilebeatgolang
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.

OAuthSSOSpring
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.

Token Bucketalgorithmdistributed systems
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 DevelopmentSeata
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.

Performance Optimizationcloud-nativefilebeat
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.

Leaky BucketToken Bucketgolang
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.

best practicescode qualitycode review
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.

Microservicescircuit breakerdesign patterns
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.

Microservicesbackendcloud-native
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.

architecture principlescode reviewgolang
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.

best practicescode reviewgolang
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.

QPSSimulationdistributed-systems
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.

coroutinegolangthread
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.

DockerJavaMicroservices
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 reviewdesign principlesgolang
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 performanceQPScapacity planning
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.

distributed-systemsgolanghigh-performance
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.

backend-architecturedistributed-systemsgolang
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.

MetricsObservabilitygolang
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.

CachingMicroservicesPerformance 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.

RedisSnowflakedistributed systems
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.

best practicescode reviewdesign principles
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.

backend best practicescode reviewdesign principles
0 likes · 40 min read
Why Code Review Matters: Principles for Writing Better Backend Code