BestHub
Sign in
Tagged articles
57 articles
Page 1 of 1
Tencent Cloud Developer
Tencent Cloud Developer
Apr 1, 2026 · Artificial Intelligence

Why Raw AI Models Fail and How Harness Turns Them Into Powerful Agents

The article explains the four fundamental shortcomings of raw large language models—no memory, no code execution, outdated knowledge, and no workspace—and shows how a six‑component Harness (file system, Bash + sandbox, AGENTS.md memory, web search + MCP, context engineering, and orchestration + hooks) systematically resolves each issue to make AI agents practical and reliable.

AIEngineeringHarness
0 likes · 34 min read
Why Raw AI Models Fail and How Harness Turns Them Into Powerful Agents
Go Development Architecture Practice
Go Development Architecture Practice
Mar 27, 2026 · Backend Development

Exploring Gin 1.12: BSON Support, Enhanced Context, Flexible Binding, and Protobuf Negotiation

The article walks through Gin 1.12's new features—including native BSON handling for MongoDB, type‑safe context error methods, custom binding for dates and enums, raw‑path routing, colored latency logs, and automatic Protobuf/JSON negotiation—showing practical code examples and upgrade recommendations for microservice development.

BSONGinGo
0 likes · 10 min read
Exploring Gin 1.12: BSON Support, Enhanced Context, Flexible Binding, and Protobuf Negotiation
DevOps Coach
DevOps Coach
Feb 25, 2026 · Backend Development

Why Your Go Function Returns While Goroutine Stays Alive—and How to Fix It

Even when a Go function returns cleanly, a spawned goroutine can remain blocked on an unbuffered channel after context cancellation, causing leaks that degrade performance under load; this article explains the hidden pitfall, demonstrates the faulty pattern, and provides robust fixes using buffered channels and context-aware goroutine design.

Channelcontextgoroutine-leak
0 likes · 8 min read
Why Your Go Function Returns While Goroutine Stays Alive—and How to Fix It
Code Wrench
Code Wrench
Feb 19, 2026 · Backend Development

5 Go Techniques to Write Production‑Ready, Elegant Code

This article presents five practical Go techniques—using context for graceful cancellation, enriching errors with fmt.Errorf, leveraging sync.Pool to reduce GC pressure, employing pprof for performance profiling, and designing testable code with dependency injection—each illustrated with real‑world code examples and common pitfalls.

Gobest practicescontext
0 likes · 7 min read
5 Go Techniques to Write Production‑Ready, Elegant Code
Code Wrench
Code Wrench
Aug 11, 2025 · Backend Development

Mastering Go Context: Timeout Control and Signal Propagation for Robust Services

This guide explains why Go's Context timeout is essential for managing goroutine lifecycles, details the WithDeadline and WithTimeout APIs, reveals the internal timer and cancellation mechanisms, and provides practical HTTP request patterns and best‑practice recommendations for building stable, high‑performance backend services.

BackendGoTimeout
0 likes · 6 min read
Mastering Go Context: Timeout Control and Signal Propagation for Robust Services
php Courses
php Courses
Jun 3, 2025 · Backend Development

Understanding Go's Concurrency Model: Goroutine, Channel, Select, WaitGroup, and Context

This article explains Go's lightweight concurrency model, covering Goroutine creation, Channel communication, Select multiplexing, synchronization with WaitGroup and Context, common concurrency patterns such as worker pools and pub/sub, and provides best‑practice recommendations for building high‑performance concurrent programs.

ChannelGoGoroutine
0 likes · 7 min read
Understanding Go's Concurrency Model: Goroutine, Channel, Select, WaitGroup, and Context
FunTester
FunTester
Mar 29, 2025 · Backend Development

7 Common Go Concurrency Pitfalls and How to Avoid Them

This article examines frequent mistakes developers make when writing concurrent Go programs—such as misusing context, leaking goroutines, mishandling channels, and causing data races—and provides concrete code examples, impact analyses, and best‑practice recommendations to write safer, more efficient Go concurrency code.

ChannelGoGoroutine
0 likes · 9 min read
7 Common Go Concurrency Pitfalls and How to Avoid Them
FunTester
FunTester
Mar 26, 2025 · Backend Development

Common Go Concurrency Errors and Best Practices

This article examines frequent mistakes in Go's concurrent programming—such as confusing concurrency with parallelism, assuming concurrency always speeds up execution, misusing channels versus mutexes, overlooking workload types, and misunderstanding contexts—provides detailed explanations, potential impacts, and best‑practice solutions with improved code examples.

ChannelGoGoroutine
0 likes · 27 min read
Common Go Concurrency Errors and Best Practices
FunTester
FunTester
Mar 4, 2025 · Backend Development

Mastering Graceful Shutdown in Go: Clean Exit for Servers and Goroutines

This guide explains why graceful shutdown matters in Go programs, outlines the steps to capture termination signals, use context for coordinated goroutine exit, and properly close HTTP servers without data loss or resource leaks.

Graceful ShutdownHTTP serverResource Cleanup
0 likes · 9 min read
Mastering Graceful Shutdown in Go: Clean Exit for Servers and Goroutines
BirdNest Tech Talk
BirdNest Tech Talk
Dec 16, 2024 · Backend Development

Five Ways to Build a Broadcast Notifier in Go

This article examines five Go implementations of a broadcast notifier—using sync.Cond, channels, context, sync.WaitGroup, and sync.RWMutex—detailing their code, execution flow, and trade‑offs so readers can understand how each primitive achieves notification broadcasting.

ChannelGobroadcast
0 likes · 9 min read
Five Ways to Build a Broadcast Notifier in Go
Go Programming World
Go Programming World
Dec 10, 2024 · Backend Development

Deep Dive into Go's Context Package: Design, Implementation, and Usage

This article thoroughly explains the design and implementation of Go's context package, covering its core interfaces, various concrete types, cancellation propagation, deadline handling, value storage, and the internal mechanisms that enable concurrent-safe control flow and data passing across context trees.

cancellationconcurrencycontext
0 likes · 30 min read
Deep Dive into Go's Context Package: Design, Implementation, and Usage
php Courses
php Courses
Dec 4, 2024 · Backend Development

Using the Laravel context() Helper for Managing Application Context Data

The article introduces Laravel's new context() helper, demonstrating its basic usage and a real‑world multi‑tenant example, showing how to add, retrieve, and default context values and simplify shared data handling throughout the request lifecycle.

BackendLaravelMultitenancy
0 likes · 2 min read
Using the Laravel context() Helper for Managing Application Context Data
Huolala Tech
Huolala Tech
Aug 13, 2024 · Mobile Development

How MVP+Context Transforms iOS Architecture for Scalable Apps

This article analyzes common iOS architectural patterns, identifies the drawbacks of traditional MVP implementations, and introduces a deep‑optimization MVP+Context solution with role definitions, automatic binding, memory‑leak prevention, and Swift support, illustrated with real‑world code and diagrams.

MVPObjective‑CSwift
0 likes · 27 min read
How MVP+Context Transforms iOS Architecture for Scalable Apps
Code Mala Tang
Code Mala Tang
Jul 12, 2024 · Frontend Development

Mastering React Component Communication: 7 Essential Techniques

Explore seven core methods for React component communication—including Props, State Lifting, Context, Refs, Hooks, Event Emitters, and Redux—detailing practical code examples, key considerations, and best practices to help developers choose the optimal approach for various application scenarios.

PropsReactRedux
0 likes · 16 min read
Mastering React Component Communication: 7 Essential Techniques
Ops Development & AI Practice
Ops Development & AI Practice
Apr 5, 2024 · Fundamentals

Mastering Go’s Context: Design Principles, Features, and Real‑World Usage

Go’s Context package provides a simple, standardized way to control goroutine lifecycles, enforce timeouts, cancel operations, and pass request-scoped values, embodying Go’s philosophy of clarity and efficiency; this article outlines its key characteristics, design philosophy, and demonstrates practical HTTP cancellation with code.

GoGoroutinecancellation
0 likes · 6 min read
Mastering Go’s Context: Design Principles, Features, and Real‑World Usage
AI Illustrated Series
AI Illustrated Series
Nov 16, 2023 · Fundamentals

Unlocking Go’s Secrets: nil, context, slices, maps, and concurrency primitives

This article provides a comprehensive, step‑by‑step analysis of Go’s core concepts—including nil handling, the context package, string and rune internals, unsafe pointers, memory alignment, WaitGroup, semaphores, channels, slices, map implementations, sync.Map, garbage collection, and reflection—illustrated with concrete code examples and detailed reasoning.

Garbage CollectionGoMemory
0 likes · 30 min read
Unlocking Go’s Secrets: nil, context, slices, maps, and concurrency primitives
MaGe Linux Operations
MaGe Linux Operations
Nov 15, 2023 · Backend Development

Mastering Go’s Context: How to Control Goroutine Lifecycles and Cancel Operations

This article explains the purpose and design of Go’s Context, how it propagates cancellation, deadlines, and values across goroutine trees, and demonstrates using the context package’s functions such as Background, WithCancel, WithDeadline, WithTimeout, and WithValue to manage request‑scoped state effectively.

Goroutinecancellationconcurrency
0 likes · 11 min read
Mastering Go’s Context: How to Control Goroutine Lifecycles and Cancel Operations
KooFE Frontend Team
KooFE Frontend Team
Sep 24, 2023 · Frontend Development

Mastering React Design Patterns: Composite, Uncontrolled, and Render Props

Explore essential React design patterns—including component composition, uncontrolled composite components, and render props—through detailed explanations, practical code examples, and best practices that improve maintainability, scalability, and developer experience in modern frontend development.

Compound ComponentPortalReact
0 likes · 15 min read
Mastering React Design Patterns: Composite, Uncontrolled, and Render Props
37 Interactive Technology Team
37 Interactive Technology Team
Jul 26, 2023 · Backend Development

Investigation and Resolution of CPU Spike in a Kafka-Go Consumer Using pprof

Using Go’s pprof, the team traced a gradual CPU spike in a high‑throughput kafka‑go consumer to a saturated commit queue and repeatedly nested context values, which forced costly lookups; eliminating the unnecessary trace‑id context injection (or recreating a fresh context each loop) resolved the issue and reduced CPU usage to under 2 %.

CPU profilingConsumerGo
0 likes · 10 min read
Investigation and Resolution of CPU Spike in a Kafka-Go Consumer Using pprof
Huolala Tech
Huolala Tech
Mar 28, 2023 · Frontend Development

How to Optimize React Context to Prevent Unnecessary Re‑renders

Learn how to effectively use React Context for state management, avoid props drilling, and eliminate redundant re‑renders by implementing a custom publish‑subscribe store, selector hooks, and performance optimizations similar to libraries like zustand.

Publish-SubscribeReactState Management
0 likes · 11 min read
How to Optimize React Context to Prevent Unnecessary Re‑renders
ByteFE
ByteFE
Feb 8, 2023 · Frontend Development

React Context Re‑render Issues and an Optimized use‑context‑selector Implementation

This article explains why passing an object as a React Context Provider value can cause unnecessary re‑renders, introduces the community‑made use‑context‑selector library to mitigate the problem, analyzes its limitations, and presents a custom optimized implementation using useSyncExternalStore for precise component updates.

Reactcontextfrontend
0 likes · 17 min read
React Context Re‑render Issues and an Optimized use‑context‑selector Implementation
Xiao Lou's Tech Notes
Xiao Lou's Tech Notes
Nov 14, 2022 · Backend Development

How Go’s HttpClient Implements Timeout with Context – A Deep Dive

This article compares Java’s HttpClient timeout implementation with Go’s built‑in HttpClient, explains Go’s Context‑based timeout mechanism, walks through the underlying source code, and shows why Java cannot easily replicate the same approach due to differences in concurrency primitives.

HttpClientTimeoutconcurrency
0 likes · 15 min read
How Go’s HttpClient Implements Timeout with Context – A Deep Dive
Tencent Cloud Developer
Tencent Cloud Developer
Aug 22, 2022 · Fundamentals

Understanding Go's Context: Source Code Analysis and Practical Usage

The article explains Go's context package by dissecting its source‑code implementations—emptyCtx, valueCtx, cancelCtx, and timerCtx—showing how the API (Background, WithCancel, WithTimeout, WithDeadline, WithValue) builds a tree‑structured cancellation and timeout system that simplifies goroutine lifecycle management and request‑scoped data propagation.

GoTimeoutcontext
0 likes · 19 min read
Understanding Go's Context: Source Code Analysis and Practical Usage
KooFE Frontend Team
KooFE Frontend Team
Aug 14, 2022 · Frontend Development

Mastering React Re-renders: When, Why, and How to Optimize Performance

This comprehensive guide explains what React re‑renders are, distinguishes necessary from unnecessary re‑renders, outlines the four triggers—state, parent re‑render, context, and hooks—and provides practical patterns and anti‑patterns, including memoization, useMemo/useCallback, and key management, to improve component performance.

KEYReactcontext
0 likes · 15 min read
Mastering React Re-renders: When, Why, and How to Optimize Performance
KooFE Frontend Team
KooFE Frontend Team
May 14, 2022 · Frontend Development

Mastering Global State in React: useReducer + Context Explained

This article explains how useReducer can replace useState for complex state logic, introduces Context for sharing data across components, demonstrates their combined usage with code examples, and compares this approach to React‑Redux, highlighting differences in data flow, rendering behavior, and suitable scenarios.

ReactcontextuseReducer
0 likes · 5 min read
Mastering Global State in React: useReducer + Context Explained
IEG Growth Platform Technology Team
IEG Growth Platform Technology Team
Feb 21, 2022 · Backend Development

Deep Dive into Go net/http and Gin Framework Source Code

This article provides a comprehensive analysis of Go's net/http library and the Gin framework, detailing request handling flow, router implementation, middleware chaining, and context management, while presenting key source code excerpts to illustrate how HTTP services are built and extended in Go.

GinGoHTTP
0 likes · 18 min read
Deep Dive into Go net/http and Gin Framework Source Code
New Oriental Technology
New Oriental Technology
Dec 10, 2021 · Backend Development

Implementing a Concurrent-Safe Queue in Go

This article explains Go's concurrency safety mechanisms, demonstrates how to build a thread‑safe queue using mutexes, sync.Cond, and context cancellation, and provides complete example code and tests to illustrate proper synchronization and resource management.

GoroutineQueueconcurrency
0 likes · 10 min read
Implementing a Concurrent-Safe Queue in Go
MaGe Linux Operations
MaGe Linux Operations
Sep 10, 2021 · Backend Development

10 Common Go Mistakes That Kill Performance and How to Fix Them

This article lists ten typical Go programming pitfalls—from undefined enum values and misleading benchmarks to pointer misuse, slice initialization, error handling, context misuse, and goroutine closures—explaining why they hurt performance or correctness and offering concrete, idiomatic solutions.

Error HandlingGobest practices
0 likes · 17 min read
10 Common Go Mistakes That Kill Performance and How to Fix Them
MaGe Linux Operations
MaGe Linux Operations
Jul 3, 2021 · Backend Development

How to Build a Go Log Collector with etcd, Context, and Kafka Integration

This article walks through redesigning a Go‑based log‑collection framework, introducing etcd for distributed configuration, demonstrating context for timeout and data propagation, and showing how to integrate Kafka consumers while improving concurrency handling and adding rate‑limiting mechanisms.

BackendKafkacontext
0 likes · 16 min read
How to Build a Go Log Collector with etcd, Context, and Kafka Integration
TiPaiPai Technical Team
TiPaiPai Technical Team
May 28, 2021 · Backend Development

Mastering Go’s Context: Cancellation, Timeouts, and Value Propagation

This article explains Go’s context package, covering its purpose for managing goroutine lifecycles, the key interfaces and implementations such as emptyCtx, cancelCtx, timerCtx, and valueCtx, and demonstrates how to use WithCancel, WithDeadline, WithTimeout, and WithValue to control execution, propagate cancellations, and pass values across call chains.

GoTimeoutcancellation
0 likes · 12 min read
Mastering Go’s Context: Cancellation, Timeouts, and Value Propagation
Tencent Cloud Developer
Tencent Cloud Developer
Feb 24, 2021 · Backend Development

Common Concurrency Bugs in Go and Their Fixes

Analyzing several major Go projects, the article catalogs frequent concurrency pitfalls—such as unbuffered channels, WaitGroup deadlocks, context leaks, loop‑variable races, double channel closes, timer errors, and RWMutex misuse—and offers concise, idiomatic fixes to prevent blocking, leaks, panics, and deadlocks.

ChannelsGoRaceConditions
0 likes · 10 min read
Common Concurrency Bugs in Go and Their Fixes
21CTO
21CTO
Jan 16, 2021 · Backend Development

How to Build a Go‑Based Log Collection System with etcd, Context, and Kafka

This article walks through designing and implementing a Go log‑collection agent that uses etcd for configuration storage, context for timeout and metadata handling, and Kafka for message consumption, complete with code examples, setup instructions, and a rate‑limiting utility.

GoKafkacontext
0 likes · 16 min read
How to Build a Go‑Based Log Collection System with etcd, Context, and Kafka
Alibaba Cloud Native
Alibaba Cloud Native
Jan 3, 2020 · Backend Development

Why Go Skips Inheritance: Master Interfaces, Composition, Modules and Concurrency

This article explains how Go avoids traditional class inheritance by using implicit interfaces and composition, demonstrates the Template Method pattern in Go, explores orthogonal design principles, details Go Modules versioning and migration from GOPATH/vendor, and reviews Go's concurrency models including goroutine, channel and context.

GoInterfacesModules
0 likes · 53 min read
Why Go Skips Inheritance: Master Interfaces, Composition, Modules and Concurrency
Alibaba Cloud Native
Alibaba Cloud Native
Aug 29, 2019 · Cloud Native

Mastering Knative Serving SDK: Build Serverless Apps with Go Context

This article walks through the fundamentals of Golang Context, explains how Knative Serving SDK leverages Context for informer and client initialization, and provides step‑by‑step code examples for building serverless applications, including logging, reconciler implementation, and practical deployment tips.

GoKnativeSDK
0 likes · 11 min read
Mastering Knative Serving SDK: Build Serverless Apps with Go Context
System Architect Go
System Architect Go
Jul 29, 2019 · Backend Development

10 Common Go Mistakes That Can Sabotage Your Code

This article enumerates ten frequent Go programming errors—from unknown enum handling and benchmark mis‑optimizations to pointer misuse, slice initialization, context pitfalls, and error‑handling practices—explaining why they occur, showing reproducible code examples, and offering concrete fixes to write more reliable Go code.

Error HandlingGobenchmark
0 likes · 14 min read
10 Common Go Mistakes That Can Sabotage Your Code
JD Tech
JD Tech
Mar 16, 2018 · Frontend Development

JDReact Development Guide for the JD Oil Card Shell Project

This comprehensive guide details the setup, configuration, component customization, routing, context usage, debugging, and deployment processes for building the JD Oil Card Shell application with JDReact, covering both Android and iOS platforms, common pitfalls, and practical code examples.

JDReactMobileReactNative
0 likes · 18 min read
JDReact Development Guide for the JD Oil Card Shell Project
360 Quality & Efficiency
360 Quality & Efficiency
Aug 10, 2016 · Mobile Development

Understanding Android Activity: Role, Lifecycle, Process States, and Additional Considerations

This article explains the fundamental role of Android Activity as the primary UI component, its interaction with layouts and context, how it saves state, handles configuration changes, switches with services, and details its complete, visible, and foreground lifecycles as well as the various process priority levels in Android.

ActivityAndroidLifecycle
0 likes · 7 min read
Understanding Android Activity: Role, Lifecycle, Process States, and Additional Considerations
Hujiang Technology
Hujiang Technology
May 27, 2016 · Mobile Development

Understanding Context Design in Objective‑C: Concepts, Nested Contexts, Thread Safety, and an Event Bus Example

This article explains the concept of a software context, discusses design considerations such as nesting and thread‑safety, and provides a concrete Objective‑C implementation including a lightweight event‑bus library, helping developers apply context patterns in mobile applications.

Mobile DevelopmentObjective‑Ccontext
0 likes · 8 min read
Understanding Context Design in Objective‑C: Concepts, Nested Contexts, Thread Safety, and an Event Bus Example
21CTO
21CTO
Mar 8, 2016 · Frontend Development

Master JavaScript Scope & Context: From Basics to Advanced Patterns

This article explains the fundamental differences between scope and context in JavaScript, covers variable scope, execution contexts, the scope chain, closures, module patterns, call/apply/bind methods, and ES6 arrow functions, providing clear code examples for each concept.

BINDExecutionContextJavaScript
0 likes · 14 min read
Master JavaScript Scope & Context: From Basics to Advanced Patterns