Linus Torvalds Called Out 330 Unexpected Commits?

This article explains what happened when Linus Torvalds, the creator of Linux, publicly criticized a pull request containing roughly 330 unexpected commits. You’ll learn the context behind the criticism, what made those commits problematic, and how the situation was resolved. We’ll also cover common questions about Linux kernel development practices that this incident highlights.

Background: The Linux Kernel Development Model

Linux kernel development follows a time-based release cycle, typically lasting about 9–10 weeks. The cycle begins with a two-week “merge window” during which major new features and changes are accepted. After the merge window closes, the next few weeks are dedicated to bug fixes and stabilization, culminating in a final release. This structured process ensures that only well-tested, reviewed code makes it into the mainline kernel. Linus Torvalds oversees this process as the ultimate arbiter of what gets merged, and he is known for his blunt, sometimes harsh, feedback when developers violate the established norms.

The Incident: What Did Torvalds Call Out?

In a specific instance, a developer submitted a pull request that contained around 330 commits that were not part of the expected development cycle. These commits appeared to be a mix of new features, refactoring, and other changes that should have gone through the normal review process over a longer period. Torvalds publicly criticized the pull request, stating that such a large, unexpected batch of changes was unacceptable for a single merge request. He emphasized that it made review difficult and betrayed a lack of communication with the community. The exact date and the specific subsystem involved are not widely documented, but the incident became a notable example of Torvalds’ expectations for how maintainers should handle their contributions.

Why 330 Commits Is a Problem

In kernel development, a pull request is expected to be a focused set of changes that can be reviewed and tested quickly. A large number of commits, especially when they arrive without prior discussion, creates several issues:

• Review burden: Each commit needs to be examined for correctness, style, and potential conflicts with other changes. Hundreds of commits overwhelm the review capacity of maintainers and other developers.
• Risk of regressions: Large batches of changes increase the chance of introducing bugs that are hard to isolate. If something breaks, pinpointing which commit caused it becomes a time-consuming task.
• Lack of incremental testing: The kernel relies on continuous testing of each commit. A flood of new code bypasses the incremental testing that catches issues early.
• Disruption to the release cycle: Merging a large amount of code outside the merge window can destabilize the kernel and delay the final release.

How Developers Normally Submit Changes

The proper way to contribute to the Linux kernel is to follow a well-established process:

1. Start with a discussion: Propose the idea on the relevant mailing list (e.g., linux-kernel or a subsystem-specific list) before writing code.
2. Develop in small steps: Make small, logical commits that each address a single issue. Each commit should compile and work on its own.
3. Send patches for review: Submit patches to the mailing list and iterate based on feedback. This can take weeks or months.
4. Get a maintainer’s sign-off: Once the patches are accepted by the subsystem maintainer, they will be included in that maintainer’s tree.
5. Request a merge: The maintainer sends a pull request to Linus Torvalds during the merge window, containing a reasonable number of commits that have already been reviewed and tested.

Common Mistakes and Misconceptions

A common misconception is that Torvalds is simply rude or angry for no reason. In reality, his outbursts are usually triggered by clear violations of the development process that endanger the stability of the kernel. Another mistake developers make is to accumulate a large number of changes over a long period and then submit them all at once, thinking that a big batch is efficient. This is counterproductive. The kernel community values small, incremental, well-reviewed changes. It’s also a mistake to assume that a pull request is just a formality; it is a request for review, and the reviewer (Torvalds) has the right to reject it if it’s not in a suitable state.

How to Choose the Right Approach

If you are a kernel developer, the right approach is to communicate early and often. Before making significant changes, discuss them on the mailing list. Break your work into small, logical patches and submit them for review as you go. Do not wait until you have a massive pile of code. If you are a maintainer, ensure that you review and test the patches thoroughly before sending a pull request. The pull request should contain only commits that have been through the proper review cycle. If you are a user or observer, understand that Torvalds’ criticism is aimed at protecting the quality of the kernel, not at personal attacks.

Frequently Asked Questions

Did Linus Torvalds actually say “330 unexpected commits”?

The exact wording may vary, but he did publicly criticize a pull request for containing a large number of commits (around 330) that were not previously discussed or expected. The incident was reported on Linux kernel mailing lists and covered by tech media.

What happened after Torvalds’ criticism?

The developer in question typically has to rework the submission, breaking it into smaller, more manageable pieces, and going through the proper review process. In many cases, the changes are eventually merged after being properly vetted.

Is it ever acceptable to submit 330 commits at once?

Generally, no. The only exception might be a massive, coordinated change that has been discussed extensively in advance, such as a large refactoring effort that has been planned and reviewed over many months. Even then, it would likely be split into multiple pull requests.

How can I avoid making the same mistake?

Always communicate with the community before starting major work. Submit patches early and often. Never sit on a large body of work without feedback. Use git to keep your history clean and logical.

Does Torvalds always reject large pull requests?

Not always, but he is more likely to reject them if they come without prior discussion or if they are poorly structured. He has accepted large pull requests when the work has been clearly presented and reviewed in advance.

What is the merge window and why is it important?

The merge window is the first two weeks after a release candidate is tagged. It is the only time when new features are accepted into the mainline kernel. Outside of this window, only bug fixes and critical updates are allowed. This ensures that the kernel stabilizes before each release.

Related

• Big Walk Platforms Pricing & Crossplay Guide
• Mac Can’t Connect to Apple Media Services? Fix
• Kingdom Hearts Story So Far: Full Game List

in t | Number of commits | - | 330 | 0 | 10000
in d | Days in merge window | - | 14 | 1 | 365
out avg | Commits per day | - | t / d | 2