Uploading Your Code to a Salesforce Dev Org

Learning Objectives

After completing this unit of measurement, you'll be able to:

• Depict how y'all manage change using the org development model.
• Place the tools that you lot need for org evolution.
• Explicate the benefits of using a source control system.

Calvin's Journey Continues

Do you lot remember Calvin Light-green from Zephyrus Relocation Services? Using Salesforce, Zephyrus helps customers relocate internationally for their jobs.

As nosotros walk you lot through how the org evolution model facilitates squad development, nosotros reference the process the team followed for alter set development. Earlier you proceed the journeying with Calvin and his team, did y'all already complete the Alter Set Development Model module? Get alee. It's okay. We'll be here when you get dorsum.

Meanwhile, Back at Zephyrus Relocation Services

Every bit yous can imagine, Calvin'south world is getting more complex. He'southward managing a growing number of requested customizations to their Relocation Services software. When the projects were smaller, Calvin and his colleague, Ella, used alter sets to deploy changes.

Zephyrus continues to deliver more than options and value to its customers. Calvin and his team need a way to brand sure that the Sales team is aware of all the new and heady product offerings. They can't offering their clients these slap-up new courses and services if they don't know about them.

Before they brainstorm piece of work on the adjacent release, Calvin is looking for a process and development lifecycle that scale with this growth. As his team grows, he needs a process that supports multiple contributors developing on the Lightning Platform simultaneously.

Calvin meets with his development team to hash out how they tin piece of work more finer as the squad grows. In the past, they've encountered challenges with:

• Tracking everyone's changes
• Keeping all the development and testing environments in sync
• Creating and deploying change sets multiple times because of errors and differences amid environments

The new lead developer, Juan Garcia, has been investigating some of the new Salesforce DX tools and development models. He thinks the org evolution model tin can assistance to mitigate some of the pain points they're experiencing.

Move to Org Development

With multiple developers and admins contributing to a release, the squad agrees they need a new development model. Enter org evolution, a model that uses some dissimilar tools that provide one) greater flexibility and scalability, ii) new ways to track and manage change, and three) a unlike method of deployment.

Juan likes that the org development model uses a source command repository to store changes and projection files. A source repo can aid to mitigate the hurting point of keeping environments in sync. By externalizing the changes for each release, the squad knows that the source repo reflects what they are delivering and isn't afflicted by surround differences. This consistency ensures a smoother process as they motility through the different evolution, testing, and staging environments.

Like to change sets, the release antiquity is a set of metadata changes to apply to the production org. To ensure they're identifying dependencies from all contributors, the team uses modify tracking mechanisms that capture the changes fabricated to components versus changes made directly in the org through the Setup UI.

Juan likewise suggests that they use the Salesforce Extensions for VS Code to retrieve metadata from their development environments. Then they store the changes they make in the source control system. Once changes are in source control, they can create automatic processes for testing and deploying to production.

After several testing and integration cycles, Juan deploys the changes, stored in source control, to production. This process mitigates another hurting indicate: creating and deploying change sets multiple times because of errors and differences between environments.

Prepare the Release Environments

The team accesses the same development and testing environments they've used before. Juan's team uses sandboxes in each step of the application lifecycle.

1. Develop and test: Each squad member has their own Developer sandbox to create their assigned customization. Developer sandboxes contain no product data.
2. Build release: Each team member migrates their customizations from their respective Developer sandboxes to a shared Programmer Pro sandbox for integration. Programmer Pro sandboxes don't contain product data, merely you can seed them with testing data.
3. Examination release: For user-acceptance testing, the team uses a fractional sandbox to create a complete replica of production (without production information).
4. Release: Afterward the release is in production, the squad tin can employ the full sandbox to train users without the risk of altering product data. A full sandbox includes a copy of production information.

Manage Change Similar a Boss

Calvin and his team utilize many of the tools they are already familiar with as they begin to follow the org development model. However, some new tools raise their productivity during specific release stages. They are critical for moving to a more than active team development model.

Salesforce DX Project

The Salesforce DX projection contains the source and files that incorporate your changes. A DX project has a specific project construction and source format.

In addition to source files, the project contains a configuration file, sfdx-projection.json. This file contains project information and enables you to leverage Salesforce DX tools for many of your evolution tasks.

A DX project has this structure:

Y'all can think of the DX project as your outbound change set, where you're managing and collecting the changes that you lot desire to send to your production org.

Deployment Artifact (.zippo File)

After testing the changes, Juan creates the deployment artifact, a .zip file that contains changes to deploy. He deploys the release antiquity to the Full (staging) sandbox first, and then finally to product. You tin think of the deployment artifact as the inbound change gear up. The changes don't take event until they are deployed.

Source Control System

All changes are merged and stored in a source command system, which contains the Salesforce DX project. A source control system provides several benefits.

• Existent-time collaboration increases efficiency and drives consensus.
• The team can work on the same files at the same time without fear of overwriting changes or losing work.
• Revision history shows who made which changes.
• You can revert to earlier versions of any file. Information technology's like having your very own fourth dimension machine where y'all can become back and salve the universe from destruction.
• When you save work you provide a commit description, which provides historical context for the work.

Salesforce CLI

Salesforce CLI is a powerful control-line interface that you lot can use for every phase of the org development lifecycle. It improves productivity past providing a single interface for all your development, examination, and automation use cases. You lot tin:

• Authorize sandboxes (headless or web menses)
• Create and manage DX projects
• Import and consign test information
• Retrieve and deploy metadata
• Run and automate tests

Salesforce Extensions for Visual Studio (VS) Code

Salesforce Extensions for VS Code is congenital on pinnacle of Salesforce CLI and VS Code. Together, they are an integrated development environment that'south created for custom development on Lightning Platform. Best of all, y'all can run Salesforce CLI commands directly from the command palette or terminal. The development squad installs the Salesforce Extension Pack and then they tin apply these VS Code extensions:

• Salesforce CLI Integration—interacts with Salesforce CLI to provide core functionality.
• Apex—uses the Apex Language Server to provide features such every bit syntax highlighting and code completion.
• Noon Replay Debugger—enables VS Code to replay Apex execution from Apex debug logs.
• Aura Components—supports Aureola component bundles.
• Visualforce—supports Visualforce pages and components.

Alter Management Mechanisms

The development squad benefits from having some formal modify-tracking tools in identify, including a squad change listing, deployment run list, and project management system.

Tool	Clarification
Change list	A programmer uses this simple list, tabular array, or spreadsheet to track changes they make in their own dev org then they know what to externalize.
Deployment run listing	A developer lists whatever transmission changes required in the org pre- and post-deployment. These changes include metadata that tin't be deployed, for example, contour and permission set assignments.
Projection direction tools	Tools such as Active Accelerator and Jira aid a squad comprehend Agile development practices, track business requirements, feature work, and bugs. Projection management tools also help a team manage sprints and groom its excess (future work items).

slusstholsolot46.blogspot.com

Source: https://trailhead.salesforce.com/en/content/learn/modules/org-development-model/plan-for-changes-to-your-org2

Share this post