Index
A
- action attribute
- used, for executing code on page load / Executing the code on page load with the action attribute
- action methods
- versus JavaScript Remoting / Action methods versus JavaScript Remoting
- Advanced Encryption Standard (AES) / Encrypted fields
- Aggregate SOQL queries / SOSL and Aggregate SOQL queries
- Aloha / Security review and benefits
- Amazon EC2 / The developer workflow
- AngularJS / Client-side alternatives to Visualforce UI components
- Anonymous Apex prompt / Generating more Race Data
- Ant
- about / Development workflow and infrastructure
- Tooling API, leveraging from / Leveraging the Metadata API and Tooling APIs from Ant
- Metadata API, leveraging from / Leveraging the Metadata API and Tooling APIs from Ant
- Ant build script
- used, for building application / The Ant build script to clean and build your application
- used, for cleaning application / The Ant build script to clean and build your application
- developing, in developer org / Developing in developer orgs versus packaging orgs
- updating, for CI / Updating the Ant build script for CI
- Apache Ant open source tool / The developer workflow
- Apache Ant v1.6
- Apex / Packaging and upgradable components
- need for / Where is Apex used?
- Anonymous Apex / Where is Apex used?
- Controller action method / Where is Apex used?
- Controller remote action / Where is Apex used?
- Trigger / Where is Apex used?
- Batch Apex / Where is Apex used?
- scheduler / Where is Apex used?
- Inbound messaging / Where is Apex used?
- Flow plugin / Where is Apex used?
- REST API / Where is Apex used?
- web service / Where is Apex used?
- separation of concerns (SOC) / Separating concerns in Apex
- running, in asynchronous mode / Running Apex in the asynchronous mode
- Apex, running in asynchronous mode
- about / Running Apex in the asynchronous mode
- @future, utilizing / @future
- Batch Apex, utilizing / Batch Apex
- Apex API behavior
- versioning / Versioning Apex API behavior
- Apex application APIs
- providing / Providing Apex application APIs
- calling / Calling an application API from Apex
- modifying / Modifying and depreciating the application API
- depriciating / Modifying and depreciating the application API
- versioning / Versioning Apex API definitions
- Apex API behavior, versioning / Versioning Apex API behavior
- Apex Class / Encapsulating an object's behavior in code
- Apex classes / Introducing the Selector layer pattern
- Apex Commons library, FinancialForce.com / Introducing the FinancialForce.com Apex Commons library
- Apex compiler / Domain classes in Apex compared to other platforms
- Apex data types
- combining, with SObject types / Combining Apex data types with SObject types
- Apex Debug log / Exploring execution contexts
- Apex Describe facility / Your code and security review considerations
- Apex DML
- external references, using / Using external references in Apex DML
- Apex Domain classes
- comparing, to other platforms / Domain classes in Apex compared to other platforms
- Apex Enum types
- JavaScript Remoting, applying to / Considerations for client-side logic and Service layer logic
- Apex exception class / Translation and localization
- Apex governors
- namespaces / Apex governors and namespaces
- scope / The namespaces and governor scope
- deterministic governors / Deterministic and non-deterministic governors
- non-deterministic governors / Deterministic and non-deterministic governors
- Apex inheritance / Domain classes in Apex compared to other platforms
- Apex interface
- application logic, extending with / Extending the application logic with Apex Interfaces
- Apex Interface
- Apex Interface example
- about / An Apex Interface example
- generic service, defining / Step 5 – defining a generic service
- Domain class interface, implementing / Step 6 – implementing the Domain class interface
- Domain class factory pattern / 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
- Apex Metadata API library
- Apex property syntax / Defining and passing data
- Apex REST APIs
- versioning, need for / Is it worth versioning Apex REST APIs?
- Apex Scheduled job / Auto Number fields
- Apex script
- used, for creating Race Data object / Using the Apex script to create the Race Data object
- Apex Trigger / Domain class template
- Apex Trigger event handling
- about / 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 events / Interpreting the Domain layer in Force.com
- Apex Trigger execution / Custom Buttons and Related lists
- Apex Triggers / Custom settings storage, Alignment with Force.com extensibility features
- Apex Visualforce Controller / Mocking Selectors
- Apex wrapper
- API definition
- versioning / Versioning the API definition
- API functionality
- versioning / Versioning the API functionality
- API governors / API governors and availability
- AppExchange package
- AppExchange Publishing Org (APO) / Required organizations, Introduction to AppExchange and listings
- 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
- integration needs / What are your application's integration needs?
- extensibility needs / What are your applications extensibility needs?
- logic, extending with Apex interfaces / Extending the application logic with Apex Interfaces
- Application.Selector.setMock
- used, for writing test / Step 4 – writing a test with Application.Selector.setMock
- application access
- versioning, through Salesforce APIs / Versioning application access through the Salesforce APIs
- Application Cache / Custom settings storage
- application component / Browser-based development and Source Control
- Application integration APIs
- about / Application integration APIs
- application logic concerns
- versus execution context logic versus / Execution context logic versus application logic concerns
- application resources
- application vocabulary of terms / Naming conventions
- aspects, for developing libraries
- developer flow / Client-side alternatives to Visualforce UI components
- security / Client-side alternatives to Visualforce UI components
- testing frameworks / Client-side alternatives to Visualforce UI components
- async design considerations
- background work, types / General async design considerations
- user experience / General async design considerations
- messaging / General async design considerations
- logging / General async design considerations
- concurrency / General async design considerations
- error recovery / General async design considerations
- asynchronous execution contexts
- about / Asynchronous execution contexts
- async design considerations / General async design considerations
- Apex, running in asynchronous mode / Running Apex in the asynchronous mode
- asynchronous processing, in Force.com
- Attachments / File storage
- Aura
- about / Salesforce Aura
- URL / Salesforce Aura
- automated regression testing
- about / Automated regression testing
- implementing, considerations / Automated regression testing
- Auto Number Display Format
- customizing, by subscribers / Subscribers customizing the Auto Number Display Format
- Auto Number field / Creating test data for volume testing
- Auto Number fields
- about / Auto Number fields
- Display Format, customizing / Subscribers customizing the Auto Number Display Format
B
- background work, types
- application / General async design considerations
- end user / General async design considerations
- Batch Apex / Execution contexts, Introducing the Selector layer pattern
- about / Batch Apex
- implementing / Batch Apex
- utilizing, implementation guidelines / Batch Apex
- job performances / 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
- Batch Apex jobs performances
- start method, using / Performance of Batch Apex jobs
- calibrating / Performance of Batch Apex jobs
- frequency / Performance of Batch Apex jobs
- benefits, security review
- 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
- beta packages / Uploading the release and beta packages
- browser-based development
- using, with Source Control repository / Browser-based development and Source Control
- bulk API / Options for replicating and archiving data
- Bulk API / Platform APIs
- bulkification / Bulkification
- bulkified implementations / Domain classes in Apex compared to other platforms
C
- cache attribute
- used, for caching content / Caching content with the cache and the expires attributes
- Chatter
- enabling / Social features and mobile
- Chatter feed / Mobile strategy
- Chatter Files / File storage
- Chatter post / Visualizing your object model
- CheckMarx
- CI
- hooking up / Hooking up Continuous Integration
- about / The Continuous Integration process
- process / The Continuous Integration process
- Ant build script, updating for / Updating the Ant build script for CI
- Jenkins CI server, updating / Installing, configuring, and testing the Jenkins CI server
- Jenkins CI server, installing / Installing, configuring, and testing the Jenkins CI server
- Jenkins CI server, configuring / Installing, configuring, and testing the Jenkins CI server
- exploring / Exploring Jenkins and CI further
- CI process
- class names / Naming conventions
- client-managed state
- versus server-managed state / Client-managed state versus server-managed state
- client-side logic
- considerations / Considerations for client-side logic and Service layer logic
- client communication layers
- about / Client communication layers
- options / Client communication options
- API governors / API governors and availability
- availability / API governors and availability
- database transaction scope / Database transaction scope and client calls
- client calls / Database transaction scope and client calls
- client communication options
- Visualforce Components / Client communication options
- Visualforce JavaScript Remoting / Client communication options
- Visualforce JavaScript Remote Objects / Client communication options
- Salesforce REST/SOAP APIs / Client communication options
- Salesforce Streaming API / Client communication options
- AJAX Toolkit / Client communication options
- Analytics API / Client communication options
- columns
- versus rows / Columns versus rows
- common Apex interface / Introducing the Selector factory
- compliance application framework
- creating / Creating a compliance application framework
- compliance framework implementation
- summarizing / Summarizing compliance framework implementation
- ComplianceService.verify method / Calling an application API from Apex
- components
- adding, to managed package / Adding components to the package
- composition approach / Domain classes in Apex compared to other platforms
- compound services / Compound services
- concrete type / Domain classes in Apex compared to other platforms
- considerations, Platform APIs
- Custom Objects, naming / Considerations when naming objects and fields
- fields, naming / Considerations when naming objects and fields
- label consistency / Considerations when naming objects and fields
- API name consistency / Considerations when naming objects and fields
- Naming Relationships / Considerations when naming objects and fields
- Apex Triggers bulkification / Considerations when naming objects and fields
- constructor / Domain class template
- contentType attribute
- used, for creating Download button / Creating a Download button with the contentType attribute
- Contestant object / Columns versus rows
- contexts, of Domain class callers
- Apex Triggers / Calling the Domain layer
- Service layer / Calling the Domain layer
- Domain layer / Calling the Domain layer
- Continuous Integration (CI) / Security review and benefits
- Contract Driven Development
- about / Contract Driven Development
- create event / Encapsulating an object's behavior in code
- Cross-site Request Forgery (CSRF) security
- CRUD (Create, Read, Update, and Delete) / Enforcing object security
- CRUD and FLS Enforcement
- CRUD and FLS security / Execution context and security
- CRUD operations / Client communication layers
- Custom Button
- about / Custom Buttons and Related lists
- creating / Custom Buttons and Related lists
- custom data set
- using, with custom Selector method / A custom Selector method with a custom data set
- customer licenses
- customer metrics / Customer metrics
- customer support
- providing / Providing support
- Custom Field label / Translation and localization
- custom fields
- features / Understanding the custom field features
- custom fields, features
- about / 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
- custom indexes
- about / Standard and custom indexes
- customizable user interfaces
- building / Building customizable user interfaces, Visualforce
- layouts / Layouts
- Visualforce pages / Visualforce
- Custom Labels
- creating / Translation
- Custom Object Action overrides / Overriding the standard Salesforce UI
- Custom Objects / Introducing the book's sample application, Naming conventions
- Custom Publisher Actions / Custom Publisher Actions
- custom query logic
- implementing / Implementing the custom query logic
- custom Selector method / A basic custom Selector method
- custom Selector method, using with sub-select / A custom Selector method with sub-select
- 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
- SOSL queries / SOSL and Aggregate SOQL queries
- Aggregate SOQL queries / SOSL and Aggregate SOQL queries
- Custom Reporting / Custom Reporting and the Analytics API
- custom Selector method
- about / A basic custom Selector method
- using, with sub-select / A custom Selector method with sub-select
- 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 Selector method, using with custom data set
- Apex data types, combining with SObject types / Combining Apex data types with SObject types
- custom settings
- creating / Custom settings storage
D
- @Depreciated annotation / Modifying and depreciating the application API
- @Depricated flag / Modifying and depreciating the application API
- data
- importing / Importing and exporting data
- exporting / Importing and exporting data
- replicating, options / Options for replicating and archiving data
- archiving, options / Options for replicating and archiving data
- defining / Defining and passing data
- passing / Defining and passing data
- data consistency / Introducing the Selector layer pattern
- Data Loader tools / Using external references in Apex DML
- Data Mapper (Selector) layer, Enterprise Application Architecture patterns
- URL / The Data Mapper (Selector) layer
- about / The Data Mapper (Selector) layer
- Apex Commons library, FinancialForce.com / Introducing the FinancialForce.com Apex Commons library
- data security
- about / Understanding the available security features, Data security
- security review considerations / Your code and security review considerations
- code review considerations / Your code and security review considerations
- data storage
- about / Data storage
- columns / Columns versus rows
- rows / Columns versus rows
- object model, visualizing / Visualizing your object model
- custom settings storage / Custom settings storage
- Data Transformation Objects (DTO) / The Data Mapper (Selector) layer
- debugging aspect / The developer workflow
- debug log filters / The developer workflow
- default field values / Default field values
- default order, selectSObjectsById method / Ordering
- delete event / Encapsulating an object's behavior in code
- DELETE method / Mapping HTTP methods
- design guidelines, Domain layer
- implementing / Implementation design guidelines
- design guidelines, Selector layer
- implementing / Implementing design guidelines
- design guidelines implementation, Domain layer
- 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
- design guidelines implementation, Selector layer
- naming conventions / Naming conventions
- bulkification / Bulkification
- record order consistency / Record order consistency
- fields, querying / Querying fields consistently
- design guidelines implementations
- about / Implementation of design guidelines
- naming conventions / Naming conventions
- bulkification / Bulkification
- data, defining / Defining and passing data
- data, passing / Defining and passing data
- transaction management / Transaction management
- compound services / Compound services
- checklist / A quick guideline checklist
- desktop-based development
- using, with Source Control repository / Desktop-based development and Source Control
- Detail page / Overriding the standard Salesforce UI
- Detail Pages / Creating a compliance application framework
- deterministic governors / Deterministic and non-deterministic governors
- Developer Console / Demonstrating a large component tree
- Developer Console Preview feature / Demonstrating a large component tree
- Developer Mode / Demonstrating a large component tree
- developer org
- versus sandbox orgs / Packaging org versus sandbox versus developer org
- versus packaging org / Packaging org versus sandbox versus developer org, Developing in developer orgs versus packaging orgs
- URL / Creating and preparing your developer orgs
- creating / Creating and preparing your developer orgs
- preparing / Creating and preparing your developer orgs
- Developer Workbench tool / Profiling queries
- developer workflow
- about / The developer workflow
- diagrammatic representation / The developer workflow
- Developer X
- about / Defining the Developer X persona
- calling APIs on platform / Developer X calling your APIs on-platform
- calling APIs off platform / Developer X calling your APIs off-platform
- development tools, Source Control
- GitHub / Developing with Source Control
- Apache Ant v1.6 or greater / Developing with Source Control
- Force.com Migration Toolkit / Developing with Source Control
- MavensMate / Developing with Source Control
- development workflow
- about / Development workflow and infrastructure
- packaging org, versus developer org / Packaging org versus sandbox versus developer org
- developer org, versus packaging org / Packaging org versus sandbox versus developer org
- sandbox orgs, versus developer org / Packaging org versus sandbox versus developer org
- devices, for target
- determining / What devices should you target?
- DML
- handling, with Unit of Work pattern / Handling DML with the Unit Of Work pattern
- used, for Apex Trigger method testing / Test methods using DML and SOQL
- DNF (Did not Finish) / Custom Publisher Actions
- docType attribute / HTML5 and the docType attribute
- Domain class factory pattern, Apex Interface example
- Domain class interface, Apex Interface example
- Domain class methods
- Domain class template / Domain class template
- Domain Custom logic
- implementing / Implementing custom Domain logic
- Domain layer
- URL / Introducing the Domain layer pattern
- interpreting, in Force.com / Interpreting the Domain layer in Force.com
- design guidelines, implementing / Implementation design guidelines
- testing / Testing the Domain layer
- unit testing / Unit testing
- Apex Trigger methods, testing with DML / Test methods using DML and SOQL
- Apex Trigger methods, testing with SOQL / Test methods using DML and SOQL
- custom Domain class methods, testing with / Test methods using the Domain class methods
- Domain class methods, using / Test methods using the Domain class methods
- calling / Calling the Domain layer
- Domain layer interactions
- about / Domain layer interactions
- Domain layer logic / Custom Buttons and Related lists
- Domain layer pattern
- about / Introducing the Domain layer pattern
- objects behavior, encapsulating in code / Encapsulating an object's behavior in code
- interpreting, in Force.com / Interpreting the Domain layer in Force.com
- Apex Domain classes, comparing with the other platforms / Domain classes in Apex compared to other platforms
- Domain Model layer, Enterprise Application Architecture patterns
- URL / The Domain Model layer
- about / The Domain Model layer
- Domain Trigger logic
- implementing / Implementing Domain Trigger logic
- Domain Trigger logic implementation
- 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
- Download button
- creating, with contentType attribute / Creating a Download button with the contentType attribute
- drivers / Object-oriented programming
- dummy implementation / Contract Driven Development
- Dynamic Apex / Dynamic Apex and Visualforce
- Dynamic Apex and Dynamic SOQL / Introducing the Selector layer pattern
- Dynamic Apex type
- Dynamic SOQL / The Selector class template
E
- e-mail
- customizing, with e-mail templates / E-mail customization with e-mail templates
- E-mail templates / Alignment with Force.com extensibility features
- e-mail templates
- used, for e-mail customization / E-mail customization with e-mail templates
- encrypted fields / Encrypted fields
- end user storage requirements
- Enterprise and Developer Edition orgs / Creating websites
- Enterprise API / Platform APIs
- Enterprise Application Architecture patterns
- about / Patterns of Enterprise Application Architecture
- URL / 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
- Enterprise applications software / Introducing the book's sample application
- Entity Relationship Diagram (ERD) / Visualizing your object model
- enum / Translation and localization
- Execute Anonymous prompt / Using the Apex script to create the Race Data object
- 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
- security features / Execution context and security
- transaction management / Execution context transaction management, Execution context logic versus application logic concerns
- error handling / Execution context logic versus application logic concerns
- number of records / Execution context logic versus application logic concerns
- state management / Execution context logic versus application logic concerns
- security / Execution context logic versus application logic concerns
- Execution Governors and Limits
- expires attributes
- used, for caching content / Caching content with the cache and the expires attributes
- extensibility, Force.com
- extensibility needs
- Extension Controller / Hybrid standard and Visualforce UIs
- extension packages / Package types and benefits, Extension packages
- extensions
- external data sources / External data sources
- external identifiers / Unique and external ID fields
- external ID fields
- adding / Unique and external ID fields
F
- / folder
- @future
- utilizing / @future
- Factory pattern
- features, managed packages
- Intellectual Property (IP) protection / Features and benefits of managed packages
- naming scope / Features and benefits of managed packages
- governor scope / Features and benefits of managed packages
- versioning / Features and benefits of managed packages
- upgrades / Features and benefits of managed packages
- fflib_SObjectSelector class / Implementing the custom query logic
- FIA Super License / Object-oriented programming
- field-level security / Field-level security
- field-level security (FLS) / Your code and security review considerations
- field level security enforcements / Field-level security
- Field Sets / Overriding the standard Salesforce UI, Alignment with Force.com extensibility features
- Field Sets fields, selectSObjectsById method / Field Sets
- file storage
- about / File storage
- filter criteria / Factors affecting the use of indexes
- filters, custom filed / Lookup options, filters, and layouts
- FinancialForce.com
- FinancialForce.com Apex Enterprise Patterns library / Domain class template
- FinancialForce.com Enterprise Apex Patterns library / The Selector class template
- FinancialForce Apex Enterprise Pattern / With Unit Of Work
- FinancialForce Apex Enterprise Patterns library / With Unit Of Work
- fly-by reviews approach / Naming conventions
- Force.com
- Domain layer, interpreting in / Interpreting the Domain layer in Force.com
- Force.com Migration Toolkit / Developing with Source Control
- Force.com platform APIs
- for integration / Force.com platform APIs for integration
- Force.com Web Service Connector (WSC) / Force.com platform APIs for integration
- Formula1 motor car / Introducing the book's sample application
- Formula1 rules and regulations / Encapsulating an object's behavior in code
- Formula fields / Columns versus rows
- FormulaForce application
- FormulaForce package
- updating / Updating the FormulaForce package
- FormulaForce package, Domain layer
- updating / Updating the FormulaForce package
- FormulaForce package, Selector layer
- implementing / Updating the FormulaForce package
- FormulaForce package, Service layer
- updating / Updating the FormulaForce package
- FormulaForce package, User Interface
- updating / Updating the FormulaForce package
- functional security
- about / Understanding the available security features
- Permission Sets, creating / Functional security
- profiles, creating / Functional security
- Permission Sets, designing / Functional security
- code review considerations / Your code and security review considerations
- security review considerations / Your code and security review considerations
G
- generic service, Apex Interface example
- defining / Step 5 – defining a generic service
- implementing / Step 8 – implementing a generic service
- using, from generic controller / Step 9 – using the generic service from a generic controller
- GET method / Mapping HTTP methods
- GitFlow / The developer workflow
- GitHub
- GitHub Salesforce Deployment Tool
- global components, release package / Uploading the release and beta packages
H
- heap / Execution context and state, Querying fields consistently
- heap governor / Processing 50k maximum results in Apex
- HTTP GET / Client communication layers
- HTTP methods
- mapping / Mapping HTTP methods
- HTTP POST / Client communication layers
- HTTP protocol / Client communication layers
- hybrid mobile application / Offline Visualforce pages with the manifest attribute
- hybrid standard
- creating / Hybrid standard and Visualforce UIs
I
- Independent Software Vendor (ISV) / Becoming a Salesforce partner and benefits
- indexes
- about / Indexes, being selective, and query optimization
- standard indexes / Standard and custom indexes
- custom indexes / Standard and custom indexes
- queries leverage indexes, ensuring / Ensuring queries leverage indexes
- using, factors / Factors affecting the use of indexes
- references / Factors affecting the use of indexes
- queries, profiling / Profiling queries
- inner class names / Naming conventions
- integration
- Force.com platform APIs for / Force.com platform APIs for integration
- integration needs
- internal view state / Page response time and components
- Internet of Things (IoT)
- about / Defining the Developer X persona
- ISVForce Guide (Packaging Guide)
- iterator limits / Visualforce SOQL, iterator limits, and the readOnly attribute
J
- JavaScript Remote Objects
- JavaScript Remoting / Installing and testing your package
- about / API governors and availability
- versus action methods / Action methods versus JavaScript Remoting
- combining, with action methods / Mixing the use of action methods and JavaScript Remoting
- applying, to Service layer / Applying JavaScript Remoting to the Service layer
- using / Leveraging Visualforce and the Apex read-only mode
- Jenkins CI server
- installing / Installing, configuring, and testing the Jenkins CI server
- URL / Installing, configuring, and testing the Jenkins CI server
- configuring / Installing, configuring, and testing the Jenkins CI server
- testing / Installing, configuring, and testing the Jenkins CI server
- exploring / Exploring Jenkins and CI further
L
- /lib folder
- language attribute
- used, for overriding page language / Overriding the language of the page with the language attribute
- large component tree
- demonstrating / Demonstrating a large component tree
- managing, considerations / Considerations for managing large component trees
- large result sets
- unlimited result sets, processing / Processing unlimited result sets in Apex
- large result sets, Apex
- handling / Handling large result sets
- 50k maximum results, processing / Processing 50k maximum results in Apex
- layout component / Browser-based development and Source Control
- layouts, custom filed / Lookup options, filters, and layouts
- layouts, customizable user interfaces
- Leads tab / Trialforce and Test Drive
- License Management Org (LMO) / Required organizations
- Licenses tab / The Licenses tab and managing customer licenses
- licensing
- about / Licensing
- Licenses tab / The Licenses tab and managing customer licenses
- customer licenses, managing / 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
- List View / Custom settings storage
- List View layouts / Overriding the standard Salesforce UI
- LMA
- about / Licensing
- localization
- about / Localization, Translation and localization
- localization requirements
- considering / Translation and localization
- logging solutions / Visualizing your object model
- log table / Execution context logic versus application logic concerns
- Lookup field / Domain layer interactions
- lookup filters / Lookup options, filters, and layouts
- lookup options, custom fields / Lookup options, filters, and layouts
- Lookup relationships, Salesforce / Record relationships
M
- managed package
- about / Package types and benefits
- features / Features and benefits of managed packages
- benefits / Features and benefits of managed packages
- creating / Creating your first managed package, Creating the package and assigning it to the namespace
- package namespace, setting / Setting your package namespace
- assigning, to namespace / Creating the package and assigning it to the namespace
- components, adding to / Adding components to the package
- extension packages / Extension packages
- managers / Mapping out end user storage requirements
- manifest attribute
- about / Offline Visualforce pages with the manifest attribute
- used, for offline web pages / Offline Visualforce pages with the manifest attribute
- Master-Detail relationships, Salesforce / Record relationships
- MavensMate / Client-side alternatives to Visualforce UI components, Developing with Source Control
- messaging and logging, considerations
- Custom Object logging / General async design considerations
- unhandled exceptions / General async design considerations
- notifications / General async design considerations
- Metadata API / Platform APIs
- leveraging, from Ant / Leveraging the Metadata API and Tooling APIs from Ant
- method names / Naming conventions
- Migration Toolkit / Development workflow and infrastructure
- mobile
- about / Social features and mobile
- mobile strategy / Mobile strategy
- mocking / Mocking the Service layer
- mocking approach / Writing tests and the Selector layer
- mock Selector class
- creating / Step 3 – creating a mock Selector class
- Model View Controller (MVC) / Client-side alternatives to Visualforce UI components
- Multi-Currency feature, selectSObjectsById method / Multi-Currency
N
- .Net
- namespaces
- assigning / Setting your package namespace
- managed package, setting up / Creating the package and assigning it to the namespace
- naming conventions, design guidelines implementations
- about / Naming conventions
- acronyms, avoiding / Naming conventions
- class names / Naming conventions
- method names / Naming conventions
- parameter names / Naming conventions
- parameter types / Naming conventions
- inner class names / Naming conventions
- data, defining / Defining and passing data
- data, passing / Defining and passing data
- SObjects, using / Considerations when using SObjects in the Service layer interface
- compound services / Compound services
- naming conventions, Domain layer design guidelines
- acronyms, avoiding / Naming conventions
- class names / Naming conventions
- method names / Naming conventions
- parameter names / Naming conventions
- parameter types / Naming conventions
- inner classes / Naming conventions
- interfaces / Naming conventions
- naming conventions, Selector layer design guidelines
- class names / Naming conventions
- method names / Naming conventions
- method signatures / Naming conventions
- newInstance method
- non-deterministic governors / Deterministic and non-deterministic governors
- non-upgradable components
- nonselective query / Ensuring queries leverage indexes
O
- object-orientated programming (OOP) / Apex code evolution
- about / Encapsulating an object's behavior in code, Object-oriented programming
- compliance application framework, creating / Creating a compliance application framework
- Apex Interface example / An Apex Interface example
- Object Read Security / Security
- Object Relational Mapping (ORM) / Introducing the Domain layer pattern
- object security
- enforcing / Enforcing object security
- objects behavior
- encapsulating, in code / Encapsulating an object's behavior in code
- outbound messaging / Options for replicating and archiving data
P
- package
- about / Package types and benefits
- dependencies / Package dependencies and uploading
- release, uploading / Uploading the release and beta packages
- beta packages / Uploading the release and beta packages
- release packages / Uploading the release and beta packages
- beta packages / Uploading the release and beta packages
- installing / Installing and testing your package
- testing / Installing and testing your package
- package Apex developers
- key governors / Key governors for Apex package developers
- package dependencies
- options / Optional package dependencies
- Package dependencies / Reusing the existing Standard Objects
- package dependencies, options
- Dynamic Apex / Dynamic Apex and Visualforce
- Visualforce / Dynamic Apex and Visualforce
- extension packages / Extension packages
- package installation
- package overview step / Installing and testing your package
- Connected App and Remote Access / Installing and testing your package
- Approve Package API Access step / Installing and testing your package
- security configuration step / Installing and testing your package
- automating / Automating package installation
- package namespace
- setting up / Setting your package namespace
- packaging code
- about / The packaging code
- Apex classes / The packaging code
- packaging components
- packaging org / Introducing the book's sample application, Creating your first managed package, Updating the FormulaForce package
- versus developer org / Packaging org versus sandbox versus developer org, Developing in developer orgs versus packaging orgs
- versus sandbox orgs / Packaging org versus sandbox versus developer org
- PageReference.getContentAsPDF method / Generating PDF content with the renderAs attribute
- page response time
- about / Page response time and components
- large component tree, demonstrating / Demonstrating a large component tree
- parameter names / Naming conventions
- Partner Account Manager / API governors and availability
- Partner API / Platform APIs
- Partner Community
- Partner Developer Edition orgs / Becoming a Salesforce partner and benefits
- Partner Portal Developer Edition org / Processing 50k maximum results in Apex
- Partner Portal website / Required organizations
- PATCH method / Mapping HTTP methods
- PDF content
- generating, with renderAs attribute / Generating PDF content with the renderAs attribute
- permission sets / Installing and testing your package
- Permission Sets
- creating / Functional security
- designing, requisites / Functional security
- FormulaForce - Race Management / Functional security
- FormulaForce - Race Management - Update DNF Status / Functional security
- FormulaForce - Race Analytics / Functional security
- personas / Mapping out end user storage requirements
- picklist values / Custom field – picklist values
- PitStop Time / Profiling queries
- Plain Old Java Object (POJO) approach / Introducing the Selector layer pattern
- Plain Old Java Objects (POJO) / The Data Mapper (Selector) layer
- platform alignment
- platform APIs
- about / Platform APIs
- Enterprise API / Platform APIs
- Partner API / Platform APIs
- REST API / Platform APIs
- Tooling API / Platform APIs
- Metadata API / Platform APIs
- Streaming API / Platform APIs
- Replication API / Platform APIs
- Bulk API / Platform APIs
- object naming, considerations / Considerations when naming objects and fields
- field naming, considerations / Considerations when naming objects and fields
- POST method
- versus PUT method / Mapping HTTP methods
- private listing / Introduction to AppExchange and listings
- Production / CRM Org / Required organizations
- production implementation / Contract Driven Development
- Professional Edition / API governors and availability
- profiles / Functional security
- protected keyword / Services calling services
- public methods / Encapsulating an object's behavior in code
- Public repository / Populating your Source Control repository
- Publisher Action / Custom Publisher Actions
- Publisher Actions / Mobile strategy
- PUT method
- versus POST method / Mapping HTTP methods
Q
- Qualification Lap child object / Columns versus rows
- queries
- profiling / Profiling queries
- queries leverage indexes
- ensuring / Ensuring queries leverage indexes
- QueryLocator / Which type of Selector methods cannot be mocked?
- query optimization / Indexes, being selective, and query optimization
- Queue / Data security
R
- Race Data
- generating / Generating more Race Data
- Race Data object
- creating, Apex script used / Using the Apex script to create the Race Data object
- RaceDataSelector class / Batch Apex
- race object layout / Custom Buttons and Related lists
- RaceService.processData method / Batch Apex
- race strategists / Mapping out end user storage requirements
- readOnly attribute / Visualforce SOQL, iterator limits, and the readOnly attribute
- Recycle Bin / Generating more Race Data
- referential integrity rule / Lookup options, filters, and layouts
- Related lists / Custom Buttons and Related lists
- relationships, Salesforce
- Master-Detail / Record relationships
- Lookup / Record relationships
- limits / Record relationships
- referential integrity features / Record relationships
- release packages / Uploading the release and beta packages
- release upload / Uploading the release and beta packages
- Remote Objects / API governors and availability, Database transaction scope and client calls
- renderAs attribute
- used, for generating PDF content / Generating PDF content with the renderAs attribute
- Replication API / Platform APIs
- replication API / Options for replicating and archiving data
- report charts / Layouts
- Report Designer / Custom Reporting and the Analytics API
- REST
- versus SOAP / SOAP versus REST
- REST API / Platform APIs, Custom Reporting and the Analytics API
- REST APIs
- versioning / Versioning REST APIs
- REST application APIs
- about / Providing REST application APIs
- calling / Calling your REST application APIs
- RESTful
- about / Key aspects of being RESTful
- RESTful application APIs
- providing / Providing RESTful application APIs
- role hierarchy / Data security
- Rollup summary option / Rollup summaries and limits
- rows
- versus columns / Columns versus rows
S
- /source (alternative) folder
- /src folder
- Salesforce
- URL, for login / Becoming a Salesforce partner and benefits
- Salesforce (CRM) / Reusing the existing Standard Objects
- Salesforce Analytics API / Custom Reporting and the Analytics API
- Salesforce APIs
- application access, versioning through / Versioning application access through the Salesforce APIs
- used, for processing unlimited result sets / Processing unlimited result sets using the Salesforce APIs
- Salesforce Data Loaders / Without a Unit Of Work
- Salesforce Metadata API / Automating package installation
- URL / Automating package installation
- used, for upgrade automation / Automating upgrades with the Salesforce Metadata API
- Salesforce Migration Toolkit / Automating package installation
- Salesforce Mobile Packs
- URL / Mobile strategy
- Salesforce organizations
- about / Required organizations
- URL / Required organizations
- Salesforce partner
- becoming / Becoming a Salesforce partner and benefits
- Salesforce Partner Program
- Salesforce Platform / Reusing the existing Standard Objects
- Salesforce Reporting engine / Custom Reporting and the Analytics API
- Salesforce REST API / Mobile strategy
- Salesforce standard UI
- leveraging / Leveraging the Salesforce standard UI
- overriding / Overriding the standard Salesforce UI
- hybrid standard / Hybrid standard and Visualforce UIs
- Visualforce UI's / Hybrid standard and Visualforce UIs
- Custom Buttons / Custom Buttons and Related lists
- Related lists / Custom Buttons and Related lists
- rendering, within Visualforce page / Rendering the standard UI within a Visualforce page
- Salesforce supported browsers / What devices should you target?
- Salesforce Translation Workbench tool / Custom field – picklist values
- sandbox / Uploading the release and beta packages
- sandbox orgs
- versus developer org / Packaging org versus sandbox versus developer org
- versus packaging org / Packaging org versus sandbox versus developer org
- Savepoints / Execution context transaction management
- Schema Builder / Visualizing your object model
- seat based licensing / Installing and testing your package
- Sector Times / Profiling queries
- security, selectSObjectsById method / Security
- security compliance / Introducing the Selector layer pattern
- security features
- about / Understanding the available security features
- functional security / Understanding the available security features
- data security / Understanding the available security features
- security features, execution contexts
- sharing security / Execution context and security
- CRUD and FLS security / Execution context and security
- security review
- about / Security review and benefits
- benefits / Security review and benefits
- selective query / Indexes, being selective, and query optimization, Ensuring queries leverage indexes
- Selector / Services calling services
- Selector class template
- about / The Selector class template
- Selector factory
- about / Introducing the Selector factory
- methods / SelectorFactory methods
- Selectors, mocking / Mocking Selectors
- SelectorFactory methods
- about / SelectorFactory methods
- newInstance method / Usage and reasons for the newInstance method
- tests, writing / Writing tests and the Selector layer
- Selector layer
- URL / Introducing the Selector layer pattern
- design guidelines, implementing / Implementing design guidelines
- Selector layer pattern
- Selectors, mocking
- about / Mocking Selectors
- Application.Selector.newInstance approach / Step 1 – using the Application.Selector.newInstance approach
- virtual keyword, applying / Step 2 – applying virtual and @TestVisible
- @TestVisible annotation, applying / Step 2 – applying virtual and @TestVisible
- mock Selector class, creating / Step 3 – creating a mock Selector class
- test, writing with Application.Selector.setMock / Step 4 – writing a test with Application.Selector.setMock
- Selector methods, identifying / Which type of Selector methods cannot be mocked?
- selectSObjectsById method, features
- security / Security
- default order / Ordering
- FieldSet fields / Field Sets
- Multi-Currency / Multi-Currency
- Selenium WebDriver tool
- about / Automated regression testing
- URL / Automated regression testing
- Sencha / HTML5 and the docType attribute
- Sencha ExtJS / Client-side alternatives to Visualforce UI components
- Separation Of Concerns / Defaulting field values on insert
- separation of concerns (SOC)
- benefits / Separation of Concerns
- code evolution / Apex code evolution
- in Apex / Separating concerns in Apex
- execution context logic, versus application logic concerns / Execution context logic versus application logic concerns
- code reuse, improving / Improving incremental code reuse
- server-managed state
- versus client-managed state / Client-managed state versus server-managed state
- Service code / Creating a compliance application framework
- Service layer / Interpreting the Domain layer in Force.com
- testing / Testing the Service layer
- mocking / Mocking the Service layer
- calling / Calling the Service layer
- FormulaForce package, updating / Updating the FormulaForce package
- JavaScript Remoting, applying to / Applying JavaScript Remoting to the Service layer
- Service layer, Enterprise Application Architecture patterns
- URL / The Service layer
- about / The Service layer
- Service layer interactions
- about / Service layer interactions
- service layer logic
- considerations / Considerations for client-side logic and Service layer logic
- Service layer pattern
- service methods
- implementing / Services calling services
- sharing rules / Data security
- sharing security / Execution context and security
- Signup Request API / Trialforce and Test Drive
- Single Developer Editions orgs / Becoming a Salesforce partner and benefits
- Sites.com / Creating websites
- skinny tables
- about / Skinny tables
- SLA / Asynchronous execution contexts
- SOAP
- versus REST / SOAP versus REST
- SObject
- using, in Service layer interface / Considerations when using SObjects in the Service layer interface
- SObjects / Introducing the Selector layer pattern
- social features
- Chatter / Social features and mobile
- SOQL
- used, for Apex Trigger method testing / Test methods using DML and SOQL
- SOQL FOR LOOP / Processing 50k maximum results in Apex
- SOQL queries / SOSL and Aggregate SOQL queries
- Source Control
- developing with / Developing with Source Control
- repository, populating / Populating your Source Control repository
- Ant build script, using / The Ant build script to clean and build your application
- repository, updating / Updating your Source Control repository
- content, releasing from / Releasing from Source Control
- Source Control repository
- populating / Populating your Source Control repository
- updating / Updating your Source Control repository
- using, with browser-based development / Updating your Source Control repository, Browser-based development and Source Control
- using, with desktop-based development / Updating your Source Control repository, Desktop-based development and Source Control
- using, with browser and desktop-based development option / Updating your Source Control repository
- using, with browser-based development / Browser-based development and Source Control
- special considerations, Unit of Work pattern
- self and recursive referencing / Unit Of Work special considerations
- granular DML operations / Unit Of Work special considerations
- e-mails, sending / Unit Of Work special considerations
- standard indexes
- about / Standard and custom indexes
- fields / Standard and custom indexes
- standard objects
- reusing / Reusing the existing Standard Objects
- standard query logic
- implementing / Implementing the standard query logic
- selectSObjectsById method, features / Standard features of the selectSObjectsById method
- standardStylesheets attribute / Generating PDF content with the renderAs attribute
- state management / Execution context and state
- storage types
- about / Understanding the different storage types
- data storage / Data storage
- file storage / File storage
- auto numbering / Record identification, uniqueness, and auto numbering
- record, identifying / Record identification, uniqueness, and auto numbering
- uniqueness feature / Record identification, uniqueness, and auto numbering
- Streaming API / Platform APIs
- sub-select
- using, with custom Selector method / A custom Selector method with sub-select
- subscriber org / Features and benefits of managed packages
- licensing, enforcing / How licensing is enforced in the subscriber org
- Subscriber Overview page / The Subscriber Overview page
- Subscribers tab / The Subscribers tab
- Subscriber Support feature / Profiling queries
- system administrator / The Ant build script to clean and build your application
- system testing
- versus unit testing / Unit testing versus system testing
T
- @TestVisible annotation / Step 2 – applying virtual and @TestVisible
- team / Object-oriented programming
- team principle / Functional security
- Technical Account Manager (TAM) / Your code and security review considerations
- template method pattern
- terminology
- and platform alignment / Terminology and platform alignment
- test-driven development (TDD) / Unit testing versus system testing
- test data
- for volume testing, creating / Creating test data for volume testing
- Test Drive button / Trialforce and Test Drive
- Test Driven Development / Testing the Service layer
- Tooling API / Platform APIs
- about / Developing with Source Control
- leveraging, from Ant / Leveraging the Metadata API and Tooling APIs from Ant
- transaction management / Transaction management
- translation
- about / Translation, Translation and localization
- translation requirements
- considering / Translation and localization
- Trialforce Management Org (TMO) / Required organizations
- Trialforce Source Org (TSO) / Required organizations
- trigger events
- routing, to Domain class methods / Routing trigger events to Domain class methods
U
- Uniform Resource Identifier (URI) / What are your application resources?
- unique Id field
- adding / Unique and external ID fields
- Unit Of Work / Execution context transaction management, Defining and passing data, Implementing custom Domain logic
- Unit of Work pattern
- used, for handling DML / 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 / The Unit Of Work scope
- special considerations / Unit Of Work special considerations
- unit test
- URL / Unit testing
- defining / Unit testing
- unit testing
- versus system testing / Unit testing versus system testing
- unlimited result sets, Apex
- 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 Visualforce and the Apex read-only mode
- processing, with Salesforce APIs / Processing unlimited result sets using the Salesforce APIs
- unmanaged packages / Package types and benefits
- update event / Encapsulating an object's behavior in code
- upgradable components
- about / Packaging and upgradable components
- picklist values / Custom field – picklist values
- upgrades, automating with Salesforce Metadata API / Automating upgrades with the Salesforce Metadata API
- upgrades
- automating, with Salesforce Metadata API / Automating upgrades with the Salesforce Metadata API
- Usage Metrics Visualization application / Customer metrics
- use cases, browser-based development
- additional files downloaded / Browser-based development and Source Control
- file content order or additional elements, differences / Browser-based development and Source Control
- user experience, considerations
- background work start / General async design considerations
- progress bar indicators / General async design considerations
- monitoring process / General async design considerations
- user profile / Localization
V
- versioning
- about / Versioning
- API definition / Versioning the API definition
- application access, through Salesforce APIs / Versioning application access through the Salesforce APIs
- API functionality / Versioning the API functionality
- REST APIs / Versioning REST APIs
- Apex REST APIs / Is it worth versioning Apex REST APIs?
- View State debugger tool / Demonstrating a large component tree
- Viewstate limits / Client-managed state versus server-managed state
- viewstate size / Querying fields consistently
- virtual keyword, Selectors / Step 2 – applying virtual and @TestVisible
- Visual Flow / Workflow and Flow
- Visualforce
- about / Visualforce
- platform areas / Visualforce
- working with / What can I do within a Visualforce page?
- code execution, on page load with action attribute / Executing the code on page load with the action attribute
- content caching, with cache attributes / Caching content with the cache and the expires attributes
- content caching, with expires attributes / Caching content with the cache and the expires attributes
- Download button, creating with contentType attribute / Creating a Download button with the contentType attribute
- page language, overriding with language attribute / Overriding the language of the page with the language attribute
- HTML5 / HTML5 and the docType attribute
- docType attribute / HTML5 and the docType attribute
- manifest attribute, using for offline web pages / Offline Visualforce pages with the manifest attribute
- PDF content generation, renderAs attribute used / Generating PDF content with the renderAs attribute
- SOQL / Visualforce SOQL, iterator limits, and the readOnly attribute
- iterator limits / Visualforce SOQL, iterator limits, and the readOnly attribute
- readOnly attribute / Visualforce SOQL, iterator limits, and the readOnly attribute
- field-level security / Field-level security
- page response time / Page response time and components
- client-managed state, versus server-managed state / Client-managed state versus server-managed state
- action methods, versus JavaScript Remoting / Action methods versus JavaScript Remoting
- JavaScript Remoting, applying to Service layer / Applying JavaScript Remoting to the Service layer
- JavaScript Remote Objects, using / When should I use JavaScript Remote Objects?
- client-side alternatives, Visualforce UI components / Client-side alternatives to Visualforce UI components
- Visualforce client developer / Contract Driven Development
- Visualforce components / Alignment with Force.com extensibility features
- Visualforce Controller / Creating a compliance application framework
- Visualforce page
- Salesforce standard UI, rendering / Rendering the standard UI within a Visualforce page
- Visualforce pages / Localization
- Visualforce pages, customizable user interfaces
- embedding / Visualforce
- Visualforce SOQL / Visualforce SOQL, iterator limits, and the readOnly attribute
- Visualforce UIs
- volume testing
- test data, creating for / Creating test data for volume testing
- Race Data object, creating with Apex script / Using the Apex script to create the Race Data object
- about / Volume testing
- pitfalls / Volume testing
W
- WADL
- about / SOAP versus REST
- Web Service Connector (WSC)
- Web Service Definition Language (WSDL) / Options for replicating and archiving data
- websites
- creating / Creating websites
- websites, creating
- ways / Creating websites
- Workflow / Workflow and Flow
- wrapper class approach / Domain classes in Apex compared to other platforms
X
- XML metadata / Extension packages