Code review as testing in Testing Fundamentals - Deep Dive

Overview - Code review as testing

What is it?

Code review as testing means carefully examining someone else's code to find mistakes, improve quality, and ensure it works as expected before running it. It is like a manual check where testers or developers read the code to spot errors, unclear parts, or potential problems. This process helps catch bugs early without needing to run the program. It is a key part of software quality assurance.

Why it matters

Without code reviews, many bugs and design problems would reach later stages, making them costly and slow to fix. Code review as testing helps find issues early, improving software reliability and saving time and money. It also spreads knowledge among team members and encourages better coding habits. Without it, software quality would often be lower and development slower.

Where it fits

Before learning code review as testing, you should understand basic programming and manual testing concepts. After mastering this, you can explore automated testing, continuous integration, and advanced quality assurance practices. Code review fits early in the testing process, before running tests or deploying software.

Mental Model

Core Idea

Code review as testing is like a careful proofread of code to catch errors and improve quality before execution.

Think of it like...

It's like proofreading a written essay before printing it: you look for spelling mistakes, unclear sentences, or missing ideas without reading it aloud or running it through a spellchecker.

┌───────────────┐
│  Write Code   │
└──────┬────────┘
       │
       ▼
┌───────────────┐
│  Code Review  │
│ (Manual Check)│
└──────┬────────┘
       │
       ▼
┌───────────────┐
│  Fix Issues   │
└──────┬────────┘
       │
       ▼
┌───────────────┐
│  Run Tests    │
└───────────────┘

Build-Up - 6 Steps

1

Foundation

Understanding code review basics

Concept: Code review is the process of reading and checking code written by others to find mistakes or improvements.

Imagine you wrote a story and asked a friend to read it carefully to find spelling or grammar mistakes. Code review works the same way but with computer code. Reviewers look for errors, unclear parts, or places where the code can be better organized.

Result

You learn that code review is a manual check done by humans to improve code quality before running it.

Understanding that code review is a manual, human-driven process helps you see its role as a first line of defense against bugs.

2

Foundation

Recognizing code review as a testing form

Concept: Code review acts as a type of testing by finding bugs and issues without executing the code.

Testing usually means running code to see if it works. But code review tests the code by reading it carefully to find problems like logic errors, missing checks, or bad style. This helps catch bugs early.

Result

You realize code review is a testing step that happens before running any tests.

Knowing code review is a form of testing broadens your understanding of what testing can be beyond just running programs.

3

Intermediate

Common code review techniques

🤔Before reading on: do you think code review only finds syntax errors or also design problems? Commit to your answer.

Concept: Code review techniques include checking syntax, logic, style, and design to improve code quality.

Reviewers look for many things: simple mistakes like typos, logical errors where the code might do the wrong thing, style issues that make code hard to read, and design problems that affect how well the code fits the bigger system.

Result

You understand that code review covers a wide range of issues, not just simple errors.

Recognizing the broad scope of code review helps you appreciate its value in improving both correctness and maintainability.

4

Intermediate

Role of code review in team collaboration

🤔Before reading on: do you think code review only finds bugs or also helps team learning? Commit to your answer.

Concept: Code review supports team knowledge sharing and consistent coding practices.

When team members review each other's code, they learn new techniques and understand the project better. It also helps keep coding style consistent, making the code easier for everyone to read and maintain.

Result

You see code review as a social and educational process, not just error finding.

Understanding code review's role in team collaboration reveals its importance beyond just catching bugs.

5

Advanced

Integrating code review with automated testing

🤔Before reading on: do you think code review replaces automated tests or complements them? Commit to your answer.

Concept: Code review complements automated testing by catching issues that tests might miss and improving code quality before tests run.

Automated tests check if code behaves correctly when run, but they can't catch unclear code or design flaws. Code review finds these early, so automated tests are more effective and easier to write.

Result

You understand that code review and automated testing work together to improve software quality.

Knowing how code review fits with automated testing helps you design better quality assurance processes.

6

Expert

Common pitfalls and biases in code review

🤔Before reading on: do you think code reviewers always catch all errors? Commit to your answer.

Concept: Code review can miss bugs due to human error, bias, or poor process design.

Reviewers might overlook mistakes if they rush, are distracted, or trust the author too much. Sometimes, reviewers focus only on style and miss logic errors. Poorly defined review checklists or lack of training reduce effectiveness.

Result

You realize code review is powerful but not perfect and requires good practices to be effective.

Understanding the limits and biases in code review helps you improve the process and avoid false confidence.

Under the Hood

Code review works by leveraging human pattern recognition and reasoning to detect errors, unclear logic, and design flaws in code text. Reviewers mentally simulate code behavior, check for adherence to standards, and compare code against requirements. Unlike automated tests, it does not execute code but relies on understanding and experience.

Why designed this way?

Code review was designed to catch errors early when they are cheaper to fix and to improve code quality through human insight. Automated tests alone cannot find all issues, especially those related to readability, design, or subtle logic. Human review balances speed and depth, enabling knowledge sharing and continuous improvement.

┌───────────────┐
│  Code Author  │
└──────┬────────┘
       │
       ▼
┌───────────────┐
│  Submit Code  │
└──────┬────────┘
       │
       ▼
┌───────────────┐
│  Code Reviewer│
│  Reads & Checks│
└──────┬────────┘
       │
       ▼
┌───────────────┐
│  Feedback &   │
│  Suggestions  │
└──────┬────────┘
       │
       ▼
┌───────────────┐
│  Author Fixes │
└───────────────┘

Myth Busters - 4 Common Misconceptions

Quick: Does code review guarantee finding all bugs? Commit to yes or no before reading on.

Common Belief: Code review finds every bug before code runs.

Reality: Code review helps find many issues but cannot catch all bugs, especially those that appear only during execution or under specific conditions.

Why it matters: Relying solely on code review can lead to missed bugs and software failures in production.

Quick: Is code review only about finding mistakes? Commit to yes or no before reading on.

Common Belief: Code review is just about spotting errors and rejecting bad code.

Reality: Code review also improves code style, shares knowledge, and helps team members learn and align on best practices.

Why it matters: Ignoring the collaborative and educational benefits limits team growth and code quality improvements.

Quick: Can automated tests replace code review completely? Commit to yes or no before reading on.

Common Belief: Automated tests make code review unnecessary.

Reality: Automated tests check behavior but cannot assess code readability, design, or subtle logic issues that code review catches.

Why it matters: Skipping code review reduces code quality and maintainability despite having tests.

Quick: Does more reviewers always mean better code review? Commit to yes or no before reading on.

Common Belief: Having many reviewers always improves code review quality.

Reality: Too many reviewers can cause confusion, slow feedback, and reduce accountability, lowering review effectiveness.

Why it matters: Poorly managed review teams waste time and miss critical issues.

Expert Zone

1

Experienced reviewers balance thoroughness with efficiency to avoid review fatigue and maintain high quality.

2

Understanding cognitive biases like confirmation bias helps reviewers avoid overlooking errors that fit expectations.

3

Effective code review requires clear guidelines and checklists tailored to the project and team culture.

When NOT to use

Code review is less effective for trivial or very small changes where automated checks suffice. In fast prototyping, lightweight reviews or pair programming may be better. For performance-critical code, specialized testing and profiling tools are necessary alongside reviews.

Production Patterns

In professional teams, code review is integrated into version control workflows using pull requests. Reviews are often mandatory before merging code. Tools provide inline comments, checklists, and metrics to track review quality and speed. Reviews focus on critical code paths and complex logic.

Connections

Peer review in scientific research

Both involve experts examining work before publication to ensure quality and correctness.

Understanding peer review helps appreciate code review as a quality gate that relies on human expertise and collaboration.

Quality control in manufacturing

Code review acts like an inspection step catching defects before products reach customers.

Seeing code review as quality control highlights its role in preventing costly downstream problems.

Proofreading in writing and publishing

Both involve manual checking for errors and clarity before final release.

Recognizing code review as proofreading helps understand its focus on readability and maintainability, not just correctness.

Common Pitfalls

#1 Rushing through code review and missing important issues.

Wrong approach:

Reviewer quickly skims code and writes 'Looks good' without detailed checks.

Correct approach:

Reviewer carefully reads code, tests understanding, and leaves detailed comments on potential problems.

Root cause:

Underestimating the importance of thorough review and pressure to deliver quickly.

#2 Focusing only on style and ignoring logic or design errors.

Wrong approach:

Reviewer comments only on indentation and naming but misses a bug in the algorithm.

Correct approach:

Reviewer checks both style and correctness, asking questions about logic and design choices.

Root cause:

Lack of experience or unclear review guidelines.

#3 Assuming code review replaces all testing.

Wrong approach:

Skipping automated tests because code review was done.

Correct approach:

Using code review alongside automated and manual tests for comprehensive quality assurance.

Root cause:

Misunderstanding the complementary roles of different testing methods.

Key Takeaways

Code review as testing is a manual process of reading code to find errors and improve quality before running it.

It catches issues that automated tests might miss, such as unclear logic and poor design.

Code review also supports team learning and consistent coding practices.

It is not perfect and should be combined with automated testing for best results.

Effective code review requires good practices, clear guidelines, and awareness of human biases.