The article compares Tencent's 12.9 billion and Alipay's 4 billion new code lines in 2019, puts them in perspective with other well‑known software projects, and discusses why raw line counts are a limited metric for evaluating engineering productivity.
This article humorously presents a GitHub project's 19 tongue‑in‑cheek guidelines for writing terrible code—from typing less and mixing naming styles to avoiding comments, tests, and documentation—while illustrating each rule with vivid examples and images.
This article presents Google’s official Java coding style guide, covering terminology, file naming, source‑file structure, formatting rules such as brace placement, indentation, line length, whitespace, naming conventions, Javadoc standards, and practical programming recommendations to help developers write consistent, readable Java code.
This article explains how Alibaba's Cloud R&D team tackled the complex business environment, limited auxiliary resources, and strict product requirements of defect detection by developing the PRECFIX method, which extracts, clusters, and templates defect‑repair pairs to improve code review and patch recommendation.
At Didi, lean‑production ideas are woven into DevOps by establishing coding standards with SemVer and the NUWA framework, introducing traffic‑recording replay and a sim‑sidecar for realistic testing, extending monitoring with fine‑grained metrics, and unifying these practices into an ecosystem that cuts waste, speeds releases, and boosts overall software quality.
This article explains continuous delivery as a software engineering practice that shortens release cycles, improves stability, and enhances team collaboration through standardized processes, automation, and retrospectives, while highlighting its main advantages, business‑management considerations, and the importance of regular post‑mortem analysis.
The article explains how limiting functions to roughly 24 lines and keeping each line under 80 characters improves code readability, aligns with human memory limits, and works across languages, while offering practical tips, examples, and tooling advice for developers.
This article profiles fourteen of the most renowned programmers worldwide, detailing their reputations, key achievements, and memorable quotes that illustrate why they are celebrated as legends in software development and computer science.
This article provides comprehensive strategies for preparing and presenting project experience during software engineering interviews, emphasizing confidence, detailed preparation, highlighting technical strengths such as Java, Spring MVC, database optimization, and big‑data handling, while avoiding common pitfalls and ensuring effective communication with interviewers.
The author recounts his transformation from a teenage gaming enthusiast in a small Chinese university to a senior engineer, manager, and CTO, detailing pivotal moments, lessons on coding, leadership, AI‑driven automation, entrepreneurship, and strategic thinking that shaped his career.
This guide presents a step‑by‑step learning roadmap for ordinary university graduates who want to join leading internet companies, detailing what to study at each stage, how to gain practical experience, when to deepen theory, and effective résumé and interview strategies, with concrete milestones and resource suggestions.
The article explains why developers need to study the source code of popular open‑source frameworks—highlighting project‑driven needs, personal passion for technology, interview preparation, and long‑term career benefits—while urging continuous learning to stay competitive in a fast‑moving industry.
This article provides a thorough explanation of the mid‑platform (Zhongtai) concept, why enterprises adopt platformization, the various forms of mid‑platform systems, their benefits, challenges, and practical recommendations for successful implementation in modern digital businesses.
This tongue‑in‑cheek article enumerates a series of deliberately bad programming techniques—from confusing variable names and deceptive comments to over‑engineered designs and anti‑testing habits—showing how to make code virtually impossible to understand or maintain.
During the early COVID‑19 outbreak, Suning’s self‑developed remote‑office tool Douya was rapidly reconfigured, opened to external users, and continuously upgraded within days, showcasing an intense emergency development process that mobilized over 80 engineers to support millions of remote workers.
Meituan Waimai transformed its release process from a six‑week serial model to a hybrid bi‑weekly and weekly cadence, automating version management, CI pipelines, and deployment to enable continuous delivery that rapidly ships features for over 30 million daily orders while maintaining high quality.
This article presents a tongue‑in‑cheek guide of nineteen "anti‑best‑practice" rules sourced from a GitHub project, illustrating how to deliberately produce unreadable, unmaintainable code by minimizing typing, mixing naming styles, avoiding comments, and other absurd conventions.
During the 2020 Chinese New Year lockdown, a travel platform mobilized its development, product, and operations teams to rapidly build refund systems, coordinate with suppliers, and ensure continuous online services, showcasing a user‑first, cross‑functional emergency strategy that balanced technical delivery with intense customer pressure.
This article chronicles the author’s journey from early web development in university to senior frontend engineering at Alibaba, highlighting pivotal experiences, mindset shifts, productization of expertise, and practical insights on building scalable frontend solutions and fostering cross‑team collaboration.
This article chronicles Ziqian’s journey from university web projects to senior front‑end engineering at Alibaba, highlighting how passion, breaking conventions, productizing expertise, and proactive teamwork transformed personal experience into organizational capability and high‑impact front‑end solutions.
This article provides a comprehensive guide on preparing and delivering concise, confident project introductions during technical interviews, highlighting common pitfalls, effective storytelling techniques, and ways to subtly showcase technical strengths to impress interviewers.
This paper examines continuous deployment practices at Facebook and OANDA, presenting background, methodology, quantitative results on productivity and quality, key findings, lessons, limitations, related work, and concluding that continuous deployment can scale with organization size when supported by management and automation.
The article explains what technical debt is, how it creates a vicious cycle that slows development, outlines common causes such as rushed releases and copy‑paste coding, and offers practical strategies—including measurement tools, incremental migration and full rewrites—to manage and avoid it.
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.
