The article outlines five actionable strategies—ensuring tests exist, communicating with the original author, eliminating warnings, refactoring, and making the code better than when found—to responsibly modify and enhance legacy code while minimizing risk and technical debt.
Google’s Code Health team, led by Max Kanat‑Alexander, promotes software engineering practices that improve code readability, maintainability, stability and simplicity through internal documentation, code reviews, automated tools, and cultural initiatives, aiming to help engineers make better decisions and accelerate product development.
Google’s Code Health team uses bathroom‑posted programming puzzles to illustrate how deep nesting harms readability, and demonstrates that applying guard clauses and refactoring into short, single‑purpose conditionals can separate error handling from core logic, making code easier to understand and maintain.
This article introduces the fundamentals of using Git as a version‑control system for enterprise development, covering why VCS is needed, Git's advantages, installation, repository initialization, branching, history inspection, pull‑request workflow, and how Git supports unified workflows, collaboration, history preservation, and CI/CD integration.
This article introduces the three major categories of design patterns, explains the six SOLID principles, and provides detailed Java code examples for creational patterns such as Factory Method, Abstract Factory, Singleton, Builder, and Prototype, illustrating their structure and usage.
The article explains Google’s “Code Health” initiative, describing its purpose, organizational structure, and how it promotes better readability, maintainability, stability, and simplicity in software development through best‑practice documentation, tooling, and cultural advocacy.
This article provides a concise historical overview of various software development methods and practices, emphasizing the importance of understanding their origins to better comprehend current development approaches.
This article explains the distinctions and progression steps from senior programmer through architect, technical manager, technical director, to CTO, offering objective guidance on required experience, core duties, and leadership skills for each role in the software engineering career ladder.
This article shares the author's experience and lessons learned from a two‑day intensive discussion on microservice migration, outlining a concrete implementation plan, current architectural challenges, key debates, and the final target architecture blueprint for a third‑party payment company.
The article chronicles Google’s Test Certified initiative from its 2006 inception, detailing its three original levels, certification process, expansion efforts, cultural impact, and both positive and negative aspects, illustrating how a grassroots testing program reshaped engineering practices and code quality across the company.
This article curates ten essential books for CTOs, covering topics from lean startup principles and DevOps to software culture and product design, offering concise insights to help technology leaders stay ahead of trends, improve team productivity, and deliver user‑focused solutions.
This article explains the benefits of code reviews—early bug detection, improved code quality, knowledge transfer, and stronger team trust—while offering practical tips on what to look for and how to conduct reviews efficiently.
This extensive guide outlines how to start learning Java—from installing a JDK and choosing an editor, through mastering procedural and object‑oriented programming, to exploring multithreading, networking, databases, build tools, testing, and advanced topics such as JVM internals, native interfaces, and distributed computing.
This article chronicles the progression of continuous integration practices—from an initial linear build script to stage‑based, process‑oriented, and finally pipeline‑style CI—illustrating how teams can iteratively refine automation, balance feedback speed, and scale resources to achieve reliable, fast software delivery.
This article explores why programmers often feel lost, explains the business‑technology‑software value chain, and shows how adopting a value‑driven architecture mindset can help engineers align their work with business goals, reduce waste, and advance their careers.
The article reflects on programmers' sense of bewilderment, explains how understanding the business‑technology‑software value chain and adopting a value‑driven architectural mindset can help engineers prioritize learning, align with business goals, and reduce wasted effort while enhancing system service capability.
This article shares practical advice on cultivating the right mindset, systematic learning methods, deliberate practice, balancing depth and breadth, essential coding habits, and leveraging technology to drive business, helping engineers accelerate their growth to become technical experts within three years.
MIT researchers introduced the Genesis system, which automatically learns from existing patches to generate and evaluate new patch templates, achieving nearly double the bug‑fix success of the best hand‑crafted approaches and reducing programmers' fixing time by about 50%.
The article chronicles Bjarne Stroustrup’s creation of C++, his pivotal role in its evolution, the prestigious 2017 Faraday Medal honor, and how C++ remains essential in large‑scale and infrastructure applications such as telecommunications, banking, and embedded systems.
The article explores the AI Programmer system, a machine‑learning framework that uses genetic algorithms and a Turing‑complete, minimalist language to automatically generate full software programs with minimal human input, marking a significant step toward fully automated software development.
This guide outlines a systematic approach to rapid technical growth in the first three years of a career, covering mindset, structured learning, knowledge internalization, depth‑vs‑breadth decisions, coding habits, and practical ways to leverage tools and frameworks for continuous improvement.
This essay explores why a strong engineer culture—rooted in freedom and efficiency—is essential for tech firms, compares operation‑driven, product‑driven, and technology‑driven companies, and offers practical steps to embed such a culture through hiring, performance, and organizational design.
This article examines why JavaScript developers experience fatigue, explains that software exists to reduce costs and increase revenue, and offers practical strategies—such as mastering fundamentals, selective tool use, and test‑driven development—to help engineers stay productive and focused on solving real business problems.
An informal weekend essay explores how senior programmers differ from junior ones by emphasizing twenty key attributes—reliability, readability, maintainability, testability, extensibility, portability, scalability, usability, availability, reusability, interoperability, manageability, supportability, consistency, security, performance, stability, accuracy, customizability, and robustness—highlighting self‑discipline as the core differentiator.
Using Bjarne Stroustrup’s city-tour analogy, this article outlines seven technology‑learning stages—from Stranger to Architect—detailing the traits of each role (Tourist, Resident, Worker, Craftsman, Reformist, Revolutionist) and how developers progress from basic awareness to shaping entire tech ecosystems.
This article surveys eleven cutting‑edge development tools—from project‑based learning platforms and team‑monitoring utilities to novel web frameworks, OS query engines, mobile Firebase integration, terminal sharing, Kubernetes sandboxes, documentation generators, headless CMS, lightweight REST APIs, and Ruby performance boosters—explaining their core benefits and use cases for modern developers.
The article shares seven practical habits—such as controlled autosave, scheduled breaks, eliminating distractions, clear outcome visualization, regular skill training, test‑first development, and avoiding over‑engineering—that can boost a programmer's productivity and long‑term growth.
This article presents a detailed roadmap for aspiring front‑end engineers, covering essential fundamentals, design principles, development techniques, networking basics, server‑side knowledge, database skills, and soft‑skill practices, while providing practical code examples and resource recommendations.
The author reflects on three major challenges—staff turnover, project‑schedule control, and software‑quality improvement—and argues that mastering software‑engineering techniques, tooling, and domain knowledge is essential for effective technical team management.
The article examines the so‑called 35‑year‑old programmer crisis, explains why technical experience devalues quickly, and outlines four career paths—continuing as a specialist, moving into technical management, launching a tech startup, or the humorous idle option—to help senior engineers sustain long‑term success.
In this comprehensive talk, Li Yanpeng shares how developers can strengthen their technical foundation—covering operating systems, algorithms, high‑concurrency services, big‑data principles, and distributed architecture—while also cultivating personal habits and evaluation methods to become well‑rounded engineers.
This article explores the root causes of JavaScript fatigue, emphasizing that software exists to solve business problems, not to please developers, and offers practical advice on focusing on fundamentals, reducing unnecessary tools, applying TDD, and treating software development like city planning to improve efficiency and value.
Tech lead Tang Qiao shares his journey from iOS developer to product‑tech manager, explaining why engineers should consider management, debunking common misconceptions, and offering practical advice on time management, communication, mentorship, and upward management to help technical professionals transition into effective leadership roles.
This article explores how project management’s cost‑schedule‑quality triangle, ISO quality definitions, the software quality “iron triangle” of process, organization, and technology, and the six quality characteristics guide developers and testers in improving product quality through systematic thinking and practical testing methods.
The article shares practical insights from a Silicon Valley veteran on how professional programmers assume responsibility, write high‑quality code, allocate time for growth, master their domain, adopt thoughtful problem‑solving, communicate effectively, and collaborate without office politics to become true technical leaders.
This article explores why technical experts often lack management skills, outlines the typical career stages of engineers, and provides practical guidance on developing the mindset, responsibilities, and core competencies needed to become a successful technical manager.
The article recounts Joel Spolsky’s Yale talk, highlighting his key takeaways about focusing on real problems, avoiding in‑house programmer roles, the importance of aligning business with technical expertise, and how strong communication separates ordinary staff from leaders.
This article debunks the myth of writing a million lines of code, explains why code quantity matters less than quality, and offers ten practical steps—including solid fundamentals, coding standards, design principles, refactoring, technical debt management, code reviews, static analysis, unit testing, self‑testing, and leveraging open source—to help developers produce high‑quality software efficiently.
This article presents eleven practical tips for writing clear, readable code, covering short methods, single-purpose variables, descriptive naming, proximity of declarations, avoiding magic numbers, respecting language idioms, following conventions, steering clear of premature optimization, refactoring after testing, and using patterns wisely.
The article explains that AI engineers need solid architecture knowledge to turn high‑performing algorithms into real‑world solutions, covering four key reasons: algorithm vs. problem solving, on‑site deployment challenges, scalability, and effective team collaboration.
This article explains software architecture as the composition and interaction of components, outlines its ANSI/IEEE definition, describes UML diagrams for modeling, discusses validation through testing, and shares practical development rules, offering a concise learning summary for engineers.
This article explains that an architectural style is a set of high‑level principles that provide an abstract framework for families of systems, discusses common styles such as client‑server, layered, pipe‑and‑filter, event‑driven, and REST, and examines their benefits, trade‑offs, and open design questions.
A humorous yet insightful look at the myths of massive codebases, featuring developer anecdotes, realistic productivity calculations, and practical advice on prioritizing code quality, solid fundamentals, and modern tooling over sheer line count.
The article traces the history of software engineering as a continual shortening of release cycles, discusses the persistent emergence of new development models—from the waterfall to spiral and iterative approaches—and highlights George Box’s insight that while all models are imperfect, the useful ones illuminate practice.
The article explains why refactoring is essential for maintaining and evolving legacy code, defines refactoring, outlines when to start and stop, lists prerequisites, describes a step‑by‑step process with testing and version control, and connects refactoring to design principles and large‑scale systems.
Over 25 years, the Linux kernel community has distilled nine essential lessons—from short release cycles and distributed development models to the critical role of tools, strong governance, company participation, and incremental feature growth—demonstrating how collaborative, adaptable processes sustain large‑scale open‑source projects.
To achieve sustainable, low‑cost, high‑quality continuous delivery, teams—especially those under 30 members or working on loosely coupled services—should master core practices such as two‑week iteration cycles, CI pipelines, estimation, planning, and iterative activity management, as illustrated by the Baidu case series.
The article discusses how expert programmers must continuously learn and balance humility with confidence, explores the end‑to‑end design principle, examines complexity, layering, and componentization in large systems, and highlights performance considerations, distributed‑system realities, and management lessons for building robust software.
This comprehensive guide presents Uber engineering leader Raffi Krikorian's twelve practical rules for planning, executing, and managing architecture refactoring, covering purpose definition, incremental approaches, data handling, technical debt, team readiness, and non‑technical influences.
The article distills Kohsuke Kawaguchi’s QCon Beijing presentation on continuous delivery, covering the evolution of delivery pipelines, DevOps maturity models, practical engineering techniques, and strategic transformation paths, while highlighting Jenkins’ role and offering actionable guidance for teams seeking to adopt efficient, reliable software release processes.
The Alibaba Java Development Manual, now in its 1.2.0 version, offers a comprehensive, industry‑tested coding standard that covers layout, examples, rule corrections, and new content, aiming to boost code quality, development efficiency, and future international adoption.
The article traces the impact of Ford’s 1910 assembly line on software delivery, explains Jez Humble’s definition of deployment pipelines, showcases continuous delivery concepts, and presents real-world examples from Baidu, Netflix, and an open-source end-to-end pipeline, highlighting key design points for DevOps transformation.
This article shares a veteran front‑end engineer’s step‑by‑step methodology—covering the 3W framework, requirement clarification, timeline estimation, risk exposure, and post‑release monitoring—to help developers consistently deliver high‑quality features.
The article introduces Zhao Xingu's presentation on how Ctrip's wireless R&D team designed and implemented the Mobile Delivery Continuous Platform (MCD) to support hundreds of engineers across multiple product lines, covering integration, testing, release, and operation for efficient mobile app delivery.
In this interview, DevOps veteran Xu Lei explains that efficiency is the core competitive advantage of DevOps, shares real‑world transformation cases, outlines three key success factors, and recommends a comprehensive set of lifecycle, automation, testing, and orchestration tools for enterprises.
The article outlines a comprehensive checklist of core Java, advanced Java, frontend basics, web frameworks, databases, tools, design patterns, and other essential technologies that a senior Java developer should master to become a top‑level programmer.
This article profiles ten senior software engineers over 40 who remain on the front lines of coding, sharing their expertise, attitudes toward learning new technologies, and insights on how age impacts career longevity in software development.
The article outlines a software engineer’s evolution from focusing on business functionality and non‑functional requirements to mastering micro‑ and macro‑level concerns, embracing the "Shu‑Ha‑Ri" craftsmanship philosophy, and adopting the mindset, conditions, and practices needed for sustained professional growth.
The article explores how principles of clean code—clear naming, modular structure, and layered logic—can be applied to literary writing, using examples from classic Chinese novels to illustrate how thoughtful variable naming and multi‑threaded organization improve both code readability and narrative clarity.
This article explains why clear, self‑descriptive naming is essential for maintainable code, compares bad and clean naming examples, and offers concrete guidelines on intent‑revealing names, appropriate length, consistent terminology, domain relevance, and contextual clarity.
This article compiles a comprehensive list of interview questions tailored for software engineers, technical managers, and company leadership, explaining the purpose behind each question and offering follow‑up queries to help candidates evaluate a team's processes, culture, and overall health.
The article explores what separates genius, ideal, and mediocre programmers, shares a personal journey from novice to backend lead, and outlines six concrete habits—focus, thinking power, saying yes, future investment, tool mastery, and time management—to help anyone become an ideal programmer.
The article outlines a typical software engineer's journey from a nervous newcomer to an experienced professional, describing a non‑linear growth curve with breakthrough and comfort phases, defining four development stages, and offering practical tips—foundation, environment, authentic resources, independent thinking, and higher abstraction—to achieve continual technical breakthroughs.
This article examines the role of comments in source code, argues that well‑written, transparent code can often eliminate the need for comments, outlines four levels of code quality, provides concrete refactoring examples, and shares practical clean‑code guidelines such as avoiding magic numbers, reducing parameters, and using contract‑style preconditions.
Over the past four years a company that adopted fifteen automation‑testing principles from scratch achieved 100% API test coverage across five product lines, stable weekly releases, market leadership in two segments, and rapid expansion into three new product areas, demonstrating the lasting impact of disciplined test automation.
The article outlines six major trends shaping modern programming—from industry standards and popular third‑party modules to modular programming, framework adoption, testing practices, cross‑platform development, and the rise of tooling, automation, and ecosystem awareness—highlighting why developers must stay current.
This article analyzes the architectural redesign of BANFF, an internal sales mobile app, detailing the challenges of a flat, tightly‑coupled codebase and describing how modularization, technical abstraction, and page‑level refactoring transform it into a maintainable, extensible platform for diverse business roles.
This article outlines common misconceptions about becoming a tech leader and presents a practical three‑phase approach—Do more, Do better, Do exercise—combined with systematic learning, hands‑on practice, and teaching to help developers accelerate their growth.
This article shares practical guidance for founders and technical leaders on assembling, structuring, and managing early‑stage engineering teams, highlighting common mistakes, hiring strategies, communication practices, and the balance between speed and professionalism to ensure sustainable growth.
From a careless college student to a seasoned developer, the author chronicles a seven‑year odyssey of learning data structures and algorithms, sharing book recommendations, personal projects, internship experiences, and hard‑won insights on why solid algorithmic foundations are essential for modern software engineering.
The article presents five practical concepts—avoiding unnecessary uniqueness, modularizing code, separating concerns, enhancing readability, and choosing clear naming—to help developers write bug‑free, efficient, and easily maintainable code that reduces cognitive load and boosts productivity.
The article explores the concept of the 10x programmer, debating its existence, explaining why programming is a non‑linear design activity, and outlining the essential skills—such as raw coding ability, experience, focus, design sacrifice, simplicity, perfectionism, knowledge, low‑level understanding, and debugging—that can boost a developer’s output tenfold.
The article outlines twenty‑five practical principles for becoming an excellent software model designer, emphasizing the importance of people over technology, thorough requirement analysis, humility, low coupling, high cohesion, portability, scalability, performance, proper documentation, and continuous learning to build robust, maintainable systems.
SOA design should stay as simple as possible, guided by nine core principles—including standardized contracts, loose coupling, abstraction, reuse, autonomy, statelessness, discovery, composition, and collaboration—that together ensure robust, reusable, and maintainable services across enterprise systems.
This article explores how software engineers can turn the crucial 20‑30 age window into a period of rapid skill growth, develop leadership traits, and choose among three personal‑development paths—career advancement, meaningful experiences, and a free lifestyle—to secure long‑term professional success.
This article outlines Google’s comprehensive software engineering practices—including monolithic source repository management, the Blaze build system, automated testing, code review processes, defect tracking, language policies, debugging tools, release engineering, and project and personnel management—providing a concise overview for organizations seeking to adopt similar methods.
The article argues that mastering a wide range of programming languages deepens understanding of universal language models, improves tool selection, and expands career opportunities, and it provides a step‑by‑step roadmap—including meta‑learning, choosing prototype languages, and focused practice—supported by recommended resources and real‑world examples.
This article explains software architecture styles as high‑level design principles that guide system families, outlines common styles, their benefits and drawbacks, discusses open design questions, and provides detailed examples such as client‑server, layered, pipe‑filter, event‑driven, repository, C2, three‑tier, JB/HMB, and REST architectures.
The article outlines five common self‑imposed pitfalls—blind arrogance, reliance on others, obsessive tech focus, nitpicking, and lack of clear goals—that hinder test developers' growth, and offers practical advice for overcoming them to succeed in the evolving testing industry.
The article offers practical strategies for programmers to stay current, including learning new languages, using knowledge in novel ways, tackling client challenges, occasionally abandoning frameworks, seeking code reviews, and continuously coding to prevent skill decay.
The article reflects on the shift from pure coding to embracing requirement analysis, testing, and especially diagramming, explaining how visual representations externalize information, foster exploration, support global thinking, and make abstract concepts intuitive, ultimately improving software quality and collaboration.
This reflective guide explores the journey from novice to seasoned developer, classifies programmers into three types, and outlines six essential habits—focus, analytical thinking, constructive refusal, future investment, tool mastery, and time management—that together define an ideal programmer.
This article explains how Alibaba’s Detail 2.0 platform redesigns product‑detail services through modular architecture, front‑back separation, standardized frameworks, automated testing, and flexible deployment to boost collaboration efficiency, stability, and extensibility across diverse business scenarios.
The article explains that while machine learning has advanced with abundant courses, textbooks, and frameworks, engineers still face hard debugging problems due to algorithmic, implementation, data, and model dimensions, leading to exponential difficulty and long feedback loops that demand intuition and systematic testing.
This comprehensive guide outlines the core technical competencies, project experience details, management practices, system architecture components, third‑party tools, common interview questions, and effective interview strategies that every aspiring Java backend developer should master before a job interview.
The article explains how Google test engineers tackle the challenges of maintaining and upgrading legacy systems by redesigning test infrastructure, reducing reliance on fragile end‑to‑end tests, and adopting lightweight, mock‑driven test cases that dramatically speed up verification while preserving defect detection quality.
The article explores defensive programming and contract programming, discussing how to handle unexpected JSON data, the role of assertions and exceptions, and the trade‑offs between strict error handling and contractual code design for building robust software.
The article demystifies the full‑stack engineer role by tracing its origin, outlining essential front‑end, back‑end, and system‑admin technologies, critiquing unrealistic expectations, and showcasing the diverse, customized toolsets professionals actually use.
This article explains the essence of software architecture, outlines key project roles, details the duties and workflow of architects, and maps out a clear growth path and competency model for aspiring architects.
This comprehensive guide outlines the core Java programming competencies, web development frameworks, project experience, management tools, system architecture components, interview questions, and personal evaluation tips that aspiring Java engineers should master before a job interview.
In this interview, Sogou architect Liu Jian shares how his team built a highly available, scalable commercial advertising platform, discusses the evolution of its infrastructure, offers practical advice for engineers aspiring to become architects, and reflects on emerging technologies and time‑management strategies.
This guide walks C programmers through transitioning to Java, covering why Java is approachable, essential tools, coding standards, exception handling, core SDK libraries, object‑oriented fundamentals, and advanced topics like Effective Java, SOLID principles, design patterns, and functional programming with Java 8.
This article explains software architecture as the arrangement and interaction of components, outlines its standards, discusses UML diagrams for modeling, describes the role of architects, and shares practical rules for effective system design and development.
This article explains UML as a modeling language, detailing its semantics and notation, and introduces the nine core diagram types—use case, class, object, static, behavior, interaction, implementation, component, and deployment—highlighting their purposes, differences, and how they support static and dynamic system modeling.
Alibaba researcher Bi Xuan shares practical interview insights, explaining how recruiters assess technical fundamentals, research expertise, and genuine tech interest to identify promising student talent and guide candidates on effective preparation strategies.
This article offers a comprehensive guide for recent graduates aiming to secure offers from leading Chinese internet giants, outlining company tiers, the importance of a complete project, essential technical fundamentals, interview strategies, and ways to demonstrate passion and potential.
This discussion post examines whether code should be commented, citing the book *Refactoring* and emphasizing that needing comments often signals the need for refactoring, while good variable names can serve as implicit documentation, and stresses the importance of clear interface comments.
This article outlines a comprehensive approach for front‑end developers to achieve career growth by balancing ability and knowledge, offering practical steps to build a personal knowledge system, improve programming, architecture, and engineering skills, and adopt systematic training with classic textbooks.
The article presents a comprehensive programming philosophy that emphasizes repeatedly refining code, writing elegant, modular, readable, and simple programs, handling errors and null pointers robustly, and avoiding over‑engineering, offering practical guidelines applicable to any software development language.
This article outlines the responsibilities and career progression of technical roles—from entry‑level programmers to senior engineers, architects, technical managers, directors, and CTOs—highlighting how each level adds scope, leadership, and strategic impact within an organization.
