Index
A
Acceptance test–driven development (ATDD)
Access token
Ant Migration tool
Apex classes
API first approach
AppExchange
Appirio DX
auth:jwt:grant
Automated acceptance tests
Automated functional testing
code-based acceptance testing
CMC metrics tool
code coverage
creation
data
scratch orgs/testing sandboxes
UI testing
creation
environment
Puppeteer
Selenium
test pyramid
Automated tests
AutoRABIT
B
Bastard operator from hell (BOFH)
Behavior-driven development (BDD)
Blue Canvas
Branching strategy
best-known strategies
in Dreamhouse app
feature branch
merging master
workflow
forking workflow
granular feature management
branches
cherry picking
illlustration
org-level configuration
example
exceptions
metadata production
publishing packages
repositories
ease of managing application
fork
freedom and control
KISS principle
trunk
research
trunk-based development
vs
feature branching
Business process standardization
C
Canary deployments
CI/CD
automating delivery process
environments
merge requests
multiproject pipeline
pipelines
tool
build automation
organization level management
metadata publishing
YAML syntax
package publishing
creating walking skeleton
ID(s)
running unit tests
trunk branch
servers
configuration
configuring jobs
creating integration users
environmental variables
group-level configuration
store project-specific secrets
storing CI job configuration
systems
user permission levels
using Docker containers
Click-based development, Salesforce
data management
SeeData management
declarative tools
SeeDeclarative tools
no-code, low-code, or pro-code
security model
SeeSecurity model
ClickDeploy
Client-side programming
API access
aura components
lightning web components
S-controls
visualforce remote objects
Code-based tests
Code reviews
Command-line interface (CLI)
Command-line scripts
other techniques
Bash scripts
JQ
Node.js
Salesforce DX
package.json
Salesforce CLI
plugins
scripting
Ant Migration Tool
defined
ruby script
Salesforce data loader
Unix-compatible systems
Windows
Commit-stage tests
Community Cloud
Component tests
Comprehensive tests
Automated functional
SeeAutomated functional testing
manual QA and UAT
nonfunctional testing
SeeNonfunctional testing
Concurrent version system (CVS)
Containers
Continuous Delivery
automated deployments
automated tests
behavioral rituals
continuous integration
deploying configuration data
deployment errors
Continuous integration (CI)
Continuous testing
Copado
CPQ solutions
Create, read, update, or delete (CRUD)
Cross-Org Adapter
CumulusCI
Customer relationship management (CRM)
Custom metadata
D
Dark deploying
Data management
bulk database operations
changing the schema
developer names
field types
configuration data
redundant backup systems
schema
Data migrations
Declarative tools
community builder
lightning app builder
process/flow builder
Default Organization Template (DOT)
Delivery pipeline
branches
SeeBranching strategy
CI/CD and automation
SeeCI/CD
function
version control
Git
salesforce
Dependencies
AWS
loose coupling
tight coupling
Dependency injection (DI)
FedExService
MyClass
OrderingService
OtherClass
Deployment errors, debug
Deployment technologies
changes sets
ClickDeploy
limitation
managing deployments
target org
Command-line
SeeCommand-line scripts
IDEs
manual changes
Metadata API
packages
risk analysis
traditional software
DeprecateOnly flag
Developer Console
Developer Edition orgs
Development tools
console
IDE
Salesforce CLI
VS Code
Web IDE
Welkin Suite
DevOps
agile manifesto
better value, faster, safer, happier
blameless postmortems
business impact
click-friendly release management tool
concepts
continuous delivery
continuous feedback
continuous improvement
cycle time
enabling change
generative culture
infinity loop
lean management
measuring performance
merge conflicts
process/flow
research
Salesforce DX
tools
version control
DevOps Research and Assessment (DORA)
Dev
vs
. Ops
Domain layer
Domain pattern
Domain-specific test language (DSL)
doSomething method
E
Einstein Analytics tool
Enhancing performance
theory of constraints
value stream mapping
Enterprise design patterns
domain layer
selector layer
separation of concerns
service layer
unit of work concept
Enterprise messaging platform (EMP)
Enterprise Service Buses (ESBs)
Event-driven architecture
Extreme programming (XP)
F
Factory method/application factory pattern
Fast tests
linting, static analysis
SeeLinting, static analysis
quality gates, static analysis
technical debt
unit
SeeUnit testing
FinancialForce
Flosum
force:auth:sfdxurl:web
Force-dev-tool
Force-DI package
Full codebase, static analysis
ApexPMD
Clayton
Codacy
CodeClimate
CodeScan
MetadataService.cls
SonarQube
G, H
Gearset
Generative cultures
Git
actions
central repository
definition
naming conventions
commit messages
conventional commits
feature branches
Squashing commits
preserving history of files
tools
command line
CRLF settings
GUIs
host web interface
IDE plugins
Globally unique ID (GUID)
Grand Unified System (GUS)
Graphical user interfaces (GUIs)
I, J
Identity and Access Management (IAM)
Infrastructure as a Service (IaaS)
Integration test
K
Keep it simple and straightforward (KISS) principle
Key performance indicators (KPIs)
L
Language Server Protocol (LSP)
Law of diffusion of innovation
Leading effective change, DevOps
build on the change
communicate the vision
corporate culture
encounter obstacles
powerful coalition
short term, creation
urgency creation
vision for change
Lean management
Lightning Dev Pro Sandboxes (LDPS)
Lines of code (LOC)
Linting, static analysis
Apex code
ESLint rules
feedback
M
Manual acceptance tests
Mean Time to Restore (MTTR)
Measuring performance
change fail percentage
deployment frequency
lead time
MTTR
Metadata
API
CI/CD process
configuration changes
Coverage Report
convertion between Salesforce DX and API
manual changes
retrieving changes
Metazoa Snapshot
Modular development techniques
DI
SeeDependency Injection (DI)
event-driven architecture
naming conventions
object-oriented programming
Monitoring and observability
add-on tools
analysis
built-in tools
signals
Multifactor authentication (MFA)
Multiple production orgs
architecture
coordinate
merge
mergers/acquisitions
purchases
splitting
N
Node package manager (NPM)
Nonfunctional testing
code reviews
full codebase, static analysis
SeeFull codebase, static analysis
performance
security analysis
CheckMarx
Fortify
O
Object-oriented programming
Open CLI Framework (OCLIF)
Org62
Org differences, managing
automatic replacements
intentional and unintentional
temporary differences
XSLT
OtherClass.doSomething() method
P
Packages
depiction of
Salesforce org
sfdx-project.json file
Packaging
classic
second-generation
SeeSecond-Generation packaging
Panaya
Pareto principle
Performance tests
Platform as a Service (PaaS)
Process quality
Pub-sub architecture
Q
Quality
functional
hidden levels
process
structural
R
Red bead experiment
Refresh Token
Releasing by deploying
Restricted permissions
S
Salesforce
background
business needs
click-based tools
delivery pipeline, changes
deployments
development lifecycle
DX
metadata
version update
deploying
early access
Salesforce admin
monitoring and observability
permission sets
scheduling jobs
security
user management
Salesforce app builders
sales force automation (SFA)
Salesforce CLI
defined
hooks creation
NPM
OCLIF
Salesforce Core API
Salesforce Data Loader
Salesforce DX
CLI
concepts
creation
Dev Hub
development lifecycle
goal
managed packages
metadata API vs. SFDX source formats
modular architecture
modules
Scratch Orgs
second-generation packages
unmanaged packages
Salesforce orgs
API access
auth commands
bugs/issues
dangers in production
Dev Hub
developing new functionality
environment strategy
mapping existing orgs
OAuth 2.0 flow
testing functionality
testing integrations
training
types
user interface
Salesforce packages
Salesforce platform
Salesforce’s Development Lifecycle Guide
Sandboxes
cloning/refreshing
creation
definition
developing
disadvantages
DX team
login
planning
refresh process
size
Sarbanes Oxley (SOX)
Scratch Orgs
aspects
benefits
create additional user accounts
creation
development
install
pushing metadata
review apps
setup process
setup steps
shape
snapshots
workflow
Scratch orgs
vs.
sandboxes
Second-generation package
add and remove metadata
package dependencies
Salesforce DX workflow
unlocked
AppExchange
branch flag
build and publish
Dev Hub
Security model
admin access
infrastructure
login and identity
user access
Selector layer
Separating deployments from releases
branching by admissions
dynamic lightning pages
feature flags
layouts
permission
Server-side programming
Apex
scripting and anonymous apex
visualforce
SFDX-Falcon
sfdx force:user:create command
sfdx-project.json file
Single-org
vs.
multi-org strategy
single sign-on (SSO)
Site Reliability Engineering (SRE)
Software delivery
Software Development Performance (SDP)
Software/Platform as a Service (SaaS/PaaS)
Squashing commits
Static analysis
Strongpoint
Structural quality
maintainability
performance
reliability
security
size
Subject matter experts (SMEs)
T
Test-driven development (TDD)
Testing
automated
business-critical customizations
code, API, and UI
commit-stage
components
continous
cost of fixing bugs
engine
environments
functional/nonfunctional
integration
KPIs
manual
red bead experiment
shifting left cycle
total quality management
unit
Testing functionality
Tipping point
Tracking issues and feature requests
Trigger handler patterns
Trigger management
U
Unit testing
Apex test runner
aura lightning components
creation
data needed
lightning web components
Salesforce org
TDD
VisualForce
Unit tests
User acceptance testing (UAT)
V, W
Version control
Visual Studio Code (VS Code)
Vlocity
X, Y, Z
XSLT
..................Content has been hidden....................
You can't read the all page of ebook, please click here login for view all page.