Tagged articles
Context
68 articles · Page 1 of 1
This article argues that complex Agent systems must separate three distinct structures: Loop handles node-level convergence, Task Graph manages work dependencies and coordination, and Plugin Runtime binds capabilities like models and tools; mixing them into a monolithic Agent leads to invisible boundaries and unrecoverable failures.
Component GraphContextEvidence
0 likes · 17 min read

The article explains Go's native concurrency with lightweight goroutines and channel communication, outlines common deadlock errors, details unbuffered and buffered channel behavior, proper close rules, select usage, and presents graceful shutdown techniques using channels, context, and sync.WaitGroup, plus practical code examples.
ConcurrencyContextDeadlock
0 likes · 20 min read


ArchitectJul 31, 2026 · Artificial Intelligence
The article breaks down agent engineering into five concentric layers—Prompt, Context, Harness, Loop, and Graph—explaining how each governs task definition, current facts, execution environment, iterative exploration, and stable cross‑task relationships, illustrated with a payment‑callback fix case and AutoResearch insights.
AI agentsAgent EngineeringAutoResearch
0 likes · 20 min read

This article presents a curated collection of 30 essential Go interview questions covering language characteristics, object‑orientation, inheritance, polymorphism, goroutine basics, channel usage, defer execution order, memory allocation, slice vs array, map safety, error handling, context, Go modules, the GMP scheduler, and practical code examples for testing and middleware.
ConcurrencyContextGo
0 likes · 11 min read

This article walks through eight often‑overlooked Go features—including direct integer iteration in Go 1.22, the ~T generic constraint, UTF‑8 string length pitfalls, nil‑interface quirks, nil‑pointer method calls, proper timer usage with contexts, zero‑size struct semaphores, and the JSON "-" tag—showing concrete code examples and the reasoning behind each behavior.
ContextGenericsGo
0 likes · 9 min read

In a Tencent Cloud AI conference interview, Yao Shunyu argues that AI is a long‑term, increasingly diverse field, explains the "second half" concept, stresses the importance of context, culture, and trust, and outlines a three‑layer AI strategy covering foundation, product, and frontier research.
AGIAI strategyContext
0 likes · 9 min read

The article explains that many Claude Code skills are never invoked because their description fields are missing or too long, then walks through the official directory layout, three‑layer loading, description budgeting, fork vs. inline execution, frontmatter groups, and shell pre‑processing, providing concrete examples and best‑practice guidelines.
AI workflowClaude CodeContext
0 likes · 15 min read

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.
AIAgentContext
0 likes · 34 min read

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.
BSONContextGin
0 likes · 10 min read

Gin 1.12 introduces BSON support for direct MongoDB responses, enhanced context error handling, flexible custom binding, raw‑path routing, colored latency logs, and automatic Protobuf/JSON content negotiation, all demonstrated with practical Go code examples and performance tables.
BSONBindingContext
0 likes · 11 min read

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.
Contextchannelgoroutine-leak
0 likes · 8 min read

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.
Best PracticesContextGo
0 likes · 7 min read

Go 1.26 introduces context‑aware net.Dialer methods that combine the zero‑overhead speed of net.DialTCP with timeout, cancellation and tracing capabilities, eliminating DNS resolution and protocol dispatch overhead while providing clear code and a 10‑15% latency reduction for high‑frequency short connections.
ContextGoUnix socket
0 likes · 8 min read

This article examines why context management is critical for LLM agents, compares the strategies of OpenManus, Manus, Claude Code, and Gemini-cli, and extracts practical lessons on token limits, compression techniques, and engineering trade‑offs for building efficient, cost‑effective AI systems.
AICompressionContext
0 likes · 14 min read

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.
BackendContextGo
0 likes · 6 min read

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.
ContextGochannel
0 likes · 7 min read

Learn how to define and manage multiple Kubernetes clusters using contexts, extract certificates, configure contexts for production and test environments, and boost switching efficiency with the kubectx tool, complete with step‑by‑step commands and practical tips.
ContextKubernetesMulti-Cluster
0 likes · 6 min read

Learn why React components re‑render, distinguish parent and owner trees, and apply custom Context Provider patterns to limit updates only to components that consume the context, thereby improving performance without extra memoization.
Component RenderingContextFrontend Development
0 likes · 9 min read

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.
Best PracticesConcurrencyContext
0 likes · 9 min read

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.
ContextGoMutex
0 likes · 27 min read

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.
ConcurrencyContextHTTP server
0 likes · 9 min read

This article explains Go's Context concept, its role in managing Goroutine lifecycles, the standard library's context package API, how to create and cancel contexts, share values safely, and best practices for using Contexts in concurrent backend applications.
ConcurrencyContextGo
0 likes · 11 min read

This article explains how Go developers can break circular import problems in the context package by using XTest‑prefixed helper functions together with a regular Test wrapper, and also demonstrates the export_test.go "backdoor" technique for accessing unexported symbols in black‑box tests.
Circular DependencyContextGo
0 likes · 10 min read

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.
BroadcastConcurrencyContext
0 likes · 9 min read

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

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.
BackendContextLaravel
0 likes · 2 min read

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.
ContextMVPObjective-C++
0 likes · 27 min read

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.
ContextPropsReact
0 likes · 16 min read

This article explains how to use a custom CommonContext with conditional logging and lambda‑based delayed evaluation to quickly trace issues in high‑concurrency Java back‑end systems without degrading performance, and demonstrates the performance improvements through before‑and‑after measurements.
ContextJavaLogging
0 likes · 10 min read

This article outlines six practical techniques—input validation, leveraging Go's secure standard library, avoiding concurrency pitfalls, using defer for resource cleanup, rigorous error checking, and employing context for timeouts—to help developers write more secure and reliable Go applications.
ContextGoinput validation
0 likes · 6 min read

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.
CancellationConcurrencyContext
0 likes · 6 min read

This article explains Go's Context concept, its role in sharing execution state and cancellation signals across Goroutines, the core Context interface, how to create derived Contexts with cancellation, deadlines or values, and best practices for using Context in backend applications.
BackendCancellationContext
0 likes · 11 min read

This article provides a comprehensive analysis of Go's context package, explaining its purpose, the key interfaces and structs, the back‑trace chain and tree architecture, and how cancellation, deadlines, and value propagation are implemented in the standard library source code.
CancellationContextGo
0 likes · 26 min read

The article walks through Go’s context package, explaining how Context objects enable cancellation and timeout control in concurrent workflows, detailing the implementations of emptyCtx, cancelCtx, timerCtx, and valueCtx, and providing concrete code examples and internal mechanics.
@ValueCancellationConcurrency
0 likes · 19 min read

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.
ConcurrencyContextGarbage Collection
0 likes · 30 min read

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.
CancellationConcurrencyContext
0 likes · 11 min read

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 ComponentContextFrontend Development
0 likes · 15 min read

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 profilingConsumerContext
0 likes · 10 min read

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.
ContextFrontend DevelopmentPerformance Optimization
0 likes · 11 min read


ByteFEFeb 8, 2023 · Frontend Development
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.
ContextReactfrontend
0 likes · 17 min read

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.
ConcurrencyContextHttpClient
0 likes · 15 min read

This article explains Go's context package, covering its motivation, core design (interface, implementations, methods), detailed source‑code analysis, and practical recommendations for safe and effective usage in concurrent applications.
Best PracticesCancellationConcurrency
0 likes · 12 min read

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.
ContextGoTimeout
0 likes · 19 min read

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.
ContextReactkey
0 likes · 15 min read

This article explains Go's context package, detailing its core interface, the four concrete implementations (emptyCtx, cancelCtx, timerCtx, valueCtx), their methods, internal cancellation propagation, and practical usage recommendations for safe and effective goroutine coordination.
BackendCancellationConcurrency
0 likes · 11 min read

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.
ContextReactuseReducer
0 likes · 5 min read

This guide explains how to run and switch between several Kubernetes clusters on a single server by configuring separate kubeconfig entries, adding clusters, users, and contexts, and using kubectl commands to manage each cluster efficiently.
ContextKubernetesMulti-Cluster
0 likes · 6 min read

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.
ContextGinGo
0 likes · 18 min read

This article explains how to keep state as close as possible to where it is used, using props for simple sharing, React Context as a "wormhole" for widely needed state, and custom hooks to simplify the pattern, illustrated with a step‑by‑step click‑counter example and performance considerations.
ContextReactState Management
0 likes · 10 min read

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.
ConcurrencyContextQueue
0 likes · 10 min read

When a Go TCP proxy splits socket I/O into separate read and write goroutines, closing the connection can cause "use of closed network connection" errors, and this article shows how to use context cancellation and SetReadDeadline to make both loops exit cleanly.
ContextNetworkingSocket
0 likes · 6 min read

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.
Best PracticesConcurrencyContext
0 likes · 17 min read

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.
BackendContextKafka
0 likes · 16 min read

This article provides a comprehensive tutorial on Flask, covering request objects, application and request contexts, lifecycle hooks, blueprint modularization, class‑based and method‑based views, routing techniques, and common HTTP status codes for rapid Python web development.
BlueprintContextFlask
0 likes · 14 min read

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.
CancellationConcurrencyContext
0 likes · 12 min read

This article explains how to configure, render, and extend Django templates, covering template directories, context data, built‑in tags and filters, reusable blocks, includes, and creating custom tags to efficiently build dynamic web interfaces.
ContextDjangoRendering
0 likes · 16 min read

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.
ChannelsConcurrencyContext
0 likes · 10 min read


21CTOJan 16, 2021 · Backend Development
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.
ContextGoKafka
0 likes · 16 min read

Learn how to merge multiple kubeconfig files, resolve TLS user conflicts, and use the third‑party tools kubectx and kubens to quickly list, switch, and manage Kubernetes clusters and namespaces with simple command‑line shortcuts.
ContextKubernetescluster management
0 likes · 10 min read

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.
CompositionContextGo
0 likes · 53 min read

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.
ContextGoKnative
0 likes · 11 min read

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.
ContextGobenchmark
0 likes · 14 min read

This article explains why and how to use Go's context cancellation feature, covering listening for cancel events, emitting cancellations, time‑based timeouts, practical code examples, and important pitfalls to write faster and more robust backend services.
CancellationContextTimeout
0 likes · 8 min read

Learn how to leverage Go's context cancellation feature with practical patterns, code examples, and best practices—including listening for cancel events, submitting cancellations, time‑based timeouts, and common pitfalls—to build faster, more robust backend services.
Best PracticesCancellationContext
0 likes · 10 min read


JD TechMar 16, 2018 · Frontend Development
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.
ContextJDReactReactNative
0 likes · 18 min read

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.
ActivityAndroidContext
0 likes · 7 min read

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.
ContextEvent BusObjective-C++
0 likes · 8 min read


21CTOMar 8, 2016 · Frontend Development
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.
BINDContextES6
0 likes · 14 min read
