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