This article examines the origins and goals of software development standards, explains why they often break down when enforced through tools, presents concrete examples of such failures, and shares insights from Alibaba's Aone platform that guide the design of a more effective DevOps‑centric R&D workflow.
This article explains how managers can nurture genuine creativity among software engineers by focusing on technical knowledge, collaborative environments, balanced constraints, critical thinking, curiosity, and practical tools, turning creativity into a trainable skill rather than a myth.
This weekly roundup highlights major AI developments such as Google's restructuring of its AI team, Huawei's innovative camera technology, Microsoft's ambitious AI chip accumulation plan, OpenAI's cost‑reduction outlook, Meta's new Llama 3 models, and other notable industry news and expert opinions.
This article presents a thorough guide on modern code review, covering its importance, common obstacles, preparation steps, automation tools, good and bad commit messages, mindset, code quality principles, review workflow, and practical tips for overcoming challenges and improving team engineering culture.
This article shares ten practical Go best‑practice tips—ranging from using a single GOPATH and structuring for‑select loops to defining custom types, adding String methods for enums, and wrapping repetitive logic with context functions—to help developers write flexible, readable, and error‑resistant Go programs.
This article explores how programmers can transform routine tasks into opportunities for deep technical growth by adopting a product‑owner mindset, focusing on quality, continuous improvement, and strategic communication with leadership to secure challenging projects that drive both personal and organizational success.
In 2023, major tech companies like Google, Amazon, and Uber publicly questioned the benefits of microservices, revealing new architectural approaches that promise lower latency, reduced costs, and simpler deployment, while highlighting the challenges and pitfalls that have led many teams to revert to monolithic designs.
This article introduces the open‑source learning_mind_map project, offering 81 curated mind maps that cover topics from C/C++ and Golang to Linux, cloud‑native, databases, DPDK, audio‑video development, and core computer principles, with links to the GitHub repository.
This article examines how large language models (LLMs) are being integrated into DevOps workflows, detailing practical implementations, organizational adoption, efficiency‑boosting techniques, underlying principles, limitations, and future directions for software engineers seeking to leverage AI as a reliable development partner.
This article explains how BizDevOps extends DevOps by integrating business, development, and operations into a unified practice that addresses three efficiency inequalities, defines core capabilities, and provides a comprehensive model and practical framework for digital transformation and sustained high‑quality delivery.
This article adapts the classic "Seven Habits of Highly Effective People" framework to software development teams, explaining each habit—proactivity, beginning with the end in mind, putting first things first, seeking win‑win, understanding others, synergizing, and continuous renewal—and offering concrete behaviors to embed them in daily technical work.
The article surveys modern open‑source AI agent frameworks, defining agents as autonomous perception‑planning‑action systems, outlining core modules (inference, memory, tools, action), comparing single‑agent designs like BabyAGI and AutoGPT with multi‑agent platforms such as MetaGPT and AutoGen, and discussing their benefits, trade‑offs, and future research directions.
This article explores the hidden complexities of dependency management in modern Node.js development, covering the risks of unstable package structures, versioning pitfalls, various dependency types, ghost and circular dependencies, and provides practical strategies and best‑practice recommendations to keep dependency graphs stable, secure, and maintainable.
This article shares a developer's year‑long journey at JD Jinli, covering personal growth, technical innovations such as points‑asset protection, risk mitigation, traffic governance, and communication best practices, while emphasizing how disciplined engineering and collaborative mindset drive business value.
QCon 2024, a premier global software development conference, focuses on AI integration in software development, featuring technical sessions on large language models, AI applications in companies like fast-hand, and practical insights for developers.
AutoDev 1.8 introduces AI‑driven refactoring, commit‑message generation, CLI assistance, and Chinese prompt support, combining software‑development best practices with knowledge‑engineered AI to streamline code changes, improve code quality, and integrate seamlessly into modern DevOps pipelines.
This article presents an in‑depth guide on modern code review, covering its significance, core principles, preparation checklists, automation tools, good and bad commit messages, code quality metrics, naming conventions, security considerations, common pitfalls, conflict resolution, and time‑management strategies for development teams.
This article compiles thirty actionable tips that cover the entire software development lifecycle—from technical selection and tooling to CI/CD, monitoring, and knowledge sharing—helping engineering teams dramatically improve collaboration, productivity, and delivery quality.
The author recounts his early DevOps experiences with continuous integration using TFS, PowerShell, and Azure, reflects on the current undervaluation of DevOps, reviews the “Jenkins 2.x Practical Guide” and highlights sociological insights and practical challenges of adopting CI/CD pipelines.
The Princeton team’s open‑source SWE‑agent equips GPT‑4 with a specialized agent‑computer interface that lets it understand, edit, test, and repair code in real GitHub repositories, achieving state‑of‑the‑art bug‑fixing performance with low latency and cost.
This article outlines ten practical principles for designing applications with large language models, emphasizing a model‑first mindset, precision through interactive disambiguation, clear division of code and model responsibilities, data quality, handling uncertainty, and recognizing the limits of LLMs to build robust, maintainable software.
This article shares actionable advice from a software engineer with eight and a half years of experience, covering habits like keeping work logs, stepping out of comfort zones, staying curious about other teams, joining on‑call rotations, switching teams, blogging, and mindful approaches to introducing new ideas and managing emotions.
LangChain, an open‑source framework that combines large‑language‑model capabilities with code understanding, enables automatic code generation, intelligent code analysis, documentation creation, and interactive programming tutoring, offering software engineers a powerful tool to accelerate development, improve quality, and stay ahead of emerging AI‑driven programming trends.
This article explores the concept of R&D efficiency, outlines its goals, debunks common misconceptions, and presents a practical framework—including practice, platform, and measurement components—supported by visual models to help technology organizations improve delivery speed, quality, reliability, and sustainability.
This article examines why the enterprise mid‑platform once became a popular digital‑transformation strategy, outlines the four main benefits it offered, analyzes the practical problems that led many companies to dismantle it, and provides guidance on when and how organizations should adopt or adapt a mid‑platform approach.
The article explains how interview expectations differ for small, medium, and large companies, and contrasts the priorities of campus recruitment versus social recruitment, offering practical advice on how candidates should tailor their resumes and preparation to match each scenario.
The author reflects on two decades of programming, sharing personal achievements, mistakes, and a comprehensive set of practical recommendations—from choosing the right environment and entrepreneurship to profit models, early‑stage technologies, open‑source contributions, public speaking, and health—aimed at helping early‑career developers fast‑track their growth.
The article examines Jensen Huang’s claim that AI will make programming obsolete, discusses existing AI coding tools, highlights their limitations, and argues that human expertise in design, reasoning, and error‑checking remains essential for software development.
Former LinkedIn senior engineer Chris Krycho reveals how organizational constraints, technical debt, and conflicting migration strategies made modernizing a 2‑million‑line front‑end codebase a multi‑year challenge, offering key insights for large‑scale software refactoring.
The article warns that relying on quick, superficial bug fixes creates hidden technical debt, explains why deep understanding of code changes matters, and offers practical advice to keep code clean, maintainable, and resilient in complex systems.
After fifteen years of software development, the author learns that writing good code demands rapid trial‑and‑error, modular design, SOLID principles, early unit testing, and controlled complexity, while avoiding perfectionism, embracing stakeholder communication, and focusing on high‑ROI learning to create reusable, maintainable tools.
This article explains what a thread pool is—a collection of pre‑instantiated idle threads that execute tasks efficiently—and outlines the essential steps to implement one, including thread creation, container management, and task interface design.
This article presents 18 practical code review guidelines covering comments, logging, naming, parameter validation, exception handling, modularity, concurrency, testing, formatting, compatibility, security, transaction, idempotency, middleware, code smells, and remote calls, offering concrete examples and best‑practice recommendations for Java developers.
This article reviews the 2023 surge of large language models in software engineering, evaluates their current code generation, testing, and knowledge‑query capabilities, highlights persistent challenges in design and maintenance, and proposes concrete recommendations for advancing toward higher‑level intelligent development.
This article explains why C++ template instantiation can cause code bloat and provides concrete, actionable strategies—such as extracting non‑template parts to base classes, using helper abstractions, avoiding unnecessary template parameters, and measuring binary size—to significantly reduce compiled binary size while keeping code maintainable.
In this reflective guide, a CTO shares a year‑long journey from software engineer to technology leader, outlining his career timeline, the evolving definition of the CTO role, a customized framework, and thirteen practical lessons on leadership, delegation, decision‑making, and maintaining technical relevance.
This course introduces the background and features of PHP, explains the role and inner workings of the PHP interpreter—including lexical analysis, parsing, and the virtual machine—and guides students to implement a simple interpreter using C, enhancing their programming and problem‑solving skills.
This article explores the core concepts of software architecture, presenting various definitions from IEEE, Martin Fowler, Ralph Johnson and Neil Ford, and discusses architecture boundaries, the relationship between architecture and detailed design, patterns versus styles, and the knowledge models needed for architects and developers.
The article humorously lists twelve detrimental coding habits—such as over‑splitting microservices, writing excessively long methods, nesting deep conditionals, random variable names, misleading comments, copy‑pasting code, ignoring logs, and reinventing wheels—that reduce code readability and increase maintenance difficulty.
This guide explores practical strategies for programmers to improve communication, handle meetings, manage external dependencies, respond to emergencies, process high‑volume messages, and develop independent, critical, and systematic thinking to become more reliable contributors in software projects.
An experiment conducted on Interviewing.io shows that candidates using ChatGPT can pass 73% of original LeetCode interview questions and 67% of modified ones, while interviewers fail to detect any cheating, highlighting the need for custom interview problems to mitigate AI‑assisted fraud.
The article explains how business and domain modeling—using UML diagrams, RUP‑based workflows, and DDD principles—help engineers bridge the gap between business problems and technical solutions, enabling clearer requirements, stakeholder alignment, and improved system design across complex industries such as finance, logistics, and e‑commerce.
The article examines why every business system accumulates technical debt over time, outlines the stages from initial creation to maintenance decay, analyzes the human and architectural factors that make legacy systems hard to work with, and proposes domain‑modeling and disciplined engineering practices to mitigate and delay that decay.
While AI coding assistants such as GitHub Copilot have accelerated development speed by up to 55% and seen rapid adoption across millions of developers, extensive analysis of 153 million code changes reveals rising churn, copy‑paste, and reduced refactoring that threaten code quality and long‑term maintainability, prompting managers to seek balanced productivity strategies.
This article provides a detailed, step‑by‑step tutorial on enterprise‑grade Git branching models, development processes, common commands, merge strategies, troubleshooting tips, and advanced techniques such as cherry‑pick and rebase, helping newcomers and teams adopt a reliable version‑control workflow.
This article details ICBC Software Development Center's comprehensive approach to performance capacity testing, covering background challenges, a structured quality practice plan, enhanced test scope evaluation, result analysis, tool support, implementation outcomes, and future directions for ensuring system stability and scalability.
A reliable programmer masters timely, clear communication and effective collaboration—replying promptly, managing dependencies, handling emergencies, organizing purposeful meetings, triaging messages, and using concise group‑chat etiquette—while also exercising independent, critical, and systematic thinking to own product decisions, evaluate designs, and break goals into actionable tasks.
Based on DevJobsScanner's analysis of over 10 million global job postings, this report ranks the ten best‑paid programming languages in the United States, detailing average and median salaries, job counts, and industry trends for each language from Java to Solidity.
This article explains the concept, structure, benefits, storage options, workflow integration, common questions, and pitfalls of Architecture Decision Records (ADR), a lightweight documentation practice that helps software teams capture, communicate, and evolve critical architectural decisions effectively.
This article shares practical guidance drawn from over a decade of software engineering experience, illustrating common pitfalls such as false delivery, broken promises, and poor communication, and offering structured advice on setting goals, planning, requirement discussion, coding, code review, and documentation to build a trustworthy professional programmer persona.
The article lists twelve common anti‑patterns—such as splitting microservices per table, writing overly long methods, nesting deep conditionals, random variable names, misleading comments, copy‑pasting code, ignoring logs, and over‑engineering solutions—that dramatically reduce code readability and make maintenance a nightmare.
Recent research and industry observations reveal that developers allocate roughly 58% of their work time to comprehending existing codebases and system architecture, a trend unchanged over four decades, highlighting the critical need for better program‑understanding strategies and collaborative practices.
This article explains the fundamentals of code visualization, why it is needed, presents several real‑world scenarios, and details both static (source‑based and bytecode‑based) and dynamic analysis techniques for generating call graphs, along with their advantages, disadvantages, tools, and case studies.
The guide shows that by consciously designing Go data structures and function interfaces—using pure functions, parameter injection, interface abstractions, struct‑based objects, or function‑variable patterns—and avoiding init(), developers can expose and control all dependencies, making business code inherently testable and achieving high unit‑test coverage.
This guide offers a step‑by‑step 40‑day study plan, exam statistics, recommended resources, weekly tasks, and practical tips to help candidates confidently pass the Senior Software Architecture Designer certification exam.
This article explains typical PHP code smells such as long methods, large classes, duplicate code, excessive comments, complex conditionals, and infinite loops, and provides concrete refactoring examples to improve readability, maintainability, and overall code quality.
The article examines why senior engineers feel anxious when they stop coding, analyzes the trade‑offs between technical depth and managerial responsibilities, compares the roles of technical manager and director, and offers a structured approach for leaders to maintain growth while driving business value.
The article enumerates twenty common bad habits of programmers—from inconsistent terminology and poor documentation to inadequate testing and lack of communication—explaining why they hinder productivity and offering guidance on how to adopt better practices for professional growth.
The 2023 Levels.fyi Global Programmer Salary Report reveals how programmers' compensation varies by city, country, and seniority, highlighting rising median salaries in Beijing, the dominance of AI and blockchain sectors, and the dramatic earnings differences across junior to principal engineering levels.
This article explores how large language models like ChatGPT can be leveraged to transform natural‑language requirements into UML diagrams using PlantUML, demonstrating the workflow, prompt engineering, iterative training, and the resulting efficiency gains for developers.
This guide shares practical methods for creating clear, attractive, and complete diagrams—covering code, architecture, business process, flow, and sequence charts—by applying four design principles, color‑wheel techniques, golden‑ratio composition, and an end‑to‑start mindset to improve developers’ visual communication.
A Chengdu software engineer shares a candid, step‑by‑step recount of his job‑hunting journey, from low‑pay outsourcing traps to tough interview questions on Java, cloud, data structures, and design patterns, culminating in a modest offer and hard‑earned lessons for future candidates.
In this reflective article, a newly appointed CTO shares a year‑long journey from software engineer to technology leader, outlining fourteen practical lessons on leadership, time management, delegation, decision‑making, and the unique challenges of guiding an IT‑service organization.
The 2023 Meituan Technical roundup highlights the ten most‑read articles, ranging from the evolution of its code‑hosting platform and automatic SDK generation to risk‑visualization, trace‑ID recovery, trustworthy A/B testing, KDD research, UI intent detection, MJDK compression gains, large‑scale database high‑availability, and interactive food‑delivery recommendation, each with brief summaries and links.
This article explains the concept, goals, suitable teams, and step‑by‑step process of Mob Code Review (Mob CR), a collaborative code‑review practice that helps teams establish quality standards, educate newcomers, and improve overall code quality through collective inspection and discussion.
This article examines low-code development platforms, outlining their advantages such as reduced cost, lower technical barriers, and faster delivery, while also highlighting drawbacks including limited flexibility, performance and scalability concerns, vendor lock‑in, and challenges with complex projects.
This article revisits defensive programming, explores quirky variable‑naming techniques—including single‑character, Chinese, and multilingual identifiers—and humorously breaks down core OOP concepts while stressing the developer’s irreplaceable role in modern software projects.
The article shares a seasoned backend developer’s reflections on three essential practices—doing, thinking, and talking—highlighting how imitation, continuous questioning, balanced design, collaborative implementation, and effective communication form a lasting framework for personal and professional growth in software engineering.
This article introduces the fundamentals of software modeling and design documentation, explaining how UML diagrams such as class, sequence, component, deployment, use‑case, state and activity charts are used across requirement analysis, conceptual design, and detailed design phases to create clear architectural blueprints.
This article details how Tencent Docs implements a flexible architecture that can switch between monolithic and microservice deployments, describing the motivations, such as framework diversity, configuration conflicts, global variable management, hidden bugs, the custom 'monolith' tool with its configuration format, and the resulting performance and resource savings.
This article explores the essential role of Code Review in improving code quality, fostering knowledge sharing, and enhancing team cohesion, offering practical guidance on what to focus on—from naming conventions and comments to architecture, performance, and security—while also discussing reviewer mindsets and cultural adoption.
This article outlines a systematic approach to mobile architecture design, covering goals, when to create new architectures, requirement analysis, business flow mapping, pattern discovery, layering, modularization, lifecycle interfaces, verification, and evolution, illustrated with a Feed scenario and code examples.
This article explains why clean code matters and provides practical guidelines on naming, class design, function design, and testing—including principles, refactoring examples, and tool recommendations—to help developers write more readable, maintainable, and robust Java code.
The article lists twelve common anti‑patterns—such as over‑splitting microservices, writing excessively long methods, random naming, misleading comments, and avoiding logging—that dramatically reduce code readability and increase maintenance difficulty, illustrating each with a fictional developer’s missteps.
This article presents a comprehensive collection of R&D efficiency metrics and their calculation formulas, covering code integration, quality, productivity, reliability, maintainability, and deployment aspects, to help teams evaluate and improve development performance and operational effectiveness.
Analyzing over 10 million global developer job postings (focused on the United States) from November 2022 to November 2023, DevJobsScanner identified the top ten highest‑paying programming languages, detailing average salaries, median wages, and the number of paid positions for each language.
This article introduces ten useful Python decorator patterns—such as timing, logging, authentication, caching, input validation, retry, permission checks, type checking, singleton, and call counting—explaining their purpose, providing clear code examples, and showing how to apply them to enhance functions and classes.
The article explores why technical and business debt inevitably grow, using entropy theory, 5‑why analysis, Conway's law, and communication complexity, then draws parallels to personal health, offering structured thinking methods to identify, prioritize, and eliminate hidden liabilities in both software projects and everyday life.
This article presents a comprehensive overview of code large‑model evaluation, describing the need for multi‑dimensional benchmarks, the CodeFuseEval benchmark suite, dataset construction, evaluation methods, framework architecture, result visualisation, and future directions for enterprise‑grade code generation models.
The article humorously lists twelve common coding “techniques” that reduce readability and increase maintenance difficulty, illustrating each with exaggerated examples of a programmer named Er Gou who over‑splits microservices, writes massive methods, misuses comments, copies code, and ignores logging.
This article explains the KISS (Keep It Simple, Stupid) principle, outlines its core ideas, presents best‑practice guidelines and common anti‑patterns, and demonstrates how to refactor an over‑engineered Java DAO into a concise, maintainable implementation.
This article explores why code readability matters, compares two implementation styles, outlines three key readability dimensions—plain expression, clear intent, and hierarchical structure—and provides actionable refactoring tips, code‑generation insights, and best‑practice recommendations for developers seeking maintainable, easy‑to‑understand software.
The third part of the series shows how Python scripts can automatically refactor Objective‑C code by encapsulating each data item’s read/write operations in static wrapper classes and rewriting over 600 call sites to use generated XXXSettingReader and XXXSettingWriter methods, achieving zero bugs.
This article presents a comprehensive, four‑stage roadmap for backend developers, covering foundational Go knowledge, engineering best practices, advanced system architecture, and expert‑level soft skills, offering practical guidance for career growth and technical mastery.
This article extends the ideas from "13 Years of Coding at Tencent" by presenting a comprehensive set of engineering self‑cultivation principles—including bias, entropy control, test‑driven design, early and automated testing, unified terminology, domain‑driven design, framework decoupling, and disciplined code encapsulation—to help developers write higher‑quality, maintainable code.
The article describes an automated regression and configuration‑validation platform for social live‑streaming activities that combines task scheduling, Jenkins‑driven test scripts, visual reporting, and a standardized mind‑map configuration system, cutting manual regression time from one day to 0.2 day and alignment effort from 0.5 to 0.1 day.
This article curates 19 genuinely terrible code fragments collected from various developers, illustrating common pitfalls such as magic numbers, poorly named variables, misuse of booleans, and overly complex switch statements, and encourages readers to reflect on and learn from these mistakes.
After inheriting a decade‑old query optimizer with massive code duplication and performance issues, our team reduced the codebase by 80%, improved stability, cut startup time from 18 minutes to seconds, and enabled cloud deployment, sharing the code smells we encountered, their motivations, and concrete fixes.
This article details Guangda Securities' successful DevOps assessment at the 2023 GOPS Global Operations Conference, describing how adopting standardized DevOps practices and a continuous delivery pipeline elevated their development efficiency, quality, and competitiveness in the financial technology sector.
Dongguan Securities' "Zhangzhengbao" service platform passed the China Academy of Information and Communications Technology's DevOps Continuous Delivery Level 3 assessment, demonstrating how standardized processes, automation, and metric‑driven improvements can boost efficiency, reduce costs, and enhance competitiveness in the financial sector.
An extensive backend development roadmap, distilled from a decade of experience at a leading tech firm, guides engineers through foundational Go concepts, system design, microservices, performance optimization, DevOps, security, and leadership skills, offering a structured path from junior to expert level.
This article explains what technical debt is, its harmful effects, common scenarios that generate it, common misconceptions, and practical strategies for managing and repaying technical debt to keep software projects maintainable and cost‑effective.
In a detailed Q&A, Zhengzhou Yisheng Information Technology shares how its two exchange‑focused platforms achieved the DevOps Continuous Delivery Level‑3 assessment, highlighting process improvements, metric gains, architectural choices, challenges overcome, and future plans for broader digital transformation.
China Agricultural Bank’s data platform and user behavior analytics projects passed the Level 3 Agile Development Management assessment at the 2023 GOPS conference, showcasing how agile practices, DevOps maturity, and cross‑functional collaboration drive digital transformation and high‑quality delivery in banking.
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.
This article details Zhengzhou Commodity Exchange’s technology company's successful DevOps continuous‑delivery Level 3 assessment, sharing interview insights, performance metrics, implementation challenges, and future plans that illustrate how standardized, automated DevOps practices boost delivery speed, quality, and digital transformation.
The article explains why both engineers and leaders must participate in code reviews, outlines common pitfalls such as duplicated or overly complex code, and provides concrete best‑practice guidelines—including file and function size limits, early returns, and clear logging—to improve code quality and team collaboration.
This article presents a comprehensive overview of Zhihu's event‑tracking system, covering its motivation, toolset, demand‑management platform, verification workflow, data‑collection pipeline, query service architecture, cloud‑native data service design, and practical Q&A on best practices and optimization strategies.
This article explores the fundamentals of code understanding, including static, dynamic, and non‑code analysis, presents a three‑layer architecture for scalable code comprehension, and demonstrates practical AI‑enhanced applications such as intelligent unit testing, dead‑code detection, and AI‑based static analysis within CI/CD pipelines.
The article systematically examines Domain‑Driven Design through four discourses—Structure, Process, Language, and Modeling—while contrasting the practical “folk” school with the academic school, linking philosophical ideas, software‑complexity theory, strategic and tactical design, refactoring, agile practices, ubiquitous language, and its parallels to UML/SysML, arguing DDD repackages existing engineering concepts rather than inventing new ones.
