This article introduces six widely used code comparison utilities—WinMerge, Diffuse, Beyond Compare, Altova DiffDog, AptDiff, and Code Compare—detailing their key features, platform support, and how they help programmers efficiently spot and merge differences in source files.
This article chronicles Anders Hejlsberg's remarkable career—from creating Turbo Pascal and Delphi to designing C# and TypeScript—highlighting his influence on programming language design, IDE development, and the evolution of modern software engineering.
Effective programmers excel by mastering seven key habits—from reading others' code and recognizing bad projects, to avoiding unnecessary meetings, using Git wisely, writing maintainable code, prioritizing tasks, and thinking in scenarios—insights that bridge interview prep and real‑world software development.
Interruptions and poor management practices—such as frequent meetings, vague requirements, shifting project scopes, and unrealistic time compression—drastically reduce developers' focus, increase frustration, and lead to more bugs, making it essential to recognize and address these common workplace pitfalls.
The article argues that programmers who only code are becoming replaceable, emphasizing that mastering real-world business processes, data-driven decision making, and continuous curiosity is essential for engineers to remain valuable and drive meaningful product outcomes.
The article addresses a junior backend developer's concerns about how to start learning given the vastness of topics like algorithms, OS, networking, concurrency, middleware, and databases, and discusses when to prefer Java wrapper classes over primitive types, including performance considerations.
This article analyzes the evolving landscape of frontend IDEs, highlighting industry trends, business and technical drivers, and proposes a unified, cloud‑enabled development environment to boost efficiency and reduce duplicated effort across diverse frontend scenarios.
This article explains how software architects can use UML‑based modeling to translate functional and non‑functional requirements into clear design documents, covering the essential steps, key concepts, and the seven major UML diagram types across requirement, conceptual, and detailed design phases.
This tongue‑in‑cheek article enumerates a series of deliberately harmful programming anti‑patterns—from confusing variable names and deceptive documentation to absurd design choices and nonexistent testing—showing how to make code virtually impossible to understand or maintain.
ICBC’s Smart Investment (AI‑投) project recently passed the third‑level DevOps continuous‑delivery assessment, showcasing a cloud‑native, AI‑driven architecture, a comprehensive DevOps toolchain, and a feature‑branch workflow that together enable rapid, reliable releases and set a new benchmark for financial‑sector software delivery in China.
This article examines five frequent problems in API design—missing or incomplete documentation, lack of parameter validation, non‑atomic operations, and recurring interface issues—explaining why they frustrate front‑end developers and offering practical solutions such as proper documentation practices, enriched response structures, and rigorous validation.
This tutorial explains the concept of Data Flow Diagrams, describes the symbols used, and provides step‑by‑step instructions with screenshots for creating a context‑level DFD and a detailed Level‑1 DFD, including tips for improving readability.
This autobiographical article chronicles the author's journey from a struggling high‑school student with poor English scores to a senior software architect at Motorola, highlighting 24 practical career insights on self‑learning, perseverance, technical depth, documentation, and leadership across embedded, networking, and middleware development.
This article chronicles an Alibaba front‑end specialist’s eleven‑year progression from a fresh graduate to a P9 senior engineer, detailing technical challenges, project leadership, system redesigns, and personal insights on growth, teamwork, and career development within a large tech organization.
The article explains how powerful integrated development environments boost programmer productivity, reduce effort, improve user experience, and how cloud‑based IDEs like Cloud Studio are shaping the future of software development with elastic, serverless computing capabilities.
This article shares ten practical principles—from owning your work and mastering time management to embracing a beginner's mindset—that help engineers avoid common pitfalls, improve team efficiency, and continuously grow in fast‑moving tech environments.
The article describes how JD.com designed and deployed the VMS version management platform—organized around a 3+1 framework of testing online, integration automation, quality automation, and a single trusted data source—to boost the efficiency of thousands of developers working on mobile applications, achieving up to a 20% increase in delivery speed.
This article shares practical productivity techniques for programmers, covering time management with todo lists and the "eat the frog" method, breaking large tasks into micro‑tasks, smart laziness through automation, effective rest habits, and a structured problem‑solving approach.
The article chronicles vczh’s evolution from a curious middle‑school programmer to a Microsoft engineer, detailing his early game projects, compiler experiments, internships, work on WCF Tools, SQL Server, research at MSRA, the creation of the GacUI GUI framework, and the mentorship and career advice he offers to aspiring developers.
The article explains how micro‑frontend architecture breaks monolithic front‑ends into independent, composable units, outlines its three core values, details the ten technical challenges it must address, and describes the evolving cloud‑centric development model that reshapes front‑end engineering.
Good code follows principles of readability, scalability, high cohesion and low coupling, supported by habits like thorough code reviews, purposeful comments, and learning from quality open‑source projects, while developers cultivate abstraction thinking, curiosity, and teamwork to produce reliable, maintainable, and easily extensible software.
In a candid interview, Linus Torvalds shares his pragmatic engineering mindset, explains why Git was his second major project, and demonstrates how a clean pointer‑indirection technique can simplify linked‑list element removal, contrasting it with a more cumbersome approach.
In a candid coffee‑shop dialogue, a startup founder and a senior engineering leader explore the essential abilities of technical managers, revealing that technical judgment—not just coding—drives effective decision‑making, risk assessment, and strategic leadership across evolving team sizes and product stages.
This article distills key principles from "Clean Code", covering how expressive naming, well‑structured functions, and disciplined testing together raise code readability, maintainability, and reliability, while providing concrete examples and actionable guidelines for everyday programming.
This reflective essay shares a Huawei veteran’s journey through ten‑plus years of coding, emphasizing solid fundamentals, clean architecture, performance tuning, rigorous change‑control practices, and continuous curiosity about emerging technologies as the keys to becoming a reliable software engineer.
Gaode’s continuous delivery journey transformed its multi‑stage release process into a standardized, automated pipeline that delivers backend services within an hour, cuts manual effort, boosts release efficiency by up to 90%, and embeds early quality checks and data‑driven insights for faster, higher‑quality business value.
This guide introduces LeetCode, explains why systematic practice matters for interview success, and outlines three essential habits—choosing a scientific problem order, learning top solutions, and regularly organizing patterns—while sharing personal experiences and practical tips for effective algorithm training.
The article reflects on the parallels between urban planning and software design, critiques the pitfalls of unplanned legacy systems, outlines a typical three‑layer development workflow, and introduces domain‑driven design concepts as a disciplined approach to building maintainable backend architectures.
The article explains how to assess a project's code quality using four key metrics, compare error density between codebases, manage legacy code with the Scout Camp principle, and choose reasonable thresholds such as cyclomatic complexity, providing a practical approach for continuous delivery.
The article shares Winter's presentation on building a high‑quality, efficient frontend team, covering demand models, toolchains, continuous integration, reusable architecture, business value, data‑driven thinking, and the Weex innovation case, while also providing recruitment information for the ZooTeam.
Xiaojie, a software engineering graduate, turned his Youzan internship into a full-time Android developer role by inventively cutting Android incremental compile time from minutes to seconds, earning praise for his proactive problem-solving, thriving in the company’s supportive, growth-focused culture.
A senior developer recounts a high‑pressure midnight migration from an aging monolithic platform to a new micro‑service system, describing the technical challenges, ad‑hoc multithreading solutions, and the crucial problem‑solving mindset required to keep millions of transactions running smoothly.
The article reflects on the challenges of modernizing aviation IT systems, highlighting safety‑first regulations, the lack of plug‑in architecture, the need for robust load‑balancing and fault‑tolerance, and how data‑driven automation can bridge the gap between strict oversight and efficient operations.
This article summarizes Google’s core software‑engineering practices—including a unified source repository, the Blaze build system, rigorous code‑review processes, extensive testing, error tracking, language policies, debugging tools, release engineering, project‑management methods, and personnel development—showing how they contribute to the company’s sustained technical success.
This article examines C's unmatched hardware efficiency, its safety trade‑offs, the rise of higher‑level languages focused on developer productivity, and why C remains essential for embedded, real‑time, and AI systems despite shifting popularity trends.
The article chronicles Wang Yi’s three‑decade programming career, his moves across Tencent, Google, Baidu and Ant Financial, and explains how his open‑source AI infrastructure projects SQLFlow and ElasticDL transform model development for analysts while promoting a culture of code review and practical engineering.
The article examines the challenges of adopting microservice architecture, especially when refactoring monolithic applications, by discussing design rationale, risk assessment, mitigation plans, and how to manage conflicts between speed and quality to achieve a "good enough" solution.
The article argues that programmers should devote the majority of their limited time to mastering transferable fundamentals such as clean code, design patterns, and domain‑driven design, while allocating only a small portion to learning ever‑changing frameworks and tools, illustrated through a mentor dialogue and book recommendations.
This tongue‑in‑cheek article enumerates a series of deliberately bad programming practices—from confusing naming conventions and deceptive comments to absurd design choices and zero testing—to illustrate how to make code virtually impossible to maintain.
This article explains why and how to refactor legacy code by defining refactoring principles, describing common code smells, and presenting concrete techniques such as extracting functions, moving fields, introducing explanatory variables, and reorganizing data and inheritance hierarchies to produce cleaner, more maintainable software.
A graduate student recounts the chaotic state of his research team's C# data‑mining project, highlighting poor naming conventions, oversized classes, overuse of singletons, redundant code, lack of proper inheritance, and other anti‑patterns, while offering concrete suggestions such as using meaningful identifiers, applying the single‑responsibility principle, leveraging LINQ, and adopting MVVM for cleaner, more maintainable code.
This article outlines seven essential habits—reading others' code, spotting doomed projects, minimizing meetings, mastering GitHub, writing concise maintainable code, learning to say no, and adopting operation‑oriented design thinking—that help software engineers bridge the gap between interview preparation and real‑world productivity.
This article explains why engineers need business sense, defines the concept, shares product and engineering perspectives, outlines common pitfalls, and offers practical steps and real‑world examples for engineers to better understand and influence business outcomes.
This article summarizes Google's publicly released engineering practices for code review, outlining the purpose, standards, review workflow, key aspects to examine in change lists, strategies for efficient reviewing, handling conflicts, and tips for writing constructive review comments to improve overall code quality.
This article translates Google's engineering practices on code review, outlining the purpose, principles, guidelines, and detailed steps for reviewers and authors to ensure high code quality, efficient collaboration, and continuous improvement across design, testing, documentation, and review speed.
This comprehensive guide explains Google's code review standards, covering reviewer responsibilities, design principles, conflict resolution, what to examine in a change list, review speed, handling large changes, and effective comment writing to ensure high code quality and team productivity.
The article outlines the background, design principles, layered implementation details, and optimization considerations of a reusable, extensible basic framework architecture that separates business, functional, UI, and support layers to reduce coupling and accelerate app development.
This article distills the key recommendations from the 2017 PyCon talk “How to make a good library API”, offering a concise checklist that covers simplicity, consistency, flexibility, and security to help Python developers create intuitive, maintainable, and robust library interfaces.
This article breaks down the concept of system architecture, derives a concise formula—elements plus connections plus solving specific problems—and explores its classifications, characteristics, and practical implications for designing coherent, goal‑oriented software systems.
This article outlines a systematic approach to designing and implementing a modular, multi‑layered application framework that separates business, functional, UI, and infrastructure concerns, enabling fast feature expansion, reduced coupling, and lower development and testing costs.
This article outlines seven key abilities—reading others' code, spotting doomed projects, minimizing meetings, mastering GitHub, writing clean maintainable code, saying no to low‑impact tasks, and adopting operation‑focused design thinking—that together define a highly effective software engineer.
The article outlines five essential attitudes—learning from bugs, challenging testers, preserving code quality, balancing confidence with humility, and acknowledging testers—that together shape a developer into a high‑performing, collaborative professional.
The article details the GNSEC summit where China Merchants Bank earned a Level 3 DevOps Capability Maturity Model certification, outlines the seven evaluated projects, explains the world’s first DevOps standard, and shares an in‑depth interview revealing the bank’s DevOps promotion strategy and challenges in the financial sector.
Drawing on his 11‑year journey from entry‑level engineer to Alipay security core architect, Li Junkui shares practical guidance for new programmers, emphasizing early code exposure, project‑driven growth, code review, code archaeology, continuous polishing, reading, unit testing, and thoughtful design.
This article provides a comprehensive overview of Test‑Driven Development, explaining its principles, workflow, relationship to acceptance testing and traditional testing, its impact on design and documentation, challenges in database development, integration with Agile Model‑Driven Development, common myths, adoption statistics, and a curated list of supporting tools.
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.
A Quora‑sourced investigation reveals that Google engineers average about 150 lines of code per day, implying roughly four million lines are written across the company each day, while community debate questions whether line count truly measures developer efficiency.
This article explains the distinctions and required experience for senior programmers, architects, technical managers, technical directors, and CTOs, outlining their responsibilities, career paths, and the skills needed to advance through each role in software engineering.
The article outlines a front‑end engineer’s three‑stage journey—survival, growth, and system building—offering practical demand‑management tactics, efficiency hacks, business‑centric planning, and structured thinking methods to help developers balance heavy business workloads while advancing technical skills and career development.
A senior Alibaba engineer reflects on a decade of experience, highlighting the power of teamwork, the importance of pausing to think, and the role of learning methods, pair programming, and critical thinking in becoming a better software professional.
The article explores the concept of the enterprise “mid‑platform” (中台), explaining its purpose, types, and value as an enterprise‑level capability‑reuse platform that bridges front‑end and back‑end systems to enhance user‑centric innovation, scalability, and organizational efficiency.
The article humorously explains that the true goal of unit testing is to ensure software quality while maintaining development speed, comparing ineffective testing to practicing shooting without scoring, and suggesting that without proper practice, both efforts may be futile.
This article explains why thinking ability is essential for software engineers, outlines common growth pitfalls, introduces principle‑based, structured, reflective, and extensible thinking methods, and provides practical steps, tools, and leadership advice to continuously improve technical cognition and career advancement.
This article explains how a conventional vehicle can be progressively upgraded through hardware retrofits, sensor integration, mapping, perception, control, and planning modules to achieve SAE Level 4/5 autonomy, using a step‑by‑step analogy with driver training and iterative testing.
Google’s Piper monolithic code repository, built atop Spanner, holds over a billion files and 86 TB of source code, serving tens of thousands of engineers worldwide with trunk‑based development, fine‑grained permissions, automated code review, and massive build traffic, illustrating the benefits and challenges of a single‑repo strategy.
This article presents a detailed overview of the 58 Deployment System (USP), covering its evolution, Java‑based architecture, communication and deployment models, traffic management, one‑stop and parallel deployments, gray‑scale rollout, fast rollback, task‑driven workflow, and future direction within private‑cloud environments.
This tongue‑in‑cheek article enumerates a series of deliberately harmful programming practices—from confusing naming conventions and code obfuscation to misleading documentation, chaotic design choices, and a complete disregard for testing – illustrating how to make software virtually impossible to maintain.
This article breaks down the typical career progression in large tech companies, detailing the expected tenure, responsibilities, and skill development for each stage—from fresh graduates to ordinary engineers, core contributors, tech leads, and finally directors—offering practical insights for anyone navigating a tech career.
This article shares personal insights from a decade at Alibaba, highlighting how teamwork, pair programming, reflective thinking, and disciplined learning methods can transform engineers' productivity and career development.
The article reflects on handling online incidents by first extinguishing the immediate problem, then digging into root causes, and expands the discussion to what truly constitutes technical ability, the pitfalls of reinventing solutions, raising one’s perspective, and the critical role of systematic retrospection.
This essay reflects on why mastering fundamentals such as operating systems, databases, and networking is essential for software engineers, describing both the practical technique benefits and the deeper thinking development that occur as these concepts evolve in a programmer’s mind over time.
The article traces the evolution of autonomous driving from early concepts to modern implementations, highlighting Pony.ai’s technical innovations in sensor fusion, high‑definition mapping, simulation, data processing, software iteration, and the challenges of scaling vehicle fleets for commercial deployment.
This article offers a practical, experience‑based overview of unit testing, explaining why it matters, what makes a good test, when to write or skip tests, who should write them, and how to structure them effectively for reliable software quality.
This tongue‑in‑cheek article enumerates a series of deliberately bad programming practices—from confusing naming conventions and deceptive code tricks to misleading documentation, chaotic design, and the complete avoidance of testing—illustrating how to make software virtually impossible to maintain.
The author, a software engineer and team lead, created a WeChat mini‑program powered by cloud development to help himself and teammates practice PMP exam questions, documenting the background, app screenshots, cloud backend setup, and GitHub commit history.
The updated Java Development Handbook, originating from Alibaba's internal guidelines and now a global standard, introduces 21 new rules, revises 112 descriptions, and enhances examples across seven dimensions including coding conventions, exception logging, unit testing, security, MySQL, engineering, and design, offering developers fresh insights.
This article reviews the Twelve-Factor App methodology, outlining twelve essential guidelines—including codebase management, explicit dependencies, configuration separation, backing services, build‑release‑run workflow, stateless processes, port binding, concurrency, disposability, environment parity, logging, and admin processes—to help developers design resilient, cloud‑native applications.
This article explores the concept of the mid‑platform (ZhongTai) as an enterprise‑level capability‑reuse platform, explaining why companies adopt platformization, the distinction between front‑end, back‑end and mid‑platform, various types of mid‑platforms, and practical guidance for building and evaluating them.
This article explores why many developers feel stuck, debunks common growth myths, and presents a comprehensive thinking framework—including principle, structural, reflective, and expansion mindsets—along with practical steps, recommended books, and leadership advice to accelerate technical and career development.
In this interview, Microsoft Asia Research chief Zou Xin shares his extensive software engineering experience, discusses the evolution of software development, offers practical advice on learning AI, and reflects on his books and upcoming GIAC conference activities, providing valuable insights for engineers and students alike.
A former intern describes how a top Chinese internet firm suffers from messy code, duplicated libraries, inconsistent logging, poor configuration management, and inefficient development processes, while senior staff defend these practices as necessary adaptations to the company's scale and history.
Learn how leveraging familiar design patterns like Singleton, Observer, and Facade can create a common language that streamlines idea sharing and improves collaboration among software development team members.
Both Google and Facebook mandate code reviews, with Google enforcing stricter readability qualifications and dedicated tools, while Facebook uses Phabricator; the article outlines responsibilities, TBR handling, review terminology like PTAL and LGTM, and emphasizes resolving all negative feedback before merging.
This guide shares practical strategies for formulating clear, answerable technical questions—explaining your current understanding, asking fact‑based queries, identifying unknown terms, doing research, choosing the right person, and even using questions to uncover hidden assumptions and contribute to the community.
The article recounts a 2014 experience of refactoring a critical business system after a serious bug, detailing how the team defined scope, designed dual‑flow verification with gray releases, managed expectations, and successfully delivered a maintainable backend solution.
This article presents a curated list of fourteen of the most renowned programmers worldwide, detailing their reputation, major achievements, and community quotes, offering readers insight into the individuals who have shaped modern software development and computer science.
This article outlines a comprehensive career roadmap for programmers, emphasizing the importance of early planning, building a personal knowledge map, cultivating key traits, staying technologically current, mastering rapid learning techniques, and understanding the deeper purpose behind programming, while providing curated resource links.
The article commemorates Joe Armstrong, the creator of Erlang, outlining his life, contributions to fault‑tolerant distributed computing, his influential talks in China, and the programming wisdom he shared, while providing links to his historic presentations.
This article, based on a 2017 PyCon talk, provides a comprehensive checklist of best‑practice guidelines—covering simplicity, consistency, flexibility, and security—to help developers create intuitive, maintainable, and Pythonic library APIs.
The article explores the concept of trustworthy software, outlines its five key dimensions—safety, reliability, availability, security, and resilience—and describes how Huawei Cloud DevCloud is applying these principles through its open‑source mirror services and secure development practices.
This article presents interviews with five programmers five years into their careers, illustrating diverse trajectories—from technical management and senior leadership to frequent job‑hopping for salary growth and stable but modest roles—while offering practical advice on advancement and personal choices.
A 2013 developer poll revealed that naming functions and variables is the most challenging task for programmers, leading to a detailed guide on common naming styles, the ideal of "seeing the function by its name," and practical rules with code examples to improve function naming across languages.
This article explores the most famous software development laws—from Murphy's Law to Moore's Law—explaining their meanings, origins, and practical implications for coding, project management, and system design.
In a 2019 GTLC Beijing talk, Zhang Chu, Vice President of Technology at Mafengwo, explains why measuring engineers is essential, outlines five dimensions of their work, warns against common metric pitfalls, and shares practical frameworks like OGSM and OKR to create goal‑focused, balanced performance evaluations.
The article explores how unpredictable black‑swan events, the butterfly effect, Murphy's law, rapid business growth, technical debt, tool choices, complex domains, documentation, and leadership all combine to threaten software stability, and proposes agile, systematic, and quality‑centric approaches to mitigate these risks.
This article explores the concept of a mid‑platform (中台), explains why enterprises pursue platformization and build a mid‑platform, and shows how it bridges the speed gap between front‑end innovation and back‑end stability to boost user‑centric responsiveness.
The article shares practical interview advice from a seasoned interviewer, covering self‑introduction timing, answering technical questions with personal experience, articulating thought processes for unknown problems, expanding on answers, and emphasizing the need for both breadth and depth in technology skills to stay competitive.
This guide outlines a six‑stage roadmap for programmers, covering deep Java fundamentals, essential databases, UML, design patterns, Linux skills, industry experience, strategic career planning, mindset, documentation habits, and thoughtful job‑hopping to accelerate growth.
This article explores how a frontline technical manager can shift from a traditional top‑down approach to proactive, upward management, emphasizing non‑complaining culture, effective task prioritization, and empowering team members to drive both business and technical growth.
This article compiles curated book recommendations from renowned programmers such as Bozhidar Batsov, Robert C. Martin, Jeff Atwood, and DHH, presenting essential titles across software design, algorithms, systems, and professional development for developers of any experience level.
