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
- 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
- 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
- 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
- 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
- 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
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
- 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
- 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
- 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
- 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
- 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
- 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
- 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