Distributed version control facts for kids

This picture shows how a Git project starts. Git is a very popular tool for managing changes in computer code.

When people create computer programs, they often work in teams. They need a way to keep track of all the changes they make to the code. This is called version control. It's like having a special history book for your project, showing every change, who made it, and when.

Distributed version control is a smart way to do this. Instead of one main copy of the project, every person working on it gets their own complete copy. This copy includes all the code and its entire history. It's like everyone having their own full history book, not just a small part of it.

This way of working has many benefits. It makes it easier to work on different parts of the project at the same time. It also helps people work even when they are not connected to the internet. Plus, if one computer breaks, other copies of the project still exist. Git is the most popular system that uses distributed version control.

How Distributed Version Control Works

Distributed version control systems (DVCS) are like a team where everyone has a full copy of the project. This is different from older systems where there was only one main copy on a central server. In DVCS, people share their changes directly with each other. There isn't just one "official" version of the code. Instead, each person has their own working copy and all the past changes.

Benefits of Distributed Systems

• You can work on your project even when you are not connected to the internet.
• Many common tasks, like saving your changes or looking at the history, are faster. This is because you don't need to talk to a central server all the time. You only connect when you want to share your changes with others.
• You can work on your own ideas or drafts without sharing them right away.
• Each person's copy of the project acts like a backup. This means if something happens to one computer, the project's history is safe on other computers.
• It allows for different ways of working on a project. For example, you can create separate "branches" to try out new features.
• It's easier to create a new version of a project if the original one stops being updated. This is called "forking" a project.

Challenges of Distributed Systems

• Getting a project for the first time can take longer. This is because you copy the entire history of the project to your computer.
• It can be tricky to manage certain types of files, like images or large documents. These files are not easy to combine if two people change them at the same time.
• Each user needs more storage space on their computer. This is because they have a complete copy of the project's history.
• Since everyone has a full copy, there might be more chances for the code to be exposed if a computer is not secure.

Some older, centralized systems have started to add features that are similar to distributed systems. Also, some distributed systems now have ways to help with the challenges. For example, they can download files only when you need them.

Working Together on Projects

A distributed way of working is often best for big projects with many people working on different parts. A great example is the Linux kernel, which is the core of the Linux operating system. It lets developers work on their own parts and then share their changes. These changes can then be checked and added to the main project by others.

This method gives a lot of freedom. It makes it easy to create new versions of the code for different purposes. It also lets developers work on their own computers. They can track their changes locally before sharing them with the main project. This makes it easier for large teams to work together, even if they are in different places.

Main and Branch Copies

In a truly distributed project, like Linux, every person working on it has their own version. They share changes with each other, and a common version slowly forms from everyone's contributions. This also makes it simple to "fork" a project. If someone wants to take the project in a new direction, they just stop accepting changes from others.

However, this can sometimes be hard to manage. So, many projects choose to have one main "upstream" copy. This is the copy that everyone usually gets their changes from. This makes the project a bit more centralized. There's one main copy that is seen as the official one, managed by the project's leaders.

When new developers join, they usually copy this main project. They then work on their local copy. They regularly update their local copy with changes from the main project. Once they finish their work, their changes are added back to the main project.

Many organizations use services like GitHub to host their main project copies. These services offer reliable access and extra features. These features include ways to track problems or automatically test code.

Pull Requests

When someone wants to add their changes to a project that uses distributed version control, they usually create a pull request. This is also sometimes called a merge request. It's like asking the project's leaders to "pull" your changes into the main code. If the leaders agree, they "merge" your changes into the project.

When you create a pull request, you tell the project leaders about your new changes. There's usually a place to discuss these changes. This helps everyone talk about the code and make sure it's good. Anyone who can access the project can see these pull requests. The leaders can either accept or reject them.

Once a pull request is reviewed and approved, the changes are added to the project. Sometimes, the code needs to be tested before it becomes part of the official release. Some projects have a special area for testing new changes. Other projects use automated tools to test every pull request. This helps make sure new code works correctly.

History of Distributed Version Control

The first open-source distributed version control systems included Arch, Monotone, and Darcs. However, they didn't become very popular until Git and Mercurial were released.

From 2002 to 2005, a system called BitKeeper was used to develop the Linux kernel. But the company that made BitKeeper decided to stop offering it for free to the Linux kernel developers. This decision led to the creation of Git. Git is now the most popular version control system in the world.

See also

In Spanish: Control de versiones distribuido para niños

External links

• Essay on various revision control systems, especially the section "Centralized vs. Decentralized SCM"
• Introduction to distributed version control systems - IBM Developer Works article

de:Versionsverwaltung#Verteilte Versionsverwaltung fr:Gestion de version décentralisée ja:分散型バージョン管理システム