Fork (software development) facts for kids
In the world of computers, a project fork happens when people who develop software take a copy of its original code. Then, they start working on it separately. This creates a brand new piece of software that is different from the original.
Sometimes, a fork means more than just a new version of the software. It can also mean that the group of developers splits up. This often happens because people have different ideas about how the software should work. Or, it might happen if the original software stops being updated.
Free and open-source software is special because anyone can copy and change its code without asking for permission. This means it can be forked very easily. However, sometimes even private software (called proprietary software) can be forked, like Unix.
Contents
What Does "Fork" Mean?
The word "fork" has been used for a long time, since the 1300s, to mean "to split into different paths," like a road that forks. In computer science, it reminds us of a special command called "fork." This command makes a running computer program split into two almost identical copies. These copies then usually go on to do different tasks.
In software development, the word "fork" was first used in 1980 by a person named Eric Allman. He used it to describe creating a "branch" in the code. This is like making a separate path for changes.
Later, around 1995, people started using "fork" to describe when a group of developers split up. This happened with software like XEmacs and the Berkeley Software Distributions (BSDs).
Forking Free and Open-Source Software
Free and open-source software can be legally copied and changed by anyone. This is because of special rules called The Free Software Definition and The Open Source Definition. These rules say that you have the freedom to share copies of your changed software with others. This helps everyone in the community benefit from your work. To do this, you must have access to the original code.
Forks in free software often happen when developers disagree on goals or have personality clashes. When a fork happens, both new projects start with almost the same code. However, the original project usually keeps its name and most of its users. This means that starting a fork can sometimes make a project less popular. The relationship between the different teams can be friendly or not so friendly. A friendly fork or soft fork is one that doesn't want to compete. Instead, it hopes to join back with the original project later.
Eric S. Raymond, a well-known writer about open source, said that a fork creates competing projects. These projects cannot easily share code later, which can split the group of developers. He also noted that forks are often seen as a "Bad Thing." This is because they can waste effort and cause arguments between the groups. Because of this, big forks are rare and often remembered in hacker stories.
David A. Wheeler described four things that can happen after a fork:
- The fork might stop being developed. This is the most common result. It's easy to start a fork, but hard to keep it going.
- The fork might join back with the original project. For example, egcs became the new version of GNU Compiler Collection.
- The original project might stop, and the fork takes over. This happened when X.Org Server became more popular than XFree86.
- Both the original and the fork can succeed. They usually become different over time. For example, OpenBSD and NetBSD are both successful forks.
Tools like Mercurial or Git make it very easy to "fork" code. When you want to help with a project, you often make a personal copy (a fork) of its code. Then, you can try to add your changes back to the main project. Websites like GitHub and Bitbucket make it simple to create these independent copies. This has made "forking" a common way to work on projects.
Often, when software is forked, the new project starts its version numbering from 0.1 or 1.0. This happens even if the original software was at a much higher version. But sometimes, a forked software is made to replace the original directly. For example, MariaDB is a fork of MySQL, and LibreOffice is a fork of OpenOffice.org.
Some special licenses, like the BSD licenses, allow forks to become private software. This means the code is no longer open for everyone to use and change freely. Examples include macOS (which uses parts of FreeBSD) and Cedega (a private version of Wine). Some companies that make these private forks still share their changes back with the open-source community. Others keep their changes secret to gain a business advantage.
Forking Private Software
In proprietary software, a company usually owns the code, not the individual developers. Companies might fork their own private code for different reasons. For example, they might need to make two versions of a program. One version might have a windowed screen, and another might use command line text. Or, they might make versions for different operating systems, like a word processor for IBM PCs and Macintosh computers.
These internal forks usually try to look and act the same across different platforms. This helps users who know one version easily use another. It also lets them share documents. Companies do this to get more users and make more money.
A famous example of private software forking is the many different versions of Unix. Almost all of them came from AT&T Unix. They were all called "Unix," but they became more and more different from each other. This led to what is known as the Unix wars.
See also
In Spanish: Bifurcación (desarrollo de software) para niños
- List of software forks
- Source port
- Downstream (software development)
- Group decision-making
- Modular programming
- Modding
- Custom software
- Personalization
- Team effectiveness
- Duplicate code
- ROM Hacking
