Version control system

Article#: 00085

Date: 2024-02-01

Author: Radim

What is a version control system?
A version control system, also known as a revision control system or source code management system, is a software tool that enables developers to manage changes made to source code, documents, and other files associated with a software project.
The purpose of a version control system is to maintain a record of changes made to a project's files, enabling developers to track modifications, revert to previous versions, and collaborate effectively with other team members. Version control systems provide a centralized repository for project files, allowing multiple developers to work on the same codebase without overwriting each other's work.

What are disadvantages of a version control system?
While version control systems offer numerous benefits for software development, there are also a few potential disadvantages to consider:
1. Learning curve: Some version control systems can have a steep learning curve, requiring developers to invest time in understanding how the tool works and how to use it effectively.
2. Setup and maintenance: Setting up and maintaining a version control system can require technical expertise and effort, particularly for larger projects.
3. Storage requirements: Version control systems can require significant storage space to store all versions of files, which can be a concern for projects with large files or long histories.
4. Security concerns: Version control systems can be vulnerable to security breaches if not properly secured, potentially exposing sensitive project files and data.
5. Dependency on the tool: If a project relies heavily on a specific version control system, switching to a different tool can be difficult and disruptive.
6. Collaboration issues: While version control systems can facilitate collaboration, they can also introduce conflicts and merge issues when multiple developers are working on the same files simultaneously.

What are the advantages of version control system?
1. History tracking: Version control systems keep a record of all changes made to files, allowing developers to track who made what changes, when they were made, and why.
2. Collaboration: Version control systems enable multiple developers to work on the same codebase simultaneously, without overwriting each other's changes or introducing conflicts.
3. Reverting changes: Version control systems make it easy to revert to a previous version of a file or codebase, providing a safety net in case of mistakes or bugs.
4. Branching and merging: Version control systems allow developers to create separate branches of the codebase for different features or experiments, and to merge changes back into the main branch when ready.
5. Code reviews: Version control systems can facilitate code reviews, allowing team members to provide feedback and catch errors before changes are merged into the main branch.
6. Backup and disaster recovery: Version control systems provide a centralized repository for project files, making it easy to back up and restore data in case of hardware failures, disasters, or other emergencies.

What are the obstacles to use a version control system?
1. Lack of knowledge: Developers who are not familiar with version control systems may find it challenging to learn how to use them effectively. This can lead to mistakes or confusion, which can be detrimental to the project.
2. Resistance to change: Some developers may be resistant to using a version control system, particularly if they have used other methods in the past that they are comfortable with. This can make it difficult to adopt new tools and processes.
3. Tool selection: There are many different version control systems available, each with their own strengths and weaknesses. Choosing the right tool for a particular project can be challenging.
4. Setup and maintenance: Setting up and maintaining a version control system can require technical expertise and effort, particularly for larger projects. This can be a significant obstacle if the team does not have the necessary skills or resources.
5. Cost: Some version control systems are commercial products that require a license fee, which can be a barrier for some teams.
6. Security concerns: Version control systems can be vulnerable to security breaches if not properly secured, potentially exposing sensitive project files and data. This can be a concern for teams working with confidential or proprietary information.
7. Compatibility: Version control systems may not be compatible with all development tools and environments, which can make it challenging to integrate them into existing workflows.

How had the developers worked before the version control system was invented?
Before the invention of version control systems, developers typically used manual methods to manage changes to project files. Some common techniques included:
Copying files: Developers would create multiple copies of a file, each representing a different version of the code. This could quickly become unwieldy, as files could become lost or overwritten, and it was challenging to track changes over time.
Timestamping files: Developers might add timestamps to files to indicate when changes were made, but this approach did not provide a clear history of changes, and it was easy for timestamps to become inaccurate.
Using naming conventions: Developers might use naming conventions to indicate different versions of files, such as appending version numbers to filenames. However, this approach could also become confusing and difficult to manage over time.
Maintaining changelogs: Some developers kept handwritten logs of changes made to project files, but this approach was time-consuming and prone to errors.

These manual methods were error-prone, time-consuming, and inefficient, particularly for larger or more complex projects. Version control systems have revolutionized software development by providing a more automated, reliable, and flexible way to manage changes to project files, facilitating collaboration, and improving development workflows.

Can binary files be monitored by a version control system?
Yes, binary files can be monitored by a version control system. However, the behavior of version control systems can differ between binary files and text-based files.
Unlike text files, which can be easily compared and merged, binary files cannot be meaningfully diffed or merged by version control systems. Instead, version control systems treat binary files as opaque blobs, tracking changes to the files as a whole rather than at the level of individual lines or characters.
This means that version control systems can still be used to manage changes to binary files, but developers may need to be more careful about how they handle these files. For example, when working with binary files in a version control system, it's important to avoid making conflicting changes to the same file at the same time, as the version control system may not be able to automatically merge these changes.
Additionally, binary files can be large, which can impact storage requirements and performance of the version control system.

Does the project structure matter if we want to use a version control system?
Yes, the project structure can have an impact on how effectively a version control system can be used. A well-organized project structure can make it easier to track changes, manage conflicts, and collaborate with other developers.

Is the communication among developers still necessary if they use a version control system?
Yes, communication among developers is still necessary when using a version control system. While version control systems can help manage changes to project files, they don't necessarily replace the need for communication and collaboration among team members.
Effective collaboration and communication among developers can help ensure that everyone is on the same page about project goals, timelines, and priorities. Additionally, communication can help prevent conflicts and ensure that changes to the code are made in a coordinated way.
Some ways that developers can communicate effectively when using a version control system include:
Regular team meetings: Regular team meetings can help ensure that everyone is up-to-date on project progress and can provide an opportunity for developers to raise issues or concerns.
Using comments or annotations: Developers can use comments or annotations within the code to explain their reasoning or to highlight potential issues.
Using pull requests or code reviews: Code reviews can help catch errors or potential issues in the code, while pull requests can ensure that changes are reviewed and approved by other team members before being merged into the main branch.
Commit messages: When making changes to code, it's important to write clear, descriptive commit messages that explain what changes were made and why. This makes it easier for other developers to understand the history of the code and to identify when and why certain changes were made.

It's important to carefully evaluate the pros and cons of using a version control system for a given project, and to select a tool that best meets the project's needs and constraints.

© Radim-Automation, 2020–2025. All rights reserved.
Sharing of this article is permitted with proper attribution (link to the original page).

Related previous articles:

• Event logger as the very first function implemented in the program
• Software update
• Documentation issues
• Visual modeling
• Choice of programming language
• Variable names
• Knowledge gained from a completed project is priceless
• Machine modularization
• Modular software architecture
• Are there also any disadvantages?
• Think critically!
• Learn from your journey!
• Why do automation projects fail?
• Use a usefull styleguide!
• Write and accept only readable code!
• Who knows it?
• Appoint a representative!
• Are the people planned for this task really available?
• Write down your best practices and processes!
• Is the way really the goal?
• Do you really want to start with this?
• More than just start and stop
• Do the right things and do them right!
• Don't make it worse!
• Write a project diary!
• Keep the answers to the question "Why"
• Everything is difficult until it becomes easy
• Realize every good idea ASAP!
• Industrial evolution - Listen to your customers and follow new trends!
• Ask questions!
• Communication skills are extremely important
• Keep it simple!
• Don't leave a work package half-finished!
• Success is not a matter of coincidence
• Choose the right tool!
• Development is evolution
• Don't neglect and don't skip any step!
• Transparency and reliability
• From an idea to a consistent system

Related next articles:

• Keep the documentation up to date throughout the project
• Maintain order in the program code
• Make backups, make small changes and test a lot
• Dream of a platform-independent PLC program
• Keep everything you need together
• An irreplaceable employee
• HMI - Have a consistent style
• The false illusion of rapid progress

Comment#: 00001

Date: 2024-02-02

User: Radim

"Definition of source control

Main tasks:

Documentation of changes: It is always possible to check who changed what and when.

Restoration of old versions of individual files: This allows changes to be undone at any time.

Archiving of a project's individual releases: This makes it possible to access all delivered versions at any time.

Coordination of access to the files by multiple developers

Simultaneous development of multiple branches of a project (e.g. a stabile release version and a developer version with large untested changes): Here the developer is supported when applying individual changes from the branch versions to the main version.


What does a source control system not do?
A source control system doesn't replace communication between the developers!
It only serves as an aid for logging, archiving and coordination. It is still necessary for the individual developers to communicate with their colleagues when making changes that will affect large portions of the project."

- B&R Automation Help 4.12.2.65. GUID = e344f2b9-383d-4bc8-9dfc-862c41133935.

Comment#: 00003

Date: 2024-02-02

User: Radim

"Use version control to save your work and coordinate code changes across your team. Even if you're just a single developer, version control helps you stay organized as you fix bugs and develop new features. Version control keeps a history of your development so that you can review and even roll back to any version of your code with ease."

- https://learn.microsoft.com/en-us/azure/devops/repos/git/gitworkflow?view=azure-devops

Comment#: 00004

Date: 2024-04-09

User: Radim

Proper storage of information is crucial for efficient work and easy and quick access at a later date.
A good archiving structure and discipline helps to maintain clarity and structure in the working environment, which contributes to the productivity and success of the project as a whole.
It is therefore important to pay sufficient attention to where and how information is stored and to follow appropriate archiving and organization procedures.

Comment#: 00005

Date: 2024-12-05

User: Radim

If I want to retrieve the URL of the Git repository in the Git Gui, I can enter this command in the Git Bash:

git config --get remote.origin.url