Tagged articles
source code
89 articles · Page 1 of 1
This article analyzes how recent research redefines source code's role in training coding agents, moving beyond mere training corpus to serve as executable task environments, verification oracles, and skill repositories, citing works like CodeMidas, R2E-Gym, and SWE-smith that leverage implemented functionality for task generation and validation.
AI TrainingCodeMidasR2E-Gym
0 likes · 6 min read

A threat actor posted on a cybercrime forum that they are selling more than 35 GB of Accenture's confidential data—source code, RSA and SSH keys, Azure tokens and storage keys—prompting Accenture to confirm the breach while security experts warn the leaked assets could fuel future attacks.
AccentureAzureRSA key
0 likes · 4 min read

A high‑risk incident reported by ShinyHunters claims Cisco’s core source code, private keys, API tokens, AWS bucket rights, GitHub repositories, and millions of Salesforce records are being sold for $210,000, highlighting how simultaneous exposure of code and credentials can turn a data breach into an ecosystem‑wide compromise.
CiscoPrivate keysdata breach
0 likes · 5 min read

The article dissects Claude Code's open‑source implementation, mapping its directory structure to the five core Harness Engineering modules—bootstrap, context, skills, coordinator/tasks, and query—and explains how each module solves the four fatal agent problems through root‑state minimization, layered context, skill standardization, isolated scheduling, and a closed‑loop query engine.
Claude CodeContext ManagementHarness Engineering
0 likes · 12 min read

This article delves into Viper’s internal architecture, explaining its layered storage and priority lookup mechanism, how it merges environment variables, config files, and defaults, and highlights concurrency safety concerns, offering practical guidelines and code snippets to avoid common pitfalls when using Viper in Go projects.
Best PracticesConcurrencyGo
0 likes · 9 min read

This article presents a collection of thirteen classic Python mini‑games—ranging from coin‑catching and ping‑pong to Tetris, Snake, and 24‑point puzzles—each accompanied by complete, ready‑to‑run source code and step‑by‑step explanations, offering a practical way to learn programming through game development.
PygamePythonTutorial
0 likes · 37 min read

This article explains Redis 6.0's multithreaded I/O feature, covering its background, configuration parameters, execution flow, source code analysis, performance benchmarking against single‑threaded mode, identified limitations, and a brief comparison with Valkey 8.0's advanced I/O design.
Multithreaded I/ORedisbenchmark
0 likes · 22 min read

This article explains how Spring Boot eliminates XML configuration and embeds servlet containers like Tomcat by analyzing Maven dependencies, core startup methods, WebServer creation, and the lifecycle methods that ultimately start and stop the embedded Tomcat instance.
Embedded ServerJavaSpring Boot
0 likes · 10 min read

The article provides a comprehensive technical walkthrough of Qwen’s large‑model series, covering data preparation, tokenization, model tweaks, training settings, RLHF pipeline, Code‑Qwen specifics, Qwen2 and Qwen3 architectural changes, scaling‑law experiments, and detailed source‑code analysis with illustrative diagrams.
MoEQwenRLHF
0 likes · 7 min read

This article explains how Redis 7.0.11 implements multithreading, detailing the required configuration flags, the stages where threads are activated or deactivated based on client write‑backlog, and the impact on network I/O and command execution.
Multithreadingconfigurationio-threads
0 likes · 3 min read

The article dissects kubelet's podUpdateCh, explaining how it ingests pod data from file, URL, and the API server, the Linux‑only file watch, periodic full scans, merging logic, and the underlying code paths that push updates into the channel.
KuberneteskubeletpodUpdateCh
0 likes · 7 min read


21CTOAug 18, 2024 · Fundamentals
This article explains what source code is, why it matters for software creation, maintenance, and security, outlines common code types, provides JavaScript and C examples, and reviews essential development tools for producing high‑quality, reliable applications.
code typescoding toolssoftware development
0 likes · 9 min read

This article explains why mastering Kubernetes is key to cloud computing, outlines its rapid growth and ecosystem support, and provides practical steps, design‑pattern guidance, and community resources for effectively reading and understanding the Kubernetes source code.
Design PatternsDevOpsGo
0 likes · 9 min read

This article explains the MySQL 8.0 Clone plugin introduced in version 8.0.17, compares it with Xtrabackup, details its five‑step cloning process, describes the code structure across SQL, plugin, and InnoDB layers, and outlines the page‑archiving subsystem used to track dirty pages during cloning.
Clone PluginDatabase ReplicationInnoDB
0 likes · 18 min read

This article explains how to use Go's standard flag package for command-line argument parsing, demonstrates various flag definitions and parsing techniques, and provides an in‑depth analysis of its source code, including flag types, syntax, internal structures, and execution flow.
Gocommand lineflag
0 likes · 18 min read

This curriculum provides a comprehensive, step‑by‑step exploration of Kubernetes internals—including kubeadm core source, Go module management, cobra libraries, kubeadm init/join processes, client‑go components, code generators, custom resources, operators, and practical deployment automation—aimed at mastering cluster setup, configuration, and advanced development.
Goclient-gocluster management
0 likes · 10 min read

This article provides a complete Go implementation of the classic Minesweeper game using the Ebiten library, including source code, detailed explanations of game mechanics, instructions for compiling and running both desktop and browser versions, and screenshots demonstrating the gameplay.
EbitenGoMinesweeper
0 likes · 21 min read

This article provides a comprehensive overview of Kubernetes, detailing its fundamental concepts, master‑worker architecture, networking model, security mechanisms, extensibility via custom resources, and an in‑depth examination of key source‑code modules such as kube‑apiserver, etcd, controller‑manager, scheduler, kubelet, and kube‑proxy, with links to the official repository.
Cloud NativeKubernetesarchitecture
0 likes · 10 min read

This article presents a comprehensive guide to building a classic Snake game in Python using the Pygame library, covering game rules, overall design, required libraries, detailed function explanations, and the complete source code for both normal and wall‑through modes.
PygamePythonTutorial
0 likes · 21 min read

This article shares a practical, seven‑step methodology for efficiently reading Redis source code, covering project mapping, prerequisite knowledge, starting from basic modules, identifying the core execution path, tackling complex functions, focusing on main and side branches, and performing targeted gap‑filling to deepen understanding.
reading strategysoftware engineeringsource code
0 likes · 13 min read

This article explores Java's Optional class, explaining its intended purpose, proper usage patterns, common pitfalls, performance considerations, and detailed source code analysis, while comparing it to traditional null checks and demonstrating how methods like map, orElseThrow, and orElseGet behave in practice.
JavaNULL handlingOptional
0 likes · 10 min read

This article investigates why OceanBase's memory freeze threshold changes during load testing by analyzing monitoring data, inspecting the relevant source code, and demonstrating debugging steps, ultimately revealing that the threshold is computed dynamically based on real‑time memory usage and can be lowered when other memory modules consume space.
Freeze ThresholdMemory ManagementOceanBase
0 likes · 18 min read

This article walks you through building a minimal Spring Boot demo, setting breakpoints, analyzing call stacks and logs, and tracing the @Transactional rollback logic in the framework source code to understand why certain methods roll back or commit.
JavaSpringTransaction
0 likes · 19 min read

This article dissects Android's NFC implementation, detailing the layered architecture from the high‑level app down to the kernel driver, explaining each source‑code component, the initialization sequence, and how events travel through JNI, HAL, and the transport‑mapping layer to enable NFC functionality.
AndroidJNINFC
0 likes · 17 min read

This article explores MySQL character set implementation by analyzing system tables (CHARACTER_SETS and COLLATIONS) in information_schema and tracing internal source code structures like CHARSET_INFO, initialization logic, and client connection handling.
Client-Server ProtocolDatabase InternalsMySQL
0 likes · 6 min read

This article provides a detailed source‑code walkthrough of MySQL 8.0.33’s two‑phase commit process, explaining the Prepare and Commit stages, internal structures such as binlog queues, GTID generation, redo‑log flushing, sync handling, and the interactions between InnoDB and the binary log.
Binary LogGTIDInnoDB
0 likes · 18 min read

This article examines why long‑running SELECT COUNT(*) statements are not recorded in MySQL's slow query log, analyzes the relevant source‑code functions, demonstrates debugging with gdb, identifies the min_examined_row_limit setting as the root cause, and provides practical solutions and bug‑report details.
InnoDBMySQLbug
0 likes · 9 min read

This article presents a series of Python mini-game tutorials, including code for coin-collecting, ping-pong, skiing, space shooter, whack-a-mole, dinosaur runner, match-3, Tetris, snake, 24-point puzzle, alien invasion, tic-tac-toe, and more, offering complete source files and gameplay explanations.
PygamePythonTutorial
0 likes · 36 min read

This guide explains why reading source code matters and presents 18 practical techniques—covering JDK fundamentals, design patterns, official documentation, module analysis, demo‑first approach, purposeful reading, and effective note‑taking—to help developers confidently explore Java open‑source projects like RocketMQ.
BackendDesign PatternsRocketMQ
0 likes · 15 min read

This article explains the architecture of Mach virtual memory in iOS, details its page‑based management, describes the core data structures and kernel APIs, analyzes the Objective‑C alloc implementation, and walks through the memory‑pressure (Jetsam) mechanism that triggers low‑memory warnings.
MachMemory ManagementVirtual Memory
0 likes · 21 min read

This guide explains why actively experimenting with code beats passive reading, outlines a step‑by‑step method for mastering source code, and presents a curated list of twenty free Python3 projects—complete with executables and source—that are ideal for beginners and advanced learners alike.
AILearningProjects
0 likes · 7 min read

This guide walks through creating a React app, downloading the React source, building it, linking the packages, configuring webpack aliases, fixing import paths, disabling ESLint, adjusting environment variables, and resolving internal React errors so you can edit and debug the original React source directly in the browser.
Frontend DevelopmentReactcreate-react-app
0 likes · 11 min read

This article explains the internal implementation of component‑level navigation guards in Vue Router 4, covering guard categories, the full navigation lifecycle, the execution mechanism, and detailed source‑code analysis with examples of extractComponentsGuards, beforeRouteUpdate, beforeRouteEnter, and beforeRouteLeave.
Component GuardJavaScriptNavigation Guard
0 likes · 12 min read

This article thoroughly explains the core mechanisms of Vue Router 4 navigation guards, covering global, per‑route, and component guards, their classification, execution flow, and the underlying source‑code implementations such as useCallbacks, guardToPromiseFn, and runGuardQueue.
JavaScriptNavigation GuardRouting
0 likes · 13 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 article dissects the kube-scheduler component of Kubernetes v1.21, detailing its design, initialization, main scheduling loop, pre‑selection (Predicates) and prioritization (Priorities) algorithms, and key source‑code functions such as scheduler.New(), Run(), scheduleOne(), and the scheduling algorithm that binds Pods to Nodes.
Predicatescloud-nativekube-scheduler
0 likes · 32 min read


政采云技术May 10, 2022 · Databases
This article explains MySQL 8.0.17 InnoDB locking mechanisms—including latches, row and table locks, lock modes, intention locks, their compatibility matrix, and detailed source‑code examples that illustrate how IX and X locks are acquired during record updates.
Database ConcurrencyInnoDBIntention Locks
0 likes · 13 min read

This article presents a complete Python pygame implementation of a classic 'Plane War' game, detailing background music integration, enemy destruction effects, scoring system, and player controls, and provides the full source code spanning over three hundred lines for readers to study and run.
Plane WarPygamePython
0 likes · 33 min read

This article explains Vue's error handling mechanisms—including global errorHandler, component-level errorCaptured, and the underlying source code functions handleError, invokeWithErrorHandling, globalHandleError, and logError—through detailed code examples, execution flow diagrams, and practical interview scenarios.
JavaScriptVue.jsVue2
0 likes · 15 min read

The article analyzes NetEase Cloud Music's front‑end team's challenges with repetitive, mode‑driven development and explains how they designed a source‑code‑based low‑code system—Tango—that unifies LowCode and ProCode, integrates with existing GitLab and deployment tools, and dramatically speeds up business‑focused delivery.
ASTGitLab integrationTango platform
0 likes · 11 min read

This article provides a detailed source‑code walkthrough of Envoy's outbound request processing, explaining how the proxy receives client data, parses HTTP requests, selects routes and clusters, forwards traffic upstream, handles retries and shadowing, and finally returns responses to downstream clients.
C++EnvoyHTTP
0 likes · 26 min read

This article explains the internal structure of Java's HashMap, how it computes hash codes, resolves collisions using chaining, the impact of load factor and capacity on performance, and provides detailed source code analysis of its key methods such as put, get, resize, and entry handling.
CollisionHashMapJava
0 likes · 22 min read

This article guides readers through setting up a Kafka 2.7.0 source‑code environment, presents a comprehensive overview of Kafka's core modules, and outlines a step‑by‑step roadmap for deep‑dive analysis of both producer and broker implementations.
JavaKafkaScala
0 likes · 16 min read


ITPUBFeb 17, 2022 · Backend Development
This guide outlines a practical seven‑step methodology for mastering Redis source code, from mapping the project structure and preparing prerequisite knowledge to focusing on core execution paths, handling complex functions, exploring side modules, and iteratively filling knowledge gaps.
BackendRedisreading guide
0 likes · 14 min read

This article presents the complete Unity source code of the "Protect the Kitten" 2D mini‑game, explains its project structure and core scripts, and demonstrates how to integrate Agora's audio SDK to add simple voice‑chat functionality, with download links for the full project.
2D GameAgoraC++
0 likes · 14 min read

This article introduces Android source code directory structures, explains how to configure a local development environment with IDEGen and Android Studio, demonstrates advanced debugging methods such as method, conditional, and log breakpoints, and walks through a real‑world permission‑granting case study to illustrate source‑level analysis and modification strategies.
Android Studiodebuggingidegen
0 likes · 13 min read

This article presents a practical seven‑step methodology for efficiently reading Redis's source code—starting with project mapping, preparing prerequisite knowledge, tackling basic modules, following the core execution flow, using a whole‑before‑detail approach, exploring side features, and finally filling knowledge gaps—applicable to other large codebases as well.
Redisreading strategysoftware engineering
0 likes · 13 min read

This article examines MySQL's INSERT locking behavior, explains why phantom reads do not occur under REPEATABLE READ isolation, and walks through compiling the MySQL source, debugging lock acquisition, and the role of insert‑intention and gap locks using detailed code examples and execution traces.
INSERTInnoDBMySQL
0 likes · 18 min read

This article explains why studying Vue 3 source code is valuable, outlines potential pitfalls, details Vue 3’s design motivations, compares old and new features, answers common questions, and provides step‑by‑step debugging instructions with code examples.
Frontend DevelopmentVue3debugging
0 likes · 10 min read

This brief article explains the importance of reading Kafka's source code for technical interviews, outlines its simple module structure with emphasis on the core module, and highlights critical areas such as offset handling, storage, leader‑follower synchronization, and connector integration with Spark and Flink.
Interview PrepKafkabig-data
0 likes · 4 min read

The article explores why Vim becomes painfully slow when opening or saving a 10 GB file, detailing the editor's process initialization, its memfile‑based virtual storage, the full‑file read performed by readfile, and the multi‑step write sequence triggered by the :w command.
IOfile handlingsource code
0 likes · 17 min read

This article explains how PHP 8 initializes arrays at compile time, detailing the allocation and setup of the HashTable structure, the conditional creation of bucket memory, and provides the full source code and flowcharts for functions such as _zend_hash_init_int and zend_hash_real_init_ex.
array initializationhashtablephp8
0 likes · 9 min read

This tutorial walks iOS developers through downloading the WebKit source, configuring and compiling it, setting up a debugging project or using the MobileMiniBrowser demo, and analyzing WKWebView’s multi‑process architecture—including UI, WebContent, Network, and Storage processes—to troubleshoot and profile rendering behavior.
WKWebViewWebKitcompilation
0 likes · 12 min read

This article provides a step‑by‑step tutorial and complete Python source code for creating a Flappy Bird‑style game using the Pygame library, covering installation, game mechanics, sprite classes, collision detection, scoring, level progression, and customizable settings.
Flappy BirdPygameTutorial
0 likes · 18 min read

This article explains how Objects.equals differs from a.equals when handling nulls and empty strings, analyzes the underlying source code, and clarifies the distinction between reference (a==b) and logical (a.equals(b)) comparisons in Java.
NULL handlingObjects.equalsequality
0 likes · 5 min read

This article explains why and how to read Nacos source code, covering the benefits of understanding underlying principles, code design patterns, and practical knowledge points, while providing step‑by‑step instructions for cloning the repository, exploring the project structure, launching the application, and tracing execution flow.
GitJavaNacos
0 likes · 11 min read

This article showcases remarkable historical source code—from the Apollo 11 guidance computer and Quake III Arena's graphics tricks to the massive GNU compiler, Chromium's modular architecture, and the compact Gitk GUI—highlighting how developers achieved extraordinary efficiency and innovation with limited resources.
CompilerOptimizationgame development
0 likes · 6 min read

The article showcases a curated collection of remarkable source code—from the Apollo 11 guidance computer and Quake III Arena's fast inverse‑square‑root routine to the massive GNU compiler, Chromium browser engine, and the single‑file Gitk GUI—illustrating how developers historically pushed hardware limits and organized complex projects.
ChromiumCompilerGit
0 likes · 7 min read

This article provides a comprehensive analysis of ThinkPHP’s cache system, detailing the execution flow for setting and retrieving cache, exploring the underlying source code, illustrating static method behavior, initialization, file handling, compression techniques, and practical examples with code snippets.
BackendCachePHP
0 likes · 11 min read

The author shares a personal journey of discovering why and how to read source code, covering motivations, effective learning methods such as official docs, books, blogs, design‑pattern awareness, and IDE breakpoint debugging, illustrated with a detailed Spring Boot‑Quartz integration example.
Design PatternsJavaQuartz
0 likes · 12 min read

This article provides a systematic overview of Nginx’s high‑performance architecture, covering its modular design, master/worker process model, event‑driven loop, HTTP request processing phases, location matching rules, upstream load‑balancing, FastCGI and proxy configurations, rate‑limiting mechanisms, and common 502 error troubleshooting, while offering practical tips for reading the source code.
BackendLoad BalancingNginx
0 likes · 45 min read

This guide shows how to locate a jar’s source code in Eclipse, edit it (e.g., add a log statement), export the modified project as a new jar—using the FatJar plugin when third‑party dependencies exist—and replace the original jar in a Java application to see the changes.
EclipseFatJarJava
0 likes · 2 min read

This guide walks you through cloning the dubbo-go repository, configuring environment variables, launching a Go server and client, examining the key source files, and understanding the full export and invocation chain—including registry registration, proxy invokers, and filter wrappers—while highlighting common pitfalls.
GoRPCZooKeeper
0 likes · 22 min read


ITPUBSep 22, 2020 · Fundamentals
This article explores the original 1,000‑line Git source from its first commit, showing how to obtain, compile, and analyze the core commands and objects—init‑db, update‑cache, cat‑file, show‑diff, write‑tree, read‑tree, commit‑tree—while explaining Git’s design principles, storage layout, SHA‑1 naming, and the limitations of the initial implementation.
GitInternalsLinux
0 likes · 19 min read

This article explains how to set up the environment, identify key MyBatis components such as SqlSession, Executor, StatementHandler, ParameterHandler, TypeHandler, and ResultSetHandler, and strategically place breakpoints to effectively read and understand MyBatis 3.5 source code within a Spring Boot 2.3.3 application.
BackendJavaMyBatis
0 likes · 8 min read

The article explains how to integrate Flutter into existing iOS projects using both source code and product (binary) approaches, detailing scripts, Podfile modifications, and build processes to enable seamless debugging and minimal native impact.
CocoaPodsFlutterProduct Build
0 likes · 10 min read

This article explains the benefits of reading source code and provides a step‑by‑step guide for setting up a Gradle‑based environment, downloading, importing, compiling, and debugging Spring Framework source code with practical code examples and IDE configuration tips.
BackendGradleJava
0 likes · 10 min read

This article explains how DBLE implements the MySQL LOAD DATA large‑scale data import feature, covering the overall design, key classes such as ServerLoadDataInfileHandler and LoadDataUtil, and detailed Java source code handling client‑server interactions, file routing, and backend MySQL communication.
DBLEDatabase MiddlewareJava
0 likes · 9 min read

The article explains why developers need to study the source code of popular open‑source frameworks—highlighting project‑driven needs, personal passion for technology, interview preparation, and long‑term career benefits—while urging continuous learning to stay competitive in a fast‑moving industry.
FrameworksLearningopen-source
0 likes · 10 min read

This article explains why Spark is a mature big‑data framework, recommends which Spark versions to study, lists essential research papers, describes how to set up the development environment, and outlines the key components of Spark’s core architecture for effective source‑code exploration.
Apache SparkRDDbig data
0 likes · 6 min read

This comprehensive guide walks you through the CPython source tree, shows how to clone, configure, and compile version 3.8.0b3 on macOS, explains the language grammar, tokenization, memory management, reference counting, and garbage collection, and provides practical code snippets for each step.
CPythonPython interpretercompilation
0 likes · 22 min read

This article explains why reading source code is valuable—for debugging, understanding design, learning languages and algorithms, refactoring, and even interview preparation—and provides practical steps such as reviewing documentation, exploring project structure, focusing on specific issues, debugging, and taking notes.
Best PracticesLearningopen-source
0 likes · 7 min read

In this interview with MySQL expert Huang Yan, the speaker shares practical, down‑to‑earth techniques for DBAs and developers to explore MySQL’s source code, covering tools, history inspection, test‑driven understanding, DTrace probes, and the mindset of an effective DBA.
DBAMySQLdatabases
0 likes · 6 min read

This article shares practical Eclipse shortcuts—Quick Type Hierarchy, Open Call Hierarchy, and flexible debugging—to help developers efficiently navigate and understand Java middleware source code such as Spring and Dubbo.
EclipseIDE TipsJava
0 likes · 5 min read

This article provides a comprehensive overview of MySQL's lock architecture, covering the two‑layer server/storage engine design, metadata (MDL) locks, InnoDB row and gap locks, transaction isolation levels, and practical debugging techniques using source‑code entry points and real‑world examples.
Database InternalsInnoDBLocks
0 likes · 18 min read

This article presents a comprehensive walkthrough of MySQL's two‑layer architecture, metadata (MDL) locks, InnoDB lock types—including gap and record locks—and practical debugging techniques, helping readers understand lock acquisition, release points, and source‑code entry points for effective database operation and development.
Database InternalsInnoDBLock Mechanisms
0 likes · 19 min read

This article walks through Flutter’s Image.network implementation, explaining its constructors, the ImageState lifecycle, how resolveImage creates an ImageStream, the caching strategy in ImageProvider, the NetworkImage download flow, and multi‑frame handling for animated images.
FlutterImageanimation
0 likes · 14 min read


JD TechJul 19, 2018 · Mobile Development
This article provides a comprehensive analysis of Flutter's Image widget, especially Image.network, detailing its constructors, underlying classes, state management, image loading, caching mechanisms, and source code flow, while illustrating how images are fetched, decoded, and rendered in Flutter applications.
DartFlutterImage.network
0 likes · 13 min read

This article explores the internal implementation of Redis blocking commands such as BLPOP and BRPOP, detailing how keys are blocked, the data structures involved, the timeout detection across event loops, and the mechanisms that unblock clients both on timeout and on normal list pushes.
BackendBlocking CommandsTimeout
0 likes · 16 min read

This article provides an overview of Java's ArrayList class, explaining its dynamic array implementation, thread-safety considerations, key interfaces, constructors, capacity management, core methods, and internal mechanisms such as ensureCapacity, trimToSize, and serialization, accompanied by detailed source code excerpts and practical insights.
ArrayListData StructuresJava
0 likes · 13 min read

In Ethereum v1.7.3 the console command miner.start() always returns null, regardless of whether mining actually starts, because the underlying Go implementation returns nil and the real status is logged or inferred from other API calls, not from the return value.
EthereumGominer.start
0 likes · 7 min read

This article explores Java's ArrayList implementation in depth, covering its core interfaces, member variables, constructors, and the most commonly used methods, while illustrating how the internal array expands and how each operation manipulates the underlying data structure.
ArrayListData StructuresJava
0 likes · 14 min read

Redux is a JavaScript state container that enforces a single‑store, unidirectional data flow using actions, reducers and middleware, drawing on Flux, CQRS and event sourcing, and the article examines its core source files while offering best‑practice guidelines such as immutability, pure reducers, smart‑dumb component separation, and careful middleware use.
Design PatternsJavaScriptRedux
0 likes · 16 min read

This guide walks through extending MySQL 5.6.32 by adding a new SQLCOM_STOP_SLAVES command that stops all replication slaves, detailing modifications to lex.h, sql_cmd.h, sql_yacc.yy, sql_parse.cc, and mysqld.cc, along with compilation tips and troubleshooting steps.
C++High AvailabilityMySQL
0 likes · 7 min read

This article outlines a step-by-step DevOps guide for mastering source code, covering preparation, code exploration, framework understanding, workflow tracing, data flow analysis, debugging techniques, and practical tips such as selecting resources, IDEs, and leveraging tests to accelerate learning.
DevOpsIDELearning Guide
0 likes · 15 min read

This guide shows ops engineers how to shift from routine maintenance to DevOps expertise by adopting the right mindset, mastering open‑source community resources, contributing code, and understanding design patterns, concurrency, modularity, data structures, algorithms, and system calls.
Design Patternsoperationssource code
0 likes · 14 min read


21CTOMay 14, 2016 · Backend Development
This guide walks you through locating PHP internal function definitions in the source tree, using strpos as an example, and explains the surrounding C code structure, parameter parsing, error handling, and macro usage for deeper insight into PHP's backend implementation.
C++PHPbackend development
0 likes · 12 min read


21CTOMay 12, 2016 · Backend Development
This article introduces developers to the fundamentals of locating, navigating, and understanding PHP 5.4's C source code, covering the repository, directory structure, essential C concepts, and the role of the Zend engine and extensions.
PreprocessorZend enginebackend development
0 likes · 12 min read

This guide explains how to clone the OpenJDK 8 and 8u repositories using Mercurial, set up the environment, and compile the source code with the standard configure and make process, noting that parallel builds are not supported.
ConfigureJavaMercurial
0 likes · 3 min read
