Flosum Version Control: The Joys of GIT — Minus its Baggage
GIT has a powerful distributed architecture and provides a rich set of commands for version control. It has been rapidly becoming a standard for the sophisticated and advanced user to do crafty things with source control, particularly in the open-source community.
Yet it has alienated a large part of the developer community. What could be the cause for that? Let us examine some of the key reasons why GIT is daunting for customers to adopt.
The pre-GIT client-server modeled centralized version control systems were simpler in that you needed to know a few things to use them – namely your sandbox, a repository, branches, and version control. With GIT and its distributed architecture, you now need to understand various other constructs such as an index, local repository, remote repository, treeishes, stash, and the list goes on. The information model with GIT has grown in complexity.
The number of commands has increased significantly and simple tasks can require many more commands to accomplish.
In addition, the terminology of the GIT commands has been confusing and problematic since it has reused CVS and Subversion (SVN) terms for completely different concepts.
Every user needs to know it
Regardless of the experience and skillset of the developers and any other users, if GIT is being used for version control, every person using it has to undergo a steep learning curve to understand it.
Experts required to manage and maintain it
Orchestrating and maintaining GIT requires dedicated skilled resources to administer the build infrastructure and the release management activities. For GIT, as the number of concurrent development efforts increases, it is critical to ensure that the working streams result in a stable release.
Furthermore, if you are a Salesforce customer, the consideration of GIT for version control becomes even more difficult. Many of those who adopted GIT have been looking for alternatives to simplify and streamline their source control needs.
GIT is not an integrated solution for Salesforce. Salesforce is a cloud solution with unique needs for release management.
The release management build infrastructure using GIT looks complicated and has to be carefully crafted. The GIT repository is external. Processes like deployment become unwieldy given that the repository exists outside of Salesforce. GIT is over-engineered for the purposes of Salesforce. And the list goes on…
It is not a match made in heaven.
Compliance and certifications
Given that GIT is a non-integrated tool, compliance and certifications are issues that have to be dealt with. HIPAA and PCI standards are prime examples that require third-party integrations with plugins from external vendors to try and mitigate these issues with GIT – thus compounding things further.
Deployment of builds is complex
Deployment from GIT is cumbersome and painful to deal with. It involves using a combination of the Force.com Migration Tool (FMT) or Eclipse and Ant build scripts to fetch from GIT branches and deploy to target organizations.
High Total Cost of Ownership
Build servers, client machines, third-party plug-ins, installation, integration, on-going maintenance, dedicated personnel for integration, and release management all add up to a high total cost of ownership.
Why Flosum Version Control?
There is a community of unhappy GIT Salesforce customers. Then again, there is an even larger majority who are wary of investing in any version control tool because of its challenges.
Flosum’s version control was envisioned, designed and developed with Salesforce and its customers in mind. Its goal was to have the power of GIT while making sure it was extremely easy to use.
Flosum has an elegant and extensible architecture to solve the problems of release management in the Salesforce cloud. It is completely built on the force.com platform and has no external footprint.
Flosum has the same service level agreements (SLAs) as Salesforce and requires no special maintenance. It is as secure as Salesforce and provides the same level of certification and compliance you expect from the force.com platform.
Key Benefits of Flosum’s Version Control
Since Flosum is built entirely on the force.com platform, a native implementation of version control was done to provide a fully integrated and secure repository within Salesforce. The highlights that make the Flosum version control compelling are:
Declarative version control with intuitive user experience
Flosum’s easy-to-use “Clicks, not Code” design makes it really simple to administer and be used by developers. Any Salesforce developer can learn and use Flosum’s version control in just a few minutes!
Deployments are easy and fast
The Repository is contained within Salesforce. Patch-manifests are easy to construct from the Repository and, once qualified to be working, can be reused to deploy to other orgs.
Flosum’s version control has an architecture that allows multiple developers to collaborate and manage multiple streams of development. Its integrated solution is robust and removes the complexities of installation, management, and maintenance of external tools.
See Table 1 and Diagrams 1 and 2 below.
Flosum has all the key features and capabilities of GIT.
See Table 2 below.
Compliance and security
It is built on Salesforce, hence, it adheres to the highest level of security and compliance that the Salesforce platform provides out of the box.
All storage is maintained and managed within Salesforce.
Reduced Total Cost of Ownership
Owing to its integrated design, there is no additional capital or operational expenses to manage the infrastructure.
Flosum’s version control integrates seamlessly with other features of Flosum, like Continuous Integration and Patch Deployment, to provide a full and compelling Release Management solution.
Diagram 1: GIT Version Control Architecture
Diagram 2: Flosum Version Control Architecture
Table 1: Architecture Equivalents
|Remote repository||Flosum repository|
Table 2: Key GIT Commands Equivalents
|GIT init||Create a Branch|
|GIT add||Take a snapshot for commit|
|GIT rm||Remove files from the Branch|
|GIT commit||Commit changes to the Branch|
|GIT status||Show all components in the Branch. Merge of Branch shows files that are different from the Repository|
|GIT branch||List, create or delete Branches|
|GIT merge||Incorporate changes from workspace to Branch and from Branch to Repository|
|GIT push||Commit changes to the Repository|
|GIT log||View list of commits on a Branch|
|GIT show||View details of a given metadata/programmatic component|
|GIT diff||Comparison between metadata components|
You know your Salesforce implementation must have version control. Like Salesforce, compliance is essential and so is the ease of use for full adoption — be it by a developer, an administrator, or a business analyst who touches the implementation. With these under its belt and its rich feature-set, Flosum’s version control makes the baggage of GIT moot!