The Skill that Every Software Engineer, no Matter the Industry, Needs: Git

Understanding Version Control Systems

Version Control Systems (VCS) are indispensable tools in modern software development, enabling developers to track changes, collaborate on code, and maintain a history of project evolution. This section delves into what version control is, its significance, and the diverse systems that assist in managing software development.

What is Version Control?

Version control is the practice of managing and maintaining a record of changes made to files, particularly source code files in software development. It’s akin to having a detailed history of the edits, additions, and deletions in a document.

The Purpose and Importance in Software Development

  • Track Changes: Version control allows developers to see who made changes to the code, what changes were made, and when they were made.
  • Collaboration: Facilitates multiple developers working on the same project without overwriting each other’s work.
  • Undo Mistakes: Provides the ability to revert back to previous versions of the codebase in case of errors or undesirable outcomes.

Overview of Version Control Systems (VCS)

A well-implemented VCS is a cornerstone of any successful software project, allowing development teams to work faster, smarter, and safer.

Types of VCS: Local, Centralized, and Distributed

  • Local VCS: The simplest form where the version control database is kept on the local machine, tracking file changes over time.
  • Centralized VCS: Systems like Subversion (SVN) where team members connect to a central server to get the latest version and commit changes.
  • Distributed VCS: Systems like Git where each contributor has the complete copy of the repository locally, enabling work without a constant connection to a central server.

Understanding version control systems is foundational for ensuring robust software development processes. They reduce complexity, enforce accountability, and allow teams to build upon each other’s work cohesively. The advent of distributed VCS tools like Git has particularly revolutionized the code management landscape, providing developers with powerful, flexible, and collaborative tools to manage even the most complex projects effectively. Whether maintaining a solo project or coordinating a vast open-source endeavor, version control sits at the heart of software development, empowering teams with the control they need to architect the codebases that define the digital world

Introduction to Git

In the world of software development, Git stands out as a preeminent tool for version control. Adopted by individuals and organizations alike, Git’s power and flexibility make it indispensable for modern development workflows. This introduction to Git will cover the basics of how it works, how to set it up, and how to start using it for your own projects.

The Basics of Git

Git is a distributed version control system that allows multiple developers to work on a single project without the risk of conflicting changes.

How Git Works: Snapshots, Not Differences

  • Snapshot System: Unlike other VCS that track changes or ‘deltas’, Git takes a snapshot of the entire repository at each committed state.
  • Local Repositories: Each developer has their own complete version of the project, including the entire history of changes, allowing work to proceed even when offline.

Setting Up and Configuring Git

Installing and configuring Git correctly are the first steps to leveraging its full potential.

Installation and Initial Configuration

  • Installation: Git can be installed on Windows, macOS, and Linux systems with ease, often with just a few commands.
  • Configuration: Initial configuration involves setting up user information used across your Git activities, ensuring that each commit can be attributed to you.

Starting a New Git Repository

  • Initialization: Starting a new Git repository typically begins with the git init command, converting an existing, non-version controlled project into a Git repository.
  • Cloning: You can also start by cloning an existing repository from a remote server using the git clone command, creating a full-fledged, trackable Git project.

Git has changed the version control landscape by enabling decentralized collaboration, improving the fault tolerance of repositories, and giving developers unprecedented control over the evolution of their projects. Whether for small-scale personal projects or large, collaborative efforts, Git provides a robust framework for managing the development of software. With an understanding of Git’s core principles and setup procedures, anyone can begin to use it effectively, setting the stage for more advanced usage and further exploration of its capabilities

Core Git Commands and Workflow

Effective use of Git hinges on understanding its core commands and how they fit into a typical developer’s workflow. These commands, which represent the most frequent actions performed in Git, allow for tracking changes, managing branches, and collaborating with others.

Basic Commands: Add, Commit, Push, Pull

At the core of Git’s functionality are a few basic commands that allow developers to manage their code changes successfully.

Tracking Changes and Synchronizing Repositories

  • Add: The git add command stages changes to be committed, meaning you’ve marked the changes you want to be included in your next snapshot (commit).
  • Commit: With git commit, you capture a snapshot of the staged changes, which can then be a reference point in the project’s history and includes a message describing the changes.
  • Push: The git push command updates the remote repository with any commits made on the local branch since the last push.
  • Pull: Conversely, git pull retrieves changes from a remote repository to the local branch, merging them into a local copy.

Branching and Merging

Branches are an integral part of working with Git, allowing individual development streams to progress in parallel.

Creating Branches and Managing Merge Conflicts

  • Branching: Using git branch, you can create new branches, providing a separate environment for each new feature or task being developed.
  • Checkout: The git checkout command switches between branches, making it the currently active development path.
  • Merge: With git merge, changes from different branches can be brought together into a single branch, combining the efforts of different development trajectories.
  • Merge Conflicts: Occasionally, merging can result in conflicts if the same parts of the code have been changed on both branches. Git provides tools to identify and resolve these conflicts manually.

Staging and Committing Code

Understanding the staging area and commits is crucial for maintaining a clean, understandable history of changes.

The Staging Area Explained and Commit Best Practices

  • Staging Area: Before changes are committed, they are placed in a staging area where you can review them and ensure they are as intended.
  • Atomic Commits: It’s best practice to make commits small and focused, representing a single logical change, making it easier to track changes and understand history.
  • Commit Messages: Always include clear and informative commit messages, detailing, in a concise manner, what was accomplished in the changes.

This comprehensive overview of Git’s core commands and workflow provides developers with the tools to perform version control tasks effectively. Whether working solo on a project or collaborating within a team, understanding and properly utilizing these commands is fundamental to creating a maintainable, collaborative, and error-free codebase. As Git continues to be an industry standard for version control, mastery of these aspects allows for smooth, efficient development processes and sets the stage for utilizing more advanced Git features
7. Version Control Systems: An Introduction to Git and GitHub-c6223849-4834-45de-8851-a636b350a9a6

Git Under the Hood

While using Git effectively requires understanding its core commands and workflow, a deeper comprehension of how Git operates ‘under the hood’ can significantly enhance a developer’s troubleshooting skills and overall mastery of the tool. This section peels back the layers of Git, revealing the underlying mechanics that make it a powerful and efficient version control system.

The .git Directory: Repository’s Heartbeat

At the heart of every Git repository lies the .git directory, a hidden folder that contains all the necessary files and information to manage the version control aspects of the project.

Understanding Git Internals and Objects

  • Repository Structure: The .git directory stores the complete history of the project, index for staging, hooks, and configuration for the local Git instance.
  • Git Objects: Git uses several types of objects to manage a project’s history: blobs (which store file data), trees (which store directory contents and file references), and commits (which include pointers to a tree object, the commit message, author, and parents).

The Concept of Hashes and Commit Tree

A greater understanding of the commit tree and the secure hashes that uniquely identify objects can be critical for advanced Git operations.

Secure Hash Algorithm (SHA) and Commit Chains

  • SHA-1 Hashes: Each commit in Git is identified by a SHA-1 hash, a 40-character string that results from a cryptographic hash function of the commit’s content and metadata.
  • Commit Links: Commits form a chain where each commit includes the hash of its parent(s), creating a traceable history back to the initial commit.

A walk through Git’s internals showcases how this distributed version control system maintains detailed project history without becoming cumbersome. Through its efficient use of objects and hashing, Git provides rapid access to any version of a project while maintaining data integrity. By understanding Git’s underlying structure, developers gain valuable insights into the mechanisms of tracking changes, recovering lost data, and navigating complex histories, empowering them with a richer understanding of version control and its capabilities. Whether uncovering the state of the project in the past or unearthing the minutiae of certain changes, peering under Git’s hood provides a comprehensive guide to its powerful capabilities

Introduction to GitHub

While Git is a version control system that allows you to manage your code locally, GitHub is a cloud-based platform that takes Git to the next level by facilitating collaboration among developers. This introduction to GitHub will explore what GitHub is, its most prominent features, and how it enables developers from around the globe to work together more effectively.

What is GitHub?

GitHub is a web-based platform that uses Git for version control. It acts as a remote repository for Git projects, allowing users to push their local repositories to the cloud, collaborate with others, and track the history of their and others’ contributions.

GitHub as a Remote Server for Git Repositories

  • Centralized Sharing: GitHub serves as a central hub where your Git repositories are hosted, making code sharing and publishing more convenient.
  • Enhanced with Git Capabilities: GitHub extends Git functionalities with features like graphical user interface, issue tracking, and project management tools.

Exploring GitHub Features

GitHub isn’t just a repository hosting service; it comes with an array of features designed to improve the software development process.

Repositories, Forks, and Stars

  • Repositories: Are essentially folders for projects that take advantage of Git version control, containing all of the project files and the revision history.
  • Forks: Forking a repository allows you to create a personal copy of someone else’s project, make modifications, and propose changes to the original repository through pull requests.
  • Stars: Similar to ‘liking’ a post on social media, starring a repository shows appreciation for a project and helps you keep track of interesting repositories for future reference.

Issues, Pull Requests, and GitHub Actions

  • Issues: Offer a way to track enhancements, tasks, and bugs for your projects on GitHub. They’re also essential for discussing project-related questions.
  • Pull Requests: These are the heart of collaboration on GitHub. They let you tell others about changes you’ve pushed to a branch in a repository, initiating code review and discussion about the proposed modifications before merging them into the main branch.
  • GitHub Actions: Allow for automation directly on the platform, enabling continuous integration and continuous delivery (CI/CD) pipelines and workflow automation to build, test, and deploy projects.

Understanding GitHub gives programmers an edge in a world where software development is increasingly collaborative and distributed across the globe. It goes beyond being a repository service to being a community platform where open-source projects thrive, and collaboration is at the forefront. With GitHub, developers have a powerful ally in their endeavors to manage and share code, track project progress, and build software alongside a global communit

Leveraging GitHub for Collaborative Development

GitHub is more than a repository hosting service; it’s a robust platform that facilitates collaboration among development teams, both big and small. Whether you’re contributing to an open source project or working with a team on a commercial software product, GitHub’s collaborative tools pave the way for building software in a distributed and inclusive ecosystem.

Collaborative Tools in GitHub

GitHub provides a suite of tools specifically designed to enhance collaboration among developers. These tools facilitate communication, code review, and the merge process, ensuring that despite geographical and time zone differences, teams can efficiently work together on projects.

Code Reviews, Pull Requests, and Team Discussions

  • Code Reviews: GitHub’s pull request feature allows team members to review code changes, discuss potential improvements, and propose further commits before the changes are merged into the project.
  • Pull Requests: These requests are the lifeblood of team collaboration on GitHub. They provide a diff interface for comparing changes and a conversation thread for discussing those changes.
  • Team Discussions: GitHub fosters community and team communication through various avenues such as comments, issues, and specific team discussion platforms, all within a single, cohesive environment.

Open Source Contribution on GitHub

GitHub is also central to the open source community, offering a transparent and orderly way to contribute to public projects.

How to Contribute to Open Source Projects

  • Forking Projects: You can contribute to open source projects by forking repositories, making your changes, and submitting pull requests.
  • Community Guidelines: Most open source projects on GitHub provide contributing guidelines to help new contributors understand how to appropriately propose improvements or additions.
  • Issues and Feature Requests: By opening issues on open source projects, you can contribute ideas, bug reports, or feature requests, which maintainers and contributors can address.

Leveraging GitHub for collaborative development extends beyond source code management. It encompasses a vast array of functionalities optimized to boost team dynamics, simplify project management, and open the doors for community contributions. The platform’s omnipresence in the tech community transforms the way collaborative software development is approached, reduced from logistical headaches to a structured and accessible model. GitHub not only gives individual developers the ability to contribute code but also offers an avenue for peer recognition and communal growth. With the increasing trend toward remote work and geographically dispersed teams, GitHub’s collaborative features are a cornerstone to successful project development, innovation, and open-source stewardship
7. Version Control Systems: An Introduction to Git and GitHub-c7bb0003-2504-4174-9eab-182736018aa6

Best Practices for Using Git and GitHub

Adopting best practices for using Git and GitHub is key to maintaining a streamlined, efficient, and collaborative development process. These practices help ensure that repositories are not only functional but also comprehensible and that team members can easily navigate and contribute to the project’s codebase.

Commit Message Conventions

Well-crafted commit messages communicate context about a change to fellow developers and are crucial for future maintenance.

Writing Useful Commit Descriptions for Better Readability

  • Clarity and Context: Commit messages should be concise yet descriptive enough to convey the intent of the changes. Starting with a brief summary line followed by a more detailed explanation if necessary is encouraged.
  • Use of Imperative Mood: Writing commit messages in the imperative mood, as if giving a command or instruction, helps to keep messages consistent and clear.
  • Reference Issues: Including references to related issue trackers or ticket numbers can link commits to specific tasks or discussions.

Code Management with Branches

Effectively managing branches within a repository is an essential part of working with Git and GitHub.

Workflow Strategies like Gitflow and Feature Branch Workflow

  • Gitflow Workflow: Gitflow is a branching model designed around project releases, which assigns specific roles to different branches and defines how and when they should interact.
  • Feature Branch Workflow: This approach encourages creating new branches for each feature, making reviews and collaboration easier before the code is merged into the main branch.
  • Branch Naming Conventions: Develop consistent naming conventions for branches that provide clarity about their purpose.

Pull Requests and Collaborative Coding

Pull requests are a foundational tool within GitHub for proposing changes and facilitating reviews before code is merged.

Pull Request Best Practices

  • Small, Focused Changes: Smaller pull requests are easier to review and less likely to cause significant conflicts when merging.
  • Documentation and Comments: Provide adequate documentation and comments within the pull request to guide reviewers through the changes and the reasoning behind them.
  • Review and Merge Process: Establish a review process where at least one other team member examines the pull request for potential issues and discusses changes before merging.

Iterative Development and Continuous Integration

Embracing iterative development complemented by continuous integration helps maintain the health of the project’s codebase.

Incorporating CI/CD Pipelines

  • Automated Testing: Set up CI/CD pipelines to run automated tests every time changes are pushed to Git, ensuring the new code does not break existing functionality.
  • Regular Commits and Pushes: Encourage regular commits and pushes to GitHub, enabling collaborative development and making use of automated build and test checks.

By following best practices for using Git and GitHub, development teams can create a robust, transparent, and collaborative code management environment. Commit conventions, branch management, pull request processes, and integration with CI/CD pipelines are all aspects that, when implemented effectively, lead to a high-functioning version control system. These best practices aid in maintaining a clear project history, ensuring code quality, and facilitating team communication, all of which are pivotal for successful software development in today’s fast-paced technological landscape

Advanced Git and GitHub Features

For those with a solid grasp of the basics of Git and GitHub, diving into the advanced features can unlock new levels of productivity and collaboration. From fine-tuning your work with rebasing to augmenting workflows through automation, these advanced features provide powerful tools that go beyond simple version control.

Understanding Git Rebasing

Rebasing is an alternative to merging for integrating changes from one branch into another. It can streamline a complex stream of development into a simple, straight line.

When and How to Rebase

  • Rewriting History: Rebasing works by changing the base of your branch from one commit to another, effectively rewriting your project history.
  • Interactive Rebase: With an interactive rebase (git rebase -i), you can pick and choose which commits to include in your branch, squash commits into a single commit, or even edit commit messages.
  • Best Practices: Rebasing is best utilized in local branches before they are pushed to a shared repository as it changes history, which can complicate matters for other collaborators.

GitHub Automation and CI/CD

Incorporating automation in your GitHub projects can significantly enhance your CI/CD (Continuous Integration/Continuous Deployment) pipelines and automate repetitive tasks.

Leveraging GitHub Actions for Automation

  • Workflow Automation: GitHub Actions enable you to create custom workflows that automatically build, test, package, release, and deploy your code.
  • Event-Driven Triggers: These actions can be triggered by various events, such as pushing new code, creating a pull request, or even opening an issue.
  • Marketplace Actions: The GitHub Marketplace offers community-contributed actions, which can further simplify workflow setup for common tasks.

GitHub’s advanced features, like rebasing and GitHub Actions, expand the capability of developers to maintain clean histories and automate tasks within the software development lifecycle. Understanding and implementing these features into your workflow can lead to more efficient development cycles, enhance code quality, and allow teams to focus on more strategic work rather than repetitive tasks. Advanced Git constructs like rebasing require a sound understanding of the tool to avoid complications, while automation with GitHub Actions emphasizes the platform’s role in the broader DevOps culture. Mastery of these features serves not only to optimize your own contribution to projects but also to foster a culture of efficiency and reliability within the software development process

The Ecosystem Around Git and GitHub

Git and GitHub sit at the center of a vast ecosystem comprising tools and services that enhance the version control experience. These integrations and enhancements streamline various aspects of the software development process—from writing code in an Integrated Development Environment (IDE) to automating builds and tests with Continuous Integration (CI) services.

Integration with Other Development Tools

A powerful aspect of Git and GitHub is their ability to integrate seamlessly with a wide array of development tools, creating a unified work environment that boosts productivity and reduces friction.

IDEs, Continuous Integration Services, and Issue Trackers

  • IDE Support: Most modern IDEs come with built-in support for Git, allowing developers to commit, push, pull, and merge changes directly from their coding environment.
  • Continuous Integration Services: CI services like Jenkins, Travis CI, and CircleCI integrate well with Git, enabling automated testing and deployment pipelines that increase code quality and facilitate a DevOps approach.
  • Issue Trackers: Git and GitHub’s native issue tracking integrates smoothly with external systems like JIRA, enabling comprehensive project management from within the development workflow.

Third-Party Tools and Services

The flexibility of Git and GitHub also comes from the rich landscape of third-party tools and services designed to complement its core functionalities.

Enhancing Git/GitHub with External Services

  • Code Quality Tools: Services like SonarQube, Codacy, and CodeClimate can be integrated into a GitHub workflow to provide automated code reviews for quality assurance.
  • Developer Productivity Tools: Third-party tools like ZenHub and Waffle add project management functionalities within GitHub, bridging the gap between version control and agile methodologies.
  • Marketplace Offerings: GitHub Marketplace offers a wide range of apps and services that cater to different stages of development, from planning and coding to collaboration and deployment.

The richness of the ecosystem surrounding Git and GitHub is a testament to their centrality in modern software development. By leveraging integrations and extensions, developers and teams can customize their version control experience to match their specific needs and preferences, enabling a more efficient and enjoyable development process. These third-party collaborations not only enrich Git and GitHub but also foster an inclusive and comprehensive environment where developers can access a wide range of functionalities within their familiar workflows. Whether you are working on a solo project or part of a large-scale enterprise, the ecosystem around Git and GitHub provides the tools and capabilities to support a complete software development lifecycle

Challenges and Tips for New Git Users

For newcomers to Git and GitHub, navigating the complex landscape of version control may present a steep learning curve. Understanding common challenges and embracing practical tips can accelerate the process of becoming proficient with these essential development tools.

Common Git Challenges and How to Overcome Them

New Git users often encounter a few standard issues that can cause confusion and slow down development. Recognizing and knowing how to resolve these challenges is key for continued productivity and ease of use.

Dealing with Merge Conflicts

  • Merge conflicts occur when Git is unable to automatically resolve differences in code between merged branches.
  • Resolution: The best way to deal with merge conflicts is to carefully resolve the differing code segments using a text editor or a merge tool, ensuring you’re merging the best of both code versions.

Undoing Changes

  • Learning to use commands like git checkout, git revert, git reset, and git clean is invaluable for efficiently managing and undoing changes in a repository when things don’t go as planned.

Tips for Beginners

Mastering Git requires both understanding its commands and incorporating strategies that reduce the likelihood of encountering severe issues.

Cheat Sheets, Guides, and Learning Resources

  • Cheat Sheets: These provide a quick reference to the most common Git commands and are invaluable for beginners.
  • Guides: In-depth guides offer a more comprehensive insight into workflows and best practices when working with Git and GitHub.
  • Learning Resources: There are numerous online resources, including courses and tutorials, which can help new users to learn Git at their own pace.

Whether you encounter challenges understanding the command line operations, managing your repositories on GitHub, or dealing with complex branching and merging scenarios, the key is consistent practice and leveraging the wealth of educational content available. Over time, with hands-on experience, new Git users can transform these complexities into a part of their skillset.

Git and GitHub are powerful tools in the developer’s toolkit, and learning to use them effectively can greatly enhance the quality of collaboration, the maintainability of code, and overall productivity. Start by familiarizing yourself with the basics, practice regularly, and soon you’ll find Git an indispensable part of your coding routine. Remember, every expert was once a beginner, and with the right resources and perseverance, you can overcome the initial challenges to become proficient in using Git and GitHub


The exploration of Git and GitHub illuminates the profound impact these tools have had on the landscape of software development. From the individual developer working on a passion project to large teams coordinating on enterprise-level systems, Git and GitHub have become the linchpin of modern code management and collaboration.

The Significance of Git and GitHub in Modern Development

Git has revolutionized the way we think about version control with its distributed nature, allowing for a more nuanced and flexible approach to code changes and history tracking. GitHub has taken this a step further by providing a platform where these repositories can live in the cloud, enabling unparalleled levels of collaboration.

  • Industry Standards: Git and GitHub are now industry standards, essential for any development workflow, from continuous integration and deployment to collaborative open-source projects.
  • Accessibility and Openness: These tools have democratized software development, making it accessible to anyone with an internet connection, catalyzing the growth of numerous community-driven projects.
  • Facilitation of Best Practices: Emphasizing the importance of version control, code review, and collaborative coding practices, they have enhanced the quality and efficiency of software development.

Continuous Learning in the Version Control Landscape

The world of Git and GitHub is always evolving, with new features, best practices, and workflows continually emerging. Staying informed and adaptable is crucial:

  • Dynamic Ecosystem: As the ecosystem around Git and GitHub grows, developers should be open to leveraging new tools and integrations.
  • Skill Development: Continuous learning is critical to harness the full potential of version control, with resources readily available for developers at all levels.
  • Community Engagement: Participating in the dynamic Git and GitHub user communities can provide valuable insights and opportunities for growth and sharing knowledge.

Encouraging Aspiring Problem Solvers

For those starting their journey in version control with Git and GitHub, there’s an exciting path ahead full of opportunities to learn and shape the future of development.

  • Building a Foundation: Learning the ropes of Git and GitHub is an investment in one’s development career, establishing a solid foundation for code management and collaboration.
  • Contribution to Technology: With these tools, developers are not only consumers of technology but also active contributors, shaping the software landscape one commit at a time.

In summary, Git and GitHub stand as pivotal innovations in the tech industry, essential for progress, collaboration, and the continual improvement of software worldwide. As tools, they bridge the gap between complexity and manageability, enabling developers to focus on what they do best—solving problems through code. This journey through Git and GitHub’s capabilities, practices, and integrations cements their place as instrumental facets of a modern developer’s toolkit. Whether you’re making your first commit or managing a vast repository of projects, these version control systems will play a central role in how you create, manage, and share your work with the world

Frequently Asked Questions

Engaging with new software tools often brings up a plethora of questions and uncertainties. Git and GitHub, while now fundamental to modern software development, are no different. Below we address some of the most common queries to assist users in understanding and maximizing their utility.

Can Git be used without GitHub?

Absolutely. Git is a version control system that operates locally on your machine. It’s used to track changes in your projects and does not necessarily require GitHub, which is an online platform to host your Git repositories. You can use Git entirely offline, or with other services similar to GitHub, like GitLab or Bitbucket.

What’s the difference between Git and GitHub?

Git and GitHub are often mentioned in one breath, but they aren’t the same thing:
Git: Git is a distributed version control system itself. It’s a tool you use on your local machine to track file changes in your projects.
GitHub: GitHub is a hosting service for Git repositories. It adds a web-based graphical interface and additional features like issue tracking, user management, and project collaboration tools.

How do I collaborate on projects using GitHub?

GitHub offers several features that facilitate collaboration:
Forking and Pull Requests: You can fork a repository (make a copy), make changes, and then submit a pull request to the original repository to propose your changes.
Issues: You can participate in discussions, report bugs, and request new features using the issues feature on GitHub.
Shared Repositories: For more direct collaboration, you can work on shared repositories by having multiple collaborators push and pull directly from the same repository.

What are branch protection rules in GitHub?

Branch protection rules in GitHub are configurations that define the operations permitted on branches. They are typically used to enforce certain workflows, such as requiring pull request reviews before merging or mandating certain status checks pass before changes can be integrated. By applying these rules, teams can safeguard their primary branches (like main or master) from unintentional harmful operations and maintain the stability of their codebase.

These frequently asked questions span the essentials of using Git and GitHub and aim to clarify the nuances between the two while offering practical insights into each platform’s capabilities. As tools in the developer’s toolkit, Git and GitHub not only bring efficiency to individual and team workflows but also drive the collaborative ethos that is central to the open-source community and modern software development practices. Whether you’re a solo developer storing your projects on GitHub or a member of a globally distributed team, understanding Git’s local capabilities and GitHub’s community features are key to harnessing the full power of version control