Salesforce version control git

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 can be the cause for that? Let us examine what are some of the key reasons why GIT is daunting for customers to adopt.

  • Too complex

    The pre-GIT client-server modeled centralized version control systems were simpler where 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 the 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.

  • Non-Salesforce-centric tool

    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 Architecture

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 use 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.

  • Robust architecture

    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.

  • Rich feature-set

    Flosum has all the key features and capabilities of GIT.
    See Table 2 below.

  • Compliance and security

    It is built on Salesforce and, hence, adheres to the highest level of security and compliance that the Salesforce platform provides out of the box.

  • Secure Repository

    All storage is maintained and managed within Salesforce.

  • Reduced Total Cost of Ownership

    Owing to its integrated design, there is no additional capital and 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

commands

Diagram 2: Flosum version control architecture

flosum-version-control-workflow

Table 1: Architecture Equivalents

GIT Flosum
Workspace Developer Org
Staging area Snapshot
Branch Branch
Remote repository Flosum repository

Table 2: Key GIT Commands Equivalents

GIT Flosum
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

Decision-Making Simplified

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 version control makes moot the baggage of GIT!

^