The article explains how microservice architecture serves as a key technology enabling enterprises to achieve digital transformation by improving agility, efficiency, cost-effectiveness, and innovation across various industries, and provides practical guidance and real-world case studies for successful adoption.
The article explains that cyclomatic complexity harms code quality and testability, and shows how using IDEA’s CodeMetrics plugin together with purposeful function extraction—splitting long, complex, or duplicated code into well‑named, reusable methods—reduces complexity, improves readability, and supports maintainable, testable software.
The article explains how business architecture links models, capabilities, and processes to create value streams, stresses the need for scenario‑specific designs over generic ones, and offers practical methods—such as capability grading and risk‑driven effort allocation—to avoid blind decisions and improve resource efficiency.
This article explains how cultivating deep work habits—eliminating distractions, using the Pomodoro technique, and practicing focused, sustained coding—can dramatically boost a developer's productivity, skill growth, and career prospects in today's competitive tech market.
This article examines the importance of R&D efficiency measurement in the digital era, outlines current challenges, proposes principled metric construction, details data collection, cleaning, and analysis methods, and discusses visualization techniques and practical experience for continuous improvement.
The article argues that clean code—characterized by readable naming, minimal comments, short single‑purpose functions, simple control flow, and well‑encapsulated classes—is essential for maintainable software, contrasting it with design patterns and architecture, and demonstrates its benefits through practical refactoring examples and a real‑world case study.
This article distills Chris Zimmeman's "Programming Rules" into twenty concrete guidelines—covering simplicity, bug containment, naming, generalization, deferred optimization, code reviews, debugging, refactoring, conventions, and more—each explained with its rationale and core takeaway for developers.
This comprehensive guide explains the importance of thorough code reviews, outlines common pitfalls that make codebases hard to maintain, and provides practical principles, checklists, automation tips, scaling guidelines, clean‑code traits, naming conventions, and solutions to typical challenges such as conflicts, time pressure, and legacy baggage, helping teams improve code quality and development efficiency.
This comprehensive guide explains the purpose, principles, and practical steps of modern code review, offering checklists, automation tips, common pitfalls, and real‑world examples to help developers improve code health, reduce risk, and foster a culture of continuous learning.
Alibaba Cloud’s recent research breakthroughs—Mint, a cost‑efficient tracing framework that captures all request flows while drastically cutting storage and network overhead, and FAMOS, a multi‑modal fault‑diagnosis method for microservice systems—have been accepted to the prestigious ASPLOS and ICSE conferences, marking the first top‑conference publications in observability for the company.
The article outlines six common harmful behaviors of incompetent technical leaders—taking credit, ignoring team input, emotional manipulation, stifling growth, micromanaging, and pure task delegation—and advises engineers on recognizing and responding to such leaders to protect their career development.
Over the past year the author examined AI‑assisted software engineering through research, product releases, and real‑world deployments, revealing modest efficiency gains, the importance of deterministic inputs, manual context injection, unified domain language, knowledge retrieval strategies, and the need for solid software‑engineering foundations before AI can add real value.
This article summarizes ByteDance’s quality‑efficiency expert Zhao Liang’s QCon presentation on using large language models to automatically generate unit tests, covering pain points, goals, data‑quality engineering, model‑analysis fusion, architecture, evaluation metrics, and future plans for a production‑grade testing tool.
Improving code reviews hinges on clear, domain-specific naming, concise guiding comments that explain why code behaves as it does, and respectful, issue-focused communication that adapts to reviewers’ experience, collectively boosting code quality, team cohesion, and overall software reliability.
The article introduces a data‑driven, Datalog‑based cross‑language program analysis technique presented in an ICSE 2025 paper, describes the open‑source CodeFuse‑Query platform, its technical innovations, and multiple production scenarios such as code evaluation, precise testing, dead‑code detection, and large‑scale code data cleaning.
The article outlines 38 actionable practices—ranging from treating technical debt like a loan and emphasizing simple, well‑named code to rigorous code reviews, systematic refactoring, comprehensive testing, automation, clear documentation, continuous learning, professional conduct, and solid design principles—to help teams reduce debt, improve quality, and sustain long‑term software health.
This article explains the concept of refactoring, distinguishes it from performance optimization, outlines the purposes, timing, and challenges of refactoring, and provides concrete techniques, patterns, and IDE tools—complete with code examples—to help developers improve code structure, readability, and maintainability.
A mobile app deadlock was traced to a do‑while loop introduced by a weaver plugin that concurrently copied method nodes, causing ASM label‑node mismatches; adding thread synchronization to the method‑cloning process resolved the issue and underscores the concurrency risks of bytecode instrumentation.
This article examines how programming large models combined with code knowledge graphs can overcome the limited context of traditional code‑completion tools, detailing key techniques, trigger strategies, context acquisition methods, model fine‑tuning practices, current challenges, and future research directions for intelligent, repository‑wide code suggestions.
The article argues that despite AI’s recent breakthroughs, it cannot solve the inherent complexity of software development, and revisits classic software design principles—from modularity and code design to maintenance and performance—presented in John Ousterhout’s “Software Design Philosophy (2nd edition)” as essential guidance for developers.
This article explores how programmers can develop genuine technical depth by adopting a product‑owner mindset, meticulously handling every stage of a requirement, continuously reflecting on processes, seeking challenging tasks, and aligning personal growth with business goals to achieve lasting professional impact.
In 2003 a modest Australian startup’s desktop mapping app was transformed over a single weekend when Google’s founders challenged its engineers to rewrite the code for the web, cutting size by a third, boosting speed tenfold, and launching the revolutionary Google Maps that reshaped online navigation.
This article explains how Meituan Dianping’s transaction platform evolved through three architectural stages—simple monolith, micro‑service, and platform—by adopting Domain‑Driven Design concepts such as ubiquitous language, bounded contexts, and iterative modeling to manage growing business complexity and improve system maintainability.
Effective code comments fall into nine categories—six recommended types such as function, design, why, teacher, checklist, and guide comments, and three to avoid (trivial, debt, backup)—and using the right kind improves readability, maintenance, and AI‑assisted understanding of software projects.
Senior engineers face low interview pass rates because market standards have risen, experience often doesn’t translate to interview skill, and recruiters may lack coaching, but by deeply researching the role, tailoring résumés, delivering concise, confident introductions, steering conversations, staying tech‑savvy, asking insightful questions, and reflecting after each interview, candidates can markedly improve their performance.
A recent ByteDance programmer’s rant about being overwhelmed by relentless new‑technology hype sparked a wave of empathy among senior developers, highlighting how rapid iteration in internet companies pressures mid‑career engineers to balance experience with staying current, and offering practical ways to regain control.
The article recounts a programmer’s transition to an independent developer, detailing the technical skills acquired, the step‑by‑step creation and monetization of a niche desktop tool, and the practical marketing strategies and lessons learned for sustaining a solo software business.
The author reflects on seven years of software engineering, analyzing the slowing internet market, evolving supply‑demand dynamics, four personal stages of understanding technology as a tool, future opportunities in big firms, digital transformation, AI, and practical advice for lifelong learning and career growth.
This article explores the core competencies of backend engineers, emphasizing accurate problem abstraction, discusses Go's ServerCodec and I/O interfaces, demonstrates algorithmic solutions to the Word Search II problem, and offers practical advice on improving coding skills through studying language features, system design, and effective learning habits.
This article explores the concepts of Service Provider Interface (SPI) and Application Programming Interface (API), examines three possible package locations for interfaces, compares their rules, advantages, and trade‑offs, and provides guidance on selecting the appropriate approach for modular and extensible software design.
This article examines how the introduction of new PHP function features, such as arrow functions and pattern matching, impacts a development team's learning cost, outlining required skill updates, integration challenges, and the trade‑offs between efficiency gains and the effort required to adopt these features.
The article examines how two decades of lavish perks and guaranteed jobs have left software engineers over‑valued, how AI‑driven layoffs and shifting business priorities are forcing CTOs to abandon the old talent‑retention mindset, adopt a genuine engineering culture, and reclaim narrative control to ensure organizational resilience.
This article presents a comprehensive set of R&D performance indicators—including business value, delivery speed, engineering quality, and operational reliability—detailing each metric's definition, calculation method, and practical notes to help teams monitor and improve their development efficiency.
This article explains Joel Spolsky's law of leaky abstractions, illustrating with TCP/IP, database queries, file systems, and language design how seemingly simple abstractions can expose underlying complexities that affect performance, reliability, and developer effort.
Programmers over 30 often find job offers scarce because they focus narrowly on technology and isolated coding circles, so to break the isolation they should join cross‑department projects, engage with customers, develop communication and project‑management skills, share knowledge publicly, and build a personal brand and broader professional network.
This talk explores how engineers can transition from pure coding to collaborative success and empowerment by adopting T‑shaped skills, mastering the "three meetings and one understanding" framework, applying the WWH perspective, and leveraging AIGC tools to continuously iterate their professional growth.
This article compiles several Zhihu answers that share concrete strategies—such as effective searching, leveraging existing libraries, mastering core data structures, designing before coding, and adopting a growth mindset—to help programmers achieve rapid skill improvements.
This article explains how to build a personal quality‑score model that combines delivery efficiency and code quality by defining defect, code‑review, release, fault and ticket metrics sourced from DevOps, calculating weighted scores, addressing potential pitfalls, and extending the model to application‑ and team‑level assessments.
The article chronicles the author’s 30‑year programming career, detailing early experiences, the evolution from JavaScript projects to large‑scale big‑data architectures, cloud migration, business‑agnostic framework design, interactive analytics, and reflections on becoming an independent software architect.
The article examines the growing problem of low‑quality legacy code in large enterprises, presents market data on AI code assistants, and details how Baidu’s Wenxin KuaiMa leverages large‑model technology to provide real‑time code completion, annotation, testing, and enterprise‑level management features aimed at reducing code‑base decay.
This article explores the qualities that distinguish a senior or mature software engineer, drawing on the author’s experience and insights from Etsy’s CTO to outline attitudes, habits, and mindsets that enable engineers to have lasting impact across teams and projects.
These guidelines detail C++ client-side naming conventions using Hungarian notation, modular and component-based development principles, and comprehensive coding style rules—including variable prefixes, class naming, indentation, brace placement, macro safety, and interface design—to promote readable, maintainable, and robust software.
This article outlines the step‑by‑step architectural evolution of JD's advertising platform, describing how the system progressed from a simple, tightly coupled codebase through context‑based designs to a domain‑driven, capability‑oriented architecture that improves extensibility, reuse, stability, and knowledge transfer.
The article examines modern software development challenges, explains why thorough design and modeling are essential before coding, and outlines three key practices—business modeling, business process analysis, and system modeling—along with class analysis techniques to improve collaboration, reduce rework, and build robust architectures.
Facing a critical production deadline, the author shares a three‑step communication and process framework—empathic praise, collaborative brainstorming for an interface delivery review, and reflective design improvement—to strengthen middle‑platform team cohesion and establish robust API governance practices.
This article explains a systematic firmware version numbering scheme—including project name, major/minor versions, build ID, and release type—provides a detailed table of the format, shows a concrete example, and offers best‑practice tips for linking each image to its corresponding Git commit.
The article examines GitHub’s transition from a monolithic Ruby on Rails architecture to a micro‑service model, outlines the strategic steps, highlights the technical and organizational challenges, and presents Warner’s advice on when and how to adopt microservices for companies of different sizes.
This reflective article shares the author’s journey through technical foundations, practical output, and mindset strategies—covering curiosity‑driven learning, cache and concurrency solutions, documentation to reduce tacit knowledge, and a proactive approach to career challenges—all aimed at strengthening engineering effectiveness.
The article shares a software engineer’s personal journey, emphasizing the importance of solid fundamentals, proactive output, curiosity‑driven problem solving, documentation, and process optimization to build lasting technical competence and reduce tacit knowledge throughout a career.
This article explores the lives of pioneering programmers—from Ada Lovelace to Linus Torvalds—and distills ten essential traits that define outstanding developers, offering both historical insight and practical guidance for modern software engineers.
The article describes how Tencent Meeting improved its R&D efficiency by establishing standardization across development, testing, deployment, and operations domains, unifying programming language and CI/CD pipelines, and introducing environment governance and fast‑update mechanisms to reduce duplication, errors, and delivery time.
Matt Welsh argues that despite fifty years of programming advances, humans remain poor at coding, and in the post‑AI era large language models will reshape software engineering, prompting a shift toward prompt engineering, new team roles, and a revival of fundamental engineering practices.
While AI coding assistants like Copilot can slash developers’ workload by up to forty percent, many programmers report that the generated code often needs extensive rework, introduces duplication and subtle bugs, and creates a flood of support requests from non‑technical users, turning promised productivity gains into hidden costs.
The article investigates why Facebook abandoned Git in favor of Mercurial, detailing performance bottlenecks with massive repositories, alternative tool evaluations, the migration process, and how human factors and collaboration shaped the final decision.
This article explores how generative AI tools like ChatGPT, GitHub Copilot, and Amazon Q are enabling developers to rapidly reverse‑engineer, document, and modernize legacy codebases, reduce technical debt, and transform software development practices worldwide.
The 1996 Ariane 5 launch failed when a reused navigation code incorrectly converted 64‑bit floating‑point velocity data to a 16‑bit signed integer, causing an overflow that disabled the guidance system and led to the rocket's explosion, highlighting critical software engineering lessons.
This article shares a recent graduate's three‑year journey at JD, offering practical advice for newcomers, detailing a large‑scale system redesign for a merchant conference, outlining promotion‑season preparation, and describing the development of an AI assistant while emphasizing continuous learning and professional mindset.
The article analyzes why software engineering management has made little progress in the last ten years, highlighting the lag between rapid technological advances and outdated management practices, cultural and human challenges, and insufficient education and training, and it presents a list of questions collected from various companies.
This article explains the philosophy and practical steps of software refactoring, covering its definition, scope, when and why to refactor, systematic processes, risk management, and a catalog of common refactoring techniques illustrated with Java code examples.
Effective requirement quality—clear, complete, measurable, consistent, and feasible—significantly reduces rework, accelerates development, optimizes resource allocation, and enhances team collaboration; the article outlines key quality attributes, measurement indicators, influencing factors, improvement methods, and real-world case studies demonstrating their impact on project success.
This article examines how high‑quality code boosts development efficiency, outlines the factors that affect code quality, presents practical strategies such as training, standards, code reviews, automated testing and refactoring, and provides step‑by‑step guidance for integrating metrics and prioritizing them across various project types.
The article examines Amazon's Correction of Errors (COE) process, presenting both supportive and critical SDE perspectives, and discusses whether detailed post‑incident documentation truly improves engineering practices or merely adds bureaucratic overhead.
This article explains why traditional if‑else statements often lead to complex, hard‑to‑maintain code and demonstrates several techniques—such as removing unnecessary else blocks, using fast returns, guard clauses, dictionary‑based dispatch, and the strategy pattern—to replace if‑else with cleaner, more extensible designs.
This article lists common English technical terms that Chinese developers often mispronounce, explains why these errors happen, discusses whether correction matters, and offers practical steps and resources to improve pronunciation for clearer technical communication.
The author reflects on reading Mark’s ‘Clean Code’ sequel, sharing how seemingly ‘old‑school’ heuristics—like backup configs, commit‑message discipline, and the rubber‑duck method—remain vital in modern software development, despite flashy tools, and urges readers to embrace practical, experience‑driven practices.
Tencent engineers recommend nine classic computer‑science books—ranging from Hamming’s The Art of Doing Science and Engineering to Kleppmann’s Designing Data‑Intensive Applications and Bryant & O’Hallaron’s Computer Systems: A Programmer’s Perspective—to help software engineers deepen theory, improve practice, and gain fresh insights, with a giveaway for commenters.
This article provides a comprehensive, step‑by‑step guide to designing, prototyping, and continuously improving an AI‑assisted software engineering (AI4SE) framework, covering goal definition, pain‑point identification, technology selection, cross‑disciplinary team building, metric evaluation, and real‑world examples for teams of all sizes.
Before writing code, developers should perform systematic design and modeling—including business modeling, process analysis, and system modeling—followed by class analysis and state‑machine design, to align software with business goals, reduce changing requirements, improve quality, and keep teams motivated.
The 1996 Ariane 5 launch failed and exploded due to a single line of legacy code that caused a 64‑bit floating‑point to 16‑bit signed integer conversion overflow in the guidance system, highlighting the dangers of unchecked code reuse, inadequate error handling, and insufficient testing in critical software.
The article presents a comprehensive overview of Google’s code‑coverage system, describing its metrics, integration into the daily development workflow, underlying infrastructure, visualization tools, data‑driven analysis of five years of coverage data, and developer survey results that reveal adoption patterns and perceived usefulness.
This article outlines an architect's thinking model, a step‑by‑step requirement analysis, core design principles for a risk engine—including efficient rule composition, operational support, unified SDK integration, and an event ingestion center—and presents business, application, data, and technical architecture diagrams to illustrate the complete system.
Clean code demands readable, extensible structures and precise, unambiguous naming—each class, method, and variable should convey a single responsibility, avoid duplication, and follow consistent conventions, enabling easy testing, maintenance, and team collaboration while preventing the productivity‑draining chaos of poorly named, tangled code.
This article explores how programmers can cultivate technical depth by treating each requirement as an opportunity for excellence, aligning work with business goals, gaining leadership trust, and balancing technical expertise with broader professional skills for long‑term career growth.
The article outlines eleven common shortcomings—ranging from weak technical fundamentals and lack of business understanding to poor project management, over‑design, communication failures, low execution, insufficient hands‑on experience, ignorance of framework internals, health issues, and missing global perspective—that indicate a software architect may be unqualified for the position.
The article argues that despite advances in tools and practices, modern software quality has declined over the past ten years due to factors such as increasing complexity, lack of focus, superficial engineering culture, and inadequate attention to reliability, usability, and security.
This article explains how to transform business modeling into concrete requirements by analyzing a face‑recognition payment system for school canteens, covering vision definition, target organization identification, goal measurement, use‑case modeling, and detailed use‑case specifications to ensure valuable, well‑scoped software development.
This article outlines practical criteria for judging a programmer’s competence, describing characteristic behaviors and abilities of junior, mid‑level, senior, and veteran developers while emphasizing the importance of code quality, architectural thinking, and soft‑skill development.
This article explains the importance of code review, outlines its core objectives and basic principles, describes practical steps and a detailed checklist, shares several real‑world case studies with before‑and‑after code snippets, and discusses the benefits, metrics, and future AI‑assisted enhancements.
From 2023 to 2024, AI has expanded from simple developer assistance to comprehensive, lifecycle‑wide support, evolving through individual, team, and organizational layers and shifting from local IDE plugins to domain‑specific intelligent code generation tools.
The article outlines ten design philosophies for operating systems—covering correctness, functionality, efficiency, fairness, layered architecture, the relativity of right and wrong, lazy copying, burden allocation, reserved space, illusion of infinite memory, space‑time trade‑offs, policy‑mechanism separation, simplicity, and moderation—illustrated with real‑world software architecture examples.
The article reflects on a technical documentation guide, discusses Tencent's training series, highlights the challenges developers face in finding time for documentation and reviews, and argues that providing sufficient resources is essential for effective documentation practices.
Effective technical documentation requires choosing a searchable knowledge‑base for long‑term storage, writing only value‑adding docs such as architecture designs, feature guides, and onboarding material, following standardized templates and clear formatting rules, assigning owners for regular maintenance, and applying best‑practice principles like accuracy, completeness, and the pyramid structure.
The article reviews the history of China's IT industry over the past eighteen years, exposing how government policies, CMM certifications, and superficial agile practices have led to chronic software quality and delivery problems, and argues that only solid fundamentals such as extreme programming, TDD, and deliberate practice can truly improve software development.
This article outlines seven practical reasons why unit testing is crucial for developers, highlighting how automated tests provide fast feedback, improve code robustness, guide design, boost confidence, act as problem detectors, serve as reliable documentation, and accelerate learning of new APIs.
The article distills the book “Software Method,” outlining a disciplined approach that starts with industry‑specific business modeling—defining vision, use‑case and sequence diagrams, and improvement patterns—then moves to precise requirements gathering, detailed analysis class diagrams, and finally design, emphasizing that true software value comes from meeting real demand.
The article explains why Google created an official Code Health Group, how it promotes readable, maintainable code through internal documentation, consulting, and tooling, and why such organized efforts often fail in other companies lacking formal support and sustained leadership.
This article examines Google’s two‑decade testing culture, detailing the iconic “toilet test” posters, the development of a testing certification program, the shift toward developer‑driven automated testing pyramids, the challenges of scaling massive test suites, and the evolving role of test engineers within the broader quality engineering framework.
The article explains Codeium’s two new metrics—Characters per Opportunity (CPO) and Percentage of Code Written (PCW)—how they are calculated, why they better capture the true value of AI‑powered code completion compared to traditional benchmarks, and how they guide product decisions.
Generative AI tools such as GitHub Copilot, ChatGPT, and Amazon CodeWhisperer are rapidly reshaping software engineering, with surveys showing over 90% of U.S. developers using them, and Seattle tech leaders reporting doubled productivity, faster code migration, and new workflows across startups and enterprises.
The article outlines why reading source code matters—interview prep, skill growth, design insight—and presents a step‑by‑step guide of 18 practical habits, from mastering the JDK and design patterns to exploring demos, focusing on purpose, main flows, and thoughtful annotation.
The article explains how defensive programming extends beyond simple input checks to include comprehensive data validation, parameter verification, illegal data handling, and collaborative design practices that protect systems from both code errors and external misuse.
This case study details how Industrial and Commercial Bank of China's software development center tackled growing complexity, multi‑database client fragmentation, password‑storage risks, and data tampering by creating a centralized online platform that streamlines test data maintenance across thousands of databases while ensuring security and traceability.
The article shares practical lessons on maintaining code quality and readability amid intense project iterations, emphasizing thorough code reviews, incremental refactoring, and the importance of a shared coding style to prevent technical debt and the broken‑window effect.
The article explains that backend engineers frequently become leaders because they handle business‑critical data and architecture, possess a broader understanding of company operations, and often have more interaction‑intensive experience, making them better suited for overseeing whole projects.
The article presents a systematic method for converting business modeling into precise, measurable software requirements by illustrating a face‑recognition payment system for a school canteen, detailing how to identify the target organization and decision‑maker, define improvement metrics such as cutting payment time from five to three minutes, and develop a complete use‑case specification that aligns with organizational value.
This article explores the history of Engineering Productivity (EP) from its Google origins, examines how Chinese companies have adopted EP practices, discusses future development trends including AI‑driven tooling, and offers practical advice on metrics, team improvement, and career transitions.
Facing growing complexity in video streaming, the team overhauled a legacy codebase by redefining architecture, improving code quality, and boosting engineering efficiency through componentized micro‑services, static analysis, automated testing, and gradual rollout, ultimately achieving decoupled, fast‑iteration capabilities across the platform.
The article explains why comparing floating‑point numbers with == in Java often yields unexpected results, describes the IEEE‑754 representation of float and double, demonstrates common pitfalls through code examples, and provides step‑by‑step methods for converting decimal fractions to binary.
To tackle mounting complexity in a fast‑growing video streaming platform, the team executed a large‑scale refactor that introduced a vertical‑layered, horizontally modular architecture, enforced coding standards and ArchUnit guards, applied incremental safe refactoring and gray‑release monitoring, ultimately reducing core classes to seven, improving code quality and engineering efficiency.
This article reviews the classic book *Programming Pearls*, summarizing its overview, key problem‑solving case studies such as bitmap sorting and external sorting, practical programming techniques, and personal reflections on how the book cultivates a deeper, more efficient mindset for software development.
