Flosum and Salesforce Go Hand in Hand

Salesforce has a unique cloud-based architecture with innovative features that are not available in other development environments such as Java, C++, or other programming languages. Because Flosum has a version control system that is very tightly aligned with the Salesforce platform, it can leverage those features while natively handling all Salesforce components, including declarative components, lightning components, and static resources.

The following features are just a few of those included in Flosum to allow you to fully manage your version control system:

    • Complete Code Repository With All Historical Versions
    • Branching Strategies
    • Conflict Detection & Code Merging
    • Pull Requests & Code Reviews
    • Synchronization of Development Sandboxes
    • Roll Back From the Master Branch
    • Integration With Git, SVN, TFS, and VSTS

Complete Code Repository With All Historical Versions

Flosum offers a complete historical code repository of all components along with their corresponding versions. After Flosum starts tracking components, all versions of those components are automatically tracked and maintained in the repository. Flosum supports all component types and urges users to commit all components to the repository. This is a big departure from other version control repositories – most developers use open-source repositories for programming components, but manage declarative components outside of the version control system due to the nature of XML components.

The screenshot below shows the various versions of a Visualforce page. You can see how each component was changed and who made the change, the commit history of each component, and even differences between multiple versions of the same components. If necessary, you can deploy an older version of the component from the repository.

Branching Strategies

Flosum offers branching capabilities similar to those of most open-source version control systems.

Flosum’s version control supports the following types of branches:

  • Feature Branches (including Hotfix Branches)
  • Integration or Release Branches
  • Environment Branches

As developers change components in the developer sandbox, they can commit those components to a specific feature branch. (Feature branches can be integrated with an Agile change management system such as Jira, Agile Accelerator, Service Cloud, etc.) As soon as changes are checked in, Flosum can run static code analysis and automatically check for potential conflicts. If a pipeline is set up, the components are automatically deployed to the various orgs as defined in the pipeline.

Multiple feature branches an be merged into an integration branch. If the branches being merged have the same common component, developers can view side-by-side differences between each feature branch and resolve any conflicts before saving the changes in the integration branch. (Show an example).

Environment branches show the delta changes that need to be applied to any org. In Flosum, environment branches are maintained via Flosum.

Conflict Detection & Code Merging

Flosum has put a lot of effort into ensuring that the code merge is easy for all Salesforce components. Flosum‘s version control can handle all components, including programmatic components, declarative components, lightning components, static resources, and others.

Other version control systems have nowhere near the flexibility of Flosum. For example, the most popular open-source version control system, Git, can’t handle merging of lightning components and static resources. Many users eventually become frustrated when trying to merge various XML components with the Git repository. Flosum, however, makes it painless to merge declarative code for XML components.

The following screenshots show examples of different merges in Flosum.

[screenshot]
Custom Objects

[screenshot]
Lightning Components

[screenshot]
Programmatic Components

Pull Requests & Code Reviews

Pull requests allow a developer to notify team members that a completed feature is ready for them to review. After all approvals are obtained, the developer can then merge that feature branch to the master branch.

For this demo, create a button called as pull request on the branch page.

Code Reviews

In a world of continuous integration, code must be tested before being submitted to the master branch to become part of the code base.

Code reviews allow developers to:
Work carefully and consistently
Learn best practices and new techniques from other developers
Implement consistency and quality across the code base

A thorough code review helps developers answer the following questions:
Design: Is code well-designed and suited to the code base?
Functionality: Does code perform as intended and in a way that is good for users?
Complexity: Can other developers understand and use the code?
Naming: Does the code contain clear names for elements such as variables, classes, and methods?
Comments: Are comments specific and complete?

Flosum allows developers, reviewers, and QA teams to review and annotate the code right in the version control system.

For this demo, show the side-by-side comparison of  XML files, lightning files and Apex code.

Synchronization of Development Sandboxes

Flosum allows developers to quickly and easily synchronize their changes with changes done by other developers. Staying in sync with other developers is important to ensure that the entire development team is working with the latest code in their sandboxes and to prevent any code overwrites.

Developers can pull down the code and configuration changes from the master branch, or any other branch, into the developer sandbox.

As shown in the example below, if a component has been changed in the developer sandbox as well as the remote repository, Flosum can identify changes on both sides and merge them seamlessly to prevent any loss of changes in the developer sandbox.

Roll Back From the Master Branch

Even developers can make mistakes! Flosum makes it easy to roll back changes made to the master branch in order to prevent erroneous changes being propagated to the rest of the ecosystem.

Each individual commit to the repository in Flosum can be rolled back. Such a commit could represent a single user story or the entire release.

As shown in the example below, Flosum helps you fix mistakes by automatically detecting which components and corresponding versions need to be included when you roll back changes from the master branch.

[screenshot]

Integration With Git, SVN, TFS, and VSTS

(What diagrams will we use?)

Ready to simplify your Salesforce Deployment?

Share This