Tagged articles
Source Code Analysis
73 articles · Page 1 of 1
This article dissects Spring Boot's logging system initialization sequence, the two-phase LoggingSystem setup, and the four-tier configuration priority chain from explicit logging.config down to application.yml logging.* properties, with source-code walkthroughs and practical logback-spring.xml examples.
InitializationLog4j2Logback
0 likes · 15 min read

This article analyzes Nacos service registration and discovery internals, covering architecture, Spring Cloud Commons integration, heartbeat-based health checks, OpenAPI registration flow, and the HostReactor's three-map caching mechanism with 10-second periodic updates and failover support.
NacosRaftService Discovery
0 likes · 21 min read

This article explores how React's key prop works internally, tracing its path from JSX to ReactElement and Fiber, and detailing the three-phase reconciliation algorithm that matches old and new nodes during list updates, with source code examples from React v19.2.8.
FiberReactReactElement
0 likes · 24 min read

This article analyzes Spring Framework 7.0.8 source code to explain IoC container startup, AOP proxy creation, transaction management, and circular dependency resolution via three-level cache, with code examples and interview-focused insights.
AOPCircular DependencyIoC Container
0 likes · 50 min read

This comprehensive guide dissects Spring Boot's core mechanisms including auto-configuration internals, the nine-step startup process from main() to port binding, embedded Tomcat initialization, configuration binding, and fat JAR loading, with source code references and a structured learning path for mastering the framework.
Auto-ConfigurationBest PracticesConfiguration Binding
0 likes · 41 min read

A comprehensive 14k-word technical deep-dive into MyBatis covering its semi-automatic ORM design, four core components (Executor, StatementHandler, ParameterHandler, ResultSetHandler), dynamic SQL parsing via SqlNode trees, two-level caching, plugin mechanism, Spring integration, and source-code-level analysis of 11 key classes with practical best practices and common pitfalls.
Dynamic SQLJava PersistenceMyBatis
0 likes · 36 min read

This comprehensive guide covers Spring Framework 6.x and Spring Boot 3.x internals, including version migration, IoC/DI mechanisms, AOP proxy creation, bean lifecycle, circular dependency resolution, Spring MVC request processing, transaction management, auto-configuration, AOT compilation, and a structured learning roadmap with best practices.
AOPAOT CompilationAuto-Configuration
0 likes · 56 min read

This article provides a comprehensive technical analysis of Sa-Token 1.39.0, covering source code architecture, scenario-based configurations for JWT/stateless auth, mobile multi-device, RBAC admin panels, and SaaS multi-tenancy, plus unit testing patterns, common misconceptions, performance comparisons with Spring Security and Shiro, and production hardening practices.
Best PracticesJava AuthenticationMulti-tenancy
0 likes · 26 min read

This article analyzes MyBatis sharding execution principles through ShardingSphere source code, explaining how logical tables map to physical tables, why three-table joins fail without sharding keys in WHERE clauses, and how to debug routing issues.
Join QueriesMyBatisSQL rewriting
0 likes · 21 min read

The author demonstrates using Claude Code agent to automatically download Android 16 and 17 source code via repo init --reference for space efficiency, then generate an HTML diff report comparing simpleperf repository changes with side-by-side visualization and feature summaries, replacing manual Beyond Compare workflows.
AndroidAutomationClaude Code
0 likes · 3 min read

The final installment of the Spring Boot source‑code series consolidates the previous six episodes—covering startup flow, auto‑configuration, IoC container, bean lifecycle, circular dependencies, and SPI—while providing a complete knowledge map, 20 interview‑question templates, practical study tips, and a roadmap for further learning and contribution.
Auto-ConfigurationBean LifecycleDependency Injection
0 likes · 14 min read

After a source‑map leak revealed Claude Code's 1,884 files and over 512,000 lines of TypeScript, the author spent a month dissecting the CLI tool, exposing its architecture, tech choices, harness‑to‑model ratio, and offering a detailed roadmap for developers.
AI AgentBunClaude Code
0 likes · 16 min read

The article conducts a source‑level technical investigation of the Hermes Agent and Evolver frameworks, comparing their architectures, naming conventions, core algorithms, configuration designs, Git timelines, documentation, and public evidence to assess whether the observed similarities indicate independent development or possible code reuse.
AI AgentEvolverGEP
0 likes · 26 min read

The Claude Code source leak exposed over 500,000 lines of AI‑coding tool code, revealing its npm publishing mishap, the layered architecture built on React Ink, the ReAct‑style agent loop, sophisticated tool orchestration, multi‑tier memory management, context compression, security checks, feature flags, and even anti‑distillation defenses.
AI agentsClaude CodeMemory Management
0 likes · 30 min read


21CTOApr 5, 2026 · Industry Insights
An in‑depth examination of the leaked Claude Code repository shows how Anthropic’s AI client can retain extensive user data, execute privileged commands, and embed covert telemetry, raising serious security and privacy concerns for both public and private deployments.
AnthropicClaude CodeSource Code Analysis
0 likes · 15 min read

The article dissects the accidental public release of Anthropic's Claude Code TypeScript source, detailing the engineering mistakes that caused the leak, the anti‑distillation safeguards, prompt‑caching strategies, undercover mode, memory‑management mechanisms, and the rapid community response that spawned forks, rewrites, and extensive analysis of the system’s design trade‑offs.
AI AgentAnthropicClaude Code
0 likes · 22 min read

The March 31, 2026 Claude Code v2.1.88 release unintentionally shipped a 59.8 MB source‑map, exposing 512,000 lines of TypeScript, which revealed extensive technical debt, hidden Easter‑egg “/buddy”, an unturn‑offable Undercover Mode, anti‑distillation safeguards, and a critical token‑consumption bug that the community patched to boost cache hit rates from 26 % to 99 %.
AI developmentSource Code Analysissoftware engineering
0 likes · 10 min read

The article explains a step‑by‑step method for safely handling the accidental Claude Code source leak, from forking the repository and cloning it locally to generating a comprehensive Repo Wiki with Qoder, then turning that Wiki into reusable AI Skills.
AI skillsClaude CodeGitHub
0 likes · 7 min read

This article provides a detailed source‑code analysis of how OpenFeign and Spring Cloud LoadBalancer collaborate in Spring Cloud microservices, covering core roles, the full request‑response chain, configuration, extension points, reactive vs blocking behavior, performance tuning, and a comparison with Ribbon.
Load BalancingOpenFeignSource Code Analysis
0 likes · 10 min read

This article explains how the Easy Code Reader MCP server integrates with large language models to automatically locate, read, and analyze Java source code across multiple micro‑services and JAR files, improving code‑agent accuracy and developer productivity through a set of practical tools and step‑by‑step examples.
Easy Code ReaderJavaMCP
0 likes · 22 min read

This article explains why using variable assignment expressions inside ORDER BY clauses can trigger severe OCP alarms, analyzes the underlying source code in OceanBase, demonstrates unpredictable query results with examples, and offers safer alternative patterns.
Database WarningORDER BYOceanBase
0 likes · 8 min read

The article investigates a MySQL deadlock that arises when multiple threads concurrently execute INSERT … ON DUPLICATE KEY UPDATE for logistics cancellations, reproduces the issue on MySQL 5.7 and 8.0, analyzes InnoDB lock handling and internal mini‑transactions, and explains how batch processing of each value leads to the deadlock.
DeadlockMySQLON DUPLICATE KEY UPDATE
0 likes · 18 min read

This article walks through JustAuth’s source code, explaining its package layout, request‑response flow, template‑method architecture, key model classes, and practical strategies for reading and extending the SDK to implement new third‑party login providers.
Design PatternsJavaJustAuth
0 likes · 10 min read

This article walks through the JustAuth Spring Boot Starter’s architecture, detailing how the auto‑configuration class, property‑driven bean creation, and factory pattern enable third‑party login integration, while also offering practical tips for reading its source code and understanding key components.
Auto-ConfigurationFactory PatternJava
0 likes · 8 min read

This article provides a detailed, step‑by‑step analysis of the go‑libp2p Swarm implementation, covering host creation, configuration defaults, transport registration, server listening, stream multiplexing with yamux, and the client dialing workflow including dial synchronization, backoff handling, and connection pooling.
NetworkingSource Code Analysisgo-libp2p
0 likes · 47 min read

The article offers a thorough examination of Facebook’s Prophet forecasting model, detailing its additive decomposition of trend, seasonality, holidays and regressors, the underlying Bayesian inference via Stan, the full training‑and‑prediction pipeline, data‑normalization tricks, uncertainty estimation, and practical source‑code insights for e‑commerce applications.
Bayesian inferenceMachine LearningProphet model
0 likes · 21 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 dissects Sharding‑JDBC’s five core engines—parsing, routing, rewriting, execution, and merging—highlights production pain points, and details custom extensions such as skipping sharding for specific tables, forcing master routing, runtime configuration refresh, batch‑update handling, sharding‑condition deduplication, full‑route validation, and a simplified component wrapper to ease integration and improve performance.
Database MiddlewareExecution EngineRouting Engine
0 likes · 55 min read


政采云技术Dec 5, 2023 · Fundamentals
This article explains Java's Service Provider Interface (SPI) mechanism and compares it with Dubbo's enhanced SPI implementation, highlighting how Dubbo addresses the limitations of native Java SPI through configuration format changes and lazy loading.
Dependency InjectionDubbo SPIFramework Extension
0 likes · 19 min read

The article traces a production bug where unreleased JDK ThreadLocal data corrupted user info, then compares JDK ThreadLocal with Netty’s FastThreadLocal, detailing their source‑code implementations, performance trade‑offs (O(n) vs O(1) access), memory‑leak risks, and recommends explicit remove() calls to avoid leaks.
FastThreadLocalJavaMemory Management
0 likes · 15 min read

This course provides an in‑depth study of RocketMQ, covering its fundamentals, source‑code analysis, advanced features such as transactional and ordered messages, performance optimization, operational monitoring, and hands‑on projects that guide learners through installation, configuration, clustering, and integration with Spring Boot.
Distributed SystemsMessage QueuePerformance Optimization
0 likes · 4 min read


政采云技术May 24, 2023 · Frontend Development
This article provides a detailed walkthrough of LocatorJS, covering how to clone the repository, set up the development environment, explore the Chrome extension code, and dissect the runtime implementation that leverages React fiber, SolidJS components, and Babel plugins to enable precise code‑to‑UI mapping.
Babel PluginChrome extensionFrontend Development
0 likes · 11 min read

This article walks through MySQL 8.0.32 source code to explain how the server builds a tree for a WHERE clause, evaluates each condition using classes such as Item_cond_and, Item_cond_or, Item_func_gt, and Item_func_eq, and ultimately decides whether a row satisfies the query.
MySQLSQLSource Code Analysis
0 likes · 19 min read

The article examines Android's DropBoxManagerService architecture, its configurable file retention policies, naming conventions, atomic operations, and broadcast mechanisms, then applies these patterns to propose a client‑side log management system using a producer‑consumer model with prioritized temporary storage, rename‑based reporting, and FileObserver‑driven collection respecting network, data, timing, priority, and battery constraints.
AndroidDropBoxManagerServiceProducer-Consumer
0 likes · 14 min read

This article explains how Java's Objects.equals differs from the traditional a.equals(b) method, covering null and empty‑string scenarios, demonstrating safe comparisons without NullPointerExceptions, and includes a concise analysis of the underlying source code and the distinction between a==b and a.equals(b).
JavaNULL handlingObjects.equals
0 likes · 5 min read

The article dissects Dubbo’s ZooKeeperRegistry by tracing its inheritance from AbstractRegistry through FailbackRegistry to CacheableFailbackRegistry, detailing local memory‑disk caching, retry logic via a timing wheel, URL‑push optimizations, and the ZooKeeper‑based ephemeral node and watcher mechanisms that enable dynamic service discovery, while also covering core ZooKeeper concepts.
Distributed SystemsDubboRPC Framework
0 likes · 20 min read

This article walks through the fundamentals of Spring's transaction management, presenting a practical example, detailed execution workflow, and step‑by‑step source‑code analysis—including bean creation, AOP proxy generation, transaction attribute retrieval, transaction start, commit, and rollback – to help developers master Spring transaction internals.
AOPJavaSource Code Analysis
0 likes · 12 min read

The article dissects Node.js v17’s source to reveal how the CommonJS `require` system is bootstrapped, how native modules are loaded, how `Module._load` resolves, caches, and executes user files, and how the overall CJS loading pipeline operates step‑by‑step.
BackendCJSNode.js
0 likes · 15 min read

An in‑depth examination of Go’s compact context package reveals its core interface, internal implementations like emptyCtx, cancelCtx, timerCtx, and valueCtx, the propagation and cancellation mechanisms, and practical design patterns, concluding with essential best‑practice guidelines for passing, canceling, and using context values safely.
CancellationConcurrencyDesign Patterns
0 likes · 18 min read

This article presents a detailed walkthrough of Apache DolphinScheduler 2.x source code, covering environment preparation, service startup procedures for Master and Worker, task execution flow, key components like Netty and Zookeeper, and personal reflections on open‑source learning and improvement.
Apache DolphinSchedulerJavaSource Code Analysis
0 likes · 12 min read

This article explains why Android forbids UI updates from background threads, analyzes the underlying framework source code to trace the view hierarchy and thread checks, and presents several techniques—both general and view‑specific—to safely modify UI without triggering exceptions.
AndroidBackground ThreadSource Code Analysis
0 likes · 17 min read

This article examines Redis's single‑threaded architecture by walking through its source code, detailing the main function initialization steps, the event‑loop implementation, and how file and time events are processed, while also noting the promotional messages interspersed throughout.
C languageRedisSingle‑threaded
0 likes · 12 min read

This article dissects Nacos 1.4.1's NamingService implementation, detailing how services are registered via HTTP, the construction of registration parameters, the heartbeat mechanism that periodically confirms instance health, and the underlying code flow, including request handling, retry logic, and task scheduling.
NacosSource Code Analysis
0 likes · 9 min read

This article dissects the Kotlin coroutine implementation by decompiling a simple coroutine, explaining how the compiler transforms suspend functions into state‑machine classes, how launch creates an AbstractCoroutine, how the dispatcher intercepts and schedules execution, and how the coroutine is suspended and later resumed through Continuation mechanisms.
ConcurrencyCoroutinesKotlin
0 likes · 16 min read

The article explores MySQL's Hash Join algorithms, comparing Basic, On-disk, Grace, and Hybrid variants, while detailing rule-based optimizer decisions, memory management, disk spilling mechanisms, and outer join execution strategies through source code analysis.
Hash JoinJoin AlgorithmsMySQL
0 likes · 21 min read

This article provides a comprehensive overview of Apache ZooKeeper, covering its purpose, client‑server thread architecture, key source‑code snippets, watch mechanism, performance characteristics of large‑scale clusters, and practical operational strategies for disaster recovery, observer load, GC pauses, and configuration tuning.
Cluster ScalingSource Code AnalysisZooKeeper
0 likes · 20 min read

This course introduces learners to the Laravel framework's core source code, covering topics such as container optimization, the decorator pattern, request proxying, environment loading, and exception mechanisms, and provides an online link for self‑paced study.
LaravelSource Code Analysisframework
0 likes · 2 min read

This article explains Nacos configuration center’s pull‑based data exchange, detailing the push vs pull models, long‑polling mechanism, core concepts like dataId, group, namespace, and provides in‑depth Java source‑code analysis of both client and server implementations.
JavaLong PollingNacos
0 likes · 16 min read

The article thoroughly examines RocketMQ’s NameServer, detailing its lightweight registration-center architecture, startup sequence, and the three core routing mechanisms—registration via broker heartbeats, timed removal of stale brokers, and client‑pulled discovery—while explaining key metadata tables and design patterns such as JVM shutdown hooks and read‑write locks for high‑concurrency safety.
Architecture DesignDistributed SystemsNameServer
0 likes · 30 min read


ByteFEAug 30, 2021 · Frontend Development
This article provides a comprehensive analysis of Axios, covering its core directory structure, internal request/response flow, interceptor mechanism, data transformation, adapter handling, and ways to customize or replace default behavior, illustrated with extensive source code excerpts.
AdapterFront‑endHTTP
0 likes · 18 min read

Analyzing Hystrix’s source code reveals how its circuit‑breaker, bulkhead isolation (semaphore or thread‑pool), timeout detection, fallback logic, and sliding‑window health metrics work together to prevent cascading failures in distributed systems, as illustrated by an e‑commerce order service calling multiple downstream services.
Distributed SystemsFault ToleranceHystrix
0 likes · 20 min read

This article dissects Nacos's service registration mechanism from both client and server perspectives, explaining how it supports both AP and CP consistency models, the core classes involved, and practical debugging steps for developers working with Spring Cloud Alibaba.
AP/CPNacosService Registration
0 likes · 17 min read


政采云技术Jun 29, 2021 · Frontend Development
This article introduces Vite's key features, including its Bundleless approach, native JavaScript module support, and advantages over traditional bundling, along with an analysis of its source code structure and hot update mechanisms.
Hot ReloadJavaScript modulesSource Code Analysis
0 likes · 11 min read

This article traces Redis’s transition from its original single‑threaded design to a multi‑threaded architecture by examining the historical VM thread, the BIO background‑job threads introduced in Redis 2.4 and 4.0, and the network IO threads added in Redis 6.0, complete with source‑code excerpts and detailed explanations of each component’s purpose and implementation.
BIO threadIO threadMultithreading
0 likes · 43 min read


ByteFEMay 8, 2021 · Fundamentals
This article provides a comprehensive analysis of Webpack's core architecture, explaining its three-phase workflow (initialization, building, and generation), plugin system, and module handling mechanisms to help developers understand the underlying principles of this static module bundler.
Build ToolsFrontend DevelopmentJavaScript
0 likes · 23 min read

This article walks through building a basic front‑end router with vanilla JavaScript, then dissects React Router’s source code—including BrowserRouter, HashRouter, Router, Route, and matchPath—explaining their implementations, the history library, and how they improve routing compared to native approaches.
Hash RoutingHistory APIJavaScript
0 likes · 27 min read

The article traces Redis’s shift from its original single‑threaded reactor model to the I/O‑threaded architecture introduced in version 6, explaining how atomic operations and round‑robin client distribution let separate threads handle network I/O and parsing while the main thread executes commands, yielding roughly a two‑fold throughput boost but retaining a single‑threaded command core and incurring brief CPU spikes from busy‑wait synchronization.
I/O multiplexingNetwork ModelPerformance Optimization
0 likes · 34 min read

This article explores the Kubernetes kubelet source code, detailing its directory layout, the main kubelet.go entry point, the Run initialization sequence, the sync loop mechanics, and key questions about pod creation, synchronization, networking, volume management, and cleanup within a v1.13 cluster.
GoKubernetesPod Lifecycle
0 likes · 8 min read

Sentinel implements rate‑limiting through a chain‑of‑responsibility where annotated methods trigger SphU.entry, creating a Context, Node, and Entry; slots such as NodeSelectorSlot, ClusterBuilderSlot, StatisticSlot, and FlowSlot update sliding‑window metrics via LeapArray and enforce QPS thresholds, throwing BlockException on violations.
Circuit BreakingJavaSentinel
0 likes · 18 min read

This article dissects Spring Boot's auto‑configuration mechanism by examining the source code of @SpringBootApplication, @EnableAutoConfiguration, @AutoConfigurationPackage, and the ImportSelector, explaining how starter packages, component scanning, and spring.factories drive the framework's zero‑configuration experience.
AnnotationsAuto-ConfigurationJava
0 likes · 7 min read

This article details a two‑month journey of reading MySQL 8.0.20 source code to uncover how the DELETE statement performs mark‑delete, describing the experimental setup, trace‑log analysis, query and delete phases, and the exact functions that set the deletion flag in InnoDB.
DELETEInnoDBMySQL
0 likes · 19 min read

An in‑depth exploration of Git’s initial 1,000‑line source code reveals the foundational design principles—workspace, index, objects, and three core object types—showing how early implementations of init‑db, update‑cache, write‑tree, and commit‑tree established the powerful, distributed version‑control system we use today.
Source Code Analysisgit internalssoftware design
0 likes · 19 min read

This article introduces Spring MVC, explains the problems of mixing JSP and Servlets, details the MVC layered architecture, walks through essential configuration files and Maven dependencies, presents sample controller code, and analyzes the DispatcherServlet source to illustrate the complete request‑response flow in a Java web application.
DispatcherServletJavaMVC Architecture
0 likes · 23 min read

This article provides a detailed source‑code analysis of Android Jetpack’s Lifecycle, LiveData, and ViewModel components, explaining their architecture, usage examples, internal mechanisms, and offering practical techniques such as bottom‑up and top‑down analysis, code navigation tips, and unit‑test strategies for developers.
AndroidLifecycleLiveData
0 likes · 38 min read

This article explains the purpose of DBLE's heartbeat detection, including high‑availability switching, read load balancing, and idle connection management, and provides a detailed walkthrough of the module's source code—from the Scheduler initialization to the MySQLHeartbeat implementation—illustrating how the system monitors MySQL instance status.
DBLEMySQLSource Code Analysis
0 likes · 8 min read

Redux is a predictable JavaScript state container that centralizes a single immutable store, updates it via dispatched actions processed by pure reducers, combines multiple reducers, supports middleware and DevTools, and can be built from scratch by implementing a createStore function with subscribe, getState, and dispatch.
DevToolsReduxSource Code Analysis
0 likes · 16 min read

This article provides a detailed walkthrough of Vue.js’s core initialization process, examining how the framework’s global API, asset registration, and various utility functions are set up through multiple layers of source code, with extensive code examples and explanations of each step.
Frontend DevelopmentJavaScriptSource Code Analysis
0 likes · 14 min read

This article provides a detailed analysis of DBLE's memory management module, explaining its structure, configuration parameters, allocation and recycling logic, and includes annotated source code snippets for classes such as DirectByteBufferPool and ByteBufferPage, illustrating how off‑heap and on‑heap memory are handled.
ByteBufferDBLEJava
0 likes · 13 min read

This article provides a comprehensive analysis of Pigeon, a point-based open-source RPC framework used by the company, covering its client-side invoker, server-side provider, call flows, Zookeeper integration, service isolation, and operational features.
Load BalancingNettyPigeon
0 likes · 5 min read

This article outlines the critical knowledge points for backend developers, covering source code analysis, distributed systems, microservice architecture, performance tuning, Java engineering practices, and comprehensive concurrency programming techniques.
Distributed SystemsJavaPerformance Optimization
0 likes · 6 min read

This article discusses the importance of source code analysis, outlines key concepts in distributed systems, explains microservice architecture, highlights performance optimization techniques for Java applications, and presents practical engineering advice for modern backend development.
Distributed SystemsJava engineeringPerformance Optimization
0 likes · 8 min read

This article provides a comprehensive overview of the Kubernetes kube‑scheduler, detailing its watch‑and‑bind mechanism, two‑stage scheduling algorithm, and an in‑depth analysis of the source code structure and key functions for readers interested in mastering Kubernetes scheduling internals.
Source Code Analysiscloud-nativeoperations
0 likes · 8 min read

Through a detailed source‑code walkthrough, the article explains how Vuex injects the store via a global mixin, builds a hierarchical module tree, binds and implements dispatch and commit methods, enforces strict‑mode mutation checks with a hidden Vue instance, and enables time‑travel debugging by recording mutations and replacing state.
JavaScriptSource Code AnalysisState Management
0 likes · 24 min read
