Git on Software Factory

Source Code Management

Mon, 01 Jan 0001 00:00:00 +0000

Source Code Management (SCM) is a set of practices for tracking and managing changes to code, enabling teams to collaborate effectively and maintain a clear project history.

This guide provides an overview of SCM best practices, helping your team maintain a clear project history, collaborate effectively, and deliver high-quality code.

From branching strategies and commit conventions to merge types and tagging, these practices will ensure cohesive teamwork and a well-organized codebase.

Branching

Mon, 01 Jan 0001 00:00:00 +0000

Introduction

A branch is a diverging point in the codebase that allows for parallel development. It enables developers to work on different features, fixes, or updates independently of the main code line, known as the main branch.

Branching is a fundamental concept in Source Code Management (SCM) systems. In the Software Factory, we use Git as our SCM tool, which provides powerful and lightweight branching capabilities.

To gain a deeper understanding of Git’s branching model, please read Git Branching in a Nutshell .

Code Review

Mon, 01 Jan 0001 00:00:00 +0000

Objective & Benefits

Code review is a systematic examination of source code intended to find and fix mistakes overlooked in the initial development phase, improving the overall quality of software.

Key benefits include:

Improved code quality: Catches bugs early in the development cycle
Knowledge sharing: Facilitates learning and cross-pollination of ideas within the team
Consistency: Ensures adherence to coding standards and best practices
Collective ownership: Increases shared understanding of the codebase
Mentorship: Provides opportunities for junior developers to learn from seniors

Practice Description

Code review is a systematic process where one or more developers examine another developer’s code changes before these changes are integrated into the main codebase. The primary goal is to ensure code quality, catch potential issues early, and share knowledge within the team.

Committing

Mon, 01 Jan 0001 00:00:00 +0000

Introduction

A commit is a snapshot of changes made to the files in your repository. Commits are more than just snapshots — they tell the story of your project. A clear and well-structured commit history helps others (and future you) understand what changed, when, and why. It simplifies debugging, eases code reviews, and makes collaboration more effective.

In the Software Factory, we use Git as our SCM tool. The practices described here apply to any SCM system, while Git-specific features are highlighted where relevant.

Git

Mon, 01 Jan 0001 00:00:00 +0000

Git is a distributed version control system designed to handle everything from small to very large projects with speed and efficiency. Unlike centralized version control systems, Git allows every developer to have a full copy of the project history stored locally.

This decentralization enables seamless collaboration and efficient handling of branches and merges.

Note

For Sofware Code Management (SCM) best practices (branching strategies, commit conventions, merge types, tagging), refer to the SCM Practices section.

Git clean history

Mon, 01 Jan 0001 00:00:00 +0000

Concept

This guide explains how to clean up your branch’s Git history. A clean history makes code reviews easier, reduces merge conflicts, and keeps the main branch readable.

Remove noisy commits like fix bug, wip, debug.
Group related changes into meaningful commits.
Make the history easier to understand for reviewers.

Warning

Be careful when rebasing shared branches.
Rebasing rewrites commit history, which can cause problems for other developers working on the same branch.
Before rebasing a shared branch, make sure you coordinate with your team and communicate clearly.
When in doubt, prefer rebasing only your local feature branches before they are pushed.

GitLab Merge Request

Mon, 01 Jan 0001 00:00:00 +0000

Approval rules

Create a list of users who act as code owners for specific files and require their approval before merging work.

In the root of your repository, create (if not exist) a new directory .gitlab/
Create a file CODEOWNERS
set the rules based on this exemple :

## Code Owners for a file
filename-path @username1 @username2

## Code Owners for a directory
directory-path/ @username1 @username2

## All group members as Code Owners for a file
filename @groupname

Merge Checks

To configure checks behavior :

LFS

Mon, 01 Jan 0001 00:00:00 +0000

Understanding Git LFS

Git Large File Storage (LFS) is a Git extension that handles large binary files more efficiently by storing them separately from your Git repository.

The problem

Git stores every version of every file. This creates issues with large binary file:

Repository can grow rapidly
Slow clone/fetch operations
Wastes bandwidth and disk space

This becomes a bottleneck in workflows during cloning and fetching repositories with large binary files.

Merging

Mon, 01 Jan 0001 00:00:00 +0000

Introduction

Merging is the process of combining changes from different branches into a single branch. It is a fundamental operation in any SCM workflow, allowing teams to integrate work from multiple developers. Selecting the right merge approach is crucial for maintaining a clean and understandable project history.

In the Software Factory, we use Git for source code management. The examples below show Git commands, but the concepts apply to any modern SCM system.

Merge Requests

Mon, 01 Jan 0001 00:00:00 +0000

Objectives & Benefits

Merge requests (MRs) are a critical component in the software development life cycle (SDLC) specially in the GitLab workflow .

They allow developers to:

Propose code changes from feature branches to be merged into the main branch.
Get feedback from team members as part of code review workflows.
Enable approval and check gates before integrating changes into the main codebase.

Merge Requests improve regular collaboration and team spirit because they serve as educational moments and foster team effort.

Secure your Repository

Mon, 01 Jan 0001 00:00:00 +0000

Securing your repository is essential to maintain the integrity and confidentiality of your code base. This guide covers the practices for implementing robust access controls, enforcing branch protection, securing secrets, and using groups efficiently within GitLab.

Implement Access Controls

Establishing strong access controls is fundamental for repository security.

Properly configured permissions ensure only authorized individuals can perform sensitive actions like pushing code, merging changes, or altering project settings.

Tagging

Mon, 01 Jan 0001 00:00:00 +0000

Introduction

Tagging is a crucial practice in software development to mark important points in the project history, such as versions, releases, or milestones. Tags provide a way to capture a snapshot of your codebase at a specific moment, making it easy to reference and retrieve that exact state later.

In the Software Factory, we use Git for source code management. Git tags are references that point to specific commits, helping to mark significant points in your project’s history.