The following page may contain information related to upcoming products, features and functionality. It is important to note that the information presented is for informational purposes only, so please do not rely on the information for purchasing or planning purposes. Just like with all projects, the items mentioned on the page are subject to change or delay, and the development, release, and timing of any products, features or functionality remain at the sole discretion of GitLab Inc.
Last updated: 2021-05-05
| Section | Stage | Maturity | Last Reviewed |
|---|---|---|---|
| Dev | Create | Loveable | 2021-11-12 |
The Source Code Management direction page belongs to the Source Code group of the Create stage, and is maintained by Torsten Linz, who can be reached at tlinz@gitlab.com.
This direction is a work in progress, and everyone can contribute. Please comment and contribute in the linked issues and epics. Sharing your feedback directly on GitLab.com is the best way to contribute to our strategy and vision.
Source Code Management provides the core workflows and controls for teams to collaborate using Git to build great software, including repository view, protected branches, code owners, merge request approvals, and mirroring.
Building great software depends on teams working well together. Teams can rarely be divided into areas of complete independence. As cross-functional security, compliance and growth teams are formed, or new services and libraries are created, effective coordination and collaboration is a must. This is true whether using a single monolithic repository, or spread across numerous smaller services and libraries.
Teams require the controls to protect production while making it easy for everyone contribute. This means providing more granular and dynamic controls so that low risk changes can be made easily, and only the highest risk changes require the strictest controls.
When building software, teams greatly benefit from using open-source projects and may even submit contributions upstream. However, the balance of contribution vs. consumption is askew, partly because of a lack of controlled upstream workflows. Particularly from closed projects.
Upstreaming contributions from private repositories to a public upstream should be simple and safe, even for conservative organizations. Whether the upstream repository is on the same GitLab server, is hosted on GitHub.com, or managed via a mailing list.
The primary performance indicator (PI) for our group is the number of unique users writing to a project Git repository. We want to ensure all the features in our group provide a great experience that ultimately will allow everyone to contribute more often. A great experience in our group is a critical starting point for this.
Aligning with our SaaS first and product depth direction, we are also working to make performance our secondary indicator (see related issue). The intent here is to track the most heavily used services in our group and track how they improve over time. We firmly believe speed is the killer feature and as such will work to provide a speedy experience to set a great stage for new and existing users.
See more detail in the Create:Source Code PI page section.
Source code management targets mainly software engineers but also anyone who is contributing to any types of project. To that end, we target all the user personas we describe in our handbook, with a special focus on the following:
Sasha (Software Developer): targets full time contributors to all types of projects (commercial, OSS, data science, etc.). These users expect and need a high level of reliability and speed in their interactions with both project files and Git.
Delaney (Development Team Lead): targets users who often times have elevated roles which allow for the management of project settings, such as access control, security, commit strategies, and mirroring.
Devon (DevOps Engineer): targets engineers tasked with supporting and enabling software teams. Their tasks often revolve around platform creation and maintenance, where GitOps] workflows are crucial.
The Source Code Management category is expansive and encompasses a broad set of features. Which features are leveraged, how they are leveraged, and to what extent greatly depends on the size of development team and the complexity of the product that they are building. We find that as the team size grows, as does the complexity of the software product. For these reasons, it is challenging to define a single user journey that captures how our users move through Source Code. That being said, there are five main buckets we can use to group the jobs to be done of our users. Understanding this general workflow helps to focus product development and discovery when exploring how to streamline the Source Code experience
We intend to define and document the user journeys our specific personas take and how those differ based on the size of the development and the industry in which they work.
The Source Code category of GitLab offers the features where the creative process begins. Here authors will not only consume existing project contents but will also author new content that will eventually move through the DevOps lifecycle. Additionally, many of the features in Source Code are consumed in the Code Review stage of the software developement lifecycle. Consider the following examples:
Because of this close relationship, the Source Code Management group must work closely with the Code Review group in order to ensure the developer experience is cohesive and efficient. This experience is core to providing a great first impression for users.
The following initiatives are currently in validation as we refine the problem to solve and develop solutions.
Large repositories are difficult to manage in Git because they difficult to scale, performance concerns, requires large amounts of storage, and loss of per-service semantic versioning. We see large repositoires in situations where a compant is has a lot of large files, such as binary assets or they are operating a monolithic repositories, more commonly known as monorepos. Monorepos are a software development approach where code for many projects is stored in a single repository. Monorepos provide a number of advantages such as reduced complexity, code reuse, easier collaboration amongst teams, and streamlined dependency management. However, they have several drawbacks as aforementioned. We have the opportunity to improve workflows for large repos via improvements to partial clone and sparse checkout. WIP opportunity canvas can be found here - only accessible to internal GitLab team members.
GitLab offers a number of controls that can be implemented as safeguards. These controls can be put in place to keep changes from having a negative or enforce adherence to policies. Integrating features like protected branches, approval rules, code owners (approvals) and soon “status checks” should have an experience that easy to set up, maintain, and consume downstream. We are exploring how we can make it easier and more intuitive to adminster your Source Code management tool.
For 2021 we placed special emphasis on strengthening our SaaS offering by focusing on ensuring feature parity with our market leading self-managed offering. For the Source Code group, this that meant delivering solutions that are scalable, performant, and secure. For the last 6 months we've been focused on:
Performance: Ensure GitLab.com performs well at scale as well as provides a great developer experience on key workflows and actions. Focus on resolving existing failure scenarios and technical debt.
Infradev: Protect GitLab.com's availability from infrastructure failure.
We are immediately focused on improving the security posture of GitLab.com.
Our intention is to kick-off FY23 from a performant and reliable platform with a great security posture.
There are different ways for development teams to set up merge strategies depending on their software development, code review, and compliance practices. While we encourage customers practice GitLab Flow, we also need to support different strategies as there is no one right way for our customers. This effort streamlines the settings that allow users to create different flows and adds the option
Large organizations with many projects and large projects need to enforce review policies so that they can ensure the correct teams and individuals review changes that impact them. File owners will be automatically added to related Merge Requests (separate feature), but it is also necessary to add controls to prevent changes directly to important branches without approval. We should continue to improve on the first iteration of code owners. WIP opportunity canvas can be found here - only accessible to internal GitLab team members.
The Source Code group is not investing in the following opportunities in the immediate future:
Limiting which branches a user can read in a Git repository is possible in a basic sense, by only advertising a subset of refs, but it is not possible to guarantee that unreachable objects will not be sent to the client. This means that branch read access controls would be very weak, since they could not prevent exfiltration of data they do not have permission to read.
Path-level read access controls
From a commit, Git expects all trees and blobs to be reachable. Although Git supports partial clone and spares checkout, which allow data to be excluded from fetch and checkout, Git expects to be able to fetch missing objects on demand. Deliberately excluding objects by path is likely to cause unexpected failures.
This category is currently at the Loveable maturity level (see our definitions of maturity levels).
However, specific aspects are not yet loveable:
Important competitors are GitHub and Perforce, and increasingly Azure DevOps.
For public open source projects, GitHub is our primary competitor, with millions of active users having chosen GitHub before the first version of GitLab ever existed.
In most source code management capabilities GitLab compares favorably to GitHub, the most notable exception being the maturity of forking workflows which GitHub pioneered. GitHub has a highly polished and fast product, which makes tasks like browsing and managing projects fast and easy.
For users of SVN (Apache Subversion) intending to migrate to Git, GitHub is a significant competitor, particularly because GitHub supports hosting SVN repositories.
Perforce competes with GitLab primarily on its ability to support enormous repositories, however, Perforce also competes on the basis of being a Centralized Version Control System. This means that Perforce not only supports granular write permissions, but granular read permissions on a branch and file path basis. While fine grained read permissions are important to some customers, large monolithic repositories may be split into smaller repositories allowing read controls and easier management.
Large file support (see Gitaly direction) is an ongoing area of interest because it blocks certain segments of software development from using Git.
Similarly extremely large repository support (see Gitaly direction) is also an area of interest for the same reason.
The most frequent category of request is for improved support for finer grained controls, so that policies can be enforced at key points in the workflow, and more permissive permissions can be granted at other times.