Index
A
- Advanced Encryption Standard (AES) algorithm / Encrypted fields
- Aggregate SOQL queries
- about / SOSL and Aggregate SOQL queries
- Alexa / Which devices should you target?
- Aloha / Security review and benefits
- Amazon EC2
- about / The developer workflow
- Analytics API / Custom reporting and the Analytics API
- AngularJS / Considerations for using JavaScript libraries
- Ant
- Ant build script
- used, for cleaning application / The Ant build script to clean and build your application
- used, for building application / The Ant build script to clean and build your application
- URL / The Ant build script to clean and build your application
- developing in developer orgs, versus packaging orgs / Developing in developer orgs versus packaging orgs
- Metadata API, leveraging / Leveraging the Metadata API and Tooling APIs from Ant
- Tooling APIs, leveraging / Leveraging the Metadata API and Tooling APIs from Ant
- Apache Ant
- about / The developer workflow
- using / Developing with Source Control
- URL / Developing with Source Control
- Apex / Packaging and upgradable components
- usage / Where is Apex used?
- concerns, separating / Separating concerns in Apex
- 50k maximum results, processing / Processing 50k maximum result sets in Apex
- unlimited result sets, processing / Processing unlimited result sets in Apex
- executing, in asynchronous mode / Running Apex in the asynchronous mode
- @future, using / @future
- Queueables, using / Queueables
- Batch Apex, using / Batch Apex
- Apex application APIs
- providing / Providing Apex application APIs
- calling / Calling an application API from Apex
- modifying / Modifying and depreciating the application API
- depreciating / Modifying and depreciating the application API
- definitions, versioning / Versioning Apex API definitions
- behavior, versioning / Versioning Apex API behavior
- Apex Class
- Apex class
- Apex code
- evolution / Apex code evolution
- Apex compiler / Domain classes in Apex compared to other platforms
- Apex Controller method / RaceStandings component
- Apex data types
- combining, with SObject types / Combining Apex data types with SObject types
- Apex Debug log / Exploring execution contexts
- Apex Describe
- about / Object and field-level security
- Apex Describe facility / Your code and security review considerations
- Apex DML
- external references, using / Using external references in Apex DML
- Apex Domain class
- instantiation / Domain classes in Apex compared to other platforms
- Apex Enterprise Patterns
- Apex Enterprise Patterns library / Implementing Unit tests with CDI and Mocking
- Apex enum / Translation and localization
- Apex exception class / Translation and localization
- Apex governors
- about / Apex governors and namespaces
- scope / Namespaces and governor scope
- non-deterministic governors / Deterministic and non-deterministic governors
- deterministic governors / Deterministic and non-deterministic governors
- key governors, for Apex package developers / Key governors for Apex package developers
- Apex inheritance / Domain classes in Apex compared to other platforms
- Apex inner class / A custom Selector method with a custom data set
- Apex Interface
- using / Creating a compliance application framework
- example / An Apex interface example
- generic service, defining / Step 5 – defining a generic service
- Domain class interface, implementing / Step 6 – implementing the domain class interface
- Factory pattern, implementing / Step 7 – the domain class factory pattern
- generic service, implementing / Step 8 – implementing a generic service
- generic service, using from generic controller / Step 9 – using the generic service from a generic controller
- compliance framework implementation, summarizing / Summarizing compliance framework implementation
- application logic, extending / Extending the application logic with Apex interfaces
- about / Constructor Dependency Injection
- Apex Metadata API library
- Apex Mocks
- about / Unit testing versus system testing
- reference link / Unit testing versus system testing
- ApexMocks / Using Apex Stub API with Mocking Frameworks
- reference link / Using Apex Stub API with Mocking Frameworks
- about / Understanding how ApexMocks works
- Apex Enterprise Patterns / ApexMocks and Apex Enterprise Patterns
- controller method, unit testing / Unit Testing a Controller Method
- service method, unit testing / Unit Testing a Service Method
- domain method, unit testing / Unit Testing a Domain method
- selector method, unit testing / Unit Testing a Selector Method
- ApexMocks Matchers
- about / ApexMocks Matchers
- Apex package developers
- key governors / Key governors for Apex package developers
- Apex property / Defining and passing data
- Apex REST application APIs
- providing / Providing Apex REST application APIs
- calling / Calling your Apex REST application APIs
- versioning / Versioning Apex REST application APIs
- behavior, versioning / Behavior versioning
- definition, versioning / Definition versioning
- Apex Scheduled job / Auto Number fields
- Apex Scheduler / Running Apex in the asynchronous mode
- Apex script
- Race Data object, creating / Using the Apex script to create the Race Data object
- Apex Stub API
- about / Benefits of Dependency Injection Frameworks
- unit tests, writing / Writing Unit Tests with the Apex Stub API
- Stub Provider interface, implementing / Writing Unit Tests with the Apex Stub API
- Stubs, creating dynamically for mocking / Writing Unit Tests with the Apex Stub API
- Mock classes, implementing with Test.StubProvider / Implementing Mock classes using Test.StubProvider
- dynamic stubs, creating for mocking classes / Creating dynamic stubs for mocking classes
- mocking examples / Mocking Examples with the Apex Stub API
- usage considerations / Considerations when using the Apex Stub API
- using, with mocking framework / Using Apex Stub API with Mocking Frameworks
- Apex Trigger
- event handling / Apex Trigger event handling
- field values, defaulting on insert / Defaulting field values on insert
- validation, on insert / Validation on insert
- validation, on update / Validation on update
- Apex Trigger code / Importing and exporting data
- Apex Triggers / Apex code evolution
- API definition
- versioning / Versioning the API definition
- API functionality
- versioning / Versioning the API functionality
- AppExchange
- AppExchange solutions
- Replication API / Options for replicating and archiving data
- Outbound Messaging / Options for replicating and archiving data
- Bulk API / Options for replicating and archiving data
- application access
- versioning, through Salesforce API / Versioning application access through the Salesforce APIs
- Application Cache / Custom Settings storage
- application events / Methods, events and interfaces
- application integration APIs
- about / Application integration APIs
- Apex application APIs, providing / Providing Apex application APIs
- RESTful application APIs, providing / Providing RESTful application APIs
- Apex REST application APIs, providing / Providing Apex REST application APIs
- Apex REST application APIs, calling / Calling your Apex REST application APIs
- Apex REST application APIs, versioning / Versioning Apex REST application APIs
- application logic
- extending, with Apex Interface / Extending the application logic with Apex interfaces
- application logic concerns
- versus execution context logic / Execution context logic versus application logic concerns
- application resources
- reviewing / What are your application resources?
- applications integration needs
- reviewing / What are your application's integration needs?
- custom APIs, calling on-platform / Developer X calling your APIs on-platform
- custom APIs, calling off-platform / Developer X calling your APIs off-platform
- SOAP, versus REST / SOAP versus REST
- architecture, Lightning
- about / Lightning architecture
- containers / Containers
- components / Components
- namespaces / Platform namespaces
- platform namespaces / Platform namespaces
- Base Components / Base components
- Data Services / Data services
- object-oriented programming (OOP) / Object-oriented programming
- field-level security / Object-Level and Field-Level security
- object-level security / Object-Level and Field-Level security
- asynchronous execution
- contexts / Asynchronous execution contexts
- design considerations / General async design considerations
- Asynchronous JavaScript and XML (AJAX) / How does Lightning differ from other UI frameworks?
- asynchronous mode
- Apex, executing / Running Apex in the asynchronous mode
- Aura
- about / Platform namespaces
- Aura Definition Bundles
- about / Encapsulation during development
- reference link / Encapsulation during development
- Aura test framework
- automated regression testing
- about / Automated regression testing
- considerations / Automated regression testing
- Auto Number Display Format
- customizing / Subscribers customizing the Auto Number Display Format
- Auto Number fields
- applying / Auto Number fields
- Auto Number Display Format, customizing / Subscribers customizing the Auto Number Display Format
B
- Base Components
- about / Base components
- Base Lightning Components
- Batch Apex
- about / Execution contexts, Introducing the Selector layer pattern
- using / Batch Apex
- tips, for performance optimization / Performance of Batch Apex jobs
- external references, using in Apex DML / Using external references in Apex DML
- Batch Apex Chaining / Batch Apex
- Batch Apex Flex Queue / Performance of Batch Apex jobs
- Behavior Driven Development (BDD)
- about / Dependency Injection, Mocking, and Unit Testing
- reference link / Dependency Injection, Mocking, and Unit Testing
- benefits, managed packages
- Intellectual Property (IP) protection / Features and benefits of managed packages
- naming scope / Features and benefits of managed packages
- upgrades and versioning / Features and benefits of managed packages
- benefits, Salesforce
- bypass subscriber org setup limits / Security review and benefits
- licensing / Security review and benefits
- subscriber support / Security review and benefits
- push upgrade / Security review and benefits
- Big Objects
- about / Data storage
- browser-based development
- Bulk API
- bulkification
- about / Bulkification
C
- Chatter
- about / Social features and mobile
- enabling / Social features and mobile
- CheckMarx
- reference / Security review and benefits
- child components / Populating your Source Control repository
- Classic Encryption / Encrypted fields
- client-side controllers
- about / Lightning architecture
- client server communication
- about / Client server communication
- client communication, options / Client communication options
- API governors / API governors and availability
- API, availability / API governors and availability
- database transaction, scope / Database transaction scope and client calls
- client calls / Database transaction scope and client calls
- offline support / Offline support
- code
- packaging / Packaging the code
- columns
- versus rows / Columns versus rows
- common Apex Interface
- about / Introducing the Selector factory
- communities
- creating / Creating websites and communities
- compliance application framework
- creating / Creating a compliance application framework
- Compliance Checker / An Apex interface example
- Compliance Verification component / Embedding a custom UI in a standard UI
- Component controller (…Controller.js)
- Component CSS (.css)
- about / Component CSS (.css)
- Component Design (.design)
- Component Documentation (.auradoc)
- component events / Methods, events and interfaces
- Component Helper (…Helper.js)
- about / Component Helper (…Helper.js)
- component management
- about / Containers
- Component markup (.cmp)
- about / Component markup (.cmp)
- Component Render (…Renderer.js)
- about / Component Render (…Renderer.js)
- components
- packaging / Packaging and upgradable components
- reference link / Packaging and upgradable components
- about / Components
- separation of concerns / Separation of concerns
- encapsulation, during development / Encapsulation during development
- encapsulation, enforcing / Enforcing encapsulation and security at runtime
- security, enforcing at runtime / Enforcing encapsulation and security at runtime
- behavior, expressing / Expressing behavior
- access control / Access Control
- methods / Methods, events and interfaces
- events / Methods, events and interfaces
- interfaces / Methods, events and interfaces
- customizing / Making components customizable
- Component SVG (.svg)
- component trees
- considerations / Considerations for managing large component trees
- composition approach / Domain classes in Apex compared to other platforms
- concrete type / Domain classes in Apex compared to other platforms
- configuration data
- considerations / Considerations for configuration data
- Custom Metadata Type storage / Custom Metadata Type storage
- Custom Settings storage / Custom Settings storage
- Constructor Dependency Injection (CDI)
- about / Constructor Dependency Injection
- and mocking, used for implementing unit tests / Implementing Unit tests with CDI and Mocking
- containers
- about / Containers
- URL-parameters / Containers
- URL centric navigation / Containers
- Racing Overview Lightning App / Introducing the Racing Overview Lightning app
- Lightning Experience / Lightning Experience and Salesforce1
- Salesforce1 Mobile / Lightning Experience and Salesforce1
- Content Security Policy (CSP) / Enforcing encapsulation and security at runtime
- Continuous Integration / Test methods using the Domain class methods
- about / Hooking up Continuous Integration
- process / The Continuous Integration process
- Ant build script, updating / Updating the Ant build script for CI
- Jenkins CI server, installing / Installing, configuring, and testing the Jenkins CI server
- Jenkins CI server, configuring / Installing, configuring, and testing the Jenkins CI server
- Jenkins CI server, testing / Installing, configuring, and testing the Jenkins CI server
- Continuous Integration (CI) / Security review and benefits
- Contract Driven Development / Contract Driven Development
- controller method
- unit testing / Unit Testing a Controller Method
- CRUD operations / Client server communication
- custom Apex data type / A custom Selector method with a custom data set
- custom Domain logic
- implementing / Implementing custom Domain logic
- customer licenses
- customer metrics / Customer metrics
- customer support
- providing / Providing support
- custom field
- picklist values / Custom field – picklist values
- about / Understanding the custom field features
- features / Understanding the custom field features
- default field values / Default field values
- encrypted fields / Encrypted fields
- lookup options / Lookup options, filters, and layouts
- filters / Lookup options, filters, and layouts
- layouts / Lookup options, filters, and layouts
- rollup summaries / Rollup summaries and limits
- custom indexes
- about / Standard and custom indexes
- customizable user interfaces
- building / Building customizable user interfaces
- layouts / Layouts
- Visualforce / Visualforce
- Lightning App Builder / Lightning App Builder and Components
- Lightning Components / Lightning App Builder and Components
- Custom Labels / Translation and localization
- Custom Metadata Type storage / Custom Metadata Type storage
- Custom Objects / Introducing the book's sample application, Naming conventions
- custom Publisher Actions
- creating / Custom Publisher Actions
- custom query logic
- implementing / Implementing custom query logic
- custom Selector method, using / A basic custom Selector method
- custom Selector method, using with sub-select / A custom Selector method with subselect
- custom Selector method, using with related fields / A custom Selector method with related fields
- custom Selector method, using with custom data set / A custom Selector method with a custom data set
- Apex data types, combining with SObject types / Combining Apex data types with SObject types
- Salesforce Object Search Language (SOSL) / SOSL and Aggregate SOQL queries
- Aggregate SOQL queries / SOSL and Aggregate SOQL queries
- custom Reporting
- custom Selector method
- using / A basic custom Selector method
- using, with sub-select / A custom Selector method with subselect
- using, with related fields / A custom Selector method with related fields
- using, with custom data set / A custom Selector method with a custom data set
- Custom Settings storage / Custom Settings storage
- custom UIs / Introducing Salesforce Standard UIs and Lightning
- standard UIs, combining / Combining standard UIs with custom UIs
- embedding, in standard UIs / Embedding a custom UI in a standard UI
- standard UIs, embedding / Embedding a standard UI in a custom UI
D
- data
- importing / Importing and exporting data
- exporting / Importing and exporting data
- replicating / Options for replicating and archiving data
- archiving / Options for replicating and archiving data
- Database access
- using / Using the Service layer and database access
- JavaScript, usage considerations / When should I use JavaScript for database access?
- Data Loader tools / Using external references in Apex DML
- Data Mapper (Selector) layer
- reference link / The Data Mapper (Selector) layer
- about / The Data Mapper (Selector) layer
- FinancialForce.com Apex Commons library / Introducing the FinancialForce.com Apex Commons library
- Data Mapper layer
- about / Introducing the Selector layer pattern
- reference link / Introducing the Selector layer pattern
- data security
- data storage
- about / Data storage
- columns, versus rows / Columns versus rows
- object model, visualizing / Visualizing your object model
- configuration data, considerations / Considerations for configuration data
- Data Transformation Objects (DTO) / The Data Mapper (Selector) layer
- debugging
- about / The developer workflow
- debug log filters
- about / The developer workflow
- dependency injection
- about / Dependency Injection, Mocking, and Unit Testing
- Constructor Dependency Injection (CDI) / Constructor Dependency Injection
- other approaches / Other Dependency Injection approaches
- DI frameworks, benefits / Benefits of Dependency Injection Frameworks
- design guidelines
- implementation / Implementation of design guidelines
- naming conventions / Naming conventions
- bulkification / Bulkification
- sharing rules, enforcing / Sharing rules enforcement
- data, defining / Defining and passing data
- data, passing / Defining and passing data
- SObject, using in Service layer interface / Considerations when using SObject in the Service layer interface
- transaction management / Transaction management
- compound services / Compound services
- summarizing / A quick guideline checklist
- desktop-based development
- deterministic governors
- Developer Edition orgs / Reusing the existing Standard Objects
- developer org
- versus sandbox and packaging org / Packaging org versus sandbox versus developer org
- URL / Creating and preparing your developer orgs
- creating / Creating and preparing your developer orgs
- preparing / Creating and preparing your developer orgs
- versus packaging orgs, for Ant build script development / Developing in developer orgs versus packaging orgs
- Developer Workbench tool / Profiling queries
- developer workflow
- about / The developer workflow
- Developer X
- persona, defining / Defining the Developer X persona
- development workflow
- about / Development workflow and infrastructure
- Salesforce Developer Experience (DX) / Salesforce Developer Experience (DX)
- packaging org, versus sandbox and developer org / Packaging org versus sandbox versus developer org
- DML
- used, for testing Domain layer / Test methods using DML and SOQL
- Domain class
- template / Domain class template
- Domain factory
- about / Introducing the Selector factory
- Domain layer
- reference link / Introducing the Domain layer pattern
- about / Introducing the Domain layer pattern
- object's behavior, encapsulating / Encapsulating an object's behavior in code
- interpreting, in Force.com / Interpreting the Domain layer in Force.com
- Apex Domain class, comparing to other platforms / Domain classes in Apex compared to other platforms
- testing / Testing the Domain layer
- calling / Calling the Domain layer
- Service layer, interactions / Service layer interactions
- interactions / Domain layer interactions
- Domain layer, design guidelines
- about / Implementation design guidelines
- naming conventions / Naming conventions
- bulkification / Bulkification
- data, defining / Defining and passing data
- data, passing / Defining and passing data
- transaction management / Transaction management
- domain method
- unit testing / Unit Testing a Domain method
- Domain Model layer
- reference link / The Domain Model layer
- about / The Domain Model layer
- Domain Trigger logic
- implementing / Implementing Domain Trigger logic
- trigger events, routing to Domain class methods / Routing trigger events to Domain class methods
- object security, enforcing / Enforcing object security
- Apex Trigger, event handling / Apex Trigger event handling
- downloadable content
- generating / Generating downloadable content
- drivers / Object-oriented programming
- dummy implementation / Contract Driven Development
- Dynamic Apex
- about / Introducing the Selector layer pattern
- utilizing / Multi-Currency
- dynamic Apex / Reusing the existing Standard Objects
- Dynamic SOQL
E
- e-mail
- customizing, with e-mail templates / E-mail customization with e-mail templates
- encapsulation
- during development / Encapsulation during development
- Component markup (.cmp) / Component markup (.cmp)
- Component controller (…Controller.js) / Component controller (…Controller.js)
- Component Helper (…Helper.js) / Component Helper (…Helper.js)
- Component CSS (.css) / Component CSS (.css)
- Component Render (…Renderer.js) / Component Render (…Renderer.js)
- Component Design (.design) / Component Design (.design) and Component SVG (.svg)
- Component SVG (.svg) / Component Design (.design) and Component SVG (.svg)
- Component Documentation (.auradoc) / Component Documentation (.auradoc)
- enforcing / Enforcing encapsulation and security at runtime
- encrypted fields
- about / Encrypted fields
- Classic Encryption / Encrypted fields
- Platform Encryption / Encrypted fields
- considerations, for Platform Encryption / Special considerations for Platform Encryption
- end user
- storage requirements, mapping out / Mapping out end user storage requirements
- Enterprise API
- about / Platform APIs
- Enterprise Application Architecture
- patterns / Patterns of Enterprise Application Architecture
- reference link / Patterns of Enterprise Application Architecture
- Service layer / The Service layer
- Domain Model layer / The Domain Model layer
- Data Mapper (Selector) layer / The Data Mapper (Selector) layer
- Entity Relationship Diagram (ERD) / Visualizing your object model
- Environment Hub
- test and developer orgs, creating via / Creating test and developer orgs via Environment Hub
- reference / Creating test and developer orgs via Environment Hub
- event handling
- reference link / Methods, events and interfaces
- execution context logic
- versus application logic concerns / Execution context logic versus application logic concerns
- execution contexts
- about / Execution contexts
- exploring / Exploring execution contexts
- state / Execution context and state
- Platform Cache / Platform Cache
- security / Execution context and security
- transaction management / Execution context transaction management
- extension packages
- about / Package types and benefits, Extension packages
- reference / Package types and benefits
- external data sources / External data sources
F
- @future
- using / @future
- Factory pattern
- reference link / Step 7 – the domain class factory pattern
- factory pattern / Other Dependency Injection approaches
- Federation Internationale de l'Automobile (FIA) / Services calling services
- fflib_QueryFactory class / Implementing custom query logic
- fflib_SObjectSelector class
- getSObjectType method / The Selector class template
- selectSObjectsById method / The Selector class template
- getOrderBy method / The Selector class template
- getSObjectFieldSetList method / The Selector class template
- newQueryFactory method / The Selector class template
- FIA Super License / Object-oriented programming
- field-level security
- field-level security (FLS)
- reference link / Your code and security review considerations
- about / Your code and security review considerations
- Field-Level security (FLS)
- about / Execution context and security
- Field Level security / Enforcing object security
- Field Sets
- using / Field Sets
- file storage
- about / File storage
- FinancialForce.com / Using Apex Stub API with Mocking Frameworks
- FinancialForce.com Apex Commons library
- FinancialForce.com Apex Enterprise Patterns library / Domain class template
- FinancialForce.com Enterprise Apex Patterns library
- about / The Selector class template
- FinancialForce Apex Enterprise Pattern / With Unit Of Work
- FlexiPage
- fluent design model
- about / Implementing custom query logic
- reference link / Implementing custom query logic
- fly-by reviews / Naming conventions
- Force.com / Creating websites and communities
- Domain layer, interpreting / Interpreting the Domain layer in Force.com
- platform APIs, used for integration / Force.com platform APIs for integration
- extensibility features / Alignment with Force.com extensibility features
- asynchronous processing, URL / Running Apex in the asynchronous mode
- Force.com IDE
- FormulaForce
- FormulaForce package
- full table scan / Ensuring queries leverage indexes
- functional security
- about / Understanding the available security features, Functional security
- Permission Sets, creating / Functional security
- profiles, creating / Functional security
- code / Your code and security review considerations
- considerations / Your code and security review considerations
G
- generic service
- generic Compliance Verification UI, with Visualforce / Generic Compliance Verification UI with Visualforce
- generic Compliance Verification UI, with Lightning Component / Generic Compliance Verification UI with a Lightning Component
- GitFlow
- about / The developer workflow
- GitHub
- global / Uploading the release and beta packages
- Global Picklists
- about / Global Picklists
H
- heap / Execution context and state
- heap governor
- Heroku Connect
- HTTP methods
- mapping / Mapping HTTP methods
- GET / Mapping HTTP methods
- PUT / Mapping HTTP methods
- POST / Mapping HTTP methods
- PATCH / Mapping HTTP methods
- DELETE / Mapping HTTP methods
- HTTP protocol / Client server communication
I
- Idempotent / Mapping HTTP methods
- incremental code reuse
- improving / Improving incremental code reuse
- Independent Software Vendor (ISV) / Becoming a Salesforce partner and benefits
- indexes
- using / Indexes, being selective, and query optimization
- custom indexes / Standard and custom indexes
- standard indexes / Standard and custom indexes
- leveraging, via queries / Ensuring queries leverage indexes
- usage considerations / Factors affecting the use of indexes
- references / Factors affecting the use of indexes
- infrastructure
- integration and extensibility needs
- reviewing / Reviewing your integration and extensibility needs
- versioning / Versioning
- translation / Translation and localization
- localization / Translation and localization
- terminology / Terminology and platform alignment
- platform alignment / Terminology and platform alignment
- applications integration needs, reviewing / What are your application's integration needs?
- applications extensibility needs, reviewing / What are your applications extensibility needs?
- integration testing
- comparing, with unit testing / Comparing Unit testing and Integration Testing
- about / Comparing Unit testing and Integration Testing
- limitations / Comparing Unit testing and Integration Testing
- internal view state / Visualforce Viewstate size
- Internet of Things (IoT)
- Invocable Method
- about / Extending Process Builder and Visualflow
- versioning / Versioning Invocable Methods
- ISVforce Guide
- reference / Features and benefits of managed packages
J
- Jasmine / Using Apex Stub API with Mocking Frameworks
- JavaScript
- usage considerations, for Database access / When should I use JavaScript for database access?
- JavaScript libraries
- usage considerations / Considerations for using JavaScript libraries
- JavaScript Remote Objects / When should I use JavaScript for database access?
- JavaScript Remoting / Installing and testing your package, Leveraging Visualforce and the Apex read-only mode
- Java Server Pages (JSP) / How does Lightning differ from other UI frameworks?
- Jenkins CI server
- testing / Installing, configuring, and testing the Jenkins CI server
- configuring / Installing, configuring, and testing the Jenkins CI server
- URL / Installing, configuring, and testing the Jenkins CI server
- installing / Installing, configuring, and testing the Jenkins CI server
- exploring / Exploring Jenkins and CI further
K
- key areas, Partner Community
- Education and Trailhead / Getting the best out of the Partner Community
- Featured Groups / Getting the best out of the Partner Community
- support / Getting the best out of the Partner Community
- publishing / Getting the best out of the Partner Community
- Partner Alerts / Getting the best out of the Partner Community
- key governors
- for Apex package developers / Key governors for Apex package developers
L
- layouts
- customization features / Layouts
- Least Recently Used (LRU) algorithm
- about / Platform Cache
- License Management Application (LMA)
- about / Functional security
- licensing
- about / Licensing
- Licenses tab / The Licenses tab and managing customer licenses
- Subscribers tab / The Subscribers tab
- Subscriber Overview page / The Subscriber Overview page
- enforcing, in subscriber org / How licensing is enforced in the subscriber org
- Lighting App Builder / Domain layer interactions
- Lightning
- about / Introducing Salesforce Standard UIs and Lightning
- user interface, building / Building a basic Lightning user interface
- architecture / Lightning architecture
- Lightning App Builder
- Lightning App Builder tool / Summarizing compliance framework implementation
- Lightning Application
- creating / Building a basic Lightning user interface
- Lightning Base Components
- Lightning Bundle
- Lightning Community
- integrating with / Integrating with communities
- Lightning Component
- generic Compliance Verification UI / Generic Compliance Verification UI with a Lightning Component
- Lightning Component JavaScript
- Separation of Concerns (SOC) / Separation of concerns in Lightning Component JavaScript
- Lightning Components
- about / Lightning App Builder and Components
- designing, for FormulaForce sample application / FormulaForce Lightning Components
- RaceStandings component / RaceStandings component
- RaceCalendar component / RaceCalendar component
- RaceResults component / RaceResults component
- RaceSetup component / RaceSetup component
- exposing / Exposing Lightning Components
- Lightning Component Tabs
- Lightning Connect / External data sources
- Lightning Data Service / Database transaction scope and client calls, When should I use JavaScript for database access?
- Lightning Data Service component
- about / Object and field-level security
- Lightning Data Services
- about / Data services
- Lightning Design System (LDS)
- Lightning Experience (LEX)
- about / Introducing Salesforce Standard UIs and Lightning, Building a basic Lightning user interface
- and Salesforce1 Mobile / Lightning Experience and Salesforce1
- integrating with / Integrating with Lightning Experience
- components, using on Lightning Page / Using Components on Lightning Pages and Tabs
- components, using on Lightning Tab / Using Components on Lightning Pages and Tabs
- Lightning Framework
- about / Introducing Salesforce Standard UIs and Lightning
- Visualforce, considering over / Why consider Visualforce over the Lightning Framework?
- Lightning Inspector
- response times, monitoring / Lightning tools to monitor size and response times
- size, monitoring / Lightning tools to monitor size and response times
- Lightning Locker Service / Enforcing encapsulation and security at runtime
- Lightning Out
- and Visualforce / Lightning Out and Visualforce
- reference link / Lightning Out and Visualforce
- Lightning Page
- Lightning Tab
- localization
- about / Localization and translation
- Locker Service / Considerations for using JavaScript libraries
- logging solutions / Visualizing your object model
- log table / Execution context logic versus application logic concerns
- lookup filters
- lookup layout / Unique and external ID fields
- Lookup relationship
- about / Record relationships
- utilizing / Record relationships
M
- managed package
- creating / Creating your first managed package, Creating the package and assigning it to the namespace
- namespace, setting / Setting your package namespace
- namespace, assigning / Setting your package namespace
- assigning, to namespace / Creating the package and assigning it to the namespace
- components, adding / Adding components to the package
- managed packages
- about / Package types and benefits
- features / Features and benefits of managed packages
- benefits / Features and benefits of managed packages
- MarkDown / Populating your Source Control repository
- marker interfaces / Methods, events and interfaces
- Master-Detail relationship
- about / Record relationships
- utilizing / Record relationships
- MavensMate / Considerations for using JavaScript libraries
- MemCache
- about / Platform Cache
- reference link / Platform Cache
- Metadata API
- upgrades, automating / Automating upgrades with the Salesforce Metadata API
- about / Automating upgrades with the Salesforce Metadata API, Platform APIs
- leveraging / Leveraging the Metadata API and Tooling APIs from Ant
- Migration Toolkit
- mobile application
- development strategy / Mobile application strategy
- mocking
- about / Dependency Injection, Mocking, and Unit Testing
- and CDI, used for implementing unit tests / Implementing Unit tests with CDI and Mocking
- mocking approach / Writing tests and the Selector layer
- reference link / Introducing Unit Testing
- mocking framework
- Apex Stub API, using / Using Apex Stub API with Mocking Frameworks
- Mockitio framework / Using Apex Stub API with Mocking Frameworks
- Mockito / Unit testing
- Model View Controller (MVC) / Separation of concerns in Lightning Component JavaScript
- Model View Controller (MVC) frameworks / Considerations for using JavaScript libraries
- Multi-Currency / Multi-Currency
- My Domain feature / Package dependencies and uploading
N
- namespaces
- about / Apex governors and namespaces, Namespaces and governor scope, Platform namespaces
- aura / Platform namespaces
- force / Platform namespaces
- forceCommunity / Platform namespaces
- ui / Platform namespaces
- lightning / Platform namespaces
- naming conventions
- about / Naming conventions
- acronyms, avoiding / Naming conventions
- class, naming / Naming conventions
- method, naming / Naming conventions
- parameters, naming / Naming conventions
- parameter types / Naming conventions
- inner class, naming / Naming conventions
- nforce
- non-deterministic governors
O
- oAuth / Mobile application strategy
- object-level security
- object-orientated programming (OOP) / Apex code evolution
- object-oriented programming (OOP)
- about / Object-oriented programming, Object-oriented programming
- compliance application framework, creating / Creating a compliance application framework
- Apex Interface, example / An Apex interface example
- Object CRUD (Create, Read, Update, and Delete) security / Enforcing object security
- object level security
- about / Object and field-level security
- object model
- visualizing / Visualizing your object model
- Object Relational Mapping (ORM)
- object security
- enforcing / Enforcing object security
- default behavior / Default behavior
- default behavior, overriding / Overriding the default behavior
- Outbound Messaging
P
- package
- about / Package types and benefits
- managed / Package types and benefits
- unmanaged / Package types and benefits
- uploading / Package dependencies and uploading
- release, uploading / Uploading the release and beta packages
- beta packages / Uploading the release and beta packages
- uploading, release state / Uploading the release and beta packages
- uploading, beta state / Uploading the release and beta packages
- installing / Installing and testing your package
- testing / Installing and testing your package
- installation, aspects / Installing and testing your package
- installation, automating / Automating package installation
- package dependencies
- about / Package dependencies and uploading, Optional package dependencies
- dynamic bindings / Dynamic bindings
- extension packages / Extension packages
- Packaging Guide / Features and benefits of managed packages
- packaging org
- versus sandbox and developer org / Packaging org versus sandbox versus developer org
- versus developer orgs, for Ant build script development / Developing in developer orgs versus packaging orgs
- Partner Account Manager / API governors and availability
- Partner API
- about / Platform APIs
- Partner Community / Becoming a Salesforce partner and benefits
- Partner Portal / Required organizations
- Partner Portal Developer Edition org
- performance
- managing / Managing performance and response times
- Permission Sets
- creating / Functional security
- considerations / Functional security
- permission sets / Installing and testing your package
- personas / Mapping out end user storage requirements
- picklists
- defining / Global Picklists
- PitStop Time / Profiling queries
- Plain Old Java Object (POJO)
- Plain Old Java Objects (POJO) / The Data Mapper (Selector) layer
- platform APIs
- about / Platform APIs
- Enterprise API / Platform APIs
- Partner API / Platform APIs
- REST API / Platform APIs
- Metadata API / Platform APIs
- Tooling API / Platform APIs
- Streaming API / Platform APIs
- Replication API / Platform APIs
- Bulk API / Platform APIs
- considerations / Considerations for working well with OK platforms APIs
- used for integration / Force.com platform APIs for integration
- Platform Cache
- about / Platform Cache
- reference link / Platform Cache
- Platform Encryption
- about / Encrypted fields
- considerations / Special considerations for Platform Encryption
- printable content
- generating / Generating printable content
- page language, overriding / Overriding the page language
- Process Builder
- about / Process Builder, Workflow and Flow
- extending / Extending Process Builder and Visualflow
- Invocable Method, versioning / Versioning Invocable Methods
- production implementation / Contract Driven Development
- profiles
- creating / Functional security
- Publisher Actions / Mobile application strategy
Q
- queries
- optimizing / Indexes, being selective, and query optimization
- indexes, leveraging / Ensuring queries leverage indexes
- profiling / Profiling queries
- skinny tables / Skinny tables
- large result sets, handling / Handling large result sets
- query limits
- managing / Managing limits
- Queue / Data security
- Queueables
- using / Queueables
R
- Race Data object
- creating, with Apex script / Using the Apex script to create the Race Data object
- Racing Overview Lightning App
- record
- identification / Record identification, uniqueness, and auto numbering
- uniqueness / Record identification, uniqueness, and auto numbering
- auto numbering / Record identification, uniqueness, and auto numbering
- external ID field / Unique and external ID fields
- unique ID field / Unique and external ID fields
- Auto Number fields, applying / Auto Number fields
- relationships / Record relationships
- referential integrity rule
- relationships
- about / Record relationships
- Master-Detail / Record relationships
- Lookup / Record relationships
- Remote Objects / Database transaction scope and client calls
- Replication API
- Report Designer / Custom reporting and the Analytics API
- required organization
- about / Required organizations
- Production/CRM Org / Required organizations
- AppExchange Publishing Org (APO) / Required organizations
- License Management Org (LMO) / Required organizations
- Trialforce Management Org (TMO) / Required organizations
- Trialforce Source Org (TSO) / Required organizations
- response times
- managing / Managing performance and response times
- monitoring, with Lightning Inspector / Lightning tools to monitor size and response times
- managing, with view state size / Visualforce Viewstate size
- component trees, considerations / Considerations for managing large component trees
- REST
- versus SOAP / SOAP versus REST
- REST API
- about / Platform APIs
- RESTful application APIs
- providing / Providing RESTful application APIs
- key aspects / Key aspects of being RESTful
- application resources / What are your application resources?
- HTTP methods, mapping / Mapping HTTP methods
- result sets
- handling / Handling large result sets
- 50k maximum results, processing in Apex / Processing 50k maximum result sets in Apex
- unlimited result sets, processing in Apex / Processing unlimited result sets in Apex
- Revolutions per Minute (RPM)
- role hierarchy / Data security
- rollup summaries
- limitation / Rollup summaries and limits
- reference link / Rollup summaries and limits
- rows
- versus columns / Columns versus rows
S
- Salesforce
- required organizations / Required organizations
- reference / Required organizations, Becoming a Salesforce partner and benefits
- Partner Community / Security review and benefits
- supported browsers, URL / Which devices should you target?
- Salesforce (CRM) / Reusing the existing Standard Objects
- Salesforce1 Mobile
- about / Building a basic Lightning user interface
- and Lightning Experience (LEX) / Lightning Experience and Salesforce1
- Salesforce API
- application access, versioning / Versioning application access through the Salesforce APIs
- URL / Force.com platform APIs for integration
- unlimited result sets, processing / Processing unlimited result sets using Salesforce APIs
- Salesforce Classic
- Salesforce Connect / External data sources
- Salesforce Connected Apps
- distributing / Distributing Salesforce Connected Apps
- Salesforce Data Loaders / Without a Unit Of Work
- Salesforce Developer Experience (DX)
- about / Salesforce Developer Experience (DX)
- Scratch orgs / Salesforce Developer Experience (DX)
- Heroku flow / Salesforce Developer Experience (DX)
- Salesforce Lightning Experience
- Salesforce Metadata API
- about / Automating package installation
- Salesforce Migration Toolkit / Automating package installation
- Salesforce Mobile Packs
- Salesforce Object Search Language (SOSL) / Special considerations for Platform Encryption
- about / SOSL and Aggregate SOQL queries
- Salesforce partner
- becoming / Becoming a Salesforce partner and benefits
- benefits / Becoming a Salesforce partner and benefits, Security review and benefits
- review / Security review and benefits
- Partner Community / Getting the best out of the Partner Community
- Salesforce Platform / Reusing the existing Standard Objects
- Salesforce REST API / Mobile application strategy
- Salesforce Security Review scanner
- Salesforce standard UIs
- about / Introducing Salesforce Standard UIs and Lightning
- leveraging / Leveraging the Salesforce standard UIs
- actions, overriding / Overriding standard Salesforce UI actions
- standard UIs, combining with custom UIs / Combining standard UIs with custom UIs
- extending / Extending the Salesforce standard UIs
- Visualforce pages / Visualforce Pages
- Lightning Components / Lightning Components
- sandbox / Uploading the release and beta packages
- versus developer org and packaging org / Packaging org versus sandbox versus developer org
- Savepoints / Execution context transaction management
- Schema Builder / Visualizing your object model
- Sector Times / Profiling queries
- security
- features / Understanding the available security features
- functional security / Understanding the available security features
- data security / Understanding the available security features
- sharing security / Execution context and security
- CRUD and FLS security / Execution context and security
- field-level security / Object and field-level security
- object level security / Object and field-level security
- enforcing, in Visualforce / Enforcing security in Visualforce
- enforcing, at runtime / Enforcing encapsulation and security at runtime
- Security Review
- about / The developer workflow
- Selector base class
- standard features / Standard features of the Selector base class
- field security, enforcing / Enforcing object and field security
- object security, enforcing / Enforcing object and field security
- default behavior / Default behavior
- default behavior, overriding / Overriding the default behavior
- ordering / Ordering
- Field Sets, using / Field Sets
- Multi-Currency / Multi-Currency
- Selector class
- template / The Selector class template
- Selector factory
- about / The Selector class template, Introducing the Selector factory
- SelectorFactory methods / SelectorFactory methods
- Selector layer
- tests, writing / Writing tests and the Selector layer
- Selector layer pattern
- Selector layer pattern, design guidelines
- implementing / Implementing design guidelines
- naming conventions / Naming conventions
- bulkification / Bulkification
- record order, consistency / Record order consistency
- fields, querying consistently / Querying fields consistently
- selector method
- unit testing / Unit Testing a Selector Method
- Selector pattern class / Validation on insert
- Selenium WebDriver
- about / Automated regression testing
- URL / Automated regression testing
- Sencha ExtJS / Considerations for using JavaScript libraries
- Separation of Concerns (SOC)
- about / Separation of Concerns
- Apex code, evolution / Apex code evolution
- in Apex / Separating concerns in Apex
- in Lightning Component JavaScript / Separation of concerns in Lightning Component JavaScript
- execution context logic, versus application logic concerns / Execution context logic versus application logic concerns
- incremental code reuse, improving / Improving incremental code reuse
- Service layer
- about / The Service layer
- reference link / The Service layer
- testing / Testing the Service layer
- mocking / Mocking the Service layer
- implementing / Calling the Service layer
- FormulaForce package, updating / Updating the FormulaForce package
- interactions, with Domain layer / Service layer interactions
- using / Using the Service layer and database access
- client-side logic, considerations / Considerations for client-side logic and Service layer logic
- service layer logic, considerations / Considerations for client-side logic and Service layer logic
- Service layer pattern
- service method
- unit testing / Unit Testing a Service Method
- services
- implementing / Services calling services
- setter methods / Other Dependency Injection approaches
- sharing rules / Data security
- enforcing / Sharing rules enforcement
- Single-page Application (SPA) / How does Lightning differ from other UI frameworks?
- Sites.com / Creating websites and communities
- skinny tables
- about / Skinny tables
- SOAP
- versus REST / SOAP versus REST
- SObjects
- SObject types
- Apex data types, combining with / Combining Apex data types with SObject types
- SOQL
- used, for testing Domain layer / Test methods using DML and SOQL
- SOQL FOR LOOP
- SOQL profiler / Using the Apex script to create the Race Data object
- Source Control
- using / Developing with Source Control
- repository, populating / Populating your Source Control repository
- folder structure, considering / Populating your Source Control repository
- / folder / Populating your Source Control repository
- /lib folder / Populating your Source Control repository
- /src folder / Populating your Source Control repository
- /source folder / Populating your Source Control repository
- repository, updating / Updating your Source Control repository
- browser-based development, using / Updating your Source Control repository, Browser-based development and Source Control
- desktop-based development, using / Updating your Source Control repository, Desktop-based development and Source Control
- browser and desktop-based development, using / Updating your Source Control repository
- releasing from / Releasing from Source Control
- Standalone Lightning App
- reference link / Building a basic Lightning user interface
- about / Building a basic Lightning user interface
- standard indexes
- about / Standard and custom indexes
- Standard Objects
- reusing / Reusing the existing Standard Objects
- usage considerations / Reusing the existing Standard Objects
- standard query logic
- implementing / Implementing the standard query logic
- Selector base class, standard features / Standard features of the Selector base class
- standard UIs / Introducing Salesforce Standard UIs and Lightning
- combining, with custom UIs / Combining standard UIs with custom UIs
- custom UIs, embedding / Embedding a custom UI in a standard UI
- embedding, in custom UIs / Embedding a standard UI in a custom UI
- state management / Execution context and state
- storage, types
- about / Understanding the different storage types
- data storage / Data storage
- file storage / File storage
- Streaming API
- about / Platform APIs
- Stub / Contract Driven Development
- stubbing code
- sub-select
- subscribers
- Auto Number Display Format, customizing / Subscribers customizing the Auto Number Display Format
- system administrator / The Ant build script to clean and build your application
- system testing
- versus unit testing / Unit testing versus system testing
T
- Technical Account Manager (TAM) / Your code and security review considerations
- template method pattern
- reference link / Routing trigger events to Domain class methods
- test-driven development (TDD) / Unit testing versus system testing
- test data
- creating, for volume testing / Creating test data for volume testing
- Race Data object, creating with Apex script / Using the Apex script to create the Race Data object
- Test Drive / Trialforce and Test Drive
- testing
- with Aura test framework / Testing
- testing, Domain layer
- about / Testing the Domain layer
- unit testing / Unit testing
- using DML and SOQL / Test methods using DML and SOQL
- using Domain class methods / Test methods using the Domain class methods
- third caller type, Domain layer
- Apex Triggers / Calling the Domain layer
- Service layer / Calling the Domain layer
- tokens / Component CSS (.css)
- Tooling API
- about / Platform APIs
- Tooling APIs
- toolkit for .NET
- transaction management / Transaction management
- translation
- about / Localization and translation, Translation
- Trialforce / Trialforce and Test Drive
U
- Unified Modeling Language (UML)
- Uniform Resource Identifier (URI)
- Unit Of Work / Execution context transaction management, Defining and passing data, Implementing custom Domain logic, Using external references in Apex DML
- DML, handling / Handling DML with the Unit Of Work pattern
- URL / Handling DML with the Unit Of Work pattern
- avoiding / Without a Unit Of Work
- using / With Unit Of Work
- scope, defining / The Unit Of Work scope
- considerations / Unit Of Work special considerations
- unit testing
- versus system testing / Unit testing versus system testing
- Domain layer / Unit testing
- reference link / Unit testing
- comparing, with integration testing / Comparing Unit testing and Integration Testing
- about / Introducing Unit Testing, Dependency Injection, Mocking, and Unit Testing
- reviewing / Deciding what to test and what not to test for in a Unit test
- implementing, with CDI and mocking / Implementing Unit tests with CDI and Mocking
- with Apex Stub API / Writing Unit Tests with the Apex Stub API
- controller method / Unit Testing a Controller Method
- service method / Unit Testing a Service Method
- domain method / Unit Testing a Domain method
- selector method / Unit Testing a Selector Method
- unlimited result sets
- processing / Processing unlimited result sets in Apex
- Race Data, generating / Generating more Race Data
- Visualforce, leveraging / Leveraging Visualforce and the Apex read-only mode
- Apex read-only mode, leveraging / Leveraging Visualforce and the Apex read-only mode
- processing, with Salesforce API / Processing unlimited result sets using Salesforce APIs
- upgradable components
- about / Packaging and upgradable components
- custom field / Custom field – picklist values
- Global Picklists / Global Picklists
- upgrades, automating with Metadata API / Automating upgrades with the Salesforce Metadata API
- Usage Metrics Visualization / Customer metrics
- user interface, Lightning
- building / Building a basic Lightning user interface
- Lightning Design System (LDS) / Introduction to Lightning Design System
- component, building / Building your first component
- differentiating, from other UI frameworks / How does Lightning differ from other UI frameworks?
- Utility Bar
V
- versioning
- about / Versioning
- API definition / Versioning the API definition
- application access / Versioning application access through the Salesforce APIs
- API functionality / Versioning the API functionality
- view state size
- response times, managing with / Visualforce Viewstate size
- Visualflow
- extending / Extending Process Builder and Visualflow
- Visual Flow tool
- Visualforce
- about / Localization, Visualforce
- generic Compliance Verification UI / Generic Compliance Verification UI with Visualforce
- considering, over Lightning Framework / Why consider Visualforce over the Lightning Framework?
- security, enforcing / Enforcing security in Visualforce
- and Lightning Out / Lightning Out and Visualforce
- volume testing
- test data, creating / Creating test data for volume testing
- about / Volume testing
W
- W3C / Client communication options
- web-based application
- development considerations, for device support / Which devices should you target?
- web content
- creating, with Force.com / Creating websites and communities
- creating, with Sites.com / Creating websites and communities
- Web Service Connector (WSC)
- Web Service Definition Language (WSDL) / Options for replicating and archiving data
- websites
- creating / Creating websites and communities
- Workflow
- wrapper class approach / Domain classes in Apex compared to other platforms
X
- XML metadata / Extension packages