GitLab vs TFS

GitLab is a free and open source project licensed under MIT. Source code for Enterprise Edition can be found here and Community Edition here.

Gitlab is very close to Github in use and feel, written in Ruby on Rails, open source and hosted on Github as well as on GitLab.com

GitLab is being constantly worked on and has a new release every month on the 22nd. Updating is also very easy through a single apt-get command.

Wiki and pages support out of the box.

Has pull request (AKA, merge request) support.

With the packages available here, GitLab can be installed in two minutes.

A protected master branch means that no code can be merged to master without passing a code review by an authorised developer. With GitLab this comes out of the box.

GitLab's UI is clean and intuitive. Each view is designed to not fill the screen with useless information.

It displays the activity in a feed-type way in the most prominent part of the view. On top of that, there's a toolbar with buttons which can filter this feed by pushes, merge events or comments.

On the left, there's a menu that displays all the links that take you to the different views. For example, a file directory which displays all the files in that repo, a commit view which displays all the commits in cronological order, a network and a graph view that display important information graphically etc...

All these details make GitLab's UI extremely intuitive and easy to use, no view is overflown with information and every view displays only the most useful and crucial information needed at that time.

Has issue tracking out of the box. Creating tickets, commenting on issues, closing issues etc... It's all there out of the box.

The Lightweight Directory Access Protocol is an application protocol for accessing and maintaining distributed directory information services over an Internet Protocol (IP) network.

GitLab EE adds additional functionality over CE such as support for multiple LDAP servers and group sync.

GitLab CI makes it easy to set up CI and deployment for projects in GitLab. It supports parallel testing, multiple platforms, Docker containers and streaming build logs.

It has private/public repositories, roles for users (master, developer, reporter, guest). All of these can be set from the user interface. Same permissions set for the UI work for the SSH as well.

Since 7.12 you can define a minimum number of approvers for merge requests.

Snippets are similar to (well-known) GitHub "gists". They are a way to share code or have conversations about anything without needing a full git repo. The implementation here reminds more of a sort of pastebin.

A single instance can handle up to 40,000 users (requires a server with 64 core CPU and 64 GB of RAM) and it can run on multiple application servers to grow beyond that.

Integrates out of the box with services like Bugzilla, Pushbullet, Microsoft Team Notification and many more - one can also add own webhooks to integrate with own services.

Git Annex enables Git to manage large files (esp binaries) without checking them into Git.

The default docker.io registry is the docker hub but you can also login to other docker registries. And GitLab provides one for all Repos that make use of this feature.

EE is the commercial Enterprise Edition, CE is the free and OpenScource Community Edition. Features such as Cycle Analytics were first a part of the EE and are now also available in CE.

GitLab integrates with multiple third-party services to allow external issue trackers and external authentication.
GitLab can integrate with many third-party apps to allow external issue tracking and authentication. It can also be integrated with several services, such as:

• Slack
• Campfire
• Flowdock
• Hipchat
• Gemnasium
• Pivotal Tracker

GitLab exposes a REST API that allows automation possible, like PR bots.

Very useful project management feature that allows you to know how long it takes to go from the idea to production.

TFS contains very few locks and aims to be as suitable for multithreaded
systems as possible. It makes use of multiple truly concurrent structures
to manage the data, and scales linearly by the number of cores. This is
perhaps the most important feature of TFS.

It was never planned to be Redox-only.

TFS stores a revision history of every file without imposing extra
overhead. This means that you can revert any file into an earlier version,
backing up the system automatically and without imposed overhead from
copying.

TFS, like ZFS, stores full checksums of the file (not just metadata), and
on top of that, it is done in the parent block. That means that almost all
data corruption will be detected upon read.

Similarly to Btrfs and ZFS, TFS uses CoW semantics, meaning that no cluster
is ever overwritten directly, but instead it is copied and written to a new
cluster.

Like some other file systems, TFS can do recursive copies in constant time,
but there is an unique addition: TFS doesn't copy even after it is mutated.
How? It maintains segments of the file individually, such that only the
updated segment needs copying.

The system will never enter an inconsistent state (unless there is hardware
failure), meaning that unexpected power-off won't ever damage the system.

TFS puts a lot of effort into caching the disk to speed up disk accesses.
It uses machine learning to learn patterns and predict future uses to
reduce the number of cache misses. TFS also compresses the in-memory cache,
reducing the amount of memory needed.

CoW is very suitable for high-performance, scalable file monitoring, but
unfortunately only few file systems incorporate that. TFS is one of those.

TFS uses only components written in Rust. As such, memory unsafety is only
possible in code marked unsafe, which is checked extra carefully.

TFS aims to be full coverage with respect to testing. This gives relatively
strong guarantees on correctness by instantly revealing large classes of
bugs.

TFS uses Bloom filters for space-efficient and fast garbage collection. TFS
allows the FS garbage collector to run in the background without blocking
the rest of the file system.

TFS tries to avoid the write limitation in SSD by repositioning dead sectors.

TFS is the first file system to incorporate complete full-disk compression
through a scheme we call RACC (random-access cluster compression). This
means that every cluster is compressed only affecting performance slightly.
It is estimated that you get 60-120% more usable space.

TFS is asynchronous: operations can happen independently; writes and
reads from the disk need not block.