March 7, 2019
Salesforce Git Version Control

Salesforce Version Control – How Flosum offers the Joys of GIT (Minus its Baggage!)

GIT has a powerful distributed architecture and provides a rich set of commands.

But is that enough to make it the best choice as Salesforce version control?

This article discusses how Salesforce Github integration, although incredibly powerful, requires some tweaks to optimize Salesforce devops. We also highlight how Flosum’s 100% Salesforce native version control system blends Salesforce Git minus the baggage to help your devops team execute deployments quicker than ever before.

What is Git? Why Do We Need a Version Control?

Git is the most popular distributed version control system in the world, today, for tracking changes in files, originally designed for coordinating work among multiple developers cooperating on source code during software development. But why do we need a version control system within the Salesforce context? Simple answer: It better than Changesets and offers many benefits. Let’s discuss those now.

  • Simplified Rollbacks

Suppose you have a sandbox environment and from there you are deploying to another sandbox. In case everything went well, and deployment went as expected, that’s great, but what if something went horribly wrong so much that you cannot patch it up. With Changesets, there is no way to do a rollback. With, version control systems like GIT or Flosum you can always revert to the way your code used to look instantly and redeploy.

  • Removes Reliance on Sandbox as the Single Source Of Truth/ Backup

Usually, Salesforce developers use production orgs as the single source of truth. With VCS, you no longer have to worry about sandboxes getting out of sync. You can also deploy the metadata to as many different environments as you want and it will always be the same. Using the GIT repository or a native version control system, like Flosum, you can designate a certain branch as a master branch and consider it as your source of truth. From there, you can deploy without relying on production org as the source of truth.

  • Maintain and Track Audit Trails

If something went wrong when you were deploying to another org or if there were too many incidents, you would need to do an audit to identify the exact issue(s). With Changesets, it’s something very difficult to do. You can probably look at one of the components and maybe see the ‘last modified by’ in the ‘last modified date’ but what if some changes were introduced somewhere in the middle. There is no way to easily track that with Changesets. Using a version control, like Git or Flosum, you can not only track individual changes but also who made the changes and why they made it, thus having an audit of everything in your environment.

  • Enable Parallel Development streams, safely

Having two or more developers working on the same file can cause chaos. If you don’t use a version control system, it is possible that while deploying to the SID environment, these two developers would use individual Changesets which might cause changes to be overwritten.Using Git or Flosum as a version control system allows you to have multiple developers working in parallel without the risk of losing your changes or getting your changes overwritten.

  • Automated Deployments

VCS enables automated deployments using CI/CD tools. Version control systems can simply configure it in such a way that every time there is a commit, it will be deployed to a certain environment. The changes will be automatically tracked by the version control system and CI/CD tools will take care of doing a delta deployment or an incremental deployment to your sandbox or even production. This functionality is not possible with changesets and why a version control system is valuable to an organization.

Why don’t most projects always use Salesforce GIT version control system? 

Git has alienated a large part of the developer community. What could be the cause for that? Although Git is incredibly great and powerful, there are major challenges in adopting it as the ideal version control for Salesforce. It is because Salesforce, by design, encourages people to edit directly on the ‘server’. Getting your Salesforce configuration, code and metadata into text form so it can be version controlled has traditionally been a pain. Further, even as getting configuration changes into source control might have been difficult, getting those changes back out of source control and applied to your orgs is yet another major pain point.   Let us examine some of the key reasons why Salesforce Git is daunting for Salesforce customers to adopt.

7 Common Issues found When Using Git Alone for Salesforce

Yet GIT  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 Salesforce Git is daunting for Salesforce customers to adopt.

  • Too complex

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

  • 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 infrastructure using Git looks complicated and must 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 must 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

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

The Art of Living Foundation, a humanitarian and educational NGO with centers in more than 156 countries chose to implement Flosum into their development process and utilize the software’s robust version control system to eliminate the instances of freelance developers overwriting each other’s code.

Similarly, AT&T handpicked Flosum  native release management application to create a streamlined deployment process, thus helping their teams deploy 500% faster with greater confidence and fewer errors. achieve faster and higher quality releases to provide the most value to the customer.

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

  • 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, hence, it 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

    Due 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

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 for Salesforce Version Control Simplified

After reading this article, you know why your Salesforce implementation must have version control. Salesforce compliance is essential to businesses 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. Flosum’s version control utilizes the strength of Salesforce Github integration and the does away with the baggage of Git.

Next Steps