Rational solution for Collaborative Lifecycle Management 5.0
  ++ THIS INFORMATION IS FOR PLANNING PURPOSES ONLY. THE INFORMATION HEREIN IS SUBJECT TO CHANGE OR REMOVAL WITHOUT NOTICE BEFORE THE PRODUCTS DESCRIBED MAY BECOME AVAILABLE. ++
    Welcome
    Rational solution for Collaborative Lifecycle Management
      Overview
        Rational products and solutions
        IBM and accessibility
        Introduction to the Rational solution for CLM
          Overview of the solution
          Overview of Rational DOORS Next Generation
            Comparison of Rational DOORS and Rational DOORS Next Generation
          Overview of Rational Team Concert
          Overview of Rational Quality Manager
          Overview of Design Management
          Overview of Rational Reporting
          Linking requirements, development, and test
          What's new in this release
          Videos for the Rational solution for CLM
          Learning resources
        Getting started with the Rational solution for CLM
        Introduction to the Rational solution for systems and software engineering
        Introduction to the Rational Deployment wiki
        Security considerations for the Rational solution for CLM
        Notices for the Rational solution for CLM documentation
      Tours
        Rational solution for Collaborative Lifecycle Management
      Tutorials
        Money that matters lifecycle scenario
          Introduction
          Module 1: Plan a sprint
            Lesson 1.1: Propose the requirements for a sprint
            Lesson 1.2: Explore design options for the sprint
            Lesson 1.3: Plan the development effort
            Lesson 1.4: Plan the test effort
            Lesson 1.5: Assess coverage
          Module 2: Complete a story
            Lesson 2.1: Create test scripts
            Lesson 2.2: Detailing design
            Lesson 2.3: Develop a story
            Lesson 2.4: Submit a build request
            Lesson 2.5: Test for defects
            Lesson 2.6: Fix a defect
            Lesson 2.7: Confirm that the story is done
          Module 3: Stabilize the sprint
            Lesson 3.1: Prepare for a sprint shutdown
          Summary
        Customize process in your project area and team areas
          Introduction: Customize process in your project area and team areas
          Lesson 1: Create a lifecycle project and assign roles
          Lesson 2: Create a timeline and iterations
          Lesson 3: Create a team area and add a member
          Lesson 4: Explore setting permissions
          Lesson 5: Create a role
          Lesson 6: Configure operation behavior (CCM)
          Lesson 7: Configure operation behavior (QM)
          Lesson 8: Customize behavior for an iteration type
          Summary: Customize process in your project area and team areas
      Samples
        Money that Matters sample
      Scenarios
        Collaborative Lifecycle Management (CLM) agile scenario
          Installing and setting up
            Installing Collaborative Lifecycle Management products
            Configuring the environment
          Planning the release
            Developing a vision
            Organizing requirements
            Planning the project
            Planning the test effort
          Completing plan items
            Elaborating plan items
            Detailing requirements
            Developing
            Building
            Testing
          Fixing defects and verifying
            Querying for defects
            Fixing, delivering, and building
            Verifying that defects are fixed
            Assessing iteration completeness
      Integrating
        Overview of CLM integrations
        OSLC integrations
          Linked data and OSLC integrations
          Basics of writing OSLC integrations
          Common user features
          Common administration tasks
        Integrating applications on separate Jazz servers
          Establishing cross-server communication
          Approving access requests
          Linking between project areas
      Administering
        Administering projects
          Getting started with project areas and lifecycle projects
          Administering lifecycle projects
            Logging on to the Lifecycle Project Administration application
            Creating lifecycle projects from a template
            Lifecycle project templates
            Creating a lifecycle project and adding existing project areas
            Adding project areas to a lifecycle project
            Replacing or removing project areas from lifecycle projects
            Adding members to projects
            Assigning roles from within lifecycle projects
            Configuring process role relationship rules
            Modifying a predefined template
            Creating a lifecycle project template
            Modifying an LPA template to access an RM project template
            Importing lifecycle project templates
            Deleting lifecycle projects
          Administering project areas: Tasks for all applications (web client)
            Logging in for project administrators and team leads (web)
            Understanding licenses, permissions, and access control
            Creating a project area
              Project area
              Process
            Creating timelines, iterations, and iteration types
              Creating timelines and iterations
              Timeline
              Iteration and iteration types
              Creating an iteration type
              Modifying timelines and iterations
            Creating team areas and associating work item categories
              Creating a team area
              Team area
              Defining categories that work items can be filed against in the web client
              Work item category (Filed Against)
            Adding and modifying users as members of project areas and team areas
              Adding existing users
              Assigning roles to a member
              Roles
              Assigning administrative privileges
              Specifying team invitation content in a template
            Adding and modifying roles and permissions
              Permissions
                Change and Configuration Management role-based permissions
                Quality management role-based permissions
                Requirements Management role-based permissions
              Modifying role-based permissions
                Customizing permissions for a specific time period
                Customizing permissions in a team area
              Adding and removing roles
            Restricting read access to project areas, team areas, and artifacts
              Restricting read access to project areas or team areas
              Restricting access to work item categories
              Using access groups to control access to artifacts
                Creating access groups
                Editing access groups
                Archiving access groups
                Restoring archived access groups
            Setting preconditions and follow-up actions
              Preconditions and follow-up actions
              Copying configurations
              Creating configurations
            Adding associations
            Sharing the process of a project area
              Enabling project area process sharing across servers
              Making a project area shareable
              Modifying a project area to use another project area's process
            Archiving and restoring project areas and team areas
              Archiving project areas and team areas
              Restoring archived project areas and team areas
            Managing process descriptions and practices
              Creating process descriptions
              Importing process descriptions
              Exporting process descriptions
              Archiving process descriptions
              Restoring process descriptions
              Deleting process descriptions
              Creating practices
              Importing practices
              Exporting practices
              Archiving practices, practice elements, and practice categories
              Restoring practices, practice elements, and practice categories
            Working with process templates
              Deploying predefined process templates
              Viewing process descriptions for predefined templates
              Exporting process templates
              Importing process templates
              Editing process templates
            Viewing process history
            Refreshing browser to see process changes
        Administering help content for web applications
          Help content configurations
            Reviewing the setup requirements
            Terminology
          Accessing the default remote help
          Configuring the help server for local or intranet help
            Viewing information about the help content
            Configuring more remote help connections
            Securing your help server
            Configuring network connections
          Installing local help on your computer
            Installing from the public site
            Installing from an archive file
          Setting up help content on an intranet server
            Deploying the help system on Apache Tomcat
            Deploying the help system on IBM WebSphere Application Server
          Updating the help content
          Changing the help content selection
          Troubleshooting the help setup
            Accessing the log information
            Testing remote help connections
            Fixing proxy and firewall issues
            Fixing Internet Explorer Enhanced Security Configuration issues
            Fixing Java virtual machine issues
            Updating the help.war file
      Collaborating
        Managing dashboards
          Dashboards
            Creating personal dashboards
            Accessing project and team dashboards
            Customizing mini dashboards
            Tracking progress with plan dashboards
          Adding and organizing content on a dashboard
            Creating effective dashboards
            Adding and organizing tabs on dashboards
            Saving changes to the dashboard
            Refreshing dashboard content
            Finding a dashboard
            Configuring dashboard templates in the process
          Adding and configuring widgets
            Predefined widgets in the local catalog
            Adding a widget
            Adding an OpenSocial gadget
            Adding the Lotus Connections widget to a project dashboard
            Adding a widget from another application
            Configuring widgets
            Moving and copying widgets
            Configuring widget catalog entries in the process
      Reference
        Accessibility features
          Accessibility preferences
            Fonts and color settings
            Specifying custom color settings
            Configuring the context-sensitive help for screen readers
          Keyboard shortcuts
            Help system
      Glossary
        Glossary for the Rational solution for CLM
          A
          B
          C
          D
          E
          F
          G
          H
          I
          J
          K
          L
          M
          N
          O
          P
          Q
          R
          S
          T
          U
          V
          W
          X
          Z
        IBM Terminology website
      Using the help
        Getting started with the help
          Help system overview
          Help system features
          Information types
          Identifying and bookmarking URLs
          Navigating from a mobile device
          Searching help content
        Filtering the online help
        Configuring help content for Eclipse client applications
          Help content configurations
            Reviewing the setup requirements
            Terminology
          Accessing the default remote help
          Configuring the help server for local or intranet help
            Viewing information about the help content
            Configuring more remote help connections
            Securing your help server
            Configuring network connections
          Installing local help on your computer
            Installing from the public site
            Installing from an archive file
          Setting up help content on an intranet server
            Deploying the help system on Apache Tomcat
            Deploying the help system on IBM WebSphere Application Server
          Updating the help content
          Changing the help content selection
          Troubleshooting the help setup
            Accessing the log information
            Testing remote help connections
            Fixing proxy and firewall issues
            Fixing Internet Explorer Enhanced Security Configuration issues
            Fixing Java virtual machine issues
            Updating the help.war file
        Configuring help content for RCP applications
          Help content configurations
            Reviewing the setup requirements
            Terminology
          Accessing the default remote help
          Installing local help on your computer
            Installing from the public site
            Installing from an archive file
          Setting up help content on an intranet server
            Deploying the help system on Apache Tomcat
            Deploying the help system on IBM WebSphere Application Server
            Configuring the help server for local or intranet help
              Viewing information about the help content
              Configuring more remote help connections
              Securing your help server
              Configuring network connections
          Updating the help content
          Changing the help content selection
          Troubleshooting the help setup
            Accessing the log information
            Testing remote help connections
            Fixing proxy and firewall issues
            Fixing Internet Explorer Enhanced Security Configuration issues
            Fixing Java virtual machine issues
            Updating the help.war file
        Printing topics and creating PDFs
        Customizing help content
    Jazz Team Server
      Overview
        Jazz Team Server
        Introduction to the Rational Deployment wiki
      Installing
        Installing the Rational solution for Collaborative Lifecycle Management (CLM)
          Deployment and installation planning for the Rational solution for CLM
            Deployment and installation
              Hardware and software requirements
              Deployment topologies
              How many Jazz Team Servers to use
              Planning your URIs
              Applications in this release
              Licensing
              Single sign-on
              Planning to install on Linux, UNIX, IBM i, and z/OS systems
                Planning to install on UNIX and Linux systems
                  Troubleshooting UNIX installations
                Installing with Security-Enhanced Linux
                Planning to install on IBM i systems
                Planning to install on z/OS systems
                  Checklist for z/OS installations
                  SMP/E installation process
                  Installation information for z/OS system programmers
                  Setting up the JZOS batch launcher
                  Security on z/OS systems
                    RACF security
                    Jazz Team Server security on z/OS systems
                    Security for z/OS builds
            Examples: Installation process and topology
              Example: Installation process
              **** MISSING FILE ****
              **** MISSING FILE ****
              **** MISSING FILE ****
            Techniques for changing your topology
              Reverse proxy servers in topologies
              DNS names in topologies
              Server rename in topologies
            Performance considerations
              Maximizing performance
              Idle standby deployment
                Fully distributed enterprise topology with idle standby
          Downloading the installation media
          Interactive installation guide
          Installing Jazz Team Server and the CLM applications
            Installing by using Installation Manager
            Installing from a command line
              Choosing a different context root than default
            Installing on IBM i systems
            Installing on z/OS systems
              Configuring your installation
                Creating directories
                Customizing configuration files
                  Customizing the provisioning profiles
                  Customizing the logging utility files
          Completing the installation of Jazz Team Server and the CLM applications
          Setting up the database
            Setting up a DB2 database
              Manually configuring a DB2 database
            Setting up an Oracle database
              Manually configuring an Oracle database
            Setting up an SQL Server database
              Manually configuring an SQL Server database
            Setting up a DB2 database on a z/OS system
              Prerequisites
              Setting up DB2 for z/OS for Jazz Team Server
              Customizing the Jazz Team Server and CLM properties files for DB2
              Configuring Jazz Team Server to use DB2 on z/OS
              Creating database tables
                Creating database tables remotely
              Running UNLOAD and LOAD processes for backup
          Deploying and starting the server
            Deploying and starting Tomcat
              Starting the server
              Configuring the server as a Windows service
              Running on z/OS with Tomcat
                Reviewing the Apache Tomcat port configuration
                Starting Tomcat on z/OS
            Deploying and starting WebSphere Application Server
              Administering the server by using Jython
              Administering the server by using the Integrated Solutions Console
                Setting up WebSphere Application Server
                Deploying CLM applications on the server
              Deploying by using single sign-on
              Configuring virtual hosts for applications
              Configuring a reverse proxy
              Importing the WebSphere Application Server certificate into the HTTP Server plug-in
              Starting and stopping Jazz Team Server on IBM i systems
              Running Jazz Team Server and the CLM applications on z/OS systems or WebSphere Liberty profile on z/OS
                Setting up user security on a z/OS system by using RACF
                Configuring the Rational solution for CLM and WebSphere Application Server for z/OS
                Configuring the Rational solution for CLM and WebSphere Application Server Liberty profile on z/OS
            Changing the port numbers for the application server
          Deploying for high availability
            Manual failover techniques
              Setting up servers for high availability
              Taking the primary servers offline
              Restoring the primary server
          Configuring the server
            Running custom setup
            Running express setup
            Running the setup from the command line
            Completing the installation
            Configuring the server on IBM i systems
          Configuring security certificates
            Installing a security certificate
            Disabling security certificate settings
          Support for NIST SP 800-131
            Configuring WebSphere Application Server for TLS 1.2
            Configuring IBM HTTP Server to support TLS 1.2
            Configuring Apache Tomcat for TLS 1.2
            Configuring browsers for TLS 1.2
            Configuring Rational Team Concert for TLS 1.2
            Configuring Rational connectors for TLS 1.2
          Setting up user management
            Managing users on Apache Tomcat
              Default user management on Apache Tomcat
              Managing users by using LDAP
                LDAP configuration parameters
                Configuring an LDAP connection
                Manually configuring the Tomcat web container to use LDAP
              Configuring the Tomcat LDAPLocalGroup realm
            Managing users on WebSphere Application Server
              Enabling LDAP on WebSphere Application Server
              Custom realms for authentication and group membership
              Managing users by using a federated, file-based registry
                Configuring the federated repositories
                Setting up groups and users
          Changing the public URL by using server rename
            Planning for server rename
              Server rename
              Supported scenarios
              Mapping file for server rename
              Server rename process example
              Supplemental information about server rename on Jazz.net
              Topology diagrams and mapping file examples
                Staging environment scenario
                Pilot-to-production scenario
                Production-to-production scenario
            Impact of server rename on the Rational solution for CLM
              Jazz Team Server
              Change and Configuration Management (CCM) application
              Quality Management (QM) application
                Changes to advanced properties
              Integrated products
            Performing a server rename
              Preparing the mapping file
              Scenario: Setting up a test staging environment
              Scenario: Moving a pilot or full production deployment
              Configuring RRDI after server rename
              Changing the context root
              Configuring after a database server move
                Moving CLM databases to a different database server
                Changing CLM databases to a different database vendor
            Verifying and troubleshooting server rename
              Verifying URLs and links after a server rename
              Completing the server rename verification process
                Jazz Team Servers
                Change and Configuration Management
                Quality Management
                Requirements Management
                Design Management
                Rational ClearQuest and Rational ClearCase
              Troubleshooting server rename
                General recovery procedures
                Recovering from generateURLMappings errors
                Recovering from importURLMappings errors
                Responding to server rename status errors
                Reviewing a history of server renames
          Configuring the location of the help in a distributed environment
          Managing data collection with default CLM data collection
        Installing optional tools, clients, and samples
          Installing the Build System Toolkit
            Installing by using Installation Manager
            Installing from a .zip file
            Installing the Build System Toolkit on IBM i systems
            Installing and configuring the Build System Toolkit on z/OS systems
              Creating additional directories (required)
              Configuring the ISPF gateway for build, deployment, and promotion support
          Installing the Rational Build Agent
            Installing on z/OS systems
              Creating additional Rational Build Agent directories
              Configuring the Rational Build Agent shell script
              Completing the installation and running the Rational Build Agent
              Using InetD to start the agent
              Configuring the agent
                Locating the agent configuration file
                Changing the agent port
                Configuring a different shell
                bfagent executable file
                bfagent.conf file
            Installing on IBM i systems
              Installing and running the Rational Build Agent on IBM i systems
              Configuring the agent
                Locating the agent configuration file for IBM i systems
                Changing the agent port
                Configuring a different shell
                bfagent executable file
                bfagent.conf file
            Installing and configuring the Rational Build Agent on Linux, UNIX, and Windows
              Installing an agent
                Installing an agent on Windows
                Installing an agent on Linux and UNIX
              Running an agent
                Running an agent on Windows
                Running an agent on Linux and UNIX
              Configuring the Rational Build Agent
                Locating the agent configuration file
                Changing the agent port
                Configuring a different shell
                Running agent commands on a Network Share File System (Windows)
                bfagent executable file
                bfagent.conf file
            Build Agent Lookup Service
              Configuring a lookup service task
            Troubleshooting the Rational Build Agent
          Installing Rational Team Concert connectors
            Installing Rational Team Concert ClearCase Synchronizer
              Installing by using Installation Manager
              Installing from a .zip file
            Installing Rational Team Concert ClearQuest Synchronizer
              Installing by using Installation Manager
              Installing by using Installation Manager
          Installing Rational Team Concert clients
            Installing by using Installation Manager
            Installing the Eclipse client from a .zip file
            Installing the client in Eclipse (p2 install)
            Installing Rational Team Concert Client for Microsoft Visual Studio IDE
            Installing Rational Team Concert Shell
            Installing Rational Team Concert MS-SCCI Provider
            **** MISSING FILE ****
          Installing the Rational Team Concert ISPF client
            ISPF client security
              Security settings and classes
              OMVS segment
              Data set profiles
              ISPF daemon started task on System z
              ISPF daemon as a secure z/OS UNIX server
              Application protection for the ISPF daemon
              ISPF PassTicket support
              z/OS UNIX program-controlled files for the ISPF daemon
            Troubleshooting ISPF client security
              Troubleshooting ISPF client permissions
              Troubleshooting ISPF client PassTicket support
            ISPF daemon configuration
              Started tasks for the ISPF daemon
              ISPF daemon configuration file (ispfdmn.conf)
              ISPF daemon START (S) command
            Configuring and running the ISPF client on z/OS systems
              Starting the ISPF client
          Installing the context-aware search tool
            Installing on Windows, Linux, AIX, or Solaris systems
            Installing on z/OS systems
            Installing on IBM i systems
              Starting and stopping the search engine
          Installing the Money that Matters sample
            Configuring the Money that Matters sample environment
          Installing Rational AppScan Tester Edition
        Uninstalling Jazz Team Server and the CLM applications
        Release notes
      Upgrading and migrating
        Upgrading the Rational solution for Collaborative Lifecycle Management (CLM)
          Deployment and upgrade planning for the Rational solution for CLM
            Deployment and upgrade
              Hardware and software requirements
              Deployment and upgrade process
              Client and server version compatibility
              Reporting and the upgrade process
              Licensing
              Planning to upgrade on UNIX, IBM i, and z/OS systems
                Special instructions for upgrading on IBM i
                Planning to upgrade on z/OS
            Staging a test environment for the upgrade process
            Examples: Upgrade process and topology
              Example: Upgrade stand-alone products to an integrated solution
              Example topology: Upgrade from a distributed CLM enterprise version 4 to the current version
          Downloading the installation media for an upgrade
          Upgrading from version 3 to the current version
          Interactive upgrade guide
          Upgrade script files
            jts_upgrade script
            ccm_upgrade script
            qm_upgrade script
            rm_upgrade script
          Upgrading the server configuration on z/OS
          Configuring the data warehouse after an upgrade
          Verifying the upgrade
            Verifying the configuration files during upgrade
            Verifying logs, URLs, and administrative pages
            Verifying users, licenses, and linked artifacts
          Upgrading optional tools, clients, and reporting artifacts
            Upgrading Rational Team Concert clients for Microsoft Visual Studio and Eclipse IDE
            Upgrading Jazz Build Engine
            Upgrading the Build System Toolkit on IBM i
            Upgrading the Build System Toolkit and Rational Build Agent on z/OS
            Upgrading the ISPF client daemon
            Upgrading the Rational Developer for System z integration
            Upgrading Rational Developer for Power Systems Software 8.5 to Rational Developer for i 9.0
            Upgrading Rational Developer for zEnterprise
            Upgrading ClearQuest Synchronizer
            Upgrading process templates
            Upgrading reporting artifacts
        Migrating the database and application server
          Migrating databases
          Switching from Apache Tomcat to WebSphere Application Server
          Changing WebSphere Application Server installations and instances
      Administering
        Administering Rational solution for Collaborative Lifecycle Management servers
          Getting started: Server and repository administrator
          Repository
          Logging in to administer the server
          Registering applications with the Jazz Team Server
            Managing registered applications
          Managing licenses
            Managing client access licenses
              Client access license management overview
              TRS Consumer - Internal license
              Installing and managing client access license keys
            Managing floating client access licenses
              Floating client access license management overview
              Installing and managing floating client access license keys
              Monitoring and releasing floating client access licenses
            Managing floating client access licenses — distributing Rational Common Licensing tokens
              Setting up the Rational Common Licensing token service keys
          Managing users
            Understanding licenses, permissions, and access control
            Creating users
              Importing users from an external user registry
              IBM i authentication methods
            System users
            Assigning client access licenses to users
            Assigning default licenses to new users
            Allowing users to register themselves
            Receiving email notification when a new user self registers
            Disabling the default administrative user
              Disabling the default administrative user on IBM i
            Archiving and restoring users
            Resetting a user password
            Changing your password
          Configuring the server
            Configuring email settings
            Configuring database connections
            Configuring feed settings
            Configuring the frequency of feeds
            Configuring themes
            Configuring OAuth consumers
              Registering consumer keys
              Approving consumer keys
              Editing consumer keys
              Deleting consumer keys
            Configuring friends
              Establishing friend relationships
              Editing servers in the friends list
              Deleting servers from the friends list
            Managing the URL whitelist
            Configuring advanced properties
            Storing passwords in a clear text file
            Managing the size of the log file
            Enabling distributed source control
            Enabling Open Services for Lifecycle Collaboration
            Synchronizing LDAP with Jazz Team Server repository user information
              Viewing the results of a synchronization
              Changing the synchronization frequency
          CLM server monitoring
          Backing up and restoring CLM applications
          Backing up and restoring the Derby database
          Backing up and restoring other supported databases
          Patch service for CLM applications
      Troubleshooting and support
        General product troubleshooting
          Registering on the IBM Support Portal
          Accessing release information
          Subscribing to product updates
          Searching online knowledge bases
          IBM Support Assistant
          IBM Education Assistant
          Getting fixes
          Contacting IBM Software Support
          Fixing line wrap issues in Internet Explorer
          Disabling logging in Eclipse-based products
        Log file locations
        Messages
        Using the IBM Support Assistant Lite to gather diagnostic information
          Running the IBM Support Assistant Lite utility
          Expanding the scope of data gathered
          Reducing the scope of data gathered
        Troubleshooting Jazz Team Server
          Troubleshooting the Jazz Team Server setup wizard
      Reference
        Repository Tools command-line reference
          -addTables
          -archiveUser
          -backupJFSIndexes
          -compacttdb
          -convertTomcatUsers
          -copy
          -createTables
          -createUser
          -createUsers
          -createWarehouse
          -deleteJFSResources
          -dropTables
          -executeDiagnostics
          -export
          -exportServerRenameURLMappingHistory
          -exportUsers
          -finalizeApplicationMigration
          -generateURLMappings
          -generateWarehouseDDLScripts
          -generateWarehouseUpgradeScripts
          -help
          -import
          -importURLMappings
          -importUsers
          -isServerRunning
          -listIssuedFloatingLicenses
          -listLicenses
          -listStorageAreaKeys
          -migration_importJTSData
          -migration_ccm_updateConfigurationFiles
          -migration_jts_updateConfigurationFiles
          -migration_qm_updateConfigurationFiles
          -modifyLinkURIs
          -onlineMigrate
          -onlineMigrateEstimate
          -onlineMigrateRevert
          -onlineMigrateStop
          -patchApplyApp
          -patchApplyGlobal
          -patchRevertApp
          -patchRevertGlobal
          -rebuildClosureTable
          -rebuildIndices
          -rebuildTextIndices
          -reindex
          -repairSuites
          -resetRepoLockId
          -restoreJFSIndexes
          -resumeIndexer
          -rmUpdateConfigurationFiles
          -rmUpdateProjectBackLinks
          -rmUpdateProjectBackLinksOnline
          -setStorageAreaKeys
          -setup
          -suspendIndexer
          -syncUsers
          -upgradeWarehouse
          -verify
          -verifyURLMappings
          -version
    Rational DOORS Next Generation
      Overview
        Overview of the Requirements Management application
          Overview of Rational DOORS Next Generation
          Rational DOORS compared to Rational DOORS Next Generation
        Getting started with Rational DOORS Next Generation
          Getting started for RM project administrators
          Getting started with creating and managing requirements
          Videos and task scenarios
      Tours
        Rational DOORS Next Generation overview
      Tutorials
        Create and define requirements
          Introduction: Create and define requirements
          Lesson 1: Create requirements and edit requirement attributes
          Lesson 2: Create links in requirements
          Lesson 3: Tag artifacts by using shared tags
          Lesson 4: Import Microsoft Word documents
        Find and view project artifacts in a requirements project
          Introduction: Find and view project artifacts
          Lesson 1: Open and view artifacts
          Lesson 2: Find and tag artifacts
        Comment on and review requirement artifacts
          Introduction: Comment on and review requirement artifacts
          Lesson 1: Comment on requirement artifacts
          Lesson 2: Review and approve requirement artifacts
        Create collections and reviews
          Introduction: Create collections and reviews
          Lesson 1: Create a collection
          Lesson 2: Create a review of a collection
        Create and administer a project
          Introduction: Create and administer a project
          Lesson 1: Create a project, add a user, and assign a process role
          Lesson 2: Run a requirements report
          Lesson 3: Customize the project dashboard
        Manage requirements in the Rational solution for CLM
          Introduction: Manage requirements in the Rational solution for Collaborative Lifecycle Management (CLM)
          Lesson 1: Create links from requirements to development and test artifacts
          Lesson 2: Create links from collections to release plans and generate plan items
          Lesson 3: Create links from collections to test plans and generate test cases
          Lesson 4: Monitor the status of artifacts by using CLM links
          Lesson 5: View CLM links on the project dashboard
        Create and organize modules
          Introduction: Create and organize modules
          Lesson 1: Create a module and add artifacts
          Lesson 2: Modify the hierarchy of artifacts in a module
          Lesson 3: Add comments to artifacts in a module
          Lesson 4: Create a module from a text document
      Installing
        Installing the RM application
      Upgrading and migrating
        Upgrading the RM application
        Migrating Rational RequisitePro projects to the Requirements Management application
          Support for data types in migrated projects
          Support for user groups in migrated projects
          Support for view query conditions
          Migrating a Rational RequisitePro project
          Importing Rational RequisitePro users into a Tomcat project registry
          Migrating Rational RequisitePro projects with Rational Quality Manager integration to the RM application
          Capability comparison: Rational RequisitePro and the RM application
      Integrating
        Rational RequisitePro
        Rational DOORS
          Configuring the RM application to be a consumer
          Associating an RM project with a Rational DOORS module
          Configuring the RM application to be a provider
        Rational ClearQuest
        Rational Change
      Administering
        Administering Rational solution for Collaborative Lifecycle Management servers
        Administering requirements projects
          Creating requirements projects
          Project baselines
          Permissions
          Creating requirements project templates
          Managing requirements project templates
          Creating artifact templates
          Managing artifact templates
          Creating module templates
          Creating module baselines
          Managing project properties in a requirements project
            Creating artifact types
            Creating attributes
            Creating requirement attribute data types
            Importing project properties from a Requirement Management (RM) project
          Creating link types
            Link types
      Collaborating
        Dashboards in the RM application
      Managing and composing requirements
        Joining a requirements project
          Logging in to a requirements project repository
          Project dashboards
          Personal dashboard
        Defining requirements
          Creating artifacts
            Artifacts
            Artifact types
            Artifact formats
          Editing attributes with multiple values
          Filters and views
          Locks
          Artifact search
          Uploading files
          Data exchange methods
          Vision document
          Creating modules
            Modules
            Differences between collections and modules
            Duplicating a module
            Searching for artifacts in a module
            Linking between artifacts in modules
            Modifying hierarchy in modules
            Reusing artifacts in modules
            Filters and views
            Adding comments to artifacts in a module
            Exporting artifacts from modules to CSV files
          Importing and exporting files
            Import document planning
            Importing documents
            Importing and extracting artifacts from documents
            Importing artifacts from CSV files
            Exporting artifacts to CSV files
            CSV format and examples
            ReqIF files
              Importing from ReqIF files
              Exporting to ReqIF files
          Creating collections
            Collections
            Comparing collections
          Creating artifacts to support requirements
            Defining business processes
              Business process diagram overview
              Business rules
              Business process diagrams
              Business process elements
              Creating a business process diagram
            Creating use cases
              Use cases
              Creating a use-case diagram
              Creating an actor artifact
              Use-case specification outline
            Sketching the user interface
              User interface sketches
              Creating a user interface sketch
              Creating a user interface part
            Creating a screen flow
              Screen flows
            Creating a storyboard
              Storyboards
          Managing terminology and glossaries
            Glossaries
            Creating a glossary and terms
          Commenting on artifacts
          Reviewing artifacts
            Reviews
            Creating reviews
            Participating in a review
        Managing requirements
          Managing artifacts with attributes
          Adding tags to artifacts and viewing tagged artifacts
          Comparison of artifact grouping methods in requirements management
          Traceability
          Suspect traceability
            Creating suspicion profiles
            Viewing and clearing suspect traceability
            Suspicion indexing
          Managing requirements status and other properties
          Analyzing the impact of change
          Linking
            Links
            Linking to existing artifacts in lifecycle applications
            Linking to new artifacts in lifecycle applications
            Linking collections, modules, and module views to development and test plans
            Links explorer
            Linking requirements to Rational ClearQuest records
            Filtering artifacts for links to other applications
          Viewing artifact history
      Reporting
        Reporting
          Creating document-style reports
          Running data warehouse reports
          Requirements Management (RM) application report descriptions
          RM reportable REST API
          Data dictionary
      Extending product function
        Extending the RM application
        Extending by using OSLC services
          RM as an OSLC service consumer
          RM as an OSLC service provider
          Links across OSLC domains
          Additional OSLC integration services and requirements
      Troubleshooting and support
        Troubleshooting the RM application
          Log file locations
          Fixing a converter issue in the server in headless mode
          Opening multiple browser tabs or windows
          Opening artifacts in new tabs in the same browser window
          Redirecting HTTP requests
          Pasting invalid XHTML text
          Cutting, copying, and pasting text
          Updating custom Word templates
          Creating a hyperlink to a local file
          Moving artifacts from a folder
          Support information for the RM application
    Rational Team Concert
      Overview
        Overview of Rational Team Concert
        Getting started with Rational Team Concert
      Tours
        Rational Team Concert overview
        Rational Team Concert source control
        Rational Team Concert Build
        Rational Team Concert planning
        Rational Team Concert Enterprise Extensions tours
          Dependency builds (part 1)
          Dependency builds (part 2)
          Dependency builds (part 3)
          Dependency builds on IBM i
          Context-aware search
          Component promotion
          Work item promotion (part 1)
          Work item promotion (part 2)
          Packaging and deployment
          Source code data collection service
          Rational Developer for System z integration feature
          ISPF client
          ISPF client build results management
        Help content configuration options
      Tutorials
        Getting started
          Get started with Rational Team Concert
            Lesson 1: Setting up a project and team as Administrator
            Lesson 2: Getting connected
            Lesson 3: Using work items
            Lesson 4: Working with plans
            Lesson 5: Using the Team Dashboard and My Work views
            Lesson 6: Managing source code
            Lesson 7: Building with Rational Team Concert Build
            Lesson 8: Using the web client
            Summary
          Explore the Rational Team Concert JUnit example project
          Using an Ant with Enterprise Extensions build to compile a COBOL application
            Lesson 1: Preparing your environment
            Lesson 2: Configuring the Rational Build Agent shell script
            Lesson 3: Configuring the Rational Build Agent
            Lesson 4: Creating data set definitions
            Lesson 5: Creating translators
            Lesson 6: Creating language definitions
            Lesson 7: Creating a shared zComponent Project
            Lesson 8: Adding zFolders and associating them with data set definitions
            Lesson 9: Adding build artifacts and associating them with language definitions
            Lesson 10: Configuring a build definition
            Lesson 11: Requesting a build
          Configuring your Jazz Team Server and Rational Team Concert Eclipse client for a sample z/OS application
        Project planning
          Plan an agile project
            Introduction: Plan an agile project
            Lesson 1: Create the product backlog
            Lesson 2: Plan the release
            Lesson 3: Plan the sprint
            Lesson 4: View your work
            Lesson 5: Track progress by using queries
            Lesson 6: Schedule the sprint review
            Lesson 7: Shut down the sprint
            Summary: Plan an agile project
          Plan a traditional project
            Introduction: Plan a traditional project
            Lesson 1: Create a release plan for the project
            Lesson 2: Add resources to the project plan
            Lesson 3: Identify and plan for risks
            Lesson 4: Define project work
            Lesson 5: Create phase plans and the plan schedule
            Lesson 6: Assign owners to work items
            Lesson 7: Take a snapshot of the planned schedule
            Summary: Plan a traditional project
          Define and manage risks
            Lesson 1: Define a risk
            Lesson 2: Create a risk action
            Lesson 3: Linking a risk with a risk action
            Summary: Define and manage risks
          Create plans and work items in the Rational Team Concert Client for Microsoft Visual Studio IDE
            Create plans and work items
            Lesson 1: Create a plan
            Lesson 2: Create a work item
        Project management
          Control access to project areas and their artifacts
            Introduction: Control access to project areas and their artifacts
            Lesson 1: Control read access to project area
            Lesson 2: Restrict access to work items based on team membership
            Lesson 3: Control access to specific work items by using an access group
            Lesson 4: Restrict access to source control artifacts
            Summary: Control access to project areas and their artifacts
          Standardize process by using project area process sharing
            Introduction: Standardize process in your organization by using project process sharing
            Lesson 1: Create a provider project area
            Lesson 2: Create a standard setup process template
            Lesson 3: Create a consumer project area
            Lesson 4: Show that the consumer project area uses the process from the provider project area
            Lesson 5: Override permissions in the consumer project area
            Lesson 6: Prevent the consumer project area from overriding the permission settings inherited from the provider project area
            Summary: Standardize process in your organization by using project area process sharing
        Work item customization
          Customize work items
            Customize work items
            Lesson 1: Create a work item type
            Lesson 2: Create a work item attribute
            Lesson 3: Create an enumeration attribute type
            Lesson 4: Define a workflow with approval tracking
            Lesson 5: Customize the work item editor
            Lesson 6: Create a ToDo work item
        Source control
          Share changes with your team
            Share changes with your team
            Lesson 1: Create a repository workspace from a stream
            Lesson 2: Deliver changes and resolve a work item
            Lesson 3: Accept changes from other team members
            Lesson 4: Resolve a conflict
          Share changes using the web client
            Share changes using the web client
            Lesson 1: Add files and folders to a stream
            Lesson 2: Lock, download, and edit a file
            Lesson 3: Create and edit a text file
          Share changes with your team in the Rational Team Concert Client for Microsoft Visual Studio IDE
            Share changes with your team
            Lesson 1: Create a repository workspace from a stream
            Lesson 2: Deliver changes and resolve a work item
            Lesson 3: Accept changes from other team members
            Lesson 4: Share a project and solution
          Share changes with your team in the Rational Team Concert Shell
            Share changes with your team
            Accept a team invitation
            Create a repository workspace
            Deliver changes to team members
            Set preferences
            Resolve a conflict
            Work with Jazz properties
            Share changes in Basic mode
          Preserve component and workspace configuration in the Rational Team Concert Client for Microsoft Visual Studio IDE
            Preserve component and workspace configuration
            Lesson 1: Create a component baseline
            Lesson 2: Accept incoming baselines and change sets
            Lesson 3: Create a snapshot and assign an owner to it
        Build management
          Manage builds with the Rational Team Concert Build
            Manage builds with the Rational Team Concert Build
            Lesson 1: Build definitions and build engines
            Lesson 2: Build requests
            Lesson 3: Build results
          Manage builds with the Rational Team Concert Build in the Rational Team Concert Client for Microsoft Visual Studio IDE
            Manage builds with the Rational Team Concert Build
            Lesson 1: Build definitions and build engines
            Lesson 2: Build requests
            Lesson 3: Build results
          Using Enterprise Extensions dependency builds
            Introduction: Using Enterprise Extensions dependency builds
            Lesson: Using dependency builds to build new and changed artifacts
        ClearCase and ClearQuest Synchronizers
          Get started with the ClearCase Synchronizer
            Introduction: Get started with the ClearCase Synchronizer
            Create a Jazz administrative user
            Add a process role to the Jazz administrative user
            Create a ClearCase Synchronized Stream and merge workspace
            Import files and folders from Rational ClearCase
            Load imported files to a Rational Team Concert workspace
            Deliver changes in a synchronized environment
            Verify exported files in Rational ClearCase
            Create a schedule for future synchronizations
            Summary
          Get started with the Rational ClearQuest Synchronizer
            Module 1: Setting up your Rational ClearQuest environment
              Lesson 1.1: Create a schema repository
              Lesson 1.2: Create a schema and user database
            Module 2: Setting up your Jazz environment
              Lesson 2.1: Create an administrative user
              Lesson 2.2: Create a project area
            Module 3: Using the ClearQuest Synchronizer Setup Wizard
              Lesson 3.1: Start the Rational ClearQuest Gateway
              Lesson 3.2: Use the Rational ClearQuest Synchronizer Setup Wizard
            Module 4: Editing synchronization rules
              Lesson 4.1: Assign a role with necessary permissions to the ClearQuest Synchronizer user
              Lesson 4.2: Edit Project synchronization rule
              Lesson 4.3: Edit the Defect synchronization rule
            Module 5: Enabling outgoing synchronization
              Lesson 5.1: Enable outgoing synchronization for the Jazz Team Server
              Lesson 5.2: Enable outgoing synchronization for the external repository connection
            Module 6: Testing the configuration
              Lesson 6.1: Submit a Project record
              Lesson 6.2: Submit a Defect record
            Summary
      Scenarios
        Iterative development
          Planning an iteration
          Managing iterations
          Assessing iteration results
        Managing risks
      Installing
        Installing the Change and Configuration Management application
      Upgrading and migrating
        Upgrading the Change and Configuration Management application
        Online migration
        Migrating from the ClearQuest Synchronizer to the ClearQuest Bridge
      Integrating
        Rational Build Forge
          Creating Build Forge build engines
          Creating Build Forge build definitions
        Rational Change
        Rational ClearCase
          Getting started with the Rational ClearCase connectors
          Rational Team Concert concepts for Rational ClearCase users
          Synchronizing data with the ClearCase Synchronizer and ClearCase Baseline Importer
            Deploying Rational Team Concert into a Rational ClearCase Environment
            Planning to synchronize and import
              Guidelines for Rational ClearCase users
              How element types map to item content types
              Selecting the Rational ClearCase stream or branch to synchronize
              How exports are mapped to VOBs and UCM components
              Imported components in synchronized streams
              Running ClearCase Synchronizer subcommands from the command line
              Updating the synchronizer after server rename
                Updating the synchronizer in production environments
                Updating the synchronizer in test-staging environments
            Preparing the synchronization environment
              Configuring a synchronization host
              Selecting an operating system account for the synchronization process
              Creating a Jazz administrative user for the synchronization process
              Adding the Jazz administrative user to your team
              Preparing a sub-VOB component for base Rational ClearCase synchronization
                Known limitations of sub-VOB component mapping
                Migrating a synchronization stream
            Synchronizing data with the ClearCase Synchronizer
              Creating a ClearCase Synchronized Stream and merge workspace
                Importing files and folders from Rational ClearCase
                Exporting files and folders to Rational ClearCase
                Removing a synchronization root
                Loading a component root folder into a sandbox
                Specifying line termination characters for text files
                Configuration specification details for base Rational ClearCase
                Creating a synchronized stream work item template
                Writing Rational ClearCase triggers for synchronization
                Configuring a synchronized stream to support UCM projects that are enabled for Rational ClearQuest
              Running synchronizations
                Scheduling synchronization
                Running custom scripts before and after synchronization
                Resolving conflicts during synchronization
                Stopping the synchronization build engine process
                Starting the synchronization build engine process
                Canceling and abandoning a synchronization request
              Delivering changes in a synchronized environment
            Importing
              Preparing to import Rational ClearCase data with history
              Importing multiple streams from Rational ClearCase UCM or base Rational ClearCase
              Importing Rational ClearCase history from a UCM stream
              Importing Rational ClearCase history from base Rational ClearCase
              Verifying the imported history of a stream or component
              Importing additional Rational ClearCase history
            Managing the synchronization environment
              Managing ClearCase Synchronized Streams
                Editing a synchronized stream
                Synchronization options
                Synchronized stream properties
                Unlocking a synchronized stream
                Changing the default script location of a synchronized stream
              Managing the synchronization host
                Changing the synchronization host
                Changing the Rational ClearCase dynamic view
                Upgrading the ClearCase Synchronizer
              Managing merge workspaces
                Modifying the merge workspace
                Creating a merge workspace for an existing synchronized stream
            ClearCase Synchronizer limitations and known problems
              Troubleshooting synchronization problems
              Synchronization errors
          Migrating data with the ClearCase Version Importer
            Planning to export and import with the ClearCase Version Importer
              Identifying VOBs and subfolders for migration
              Choosing the Rational ClearCase view configurations
              Selecting versions to export by filtering
                Examples of selecting versions with filters
              Planning disk space for exporting or importing
              Planning to migrate data incrementally
              How element types map to item content types
            Preparing the environment for exporting and importing with the ClearCase Version Importer
              Configuring the export and import hosts
              Selecting an operating system account for exporting
              Adding the Jazz administrative user account to your team
              Creating Rational Team Concert streams and components
            Exporting and importing data with the ClearCase Version Importer
              Exporting multiple configurations
              Migrating data in increments
              Exporting data and specifying the change-set comment format
              Updating character encoding of text files
              Excluding file elements from the exported data files
              Specifying the user accounts mapping
              Importing data into Rational Team Concert source control
              Importing change-set links from the Rational ClearQuest and Rational ClearCase integration
              Verifying the imported history of a stream or component
            ClearCase Version Importer limitations and known problems
              Troubleshooting export problems
              Troubleshooting import problems
              Error messages
          Using the ClearCase Bridge
            ClearCase Bridge version compatibility and functionality
            Connecting Rational Team Concert and UCM
              Manually associating a Rational ClearCase activity with a work item
              Viewing linked work items and UCM activities
              Enforcing an association between a Rational ClearCase activity and a work item
              Configuring site-wide ClearCase Bridge UCM integration
            Connecting Rational Team Concert and base Rational ClearCase
              Associating Rational ClearCase element versions with a work item during operations
              Manually associating a Rational ClearCase element version with a work item
              Viewing linked work items and element versions
            Updating the bridge after server rename
              Updating the bridge in production environments
              Setting up a test staging environment with production data
        Rational ClearQuest
          Configuring and using the Rational ClearQuest Synchronizer
            Getting started with the ClearQuest Synchronizer
            Prerequisites
            Configuration checklist
            Deploying the ClearQuest Synchronizer
              Connecting to multiple project areas
              Starting the ClearQuest Gateway
              Verifying that the ClearQuest Gateway is running
            Using the ClearQuest Synchronizer Setup Wizard
              Starting the ClearQuest Synchronizer Setup Wizard
              Configure ClearQuest
              Jazz server configuration
              Create ClearQuest record filtering queries
              Reset Gateway
            Configuring a Jazz project area for the ClearQuest Synchronizer
              Synchronization rules
              Planning synchronization rules
                Sample planning worksheet
                Reviewing generated synchronization rules
              Creating synchronization rules
                Mapping record types to work item types
                Configuring synchronization rules for external users
                Editing synchronization rules to specify categories
                Creating a synchronization rule for attachments
                Mapping comments to notes log entries
                Mapping referenced fields
                Displaying the contents of a referenced record
                Synchronizing users
                How items become candidates for outgoing synchronization
              Creating and modifying an external repository connection
            Modifying Connector service parameters
            Configuring the ClearQuest Synchronizer to create OSLC links
            Stopping and restarting the ClearQuest Gateway
            Enabling outgoing synchronization
            Testing the ClearQuest Synchronizer
            Preparing the ClearQuest Synchronizer for renaming the Jazz Team Server
              Preparing the ClearQuest Synchronizer for a server rename operation
              Performing post-server rename actions for the ClearQuest Synchronizer – test staging scenario
              Performing post-server rename actions for the ClearQuest Synchronizer – production scenarios
            Importing a batch of ClearQuest records
              Importing but not synchronizing records
            Working in a configured environment
              Associating a category with a team area
              Viewing synchronization status
              Finding and resolving conflicts
              Filtering for connector events
              Resolving blocked synchronization
              Resolving communication problems with the Jazz Team Server
              Viewing log files
              Deleting records and work items
              Preparing to archive a synchronized project area
              Additional troubleshooting resources
            MultiSite considerations
              Applying the JazzInterop package to MultiSite replica schemas
            Additional resources
            Upgrading the user database with a new version of the JazzInterop package
          Configuring and using the Rational ClearQuest Bridge
            Getting started with the ClearQuest Bridge
            Configuring the ClearQuest Bridge
            Working with records in the web client
              Adding ClearQuest content on the dashboard
                Adding the ClearQuest Query widget
                Configuring the ClearQuest Query widget
                Adding the ClearQuest Chart widget
                Configuring the ClearQuest Chart widget
              Finding and reviewing records
              Updating and resolving records
            Associating work items and records
            Agile planning for records
              Breaking down the ClearQuest backlog
              Updating work items and records
              Prioritizing and scheduling work items
              Tracking work item and iteration progress
              Resolving work items and records
          Migrating Rational ClearQuest records to work items
            Customizing the mapping file
              Mapping attributes
              Specifying attribute types
              Mapping attribute values
              Concatenating field values for the work item category mapping
              Mapping record types to work item types
              Mapping state and resolution values
              Mapping ClearQuest record relationships to work item relationships
              Importing ClearQuest FTP links
        Rational DOORS
        Rational Engineering Lifecycle Manager
        Rational Focal Point
        Git
        Hudson/Jenkins build engine type
          Creating a Hudson/Jenkins build engine
          Creating a Hudson/Jenkins build definition
        IBM Connections
          Associating a Jazz project with an IBM Connections community
          Adding the IBM Connections widget to a project dashboard
          Connecting to a IBM Connections community
          Sharing ideas with a IBM Connections community through work items or dashboards
        IBM UrbanCode Deploy
          Creating build definitions for IBM UrbanCode Deploy
        Jenkins plugin
        Microsoft Source Code Control Interface
          Setting up repository workspaces
            Connecting to repositories and project areas
            Creating repository workspaces
            Loading repository workspaces
          Sharing changes with your team
            Sharing changes
            Checking in change sets
            Accepting incoming change sets
            Delivering change sets
          Additional features
          Integrating Rational Rhapsody with Rational Team Concert and MS-SCCI
            Configuring MSSCCI as the source control provider
            Source control operation mappings for Rational Rhapsody
            Sharing changes in Rational Rhapsody
            Viewing the change history of files
            Viewing file properties
          Setting preferences
        Rational Synergy
        Subversion
          Importing Subversion repository contents to Rational Team Concert source control
          Importing a Subversion dump file
          Importing branches after you import the trunk
          Linking work items to Subversion repositories
        Rational Developer for i
          Installing and configuring the integration
          Introduction to Rational Team Concert and Rational Developer for i
            Orientation to Rational Team Concert for Rational Developer for i users
            Orientation to Rational Developer for i for Rational Team Concert users
          Developing IBM i applications using Rational Developer for i
          Sharing i Projects
        Rational Developer for Power Systems Software
          Installing and configuring the integration
          Introduction to Rational Team Concert and Rational Developer for Power Systems Software
            Orientation to Rational Team Concert for Rational Developer for Power Systems Software users
            Orientation to Rational Developer for Power Systems Software for Rational Team Concert users
          Developing AIX applications using Rational Developer for Power Systems Software
          Developing IBM i applications using Rational Developer for Power Systems Software
          Sharing i Projects
        Rational Developer for System z
          Installing and configuring the integration
            Installing the file agent RSE miner
            Installing the integrated client
            Installing Rational Team Concert on Rational Developer for System z
          Orientation to Rational Developer for System z and Rational Team Concert integration
            Orientation to Rational Team Concert for Rational Developer for System z users
            Orientation to Rational Developer for System z for Rational Team Concert users
          Adding Rational Developer for System z to an existing Rational Team Concert installation
            Differences in Rational Developer for System z operations after sharing artifacts to Rational Team Concert
            Managing dependencies
            Loading artifacts to Rational Developer for System z
            Adding an artifact to Rational Team Concert
          Working with Rational Team Concert projects locally
          Requesting a user build
            Adding error feedback support to user build
            Built-in Jazz properties
            JCL parm can exceed the character limit
            Specify alternative DD names in user build
          Setting up additional debug parameters on z/OS
      Administering
        Administering Rational solution for Collaborative Lifecycle Management servers
        Administering change and configuration management project areas
          Working in the web client
          Working in the client for Eclipse IDE
            Connecting to repositories and project areas
            Connecting to JazzHub projects
            Accepting a team invitation
            Creating and modifying project areas
              Creating project areas
              Sharing the process of a project area
                Enabling project area process sharing across servers
                Making a project area shareable
                Modifying a project area to use another project area's process
              Creating timelines, iterations, and iteration types
              Setting project hours and days per week
              Creating a team area
              Adding and modifying users as members of project areas
                Adding existing users
                Creating users
                Importing users from an external registry service
                Assigning roles to users
                Assigning administrative privileges
                Modifying user information
                Setting user work environments
                Scheduling team member absences
              Defining work item categories
              Adding attachments to project areas and team areas
              Restricting read access to project area, team areas, and artifacts
                Restricting read access to project areas or team areas
                Restricting access to work item categories
              Archiving project areas and team areas
              Adding associations
            Customizing the process in projects, teams, and templates
              Editing the process description
              Modifying timelines and iterations
              Modifying roles
              Modifying permissions
              Synchronizing time entries
              Modifying operation behavior (preconditions and follow-up actions) in project areas and team areas
                Operation Behavior (preconditions and follow-up actions)
              Modifying project area initialization
              Adding formal project management features to a process template
                Process customization for formal project management
              Viewing history of changes to process
              Refreshing the client to see process changes
            Working with process templates
              Creating a process template
              Process templates
                OpenUP process template
                Scrum process template
                Simple Team process template
                Formal Project Management Process template
                Unconfigured Process template
              Creating process template documentation
              Including reports in a process template
              Exporting and importing process templates
              Migrating a project to a different process template
              Adding a translation to a process template
              Making templates translatable
          Working in the client for Microsoft Visual Studio IDE
            Working with projects and teams
              Project concepts
                Repository
                Project area
                Team area
              Getting started with projects and teams
              Accepting team invitations
              Connecting to repositories
                Deleting repository connections
                Modifying repository connection properties
                Viewing Client Access License and server information
              Connecting to project areas
              Connecting to JazzHub projects
              Disconnecting project areas
              Clearing session history
      Collaborating
        Getting started with your development project
          Getting started: Project administrator
          Getting started: Team lead
          Getting started: Team member
          Quick reference
        Managing dashboards
        Creating development plans
          Getting started with planning
          Plans and work item management
            Plan types
            Agile planning
            Traditional planning
              Schedules in traditional project plans
              Schedule dependencies
              Schedule constraints
              Critical path
              Basic resource leveling
              The Work breakdown and Schedule chart
          Planning the development with the Eclipse client
            Planning projects
              Creating project plans
              Adding unstructured content to plan notes
              Renaming and reassigning a plan
              Duplicating plans
              Setting work item types as plan items
              Resolving conflicts in planned items
              Viewing plans associated to a work item
              Subscribing to plans
              Linking development plans
            Changing plan configuration settings for a project
              Setting project hours and days per week
              Configuring the preview pane
              Computing progress of release plans
              Showing time remaining or time spent
              Configuring attributes in customized work items to display in a plan
              Permitting users to modify allocation
            Managing work items and work loads
              Viewing work items in a plan
              Adding work items to a plan
              Modifying and moving work items in a plan
              Creating a work item in a plan from a template
              Find, filter, and colorize work items
              Organizing work items with plan views
                Creating plan views
                Configuring plan views
                Associating plan views with a plan type
                Modifying plan view elements in the process configuration
              Ranking work items
              User profile
                Setting a user's work environment
                Scheduling team member absences
              Configuring team loads
              Managing work items in My Work view
                Managing my new work
                Managing my current work
                Managing my future work
                Previewing my work items
            Progress reports and charts
          Planning the development with the web client
            Planning projects
              Creating project plans
              Creating a child iteration
              Tracking progress with plan dashboards
              Importing and exporting plans with Microsoft Project
                Importing, exporting, and reimporting project plans
              Plan snapshots
                Taking, comparing, and deleting plan snapshots
              Linking development plans
            Managing work items
              Viewing work items in a plan
              Viewing the Work Breakdown and Schedule chart (Gantt chart)
              Creating, modifying, and moving work items in a plan
              Creating work items from requirements
              Creating schedule dependencies between work items
              Tracking work item relationships across projects
              Organizing work items in a plan
                Creating plan views
                  Plan view options
                Configuring existing plan views
              Ranking work items
                Ranking all work items in a plan
                Ranking work items by dragging
                Ranking work items by using menu options
                Changing the ranking of work items
            Managing project resources
              Allocating resources to a project
              Adding allocation periods for resources
              Modifying allocation periods for resources
              Adding allocation periods for a project
            Load, Progress, and Burndown reports in the Plan Details
          Planning the development with the Rational Team Concert Client for Microsoft Visual Studio IDE
            Creating development plans
              Plans and work item management
              Plans
                Plan types
              Creating plans
                Creating plan overviews
                Adding plan pages
                Renaming and reassigning plans
              Managing work items
                Grouping work items in plans
                Modify work items in plans
                Creating plan modes
                Configuring plan modes
        Instant messaging
          Connecting to local Sametime applications
          Connecting to Jabber servers
          Chatting with team members
          Sending files to team members
          Sending artifact links to team members from the Rational Team Concert Client for Microsoft Visual Studio IDE
      Managing change and releases
        Getting started with change management
        Getting started with configuration management
        Getting started with the Rational Team Concert Client for Microsoft Visual Studio IDE
        Tracking work by using work items
          Getting started with work items
          Work items
          Setting up work items
            Defining categories that work items can be filed against
            Defining categories that work items can be filed against in the web client
            Defining releases
            Defining releases in the web client
            Importing Bugzilla bugs
            Importing work items from a CSV file
            Using a template to create work items
              Creating a work item template
              Importing a template
            Creating text templates
            Time tracking for work items
          Working in the Eclipse client
            Work items perspective and views
              Work Items view
              Team Artifact view
              My Work view
              Team Dashboard view
              Tag Cloud view
            Creating work items
              Additional ways to create work items
              Creating work items from a template
            Working on and resolving work items
              Triaging work items
              Updating work items
              Modifying multiple work items simultaneously in the Eclipse client
              Specifying work item constraints
              Viewing work item history
              Linking to work items on remote repositories
              Linking work items to test artifacts
              Linking work items to requirements
              Linking work items to plans
              Entering time for a work item
              Exporting work items
              Printing work items
              Restricting access to work items
            Finding work items
              Using predefined queries
              Creating queries
              Configuring queries to show work item relationships
              Retrieving a specific work item
              Searching for potential duplicate work items
              Searching from the Console and Error Log views
              Using full-text search to find work items
            Deleting work items in the Eclipse client
            Deleting work item comments
            Configuring notifications
            Managing risks
              Defining risks
              Creating risk actions
              Setting the currency of risk costs
            Customizing work items
              Work item customization overview
              Defining work item types and attributes
              Updating work items with new or modified attributes
              Defining an approval tracking process
              Defining a workflow
              Defining enumerations
              Defining required and implied attributes
              Configuring read-only attributes for work item type and work item state
              Requiring E-Signatures
              Requiring approvals for state transitions
              Predefining queries
              Customizing the work item editor
              Adding the Restricted Access presentation
              Customizing the Quick Information section
              Including process guidance in the work item editor
              Customizing attributes
                Customization types
                Configuring default values
                  Configuring a default description
                  Configuring a role-based enumeration default
                Configuring value sets
                  Configuring a dependent enumeration value set
                  Configuring a role-based user list value set
                  Configuring an HTTP filtered value set provider
                Configuring validators
                  Configuring a regular expression validator
                Configuring conditions
                  Configuring dynamic required attributes
                  Configuring dynamic Read-Only attributes
              Customizing Email notifications
              Defining mapping between change management type and work item type
          Working in the web client
            Work Items pages in the web client
            Creating work items in the web client
              Creating work items from a template in the web client
            Working on and resolving work items in the web client
              Triaging work items in the web client
              Updating work items in the web client
              Modifying multiple work items simultaneously in the web client
              Specifying work item constraints in the web client
              Viewing work item history in the web client
              Linking to work items on remote repositories in the web client
              Linking work items to test cases in the web client
              Linking work items to requirements in the web client
              Linking work items to plans in the web client
              Entering time for a work item in the web client
              Restricting access to work items
              Exporting work items in the web client
              Printing work items in the web client
            Finding work items in the web client
              Using predefined queries in the web client
              Using lifecycle queries
              Creating queries
              Retrieving a specific work item in the web client
              Searching for duplicate work items in the web client
            Deleting work items in the web client
            Configuring notifications in the web client
            Managing risks
              Defining risks
              Creating risk actions
            Customizing work items in the web client
              Work item customization overview
              Setting preconditions and follow-up actions for saving work items
              Defining work items types and attributes in the web client
              Defining enumerations in the web client
              Customizing the work item editor in the web client
              Including process guidance in the work item editor
              Adding the Restricted Access presentation
              Defining a workflow in the web client
              Customizing Email notifications in the web client
              Defining mapping between change management type and work item type in the web client
          Working with work items in the client for Microsoft Visual Studio
            Getting started with work items
            Team Artifact window
            My Dashboard window
            Configuring the My Dashboard window
            Creating work items
              Additional ways to create work items
              Creating work items from a template
            Working on and resolving work items
              Triaging work items
              Updating work items
              Modifying multiple work items at once
              Viewing work item history
              Linking work items to artifacts on remote repositories
              Tracking current work
              Exporting work items
            Finding work items
              Creating queries
              Using predefined queries
              Retrieving specific work items
            Configuring notifications
          Linking to requirements and test artifacts
        Managing source code
          Getting started with Rational Team Concert source control
          Rational Team Concert source control icons
          Source control overview
            The repository
            Workspaces and sandboxes
            File content types and line delimiters
            Read access permissions
            Streams and components
              Component baselines
              Workspace snapshots
            Change sets and change flow
              Change sets
              Change flow
              Flow targets
              Incoming change sets
              Outgoing change sets
              Change sets in a workspace
              Change flow, conflict detection, and conflict resolution
          Working in the Eclipse client
            Sharing Eclipse projects with your team
            Working independently in Rational Team Concert source control
              Adding projects to repositories
                Renaming projects in repositories
                Removing projects from repositories
                Moving projects to other components
              Working with projects under Rational Team Concert source control
                Checking in unresolved changes
                Selecting resources to exclude from Rational Team Concert source control
                Specifying file properties and line delimiter types
                  Using the File Properties wizard
                  Setting line delimiter handling
                  Changing resource properties
                Locking resources
                Choosing automatic or manual check-ins
                Viewing files in repositories
                Searching for repository objects
                Creating and managing change sets
                  Starting a new change set
                  Specifying current change sets
                  Suspending change sets
                  Completing change sets
                  Reversing change sets
                  Discarding change sets from workspaces
                  Locating change sets
                Synchronizing sandboxes
                Creating and applying Rational Team Concert source control patches
              Organizing projects into components and streams
                Creating components
                Creating streams
              Preserving and restoring component and workspace configurations
                Creating component baselines
                Taking workspace snapshots
                Replacing workspace contents with snapshots
                Creating or deleting snapshot associations
            Repository workspaces in team environments
              Creating new repository workspaces from streams
              Creating new repository workspaces
              Changing owners of repository workspaces
              Creating load rules files
              Creating duplicate workspaces
              Loading or unloading repository workspaces
              Replacing the contents of components or workspaces
              Adding and removing components
              Replacing stream contents with workspace or component contents
            Sharing changes with your team
              Submitting changes for review
              Accepting incoming change sets
              Delivering change sets
              Filtering for Rational Team Concert source control events
              Sharing symbolic links
              Setting read access permissions
            Finding and resolving conflicts
              Resolving conflicts in file content
              Resolving structural conflicts
              Merging changes that include gaps
                Gaps in change set history
                Workflow for merging gaps
                Example of merging gaps
                Merge gap examples for SCM CLI
            Exploring the history of components and files
              Viewing or editing the change history of components
              Viewing the baseline history of components
              Viewing the change history of files
              Viewing version identifiers
              Reviewing changes in change sets
              Saving change logs
              Viewing annotations
              Comparing baselines
              Locating change sets
              Viewing check-in history
              Deleting file content from the repository
              Restoring deleted files or folders
              Setting up external compare tools
            Understanding and modifying change flows
              Adding and removing workspace flow targets
              Collaborating with another workspace
              Adding and removing stream flow targets
              Flowing changes between streams
              Flowing changes to different repositories
            Using work items and team process with Rational Team Concert source control
              Associating change sets with work items
              Working on work items
              Team process preconditions
              Restricting deliveries to streams
            Associating change requests with change sets
            Visualizing workspaces and streams
              Flow diagrams
              Creating and populating flow diagrams
                Flow diagram elements
                Creating flow diagrams
                Viewing incoming or outgoing flow nodes
                Adding elements to flow diagrams
                Linking elements in flow diagrams
                Removing elements from diagrams
              Changing properties in flow diagrams
              Changing palette settings
          Working in the Rational Team Concert Shell
            Working in Basic mode
              Getting started with Basic mode
                Creating a work area
                Connecting to a repository
                Opening a work area
              Sharing changes with your team
                Adding files or folders
                Accepting incoming changes
                Delivering changes
              Managing resources
                Refreshing changes
                Moving files or folders
                Renaming files or folders
                Downloading the latest file version from a stream
                Viewing the change history of files
                Switching to previous versions
                Comparing resources with repository versions
              Setting preferences
                Linking work items to changes
                Configuring compare tools
            Working in Advanced mode
              Connecting to Jazz repositories and project areas
                Connecting to repositories and project areas
                Connecting to a project area by accepting a team invitation
              Setting up repository workspaces
                Creating repository workspaces
                Loading repository workspaces
                Creating a source control configuration file
                Adding components
                Modifying workspace flow targets
              Setting up sandboxes
                Creating sandboxes
                Setting the current sandbox
              Opening the Pending Changes view
              Sharing changes with your team
                Sharing folders
                Associating work items with change sets
                Accepting incoming change sets
                Checking in change sets
                Delivering change sets
              Managing resources
                Refreshing local changes
                Moving files or folders
                Renaming files or folders
                Undoing changes
                Locking and unlocking resources
                Viewing the change history of files
                Comparing resources with repository versions
                Selecting resources to ignore
                Viewing and editing Jazz properties
                Disconnecting shared folders
              Setting preferences
                Enabling automatic check ins
                Configuring compare tools
                Setting additional preferences
          Working in the web client
            Connecting to repositories from web browsers
            Viewing repository contents
            Modifying stream contents
              Editing repository files
              Adding files or folders to repositories
              Associating change requests with change sets
              Creating text files in repositories
              Deleting repository files or folders
              Locking repository files
              Renaming repository files or folders
              Searching for repository artifacts
          Working in the command line
          Managing source code in the client for Microsoft Visual Studio IDE
            Getting started with Rational Team Concert source control
            Migrating
              Migrating repository workspaces
              Migrating from another Source Control provider to Jazz
            Adding projects to repositories
              Disconnecting projects from repositories
              Moving solutions to other components
            Read access permissions
            Selecting resources to ignore in Rational Team Concert source control
            Checking in automatically or manually
            Undoing changes
            Viewing files in repositories
            Locking resources
            Working in the Sandbox Explorer window
              Creating a new sandbox
              Setting the current sandbox
              Sharing projects and solutions
              Opening projects and solutions
              Editing files
              Moving files or folders
              Renaming files or folders
              Setting read access permissions
            Managing change sets
              Team process preconditions for Rational Team Concert source control operations
              Starting new change sets
              Configuring Static Analysis tools for source control deliveries
              Configuring unit testing tools for source control deliveries
              Delivering change sets
              Accepting incoming change sets
              Suspending change sets
              Resuming change sets
              Discarding change sets
              Completing change sets
              Reversing change sets
              Moving files or folders to other change sets
              Associating work items with change sets
              Associating change requests with change sets
              Enabling Open Services for Lifecycle Collaboration
              Sharing symbolic links
              Viewing change sets associated with work items
            Exploring the history of components and files
              Viewing the change history of components
              Viewing the change history of files
              Viewing the baseline history of components
              Viewing version identifiers
              Reviewing changes in change sets
              Locating change sets
              Viewing annotations
            Creating streams and components
              Creating streams
              Creating duplicate streams
              Creating components
            Working with repository workspaces
              Creating repository workspaces
              Creating duplicate workspaces
              Creating load rules files
              Loading or unloading repository workspaces
              Replacing component or workspace contents
              Replacing stream contents with workspace or component contents
              Adding components
              Deleting components
            Preserving component and workspace configuration
              Creating component baselines
              Taking workspace snapshots
              Replacing workspace contents with snapshots
              Creating or deleting snapshot associations
            Comparing resources
              Comparing resources with repository versions
              Comparing workspaces and streams
              Comparing baselines
              Comparing components with baselines, workspaces, and streams
              Comparing workspaces or streams with snapshots
            Finding and resolving conflicts
              Merging changes in the compare editor
              Resolving conflicts
              Setting up file compare utilities
              Compare arguments
            Working with feeds
              Viewing feeds
              Subscribing to feeds
            Understanding and modifying change flow
              Modifying workspace flow targets
              Collaborating with other workspaces
              Flowing changes to different repositories
              Enabling distributed source control
            Searching in the client for Microsoft Visual Studio IDE
              Searching for change sets
              Searching for components
              Searching for workspaces or streams
              Searching for snapshots
              Searching in the Pending Changes window
          Managing Enterprise Extensions source code
            Enterprise Extensions system definitions
              System definitions for IBM i
                IBM i library definitions
                  Creating an IBM i library definition
                  IBM i library naming rules
                IBM i language definitions
                  Creating an IBM i language definition
                IBM i translators
                  Creating an IBM i translator
                  Translator output pattern rules
                IBM i search paths
                  Creating IBM i search paths
                IBM i system definitions generator overview
                  Generating IBM i build metadata automatically by using the system definitions generator.
                IBM i system definition reference searches
                  Searching for object dependencies with the system definition reference search on IBM i
                  Archiving IBM i language definitions, library definitions, search paths, and translators
                  Rereferencing an IBM i language definition, library definition, search path, or translator
              System definitions for z/OS
                z/OS data set definitions
                  Creating a z/OS data set definition
                  z/OS data set naming rules
                z/OS language definitions
                  Creating a z/OS language definition
                z/OS translators
                  Creating a z/OS translator
                  Translator output pattern rules
                  Using STEPLIB and TASKLIB with z/OS translators
                z/OS system definitions generator overview
                  Generating z/OS build metadata automatically by using the system definitions generator
                z/OS system definition reference searches
                  Searching for object dependencies with the system definition reference search on z/OS
                  Archiving z/OS language definitions, data set definitions, and translators
                  Rereferencing a z/OS language definition, data set definition, or translator
            Managing source code on IBM i
              Loading an IBM i Project from the Jazz Team Server
              Migrating IBM i Projects
              Using quick fix to migrate IBM i Projects with Rational Developer for i
              Working with IBM i projects by using the command line interface
              Using the Compare with IBM i view for IBM i Projects
            Managing source code on z/OS
              mvsCodePage file property
            Managing source code with the ISPF client
              Setting ISPF client preferences
              Repository connection
                Creating or selecting a repository connection
                Editing the repository connection
                Deleting the repository connection
                Logging in to a repository connection
                Logging out of a repository connection
                Connecting to a project area
                Switching project areas
              Repository workspaces
                Creating or selecting a repository workspace
                Editing the repository workspace settings
                  Changing the repository workspace flow target
                  Modifying the repository workspace components
                Loading the repository workspace
                Unloading the repository workspace
                Reloading the repository workspace
                Deleting the repository workspace
                Viewing files in the repository workspace
                Viewing pending changes in the repository workspace
              Work with files in the repository
                Creating a file
                Sharing files to a repository
                  Sharing files to a loaded repository workspace
                  Sharing files to a new repository workspace
                Locking a shared file
                Unlocking a file
                Editing files
                Replacing local changes in an ISPF file
                Viewing the change history of files
                Viewing and changing file properties
                Checking in a changed file
                  Create a work item for a change set
                Renaming a file in the repository workspace
                Deleting a file from the repository workspace
              Managing change sets
                Resolving an incoming change set
                Managing outgoing change sets
                Resolving conflicts
              Working with ISPF client builds
                Viewing builds
                Submitting a build request
                Viewing build results
              Troubleshooting the Rational Team Concert ISPF client
            Source code data collection service
              Searching for object dependencies with the system definition reference search on z/OS
              Creating a source code data query
                Loading files from the source code data view
                Exporting source code data query results
              Viewing source code data with the Source Code Data editor
              Specifying a source code data scanner
              Relationship of the source code data scanner and the dependency build
              Changing the source code data collection service interval
              Assigning a language definition to a resource
              Troubleshooting dependency data scanning
              Searching for file dependencies with the Impact Analysis Search
            Using the context-aware search
              Defining a search engine to manage the search index
              Setting up indexing and configuring search parameters
                Selecting search engines
                Configuring the search index
                Scheduling search indexing
                Configuring search synonyms
                Viewing the status of search engine indexing
        Building with Rational Team Concert Build
          Getting started with builds
          About Rational Team Concert Build
          A typical Rational Team Concert Build setup
          Rational Team Concert Build setup variations
          Dedicated build workspaces
          Component load rules
          Ant build toolkit
          Build properties
          Performing build tasks in the Eclipse client
            Setting up builds and viewing results
              Creating build definitions
              Organizing build definitions into folders
              Creating build engines
              Configuring email notifications for builds
              Requesting builds
              Viewing build results
              Viewing build status
            Administering Rational Team Concert Builds
              Starting and stopping Jazz Build Engines
              Flowing changes to a build workspace from different repositories
              Tagging builds
              Canceling build requests
              Abandoning builds
              Automatically deleting build results
              Associating builds with releases
              Creating encrypted password files
          Performing build tasks in the Web client
            Requesting a build
            Viewing build definition and build engine configurations
            Viewing build results
            Viewing build engine status
            Viewing build queue status
          Performing build tasks in the client for Microsoft Visual Studio IDE
            Building with Jazz
              About Rational Team Concert Build
                Jazz build setup variations
                Dedicated build workspaces
                Component load rules
                Ant build toolkit
                Build properties
              Setting up builds and viewing results
                Creating build definitions
                Requesting builds
                Viewing build results
                Tagging builds
              Ant tasks
                Publishing build results and contributions
                  artifactFilePublisher
                  artifactLinkPublisher
                  buildResultPublisher
                  ccpunitLogPublisher
                  filePublisher
                  jdtCompileLogPublisher
                  junitLogPublisher
                  mstestLogPublisher
                  nunitLogPublisher
                  linkPublisher
                  logPublisher
                  workItemPublisher
                Enabling progress monitoring
                  startBuildActivity
                  completeBuildActivity
                Work with Jazz source control
                  teamAccept
                  teamFetch
                  teamLastModified
                  pluginOrganizer
                Controlling the build life cycle
                  requestTeamBuild
                  getNextTeamBuildRequest
                  startTeamBuild
                  completeTeamBuild
                  waitForTeamBuild
          Setting up Enterprise Extensions builds
            Enterprise Extensions builds
            Dependency builds on z/OS and IBM i
              Dependency build authentication
              Creating a dependency build definition
                Customizing z/OS dependency build settings
                  Including Rational Developer for System z COBOL compiler error lists in dependency build results views
                  Including PL/I compiler error lists in dependency build results views
                Creating linkage source files for IBM i dependency builds
                Customizing IBM i dependency build settings
              Simulating dependency builds
                Configuring your project for simulation builds
                Running a simulation build
                Viewing simulation build status and results
              Migrating z/OS build definitions to current dependency build templates
                Migrating customized build files to current dependency build templates
              Requesting a dependency build
                Requesting and viewing a build preview
                Requesting personal builds
                Setting up personal build options
              Getting started with build subsets
                Setting up projects and teams to use build subsets
                Creating build subsets
              Ignoring changes in dependency builds
              Using the "Always load during dependency build" option
              Viewing dependency build results
              Dependency build reports and build maps
            Managing z/OS builds
              Build templates available for z/OS
              Building with Ant with Enterprise Extensions and the Rational Build Agent
                Preparing your environment
                Configuring the Rational Build Agent Service
                Security for the Rational Build Agent
                Creating a shared zComponent project
                Creating a zFolder
                Creating zFiles and associating them with language definitions
                Creating a new Ant with Enterprise Extensions build definition
                  Using the Ant with Enterprise Extensions build definition editor
                Requesting an Ant with Enterprise Extensions build
                Ant with Enterprise Extensions tasks and data types
                  Ant with Enterprise Extensions custom data types
                    BuildableResourceCollection custom data type
                      BuildableResourceCollection parameter
                      BuildableResourceCollection examples
                    BuildableResourceList custom data type
                      BuildableResourceList example
                    BuildableResource custom data type
                      BuildableResource parameters
                      BuildableResource example
                    ComponentSelector custom data type
                      ComponentSelector parameters
                      ComponentSelector example
                    ProjectSelector custom data type
                      ProjectSelector parameters
                      ProjectSelector example
                    LanguageDefinitionSelector custom data type
                      LanguageDefinitionSelector parameters
                      LanguageDefinitionSelector example
                  Ant with Enterprise Extensions Compile custom data task
                    Compile custom data task
                      Compile examples
              Using the Rational Build Agent to run command-driven builds
                Defining and running a build using the Rational Build Agent
              Using the Rational Build Agent and Job Monitor to run builds using JCL
                Job Monitor customization
                  PARMLIB changes
                  PROCLIB changes
                  Job Monitor configuration file BLZJCNFG
                Submitting JCL inside the build command
                  Prerequisites and security considerations
                  Submitting JCL contained in a build system data set
                  Providing JCL through a Rational Build Agent step command
                Job Monitor security
                  JES security
                    Actions against jobs: target limitations
                    Actions against jobs: execution limitations
                    Access to spool files
                  Job Monitor configuration file
                  Security definitions
                    Define the Job Monitor started task
                    Define JES command security
              Working with ISPF client builds
                Viewing builds
                Submitting a build request
                Viewing build results
              Using the Jazz Build Engine on z/OS
                Running the Jazz Build Engine on z/OS
                Creating a password file using BLZBPASS
            Managing IBM i builds
              Starting and stopping the Jazz Build Engine
              Build templates available for IBM i
                Overview of the IBM i build specification
                Creating an IBM i Build Specification - Rational Build Agent build definition
                Requesting a personal build for IBM i Build Specification builds
                Creating an IBM i Command build definition
              Enabling dependency data collection for your stream
              Understanding build specification build results
                Overview of build results
                Viewing the build log file
                Viewing the build output records file
                Viewing compilation results
              Synchronizing a repository workspace with mapped libraries on IBM i
                Using the Continuous Load build definition template
              Auditing with IBM i
          Jazz build Ant task reference
            Publishing build results and contributions
              artifactFilePublisher
              artifactFileRetriever
              artifactLinkPublisher
              buildResultPublisher
              cppunitLogPublisher
              filePublisher
              generateChangeLog
              jdtCompileLogPublisher
              junitLogPublisher
              mstestLogPublisher
              nunitLogPublisher
              linkPublisher
              logPublisher
              logLinkPublisher
              logRetriever
              workItemPublisher
            Enabling progress monitoring
              startBuildActivity
              completeBuildActivity
            Working with Jazz source control
              teamAccept
              teamFetch
              teamLastModified
            Controlling the build life cycle
              requestTeamBuild
              getNextTeamBuildRequest
              startTeamBuild
              completeTeamBuild
              waitForTeamBuild
            Packaging and deployment
              requestPackage
              requestDeploy
              retrieveChildrenWorkItems
            Miscellaneous tasks
              deleteBuildResult
              buildResultRetriever
              pluginOrganizer
            Ant attribute reference
        Packaging and deploying with Enterprise Extensions
          Configuring a project area for work item packaging
          Package and deployment build authentication
          Creating a package definition
            Configuring a z/OS package definition
            Configuring an IBM i package definition
            Configuring a Linux or UNIX package definition
            Creating a ship list filter file
            Creating an include or exclude file (optional)
            Configuring the auto clean option
          Requesting a package
            Requesting a z/OS ship list package
            Requesting a z/OS work item package
            Requesting an IBM i ship list package
            Requesting an IBM i work item package
            Requesting a Linux or UNIX package
            Requesting and viewing a package preview
            Checking packaging results
          Creating a deployment definition
            Configuring a z/OS deployment definition
            Configuring an IBM i deployment definition
            Configuring a Linux or UNIX deployment definition
          Requesting a deployment
            Requesting a z/OS or IBM i deployment
            Requesting a Linux or UNIX deployment
            Checking deployment results
          Scheduling packages and deployments
          Querying packages and deployments
          Exporting package and deployment query results
        Promoting artifacts with Enterprise Extensions
          Promotion build authentication
          Creating source and target builds for promotion
          Creating a promotion definition
          Customizing promotion settings
          Component promotion
            Requesting a component promotion
          Work item promotion
            Configuring the project area for work item promotion
            Requesting a work item promotion
            Promoting work items without using the Rational Team Concert client
      Reporting
        Change and Configuration Management (CCM) reporting
        About the change and configuration management reports
          Change and configuration management predefined report descriptions
          Change and configuration management sample report descriptions
          Installing BIRT tools
          Build reports
          Source control reports
          Work item reports
        Using change and configuration management reports to get status
          Checking project status by release
          Checking project status by iteration
          Determining project velocity
        Change and configuration management data dictionary
        Change and configuration management reportable REST API
      Extending product function
        Extending Rational Team Concert
        Extending Rational Team Concert by using OSLC services
          Rational Team Concert as an OSLC service consumer
          Rational Team Concert as an OSLC service provider
          Links across OSLC domains
          Additional OSLC integration services and requirements
      Troubleshooting and support
        Troubleshooting Rational Team Concert
          Troubleshooting client-server connection issues
          Measuring server response times
          ClearCase Synchronizer limitations and known problems
            Troubleshooting synchronization problems
            Synchronization errors
          ClearQuest Synchronizer limitations and known problems
          ClearQuest Import Wizard limitations and known problems
          ClearQuest Bridge limitations and known problems
          Troubleshooting the Rational Build Agent
            Testing host name resolution
            Testing the connection
            Troubleshooting an agent on Windows systems
            Troubleshooting an agent on UNIX and Linux systems
          Troubleshooting z/OS
            Troubleshooting Ant-based z/OS builds
              File agent cannot log in to the Jazz Team Server on z/OS
              Minimum Ant with Enterprise Extensions build region size
              Using a different STEPLIB environment variable in the ISPF/TSO client
              Using ISPF Statistics in Ant-based z/OS builds
              Using DBCS characters in zComponent project and zFolder names
              Read access permissions considerations for z/OS Ant-based builds
              Using the same DD name for a temporary data set with the keep option in translators
              Build fails when file list exceeds 100 KB
              Build fails with abend S806 in the link-edit parser execution
            Troubleshooting the ISPF gateway configuration
            Troubleshooting the ISPF client
              Member list shows incorrect local changes
        Troubleshooting and support for IBM i
          Troubleshooting and getting help for Jazz Team Server on IBM i
        Support information for Rational Team Concert
        Disabling logging in Eclipse-based products
      Reference
        Source control command line reference
          Example scm commands
          Environment variables
          Synchronize streams across repositories
          scm
            accept
            accept example
            add
              add component
              add component example
              add flowtarget
              add flowtarget example
              add workitem
            annotate
            annotate example
            checkin
            checkin example
            compare
            compare example
            create
              create baseline
              create baseline example
              create change set
              create component
              create loadrules
              create snapshot
              create stream
              create workspace
            daemon
              daemon deregister
              daemon register
              daemon start
              daemon start example
              daemon stop
              daemon stop example
            delete
              delete snapshot
              delete state-content
              delete stream
              delete workspace
              delete workspace example
            deliver
            deliver example
            diff
            diff example
            discard
            discard example
            get
              get attributes
              get attributes example
              get change
              get file
              get file example
              get preference
              get preference example
              get property
              get property example
            help
            help example
            list
              list baselines
              list changes
              list changesets
              list components
              list connections
              list daemons
              list daemons example
              list flowtargets
              list flowtargets example
              list locks
              list merge-queue
              list_missing-changesets
              list preferences
              list preferences example
              list projectareas
              list remotefiles
              list remotefiles example
              list_smartcard-aliases
              list snapshots
              list states
              list streams
              list teamareas
              list users
              list workspaces
              list workspaces example
            load
            load example
            locate
            login
            login example
            logout
            logout example
            move
              move change
              move path
              move path example
            refresh
            remove
              remove component
              remove component example
              remove flowtarget
              remove flowtarget example
              remove merge-queue
              remove property
              remove workitem
            repair
            repair example
            resolve
              resolve conflict
              resolve conflict example
              resolve current-merge
            resume
              resume changeset
              resume merge-queue
            set
              set access
              set attributes
              set attributes example
              set changeset
              set component
              set current-merge
              set flowtarget
              set flowtarget example
              set lock
              set merge-queue
              set preference
              set preference example
              set property
              set property example
              set user
            share
            share example
            show
              show attributes
              show attributes example
              show conflicts
              show conflicts example
              show history
              show lastmod
              show lastmod example
              show properties
              show status
              show status example
            suspend
            undo
              undo change
              undo change example
              undo current-merge
            unload
            unload example
            unset
              unset flowtarget
              unset lock
            version
            version example
          ClearCase Synchronizer subcommands
            addSyncRoots
            create synchronizedStream
            export ccase
            import ccase
            import ucmLinks
            list, ls
            requestSync
            start syncEngine
            stop syncEngine
            update ccase encoding
            update ccase skipElement
          Subcommand exit codes
          On Properties
          preferences.properties file
          Enabling default logging
          z/OS source control command line reference
            create dataset
            list datasetdefinitions
            zload
            z/OS mass import tool overview
              zimport
              Mass import mapping file overview
              Mass import tool mapping file format
        Work item Email notification template syntax
          Email template variables
          Email template variable types
        Syntax for plans
          Quick query syntax
          Text formatting syntax for plans
        Windows preferences for the Rational Team Concert client for Eclipse IDE
    Rational Quality Manager
      Overview
        Overview of Rational Quality Manager
        Getting started with Rational Quality Manager
        Workflows and guidance
          Typical use of Rational Quality Manager
          Rational Quality Manager in an enterprise environment
          Multi-channel testing
          Best practices and test process guidance
            Deploying process guidance from Rational Method Composer
      Tours
      Tutorials
      Scenarios
        Test management
          Identifying test motivators
      Installing
        Installing the Quality Management Application
        Installing Rational AppScan Tester Edition
      Upgrading and migrating
        Upgrading the Quality Management application
        Migrating test artifacts to Rational Quality Manager
          Online migration
          Migrating Files into Rational Quality Manager
      Integrating
        Rational RequisitePro
          Rational Quality Manager and Rational RequisitePro integration
          Connecting to an IBM Rational RequisitePro server
          Connecting Quality Management projects to Rational RequisitePro projects
          Associating test plans with requirements views and packages in Rational RequisitePro
          Administering the Rational RequisitePro integration
            Adding and deleting Rational RequisitePro projects
            Synchronizing project deletions and name changes
            Restricting privileges to connect requirement projects
            User permissions for managing Rational RequisitePro server and project associations
        Rational DOORS
          Rational Quality Manager and Rational DOORS integration
          Upgrading from earlier versions of the Rational Quality Manager and Rational DOORS integration
          Configuring Rational Quality Manager and Rational DOORS integrations
            Configuring Rational Quality Manager to integrate with Rational DOORS
            Configuring Rational DOORS to integrate with Rational Quality Manager
        Rational Change
        Rational ClearQuest
          Configuring the Rational ClearQuest Bridge as your defect provider
          Using the IBM Rational ClearQuest Synchronizer
        Rational or third-party test tools
          Rational test tools integration overview
          Third-party test tools integration overview
          Rational Functional Tester
            Enabling the manual test script recorder
          Rational Integration Tester
          Rational Performance Tester
          Rational Test Workbench
          Rational Test Virtualization Server
            Establishing cross-server communication between
            Linking between project areas and domains
          Rational Service Tester for SOA Quality
          Rational Robot
          Rational Test RealTime
          Rational AppScan Enterprise
            Security testing overview
            Configuring AppScan Enterprise
            Configuring communication between AppScan and Rational Quality Manager
            Sample AppScan Data
            Configuring IBM SecurityAppScan Enterprise Adapter
            Workflow for creating and running security tests
        Selenium
          About the JUnit Selenium adapter integration
      Administering
        Administering quality management project areas
          Getting started administering projects
          Configuring quality management project areas
            Setting up timelines, iterations, and team areas
            Defining custom workflows for test artifacts
            Configuring auto-lock after a state change
            Defining transition rules for approval tracking
            Defining preconditions and follow-up actions
              Preconditions and follow-up actions
              Copying precondition configurations
              Creating precondition configurations
              Defining preconditions for reviews
              Mandating actual results in a manual test script
              Defining a precondition to select test data records before executing test cases
              Requiring e-signature for the review process
              Allowing users to edit approved artifacts
              Disallow modifications to completed approval groups
            Setting up a new project area with existing project settings
              Copying project settings to a new project
              Creating a project area template for quality management
            Enforcing unique test artifact names
            Defining test artifact priority
            Customizing work items
            Using team areas for lab management
          Managing project properties
            Project Properties
            Enabling team areas and support for multiple timelines
            Making shared test resources available
            Unblocking test case execution records automatically
            Creating types associated with machines
            Setting up project-level quality objectives
            Defining categories and category relationships
            Defining custom attributes from the Project Properties page
            Managing risk profiles
            Defining your own risks
          Using custom execution adapter types
            Configuring a custom execution adapter type
            Creating a test script that uses a custom test automation adapter
        Administering the Rational solution for Collaborative Lifecycle Management server
      Collaborating
        Managing dashboards
          Quality dashboard overview
      Reporting
        About the quality management predefined reports
          Quality management predefined report descriptions
          Quality management sample report descriptions
          Defects reports
          Execution reports
          Requirements reports
          Summary reports
        Running and viewing reports for quality management
        Using quality management reports to get status
          Master and child test plan artifact relationships
          Reporting on data with custom attributes
          Determining the quality of testing
          Checking project status with the Execution Trend Report
          Determining problem areas
          Viewing pending work
          Viewing work load distribution across testers
          Determining which defects impact requirements
          Running requirements traceability reports with Rational RequisitePro integration
        Customizing reports
          Importing sample reports into quality management
          Creating new report definitions from report templates and copies
        Quality management data dictionary
        Quality management reportable REST API
      Testing
        Getting started testing software
        Getting started managing tests
        Preparing to test
          Creating custom attributes
            Defining custom attributes from the Project Properties page
            Adding categories and custom attributes as column headings
          Identifying and creating requirements
            Requirements-based testing
            Requirements management
            Managing requirements by using the RM application
            Creating requirements
            Creating requirement collections
          Managing risk
            How risk assessment scores are calculated
            Managing risk profiles
            Defining your own risks
          Managing the team with work items
          Organizing by using categories
            Defining categories and category relationships
            Adding categories and custom attributes as column headings
          Setting quality objectives and entry and exit criteria
            Example: Using quality objectives and entry and exit criteria
            Setting up project-level quality objectives
          Setting up a review process
            Typical review process
            Planning the review process
        Developing test plans
          Test plan overview
          Test plan development checklist
          Creating test plans
          Creating test plans from a template
          Managing test artifact sections
          Creating master and child test plans
          Linking to requirement collections
            Associating test plans with requirement collections in the Requirements Management application
            Reconciling test plans with requirements in the Requirements Management application
            Linking to collections in Rational DOORS
              Associating test plans with Rational DOORS requirement views
              Reconciling test plans with requirements in Rational DOORS
            Linking to collections in Rational RequisitePro
              Associating test plans with requirements views and packages in Rational RequisitePro
              Reconciling test plans with requirements in Rational RequisitePro
              Fixing requirement references when requirement project names change
          Linking to development plans
          Creating test schedules
          Estimating the overall size of the test effort
          Planning test environments
            Platform coverage and test environments
            Defining your platform coverage
            Generating new test environments
            Adding existing test environments to a test plan
            Test environment types
              Creating types associated with machines
              Creating types associated with any lab resource
          Adding quality objectives to a test plan
          Making shared resources available to a test plan
          Copying portions of existing documents
          Reviewing test plans
            Assigning reviewers and approvers
            Reviewing test artifacts
            Tracking reviews
        Developing test cases, test suites, and test scripts
          Developing test cases
            Test case and test suite overview
            Creating test cases
            Managing test artifact sections
            Importing test cases
            Adding new test cases to test plans
            Adding existing test cases to a test plan
            Adding existing test scripts to a test case
            Adding a new test script to a test case
            Estimating the weight of individual test cases
            Linking a test case to a development work item
            Linking and managing requirements
              Associating test cases with requirements
              Generating test cases for requirements in requirement collections in the Requirement Management application
              Reconciling test cases with associated requirements
              Fixing requirement references when requirement project names change
              Associating test cases with Rational DOORS requirements
              Reconciling test cases with requirements in Rational DOORS
              Requirement reconcile operation status types
            Configuring data record selection criteria in test cases
          Developing test suites
            Test case and test suite overview
            Creating a test suite
            Managing test artifact sections
            Adding existing test cases to a test suite
            Adding a new test case to a test suite
            Adding existing test suites to a test plan
            Adding a new test suite to a test plan
          Developing execution records for test cases and test suites
            Creating single test case execution records
            Creating a test suite execution record
            Generating test execution records automatically
            Generating test execution records from a test plan
            Editing test case and test suite execution records
          Developing manual test scripts
            Manual test script overview
            Execution variables
            Manual test scripts and statements
            Using the manual test script recorder
              Manual test script recorder overview
              Enabling the manual test script recorder
              Setting user preferences for the manual test script recorder
              Creating or modifying manual test scripts with the recorder
            Adding existing test scripts to a test case
            Creating manual test scripts
            Creating manual test scripts from the test case design
            Creating or modifying manual test scripts with the recorder
            Editing manual test scripts
              Attaching files to script steps
              Adding comments to script steps
              Verifying text
              Providing assisted data entry text
            Importing manual test scripts
            Linking test script steps to requirements
              Linking test script steps to requirements in the Requirements Management application
              Linking test script steps to requirements in Rational DOORS
              Setting test script preferences for requirements management
            Working with test data
              Test data overview
              Creating test data
              Updating test data
              Using test data in manual test scripts
            Using keywords in manual tests
              Keyword overview
              Creating keywords
              Searching for keywords
              Creating automated keywords
              Creating keyword-enabled manual test scripts
              Editing keywords
              Test data in keyword-enabled scripts
            Incorporating execution variables into manual tests
          Referencing automated test scripts
            Automated testing overview
            Making shared test resources available
            Creating a reference to an automated test script on a local test machine
            Creating a reference to an automated test script at a shared location
            Accessing UNC shares when running WebSphere Application Server as a Windows service
            Importing automated test scripts from a test machine
            Importing automated test scripts from a shared location
            Creating an AppScan Tester Edition test script
        Managing test artifacts
          Assessing risk
            Creating the initial risk assessment
            Contributing to the community risk assessment
            Comparing the risk of multiple test plans, test cases, and test suites
          Copying test artifacts
            Copying test artifacts while viewing a list
            Copying a single test artifact
            Copying execution records to another iteration
          Creating quality tasks to manage test artifact changes
          Creating versioned test artifacts with snapshots
            Creating snapshots
            Create a new test artifact from a snapshot
          Editing, deleting, and reusing test artifacts
            Editing test artifacts with the rich-text editor
            Deletion and restoration
            Reusing test artifacts
            Using the screen capture tool
          Importing and exporting test artifacts
            Exporting test-artifact list views as CSV files
            Managing the Export Job Queue
            Saving test artifacts as PDF files
          Linking to requirements and development artifacts
          Locking and unlocking test artifacts
          Managing artifact templates and sections
            Creating templates
            Managing test artifact sections
            Test plan template reference
            Test case template reference
            Test suite template reference
          Reviewing test artifacts
            Assigning reviewers and approvers
            Reviewing test artifacts
            Tracking reviews
          Searching, filtering, and querying test artifacts
            Test artifact list views
              Row action menus in test artifact lists
            Using full-text search
            Performing a quick search of test artifacts
            Disabling automatic search
            Using filters and queries in the list views
            Sorting list views
            Filtering test artifacts with category filters
            Using artifact filters
            Using test case and test suite categories to filter execution records
            Running a saved query from the sidebar
          Track test artifacts and activities for auditing
          Viewing links to development, requirement, and test artifacts
        Running tests
          Preparing for test execution
            Test execution overview
            Test case execution workflow
            Test suite execution workflow
            Test execution preferences
          Running tests by using OSLC automation providers
            Running a test case execution record with a deployment plan
          Running manual tests
            Running a test case
            Running a test suite
            Running a test case execution record
            Running a test suite execution record
            Running manual tests with automated keywords
            Running manual tests in off-line mode
            Running tests without a test script
            Configuring to select record data during test runs
          Running automated tests
            Execution adapter selection
            Running an automated test with an adapter
          Running command-line tests
            Setting up and starting the command-line adapter
            Customizing the command-line adapter
            Creating a job that uses the command-line adapter to test an application-under-test
            Running a test with the command-line adapter
            Adding attachments and links to command-line execution results
            Troubleshooting command-line adapter issues
          Running JUnit Selenium adapter execution tests
            Configuring adapters
            Starting JUnit Selenium adapters
            Creating and running Selenium scripts in the Quality Management application
            Adding screen captures created by a JUnit Selenium test to execution results
          Creating and running Rational Integration Tester scripts
          Scheduling tests
            Test execution schedules
            Creating and viewing test execution schedules
            Viewing scheduled jobs
          Managing test runs and results
            Managing active test runs
            Recalculating the weight distribution of a test suite execution result
            Recording test results without execution
        Submitting and tracking defects
          Defects overview
          Configuring the CCM application as your defect provider
          Designating a blocking defect
          Submitting defects during test execution
          Checking for duplicate defects
          Submitting defects from AppScan Tester Edition to Rational Quality Manager
        Tracking the test effort
          Quality dashboard overview
          Traceability and test execution views
          Tracking requirements and development artifacts
          Tracking requirement coverage from test plans
          Tracking test execution status
            Test execution results
            Viewing status from a list of test plans
            Viewing status within a test plan or test suite
            Viewing status from a list of test execution records
            Viewing status with the Execution Console
            Configuring the display of execution status within a test plan or test suite
            Test artifact status icons
          Updating multiple artifacts
        Managing product builds
          Managing product builds
          Configuring Rational Team Concert as your build provider
          Creating and viewing build records
          Creating and viewing build definitions
          Creating and viewing test cells
          Test execution schedules
          Creating and viewing test execution schedules
      Extending product function
        Extending the Quality Management application
          Extending Rational Quality Manager by using OSLC services
            Rational Quality Manager as an OSLC service consumer
            Rational Quality Manager as an OSLC service provider
            Links across OSLC domains
            Additional OSLC integration services and requirements
      Troubleshooting and support
        Troubleshooting Rational Quality Manager
          Location of RQM log files
          DB2 errors
          Browser cache issue
          Execution fails with an IOException
          Execution fails with low level model error
          Remote connection issue
          Link to product documentation error
          Fixing invalid characters (#) in the PDF of test artifacts
          Finding missing changes after modifying an installation
          Execution adapter connection issues
        Support information for Rational Quality Manager
      Reference
        Logging in to Rational Quality Manager
        Setting user preferences for quality management
        General reference for the QM application
          Lab management reference
          Rational Quality Manager migrations
          Rational Quality Manager integrations
          Project Properties
          Test artifact relationships
          The life cycle of test artifacts
          Test execution states
          User preferences
    Rational Reporting
      Overview
        IBM Rational Reporting Solutions
          What's new in Rational Reporting
          Deciding which reporting options to use
            Rational solution for Collaborative Lifecycle Management reporting solutions
            Introduction to the Data Collection Component
            Introduction to the Jazz Reporting Service
            Introduction to the Rational Report Server
          Reporting architecture overview
            Application data, storage and Reportable REST APIs
            Jazz Team Server data, storage and Reportable REST API
            Data warehouse
            RRDI architecture
            Rational Insight and RRDI
          Data flow processes overview
            Application Reportable REST APIs
            XML data configuration
            Data collection with the default CLM data collection jobs
            Data collection with the Data Collection Component
            Report authoring with metadata models
          Reports and dashboards
          Report descriptions
          Reporting videos and multimedia
          Installation worksheets
          Security considerations for Rational Reporting for Development Intelligence
          Information resources
        Getting started with Rational Reporting
      Tutorials
        Configure and run data collection for CLM reporting
          Lesson 1: Select options to customize reporting
          Lesson 2: Configure CLM data collection
          Lesson 3: Run data collection jobs
        Creating reports with Query Studio
          Lesson 1: Create list reports in Query Studio
          Lesson 2: Creating a Query Studio chart and crosstab
        Build a simple parameter and list report in Cognos Report Studio
          Lesson 1: Add a list to your report Page 1
          Lesson 2: Create a prompt page
          Lesson 3: Add a filter to the QueryForCharts query
      Installing
        Getting started to install, configure, and deploy
        Installation roadmap: Jazz Reporting Service
        Rational Report Server interactive installation guide
        Installing silently
          Response file parameters
      Planning the installation
        Installation requirements
        Deciding which data collection option to use
        Installation topology examples
          Single-server deployment topology
          Two-server topology
          Standard departmental topology
          Enterprise deployment topology
        Planning to install the Data Collection Component
          Installation requirements
          Installation and deployment
            Default files, directories, and values
            Installation Manager
        Planning to install Jazz Reporting Service
          Installation requirements
          Administrator accounts and authentication
          Default files, directories, and values
        Planning to install the report server
          Default files, directories, and values
          Database planning
            Supported database configurations for 64-bit systems
            DB2
            Oracle
            Microsoft SQL server
          Installation Manager
          Load distribution for report resources
      Preparing to install
        Preparing to install the Data Collection Component
          Disable data collection jobs before installation
          Preparing the data warehouse database
          Accounts and authentication
          Backing up and collecting installation information
            Required installation information worksheet
        Preparing to install Jazz Reporting Service
          Required installation information worksheet
          Setting up the application server
        Preparing to install the report server
          Backing up and collecting installation information
            Required installation information worksheet for the report server
          Verifying the CLM installation
          Creating the database for the content store
            Creating the DB2 content store
            Creating the Microsoft SQL Server content store
            Creating the Oracle content store
            Creating the DB2 for z/OS content store
          Linux, AIX: Increasing the limit of open files and user processes
          Configuring security-enhanced Linux environments
          Creating a user account for the data warehouse
          Setting up the report server system
            Linux: Additional steps
            AIX: Additional steps
            Oracle: Additional steps
      Installation tasks
        Installing Rational Reporting for Development Intelligence
        Verifying the installation
      Configuring Rational Reporting for Development Intelligence
        Configuring the Data Collection Component
          Configure the application server
          Configure Jazz Team Server for the Data Collection Component
        Configuring Jazz Reporting Service
          Deploying and starting the server
            Deploying on Tomcat
            Deploying on WebSphere Application Server
          Register JRS as an application on JTS
          Establishing cross-server communication
        Configuring the report server
          Initializing the server for the setup wizard
          Starting the setup wizard
            Setting the locale for the setup server
          Configuring the deployment
            Configuring an IBM HTTP Server based proxy server to work with the report server
            Assigning a fully qualified domain name to the Gateway URI in Cognos Configuration for the report server
          Configuring the report server to integrate with a TLS 1.2-enabled JTS
            Integrating the report server with a TLS 1.2-enabled JTS
            Importing and running reports with a TLS 1.2-enabled Jazz Team Server
          Oracle: Additional steps
          Optional: Creating the data warehouse with scripts
            DB2 data warehouse setup scripts
            Microsoft SQL data warehouse setup scripts
            Oracle Data warehouse setup scripts
          Verifying the deployment
          Integrating with CLM data sources
          Verifying the integration with CLM data sources
          Optional: Setting up live reporting
            Importing the XDC file
            Configuring the data source connection
            Testing live reporting
      Uninstalling the product
      Release notes for IBM Rational Reporting for Development Intelligence
      Upgrading and migrating
        Preupgrade tasks
          Disabling SSL on the report server
          Backing up RRDI 1.0.x
          Backing up RRDI 2.0.x or 5.0.x
        Upgrade tasks
          Upgrading RRDI to a newer version
            Upgrading RRDI from version 2.0.x to version 5.0
            Upgrading RRDI from version 1.0.x to version 5.0
            Upgrading RRDI from 32-bit to 64-bit systems
          Upgrading RRDI to Rational Insight
        Postupgrade tasks
          Upgrading reporting artifacts
          Importing reporting packages after upgrading
          Integrating the CLM reporting artifacts to Rational Insight
            Adding the CLM schema to the Rational Insight data warehouse
            Integrating the CLM XML data configuration files with Rational Insight
            Integrating the CLM DM packages and ETL modules with Rational Insight
            Integrating the CLM Framework Manager models with Rational Insight
          Migrating the CLM ETL and reporting artifacts integrated with Rational Insight
            Migrating the data warehouse
            Migrating the Rational Insight and CLM XDC files
            Migrating the Rational Insight ETL catalog with the imported CLM ETL jobs
            Migrating a customized Rational Insight Reporting Data Model (DW+CALM) FM project
      Administering
        Getting started with configuring and maintaining reporting in CLM
        Managing data collection with the Data Collection Component
          Roadmap to collecting data with Data Collection Component
          Starting and stopping the Data Collection Component server
          Activating Data Collection Component for data collection
          Configuring resource groups
        Managing data collection with default CLM data collection
          Running the data collection jobs
          Turning off the data collection jobs
          Verifying the user ID for running data collection jobs
        Extending the date range for reports
        Deploying new report resources
        Viewing and canceling running reports
        Setting up and configuring IBM Jazz Reporting Service
          Managing data sources
          Importing queries and reports
          Assigning report managers
        Administering the report server
          Accounts and authentication
            Validating the connection from the report server to the Jazz Team Server and CLM applications
            Modifying OAuth properties on report server
            Disabling anonymous access to report server
            Assigning Cognos roles to Jazz users
            Configuring the report server
            Changing the password for the setup administrator account
            Changing the password for the report user account
          Configuring the ODBC driver for Linux and AIX systems
          Finding the port number of a server
          Finding the values for Oracle variables
          Starting and stopping the report server
          Starting and stopping the setup wizard server
          Configuring email notification
          Backing up your data
          Backing up the key stores
          Configuring security settings
            Disabling anonymous access to report server
            Enabling security for WebSphere Application Server Windows service
            Enabling secure sockets layer (SSL) for the report server
              Creating an SSL certificate for the application server
              Configuring a browser to work with self-signed certificates
              Enabling WebSphere Application Server administrative security
              Exporting signer certificates from the WebSphere Application Server trust store
              Importing signer certificates into the report server trust store
              Configuring the report server to use HTTPS URIs
              Integrating a SSL-enabled report server with a Jazz Team Server
              Disabling the HTTP port
              Replacing existing WebSphere Application Server SSL certificates
            Adding report users
            Configuring data source connections
            Configuring IBM Cognos administration and security
          Data models and sample reports
            Loading the CLM data models and sample reports onto the report server
            Manually loading the data models and application sample reports onto the report server
            Switching to the unrestricted data model
            Loading customized report packages into your report servers
        Server rename and reporting
          Pre-server rename tasks for RRDI and Rational Insight
          Post-server rename tasks for RRDI and Rational Insight
      Reporting
        Measuring and tracking projects with Rational Reporting
          Getting started with viewing reports and dashboards
          Running and viewing document-style reports
          Running and viewing development intelligence reports
          Printing and exporting development intelligence report output
          Creating and saving reusable development intelligence reports
          Viewing development intelligence reports in dashboards
            Using report views in custom reports
            Viewing non-optimized custom reports in a dashboard
            Interacting with reports
              Running reports
              Saving reports
            Managing reports on the reporting server
            Making development intelligence reports available to viewers
          Managing available reports in the CLM applications
            Organizing reports
            Updating BIRT or RRDG report resources in the project area
          Viewing reports in dashboards
            Managing reports in dashboards
            Refining ready-to-use query output in dashboards
        Authoring and maintaining reports and dashboards
          Getting started with creating and customizing reports and dashboards
          Authoring development intelligence reports
            Starting the RRDI authoring and report management tools
            Customizing development intelligence reports
            Creating development intelligence reports
              Optimizing development intelligence reports for dashboard widgets
                Creating new miniature chart reports
                  Creating new report pages for miniature chart reports
                  Creating new prompt pages for miniature chart reports
                Converting existing chart reports to miniature chart reports
                  Modifying existing report pages to support miniature chart reports
                  Modifying existing prompt pages to support miniature chart reports
                Creating new miniature list reports
                  Creating new report pages for miniature list reports
                  Creating micro lists
                  Creating new prompt pages for miniature list reports
                Converting existing list reports to miniature list reports
                  Converting existing report pages to support miniature list reports
                  Converting existing report lists to micro lists
                  Converting prompt pages for miniature list reports
              IBM Cognos
            Reporting on data with custom attributes
          Authoring document-style reports
            Creating document-style reports
            Customizing document-style reports
            Configuring metadata for document-style reports
            Making document-style reports available to viewers
      Troubleshooting
        Troubleshooting IBM Jazz Reporting Service
          IBM Jazz Reporting Service error messages
          IBM Jazz Reporting Service log files
        Using the logs
          Activating the logs
          Locating the logs
        Installation
        Upgrade
        User authentication
        Report server
        Rational XML ODBC driver
        Data collection jobs and Reports
        Running the IBM Support Assistant Lite utility for Rational Reporting for Development Intelligence
      Reference
        Report descriptions
        Reporting data dictionaries
          Data warehouse metrics populated by CLM application data
        Application reportable REST APIs
  ++ THIS INFORMATION IS FOR PLANNING PURPOSES ONLY. THE INFORMATION HEREIN IS SUBJECT TO CHANGE OR REMOVAL WITHOUT NOTICE BEFORE THE PRODUCTS DESCRIBED MAY BECOME AVAILABLE. ++
    Welcome
    Rational solution for Collaborative Lifecycle Management
      Overview
        Rational products and solutions
        IBM and accessibility
        Introduction to the Rational solution for CLM
          Overview of the solution
          Overview of Rational DOORS Next Generation
            Comparison of Rational DOORS and Rational DOORS Next Generation
          Overview of Rational Team Concert
          Overview of Rational Quality Manager
          Overview of Design Management
          Overview of Rational Reporting
          Linking requirements, development, and test
          What's new in this release
          Videos for the Rational solution for CLM
          Learning resources
        Getting started with the Rational solution for CLM
        Introduction to the Rational solution for systems and software engineering
        Introduction to the Rational Deployment wiki
        Security considerations for the Rational solution for CLM
        Notices for the Rational solution for CLM documentation
      Tours
        Rational solution for Collaborative Lifecycle Management
      Tutorials
        Money that matters lifecycle scenario
          Introduction
          Module 1: Plan a sprint
            Lesson 1.1: Propose the requirements for a sprint
            Lesson 1.2: Explore design options for the sprint
            Lesson 1.3: Plan the development effort
            Lesson 1.4: Plan the test effort
            Lesson 1.5: Assess coverage
          Module 2: Complete a story
            Lesson 2.1: Create test scripts
            Lesson 2.2: Detailing design
            Lesson 2.3: Develop a story
            Lesson 2.4: Submit a build request
            Lesson 2.5: Test for defects
            Lesson 2.6: Fix a defect
            Lesson 2.7: Confirm that the story is done
          Module 3: Stabilize the sprint
            Lesson 3.1: Prepare for a sprint shutdown
          Summary
        Customize process in your project area and team areas
          Introduction: Customize process in your project area and team areas
          Lesson 1: Create a lifecycle project and assign roles
          Lesson 2: Create a timeline and iterations
          Lesson 3: Create a team area and add a member
          Lesson 4: Explore setting permissions
          Lesson 5: Create a role
          Lesson 6: Configure operation behavior (CCM)
          Lesson 7: Configure operation behavior (QM)
          Lesson 8: Customize behavior for an iteration type
          Summary: Customize process in your project area and team areas
      Samples
        Money that Matters sample
      Scenarios
        Collaborative Lifecycle Management (CLM) agile scenario
          Installing and setting up
            Installing Collaborative Lifecycle Management products
            Configuring the environment
          Planning the release
            Developing a vision
            Organizing requirements
            Planning the project
            Planning the test effort
          Completing plan items
            Elaborating plan items
            Detailing requirements
            Developing
            Building
            Testing
          Fixing defects and verifying
            Querying for defects
            Fixing, delivering, and building
            Verifying that defects are fixed
            Assessing iteration completeness
      Integrating
        Overview of CLM integrations
        OSLC integrations
          Linked data and OSLC integrations
          Basics of writing OSLC integrations
          Common user features
          Common administration tasks
        Integrating applications on separate Jazz servers
          Establishing cross-server communication
          Approving access requests
          Linking between project areas
      Administering
        Administering projects
          Getting started with project areas and lifecycle projects
          Administering lifecycle projects
            Logging on to the Lifecycle Project Administration application
            Creating lifecycle projects from a template
            Lifecycle project templates
            Creating a lifecycle project and adding existing project areas
            Adding project areas to a lifecycle project
            Replacing or removing project areas from lifecycle projects
            Adding members to projects
            Assigning roles from within lifecycle projects
            Configuring process role relationship rules
            Modifying a predefined template
            Creating a lifecycle project template
            Modifying an LPA template to access an RM project template
            Importing lifecycle project templates
            Deleting lifecycle projects
          Administering project areas: Tasks for all applications (web client)
            Logging in for project administrators and team leads (web)
            Understanding licenses, permissions, and access control
            Creating a project area
              Project area
              Process
            Creating timelines, iterations, and iteration types
              Creating timelines and iterations
              Timeline
              Iteration and iteration types
              Creating an iteration type
              Modifying timelines and iterations
            Creating team areas and associating work item categories
              Creating a team area
              Team area
              Defining categories that work items can be filed against in the web client
              Work item category (Filed Against)
            Adding and modifying users as members of project areas and team areas
              Adding existing users
              Assigning roles to a member
              Roles
              Assigning administrative privileges
              Specifying team invitation content in a template
            Adding and modifying roles and permissions
              Permissions
                Change and Configuration Management role-based permissions
                Quality management role-based permissions
                Requirements Management role-based permissions
              Modifying role-based permissions
                Customizing permissions for a specific time period
                Customizing permissions in a team area
              Adding and removing roles
            Restricting read access to project areas, team areas, and artifacts
              Restricting read access to project areas or team areas
              Restricting access to work item categories
              Using access groups to control access to artifacts
                Creating access groups
                Editing access groups
                Archiving access groups
                Restoring archived access groups
            Setting preconditions and follow-up actions
              Preconditions and follow-up actions
              Copying configurations
              Creating configurations
            Adding associations
            Sharing the process of a project area
              Enabling project area process sharing across servers
              Making a project area shareable
              Modifying a project area to use another project area's process
            Archiving and restoring project areas and team areas
              Archiving project areas and team areas
              Restoring archived project areas and team areas
            Managing process descriptions and practices
              Creating process descriptions
              Importing process descriptions
              Exporting process descriptions
              Archiving process descriptions
              Restoring process descriptions
              Deleting process descriptions
              Creating practices
              Importing practices
              Exporting practices
              Archiving practices, practice elements, and practice categories
              Restoring practices, practice elements, and practice categories
            Working with process templates
              Deploying predefined process templates
              Viewing process descriptions for predefined templates
              Exporting process templates
              Importing process templates
              Editing process templates
            Viewing process history
            Refreshing browser to see process changes
        Administering help content for web applications
          Help content configurations
            Reviewing the setup requirements
            Terminology
          Accessing the default remote help
          Configuring the help server for local or intranet help
            Viewing information about the help content
            Configuring more remote help connections
            Securing your help server
            Configuring network connections
          Installing local help on your computer
            Installing from the public site
            Installing from an archive file
          Setting up help content on an intranet server
            Deploying the help system on Apache Tomcat
            Deploying the help system on IBM WebSphere Application Server
          Updating the help content
          Changing the help content selection
          Troubleshooting the help setup
            Accessing the log information
            Testing remote help connections
            Fixing proxy and firewall issues
            Fixing Internet Explorer Enhanced Security Configuration issues
            Fixing Java virtual machine issues
            Updating the help.war file
      Collaborating
        Managing dashboards
          Dashboards
            Creating personal dashboards
            Accessing project and team dashboards
            Customizing mini dashboards
            Tracking progress with plan dashboards
          Adding and organizing content on a dashboard
            Creating effective dashboards
            Adding and organizing tabs on dashboards
            Saving changes to the dashboard
            Refreshing dashboard content
            Finding a dashboard
            Configuring dashboard templates in the process
          Adding and configuring widgets
            Predefined widgets in the local catalog
            Adding a widget
            Adding an OpenSocial gadget
            Adding the Lotus Connections widget to a project dashboard
            Adding a widget from another application
            Configuring widgets
            Moving and copying widgets
            Configuring widget catalog entries in the process
      Reference
        Accessibility features
          Accessibility preferences
            Fonts and color settings
            Specifying custom color settings
            Configuring the context-sensitive help for screen readers
          Keyboard shortcuts
            Help system
      Glossary
        Glossary for the Rational solution for CLM
          A
          B
          C
          D
          E
          F
          G
          H
          I
          J
          K
          L
          M
          N
          O
          P
          Q
          R
          S
          T
          U
          V
          W
          X
          Z
        IBM Terminology website
      Using the help
        Getting started with the help
          Help system overview
          Help system features
          Information types
          Identifying and bookmarking URLs
          Navigating from a mobile device
          Searching help content
        Filtering the online help
        Configuring help content for Eclipse client applications
          Help content configurations
            Reviewing the setup requirements
            Terminology
          Accessing the default remote help
          Configuring the help server for local or intranet help
            Viewing information about the help content
            Configuring more remote help connections
            Securing your help server
            Configuring network connections
          Installing local help on your computer
            Installing from the public site
            Installing from an archive file
          Setting up help content on an intranet server
            Deploying the help system on Apache Tomcat
            Deploying the help system on IBM WebSphere Application Server
          Updating the help content
          Changing the help content selection
          Troubleshooting the help setup
            Accessing the log information
            Testing remote help connections
            Fixing proxy and firewall issues
            Fixing Internet Explorer Enhanced Security Configuration issues
            Fixing Java virtual machine issues
            Updating the help.war file
        Configuring help content for RCP applications
          Help content configurations
            Reviewing the setup requirements
            Terminology
          Accessing the default remote help
          Installing local help on your computer
            Installing from the public site
            Installing from an archive file
          Setting up help content on an intranet server
            Deploying the help system on Apache Tomcat
            Deploying the help system on IBM WebSphere Application Server
            Configuring the help server for local or intranet help
              Viewing information about the help content
              Configuring more remote help connections
              Securing your help server
              Configuring network connections
          Updating the help content
          Changing the help content selection
          Troubleshooting the help setup
            Accessing the log information
            Testing remote help connections
            Fixing proxy and firewall issues
            Fixing Internet Explorer Enhanced Security Configuration issues
            Fixing Java virtual machine issues
            Updating the help.war file
        Printing topics and creating PDFs
        Customizing help content
    Jazz Team Server
      Overview
        Jazz Team Server
        Introduction to the Rational Deployment wiki
      Installing
        Installing the Rational solution for Collaborative Lifecycle Management (CLM)
          Deployment and installation planning for the Rational solution for CLM
            Deployment and installation
              Hardware and software requirements
              Deployment topologies
              How many Jazz Team Servers to use
              Planning your URIs
              Applications in this release
              Licensing
              Single sign-on
              Planning to install on Linux, UNIX, IBM i, and z/OS systems
                Planning to install on UNIX and Linux systems
                  Troubleshooting UNIX installations
                Installing with Security-Enhanced Linux
                Planning to install on IBM i systems
                Planning to install on z/OS systems
                  Checklist for z/OS installations
                  SMP/E installation process
                  Installation information for z/OS system programmers
                  Setting up the JZOS batch launcher
                  Security on z/OS systems
                    RACF security
                    Jazz Team Server security on z/OS systems
                    Security for z/OS builds
            Examples: Installation process and topology
              Example: Installation process
              **** MISSING FILE ****
              **** MISSING FILE ****
              **** MISSING FILE ****
            Techniques for changing your topology
              Reverse proxy servers in topologies
              DNS names in topologies
              Server rename in topologies
            Performance considerations
              Maximizing performance
              Idle standby deployment
                Fully distributed enterprise topology with idle standby
          Downloading the installation media
          Interactive installation guide
          Installing Jazz Team Server and the CLM applications
            Installing by using Installation Manager
            Installing from a command line
              Choosing a different context root than default
            Installing on IBM i systems
            Installing on z/OS systems
              Configuring your installation
                Creating directories
                Customizing configuration files
                  Customizing the provisioning profiles
                  Customizing the logging utility files
          Completing the installation of Jazz Team Server and the CLM applications
          Setting up the database
            Setting up a DB2 database
              Manually configuring a DB2 database
            Setting up an Oracle database
              Manually configuring an Oracle database
            Setting up an SQL Server database
              Manually configuring an SQL Server database
            Setting up a DB2 database on a z/OS system
              Prerequisites
              Setting up DB2 for z/OS for Jazz Team Server
              Customizing the Jazz Team Server and CLM properties files for DB2
              Configuring Jazz Team Server to use DB2 on z/OS
              Creating database tables
                Creating database tables remotely
              Running UNLOAD and LOAD processes for backup
          Deploying and starting the server
            Deploying and starting Tomcat
              Starting the server
              Configuring the server as a Windows service
              Running on z/OS with Tomcat
                Reviewing the Apache Tomcat port configuration
                Starting Tomcat on z/OS
            Deploying and starting WebSphere Application Server
              Administering the server by using Jython
              Administering the server by using the Integrated Solutions Console
                Setting up WebSphere Application Server
                Deploying CLM applications on the server
              Deploying by using single sign-on
              Configuring virtual hosts for applications
              Configuring a reverse proxy
              Importing the WebSphere Application Server certificate into the HTTP Server plug-in
              Starting and stopping Jazz Team Server on IBM i systems
              Running Jazz Team Server and the CLM applications on z/OS systems or WebSphere Liberty profile on z/OS
                Setting up user security on a z/OS system by using RACF
                Configuring the Rational solution for CLM and WebSphere Application Server for z/OS
                Configuring the Rational solution for CLM and WebSphere Application Server Liberty profile on z/OS
            Changing the port numbers for the application server
          Deploying for high availability
            Manual failover techniques
              Setting up servers for high availability
              Taking the primary servers offline
              Restoring the primary server
          Configuring the server
            Running custom setup
            Running express setup
            Running the setup from the command line
            Completing the installation
            Configuring the server on IBM i systems
          Configuring security certificates
            Installing a security certificate
            Disabling security certificate settings
          Support for NIST SP 800-131
            Configuring WebSphere Application Server for TLS 1.2
            Configuring IBM HTTP Server to support TLS 1.2
            Configuring Apache Tomcat for TLS 1.2
            Configuring browsers for TLS 1.2
            Configuring Rational Team Concert for TLS 1.2
            Configuring Rational connectors for TLS 1.2
          Setting up user management
            Managing users on Apache Tomcat
              Default user management on Apache Tomcat
              Managing users by using LDAP
                LDAP configuration parameters
                Configuring an LDAP connection
                Manually configuring the Tomcat web container to use LDAP
              Configuring the Tomcat LDAPLocalGroup realm
            Managing users on WebSphere Application Server
              Enabling LDAP on WebSphere Application Server
              Custom realms for authentication and group membership
              Managing users by using a federated, file-based registry
                Configuring the federated repositories
                Setting up groups and users
          Changing the public URL by using server rename
            Planning for server rename
              Server rename
              Supported scenarios
              Mapping file for server rename
              Server rename process example
              Supplemental information about server rename on Jazz.net
              Topology diagrams and mapping file examples
                Staging environment scenario
                Pilot-to-production scenario
                Production-to-production scenario
            Impact of server rename on the Rational solution for CLM
              Jazz Team Server
              Change and Configuration Management (CCM) application
              Quality Management (QM) application
                Changes to advanced properties
              Integrated products
            Performing a server rename
              Preparing the mapping file
              Scenario: Setting up a test staging environment
              Scenario: Moving a pilot or full production deployment
              Configuring RRDI after server rename
              Changing the context root
              Configuring after a database server move
                Moving CLM databases to a different database server
                Changing CLM databases to a different database vendor
            Verifying and troubleshooting server rename
              Verifying URLs and links after a server rename
              Completing the server rename verification process
                Jazz Team Servers
                Change and Configuration Management
                Quality Management
                Requirements Management
                Design Management
                Rational ClearQuest and Rational ClearCase
              Troubleshooting server rename
                General recovery procedures
                Recovering from generateURLMappings errors
                Recovering from importURLMappings errors
                Responding to server rename status errors
                Reviewing a history of server renames
          Configuring the location of the help in a distributed environment
          Managing data collection with default CLM data collection
        Installing optional tools, clients, and samples
          Installing the Build System Toolkit
            Installing by using Installation Manager
            Installing from a .zip file
            Installing the Build System Toolkit on IBM i systems
            Installing and configuring the Build System Toolkit on z/OS systems
              Creating additional directories (required)
              Configuring the ISPF gateway for build, deployment, and promotion support
          Installing the Rational Build Agent
            Installing on z/OS systems
              Creating additional Rational Build Agent directories
              Configuring the Rational Build Agent shell script
              Completing the installation and running the Rational Build Agent
              Using InetD to start the agent
              Configuring the agent
                Locating the agent configuration file
                Changing the agent port
                Configuring a different shell
                bfagent executable file
                bfagent.conf file
            Installing on IBM i systems
              Installing and running the Rational Build Agent on IBM i systems
              Configuring the agent
                Locating the agent configuration file for IBM i systems
                Changing the agent port
                Configuring a different shell
                bfagent executable file
                bfagent.conf file
            Installing and configuring the Rational Build Agent on Linux, UNIX, and Windows
              Installing an agent
                Installing an agent on Windows
                Installing an agent on Linux and UNIX
              Running an agent
                Running an agent on Windows
                Running an agent on Linux and UNIX
              Configuring the Rational Build Agent
                Locating the agent configuration file
                Changing the agent port
                Configuring a different shell
                Running agent commands on a Network Share File System (Windows)
                bfagent executable file
                bfagent.conf file
            Build Agent Lookup Service
              Configuring a lookup service task
            Troubleshooting the Rational Build Agent
          Installing Rational Team Concert connectors
            Installing Rational Team Concert ClearCase Synchronizer
              Installing by using Installation Manager
              Installing from a .zip file
            Installing Rational Team Concert ClearQuest Synchronizer
              Installing by using Installation Manager
              Installing by using Installation Manager
          Installing Rational Team Concert clients
            Installing by using Installation Manager
            Installing the Eclipse client from a .zip file
            Installing the client in Eclipse (p2 install)
            Installing Rational Team Concert Client for Microsoft Visual Studio IDE
            Installing Rational Team Concert Shell
            Installing Rational Team Concert MS-SCCI Provider
            **** MISSING FILE ****
          Installing the Rational Team Concert ISPF client
            ISPF client security
              Security settings and classes
              OMVS segment
              Data set profiles
              ISPF daemon started task on System z
              ISPF daemon as a secure z/OS UNIX server
              Application protection for the ISPF daemon
              ISPF PassTicket support
              z/OS UNIX program-controlled files for the ISPF daemon
            Troubleshooting ISPF client security
              Troubleshooting ISPF client permissions
              Troubleshooting ISPF client PassTicket support
            ISPF daemon configuration
              Started tasks for the ISPF daemon
              ISPF daemon configuration file (ispfdmn.conf)
              ISPF daemon START (S) command
            Configuring and running the ISPF client on z/OS systems
              Starting the ISPF client
          Installing the context-aware search tool
            Installing on Windows, Linux, AIX, or Solaris systems
            Installing on z/OS systems
            Installing on IBM i systems
              Starting and stopping the search engine
          Installing the Money that Matters sample
            Configuring the Money that Matters sample environment
          Installing Rational AppScan Tester Edition
        Uninstalling Jazz Team Server and the CLM applications
        Release notes
      Upgrading and migrating
        Upgrading the Rational solution for Collaborative Lifecycle Management (CLM)
          Deployment and upgrade planning for the Rational solution for CLM
            Deployment and upgrade
              Hardware and software requirements
              Deployment and upgrade process
              Client and server version compatibility
              Reporting and the upgrade process
              Licensing
              Planning to upgrade on UNIX, IBM i, and z/OS systems
                Special instructions for upgrading on IBM i
                Planning to upgrade on z/OS
            Staging a test environment for the upgrade process
            Examples: Upgrade process and topology
              Example: Upgrade stand-alone products to an integrated solution
              Example topology: Upgrade from a distributed CLM enterprise version 4 to the current version
          Downloading the installation media for an upgrade
          Upgrading from version 3 to the current version
          Interactive upgrade guide
          Upgrade script files
            jts_upgrade script
            ccm_upgrade script
            qm_upgrade script
            rm_upgrade script
          Upgrading the server configuration on z/OS
          Configuring the data warehouse after an upgrade
          Verifying the upgrade
            Verifying the configuration files during upgrade
            Verifying logs, URLs, and administrative pages
            Verifying users, licenses, and linked artifacts
          Upgrading optional tools, clients, and reporting artifacts
            Upgrading Rational Team Concert clients for Microsoft Visual Studio and Eclipse IDE
            Upgrading Jazz Build Engine
            Upgrading the Build System Toolkit on IBM i
            Upgrading the Build System Toolkit and Rational Build Agent on z/OS
            Upgrading the ISPF client daemon
            Upgrading the Rational Developer for System z integration
            Upgrading Rational Developer for Power Systems Software 8.5 to Rational Developer for i 9.0
            Upgrading Rational Developer for zEnterprise
            Upgrading ClearQuest Synchronizer
            Upgrading process templates
            Upgrading reporting artifacts
        Migrating the database and application server
          Migrating databases
          Switching from Apache Tomcat to WebSphere Application Server
          Changing WebSphere Application Server installations and instances
      Administering
        Administering Rational solution for Collaborative Lifecycle Management servers
          Getting started: Server and repository administrator
          Repository
          Logging in to administer the server
          Registering applications with the Jazz Team Server
            Managing registered applications
          Managing licenses
            Managing client access licenses
              Client access license management overview
              TRS Consumer - Internal license
              Installing and managing client access license keys
            Managing floating client access licenses
              Floating client access license management overview
              Installing and managing floating client access license keys
              Monitoring and releasing floating client access licenses
            Managing floating client access licenses — distributing Rational Common Licensing tokens
              Setting up the Rational Common Licensing token service keys
          Managing users
            Understanding licenses, permissions, and access control
            Creating users
              Importing users from an external user registry
              IBM i authentication methods
            System users
            Assigning client access licenses to users
            Assigning default licenses to new users
            Allowing users to register themselves
            Receiving email notification when a new user self registers
            Disabling the default administrative user
              Disabling the default administrative user on IBM i
            Archiving and restoring users
            Resetting a user password
            Changing your password
          Configuring the server
            Configuring email settings
            Configuring database connections
            Configuring feed settings
            Configuring the frequency of feeds
            Configuring themes
            Configuring OAuth consumers
              Registering consumer keys
              Approving consumer keys
              Editing consumer keys
              Deleting consumer keys
            Configuring friends
              Establishing friend relationships
              Editing servers in the friends list
              Deleting servers from the friends list
            Managing the URL whitelist
            Configuring advanced properties
            Storing passwords in a clear text file
            Managing the size of the log file
            Enabling distributed source control
            Enabling Open Services for Lifecycle Collaboration
            Synchronizing LDAP with Jazz Team Server repository user information
              Viewing the results of a synchronization
              Changing the synchronization frequency
          CLM server monitoring
          Backing up and restoring CLM applications
          Backing up and restoring the Derby database
          Backing up and restoring other supported databases
          Patch service for CLM applications
      Troubleshooting and support
        General product troubleshooting
          Registering on the IBM Support Portal
          Accessing release information
          Subscribing to product updates
          Searching online knowledge bases
          IBM Support Assistant
          IBM Education Assistant
          Getting fixes
          Contacting IBM Software Support
          Fixing line wrap issues in Internet Explorer
          Disabling logging in Eclipse-based products
        Log file locations
        Messages
        Using the IBM Support Assistant Lite to gather diagnostic information
          Running the IBM Support Assistant Lite utility
          Expanding the scope of data gathered
          Reducing the scope of data gathered
        Troubleshooting Jazz Team Server
          Troubleshooting the Jazz Team Server setup wizard
      Reference
        Repository Tools command-line reference
          -addTables
          -archiveUser
          -backupJFSIndexes
          -compacttdb
          -convertTomcatUsers
          -copy
          -createTables
          -createUser
          -createUsers
          -createWarehouse
          -deleteJFSResources
          -dropTables
          -executeDiagnostics
          -export
          -exportServerRenameURLMappingHistory
          -exportUsers
          -finalizeApplicationMigration
          -generateURLMappings
          -generateWarehouseDDLScripts
          -generateWarehouseUpgradeScripts
          -help
          -import
          -importURLMappings
          -importUsers
          -isServerRunning
          -listIssuedFloatingLicenses
          -listLicenses
          -listStorageAreaKeys
          -migration_importJTSData
          -migration_ccm_updateConfigurationFiles
          -migration_jts_updateConfigurationFiles
          -migration_qm_updateConfigurationFiles
          -modifyLinkURIs
          -onlineMigrate
          -onlineMigrateEstimate
          -onlineMigrateRevert
          -onlineMigrateStop
          -patchApplyApp
          -patchApplyGlobal
          -patchRevertApp
          -patchRevertGlobal
          -rebuildClosureTable
          -rebuildIndices
          -rebuildTextIndices
          -reindex
          -repairSuites
          -resetRepoLockId
          -restoreJFSIndexes
          -resumeIndexer
          -rmUpdateConfigurationFiles
          -rmUpdateProjectBackLinks
          -rmUpdateProjectBackLinksOnline
          -setStorageAreaKeys
          -setup
          -suspendIndexer
          -syncUsers
          -upgradeWarehouse
          -verify
          -verifyURLMappings
          -version
    Rational DOORS Next Generation
      Overview
        Overview of the Requirements Management application
          Overview of Rational DOORS Next Generation
          Rational DOORS compared to Rational DOORS Next Generation
        Getting started with Rational DOORS Next Generation
          Getting started for RM project administrators
          Getting started with creating and managing requirements
          Videos and task scenarios
      Tours
        Rational DOORS Next Generation overview
      Tutorials
        Create and define requirements
          Introduction: Create and define requirements
          Lesson 1: Create requirements and edit requirement attributes
          Lesson 2: Create links in requirements
          Lesson 3: Tag artifacts by using shared tags
          Lesson 4: Import Microsoft Word documents
        Find and view project artifacts in a requirements project
          Introduction: Find and view project artifacts
          Lesson 1: Open and view artifacts
          Lesson 2: Find and tag artifacts
        Comment on and review requirement artifacts
          Introduction: Comment on and review requirement artifacts
          Lesson 1: Comment on requirement artifacts
          Lesson 2: Review and approve requirement artifacts
        Create collections and reviews
          Introduction: Create collections and reviews
          Lesson 1: Create a collection
          Lesson 2: Create a review of a collection
        Create and administer a project
          Introduction: Create and administer a project
          Lesson 1: Create a project, add a user, and assign a process role
          Lesson 2: Run a requirements report
          Lesson 3: Customize the project dashboard
        Manage requirements in the Rational solution for CLM
          Introduction: Manage requirements in the Rational solution for Collaborative Lifecycle Management (CLM)
          Lesson 1: Create links from requirements to development and test artifacts
          Lesson 2: Create links from collections to release plans and generate plan items
          Lesson 3: Create links from collections to test plans and generate test cases
          Lesson 4: Monitor the status of artifacts by using CLM links
          Lesson 5: View CLM links on the project dashboard
        Create and organize modules
          Introduction: Create and organize modules
          Lesson 1: Create a module and add artifacts
          Lesson 2: Modify the hierarchy of artifacts in a module
          Lesson 3: Add comments to artifacts in a module
          Lesson 4: Create a module from a text document
      Installing
        Installing the RM application
      Upgrading and migrating
        Upgrading the RM application
        Migrating Rational RequisitePro projects to the Requirements Management application
          Support for data types in migrated projects
          Support for user groups in migrated projects
          Support for view query conditions
          Migrating a Rational RequisitePro project
          Importing Rational RequisitePro users into a Tomcat project registry
          Migrating Rational RequisitePro projects with Rational Quality Manager integration to the RM application
          Capability comparison: Rational RequisitePro and the RM application
      Integrating
        Rational RequisitePro
        Rational DOORS
          Configuring the RM application to be a consumer
          Associating an RM project with a Rational DOORS module
          Configuring the RM application to be a provider
        Rational ClearQuest
        Rational Change
      Administering
        Administering Rational solution for Collaborative Lifecycle Management servers
        Administering requirements projects
          Creating requirements projects
          Project baselines
          Permissions
          Creating requirements project templates
          Managing requirements project templates
          Creating artifact templates
          Managing artifact templates
          Creating module templates
          Creating module baselines
          Managing project properties in a requirements project
            Creating artifact types
            Creating attributes
            Creating requirement attribute data types
            Importing project properties from a Requirement Management (RM) project
          Creating link types
            Link types
      Collaborating
        Dashboards in the RM application
      Managing and composing requirements
        Joining a requirements project
          Logging in to a requirements project repository
          Project dashboards
          Personal dashboard
        Defining requirements
          Creating artifacts
            Artifacts
            Artifact types
            Artifact formats
          Editing attributes with multiple values
          Filters and views
          Locks
          Artifact search
          Uploading files
          Data exchange methods
          Vision document
          Creating modules
            Modules
            Differences between collections and modules
            Duplicating a module
            Searching for artifacts in a module
            Linking between artifacts in modules
            Modifying hierarchy in modules
            Reusing artifacts in modules
            Filters and views
            Adding comments to artifacts in a module
            Exporting artifacts from modules to CSV files
          Importing and exporting files
            Import document planning
            Importing documents
            Importing and extracting artifacts from documents
            Importing artifacts from CSV files
            Exporting artifacts to CSV files
            CSV format and examples
            ReqIF files
              Importing from ReqIF files
              Exporting to ReqIF files
          Creating collections
            Collections
            Comparing collections
          Creating artifacts to support requirements
            Defining business processes
              Business process diagram overview
              Business rules
              Business process diagrams
              Business process elements
              Creating a business process diagram
            Creating use cases
              Use cases
              Creating a use-case diagram
              Creating an actor artifact
              Use-case specification outline
            Sketching the user interface
              User interface sketches
              Creating a user interface sketch
              Creating a user interface part
            Creating a screen flow
              Screen flows
            Creating a storyboard
              Storyboards
          Managing terminology and glossaries
            Glossaries
            Creating a glossary and terms
          Commenting on artifacts
          Reviewing artifacts
            Reviews
            Creating reviews
            Participating in a review
        Managing requirements
          Managing artifacts with attributes
          Adding tags to artifacts and viewing tagged artifacts
          Comparison of artifact grouping methods in requirements management
          Traceability
          Suspect traceability
            Creating suspicion profiles
            Viewing and clearing suspect traceability
            Suspicion indexing
          Managing requirements status and other properties
          Analyzing the impact of change
          Linking
            Links
            Linking to existing artifacts in lifecycle applications
            Linking to new artifacts in lifecycle applications
            Linking collections, modules, and module views to development and test plans
            Links explorer
            Linking requirements to Rational ClearQuest records
            Filtering artifacts for links to other applications
          Viewing artifact history
      Reporting
        Reporting
          Creating document-style reports
          Running data warehouse reports
          Requirements Management (RM) application report descriptions
          RM reportable REST API
          Data dictionary
      Extending product function
        Extending the RM application
        Extending by using OSLC services
          RM as an OSLC service consumer
          RM as an OSLC service provider
          Links across OSLC domains
          Additional OSLC integration services and requirements
      Troubleshooting and support
        Troubleshooting the RM application
          Log file locations
          Fixing a converter issue in the server in headless mode
          Opening multiple browser tabs or windows
          Opening artifacts in new tabs in the same browser window
          Redirecting HTTP requests
          Pasting invalid XHTML text
          Cutting, copying, and pasting text
          Updating custom Word templates
          Creating a hyperlink to a local file
          Moving artifacts from a folder
          Support information for the RM application
    Rational Team Concert
      Overview
        Overview of Rational Team Concert
        Getting started with Rational Team Concert
      Tours
        Rational Team Concert overview
        Rational Team Concert source control
        Rational Team Concert Build
        Rational Team Concert planning
        Rational Team Concert Enterprise Extensions tours
          Dependency builds (part 1)
          Dependency builds (part 2)
          Dependency builds (part 3)
          Dependency builds on IBM i
          Context-aware search
          Component promotion
          Work item promotion (part 1)
          Work item promotion (part 2)
          Packaging and deployment
          Source code data collection service
          Rational Developer for System z integration feature
          ISPF client
          ISPF client build results management
        Help content configuration options
      Tutorials
        Getting started
          Get started with Rational Team Concert
            Lesson 1: Setting up a project and team as Administrator
            Lesson 2: Getting connected
            Lesson 3: Using work items
            Lesson 4: Working with plans
            Lesson 5: Using the Team Dashboard and My Work views
            Lesson 6: Managing source code
            Lesson 7: Building with Rational Team Concert Build
            Lesson 8: Using the web client
            Summary
          Explore the Rational Team Concert JUnit example project
          Using an Ant with Enterprise Extensions build to compile a COBOL application
            Lesson 1: Preparing your environment
            Lesson 2: Configuring the Rational Build Agent shell script
            Lesson 3: Configuring the Rational Build Agent
            Lesson 4: Creating data set definitions
            Lesson 5: Creating translators
            Lesson 6: Creating language definitions
            Lesson 7: Creating a shared zComponent Project
            Lesson 8: Adding zFolders and associating them with data set definitions
            Lesson 9: Adding build artifacts and associating them with language definitions
            Lesson 10: Configuring a build definition
            Lesson 11: Requesting a build
          Configuring your Jazz Team Server and Rational Team Concert Eclipse client for a sample z/OS application
        Project planning
          Plan an agile project
            Introduction: Plan an agile project
            Lesson 1: Create the product backlog
            Lesson 2: Plan the release
            Lesson 3: Plan the sprint
            Lesson 4: View your work
            Lesson 5: Track progress by using queries
            Lesson 6: Schedule the sprint review
            Lesson 7: Shut down the sprint
            Summary: Plan an agile project
          Plan a traditional project
            Introduction: Plan a traditional project
            Lesson 1: Create a release plan for the project
            Lesson 2: Add resources to the project plan
            Lesson 3: Identify and plan for risks
            Lesson 4: Define project work
            Lesson 5: Create phase plans and the plan schedule
            Lesson 6: Assign owners to work items
            Lesson 7: Take a snapshot of the planned schedule
            Summary: Plan a traditional project
          Define and manage risks
            Lesson 1: Define a risk
            Lesson 2: Create a risk action
            Lesson 3: Linking a risk with a risk action
            Summary: Define and manage risks
          Create plans and work items in the Rational Team Concert Client for Microsoft Visual Studio IDE
            Create plans and work items
            Lesson 1: Create a plan
            Lesson 2: Create a work item
        Project management
          Control access to project areas and their artifacts
            Introduction: Control access to project areas and their artifacts
            Lesson 1: Control read access to project area
            Lesson 2: Restrict access to work items based on team membership
            Lesson 3: Control access to specific work items by using an access group
            Lesson 4: Restrict access to source control artifacts
            Summary: Control access to project areas and their artifacts
          Standardize process by using project area process sharing
            Introduction: Standardize process in your organization by using project process sharing
            Lesson 1: Create a provider project area
            Lesson 2: Create a standard setup process template
            Lesson 3: Create a consumer project area
            Lesson 4: Show that the consumer project area uses the process from the provider project area
            Lesson 5: Override permissions in the consumer project area
            Lesson 6: Prevent the consumer project area from overriding the permission settings inherited from the provider project area
            Summary: Standardize process in your organization by using project area process sharing
        Work item customization
          Customize work items
            Customize work items
            Lesson 1: Create a work item type
            Lesson 2: Create a work item attribute
            Lesson 3: Create an enumeration attribute type
            Lesson 4: Define a workflow with approval tracking
            Lesson 5: Customize the work item editor
            Lesson 6: Create a ToDo work item
        Source control
          Share changes with your team
            Share changes with your team
            Lesson 1: Create a repository workspace from a stream
            Lesson 2: Deliver changes and resolve a work item
            Lesson 3: Accept changes from other team members
            Lesson 4: Resolve a conflict
          Share changes using the web client
            Share changes using the web client
            Lesson 1: Add files and folders to a stream
            Lesson 2: Lock, download, and edit a file
            Lesson 3: Create and edit a text file
          Share changes with your team in the Rational Team Concert Client for Microsoft Visual Studio IDE
            Share changes with your team
            Lesson 1: Create a repository workspace from a stream
            Lesson 2: Deliver changes and resolve a work item
            Lesson 3: Accept changes from other team members
            Lesson 4: Share a project and solution
          Share changes with your team in the Rational Team Concert Shell
            Share changes with your team
            Accept a team invitation
            Create a repository workspace
            Deliver changes to team members
            Set preferences
            Resolve a conflict
            Work with Jazz properties
            Share changes in Basic mode
          Preserve component and workspace configuration in the Rational Team Concert Client for Microsoft Visual Studio IDE
            Preserve component and workspace configuration
            Lesson 1: Create a component baseline
            Lesson 2: Accept incoming baselines and change sets
            Lesson 3: Create a snapshot and assign an owner to it
        Build management
          Manage builds with the Rational Team Concert Build
            Manage builds with the Rational Team Concert Build
            Lesson 1: Build definitions and build engines
            Lesson 2: Build requests
            Lesson 3: Build results
          Manage builds with the Rational Team Concert Build in the Rational Team Concert Client for Microsoft Visual Studio IDE
            Manage builds with the Rational Team Concert Build
            Lesson 1: Build definitions and build engines
            Lesson 2: Build requests
            Lesson 3: Build results
          Using Enterprise Extensions dependency builds
            Introduction: Using Enterprise Extensions dependency builds
            Lesson: Using dependency builds to build new and changed artifacts
        ClearCase and ClearQuest Synchronizers
          Get started with the ClearCase Synchronizer
            Introduction: Get started with the ClearCase Synchronizer
            Create a Jazz administrative user
            Add a process role to the Jazz administrative user
            Create a ClearCase Synchronized Stream and merge workspace
            Import files and folders from Rational ClearCase
            Load imported files to a Rational Team Concert workspace
            Deliver changes in a synchronized environment
            Verify exported files in Rational ClearCase
            Create a schedule for future synchronizations
            Summary
          Get started with the Rational ClearQuest Synchronizer
            Module 1: Setting up your Rational ClearQuest environment
              Lesson 1.1: Create a schema repository
              Lesson 1.2: Create a schema and user database
            Module 2: Setting up your Jazz environment
              Lesson 2.1: Create an administrative user
              Lesson 2.2: Create a project area
            Module 3: Using the ClearQuest Synchronizer Setup Wizard
              Lesson 3.1: Start the Rational ClearQuest Gateway
              Lesson 3.2: Use the Rational ClearQuest Synchronizer Setup Wizard
            Module 4: Editing synchronization rules
              Lesson 4.1: Assign a role with necessary permissions to the ClearQuest Synchronizer user
              Lesson 4.2: Edit Project synchronization rule
              Lesson 4.3: Edit the Defect synchronization rule
            Module 5: Enabling outgoing synchronization
              Lesson 5.1: Enable outgoing synchronization for the Jazz Team Server
              Lesson 5.2: Enable outgoing synchronization for the external repository connection
            Module 6: Testing the configuration
              Lesson 6.1: Submit a Project record
              Lesson 6.2: Submit a Defect record
            Summary
      Scenarios
        Iterative development
          Planning an iteration
          Managing iterations
          Assessing iteration results
        Managing risks
      Installing
        Installing the Change and Configuration Management application
      Upgrading and migrating
        Upgrading the Change and Configuration Management application
        Online migration
        Migrating from the ClearQuest Synchronizer to the ClearQuest Bridge
      Integrating
        Rational Build Forge
          Creating Build Forge build engines
          Creating Build Forge build definitions
        Rational Change
        Rational ClearCase
          Getting started with the Rational ClearCase connectors
          Rational Team Concert concepts for Rational ClearCase users
          Synchronizing data with the ClearCase Synchronizer and ClearCase Baseline Importer
            Deploying Rational Team Concert into a Rational ClearCase Environment
            Planning to synchronize and import
              Guidelines for Rational ClearCase users
              How element types map to item content types
              Selecting the Rational ClearCase stream or branch to synchronize
              How exports are mapped to VOBs and UCM components
              Imported components in synchronized streams
              Running ClearCase Synchronizer subcommands from the command line
              Updating the synchronizer after server rename
                Updating the synchronizer in production environments
                Updating the synchronizer in test-staging environments
            Preparing the synchronization environment
              Configuring a synchronization host
              Selecting an operating system account for the synchronization process
              Creating a Jazz administrative user for the synchronization process
              Adding the Jazz administrative user to your team
              Preparing a sub-VOB component for base Rational ClearCase synchronization
                Known limitations of sub-VOB component mapping
                Migrating a synchronization stream
            Synchronizing data with the ClearCase Synchronizer
              Creating a ClearCase Synchronized Stream and merge workspace
                Importing files and folders from Rational ClearCase
                Exporting files and folders to Rational ClearCase
                Removing a synchronization root
                Loading a component root folder into a sandbox
                Specifying line termination characters for text files
                Configuration specification details for base Rational ClearCase
                Creating a synchronized stream work item template
                Writing Rational ClearCase triggers for synchronization
                Configuring a synchronized stream to support UCM projects that are enabled for Rational ClearQuest
              Running synchronizations
                Scheduling synchronization
                Running custom scripts before and after synchronization
                Resolving conflicts during synchronization
                Stopping the synchronization build engine process
                Starting the synchronization build engine process
                Canceling and abandoning a synchronization request
              Delivering changes in a synchronized environment
            Importing
              Preparing to import Rational ClearCase data with history
              Importing multiple streams from Rational ClearCase UCM or base Rational ClearCase
              Importing Rational ClearCase history from a UCM stream
              Importing Rational ClearCase history from base Rational ClearCase
              Verifying the imported history of a stream or component
              Importing additional Rational ClearCase history
            Managing the synchronization environment
              Managing ClearCase Synchronized Streams
                Editing a synchronized stream
                Synchronization options
                Synchronized stream properties
                Unlocking a synchronized stream
                Changing the default script location of a synchronized stream
              Managing the synchronization host
                Changing the synchronization host
                Changing the Rational ClearCase dynamic view
                Upgrading the ClearCase Synchronizer
              Managing merge workspaces
                Modifying the merge workspace
                Creating a merge workspace for an existing synchronized stream
            ClearCase Synchronizer limitations and known problems
              Troubleshooting synchronization problems
              Synchronization errors
          Migrating data with the ClearCase Version Importer
            Planning to export and import with the ClearCase Version Importer
              Identifying VOBs and subfolders for migration
              Choosing the Rational ClearCase view configurations
              Selecting versions to export by filtering
                Examples of selecting versions with filters
              Planning disk space for exporting or importing
              Planning to migrate data incrementally
              How element types map to item content types
            Preparing the environment for exporting and importing with the ClearCase Version Importer
              Configuring the export and import hosts
              Selecting an operating system account for exporting
              Adding the Jazz administrative user account to your team
              Creating Rational Team Concert streams and components
            Exporting and importing data with the ClearCase Version Importer
              Exporting multiple configurations
              Migrating data in increments
              Exporting data and specifying the change-set comment format
              Updating character encoding of text files
              Excluding file elements from the exported data files
              Specifying the user accounts mapping
              Importing data into Rational Team Concert source control
              Importing change-set links from the Rational ClearQuest and Rational ClearCase integration
              Verifying the imported history of a stream or component
            ClearCase Version Importer limitations and known problems
              Troubleshooting export problems
              Troubleshooting import problems
              Error messages
          Using the ClearCase Bridge
            ClearCase Bridge version compatibility and functionality
            Connecting Rational Team Concert and UCM
              Manually associating a Rational ClearCase activity with a work item
              Viewing linked work items and UCM activities
              Enforcing an association between a Rational ClearCase activity and a work item
              Configuring site-wide ClearCase Bridge UCM integration
            Connecting Rational Team Concert and base Rational ClearCase
              Associating Rational ClearCase element versions with a work item during operations
              Manually associating a Rational ClearCase element version with a work item
              Viewing linked work items and element versions
            Updating the bridge after server rename
              Updating the bridge in production environments
              Setting up a test staging environment with production data
        Rational ClearQuest
          Configuring and using the Rational ClearQuest Synchronizer
            Getting started with the ClearQuest Synchronizer
            Prerequisites
            Configuration checklist
            Deploying the ClearQuest Synchronizer
              Connecting to multiple project areas
              Starting the ClearQuest Gateway
              Verifying that the ClearQuest Gateway is running
            Using the ClearQuest Synchronizer Setup Wizard
              Starting the ClearQuest Synchronizer Setup Wizard
              Configure ClearQuest
              Jazz server configuration
              Create ClearQuest record filtering queries
              Reset Gateway
            Configuring a Jazz project area for the ClearQuest Synchronizer
              Synchronization rules
              Planning synchronization rules
                Sample planning worksheet
                Reviewing generated synchronization rules
              Creating synchronization rules
                Mapping record types to work item types
                Configuring synchronization rules for external users
                Editing synchronization rules to specify categories
                Creating a synchronization rule for attachments
                Mapping comments to notes log entries
                Mapping referenced fields
                Displaying the contents of a referenced record
                Synchronizing users
                How items become candidates for outgoing synchronization
              Creating and modifying an external repository connection
            Modifying Connector service parameters
            Configuring the ClearQuest Synchronizer to create OSLC links
            Stopping and restarting the ClearQuest Gateway
            Enabling outgoing synchronization
            Testing the ClearQuest Synchronizer
            Preparing the ClearQuest Synchronizer for renaming the Jazz Team Server
              Preparing the ClearQuest Synchronizer for a server rename operation
              Performing post-server rename actions for the ClearQuest Synchronizer – test staging scenario
              Performing post-server rename actions for the ClearQuest Synchronizer – production scenarios
            Importing a batch of ClearQuest records
              Importing but not synchronizing records
            Working in a configured environment
              Associating a category with a team area
              Viewing synchronization status
              Finding and resolving conflicts
              Filtering for connector events
              Resolving blocked synchronization
              Resolving communication problems with the Jazz Team Server
              Viewing log files
              Deleting records and work items
              Preparing to archive a synchronized project area
              Additional troubleshooting resources
            MultiSite considerations
              Applying the JazzInterop package to MultiSite replica schemas
            Additional resources
            Upgrading the user database with a new version of the JazzInterop package
          Configuring and using the Rational ClearQuest Bridge
            Getting started with the ClearQuest Bridge
            Configuring the ClearQuest Bridge
            Working with records in the web client
              Adding ClearQuest content on the dashboard
                Adding the ClearQuest Query widget
                Configuring the ClearQuest Query widget
                Adding the ClearQuest Chart widget
                Configuring the ClearQuest Chart widget
              Finding and reviewing records
              Updating and resolving records
            Associating work items and records
            Agile planning for records
              Breaking down the ClearQuest backlog
              Updating work items and records
              Prioritizing and scheduling work items
              Tracking work item and iteration progress
              Resolving work items and records
          Migrating Rational ClearQuest records to work items
            Customizing the mapping file
              Mapping attributes
              Specifying attribute types
              Mapping attribute values
              Concatenating field values for the work item category mapping
              Mapping record types to work item types
              Mapping state and resolution values
              Mapping ClearQuest record relationships to work item relationships
              Importing ClearQuest FTP links
        Rational DOORS
        Rational Engineering Lifecycle Manager
        Rational Focal Point
        Git
        Hudson/Jenkins build engine type
          Creating a Hudson/Jenkins build engine
          Creating a Hudson/Jenkins build definition
        IBM Connections
          Associating a Jazz project with an IBM Connections community
          Adding the IBM Connections widget to a project dashboard
          Connecting to a IBM Connections community
          Sharing ideas with a IBM Connections community through work items or dashboards
        IBM UrbanCode Deploy
          Creating build definitions for IBM UrbanCode Deploy
        Jenkins plugin
        Microsoft Source Code Control Interface
          Setting up repository workspaces
            Connecting to repositories and project areas
            Creating repository workspaces
            Loading repository workspaces
          Sharing changes with your team
            Sharing changes
            Checking in change sets
            Accepting incoming change sets
            Delivering change sets
          Additional features
          Integrating Rational Rhapsody with Rational Team Concert and MS-SCCI
            Configuring MSSCCI as the source control provider
            Source control operation mappings for Rational Rhapsody
            Sharing changes in Rational Rhapsody
            Viewing the change history of files
            Viewing file properties
          Setting preferences
        Rational Synergy
        Subversion
          Importing Subversion repository contents to Rational Team Concert source control
          Importing a Subversion dump file
          Importing branches after you import the trunk
          Linking work items to Subversion repositories
        Rational Developer for i
          Installing and configuring the integration
          Introduction to Rational Team Concert and Rational Developer for i
            Orientation to Rational Team Concert for Rational Developer for i users
            Orientation to Rational Developer for i for Rational Team Concert users
          Developing IBM i applications using Rational Developer for i
          Sharing i Projects
        Rational Developer for Power Systems Software
          Installing and configuring the integration
          Introduction to Rational Team Concert and Rational Developer for Power Systems Software
            Orientation to Rational Team Concert for Rational Developer for Power Systems Software users
            Orientation to Rational Developer for Power Systems Software for Rational Team Concert users
          Developing AIX applications using Rational Developer for Power Systems Software
          Developing IBM i applications using Rational Developer for Power Systems Software
          Sharing i Projects
        Rational Developer for System z
          Installing and configuring the integration
            Installing the file agent RSE miner
            Installing the integrated client
            Installing Rational Team Concert on Rational Developer for System z
          Orientation to Rational Developer for System z and Rational Team Concert integration
            Orientation to Rational Team Concert for Rational Developer for System z users
            Orientation to Rational Developer for System z for Rational Team Concert users
          Adding Rational Developer for System z to an existing Rational Team Concert installation
            Differences in Rational Developer for System z operations after sharing artifacts to Rational Team Concert
            Managing dependencies
            Loading artifacts to Rational Developer for System z
            Adding an artifact to Rational Team Concert
          Working with Rational Team Concert projects locally
          Requesting a user build
            Adding error feedback support to user build
            Built-in Jazz properties
            JCL parm can exceed the character limit
            Specify alternative DD names in user build
          Setting up additional debug parameters on z/OS
      Administering
        Administering Rational solution for Collaborative Lifecycle Management servers
        Administering change and configuration management project areas
          Working in the web client
          Working in the client for Eclipse IDE
            Connecting to repositories and project areas
            Connecting to JazzHub projects
            Accepting a team invitation
            Creating and modifying project areas
              Creating project areas
              Sharing the process of a project area
                Enabling project area process sharing across servers
                Making a project area shareable
                Modifying a project area to use another project area's process
              Creating timelines, iterations, and iteration types
              Setting project hours and days per week
              Creating a team area
              Adding and modifying users as members of project areas
                Adding existing users
                Creating users
                Importing users from an external registry service
                Assigning roles to users
                Assigning administrative privileges
                Modifying user information
                Setting user work environments
                Scheduling team member absences
              Defining work item categories
              Adding attachments to project areas and team areas
              Restricting read access to project area, team areas, and artifacts
                Restricting read access to project areas or team areas
                Restricting access to work item categories
              Archiving project areas and team areas
              Adding associations
            Customizing the process in projects, teams, and templates
              Editing the process description
              Modifying timelines and iterations
              Modifying roles
              Modifying permissions
              Synchronizing time entries
              Modifying operation behavior (preconditions and follow-up actions) in project areas and team areas
                Operation Behavior (preconditions and follow-up actions)
              Modifying project area initialization
              Adding formal project management features to a process template
                Process customization for formal project management
              Viewing history of changes to process
              Refreshing the client to see process changes
            Working with process templates
              Creating a process template
              Process templates
                OpenUP process template
                Scrum process template
                Simple Team process template
                Formal Project Management Process template
                Unconfigured Process template
              Creating process template documentation
              Including reports in a process template
              Exporting and importing process templates
              Migrating a project to a different process template
              Adding a translation to a process template
              Making templates translatable
          Working in the client for Microsoft Visual Studio IDE
            Working with projects and teams
              Project concepts
                Repository
                Project area
                Team area
              Getting started with projects and teams
              Accepting team invitations
              Connecting to repositories
                Deleting repository connections
                Modifying repository connection properties
                Viewing Client Access License and server information
              Connecting to project areas
              Connecting to JazzHub projects
              Disconnecting project areas
              Clearing session history
      Collaborating
        Getting started with your development project
          Getting started: Project administrator
          Getting started: Team lead
          Getting started: Team member
          Quick reference
        Managing dashboards
        Creating development plans
          Getting started with planning
          Plans and work item management
            Plan types
            Agile planning
            Traditional planning
              Schedules in traditional project plans
              Schedule dependencies
              Schedule constraints
              Critical path
              Basic resource leveling
              The Work breakdown and Schedule chart
          Planning the development with the Eclipse client
            Planning projects
              Creating project plans
              Adding unstructured content to plan notes
              Renaming and reassigning a plan
              Duplicating plans
              Setting work item types as plan items
              Resolving conflicts in planned items
              Viewing plans associated to a work item
              Subscribing to plans
              Linking development plans
            Changing plan configuration settings for a project
              Setting project hours and days per week
              Configuring the preview pane
              Computing progress of release plans
              Showing time remaining or time spent
              Configuring attributes in customized work items to display in a plan
              Permitting users to modify allocation
            Managing work items and work loads
              Viewing work items in a plan
              Adding work items to a plan
              Modifying and moving work items in a plan
              Creating a work item in a plan from a template
              Find, filter, and colorize work items
              Organizing work items with plan views
                Creating plan views
                Configuring plan views
                Associating plan views with a plan type
                Modifying plan view elements in the process configuration
              Ranking work items
              User profile
                Setting a user's work environment
                Scheduling team member absences
              Configuring team loads
              Managing work items in My Work view
                Managing my new work
                Managing my current work
                Managing my future work
                Previewing my work items
            Progress reports and charts
          Planning the development with the web client
            Planning projects
              Creating project plans
              Creating a child iteration
              Tracking progress with plan dashboards
              Importing and exporting plans with Microsoft Project
                Importing, exporting, and reimporting project plans
              Plan snapshots
                Taking, comparing, and deleting plan snapshots
              Linking development plans
            Managing work items
              Viewing work items in a plan
              Viewing the Work Breakdown and Schedule chart (Gantt chart)
              Creating, modifying, and moving work items in a plan
              Creating work items from requirements
              Creating schedule dependencies between work items
              Tracking work item relationships across projects
              Organizing work items in a plan
                Creating plan views
                  Plan view options
                Configuring existing plan views
              Ranking work items
                Ranking all work items in a plan
                Ranking work items by dragging
                Ranking work items by using menu options
                Changing the ranking of work items
            Managing project resources
              Allocating resources to a project
              Adding allocation periods for resources
              Modifying allocation periods for resources
              Adding allocation periods for a project
            Load, Progress, and Burndown reports in the Plan Details
          Planning the development with the Rational Team Concert Client for Microsoft Visual Studio IDE
            Creating development plans
              Plans and work item management
              Plans
                Plan types
              Creating plans
                Creating plan overviews
                Adding plan pages
                Renaming and reassigning plans
              Managing work items
                Grouping work items in plans
                Modify work items in plans
                Creating plan modes
                Configuring plan modes
        Instant messaging
          Connecting to local Sametime applications
          Connecting to Jabber servers
          Chatting with team members
          Sending files to team members
          Sending artifact links to team members from the Rational Team Concert Client for Microsoft Visual Studio IDE
      Managing change and releases
        Getting started with change management
        Getting started with configuration management
        Getting started with the Rational Team Concert Client for Microsoft Visual Studio IDE
        Tracking work by using work items
          Getting started with work items
          Work items
          Setting up work items
            Defining categories that work items can be filed against
            Defining categories that work items can be filed against in the web client
            Defining releases
            Defining releases in the web client
            Importing Bugzilla bugs
            Importing work items from a CSV file
            Using a template to create work items
              Creating a work item template
              Importing a template
            Creating text templates
            Time tracking for work items
          Working in the Eclipse client
            Work items perspective and views
              Work Items view
              Team Artifact view
              My Work view
              Team Dashboard view
              Tag Cloud view
            Creating work items
              Additional ways to create work items
              Creating work items from a template
            Working on and resolving work items
              Triaging work items
              Updating work items
              Modifying multiple work items simultaneously in the Eclipse client
              Specifying work item constraints
              Viewing work item history
              Linking to work items on remote repositories
              Linking work items to test artifacts
              Linking work items to requirements
              Linking work items to plans
              Entering time for a work item
              Exporting work items
              Printing work items
              Restricting access to work items
            Finding work items
              Using predefined queries
              Creating queries
              Configuring queries to show work item relationships
              Retrieving a specific work item
              Searching for potential duplicate work items
              Searching from the Console and Error Log views
              Using full-text search to find work items
            Deleting work items in the Eclipse client
            Deleting work item comments
            Configuring notifications
            Managing risks
              Defining risks
              Creating risk actions
              Setting the currency of risk costs
            Customizing work items
              Work item customization overview
              Defining work item types and attributes
              Updating work items with new or modified attributes
              Defining an approval tracking process
              Defining a workflow
              Defining enumerations
              Defining required and implied attributes
              Configuring read-only attributes for work item type and work item state
              Requiring E-Signatures
              Requiring approvals for state transitions
              Predefining queries
              Customizing the work item editor
              Adding the Restricted Access presentation
              Customizing the Quick Information section
              Including process guidance in the work item editor
              Customizing attributes
                Customization types
                Configuring default values
                  Configuring a default description
                  Configuring a role-based enumeration default
                Configuring value sets
                  Configuring a dependent enumeration value set
                  Configuring a role-based user list value set
                  Configuring an HTTP filtered value set provider
                Configuring validators
                  Configuring a regular expression validator
                Configuring conditions
                  Configuring dynamic required attributes
                  Configuring dynamic Read-Only attributes
              Customizing Email notifications
              Defining mapping between change management type and work item type
          Working in the web client
            Work Items pages in the web client
            Creating work items in the web client
              Creating work items from a template in the web client
            Working on and resolving work items in the web client
              Triaging work items in the web client
              Updating work items in the web client
              Modifying multiple work items simultaneously in the web client
              Specifying work item constraints in the web client
              Viewing work item history in the web client
              Linking to work items on remote repositories in the web client
              Linking work items to test cases in the web client
              Linking work items to requirements in the web client
              Linking work items to plans in the web client
              Entering time for a work item in the web client
              Restricting access to work items
              Exporting work items in the web client
              Printing work items in the web client
            Finding work items in the web client
              Using predefined queries in the web client
              Using lifecycle queries
              Creating queries
              Retrieving a specific work item in the web client
              Searching for duplicate work items in the web client
            Deleting work items in the web client
            Configuring notifications in the web client
            Managing risks
              Defining risks
              Creating risk actions
            Customizing work items in the web client
              Work item customization overview
              Setting preconditions and follow-up actions for saving work items
              Defining work items types and attributes in the web client
              Defining enumerations in the web client
              Customizing the work item editor in the web client
              Including process guidance in the work item editor
              Adding the Restricted Access presentation
              Defining a workflow in the web client
              Customizing Email notifications in the web client
              Defining mapping between change management type and work item type in the web client
          Working with work items in the client for Microsoft Visual Studio
            Getting started with work items
            Team Artifact window
            My Dashboard window
            Configuring the My Dashboard window
            Creating work items
              Additional ways to create work items
              Creating work items from a template
            Working on and resolving work items
              Triaging work items
              Updating work items
              Modifying multiple work items at once
              Viewing work item history
              Linking work items to artifacts on remote repositories
              Tracking current work
              Exporting work items
            Finding work items
              Creating queries
              Using predefined queries
              Retrieving specific work items
            Configuring notifications
          Linking to requirements and test artifacts
        Managing source code
          Getting started with Rational Team Concert source control
          Rational Team Concert source control icons
          Source control overview
            The repository
            Workspaces and sandboxes
            File content types and line delimiters
            Read access permissions
            Streams and components
              Component baselines
              Workspace snapshots
            Change sets and change flow
              Change sets
              Change flow
              Flow targets
              Incoming change sets
              Outgoing change sets
              Change sets in a workspace
              Change flow, conflict detection, and conflict resolution
          Working in the Eclipse client
            Sharing Eclipse projects with your team
            Working independently in Rational Team Concert source control
              Adding projects to repositories
                Renaming projects in repositories
                Removing projects from repositories
                Moving projects to other components
              Working with projects under Rational Team Concert source control
                Checking in unresolved changes
                Selecting resources to exclude from Rational Team Concert source control
                Specifying file properties and line delimiter types
                  Using the File Properties wizard
                  Setting line delimiter handling
                  Changing resource properties
                Locking resources
                Choosing automatic or manual check-ins
                Viewing files in repositories
                Searching for repository objects
                Creating and managing change sets
                  Starting a new change set
                  Specifying current change sets
                  Suspending change sets
                  Completing change sets
                  Reversing change sets
                  Discarding change sets from workspaces
                  Locating change sets
                Synchronizing sandboxes
                Creating and applying Rational Team Concert source control patches
              Organizing projects into components and streams
                Creating components
                Creating streams
              Preserving and restoring component and workspace configurations
                Creating component baselines
                Taking workspace snapshots
                Replacing workspace contents with snapshots
                Creating or deleting snapshot associations
            Repository workspaces in team environments
              Creating new repository workspaces from streams
              Creating new repository workspaces
              Changing owners of repository workspaces
              Creating load rules files
              Creating duplicate workspaces
              Loading or unloading repository workspaces
              Replacing the contents of components or workspaces
              Adding and removing components
              Replacing stream contents with workspace or component contents
            Sharing changes with your team
              Submitting changes for review
              Accepting incoming change sets
              Delivering change sets
              Filtering for Rational Team Concert source control events
              Sharing symbolic links
              Setting read access permissions
            Finding and resolving conflicts
              Resolving conflicts in file content
              Resolving structural conflicts
              Merging changes that include gaps
                Gaps in change set history
                Workflow for merging gaps
                Example of merging gaps
                Merge gap examples for SCM CLI
            Exploring the history of components and files
              Viewing or editing the change history of components
              Viewing the baseline history of components
              Viewing the change history of files
              Viewing version identifiers
              Reviewing changes in change sets
              Saving change logs
              Viewing annotations
              Comparing baselines
              Locating change sets
              Viewing check-in history
              Deleting file content from the repository
              Restoring deleted files or folders
              Setting up external compare tools
            Understanding and modifying change flows
              Adding and removing workspace f