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 help archive site
    Installing from a downloaded 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
  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 help archive site
    Installing from a downloaded 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 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 help archive site
    Installing from a downloaded 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
  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 help archive site
    Installing from a downloaded 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
  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 help archive site
    Installing from a downloaded 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
  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 help archive site
    Installing from a downloaded 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
Rational solution for Collaborative Lifecycle Management 6.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 solution for CLM
        Rational DOORS Next Generation
          Comparison of Rational DOORS and Rational DOORS Next Generation
        Rational Team Concert
        Rational Quality Manager
        Design Management
        Rational Reporting
        Overview of Global Configuration Management
        Collaborative lifecycle management
        What's new
        Learning resources
        Getting started with the Rational solution for CLM
        Getting started with configuration management
          Configuration management: concepts and capabilities
          Workflow for using configurations in CLM projects
        Rational solution for SSE
        Deployment wiki
        Security considerations for the Rational solution for CLM
        Rational products and solutions
        IBM and accessibility
        Notices for the Rational solution for CLM
      Video 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
        CLM integrations
        OSLC integrations
          Linked data
          Integration basics
          Interface features
          Postinstallation tasks
        Integrating applications on separate Jazz servers
          Establishing cross-server communication
          Approving access requests
          Linking between project areas
        Design management
        HP ALM Quality Center
        JIRA
        Rational Focal Point
        Rational Asset Manager
      Administering
        Administering projects
          Getting started with project areas and lifecycle projects
          Administering lifecycle projects
            Accessing the Lifecycle Project Administration user interface
            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 template IDs, names, and summaries
            Viewing process history
            Refreshing browser to see process changes
        Administering configurations in CLM applications
          Considerations for enabling configuration management
          Enabling configuration management in applications
          Enabling configuration management in project areas
          Setting permissions for configurations in project areas
          Viewing and managing configurations
            Creating streams and baselines
            Archiving and restoring configurations
      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
        Requirements Management (RM) application keyboard shortcuts
        Rational Team Concert keyboard shortcuts
        Rational Quality Manager keyboard shortcuts
      Glossary
        IBM Terminology website
      Using the help
        Filtering the online help
    Jazz Team Server
      Overview
        Jazz Team Server overview
        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
                  SMP/E installation process
                  Checklist for z/OS installations
                  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
                  Installation verification process (IVP)
                  Installing the configuration utility
            Examples: Installation process and topology
              Example: Installation process
              Example topology: Single-server evaluation
              Example topology: Standard single-server departmental
              Example topology: Distributed enterprise
            Techniques for changing your topology
              Reverse proxy servers in topologies
              DNS names in topologies
              Server rename in topologies
            Performance considerations
              Maximizing performance
              High availability and disaster recovery
          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
              Starting the configuration utility
              Running the configuration utility
                Generating a configuration workflow
                Modifying an existing configuration
                Working with a configuration workflow
                Selecting additional configuration options
          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
              Deploying LQE on multiple nodes
              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
          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 Kerberos single sign-on authentication
            Server configuration
              Deployment topology and installation
                Supported platforms
                Microsoft Active Directory
                IBM WebSphere Application Server
                Multiple Microsoft Active Directory domain controllers
                Proxy servers and IBM HTTP Server (IHS)
                Lightweight Directory Access Protocol (LDAP)
                Test your deployment
                Fallback authentication in WebSphere Application Server with SPNEGO
                  Configuring fall back to application authentication
                Client certificates or smart cards in WebSphere Application Server with SPNEGO
                  Configuring fall back to basic credentials when certificates and SPNEGO are enabled
                Compatibility with earlier client versions
                  Configuring a filter for WebSphere Application Server with SPNEGO
              Other installation information
                Logout and token licenses
                Configure a reverse lookup zone in the Domain Name System (DNS)
                Avoid mixed-case host names in the Windows domain
                Encryption
                  AES 256-bit encryption and the IBM JRE
                  Configuring WebSphere Application Server with SPNEGO for encryption
                  Enforcing Kerberos encryptions on Microsoft Active Directory and domain clients
                Troubleshooting SPNEGO issues on WebSphere Application Server
            Client configuration
              Jazz client configuration
              Windows domain client configuration
                Making the Kerberos session key available to the IBM JRE
                Local administrative users and the kinit utility
                Align encryption algorithms
              Linux, other UNIX systems, z/OS, and IBM i client configuration
              Browser client configuration
              Other krb5 configuration file and kinit cache file changes
                Configuring the krb5 file for encryption
                Ticket expiry
                Cross-realm authentication
                Change the default location of the kinit cache file
              Scripted authentication
                Run as a Microsoft Windows service
                Using keytab files for scripted authentication
              Debug information collection for client authentication issues
          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
              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
            Connecting to the server
          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
              Enabling Jazz Security Architecture single sign-on after upgrading
                Enabling CLM applications for Jazz Security Architecture single sign-on
              Licensing
              Planning to upgrade on 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 4 to the current version
          Interactive upgrade guide
          Upgrade script files
            jts_upgrade script
            ccm_upgrade script
            qm_upgrade script
            rm_upgrade script
            dcc_upgrade script
            rs_upgrade script
            relm_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
            Configuring a custom logout page
            Storing passwords in a clear text file
            Managing the size of the log file
            Enabling automatic archiving of auditable links for work items
            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
          Monitoring CLM servers
            CLM Server Monitoring feature
            Enabling JMX on application servers
              Enabling JMX on Apache Tomcat
                Option 1: Setting up unsecured JMX
                Option 2: Setting up JMX with client authentication without SSL
                Option 3: Setting up JMX with SSL
              Enabling JMX on WebSphere Application Server
                Connecting to JConsole by using the platform MBean server
                Connecting to JConsole by using the JSR160RMI connector
                Connecting to JConsole by using the Liberty profile connector
              Installing the CLM Server Monitoring agent
                Configuring Apache Tomcat for server monitoring
                  Setting up JConsole
                Configuring WebSphere Application Server for server monitoring
                  Connecting WebSphere Application Server to JConsole
            Running the setup wizard
            Establishing friends for the CLM Server Monitoring agent
            Configuring the WAIT reporting tool
            Creating server monitoring projects
            Creating JMX connections for WebSphere Application Server
            Creating JMX connections for Apache Tomcat
            Activating CLM Server Monitoring connections
            Modifying server monitoring thresholds
            CLM Server Monitoring data dictionary
            CLM Server Monitoring rules engine
          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
            Viewing installed patches
      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
          Disabling logging in Eclipse-based products
        Log file locations
        Messages
        Using the IBM Support Assistant Data Collector to gather diagnostic information
          Running IBM Support Assistant Data Collector
          Expanding the scope of data
          Reducing the scope of data
        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
          -createVersionIDs
          -createWarehouse
          -deleteJFSResources
          -dropTables
          -executeDiagnostics
          -export
          -exportServerRenameURLMappingHistory
          -exportUsers
          -exportVersionIDs
          -finalizeApplicationMigration
          -generateURLMappings
          -generateWarehouseDDLScripts
          -generateWarehouseUpgradeScripts
          -help
          -import
          -importURLMappings
          -importUsers
          -importVersionIDs
          -isServerRunning
          -listIssuedFloatingLicenses
          -listLicenses
          -listStorageAreaKeys
          -mergeLPAJTS
          -migrateToJsaSso
          -migration_ccm_updateConfigurationFiles
          -migration_dcc_updateConfigurationFiles
          -migration_jts_updateConfigurationFiles
          -migration_qm_updateConfigurationFiles
          -migration_rm_updateConfigurationFiles
          -migration_relm_updateConfigurationFiles
          -modifyLinkURIs
          -onlineMigrate
          -onlineMigrateEstimate
          -onlineMigrateRevert
          -onlineMigrateStop
          -patchApplyApp
          -patchApplyGlobal
          -patchRevertApp
          -patchRevertGlobal
          -prepareJsaSsoMigration
          -rebuildClosureTable
          -rebuildIndices
          -rebuildTextIndices
          -reindex
          -repairSuites
          -resetRepoLockId
          -restoreJFSIndexes
          -resumeIndexer
          -rmUpdateProjectBackLinksOnline
          -setStorageAreaKeys
          -setup
          -suspendIndexer
          -synchronizeJFSIndexes
          -syncUsers
          -upgradeWarehouse
          -verify
          -verifyJFSIndexes
          -verifyURLMappings
          -version
    Rational DOORS Next Generation
      Overview
        RM application overview
          Rational DOORS Next Generation
          Comparison of Rational DOORS and Rational DOORS Next Generation
          Configuration Management in the Requirements Management (RM) application
            Artifact recovery
        Getting started
          RM project administrators
          Creating and managing requirements
      Video 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
          Supported 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 RM as a consumer
          Associating RM projects with Rational DOORS modules
          Configuring RM as a provider
        Rational ClearQuest
        Rational Change
        Rational Focal Point
      Administering
        Administering Rational solution for Collaborative Lifecycle Management servers
        Administering requirements projects
          Administering configuration management capabilities
          Creating requirements projects
          Baselines
          Permissions
          Creating requirements project templates
          Managing requirements project templates
          Creating artifact templates
          Managing artifact templates
          Creating module templates
          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
          Inserting 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
            Import process for CSV files
            Export process for 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 diagrams
            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
        Managing artifacts by using configurations
          Selecting a configuration to work in
          Viewing configuration details
          Creating streams
          Creating baselines from streams
          Comparing configurations
          Delivering changes to other streams
          Accepting changes from other streams
          Managing changes to artifacts
            Creating change sets
            Preventing changes to change sets
            Discarding your changes
            Delivering change sets
      Reporting
        Reporting
          Creating document-style reports
          Running data warehouse reports
          Reports in the RM application
          RM reportable REST API
          Requirements management data dictionary
            RM Attribute Enumerations
            RM Attribute Values
            RM Link Types
            RM Parent-Child Links
            RM Requirement
            RM Requirement Collection / Module
            RM Requirement Collection / Module Contents
            RM Requirement Collection / Module to Test Plan Links
            RM Requirement to Request Links
            RM Requirement to Requirement Links
            RM Requirement to Test Case Links
            What's changed in the 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 artifacts in multiple tabs or windows
          Opening artifacts in new tabs in the same 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
          Creating a project template for a large project
          Support information for the RM application
    Rational Team Concert
      Overview
        Rational Team Concert
        Getting started
      Video 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 in the product
      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
          Tutorial: Understand the workbench environment
            Introduction
            Lesson 1: Work with perspectives and views
            Lesson 2: Create projects and files
            Lesson 3: Open and edit files
            Lesson 4: Customize your workbench
        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
          Get started with Quick Planner
            Introduction: Get started with Quick Planner
            Managing a project with Quick Planner
          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
        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 engines
          Creating build definitions
        Rational Change
        Rational ClearCase
          Getting started with connectors
          Rational Team Concert concepts
          Synchronizing and importing data
            Deploying Rational Team Concert
            Planning to synchronize and import
              Guidelines for Rational ClearCase users
              Element types versus MIME content types
              Selecting streams or branches to synchronize
              Exporting to VOBs and UCM components
              Imported components in synchronized streams
              ClearCase Synchronizer subcommands
              Updating the synchronizer after server rename
                Production environments
                Test-staging environments
            Preparing the synchronization environment
              Configuring a synchronization host
              Selecting an operating system account
              Creating a Jazz administrative user
              Adding the Jazz administrative user to your team
              Preparing a sub-VOB component
                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
              Running synchronizations
                Scheduling synchronization
                Running custom scripts before and after synchronization
                Resolving conflicts during synchronization
                Stopping the synchronization engine process
                Starting the synchronization engine process
                Canceling and abandoning a synchronization request
              Delivering changes in a synchronized environment
            Importing history
              Preparing to import
              Importing multiple streams
              Importing history from a UCM stream
              Importing history from base Rational ClearCase
              Verifying the imported history
              Importing additional history
            Managing the synchronization environment
              Managing streams
                Editing a synchronized stream
                Synchronization options
                Stream properties
                Unlocking a synchronized stream
                Changing the default script location
              Managing the synchronization host
                Changing the synchronization host
                Changing the dynamic view
                Upgrading the ClearCase Synchronizer
              Managing merge workspaces
                Modifying the workspace
                Creating a workspace for a synchronized stream
            Limitations and known problems
              Troubleshooting synchronization problems
              Synchronization errors
          Migrating data
            Planning to export and import
              Identifying VOBs and subfolders to migrate
              Choosing view configurations
              Selecting versions to export by filtering
                Examples of selecting versions with filters
              Disk space
              Incremental migration
              Element types versus MIME content types
            Preparing the environment
              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
              Exporting multiple configurations
              Migrating incrementally
              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
              Verifying stream and component histories
              Verifying configuration and version histories
            ClearCase Version Importer limitations and known problems
              Export problems
              Import problems
              Error messages
          ClearCase Bridge
            Version compatibility and functionality
            Connecting Rational Team Concert and UCM
              Manually associating activities with work items
              Viewing linked work items and UCM activities
              Enforcing an association
              Configuring site-wide integration
            Connecting Rational Team Concert and base Rational ClearCase
              Associating element versions with work items
              Manually associating element versions with work items
              Viewing linked work items and element versions
            Updating the bridge after server rename
              Production environments
              Test-staging environments
        Rational ClearQuest
          ClearQuest Synchronizer
            Getting started
            Prerequisites
            Configuration checklist
            Deploying the ClearQuest Synchronizer
              Connecting to multiple project areas
              Starting the ClearQuest Gateway
              Verifying the ClearQuest Gateway is running
            Setting up the ClearQuest Synchronizer
              Starting the setup wizard
              Configuring Rational ClearQuest
              Configuring Jazz Team Server
              Creating record queries
              Resetting the ClearQuest Gateway
            Configuring project areas for synchronization
              Synchronization rules
              Planning synchronization rules
                Sample planning worksheet
                Reviewing synchronization rules
              Creating synchronization rules
                Mapping records to work items
                Configuring rules for external users
                Setting categories for rules
                Creating rules for attachments
                Mapping notes to comments
                Mapping referenced fields
                Displaying record contents
                Synchronizing users
                Outgoing synchronization
              Connecting to external repositories
            Modifying service parameters
            Configuring OSLC linking
            Stopping and restarting the ClearQuest Gateway
            Enabling outgoing synchronization
            Testing the ClearQuest Synchronizer
            Tasks before and after a server rename
              Preparing the ClearQuest Synchronizer
              Test-staging environments
              Production environments
            Importing batches of records
              Importing but not synchronizing records
            Working in a synchronized environment
              Associating categories with team areas
              Viewing synchronization status
              Finding and resolving conflicts
              Showing ClearQuest Synchronizer events
              Resolving blocked synchronization
              Resolving server communication problems
              Viewing log files
              Deleting records and work items
              Archiving synchronized project areas
              Troubleshooting ClearQuest Synchronizer
            Rational ClearQuest MultiSite
              Applying the JazzInterop package
            ClearQuest Synchronizer resources
            Updating the JazzInterop package
          ClearQuest Bridge
            Getting started
            Configuring
            Working with records in the web client
              Adding ClearQuest content to dashboards
                Adding queries
                Configuring queries
                Adding charts
                Configuring charts
              Finding and reviewing records
              Updating and resolving records
            Associating work items with records
            Agile planning for records
              Managing the ClearQuest backlog
              Updating work items and records
              Prioritizing and scheduling work
              Tracking progress
              Resolving work items and records
          Migrating records to work items
            Customizing the mapping file
              Mapping attributes
              Specifying attribute types
              Mapping attribute values
              Concatenating field values
              Mapping records to work items
              Mapping state and resolution values
              Mapping relationships
              Importing FTP links
        Rational DOORS
        Rational Engineering Lifecycle Manager
        Rational Focal Point
        Git
          Installing and configuring
          Configuring server-side hooks
          Registering Git repositories
          Creating reference mappings
          Configuring Apache HTTP Server
          Configuring SSH support
          Defining permissions and preconditions
          Authorizing requests
          Associating work items with commits
          Removing associated work items
          Modifying associated work items
        Hudson/Jenkins
          Jenkins plugin
          Creating a build engine
          Creating a build definition
        IBM Connections
          Associating projects with communities
          Adding IBM Connections to dashboards
          Connecting to communities
          Sharing work items and dashboards
        IBM UrbanCode Deploy
          Creating build definitions
        Microsoft Source Code Control Interface
          Setting up repository workspaces
            Connecting to repositories and project areas
            Creating repository workspaces
            Loading repository workspaces
          Sharing changes
            Sharing changes
            Checking in change sets
            Accepting incoming change sets
            Delivering change sets
          Additional features
          Rational Rhapsody
            Configuring MSSCCI as the source control provider
            Source control operation mappings for Rational Rhapsody
            Sharing changes
            Viewing change history
            Viewing file properties
          Setting preferences
        Rational Synergy
        Subversion
          Importing repository contents
          Importing dump files
          Importing branches after you import the trunk
          Linking work items to Subversion repositories
        Rational Developer for i
          Installing and configuring the integration
          Integration overview
            Rational Team Concert
            Rational Developer for i
          Developing IBM i applications
          Sharing i Projects
        Rational Developer for Power Systems Software
          Installing and configuring the integration
          Integration overview
            Rational Team Concert
            Rational Developer for Power Systems Software
          Developing AIX applications
          Developing IBM i applications
          Sharing i Projects
        Rational Developer for System z
          Installing and configuring the integration
            File agent RSE miner
            Integrated client
            Rational Team Concert
          Integration overview
            Rational Team Concert
            Rational Developer for System z
          Adding resources to Rational Team Concert
            Differences to operations after sharing artifacts
            Managing dependencies
            Loading artifacts
            Adding artifacts to Rational Team Concert
          Working with projects locally
          Requesting user builds
            Adding error feedback support
            Built-in Jazz properties
            PARM parameter character limits
            Alternative DD names
          Enabling debug parameters
      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 IBM Bluemix DevOps Services 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 configuration source
              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
                Scrum process template
                Formal Project Management Process template
                Scaled Agile Framework (SAFe) 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 IBM Bluemix DevOps Services 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
              Managing projects with Quick Planner
              Organizing work items in a plan
                Creating plan views
                  Plan view options
                Viewing work items with the Kanban board
                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
                Creating, modifying, and moving work items in a plan
                Creating plan views
                Configuring plan views
        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
              Exporting a template
            Creating text templates
            Time tracking for work items
            Enabling linking of work items to versioned artifacts
          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
              Using the user editor commands to retrieve recent and in progress work items
              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
              Setting the default work item type
              Updating work items with new or modified attributes
              Defining an approval tracking process
              Defining a workflow
              Setting the order of work item state groups
              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 calculated values
                  Configuring a calculated time value
                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 IBM Rational Team Concert 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 item 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 in Rational Team Concert source control
          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
            Creating custom attributes
            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 a repository workspace
                Removing projects from a repository workspace
                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
                Automatically locking specific file types
                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 a sandbox with a repository workspace
                Creating and applying Rational Team Concert source control patches
              Organizing projects into components and streams
                Component sizing guidelines
                Creating components
                Renaming 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
            Automatically locking specific file types
            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
                Comparing a changed resource to the repository
              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 or components
                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
                Searching for strings in data sets and members
              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
              Viewing the status of a stream during scanning
              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
                View 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
            Running dependency builds
              Authenticating
              Creating a build definition
                z/OS build settings
                IBM i build settings
                  Creating linkage source files
              Simulating builds
                Configuring the project
                Running a build
                Viewing status and results
              Requesting builds
                Requesting dependency, personal, and preview builds
                Options for personal builds
              Building subsets
                Configuring the project
                  Configuring new build subset defaults
                Creating subsets
                Filtering subsets
              Ignoring changes
              Always load during build
              Viewing results
                Including compiler error lists in dependency build results views
                Including error lists in dependency build results views
              Build reports and 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
              snapshotPublisher
              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
          Viewing promotion status
      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 Cognos 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
          Activity
          Approval
          Approval Descriptor
          Approval State
          Approval Type
          Build Result
          Compilation Result
          Component
          Contributor
          Custom Attribute
          Iteration
          Project Area
          Project Area Member
          Project Area Role
          Project Area Role Assignments
          Task
          Team Area
          Team Area Member
          Team Area Role
          Team Area Role Assignments
          Timeline
          Timesheet
          Unit Test Event
          Unit Test Result
          Work Item
          Work Item Category
          Work Item State
          Work Item Status
          Work Item Type
          Work Item Type Mapping
          Workspace/Stream
          What's changed in the 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
          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
          merge-queue example
          Environment variables
          Synchronize streams across repositories
          Kerberos authentication
          Specifying file properties and line delimiter types for the source control command-line interface
          scm
            accept
            accept example
            add
              add component
              add component example
              add flowtarget
              add flowtarget example
              add_subcomponent
              add workitem
              add workitem example
            annotate
            annotate example
            checkin
            checkin example
            compare
            compare example
            create
              create baseline
              create baseline example
              create change set
              create changeset example
              create component
              create component example
              create loadrules
              create snapshot
              create snapshot example
              create stream
              create stream example
              create workspace
              create workspace example
            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 custom-attribute
              get custom-attribute example
              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 merge-queue example
              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
            locate example
            login
            login example
            logout
            logout example
            move
              move change
              move path
              move path example
            query
            query example
            refresh
            remove
              remove component
              remove component example
              remove flowtarget
              remove flowtarget example
              remove merge-queue
              remove property
              remove_subcomponent
              remove workitem
              remove workitem example
            repair
            repair example
            resolve
              resolve conflict
              resolve conflict example
              resolve current-merge
              resolve current-merge example
            resume
              resume changeset
              resume changeset example
              resume merge-queue
            set
              set access
              set attributes
              set attributes example
              set changeset
              set component
              set current-merge
              set custom-attribute
              set custom-attribute example
              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 custom-attributes
              show custom-attribute example
              show history
              show history example
              show lastmod
              show lastmod example
              show properties
              show status
              show status example
            suspend
            suspend changeset example
            undo
              undo change
              undo change example
              undo current-merge
            unload
            unload example
            unset
              unset custom-attribute
              unset custom-attribute example
              unset flowtarget
              unset lock
            version
            version example
          ClearCase Synchronizer subcommands
            addSyncRoots
            compare ccase
            clones
            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
        Operation preconditions and follow-up actions
        Windows preferences for the Rational Team Concert client for Eclipse IDE
    Rational Quality Manager
      Overview
        Rational Quality Manager overview
        Getting started
        Workflows and guidance
          Typical use of Rational Quality Manager
          Enterprise environment workflow
          Multi-channel testing
          Test process guidance
            Deploying process guidance
      Video tours
        Rational Quality Manager overview
      Tutorials
        Develop a test plan
          Introduction: Develop a test plan
          Lesson 1: Add support for multiple timelines and team areas
          Lesson 2: Copy a test plan
          Lesson 3: Select an iteration to create a test schedule
          Lesson 4: Add a test plan section
          Lesson 5: Define quality objectives and set entry and exit criteria
          Lesson 6: Create a risk assessment
          Lesson 7: Create a snapshot of the test plan
        Work with requirements and the formal review process
          Introduction: Work with requirements and the formal review process
          Lesson 1: Add a reviewer to the test plan
          Lesson 2: Add a new requirement to the test plan
          Lesson 3: Review and reject the test plan
          Lesson 4: Generate test cases
          Lesson 5: Discover suspect test cases
          Lesson 6: Approve the test plan
        Set up the test environment
          Introduction: Set up the test environment
          Lesson 1: Specify the test environment
          Lesson 2: Generate test case execution records
        Work with lab resources
          Introduction: Work with lab resources
          Module 1: Create lab resource data
            Lesson 1.1: Create a physical machine
            Lesson 1.2: Create a physical machine with minimal data
            Lesson 1.3: Create a virtual image
            Lesson 1.4: Display all lab resources
            Lesson 1.5: Create a lab resource test environment
            Lesson 1.6: Create a test cell for the test environment
          Module 2: Request and reserve lab resources
            Lesson 2.1: Reserve lab resources for immediate use
            Lesson 2.2: Reserve a lab resource for a specific time period
            Lesson 2.3: Request a lab resource
            Lesson 2.4: Fulfill lab resource requests
        Create and run a manual test
          Introduction: Create and run a manual test
          Lesson 1: Add a manual test script to a test case
          Lesson 2: Add test data to a manual test script
          Lesson 3: Add an execution variable to a test script
          Lesson 4: Create keywords from steps in a manual test script
          Lesson 5: Run a test and submit a defect
        Work with test suites
          Introduction: Work with test suites
          Lesson 1: Create a test suite
          Lesson 2: Add the test suite to a test plan
          Lesson 3: Add existing test cases to a test suite
          Lesson 4: Create a test suite execution record
          Lesson 5: Run the test suite execution record
          Lesson 6: Analyze the test suite execution records
        Use reports to assess test results
          Introduction: Use reports to assess test results
          Lesson 1: Run and save a report
          Lesson 2: Drill down into a report
        Additional 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
        Online migration
        Migrating Rational RequisitePro projects to the RM application
        Migrating files into Rational Quality Manager
      Integrating
        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
        Administering configurations
          Allowing a team role to accept all changes from a configuration during a merge
      Collaborating
        Managing dashboards
          Quality dashboard overview
      Reporting
        Rational Quality Manager 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
          Quality management reports in a configuration context
          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
            Artifact Categories
            Artifact Categories Type
            Automation Job
            Automation Job Result
            Build Record
            Contributor (Deprecated in RQM301)
            Defect / Work Item
            Key Word
            Lab Resource
            Lab Resource Group
            Non Manual Test Script
            Project (Deprecated in RQM301)
            Quality Objective
            Request
            Requirement
            Reservation
            Test Artifacts Workflows
            Test Artifacts Workflows State Group
            Test Artifacts Workflows State Group Category
            Test Artifacts Workflows Test Priority Category (new added in RQM 401)
            Test Case
            Test Case Execution Record
            Test Case Result
            Test Case Result's Result Details
            Test Environment
            Test Plan
            Test Schedules
            Test Script
            Test Script Step
            Test Suite
            Test Suite Execution Record
            Test Suite Result
            What's changed in the 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 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 and test suites
          Test case and test suite overview
          Developing test cases
            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
              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
            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 test scripts
          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
          Save conflicts
          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
            Duplicating execution records to another iteration
          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
          Adding a test artifact widget
          Track test artifacts and activities for auditing
          Viewing links to development, requirement, and test artifacts
        Managing test artifacts by using configurations
          Selecting a configuration to work in
          Viewing configuration details
          Creating streams
          Creating baselines from streams
          Comparing configurations
          Comparing test artifacts and merging changes
            Comparison and merging of differences in test artifacts
            Comparing quality management configurations
            Merging content from baselines to streams
          Managing test artifacts in global configurations
        Managing lab resources
          Getting started managing lab resources
          Lab management overview
          Creating and viewing lab resources
            Roles in test lab management
            Customizing lab resource properties
            Creating new test environments
            Viewing test environments
            Creating lab resource data for physical machines
            Creating virtual images
            Creating and viewing test cells
            Managed Virtual Images and Managed Virtual Machines
            Creating lab resource groups
            Viewing lab resource groups
            Searching for lab resources
            Hiding lab resources
            Updating lab resource data
            Running scripts on remote lab resources
          Channels
            Creating and managing channels
          Working with lab resource reservations and requests
            Reserving a lab resource for a specified time period
            Viewing lab resource reservations
            Creating a lab resource request
            Viewing lab resource requests
            Fulfilling requests and reserving lab resources
        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 adapters
            Enforcing reservations for lab resources
            Running an automated test with an adapter
            Running a test suite on specific machines
            Changing the adapter for a scheduled execution
          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 using local resources
            Running a test with the command-line adapter by reserving specific resources
            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
        What's new in Rational Reporting
        Deciding which reporting options to use
          Moving to the new reporting solution
          Introduction to the Data Collection Component
          Introduction to the Report Builder
          Introduction to Lifecycle Query Engine
        Reporting architecture overview
          Data warehouse
          Data collection with the Data Collection Component
          Rational Insight
        Report descriptions
        Reports and dashboards
        Reporting videos and multimedia
      Tutorials
        Jazz Reporting Service tutorials (videos)
          Create, refine, and manage reports
      Installing
        Installing the Jazz Reporting Service applications
        Installing ALM Cognos Connector
      Upgrading and migrating
        Upgrading the Jazz Reporting Service applications
        Migrating LQE
        Migrating RRDI reports to Cognos Business Intelligence using the ALM Cognos Connector
          Authenticating Cognos Business Intelligence
            Configuring Jazz user authentication on the Cognos Business Intelligence server
            Enabling Jazz Security Architecture single sign-on
          Adding the ALM Cognos reports to the Cognos Business Intelligence server
          Optional: Setting up live reporting
            Importing the XDC file
            Testing live reporting
            Configuring the data source connection
              Configuring the ODBC driver for Linux and AIX systems
          Migrating custom Cognos reports
        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
        Deploying new report resources
        Collecting data with the Data Collection Component
        Setting up and configuring Jazz Reporting Service
          Managing data sources for Jazz Reporting Service
          Configuring security certificates for Jazz Reporting Service servers
          Activating ready-to-use reports
          Assigning report managers
        Administering Lifecycle Query Engine
          Configuring LQE by using properties files
          Lifecycle Query Engine licenses
          Specifying access permissions for Jazz Reporting Service
          Managing user access to data sources
            Specifying access permissions for Jazz Reporting Service
          Managing data sources for LQE
          Monitoring and managing performance
            Monitoring performance
            Improving query responsiveness
            Managing the nodes
            Improving performance
            Compacting indexed data
            Analyzing LQE server statistics
            Setting up notifications
          Managing vocabularies
          Backing up and restoring Lifecycle Query Engine
          Running queries to test or debug
          Completing the server rename for LQE
          Enabling Lifecycle Query Engine for single sign-on
        Administering Cognos reports
          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
        Viewing and canceling running reports
        Extending the date range for reports
      Reporting
        Measuring and tracking projects with Rational Reporting
          Running and viewing document-style reports
          Running and viewing development intelligence reports
          Printing and exporting development intelligence report output
          Creating and saving reusable reports
          Viewing development intelligence reports in dashboards
            Using report views in custom reports
            Viewing non-optimized custom reports in a dashboard
            Making Cognos reports available to viewers
          Managing available reports in the CLM applications
            Organizing reports
            Updating BIRT or RRDG report resources in the project area
          Reporting across projects
            Reporting on data in configurations
            Exporting reports to spreadsheets
          Viewing Jazz Reporting Service reports in dashboards
            Importing certificates and configuring browsers for Jazz Reporting Service reports
            Adding Jazz Reporting Service reports to dashboards
            Refining Jazz Reporting Service ready-to-use reports in dashboards
        Authoring and maintaining reports and dashboards
          Authoring development intelligence reports
            Starting the Cognos authoring and report management tools
          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 Jazz Reporting Service
          Jazz Reporting Service log files
        Troubleshooting Lifecycle Query Engine
          Lifecycle Query Engine log files
          Preventing Out-of-memory errors
          Lifecycle Query Engine error messages
      Reference
        Report descriptions
        Ready-to-use reports
        Reporting data dictionaries
        Application reportable REST APIs
    Global Configuration Management
      Overview
        Overview of Global Configuration Management
        Getting started
          Getting started for application administrators
          Getting started by user role
        Tips on the screen
      Video tours
        Global Configuration Management overview
      Installing
        Installing the GCM application
      Upgrading and migrating
        Upgrading the GCM application
      Administering
        Administering Rational solution for Collaborative Lifecycle Management servers
        Administering global configuration project areas
          Project areas for Global Configuration Management
          Role-based permissions for Global Configuration Management
          Creating global configuration project templates
          Managing global configuration project templates
      Collaborating
        Dashboards in the GCM application
      Managing global configurations
        Joining a global configuration project
          Logging into Global Configuration Management
          Personal dashboard
        Workflow for global configurations
        Creating the global configuration hierarchy
          Creating a component to establish a work context
          Adding configurations to a stream
          Managing configurations
          Creating a baseline to save a milestone
          Comparing configurations
          Checking for multiple configurations of a component (component skew)
            Configuration order in global configuration hierarchies
          Finding where a stream or baseline is used in configurations
        Working with configurations in CLM applications
          Viewing configurations in a tree view
          Using GCM to open configurations in CLM applications
          Creating a variant by branching
          Adding insulated changes to a personal stream
      Troubleshooting and support
        Troubleshooting the GCM application
          Log file locations for Global Configuration Management
          Support information for the GCM application
    Rational Engineering Lifecycle Manager
      Overview
        Overview of Rational Engineering Lifecycle Manager
        What's new in this release
        Getting started with Rational Engineering Lifecycle Manager
        On-screen tips and help
      Tutorials
        Using views (title tbd)
      Installing
        Installing Rational Engineering Lifecycle Manager
      Upgrading and migrating
        Upgrading Rational Engineering Lifecycle Manager
        Migrating queries to version 6.0
      Integrating
        Integrating Rational Engineering Lifecycle Manager with DOORS
      Administering
        Managing the Rational Engineering Lifecycle Manager application
        Managing Rational Engineering Lifecycle Manager users
        Managing Rational Engineering Lifecycle Manager project areas
          Role-based permissions for Rational Engineering Lifecycle Manager
        Managing project content
        Export views and artifact elements
        Setting up a report template
      Managing lifecycle data
        Map of user needs to features
        Terminology and concepts
        Technical overview
        Designing queries and views
          How queries and views work together
            Jazz Reporting Service ready-to-use reports
            Rational Engineering Lifecycle Manager ready-to-use views
          Using views
          Creating a view
          Adding and setting up a view in a Jazz project dashboard
          Creating folders to organize queries, views, and reports
        Analyzing the impact of change
          Impact analysis workflow
          Creating impact analysis profiles
          Creating and modifying impact analysis diagrams
          Full traceability
          Impact analysis types
          Creating impact analysis filters
          Analyzing an artifact's relationships to other artifacts
          Understanding how analysis determines artifacts to display
        Authoring reports
          Customizing reports
          Creating and running reports from views
          Running and printing a report to show the status of artifacts
          Sharing reports
      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
          Disabling logging in Eclipse-based products
        Troubleshoot Rational Engineering Lifecycle Manager
          Rational Engineering Lifecycle Manager log files
          Moving report resources (templates) to the Report Resources page
          Downloading and deploying the ISO-26262 sample view from jazz.net
          Administration and configuration problems
  ++ 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 solution for CLM
        Rational DOORS Next Generation
          Comparison of Rational DOORS and Rational DOORS Next Generation
        Rational Team Concert
        Rational Quality Manager
        Design Management
        Rational Reporting
        Overview of Global Configuration Management
        Collaborative lifecycle management
        What's new
        Learning resources
        Getting started with the Rational solution for CLM
        Getting started with configuration management
          Configuration management: concepts and capabilities
          Workflow for using configurations in CLM projects
        Rational solution for SSE
        Deployment wiki
        Security considerations for the Rational solution for CLM
        Rational products and solutions
        IBM and accessibility
        Notices for the Rational solution for CLM
      Video 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
        CLM integrations
        OSLC integrations
          Linked data
          Integration basics
          Interface features
          Postinstallation tasks
        Integrating applications on separate Jazz servers
          Establishing cross-server communication
          Approving access requests
          Linking between project areas
        Design management
        HP ALM Quality Center
        JIRA
        Rational Focal Point
        Rational Asset Manager
      Administering
        Administering projects
          Getting started with project areas and lifecycle projects
          Administering lifecycle projects
            Accessing the Lifecycle Project Administration user interface
            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 template IDs, names, and summaries
            Viewing process history
            Refreshing browser to see process changes
        Administering configurations in CLM applications
          Considerations for enabling configuration management
          Enabling configuration management in applications
          Enabling configuration management in project areas
          Setting permissions for configurations in project areas
          Viewing and managing configurations
            Creating streams and baselines
            Archiving and restoring configurations
      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
        Requirements Management (RM) application keyboard shortcuts
        Rational Team Concert keyboard shortcuts
        Rational Quality Manager keyboard shortcuts
      Glossary
        IBM Terminology website
      Using the help
        Filtering the online help
    Jazz Team Server
      Overview
        Jazz Team Server overview
        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
                  SMP/E installation process
                  Checklist for z/OS installations
                  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
                  Installation verification process (IVP)
                  Installing the configuration utility
            Examples: Installation process and topology
              Example: Installation process
              Example topology: Single-server evaluation
              Example topology: Standard single-server departmental
              Example topology: Distributed enterprise
            Techniques for changing your topology
              Reverse proxy servers in topologies
              DNS names in topologies
              Server rename in topologies
            Performance considerations
              Maximizing performance
              High availability and disaster recovery
          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
              Starting the configuration utility
              Running the configuration utility
                Generating a configuration workflow
                Modifying an existing configuration
                Working with a configuration workflow
                Selecting additional configuration options
          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
              Deploying LQE on multiple nodes
              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
          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 Kerberos single sign-on authentication
            Server configuration
              Deployment topology and installation
                Supported platforms
                Microsoft Active Directory
                IBM WebSphere Application Server
                Multiple Microsoft Active Directory domain controllers
                Proxy servers and IBM HTTP Server (IHS)
                Lightweight Directory Access Protocol (LDAP)
                Test your deployment
                Fallback authentication in WebSphere Application Server with SPNEGO
                  Configuring fall back to application authentication
                Client certificates or smart cards in WebSphere Application Server with SPNEGO
                  Configuring fall back to basic credentials when certificates and SPNEGO are enabled
                Compatibility with earlier client versions
                  Configuring a filter for WebSphere Application Server with SPNEGO
              Other installation information
                Logout and token licenses
                Configure a reverse lookup zone in the Domain Name System (DNS)
                Avoid mixed-case host names in the Windows domain
                Encryption
                  AES 256-bit encryption and the IBM JRE
                  Configuring WebSphere Application Server with SPNEGO for encryption
                  Enforcing Kerberos encryptions on Microsoft Active Directory and domain clients
                Troubleshooting SPNEGO issues on WebSphere Application Server
            Client configuration
              Jazz client configuration
              Windows domain client configuration
                Making the Kerberos session key available to the IBM JRE
                Local administrative users and the kinit utility
                Align encryption algorithms
              Linux, other UNIX systems, z/OS, and IBM i client configuration
              Browser client configuration
              Other krb5 configuration file and kinit cache file changes
                Configuring the krb5 file for encryption
                Ticket expiry
                Cross-realm authentication
                Change the default location of the kinit cache file
              Scripted authentication
                Run as a Microsoft Windows service
                Using keytab files for scripted authentication
              Debug information collection for client authentication issues
          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
              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
            Connecting to the server
          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
              Enabling Jazz Security Architecture single sign-on after upgrading
                Enabling CLM applications for Jazz Security Architecture single sign-on
              Licensing
              Planning to upgrade on 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 4 to the current version
          Interactive upgrade guide
          Upgrade script files
            jts_upgrade script
            ccm_upgrade script
            qm_upgrade script
            rm_upgrade script
            dcc_upgrade script
            rs_upgrade script
            relm_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
            Configuring a custom logout page
            Storing passwords in a clear text file
            Managing the size of the log file
            Enabling automatic archiving of auditable links for work items
            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
          Monitoring CLM servers
            CLM Server Monitoring feature
            Enabling JMX on application servers
              Enabling JMX on Apache Tomcat
                Option 1: Setting up unsecured JMX
                Option 2: Setting up JMX with client authentication without SSL
                Option 3: Setting up JMX with SSL
              Enabling JMX on WebSphere Application Server
                Connecting to JConsole by using the platform MBean server
                Connecting to JConsole by using the JSR160RMI connector
                Connecting to JConsole by using the Liberty profile connector
              Installing the CLM Server Monitoring agent
                Configuring Apache Tomcat for server monitoring
                  Setting up JConsole
                Configuring WebSphere Application Server for server monitoring
                  Connecting WebSphere Application Server to JConsole
            Running the setup wizard
            Establishing friends for the CLM Server Monitoring agent
            Configuring the WAIT reporting tool
            Creating server monitoring projects
            Creating JMX connections for WebSphere Application Server
            Creating JMX connections for Apache Tomcat
            Activating CLM Server Monitoring connections
            Modifying server monitoring thresholds
            CLM Server Monitoring data dictionary
            CLM Server Monitoring rules engine
          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
            Viewing installed patches
      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
          Disabling logging in Eclipse-based products
        Log file locations
        Messages
        Using the IBM Support Assistant Data Collector to gather diagnostic information
          Running IBM Support Assistant Data Collector
          Expanding the scope of data
          Reducing the scope of data
        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
          -createVersionIDs
          -createWarehouse
          -deleteJFSResources
          -dropTables
          -executeDiagnostics
          -export
          -exportServerRenameURLMappingHistory
          -exportUsers
          -exportVersionIDs
          -finalizeApplicationMigration
          -generateURLMappings
          -generateWarehouseDDLScripts
          -generateWarehouseUpgradeScripts
          -help
          -import
          -importURLMappings
          -importUsers
          -importVersionIDs
          -isServerRunning
          -listIssuedFloatingLicenses
          -listLicenses
          -listStorageAreaKeys
          -mergeLPAJTS
          -migrateToJsaSso
          -migration_ccm_updateConfigurationFiles
          -migration_dcc_updateConfigurationFiles
          -migration_jts_updateConfigurationFiles
          -migration_qm_updateConfigurationFiles
          -migration_rm_updateConfigurationFiles
          -migration_relm_updateConfigurationFiles
          -modifyLinkURIs
          -onlineMigrate
          -onlineMigrateEstimate
          -onlineMigrateRevert
          -onlineMigrateStop
          -patchApplyApp
          -patchApplyGlobal
          -patchRevertApp
          -patchRevertGlobal
          -prepareJsaSsoMigration
          -rebuildClosureTable
          -rebuildIndices
          -rebuildTextIndices
          -reindex
          -repairSuites
          -resetRepoLockId
          -restoreJFSIndexes
          -resumeIndexer
          -rmUpdateProjectBackLinksOnline
          -setStorageAreaKeys
          -setup
          -suspendIndexer
          -synchronizeJFSIndexes
          -syncUsers
          -upgradeWarehouse
          -verify
          -verifyJFSIndexes
          -verifyURLMappings
          -version
    Rational DOORS Next Generation
      Overview
        RM application overview
          Rational DOORS Next Generation
          Comparison of Rational DOORS and Rational DOORS Next Generation
          Configuration Management in the Requirements Management (RM) application
            Artifact recovery
        Getting started
          RM project administrators
          Creating and managing requirements
      Video 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
          Supported 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 RM as a consumer
          Associating RM projects with Rational DOORS modules
          Configuring RM as a provider
        Rational ClearQuest
        Rational Change
        Rational Focal Point
      Administering
        Administering Rational solution for Collaborative Lifecycle Management servers
        Administering requirements projects
          Administering configuration management capabilities
          Creating requirements projects
          Baselines
          Permissions
          Creating requirements project templates
          Managing requirements project templates
          Creating artifact templates
          Managing artifact templates
          Creating module templates
          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
          Inserting 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
            Import process for CSV files
            Export process for 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 diagrams
            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
        Managing artifacts by using configurations
          Selecting a configuration to work in
          Viewing configuration details
          Creating streams
          Creating baselines from streams
          Comparing configurations
          Delivering changes to other streams
          Accepting changes from other streams
          Managing changes to artifacts
            Creating change sets
            Preventing changes to change sets
            Discarding your changes
            Delivering change sets
      Reporting
        Reporting
          Creating document-style reports
          Running data warehouse reports
          Reports in the RM application
          RM reportable REST API
          Requirements management data dictionary
            RM Attribute Enumerations
            RM Attribute Values
            RM Link Types
            RM Parent-Child Links
            RM Requirement
            RM Requirement Collection / Module
            RM Requirement Collection / Module Contents
            RM Requirement Collection / Module to Test Plan Links
            RM Requirement to Request Links
            RM Requirement to Requirement Links
            RM Requirement to Test Case Links
            What's changed in the 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 artifacts in multiple tabs or windows
          Opening artifacts in new tabs in the same 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
          Creating a project template for a large project
          Support information for the RM application
    Rational Team Concert
      Overview
        Rational Team Concert
        Getting started
      Video 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 in the product
      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
          Tutorial: Understand the workbench environment
            Introduction
            Lesson 1: Work with perspectives and views
            Lesson 2: Create projects and files
            Lesson 3: Open and edit files
            Lesson 4: Customize your workbench
        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
          Get started with Quick Planner
            Introduction: Get started with Quick Planner
            Managing a project with Quick Planner
          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
        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 engines
          Creating build definitions
        Rational Change
        Rational ClearCase
          Getting started with connectors
          Rational Team Concert concepts
          Synchronizing and importing data
            Deploying Rational Team Concert
            Planning to synchronize and import
              Guidelines for Rational ClearCase users
              Element types versus MIME content types
              Selecting streams or branches to synchronize
              Exporting to VOBs and UCM components
              Imported components in synchronized streams
              ClearCase Synchronizer subcommands
              Updating the synchronizer after server rename
                Production environments
                Test-staging environments
            Preparing the synchronization environment
              Configuring a synchronization host
              Selecting an operating system account
              Creating a Jazz administrative user
              Adding the Jazz administrative user to your team
              Preparing a sub-VOB component
                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
              Running synchronizations
                Scheduling synchronization
                Running custom scripts before and after synchronization
                Resolving conflicts during synchronization
                Stopping the synchronization engine process
                Starting the synchronization engine process
                Canceling and abandoning a synchronization request
              Delivering changes in a synchronized environment
            Importing history
              Preparing to import
              Importing multiple streams
              Importing history from a UCM stream
              Importing history from base Rational ClearCase
              Verifying the imported history
              Importing additional history
            Managing the synchronization environment
              Managing streams
                Editing a synchronized stream
                Synchronization options
                Stream properties
                Unlocking a synchronized stream
                Changing the default script location
              Managing the synchronization host
                Changing the synchronization host
                Changing the dynamic view
                Upgrading the ClearCase Synchronizer
              Managing merge workspaces
                Modifying the workspace
                Creating a workspace for a synchronized stream
            Limitations and known problems
              Troubleshooting synchronization problems
              Synchronization errors
          Migrating data
            Planning to export and import
              Identifying VOBs and subfolders to migrate
              Choosing view configurations
              Selecting versions to export by filtering
                Examples of selecting versions with filters
              Disk space
              Incremental migration
              Element types versus MIME content types
            Preparing the environment
              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
              Exporting multiple configurations
              Migrating incrementally
              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
              Verifying stream and component histories
              Verifying configuration and version histories
            ClearCase Version Importer limitations and known problems
              Export problems
              Import problems
              Error messages
          ClearCase Bridge
            Version compatibility and functionality
            Connecting Rational Team Concert and UCM
              Manually associating activities with work items
              Viewing linked work items and UCM activities
              Enforcing an association
              Configuring site-wide integration
            Connecting Rational Team Concert and base Rational ClearCase
              Associating element versions with work items
              Manually associating element versions with work items
              Viewing linked work items and element versions
            Updating the bridge after server rename
              Production environments
              Test-staging environments
        Rational ClearQuest
          ClearQuest Synchronizer
            Getting started
            Prerequisites
            Configuration checklist
            Deploying the ClearQuest Synchronizer
              Connecting to multiple project areas
              Starting the ClearQuest Gateway
              Verifying the ClearQuest Gateway is running
            Setting up the ClearQuest Synchronizer
              Starting the setup wizard
              Configuring Rational ClearQuest
              Configuring Jazz Team Server
              Creating record queries
              Resetting the ClearQuest Gateway
            Configuring project areas for synchronization
              Synchronization rules
              Planning synchronization rules
                Sample planning worksheet
                Reviewing synchronization rules
              Creating synchronization rules
                Mapping records to work items
                Configuring rules for external users
                Setting categories for rules
                Creating rules for attachments
                Mapping notes to comments
                Mapping referenced fields
                Displaying record contents
                Synchronizing users
                Outgoing synchronization
              Connecting to external repositories
            Modifying service parameters
            Configuring OSLC linking
            Stopping and restarting the ClearQuest Gateway
            Enabling outgoing synchronization
            Testing the ClearQuest Synchronizer
            Tasks before and after a server rename
              Preparing the ClearQuest Synchronizer
              Test-staging environments
              Production environments
            Importing batches of records
              Importing but not synchronizing records
            Working in a synchronized environment
              Associating categories with team areas
              Viewing synchronization status
              Finding and resolving conflicts
              Showing ClearQuest Synchronizer events
              Resolving blocked synchronization
              Resolving server communication problems
              Viewing log files
              Deleting records and work items
              Archiving synchronized project areas
              Troubleshooting ClearQuest Synchronizer
            Rational ClearQuest MultiSite
              Applying the JazzInterop package
            ClearQuest Synchronizer resources
            Updating the JazzInterop package
          ClearQuest Bridge
            Getting started
            Configuring
            Working with records in the web client
              Adding ClearQuest content to dashboards
                Adding queries
                Configuring queries
                Adding charts
                Configuring charts
              Finding and reviewing records
              Updating and resolving records
            Associating work items with records
            Agile planning for records
              Managing the ClearQuest backlog
              Updating work items and records
              Prioritizing and scheduling work
              Tracking progress
              Resolving work items and records
          Migrating records to work items
            Customizing the mapping file
              Mapping attributes
              Specifying attribute types
              Mapping attribute values
              Concatenating field values
              Mapping records to work items
              Mapping state and resolution values
              Mapping relationships
              Importing FTP links
        Rational DOORS
        Rational Engineering Lifecycle Manager
        Rational Focal Point
        Git
          Installing and configuring
          Configuring server-side hooks
          Registering Git repositories
          Creating reference mappings
          Configuring Apache HTTP Server
          Configuring SSH support
          Defining permissions and preconditions
          Authorizing requests
          Associating work items with commits
          Removing associated work items
          Modifying associated work items
        Hudson/Jenkins
          Jenkins plugin
          Creating a build engine
          Creating a build definition
        IBM Connections
          Associating projects with communities
          Adding IBM Connections to dashboards
          Connecting to communities
          Sharing work items and dashboards
        IBM UrbanCode Deploy
          Creating build definitions
        Microsoft Source Code Control Interface
          Setting up repository workspaces
            Connecting to repositories and project areas
            Creating repository workspaces
            Loading repository workspaces
          Sharing changes
            Sharing changes
            Checking in change sets
            Accepting incoming change sets
            Delivering change sets
          Additional features
          Rational Rhapsody
            Configuring MSSCCI as the source control provider
            Source control operation mappings for Rational Rhapsody
            Sharing changes
            Viewing change history
            Viewing file properties
          Setting preferences
        Rational Synergy
        Subversion
          Importing repository contents
          Importing dump files
          Importing branches after you import the trunk
          Linking work items to Subversion repositories
        Rational Developer for i
          Installing and configuring the integration
          Integration overview
            Rational Team Concert
            Rational Developer for i
          Developing IBM i applications
          Sharing i Projects
        Rational Developer for Power Systems Software
          Installing and configuring the integration
          Integration overview
            Rational Team Concert
            Rational Developer for Power Systems Software
          Developing AIX applications
          Developing IBM i applications
          Sharing i Projects
        Rational Developer for System z
          Installing and configuring the integration
            File agent RSE miner
            Integrated client
            Rational Team Concert
          Integration overview
            Rational Team Concert
            Rational Developer for System z
          Adding resources to Rational Team Concert
            Differences to operations after sharing artifacts
            Managing dependencies
            Loading artifacts
            Adding artifacts to Rational Team Concert
          Working with projects locally
          Requesting user builds
            Adding error feedback support
            Built-in Jazz properties
            PARM parameter character limits
            Alternative DD names
          Enabling debug parameters
      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 IBM Bluemix DevOps Services 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 configuration source
              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
                Scrum process template
                Formal Project Management Process template
                Scaled Agile Framework (SAFe) 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 IBM Bluemix DevOps Services 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