This article explores the importance of code review for engineers and leaders, examines common pitfalls such as duplicated code and premature optimization, presents core software design principles like KISS and composition, and offers practical guidelines and Golang examples to improve code quality and maintainability.
This article shares practical principles and concrete guidelines for effective code review and backend engineering, covering why reviews are essential, common pitfalls like duplicated code and premature optimization, design philosophies such as composition over inheritance, and actionable rules for maintaining clean, maintainable Go codebases.
The article shares a senior engineer's insights on why code review is essential, outlines common pitfalls such as duplicated code, premature optimization, and poor design, and presents concrete principles and practical guidelines—including KISS, composition over inheritance, and disciplined logging—to improve code quality and maintainability in large‑scale backend projects.
This article explains the true purpose of code review beyond bug hunting, explores its cultural and quality benefits, and offers seven actionable recommendations—including small batch reviews, frequent cycles, choosing the right reviewers, rapid feedback, modern tools, pair programming, and blending online with offline sessions—to make code reviews more effective.
The article explains how adopting a concise, shared checklist for code reviews can reduce subjectivity, improve team trust, and ensure critical quality and documentation standards are met across software projects.
The article outlines best practices for remote software teams to keep pull requests small, fast, and well‑communicated, emphasizing frequent reviews, clear labeling, context provision, reviewer support, CI automation, and a collaborative, non‑authoritative culture to improve code quality and team productivity.
This article outlines six frequent code review pitfalls—including missing change notes, overusing generic exception handling, blind trust in third‑party inputs, overly broad variable scopes, lack of staged results, and excessive logging—and offers practical recommendations to improve code quality and maintainability.
The article recounts a real SAP project where a stray 20‑second wait statement crippled performance, then outlines five actionable principles—including setting clear goals, using profilers, enabling compiler optimizations, targeted code adjustments, and mandatory code reviews—to ensure optimization improves speed without sacrificing quality.
A massive SAP cloud application suffered a 20‑second pause due to an accidental wait statement, revealing how careless code can cripple performance and illustrating practical, step‑by‑step guidelines for effective, measured code optimization.
The article explores how disciplined Code Review fosters better software quality, emphasizing that every line of code should have purpose, encouraging concise, well‑named, and well‑documented code, while highlighting common pitfalls such as unnecessary complexity, poor exception handling, and scattered constants.
Code review, described as a rational dialogue about code, improves team harmony, uncovers hidden bugs, enforces meaningful naming, reduces redundancy, and promotes disciplined practices such as proper spacing, centralized constants, and thoughtful exception handling, ultimately turning every line of code into purposeful, maintainable software.
The article shares insights from reviewing thousands of code submissions, highlighting frequent errors such as swallowing exceptions, overusing generic string types, and misusing nulls, and recommends concrete type usage, proper exception handling, Optionals, and "unlifting" techniques to improve code quality and maintainability.
This article outlines the responsibilities of frontline technical managers, detailing project release stages, technical review and documentation standards, code style and development conventions, code management practices, and a comprehensive CodeReview process to ensure quality and efficiency across software projects.
This article outlines a detailed software development workflow—including requirement review, technical design review, coding, code review, testing, deployment, and post‑release retrospection—providing practical checklists, templates, and best‑practice recommendations to improve product quality and team efficiency.
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.
This article outlines ten practical habits—ranging from saying no to unreasonable requests and building a personal knowledge system to mastering code standards, reviews, time management, and proactive problem‑solving—that can help programmers grow professionally and deliver higher‑quality software throughout their careers.
This article shares practical Java backend best‑practice tips—ranging from reordering conditional checks and avoiding unnecessary object creation to efficient database queries, proper logging, idempotent APIs, and smart caching—to help developers write faster, safer, and more maintainable code.
This article explains why code review is essential for improving code quality, fostering team knowledge sharing, enforcing standards, and reducing technical debt, and provides concrete guidelines on making code review a mandatory, cultural part of the development workflow with practical tips and tool recommendations.
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.
The article explains what code review is, its goals, why it’s essential alongside testing, how QA professionals can effectively participate, various review methods, a Selenium‑specific checklist, and a set of best‑practice guidelines to improve software quality and delivery speed.
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 translates and summarizes the key software engineering practices at Google, covering their unified source repository, build system, code ownership, automated testing, code review process, error tracking, language policies, debugging tools, release engineering, project and personnel management, and training, illustrating how these practices contribute to the company's success.
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.
This article explains the importance of code review for improving software quality, outlines the benefits of using Gerrit as a CR tool, describes the detailed workflow and promotion strategies, and discusses future extensions such as CI integration, issue tracking, and metric‑driven improvements.
The 2019 Stack Overflow Developer Survey of over 90,000 respondents reveals the most popular programming languages, frameworks and tools, typical work hours, industry distribution, job‑change frequency, age and experience demographics, and how language choice and seniority affect developer salaries worldwide.
A technical director recounts a month‑long, troubled e‑commerce project—detailing its background, the cascade of quality and management mistakes, the intensive code‑review rescue, and the hard‑earned lessons on design, delegation, and balancing speed with quality.
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.
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 explains why code review is essential for software teams, covering its benefits for knowledge sharing, code quality, and team standards, and provides practical guidelines on making code review a mandatory step, fostering a review culture, and applying effective techniques and tools.
A busy DBA can reduce weekend firefights by automating SQL code formatting, detecting injection risks, assessing performance impact, and fostering a collaborative review culture with developers through testing frameworks and knowledge‑sharing sessions.
This article explains the multiple benefits of code review—including knowledge sharing, improved code quality, and enforcing team standards—and provides practical steps, cultural tips, and tool recommendations to make code review a mandatory, effective part of any development workflow.
The article explains how testers can improve software quality by actively reviewing API definitions, understanding system architecture, evaluating database designs, reading code, and mastering configuration files, turning testing from a final checkpoint into a proactive, integral part of the development lifecycle.
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 article explores the responsibilities of a technical leader, detailing essential development standards, comprehensive workflow practices, architecture and code reviews, release planning, system health monitoring, and strategic technical planning to help teams deliver high‑quality software efficiently.
The article explains why code review is essential for software teams, describing how systematic reviews catch bugs, spread knowledge, reduce bus factor risk, align trends, improve communication, create useful history, enable precise discussions, strengthen team cohesion, and enhance code readability.
Ensuring high‑quality software in agile projects requires a disciplined Definition‑of‑Done checklist that covers functional and non‑functional criteria, including requirements analysis, design reviews, code and security audits, database checks, performance testing, version control, and data migration, all enforced through story‑level tasks and sign‑offs.
This article analyzes the advantages of Gerrit’s pre‑commit CHANGE workflow and GitLab’s Merge Request, proposes a hybrid code‑review service that integrates both approaches, and outlines the scenarios where each method or their combination best fits development teams seeking higher code quality and efficient integration.
Improving code quality requires adopting Clean Code principles—clear naming, purposeful comments, consistent formatting, robust error handling, small single‑responsibility classes, shared conventions, and a disciplined workflow that integrates pre‑commit checks, automated static analysis, code reviews, and continuous metric monitoring to ensure each change is cleaner than the last.
A project manager reflects on a four‑month development effort that collapsed after launch, analyzing mistakes in quality control, trust, ownership, requirement handling, and code review, and shares concrete steps taken to fix the issues and key lessons learned for future projects.
A senior project manager reflects on a four‑month, 100‑person‑day software project that collapsed after launch, analyzing five critical mistakes—from neglecting quality and over‑trusting the team to lacking ownership, design, and code review—and shares the concrete steps taken to rescue the product and the key takeaways for future projects.
Through a series of candid developer anecdotes—ranging from accidental production database truncations and hidden mistakes to the dangers of coding while exhausted and the importance of version control—this article highlights practical lessons for safer coding practices, rigorous reviews, and disciplined operational procedures.
This article examines the importance of code review in fast‑growing development teams, discusses its benefits and common challenges, and provides practical guidelines—including review frequency, time limits, checklists, and cultural tips—to help engineers improve code quality and collaboration.
This article describes how a hotel testing team integrated white‑box testing—code review and static analysis—into fast‑paced agile workflows, detailing the exploration timeline, typical functional testing challenges, three concrete bug‑finding case studies, measurable quality improvements, and practical promotion guidelines.
This article explores how developers can improve their coding by mastering collaboration skills such as pair programming and code reviews, cultivating patience and humility, and adopting solid fundamentals like reading code, design patterns, test‑driven development, and disciplined refactoring to produce cleaner, more maintainable software.
This article shares ZhaiZhai's data‑driven approach to process improvement, detailing how development self‑testing and code‑review practices were introduced, measured, and refined using PDCA cycles to boost quality, efficiency, and team morale across multiple teams.
The article presents a concise 20‑character Chinese mnemonic for code review, expands each keyword into practical guidelines covering validation, magic numbers, null checks, bounds, duplication, naming, performance, exception handling, logging, dependency management, thread safety, interface design, coupling, and robustness, with illustrative Java examples.
This article explains what a pull request is, why it is essential for code quality and collaboration, and walks through the typical four‑step workflow—creating a branch, opening a pull request, updating it, and completing the merge—using Git and TFS/VSTS examples.
The article shares practical experiences on writing high‑quality code by emphasizing logical correctness, the necessity of handling the else branch, techniques for lowering logical complexity, and strategies for decoupling business logic from implementation, all illustrated with clear Java examples.
This article presents a concise collection of Java backend code‑review best practices—ranging from parameter validation and null‑safety to logging, thread safety, and design simplicity—offering actionable tips to improve code quality and avoid common pitfalls.
This article explores the essential tools, methods, and developer habits needed to produce high‑quality, maintainable code, emphasizing why automation alone isn’t enough and outlining concrete code‑review steps that ensure reliability and alignment with product requirements.
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.
This article outlines key professional habits for programmers, from learning when to say yes or no and building a personal knowledge system to mastering code standards, reviews, time management, and proactive problem‑solving, all aimed at fostering long‑term career growth.
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 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 explains how to transform raw Git diff output into a structured JSON format, handle various diff headers, and apply line‑by‑line highlighting using the diff‑match‑patch algorithm, while also offering performance optimizations for long lines.
This guide outlines practical strategies for tech team leadership, covering people, project, technology, and culture management, recruitment, mentorship, code review, pair programming, documentation standards, automation, and workflow optimization to boost productivity and morale.
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.
Clean code for object‑oriented development means writing readable, self‑describing, maintainable software by applying principles such as single responsibility, clear naming, small methods, composition over inheritance, regular code reviews, refactoring, static analysis, and learning from open‑source, ensuring simplicity and collaborative excellence.
Learn how to ensure high‑quality Java code throughout agile development by standardizing coding conventions, applying static analysis, writing unit tests, implementing continuous integration, and conducting thorough code reviews and refactoring, with practical tool recommendations and best‑practice guidelines for each step.
This article outlines the essential qualities of a good Pull Request—including meaningful improvements, readability, and maintainability—while also highlighting advanced practices such as priority setting, code review, and automated testing to make PRs more disciplined and artistic.
The article shares practical insights and a comprehensive checklist for conducting code reviews, emphasizing formatting, readability, corner‑case coverage, error handling, testing, and architectural considerations to improve code quality and foster team growth.
Drawing on interviews with over 500 engineers from top tech firms, this article outlines ten actionable practices—such as speeding iteration, embracing automation, fostering code ownership, and allocating 20% time—that together create a respectful, high‑performance engineering culture.
From a tiny squad using SVN to a full‑stack agile team, we detail how migrating to GitHub, adopting ZenHub for project management, integrating TravisCI for continuous testing and deployment, using Reviewable for pull‑request reviews, Coveralls for coverage metrics, and Slack for real‑time communication transformed our development workflow and boosted code quality.
The article examines how Google maintains high code quality through rigorous code reviews, strict style guides, active code‑health initiatives, fix‑it events, and a strong testing culture, while also discussing the perception that older code inevitably degrades.
The article examines Digg’s former software development workflow, detailing its team structure, Git‑Gerrit code review, Jenkins testing, Puppet deployments, evolving practices, and how Conway’s Law shaped its architecture, offering lessons for modern engineering teams.
Discover nine practical Git pull‑request patterns—from isolated PRs and optimistic branching to stealth commits and prototype PRs—that help you quickly fix unrelated issues, manage branch dependencies, and improve code review clarity, all while keeping your development workflow efficient and organized.
This article outlines twelve practical techniques—including TDD, ATDD, CI, pair programming, code reviews, static analysis, coding standards, automation, refactoring, early demos, user testing, and team cohesion—that collectively raise software quality while reducing bugs and development costs.
The article shares a comprehensive overview of Google’s engineering environment, covering Silicon Valley work culture, internal communication mechanisms, the company’s development toolchain, quality‑versus‑speed trade‑offs in workflows, hiring practices, and the broader engineer mindset, supplemented by a detailed Q&A session.
The article offers practical guidance for programmers on when to say Yes or No, how to construct a personal knowledge system, develop a big‑picture view, follow coding standards, conduct code reviews, learn business knowledge, and maintain disciplined habits for continuous growth.
This article provides a comprehensive checklist for code reviewers, covering formatting, design, readability, functionality, security, testing, performance, and resource usage, while explaining why many of these aspects can be automated and how to balance manual inspection with tooling.
Quora shares how it sustains high‑quality code while accelerating development by applying four quality principles and implementing specialized tools and processes across writing, review, testing, and legacy cleanup stages, offering a practical model for other engineering teams.
The article outlines essential habits for developers—including cautious acceptance of tasks, strategic refusal of unreasonable requests, building a personal knowledge framework, maintaining a big‑picture view, adhering to coding standards, conducting code reviews, learning business domain, and persisting with good practices—to become a high‑performing programmer.
The article offers practical advice for programmers to improve their professional growth by carefully evaluating tasks before saying yes, learning to say no when necessary, building a personal knowledge system, maintaining a big‑picture view, adhering to coding standards, conducting code reviews, and continuously learning business knowledge.
A seasoned CTO shares six recurring problems—from unfamiliar tools and over‑planning to poor stack choices and ignored patterns—offering practical advice on fostering learning, focusing on MVPs, encouraging code reuse, and promoting continuous development within engineering teams.
The article examines Quora's engineering practices—including static analysis, post‑commit code review, automated testing, and systematic legacy code cleanup—that enable the company to maintain high code quality while sustaining fast development cycles.
Etsy’s engineering team applies continuous delivery principles to mobile development by enforcing main‑branch commits, automating environment setup, building on every push, providing daily internal builds, running functional tests on physical devices via a cloud service, maintaining a Jenkins‑driven dashboard, and requiring static analysis and code reviews to ensure high release quality.
This article recounts how Tencent’s advertising team introduced and scaled a rigorous code review process—starting with the Rietveld system, adopting Google C++ coding style, and establishing metrics and ownership—to improve code quality, knowledge sharing, and engineering efficiency across multiple departments.
After two years as an intern and eight months as a full‑time engineer at Microsoft Azure, I reflect on nine often‑overlooked corporate practices—from missing documentation and low enthusiasm to limited code review and reliance on outdated tools—that shape daily life for developers in large tech firms.
The article critiques common careless attitudes toward code reviews, exposing how pointless debates, condescending comments, exhaustive checklists, and rigid pass‑fail policies hinder collaboration, and offers practical, fact‑based strategies—including constructive questioning and pair verification—to transform reviews into productive, bug‑reducing discussions.
