Review tool
A review tool is a software application or feature that facilitates the collaborative process of examining and providing feedback on work products like source code, documents, or designs. It helps improve quality, enforce standards, and share knowledge.
Late 1990s
2
Definitions
In Software Engineering
In the context of software engineering, a review tool is a software application or an integrated feature within a larger platform designed to facilitate the systematic examination of source code by peers. This process is commonly known as code review or peer review.
Key features of a modern code review tool include:
- Diff Viewing: Presenting changes between code versions in a clear, easy-to-compare format, often side-by-side or inline.
- Inline Commenting: Allowing reviewers to attach comments, questions, and suggestions directly to specific lines of code.
- Workflow Management: Tracking the status of a review (e.g., pending, approved, changes requested) and managing the approval process.
- Notifications: Automatically alerting authors and reviewers about new reviews, comments, and status changes.
- Integration: Seamlessly connecting with version control systems (like Git), issue trackers (like Jira), and Continuous Integration/Continuous Deployment (CI/CD) pipelines.
Examples include the Pull Request feature in GitHub, the Merge Request feature in GitLab, Gerrit, and Atlassian's Crucible. The primary goal is to improve code quality, find defects early, enforce coding standards, and promote knowledge sharing across the team.
In Document and Design Collaboration
Beyond code, a review tool can also refer to software used for the collaborative review and approval of documents, designs, and other creative assets. These tools are essential for teams in marketing, legal, design, and technical writing to streamline feedback and manage revisions.
Common functionalities in this context include:
- Version Comparison: Highlighting changes between different versions of a document or design.
- Annotations and Markup: Providing tools to mark up specific areas of a document, image, or video with comments and suggestions.
- Approval Workflows: Creating structured processes for stakeholders to provide feedback and formally approve assets.
- Centralized Feedback: Consolidating all comments and revisions in a single place to avoid confusion from email chains or multiple file versions.
Examples include the 'Suggesting' mode in Google Docs, commenting features in Figma and Adobe Acrobat, and specialized platforms like Filestage. These tools ensure clarity, accountability, and an organized history of all feedback.
Origin & History
Etymology
The term is a compound of "review" and "tool." "Review" originates from the Middle French "reveue," meaning "a viewing, inspection." "Tool" comes from the Old English "tōl," meaning "instrument" or "implement." Combined, a "review tool" is literally an instrument for inspection.
Historical Context
The practice of formal code inspection predates dedicated software tools. In the 1970s, Michael Fagan at IBM introduced "Fagan inspections," a highly structured, manual, and paper-based process for finding defects in software artifacts. With the rise of distributed version control systems (VCS) in the 1990s and early 2000s, the need for better collaboration methods grew. Early forms of tool-assisted reviews were often script-based or managed through email, where developers would send "patch files" to a mailing list for feedback. The mid-2000s saw the emergence of dedicated, web-based review tools like Rietveld (developed by Google), Review Board, and Gerrit. These platforms provided a structured web interface for viewing diffs and leaving comments, separating the review process from email inboxes. The modern era of code review is characterized by deep integration within development platforms. The introduction of the "Pull Request" by GitHub in 2008 (and later "Merge Requests" by GitLab) revolutionized the process. It tightly coupled code review with the branching and merging workflow of the underlying Git VCS, making it a natural and seamless part of the development lifecycle.
Usage Examples
Our team uses GitHub's built-in review tool to manage pull requests and ensure code quality before merging to the main branch.
To streamline feedback from the legal department, we adopted a document review tool that tracks every change and comment.
The new peer review tool integrates directly with our IDE, allowing developers to request and perform reviews without switching context.
Management decided to invest in a dedicated inspection tool to meet the strict compliance requirements for our medical device software.
Frequently Asked Questions
What are the primary functions of a code review tool?
The primary functions of a code review tool are:
- Displaying Diffs: Showing the differences between the old and new code in an easy-to-read format.
- Facilitating Comments: Allowing reviewers to leave inline comments on specific lines of code.
- Managing Workflow: Tracking the review's status (e.g., approved, rejected, pending) and managing approvals.
- Integration: Connecting with version control systems, issue trackers, and other development tools to create a seamless workflow.
How does a modern review tool, like the one in GitHub, differ from older methods?
Modern tools, like GitHub's Pull Requests, integrate code review directly into the version control and development workflow. This creates a single, unified platform for coding, reviewing, and merging. Older methods were often disconnected, relying on manual processes like emailing patch files or using separate, non-integrated web applications. The modern approach is far more efficient and collaborative.
Why is using a review tool important for a development team?
Using a review tool is crucial for several reasons. It improves software quality by catching bugs and design flaws early in the process. It helps enforce team-wide coding standards and consistency. Most importantly, it serves as a vital mechanism for knowledge sharing, mentoring junior developers, and fostering a collaborative culture of collective code ownership.