A**Version Control System (VCS) **is a tool that stores the history of changes in project files, allowing developers to track changes and manage code versions. The main purpose of VCS is to simplify and organize project work.
## What is a version control system?
A version control system allows you to track changes, manage versions, and work productively as a team. Without a VCS, it is difficult to ensure stability, security, and transparency of development, as well as to avoid errors when working together on a project.
Imagine that several developers are working on a single product module for an application. One of them is writing code for the data processing function, another one is developing the user interface, and the third one is customizing the server part. All of these changes are happening in parallel, and it is important that the changes do not conflict with each other.A version control system allows you to resolve this conflict by tracking what changes were made by whom and when, and to revert to the previous version if something went wrong. An example is Git, one of the most popular VCSs used for version control in open source projects.
## How to use a version control system: steps to follow
Using a version control system (VCS) greatly simplifies the development process, keeping your projects safe and organized. Implementing a VCS into the development process can be broken down into several key steps. Let's consider how to work with a version control system step by step.
#### Step 1: Connecting to the host.
Go to the integration section in the navigator, then select "Connections" and create a new connection.
#### Step 2. Configure the connection.
Enter a URL (e.g., [gitlab.com]()) and a personal access token. After saving the connection, the system will attempt to connect to the server using the specified token. If the connection is successful, a "Connection Established" badge will be displayed. At this time, the automatic upload of group and project data will begin.
You can monitor the upload process through the activity feed. If the token has restricted access rights, the upload will go faster. When the page refreshes, the status will appear as "Completed" and GitLab repositories and groups will be listed. If the token or URL is invalid, the system will notify you that the connection could not be established and you can go to the logs for details.
Establishing a connection is necessary to work with the developer panel widget on task forms from the [SDLC](). The widget will display information about merge requests, branches, and commits, automatically pulling this data from GitLab.
#### Step 3: Specify the project repository.
To properly display data in the widget, you need to specify the project repository. In the project form in the "Git repository" field, select the required repositories.
After that, the developer panel widget will become available in the corresponding tab of the task. The widget will display information about the linked repositories with filtering options. Tasks are linked to data from GitLab by task number. For the widget to function correctly, task numbers must be present in branch names, commit messages, and merge requests.
In the "Merge Requests" tab, you can see various parameters: request ID, name, source and target branches, number of tracks, and status of the last pipeline. Clicking on the request name will take you to GitLab. The Commits tab displays the name of the commit, its hash code, and the author, which will be mapped to the employee's profile in the SimpleOne system. By default, up to five recent commits are displayed, but this number can be customized. The "Branches" tab shows the branch name and its connection, and provides a link to GitLab to jump to.
The version control system steps help you keep your project organized, as well as simplify teamwork and code version control. By following these steps, you'll be able to use VCS to develop software while maintaining its stability and integrity at every step of the way.
## What a version control system solves
A version control system solves tasks that are important for a successful project, especially in teams with multiple developers. Here are the main ones:
- **Change tracking**
A VCS allows you to capture all changes made to the code and save them in a history. This way, developers can keep track of who made the changes, when they were made, and what fixes were made. If an error occurs after a change, you can easily revert to a previous working version.
- **Conflict resolution**
When multiple developers are working on the same file at the same time, there may be a situation where their changes conflict. The version control system helps resolve such conflicts by automating the merging of changes and providing tools for manual correction if necessary.
- **Support for concurrent development**
VCS allows developers to work on different parts of a project simultaneously without interfering with each other. Each developer can create branches to work on new functionality or bug fixes, and then merge them into the main version of the project when the work is complete.
- **Version Control**
VMS helps maintain the stability of a project by separating it into versions and making it easier to move from one version to another. This is important for testing and new releases because it allows you to manage which version of the project is used in the production environment and which version is used in development.
- **Collaboration and improved coordination**
SCV helps coordinate developers, letting them work on a project without fear of accidental conflicts or data loss. All changes are synchronized, and everyone involved in the project always has an up-to-date version of the code.
In summary, a version control system is a project management tool that ensures collaboration, code stability, and minimizes risk.
## Types of version control systems
Version control systems are divided into types depending on how exactly they organize the storage and management of versions. There are local, centralized and distributed systems, each of which has its own features and areas of application.
### Local VCSs
Local version control systems
**Local version control systems** are simple systems where the entire change history is stored on the developer's computer. All changes are committed to a local repository, and each user works with their own copy of the data. To share files with other developers, you have to manually copy them.
For example, RCS (Revision Control System) allows saving changes to a local repository, but does not support multiple developers working on the same project.
**Features of local RCS:**
- Data storage only locally, with no interaction with other users.
- Limited ability to collaborate: synchronizing changes requires manually transferring files between computers.
- Easy to set up and use, but no scalability for teamwork.
### Centralized version control systems
Centralized version control systems
**Centralized version control systems** store all the history of changes and current versions of a project on a single server. Developers work with local copies of the source code and connect to the server to get the latest changes or submit their edits. The central repository is the only source of truth.
For example, in Subversion (SVN), all changes are committed to a central server, and developers synchronize their local copies with it.
**Features of centralized SVNs:**
- A centralized repository where all change history and up-to-date versions of files are stored.
- Constant access to the server is required for operation, making the system dependent on network connections.
- Fault tolerance difficulties: if the central server fails, access to the project may be restricted, although local copies of the developers' code remain up to date until the last synchronization.
### Distributed version control systems
Distributed version control systems
**Distributed version control systems** are a more advanced and flexible approach. Distributed version control systems, such as Git, allow each developer to have a complete local copy of the repository with a history of changes. You can work without constant access to a server and synchronize changes with other contributors as needed. Git, used in services such as GitHub and GitLab, is a prime example of a distributed VCS.
**Features of distributed RMS:**
- Each developer has a full local copy of the repository with a complete history of changes, which allows them to work without constant access to a central server.\
- High flexibility: developers can work offline and then synchronize changes with other users as needed.
- Resilient to failures: even if the central server or one of the repositories fails, developers can continue working with local copies of data and synchronize them later.
- Features for parallel work in different branches and merging changes.
Feature
Local RMS
Centralized RMS
Distributed RMS
Data storage
Locally
Centralized
Local and centralized
Data access
Local access
Server required
Local access for everyone
Collaboration
Limited
Server dependent
Highly flexible, work without connection
Example
RCS
SVN
Git
Server dependency
No
Yes
No (but you can)
Offline operation
No
No
Yes
Easy setup
Easy to set up and use
Requires central server configuration
More complex to configure, but provides greater flexibility and fault tolerance
Each type of version control system has its advantages and disadvantages, and the choice depends on team size, project complexity, and developer preferences. Local SDLCs are good for small projects, centralized SDLCs are good for larger projects with centralized management, and distributed SDLCs such as Git provide maximum flexibility and allow you to work efficiently in distributed teams.
## SimpleOne SDLC integration with Gitlab
The latest version of SimpleOne SDLC features integration with GitLab, which improves development processes and synchronization between teams.
Integration with version control system in SimpleOne SDLC
The main thing about integration:
- **Connection setup:** you need to connect SimpleOne SDLC to a server, whether it's GitLab's own server (for example, at ITGlobal) or the public GitLab.com service if the company doesn't have its own server solution.
- Working with data: once configured, the system automatically retrieves and displays data from GitLab in the SimpleOne SDLC interface.
- View information: a widget appears in
[SimpleOne SDLC
]() to view task-related merge requests, branches, and commits.
- Linking tasks to repositories is done via unique task numbers (similar to Jira).
- Tasks are linked to repositories via unique task numbers (similar to Jira).
- Benefits of integration:
- Improved synchronization: developers can track changes directly in the task interface, increasing transparency and minimizing errors.
- Simplified decision making: branch status and commit data is always available in the task system, eliminating the need for frequent access to GitLab.
- Development lifecycle management: all changes (code, tasks, repositories) are available in one place, making it easier to monitor and faster to react to changes.
- Automatic synchronization: repository updates happen automatically, eliminating the need to manually update information and ensuring that data is up-to-date.Thus,
[SimpleOne SDLC
]()integration with Gitlab significantly speeds up workflows, improves team coordination, and minimizes errors. Automatic data synchronization and real-time access to up-to-date information allow developers to track changes without having to switch platforms frequently. Task monitoring is simplified and response to code changes is accelerated, minimizing time to resolve conflicts.
Linking tasks to code through unique numbers eliminates synchronization errors and increases information availability, making project management easier. Integration also improves code quality, as developers can quickly track changes and quickly roll back to previous versions.
Automatic synchronization between SimpleOne SDLC and GitLab ensures that data is up-to-date, eliminating errors due to outdated information. Decision making is accelerated and team accuracy and productivity are improved.
## What's important about the SDLC
1. **Change Tracking: **Version Control captures all changes made to your project, including who made the changes and when. This helps you to restore previous versions in case of errors and provides transparency in development.
2. **Version **management: VMS allows you to effectively manage project versions by dividing them into separate stages. This allows you to organize testing and new releases, as well as guarantee stability during the development process.
3. **Collaboration: **The system synchronizes changes made by different developers, minimizing the risk of conflicts. Using branches and commits, you can work on different parts of the project without interfering with other team members.
4. **Conflict resolution: **In case two developers' changes overlap, the RMS helps resolve conflicts by providing mechanisms for manual intervention and merging changes.
5. **Support for concurrent development -- **A version control system allows developers to work on different features and patches simultaneously without interfering with each other. This is achieved through the creation of separate branches, which are then merged into the main version of the project.
6. **CI/CD process automation: **Version control systems can be integrated with CI/CD tools to automate the building, testing and deployment of code, speeding up the development process and improving the quality of releases.
7. **Types of VCS **: There are 3 types of VCS: local (e.g. RCS), centralized (e.g. SVN), and distributed (e.g. Git). Each type has its own features suitable for different project scales.
8. **Integration with other tools: **Modern RMSs, such as Git, integrate with various services (e.g., GitHub, GitLab) to facilitate collaboration and speed up development processes.
