Index

A

• accessor / Adding the Gantt component
• activation
  • testing / Testing passivation and activation
• Active Work Item / Working with Oracle Team Productivity Center
  • versioning / Working with Oracle Team Productivity Center
• ADF
  • architecture / Understanding the architecture of ADF, Enterprise architecture
  • architectureTopicnabout / The ADF architecture
  • Java classes, using / Understanding how Java classes are used in ADF, Some Java required
  • skinning process / The skinning process
  • customization / The technology behind ADF customization
  • working with / Scripting the build process
• ADF application
  • securing / Implementing ADF Security
• ADF applications
  • unit testing / The unit testing ADF applications
• ADF architecture
  • frontend part / The frontend part
  • frontend / The frontend part
  • backend part / The backend part
  • ADF framework / The ADF architecture
• ADF binding layer (ADFm) / The ADF architecture
• ADF Business Components / The backend part
  • about / The Proof of Concept ADF Business Components
  • connection, creating / Creating a connection
  • tuning / Tuning your ADF application
• ADF Business Components (ADF-BC) / The ADF architecture
• ADF Controller (ADFc) / The ADF architecture
• ADF customization
  • seeded customizations / The technology behind ADF customization
  • user customizations / The technology behind ADF customization
  • design time at runtime customizationTopicn / The technology behind ADF customization
• ADF elements
  • entity objects / ADF elements
  • associations / ADF elements
  • view objects / ADF elements
  • view links / ADF elements
  • application modules / ADF elements
  • task flows / ADF elements
• ADF enterprise base package (<aebp>) / Enterprise Common Code
• ADF Faces application / Controlling appearance
• ADF Faces Rich Client (ADFv) / The ADF architecture, The ADF user interface
• ADF framework
  • ADF Faces Rich Client (ADFv) / The ADF architecture
  • ADF Controller (ADFc) / The ADF architecture
  • ADF binding layer (ADFm) / The ADF architecture
  • ADF Business Components (ADF-BC) / The ADF architecture
  • diagram / The ADF architecture
  • Entity objects (EOs) / Entity objects and associations
  • associations / Entity objects and associations
  • view objects / View objects and view links
  • view links / View objects and view links
  • application modules / Application modules
  • ADF user interface / The ADF user interface
  • ADF Task Flows / ADF Task Flows
  • ADF pages and fragments / ADF pages and fragments
• ADF Libraries
  • working with / Working with ADF Libraries
  • ADF Library workflow / The ADF Library workflow
  • using / Using ADF Libraries
  • exporting / Exporting an ADF Library
  • build tasks, creating / Creating build tasks for ADF Libraries
• ADF library
  • project, deploying to / Packaging your common code
• ADF Library workflow
  • creating / The ADF Library workflow
• ADF Pages / The Proof of Concept ADF user interface
• ADF project
  • skills / Skills required for an ADF project
• ADF Security
  • implementing / Implementing ADF Security
• ADF Security implementation
  • security model, selecting / Selecting a security model
  • authentication type, selecting / Selecting the authentication type
  • access grant, selecting / Selecting how to grant access
  • common welcome page, selecting / Select a common welcome page
• ADF skin / Skinning overview
• ADF Skin dialog / Faces Component Selectors
• ADF skinning / The skinning process
• ADF Task Flows
  • about / ADF Task Flows, ADF Task Flows
• ADF tuning / Testing passivation and activation
• af*panelBorderLayout / Navigation
• Agile ADF programming / Reviewing the task flows
• annotations / Adding default testing
• anonymous-role / Assigning application roles
• Apache Ant tool / Automated build system
• Apache Maven tool / Automated build system
• Apache Struts / ADF Task Flows
• Apache Subversion (SVN) / Source control
• application
  • running / Running the application
  • deploying / Deploying the application
• application architecture
  • simple architecture / Application architecture
  • modular architecture / Application architecture
  • enterprise architecture / Application architecture
• Application Assembly node / Deploying your application directly
• Application Common Code project / Application Common Code project
• Application Common Model project / Application Common Model project
• Application Common user interface project / Application Common User Interface project
• Application Common Workspace
  • about / Application Common Workspace
  • Application Common Code project / Application Common Code project
  • Application Common Model project / Application Common Model project
  • Application Common user interface project / Application Common User Interface project
• application cutomization techniques
  • customization classes, developing / Developing customization classes
  • classes, building / Building the classes
  • methods, implementing / Implementing the methods
  • seeded customization, enabling / Enabling seeded customization
  • customization class, linking / Linking the customization class to the application
  • customization layers, configuring / Configuring customization layers
  • resource bundles, using / Using resource bundles
  • resource bundles customization, allowing / Allowing resource bundle customization
• application deployment
  • direct deployment / Direct deployment
  • through console / Deploying the file through the console
• Application Lifecycle Management (ALM) tool / Gathering the tools
• ApplicationModuleDefImp class / Framework extension classes
• ApplicationModuleImpl class / Framework extension classes
• application modules
  • about / Application modules
  • for Oracle Forms / Application modules
  • building, for tasks / Building an application module for tasks
  • building, for scheduling / Building an application module for scheduling
  / ADF elements
• Application Navigator window / Automatic internationalization
• application parameters setup
  • application module, tuning / Application module tuning
  • database locking, controlling / Controlling database locking
• application roles
  • about / Performing authorization, Application roles
  • Admin Staff / Application roles
  • Operations Staff / Application roles
  • Finance / Application roles
  • Event Responsible / Application roles
  • Manager / Application roles
  • assigning / Assigning application roles
• application server
  • mapping, to organization / Mapping the application to the organization
  • setting up / Setting up the application server
  • production environment, requirements / Number of servers
  • enterprise setting / Number of servers
  • WebLogic 12c standalone, installing for ADF / Installing WebLogic 12c standalone for ADF
  • datasource, creating on server / Creating a data source on the server
• Application Servers window / Creating an application server connection
• Applications window / Handling conflicts
• application workspace
  • projects, using / Using projects
  • simple architecture / Simple architecture
  • modular architecture / Modular architecture
• assertElementPresent option / Value checking options
• assertions / Working with JUnit
• assertValue option / Value checking options
• associations / Entity objects and associations, ADF elements
• at-rules / At-Rules
• attribute
  • protecting / Protecting an attribute
• authenticated-role / Assigning application roles
• authentication
  • about / The security basics
  • digest authentication / Authentication means knowing your user
  • basic authentication / Authentication means knowing your user
  • performing / Performing authentication
• authentication provider / Authentication means knowing your user
• authorization
  • about / The security basics, Authorization means deciding on access
  • container-managed security / Authentication means knowing your user, Authorization means deciding on access
  • performing / Performing authorization
• automatic internationalization
  • about / Automatic internationalization
  • localizable strings, storing / How localizable strings are stored
  • localizable strings, defining / Defining localizable strings
  • translation, performing / Performing the translation

B

• Back button / Creating a task flow template
• backend part / The backend part
• basic authentication / Authentication means knowing your user
• Bindings tab / Fixing the bindings, Defining the start and end time
• bind variables / Creating a view object for tasks
• Border property / Faces Component Selectors
• bottom-up estimate
  • producing / Bottom-up estimate
  • three-point estimates / Three-point estimates
  • grouping / Grouping – simple, normal, and hard
  • about / More input, better estimates
• bounded task flows / ADF Task Flows, Creating task flows
• Branches / Effective Subversion
• Browse button / Deploying the EAR file
• Bug/issue tracking tool
  • Jira / Bug/issue tracking
  • Bugzilla / Bug/issue tracking
  • FogBugz / Bug/issue tracking
• Bugzilla tool
  • about / Bug/issue tracking
  • URL / Bug/issue tracking
• build/configuration manager / Build/configuration manager
• build file / Creating a build task
• build process
  • scripting / Scripting the build process
  • build task, creating / Creating a build task
  • task, moving to test/integration server / Moving your task to the test/integration server
  • checkout, adding / Adding a checkout
  • database, adding / Adding the database
  • build script actions, adding / More scripting
  • automation / Automation
• Builds window / Viewing build status
• build task
  • creating, for master project / Creating a build task for the master project
  • creating, for ADF Libraries / Creating build tasks for ADF Libraries
  • creating, formaster application / Creating a build task for the master application
• build tool
  • about / Automated build system
  • Apache Ant / Automated build system
  • Apache Maven / Automated build system
  • continuous integration tools / Automated build system
• Business Components
  • creating / Creating Business Components
  • view objects, building / Building view objects, view links, and the application module
  • view links, building / Building view objects, view links, and the application module
  • application module, building / Building view objects, view links, and the application module
  • Business Logic, implementing / Implementing Business Logic
  • , testing / Testing your Business Components
  • task flows, creating / Creating task flows
  • task flows, reviewing / Reviewing the task flows
  • page fragments, creating / Creating the page fragments
  • UI logic, implementing / Implementing UI logic
  • UI test, defining / Defining the UI test
  • UI test, reviewing / Reviewing the UI test
• Business Components, scheduling subsystem
  • creating / Creating Business Components
  • persons view object, building / Building the persons' view object
  • task view object, building / Building the tasks view object
  • master-detail link, building / Building the master-detail link
  • MinMaxDate view object, building / Building the MinMaxDate view object
  • application module, building / Building the application module
  • testing / Testing your Business Components
  • tasks, completing / Building the task flow
• Business Components, task management subsystem
  • creating / Creating Business Components
  • starting with / Starting work
  • main view object, building / Building the main view object
  • application module, building / Building the application module
  • testing / Testing your Business Components
  • code, checking / Checking in your code
  • tasks, completing / Finishing the tasks
• business service layer / The backend part

C

• calendar time
  • calculating to / From effort to calendar time
• Cance button / OK and Cancel buttons
• Cascading Style Sheets (CSS) / Web technologies
• Change Center box / Deploying the EAR file
• Classes Extend button / Using framework extension classes
• co-creativity stage / Determining the development speed
• code, cleaning up
  • about / Cleaning up your code
  • users, testing / Test users and groups
  • group, testing / Test users and groups
  • other development artifacts / Other development artifacts
  • code audit, performing / Performing code audit
  • rules, ignoring / Ignoring rules
  • rules, checking / Checking more rules
• Code Reviews tab / Code reviews
• code structuring
  • about / Structuring your code
  • workspaces, using / Using workspaces
  • workspace hierarchy / The workspace hierarchy
  • workspace, creating / Creating a workspace
• collaboration tools
  • shared documents / Shared documents
  • discussion forums / Discussion forums
  • online chat / Online chat
• columns / Database objects
• Comment templates / Working with Subversion
• Common Code / The workspace hierarchy
• common model
  • about / The workspace hierarchy
  • building / Building the Common Model, Use framework extension classes, Entity objects, Common View objects, Testing the Common Model
  • testing / Testing the Common Model
• Common View / The workspace hierarchy
• common view objects
  • creating / Common View objects
• common welcome page
  • selecting / Select a common welcome page
• common workspaces
  • creating / Creating common workspaces
• Complete Merge button / Handling conflicts
• component catalog / Screen design
• Components palette / Using the skin
• concurrency issues / Testing application performance with JMeter
• Configuration wizard / Creating an application server connection
• container-managed security / Authentication means knowing your user
• containers / Creating the tasks page
• ContentDelivery property / Lazy content delivery
• ContentStyle / InlineStyle and ContentStyle
• context root / Deploying your application directly
• continuous integration tools
  • about / Automated build system
  • Hudson / Automated build system
  • CruiseControl / Automated build system
• controller layer / The frontend part
• Create ADF Fusion Web Application wizard / Creating a build task for the master project
• Create a Page Template wizard / Defining template facets
• Create Attribute Binding dialog / Defining the start and end time
• Create Entity Object dialog / Entity objects for the Proof of Concept
• Create JSF Page dialog / Creating the tasks page
• Create Managed Bean dialog / Creating a dynamic region
• Create Scheduling Gantt dialog / Adding the Gantt component, Adding a Gantt chart component
• Create Table dialog / Creating the tasks page
• CruiseControl tool / Automated build system
• CSS
  • about / Controlling appearance
  • basics / The Cascading Style Sheets basics
  • individual components, styling / Styling individual components
  • styling / Unravelling the mysteries of CSS styling
  • conditional formatting / Conditional formatting
• CSS styling
  • about / Unravelling the mysteries of CSS styling
• Currency format
  • avoiding / Localizing formats
• customization
  • of customization role / Selecting the customization role
  • role, selecting / Selecting the customization role
  • of business components / Customizing Business Components
  • of pages / Customizing pages
  • of strings / Customizing strings
  • non customizable elements / Elements that cannot be customized
• customization classes
  • deploying / Developing customization classes, Deploying the customization classes
  • building / Building the classes
  • methods, implementing / Implementing the methods
• customization layers
  • about / Applying customization layers
  • applying / Applying customization layers
  • qrstravel / Applying customization layers
  • abctravel / Applying customization layers
  • xyztravel / Applying customization layers

D

• database
  • validation / Entity objects
• database and application server administrator / Database and application server administrator
• database locking
  • pessimistic locking / Controlling database locking
  • optimistic locking / Controlling database locking
  • ADF application, tuning / Tuning your ADF application
• database objects
  • table names / Database objects
  • Primary key columns / Database objects
  • views / Database objects
  • primary key constraints / Database objects
  • foreign key constraints / Database objects
  • sequences / Database objects
  • triggers / Database objects
• database workspacet / Database workspace
• Data Controls panel / Data table
• data manipulation language (DML) / Implementing logical delete
• data modelers / Data modelers
• data security
  • protected operations, defining / Defining protected operations
  • operations, granting to roles / Granting operations to roles
• data service layer / The backend part
• default JDeveloper URL
  • shortening / A simple test with Selenium
• deleteTestData() method / Adding a test case
• deployment
  • preparing / Preparing for deployment, Cleaning up your code, Setting application parameters for production use
• deployment package
  • contents / The contents of a good deployment package, The runnable application, Installation and operation instructions
  • runnable application / The runnable application
  • database code / Database code
  • installation instructions / Installation and operation instructions
  • operation instructions / Installation and operation instructions
• deployment preparation
  • code, cleaning up / Cleaning up your code
  • application parameters, setting / Setting application parameters for production use
• Deployment tab / Creating the EAR file
• Design tab / Working in the Design tab, Global Selector Aliases
• design time at runtime customization / The technology behind ADF customization
• digest authentication / Authentication means knowing your user
• direct deployment
  • application server connection, creating / Creating an application server connection
  • steps / Deploying your application directly
• Disabled property / Adding database operations
• discussion forums, collaboration tools / Discussion forums
• distributed version control system (DVCS) / Version control with Git
• doDML() method / Making the technology work, Creating framework extension classes, Implementing logical delete
• dynamic region / Running the page
  • execution flow / Understanding the dynamic region

E

• Edit List Binding dialog / Refining the tasks page
• EndTime property / Defining the start and end time
• enterprise application development project team
  • roles / Organizing the team
  • role, project manager / Project manager
  • role, software architect / Software architect and lead programmer
  • role, lead programmer / Software architect and lead programmer
  • role, regular programmers / Regular programmers
  • role, build/configuration manager / Build/configuration manager
  • role, database and application server administrator / Database and application server administrator
  • role, graphics designers / Graphic designers
  • role, usability experts / Usability experts
  • role, quality assurance / Quality assurance, test manager, and tester
  • role, test manager / Quality assurance, test manager, and tester
  • role, tester / Quality assurance, test manager, and tester
  • role, data modelers / Data modelers
  • role, users / Users
• enterprise architecture
  • diagram / Enterprise architecture
  • Enterprise Common Workspace / Enterprise Common Workspace
  • master application workspaces / Master application workspaces
• Enterprise Common Workspace / Enterprise Common Workspace
• enterprise roles
  • about / Example users and enterprise roles
• enterprise roles / Users and groups
• Enterprise Roles tab / Example users and enterprise roles
• entitlements / Using entitlements
• EntityImpl class / Framework extension classes, Understanding how Java classes are used in ADF
• entity object
  • protecting / Protecting an entity object
• entity objects
  • about / Entity objects
  • creating / Entity objects
  • primary key generation / Primary key generation
  • business rules / Business rules
  • user interface strings / User interface strings
  • common view objects / Common View objects
  • common model, testing / Testing the Common Model
  • ADF Library, exporting / Exporting an ADF Library
• entity objects / ADF elements
• Entity objects (EOs) / Entity objects and associations
• entity object security
  • implementing, steps / Implementing data security
• estimate
  • calculating / Estimating the solution
  • top-down estimate / Top-down estimate
  • bottom-up estimate / Bottom-up estimate
• example users
  • creating / Example users and enterprise roles
• exception handler / An exception handler
• Expression Language (EL) / Conditional formatting
• Extensible Markup Language (XML) / XML knowledge

F

• facelets
  • using / Creating a page template
• Faces Component Selectors node / Faces Component Selectors
• Faces Flows / ADF Task Flows
• facets, page templates
  • about / Working with facets
  • defining / Defining template facets
  • component facets / Understanding component facets
  • template attributes / Defining template attributes
  • content, adding to / Adding content to the page template
• file deployment, through console
  • EAR file, creating / Creating the EAR file
  • EAR file, deploying / Deploying the EAR file
• files
  • staging / Staging and committing
• final estimate
  • roundabouts / Swings and roundabouts
  • standard task deviation, calculating / Calculating the standard deviation for a task
  • standard project deviation, calculating / Calculating the standard deviation for a project
  • standard project deviation, calculating / Calculating the standard deviation for a project
• Firebug / Unravelling the mysteries of CSS styling
• Flow / Focusing for maximum productivity
• focus mode / Focusing for maximum productivity
• FogBugz tool
  • URL / Bug/issue tracking
  • about / Bug/issue tracking
• form-based authentication / Authentication means knowing your user
• formats
  • localizing / Localizing formats
• framework extension classes
  • about / Framework extension classes
  • EntityImpl / Framework extension classes
  • ViewObjectImpl / Framework extension classes
  • ViewRowImpl / Framework extension classes
  • ApplicationModuleImpl / Framework extension classes
  • ViewDefImpl / Framework extension classes
  • ApplicationModuleDefImpl / Framework extension classes
  • location / The place for framework extension classes
  • creating / Creating framework extension classes
  • using / Using framework extension classes, Use framework extension classes
• frontend part / The frontend part
• Function Point Analysis / Grouping – simple, normal, and hard
• Fusion Web Application / Using projects

G

• Gantt chart component
  • adding / Adding a Gantt chart component
• Gantt component
  • about / Adding the Gantt component
• getCacheHint() method / Implementing the methods
• GetCacheHint method / Implementing the methods
• getDynamicTaskFlowId() method / Additional code for task flow switching
• getMaxEndDate() method / Building the MinMaxDate view object
• getMinStartDate() method / Building the MinMaxDate view object
• getName() method / Implementing the methods
• GetName method / Implementing the methods
• getValue() method / Implementing the methods
• getValue(RestrictedSession, MetadataObject) method / Implementing the methods
• GetValue method / Implementing the methods
• Git / Source control
  • about / Version control with Git
  • using, for version control / Version control with Git, Effective Git , Staging and committing, Preparing your local repository, Initial load of a workspace, Starting the day, Completing a task, Handling conflicts
  • features / Version control with Git
  • usi ng / Effective Git
  • using / Effective Git
  • files, stagging / Staging and committing
  • files, committing / Staging and committing
  • local repository, preparing / Preparing your local repository
  • application workspace, adding to local repository / Initial load of a workspace
  • working with / Working with Git, Committing often to a task, Ending the day
  • conflicts, handling / Handling conflicts
  • conflicts,avoiding / Avoiding conflicts
• Git hosting / Preparing your local repository
• Global Area tabs / Working in the Design tab
• Global Selector Aliases / Global Selector Aliases
• goSchedule option / Navigation
• Go To Meeting tool / Reviewing the task flows
• graphics designers / Graphic designers
• grouping
  • simple / Grouping – simple, normal, and hard
  • normal / Grouping – simple, normal, and hard
  • hard / Grouping – simple, normal, and hard

H

• Halign property / Navigation
• HTML elements
  • styling / Styling individual components
• HTTP Proxy Server window / Recording a session
• Hudson / Automation

I

• images / Optionally providing images for your skin
• Import to Subversion wizard / Starting with Subversion
• inaccessible items
  • removing / Removing inaccessible items
• infatuation stage / Determining the development speed
• InlineStyle
  • building / Building a style
• inlineStyle attribute / Styling individual components
• InlineStyle property / Building a style
• Inspect button / Unravelling the mysteries of CSS styling
• inspect mode / Unravelling the mysteries of CSS styling
• Internationalization
  • about / More internationalization
• iterators / Creating Business Components

J

• Java Authentication and Authorization Service (JAAS) / Authorization means deciding on access
• Java Enterprise Edition (JEE) application / The runnable application
• Java packages
  • about / Java packages
  • project code / Project code
  • Enterprise Common Code / Enterprise Common Code
• JavaServer Faces (JSF) / Building the user interface, Authorization means deciding on access
• JavaServer Pages (JSP) / The ADF user interface
• Java String value / Storing the selected task flow value
• JDeveloper
  • about / Getting started with JDeveloper
  • ADF workspace, creating / Getting started with JDeveloper
  • window / The JDeveloper window and panels
  • panels / The JDeveloper window and panels
  • preferences, setting up / Setting JDeveloper preferences
  • productivity / The secret of productivity
  • exterior version control / Working with ADF Libraries
  • task execution / Automatic internationalization
• JDeveloper window
  • Applications window / The JDeveloper window and panels
  • Structure window / The JDeveloper window and panels
  • Resources window / The JDeveloper window and panels
  • Properties window / The JDeveloper window and panels
• Jira tool
  • about / Bug/issue tracking
  • URL / Bug/issue tracking
• JMeter
  • about / Stress and performance tests
  • working with / Working with JMeter
  • application performance, testing / Testing application performance with JMeter
  • installing / Installing and running JMeter
  • running / Installing and running JMeter
  • simple test / A simple test with JMeter
  • setting up, as proxy / Setting up JMeter as a proxy
  • session, recording / Recording a session
• JMeter sessions
  • troubleshooting / Troubleshooting JMeter sessions
• JSF components
  • styling / Styling individual components, InlineStyle and ContentStyle
• JUnit
  • URL / Initial tests
  • uses / Working with JUnit
  • about / Working with JUnit
  • using, for code test / Using JUnit to test code
  • good unit tests, writing / Writing good unit tests
• JUnit ADF Business Components Test Suite Wizard window / Adding default testing
• JUnit Test Runner
  • using / Writing good unit tests
  • about / Adding default testing

L

• Label property / Refining the tasks page
• LabelStyle property / InlineStyle and ContentStyle
• layout containers
  • arranging, Structure window used / Adding database operations
• Layout property / Navigation
• lead programmer / Software architect and lead programmer
• listeners, recorded sessions
  • View Results Tree / Running a recorded session
  • Graph Results / Running a recorded session
  • View Results in Table / Running a recorded session
  • Aggregate Graph / Running a recorded session
• localized application
  • testing / Running your localized application
  • business components, testing / Testing the localized Business Components
  • user interface, testing / Testing the localized user interface

M

• Make Active button / Setting the active work item
• Managed Beans / Implementing UI logic, Creating a dynamic region
• managed servers / Creating a data source on the server
• master application
  • aspects / Building the master application
  • master workspace, setting up / Setting up the master workspace
  • libraries / Getting the libraries
  • master page, creating / Creating the master page
  • dynamic region, creating / Creating a dynamic region
  • task flow switching / Additional code for task flow switching
• master application workspaces / Master application workspaces
• master page
  • creating / Creating the master page
  • layout, creating / Creating the layout
  • menu, adding / Adding the menu
• master workspace / Master workspace
  • setting up / Setting up the master workspace
• master workspaces / Where to implement security
• Maven
  • working with / Scripting the build process
• MaxEndDate attribute / Defining the start and end time
• maximum productivity
  • focusing on / Focusing for maximum productivity
  • time, work mode / Focusing for maximum productivity
  • time, focus mode / Focusing for maximum productivity
  • time, recharge mode / Focusing for maximum productivity
• Members subtab / Example users and enterprise roles
• Messages window / Handling conflicts
• MinStartDate attribute / Defining the start and end time
• model-view-controller (MVC) pattern
  • about / The frontend part
  • view layer / The frontend part
  • controller layer / The frontend part
  • model layer / The frontend part
• model layer / The frontend part
• modular architecture
  • about / Modular architecture
  • Application Common Workspace / Application Common Workspace
  • database workspace / Database workspace
  • subsystem workspaces / Subsystem workspaces
  • master workspace / Master workspace

N

• naming conventions
  • about / Naming conventions
  • general / General
  • Java packages / Java packages
  • database objects / Database objects
  • ADF elements / ADF elements
  • file locations / File locations
  • test code / Test code
• nesting / Application modules
• new files
  • versioning / Checking in your code
• new workspace
  • setting up / Setting up a new workspace
• non-functional requirements
  • aspects / Non-functional requirements
  • NFR002 / Non-functional requirements
  • about / Non-functional requirements
• No Proxy for field / Setting up JMeter as a proxy

O

• Object-oriented programming / Object-oriented programming
• OFA
  • about / The reason for customization
• OK button / OK and Cancel buttons
• online chat, collaboration tools / Online chat
• OPSS
  • about / The Oracle security solution
• optimistic locking / Controlling database locking
• Oracle
  • alternatives / The Oracle alternative
• Oracle Application Testing Suite
  • contents / The Oracle alternative
  • URL / The Oracle alternative
• Oracle Dynamic Tabs Shell / Working with page templates
• Oracle Enterprise Manager (OEM) / Deploying the EAR file
• Oracle Team Productivity Center (OTPC) / Integrate your tools, Starting work
• Oracle Three Column Layout / Working with page templates
• Oracle WebCenter / Deciding how much to build yourself
• organization base package
  • about / Project code
• OrgLayerCC class / Implementing the methods
• OTN
  • about / Understanding the architecture of ADF
• OTPC
  • about / The Integrated Solution – Oracle Team Productivity Center
  • architecture / The Integrated Solution – Oracle Team Productivity Center
  • requirements / The Integrated Solution – Oracle Team Productivity Center
  • server, installing / Installing the server
  • JDeveloper, connecting, to repositories / Connecting JDeveloper to repositories
  • administration tasks / Administration tasks
  • working with / Working with Oracle Team Productivity Center
  • work items, working with / Working with work items
  • context, restoring / Saving and restoring context
  • context, saving / Saving and restoring context
  • code reviews / Code reviews
  • build status, viewing / Viewing build status
  • chat / Chat
  • News panel / Reading news
• Overview button / Navigation
• Overview tab / Unravelling the mysteries of CSS styling

P

• page
  • about / ADF pages and fragments
  • content adding, layout components used / ADF pages and fragments
  • content adding, data components used / ADF pages and fragments
  • content adding, control components used / ADF pages and fragments
• page, scheduling subsystem
  • Gantt chart component, adding / Adding a Gantt chart component
  • start time, defining / Defining the start and end time
  • end time, defining / Defining the start and end time
  • running / Running the page
• page flow scope / Storing the selected task flow value
• page fragment, task management subsystem
  • creating / Creating the page fragment
  • Data Controls panel / Data table
  • Search panel / Search panel, Fixing the bindings
  • page, running / Running the page
  • OK button / OK and Cancel buttons
  • Cancel buttons / OK and Cancel buttons
• page fragments
  • about / ADF pages and fragments
  • creating / Creating the page fragments
• pages
  • customizing / Customizing pages
• PageSwitcher class / Accessing the session bean from the backing bean
• page template attributes
  • setting / Defining template attributes
• page templates
  • about / Working with page templates
  • creating / Creating a page template
  • layout containers, using / Using layout containers
  • facets, working with / Working with facets
• Panel Group Layout / Refining the tasks page, Navigation, Search panel
• PartialTriggers property / Making the region redraw itself
• passivation
  • testing / Testing passivation and activation
  / Application module tuning
• password policy / Example users and enterprise roles
• Pending Changes window / Handling conflicts
• pessimistic locking / Controlling database locking
• Phase I testing
  • about / Initial tests
  • JUnit, working with / Working with JUnit
  • good unit tests, writing / Writing good unit tests
  • ADF applications, unit testing / The unit testing ADF applications
  • unit testing, preparing / Setting up a test project
  • unit testing, real example / The real unit testing example
  • unit testing, automating / Automating unit testing
• PL/SQL Business rules
  • handling / Business rules
• Pooling and Scalability tab / Application module tuning
• power struggle stage / Determining the development speed
• pProgramme parameter / Refining the tasks page
• primary key constraints / Database objects
• productivity, requirements
  • pixels / More pixels give better productivity
  • version control / Version control
  • spreadsheets, avoiding / Avoiding spreadsheets
  • project, splitting to tasks / Split your project into tasks
  • focus / Focus
  • tools, integrating / Integrate your tools
• Program Evaluation and Review Technique (PERT) / Three-point estimates
• project base package / Project code
• project base package(<pbp>)
  • naming / Project code
• Proof of Concept
  • about / The Proof of Concept
  • content / Content of a Proof of Concept
  • ADF technology / Making the technology work
  • development speed, determining / Determining the development speed
  • infatuation stage / Determining the development speed
  • power struggle stage / Determining the development speed
  • co-creativity stage / Determining the development speed
  • eliverables / The Proof of Concept deliverables
  • case study / The Proof of Concept case study
  • DMC / The Proof of Concept case study
  • use cases / Use cases
  • UC008 Task Overview / UC008 Task Overview and Edit
  • UC104 Person Task Timeline / UC104 Person Task Timeline
  • data model / Data model
  • entity objects / Entity objects for the Proof of Concept
  • associations, building / Building associations for the Proof of Concept
  • view links, building / Building view objects and view links for the Proof of Concept
  • view objects, building / Building view objects and view links for the Proof of Concept
• Proof of Concept ADF user interface
  • ADF Task Flows / The Proof of Concept ADF user interface, ADF Task Flows
  • ADF Pages / The tasks page
• Properties tab / Testing the localized Business Components
• Properties window / Creating the tasks page, Building a style, Working in the Selectors tab
• Property Inspector panel / Refining the tasks page
• Pseudo-Elements node / Faces Component Selectors
• Push to Git wizard / Ending the day

Q

• quality assurance / Quality assurance, test manager, and tester

R

• ReadOnly attribute / Protecting an attribute
• Real Application Security (RAS) / Granting operations to roles
• real example, unit testing
  • test case, adding / Adding a test case
  • logical delete, implementing / Implementing logical delete
  • re-testing / Re-testing
• recharge mode / Focusing for maximum productivity
• recorded session
  • post-processing / Post-processing a recorded session
  • running / Running a recorded session
• refactoring / Creating view objects for scheduling
• region / Creating a dynamic region
• regular expressions / Regular expressions
• regular programmers
  • programming tasks / Regular programmers
  • business components, building / Building Business Components
  • user interface, building / Building the user interface
  • skinning / Skinning
  • templates / Templates
  • data validation, defining / Defining data validation
  • support classes, building / Building support classes
  • database stored procedures, building / Building database stored procedures
• remove() method / Implementing logical delete
• Replace Icons dialog box / Optionally providing images for your skin
• resource bundle / Refining the tasks page, Automatic internationalization
  • using / Search panel
• resource bundles
  • using / Using resource bundles
  • enabling / Allowing resource bundle customization
• resource string / Optionally creating a resource bundle for your skin
• resource strings
  • customizing / Customizing strings
• Resources window / The JDeveloper window and panels
• Rich Internet Application (RIA) / ADF pages and fragments
• Rich Internet Applications (RIA) / Creating a task flow template, Creating the page fragment
• rules / The Cascading Style Sheets basics
• Run button / Setting up the application server

S

• Save Context button / Saving and restoring context
• scheduled tasks page
  • about / The scheduled tasks page
  • Gantt component, adding / Adding the Gantt component
  • navigating between / Navigation
• SchedulePage icon / The scheduled tasks page
• scheduling subsystem
  • implementing / Implementing the scheduling subsystem
  • page, building / Building the page
  • deploying / Deploying your scheduling subsystem
• scheduling subsystem implementation
  • new workspace, setting up / Setting up a new workspace
  • libraries, obtaining / Getting the libraries
  • Business Components, creating / Creating Business Components
  • task flow, building / Building the task flow
  • page, building / Building the page
  • code, checking / Checking in your code
• security basics
  • authentication / The security basics, Authentication means knowing your user
  • authorization / The security basics, Authorization means deciding on access
  • OPSS / The Oracle security solution
  • alternative security / Alternative security
• security decision
  • application, securing / Security decisions
  • authentication, performing / Performing authentication
  • authorization, performing / Performing authorization
  • implementing, locations / Where to implement security
• seeded customizations / The technology behind ADF customization
• Select Branch button / Starting work on a task
• Select Java Options dialog / Implementing logical delete
• selector function / The Cascading Style Sheets basics
• Selectors tab
  • working with / Working in the Selectors tab
• Select Text Resource dialog / Using resource bundles
• Selenium
  • URL / User interface tests
  • using, Selenium IDE / About Selenium
  • using, Selenium WebDriver / About Selenium
  • value checking, assertValue option / Value checking options
  • value checking, verifyValue option / Value checking options
  • value checking, waitForValue option / Value checking options
  • value checking, assertElementPresent option / Value checking options
  • shortcomings / Lazy content delivery
  • context menus, testing / Testing the context menus
  • item ID, verifying / Verifying the item ID
  • passivation, testing / Testing passivation and activation
  • activation, testing / Testing passivation and activation
• Selenium IDE
  • about / About Selenium
  • installing / Installing Selenium IDE
  • test / A simple test with Selenium
  • test, exporting / Exporting your test
  • using / Using Selenium effectively
• Selenium WebDriver / About Selenium
• Sequences / Database objects
• Service-Oriented Architecture (SOA) / Deciding how to integrate
• setUiState method / Accessing the session bean from the backing bean
• shared documents, collaboration tools / Shared documents
• simple architecture / Application architecture
• skills, for ADF project
  • about / Skills required for an ADF project
  • framework knowledge / ADF framework knowledge
  • Object-oriented programming / Object-oriented programming
  • Java programming / Java programming
  • programming / Database design and programming
  • database design / Database design and programming
  • XML knowledge / XML knowledge
  • web technologies / Web technologies
  • regular expressions / Regular expressions
  • graphics design / Graphics design
  • usability / Usability
  • testing / Testing
• skin / Skinning
  • families / Creating a skin CSS file
  • images, providing for / Optionally providing images for your skin
  • resource bundle, creating / Optionally creating a resource bundle for your skin
  • packaging / Packaging the skin
  • using / Using the skin
• skin CSS file
  • creating / Creating a skin CSS file
• Skin menu / Skinning capabilities
• skinning / Skinning
  • overview / Skinning overview
  • capabilities / Skinning capabilities
  • in action / Skinning capabilities
  • recommendations / Skinning recommendations
  • processTopicnin ADF, steps / The skinning process
  • skin CSS file, creating / Creating a skin CSS file
  • Design tab, working / Working in the Design tab
  • Selectors tab, working / Working in the Selectors tab
  • Style Classes / Style Classes
  • Global Selector Aliases / Global Selector Aliases
  • At-Rules / At-Rules
  • Faces Component Selectors node / Faces Component Selectors
  • Data Visualizations Component Selectors / Data Visualizations Component Selectors
  • selector, finding at runtime / Finding the selector at runtime
  • optionl images, providing / Optionally providing images for your skin
  • optionl images, providing / Optionally providing images for your skin
  • resource bundle, creating / Optionally creating a resource bundle for your skin
• skin project
  • creating / Creating a skin project
• skyros skin / Skinning overview
• Slik SVN client / Adding a checkout
• software architect / Software architect and lead programmer
• software building
  • aspects / Deciding how to build it, Deciding how much to build yourself, Deciding how to integrate
  • time, deciding / Deciding how much to build at a time
  • content, deciding / Deciding how much to build yourself
  • integration technique, deciding / Deciding how to integrate
• software requirements
  • gathering / Gathering requirements
  • use cases / Use cases
  • user stories / User stories
  • non-functional requirements / Non-functional requirements
  • lists / Requirement lists
  • screen design / Screen design
• source control system
  • about / Source control
  • example, Apache Subversion (SVN) / Source control
  • G / Source control
• Source tab / Working in the Design tab
• SQL Developer Data Modeler / Making the technology work
• SSL (Secure Sockets Layer) / Authentication means knowing your user
• stand-alone skinning / The skinning process
• static region / Running the page
• Structure panel / Adding database operations
• Structure window
  • using, for layout containers arrangement / Adding database operations
  / Creating a build task for the master project
• style
  • building / Building a style
• style class
  • using, ways / The Cascading Style Sheets basics
• styleClass attribute / Styling individual components
• Style Classes / Style Classes
• StyleClass property / Building a style
• Style Selectors / Skinning capabilities
• subsystem workspaces / Subsystem workspaces
• Subversion
  • using, for version control / Version control with Subversion, Handling new files, Starting with Subversion
  • features / Version control with Subversion
  • requirements / Version control with Subversion
  • using, for ADF project / Effective Subversion
  • new files, handling / Handling new files
  • starting with / Starting with Subversion
  • working with / Working with Subversion
  • new copy, obtaining / Getting a new copy
  • modified file changes, obtaining / Getting other people's changes
  • automatic merging / Automatic merge
  • conflicts, handling / Handling conflicts
• Suppress Audit Warnings plugin / Ignoring rules
• SvnAnt task / Adding a checkout

T

• table names / Database objects
• Tags / Effective Subversion
• targets / Creating a build task
• Targets tab / Creating a data source on the server
• task flow, task management subsystem
  • creating / Creating the task flow
• task flows / ADF elements
  • creating / Creating task flows
  • reviewing / Reviewing the task flows
  • securing / Securing task flows
• task flow switching
  • selected task flow value, storing / Storing the selected task flow value
  • session bean, accesing / Accessing the session bean from the backing bean
  • task flow values, setting up / Setting up the task flow values
  • redraw activity / Making the region redraw itself
  • code, checking / Checking in your code
• task flow templates
  • about / Working with task flow templates
  • creating / Creating a task flow template
  • elements / Contents of your task flow template
  • using / Creating several levels of templates
• task flow templates, elements
  • exception handler / An exception handler
  • initializers / Initializers and finalizers
  • finalizers / Initializers and finalizers
  • multiple levels, creating / Creating several levels of templates
• task management subsystem
  • implementing / Implementing the task management subsystem
  • new workspace, setting up / Setting up a new workspace
  • libraries / Getting the libraries
  • code, checking / Checking in your code
  • deploying / Deploying the task management subsystem
• TaskPage icon / The scheduled tasks page
• tasks
  • view objects, creating for / Creating a view object for tasks
  • application module, building for / Building an application module for tasks
• tasks / Creating a build task
• tasks pages
  • creating / Creating the tasks page
  • initial tasks page, running / Running the initial tasks page
  • tasks page, refining / Refining the tasks page
  • bindings, fixing / Fixing the bindings
  • running, with parameters / Running the tasks page with parameters
  • database operations, adding / Adding database operations
  • running, with database operations / Running the tasks page with database operations
• Teams window
  • Team Members / Working with Oracle Team Productivity Center
  • Work Items / Working with Oracle Team Productivity Center
  • versioning / Working with Oracle Team Productivity Center
• Team | Builds / Viewing build status
• Team | Chat / Chat
• Team | Connect to Team Server / Working with Oracle Team Productivity Center
• Team | Git | Clone / Preparing your local repository
• Team | Git | Commit All / Committing often to a task
• Team | Git | Resolve Conflict / Handling conflicts
• Team | Subversion | Check Out / Getting a new copy
• template attributes
  • defining / Defining template attributes
• ternary operator / Conditional formatting
• Test and Explain button / Creating a view object for tasks
• test classes / Working with JUnit
• testDelete() method / Adding a test case
• tester / Quality assurance, test manager, and tester
• test manager / Quality assurance, test manager, and tester
• test methods / Working with JUnit
• theme / Working in the Selectors tab
• three-point estimates
  • optimistic estimate / Three-point estimates
  • likely estimate / Three-point estimates
  • pessimistic estimate / Three-point estimates
• tip layer / Selecting the customization role
• Tools | Preferences | Versioning | Subversion | Comment Templates / Working with Subversion
• top-down estimate
  • producing / Top-down estimate
• TortoiseGit
  • URL / Version control with Git
• TortoiseSVN / Version control with Subversion
• train / Creating a task flow template
• triggers / Database objects
• Trunk / Effective Subversion

U

• UI logic
  • implementing / Implementing UI logic
• UI test
  • defining / Defining the UI test
  • reviewing / Reviewing the UI test
• unbounded task flow / ADF Task Flows
• unit testing
  • preparing for / Preparing for unit testing
  • real example / The real unit testing example
• unit testing preparation
  • test project, setting up / Setting up a test project
  • default testing, adding / Adding default testing
• unit tests
  • about / Initial tests
  • tools, JUnit / Initial tests
  • tools, TestNG / Initial tests
  • writing / Writing good unit tests
• unmergeable files
  • examples / Avoiding conflicts
• usability experts / Usability experts
• use cases
  • about / Use cases
  • brief / Use cases
  • casual / Use cases
  • fully dressed / Use cases
• user customizations / The technology behind ADF customization
• user groups / Users and groups
• user interface security
  • task flows, securing / Securing task flows
  • pages, securing / Securing pages
  • entitlements, using / Using entitlements
  • data security, implementing / Implementing data security
• user interface tests
  • about / User interface tests
  • contents / What should you test?
  • Selenium / About Selenium
  • Selenium IDE, installing / Installing Selenium IDE
  • Selenium, test / A simple test with Selenium
  • test, exporting / Exporting your test
• users / Users

V

• value lists
  • view objects, creating for / Creating view objects for value lists
• Value property / Adding content to the page template
• verifyValue option / Value checking options
• version
  • controlling, with Subversion / Version control with Subversion, Handling new files, Starting with Subversion, Working with Subversion
  • controlling, with Git / Version control with Git
• vew links / ADF elements
• ViewDefImpl class / Framework extension classes
• view layer / The frontend part
• view links
  • about / View objects and view links
• ViewObjectImpl class / Framework extension classes
• view object instance / Building an application module for tasks
• view objects
  • about / View objects and view links
  • using / View objects and view links
  • building, for Proof of Concept / Building view objects and view links for the Proof of Concept
  • creating, for value lists / Creating view objects for value lists
  • creating, for taks / Creating a view object for tasks
  • creating, for scheduling / Creating view objects for scheduling
  / ADF elements
• View Results Tree view / Troubleshooting JMeter sessions
• ViewRowImpl class / Framework extension classes
• views / Database objects
• Virtual Private Database (VPD) / Granting operations to roles, Database code

W

• waitForValue option / Value checking options
• WBS
  • about / Example Work Breakdown Structure
  • technical design / Example Work Breakdown Structure
  • server setup / Example Work Breakdown Structure
  • development workstation setup / Example Work Breakdown Structure
  • development standards / Example Work Breakdown Structure
  • prototyping / Example Work Breakdown Structure
  • framework extension classes / Example Work Breakdown Structure
  • data model / Example Work Breakdown Structure
  • entity objects for all tables / Example Work Breakdown Structure
  • view objects for common queries (for value lists / Example Work Breakdown Structure
  • graphical design / Example Work Breakdown Structure
  • skinning and templates / Example Work Breakdown Structure
  • usability testing / Example Work Breakdown Structure
  • business logic packages / Example Work Breakdown Structure
  • integration packages / Example Work Breakdown Structure
  • master application / Example Work Breakdown Structure
  • automated build procedure / Example Work Breakdown Structure
  • system integration testing / Example Work Breakdown Structure
  • coordination and project management / Example Work Breakdown Structure
• Web Archive (.war) file / The runnable application
• WebLogic 12c standalone
  • installing, for ADF / Installing WebLogic 12c standalone for ADF
• WebLogic server / Running the initial tasks page
• work
  • organizing / Organizing the work, Preconditions, Development tasks, Building view objects, view links, and the application module, Creating task flows, Reviewing the task flows, Creating the page fragments, Implementing UI logic, Defining the UI test, Reviewing the UI test
• Work Breakdown Structure (WBS) / Development tasks
• Working sets / Simple architecture
• work items
  • working with / Working with work items
  • finding / Finding work items
  • setting / Setting the active work item
  • linking / Linking work items
  • tagging / Tagging work items
• work mode / Focusing for maximum productivity
• work organization
  • about / Organizing the work
  • preconditions / Preconditions
  • good user requirements / Preconditions
  • development tasks / Development tasks
• workspace hierarchy
  • about / The workspace hierarchy
  • common model / The workspace hierarchy
  • Common View / The workspace hierarchy
  • Common Code / The workspace hierarchy
• workspaces
  • using / Using workspaces
  • hierarchy / The workspace hierarchy
  • creating / Creating a workspace

X

• XLIFF / How localizable strings are stored