Jenkins vs TFS

Even though Jenkins is pretty functional and useful out of the box, there's a large plugin ecosystem from which the user can choose plugins to integrate into their Jenkins build. This is needed for when the user wants to extend any of the tool's features.

Jenkins is a free and open source continuous integration tool, while its source code is hosted on GitHub.

Self-hosting provides a safe location to store key environment variables since it is the user who is in charge of the server and environment where Jenkins is hosted.

Jenkins has been in development since 2004 and is one of the most popular tools of its kind. This means that its technology is very mature and there is a lot of documentation and resources available for it.

Supports the most popular version control systems out of the box: SVN, Mercurial, and Git.

The distributed builds in Jenkins work effectively, thanks to the Master and Slave capabilities.

This is called the Jenkins Long-Term Support (LTS) version and helps to provide the most stable and assuring version of the Jenkins CI possible. Every 3 months, a version (which has been deemed the most reliable by the community) is chosen. After this, its branched, well-tested features are added (if they are missing), it is tested with the new features, bug fixes are then carried out if necessary, and from there it is released as the official Jenkins LTS version.

Starting with Jenkins 2.0, the pipeline capability, which has been available as a plugin before this version, has been built into Jenkins itself. This allows developers to describe their chain of automation in text form, which can be version controlled and put alongside the source tree.

For most operations we need not reinvent the wheel, there are plugins already existing.

Being a Java application it can be installed under any OS: Windows, Linux, and macOS. On the other hand, JNLP slaves also enriches the cross-platform build support for its agents.

A Jenkins install is very simple and the user can have the service up and running within minutes. To install Jenkins, the command java -jar jenkins.war is all that is needed - nothing more.

Including, Docker, Amazon EC2 and S3.

Jenkins has a large and helpful community, which welcomes new users and provides a great number of tutorials.
Project Website, including links to Blog , Wiki, Docs. Community groups via Jenkins Users ML group.

You stay in full control of your source code, build environment and deployment. No third party gets access to your source code or knows exactly how to build your software.

Thanks to JENKINS Credentials and Plugin.

They can be added easily under your Global Configuration.

Including InfoWorld Bossie Award (Best of Open Source Software Award) in 2011, and Received Geek Choice Award in 2014.

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.