Why Git Beats SVN: Lessons from iPhone, Android, and Open Collaboration

When discussing Git, the common question is "What makes Git better than SVN?" The author draws an analogy with the iPhone, noting that early iPhone advantages (web access, apps, touch screen) were countered by perceived drawbacks, yet the device reshaped how people think about mobile devices.

Similarly, Android’s open strategy contrasted with Windows Mobile’s closed, costly, and proprietary approach. Android’s openness allowed rapid adoption, hardware diversity, and a thriving ecosystem, while Windows Mobile suffered from limited customization and slow feature rollout.

The author then expands the comparison to Git, arguing that Git should be viewed not just as a configuration‑management tool but as a broader system that includes platforms like GitHub and GitLab. This broader system simplifies open‑source collaboration, accelerates development, and creates a knowledge‑sharing environment.

Git is defined as COLHS – Collaboration, Open, Link, Heritage, Service:

1. Collaboration

Git was created to improve open‑source collaboration, reducing the need for repetitive code copying and manual merging that plagued SVN.

Initial code download happens once; developers work locally with a single repository.

Branching and merging dramatically increase efficiency.

Most merge conflicts are resolved automatically, eliminating the need for external diff tools.

2. Open

Open environments let quality surface quickly. The author cites the rapid community translation of Apple’s Swift guide on GitHub as an example of open collaboration outperforming closed, slow processes.

3. Link

Social programming platforms (GitHub, GitLab) create trust‑based connection graphs that amplify information spread, similar to how Weibo and WeChat leverage trusted relationships for rapid content propagation.

4. Heritage

Git’s distributed history preserves the evolution of code, allowing teams to trace why changes were made, even after original developers leave. This heritage becomes valuable organizational knowledge.

5. Service

Continuous integration and build‑as‑a‑service shift the burden of building from developers to automated systems, turning "I need to build" into "the system builds for me," reducing local build time to near zero.

Code style examples illustrate how tooling can reduce line counts:

while (x == y) 
{
    something();
    somethingelse();

    if (some_error) 
    {
        do_correct();
    } 
    else 
    {
        continue_as_usual();
    }
}

Converted to K&R style:

while (x == y) {
    something();
    somethingelse();

    if (some_error) {
        do_correct();
    } else {
        continue_as_usual();
    }
}

In summary, the iPhone’s rise, Android’s open strategy, and Git’s COLHS principles demonstrate that embracing openness, collaboration, and service‑oriented architectures drives technological adoption and efficiency, while closed, proprietary models risk obsolescence.