Concur Task Trees (CTT)

2. Introduction

This section is non-normative.

This document defines a metamodel, XML Schema and visualization for the ConcurTaskTrees notation, which is intended as a basis for interchange of high level user interface interface task models.

High level task models enable designers to focus on the overall flow of a user interface without becoming distracted by the details by which the user interface is presented on different platforms and modes of interaction. The following diagram illustrates the role of task models in the design cycle for user interfaces.

Figure 1: Use of task models in the design cycle

The main features of ConcurTaskTrees are:

Focus on activities, it allows designers to concentrate on the activities that users aim to perform, that are the most relevant aspects when designing interactive applications that encompass both user and system-related aspects avoiding low-level implementation details that at the design stage would only obscure the decisions to take.
Hierarchical structure, a hierarchical structure is something very intuitive, in fact often when people have to solve a problem they tend to decompose it into smaller problems still maintaining the relationships among the various parts of the solution. The hierarchical structure of this specification has two advantages: it provides a wide range of granularity allowing large and small task structures to be reused, it enables reusable task structures to be defined at both low and high semantic level.
Graphical syntax, a graphical syntax often (though not always) is easier to interpret, in this case it reflects the logical structure so it has a tree-like form.
Rich set of temporal operators, a rich set of possible temporal relationships between the tasks can be defined. This sort of aspect is usually implicit, expressed informally in the output of task analysis. Making the analyst use these operators is a substantial change to normal practice. The reason for this innovation is that after an informal task analysis we want designers to express clearly the logical temporal relationships. This is because such ordering should be taken into account in the user interface implementation to allow the user to perform at any time the tasks that should be enabled from a semantic point of view.
Task allocation, how the performance of the task is allocated is indicated by the related category and it is explicitly represented by using icons.
Objects and task attributes, once the tasks are identified it is important to indicate the objects that have to be manipulated to support their performance. Two broad types of objects can be considered: the user interface objects and the application domain objects. Multiple user interface objects can be associated to a domain objects (for example, temperature can be represented by a bar-chart of a textual value).

Here is an example of applying the CTT notation to a hotel booking task:

Figure 2: Example of inheritance of temporal constraints.

The symbols on the arcs indicate the kind of temporal operator. In the above diagram a choice is given between booking a single or double room. However, it is necessary to select the room type before making the reservation. The choice of room type is an input to the reservation task. CTT has a rich visual vocabulary for its temporal operators. The three kinds of node symbols differentiate between tasks requiring user input, tasks involving the user reading output presented by the application, and grouped tasks.

Providing support for cooperative applications is important because the increasing spread and improvement of Internet connections makes it possible to use many types of cooperative applications. Consequently, tools supporting the design of applications where multiple users can interactively cooperate are more and more required.

CTT can also be applied to multi-user applications, where users take on specific roles. A role is identified by a specific set of tasks and relationships among them. Thus, there is one task model for each role involved. In addition, there is a cooperative part whose purpose is to indicate the relationships among tasks performed by different users. The cooperative part is described in a manner similar to the single user parts: it is a hierarchical structure with indications of the temporal operators. The main difference is that it includes cooperative tasks: those tasks that imply actions by two or more users in order to be performed. For example, negotiating a price is a cooperative task because it requires actions from both a customer and a salesman. Cooperative tasks are represented by a specific icon with two persons interacting with each other.

In the cooperative part, cooperative tasks are decomposed until we reach tasks performed by a single user that are represented with the icons used in the single user parts. These single user tasks will also appear in the task model of the associated role. They are defined as connection tasks between the single-user parts and the cooperative part. In the task specification of a role, (see for example Figure 8, top part) we can identify connection tasks because they are annotated by a double arrow under their names.

3. CTT Metamodel

This section is normative.

The CTT notation is defined in terms of a hierarchical composition of temporal operators over named tasks, that relate a parent task to a non-empty set of child tasks. Tasks are associated with metadata including simple expressions over preconditions.

Figure 3: CTT metamodel as an UML diagram

Note: the icons used for node and link types are informative.

3.1 Hierarchy

Figure 4: Task hierarchy.

Tasks at same level represent different options or different tasks at the same abstraction level that have to be performed. Read levels as “In order to do T1, I need to do T2 and T3”, or “In order to do T1, I need to do T2 or T3”

3.2 Enabling

Figure 5: Task enabling.

Specifies second task cannot begin until first task performed. Example: I cannot enroll at university before I have chosen which courses to take.

3.3 Choice

Figure 6: Task choice.

Specifies two tasks enabled, then once one has started the other one is no longer enabled. Example: When accessing a web site it is possible either to browse it or to access some detailed information.

3.4 Enabling with information passing

Figure 7: Task enabling with information passing.

Specifies second task cannot be performed until first task is performed, and that information produced in first task is used as input for the second one. Example: The system generates results only after that the user specifies a query and the results will depend on the query specified.

3.5 Concurrent tasks

Figure 8: Task concurrency.

Tasks can be performed in any order, or at same time, including the possibility of starting a task before the other one has been completed. Example: In order to check the load of a set of courses, I need to consider what terms they fall in and to consider how much work each course represents

3.6 Concurrent communicating tasks

Figure 9: Task concurrent communicating tasks.

Tasks that can exchange information while performed concurrently. Example: An application where the system displays a calendar where it is highlighted the data that is entered in the meantime by the user.

3.7 Task independence

Figure 10: Task independence.

Tasks can be performed in any order, but when one starts then it has to finish before the other one can start. Example: When people install new software they can start by either registering or implementing the installation but if they start one task they have to finish it before moving to the other one.

3.8 Disabling

Figure 11: Task interruption.

The first task (usually an iterative task) is completely interrupted by the second task. Example: A user can iteratively input data in a form until the form is sent.

3.9 Suspend-Resume

Figure 12: Task suspension.

First task can be interrupted by the second one. When the second terminates then the first one can be reactivated from the state reached before Example: Editing some data and then enabling the possibility of printing them in an environment where when printing is performed then it is no possible to edit.

4. CTT XML Schema

This section is normative.

This section defines an XML schema [XSD1, XSD2] for CTT as a basis for an XML serialization of CTT models including an expression language for task preconditions:

<?xml version="1.0" encoding="iso-8859-1"?>
<xs:schema xmlns="http://giove.isti.cnr.it/ctt"
   elementFormDefault="qualified" targetNamespace="http://giove.isti.cnr.it/ctt"
   xmlns:xs="http://www.w3.org/2001/XMLSchema">
   <xs:element name="TaskModel">
      <xs:complexType>
         <xs:sequence>
            <xs:element name="Task" type="Task" />
         </xs:sequence>
         <xs:attribute name="NameTaskModelID" type="xs:string"
            use="required" />
      </xs:complexType>
   </xs:element>

   <xs:complexType name="Task">
      <xs:sequence>
         <xs:element name="Name" type="xs:string" />
         <xs:element name="Type" type="xs:string" />
         <xs:element name="Description" type="xs:string" />
         <xs:element minOccurs="0" maxOccurs="unbounded" name="Platform"
            type="xs:string" />
         <xs:element name="Precondition" type="ConditionGroup" />
         <xs:element minOccurs="0" maxOccurs="1" name="TemporalOperator"
            type="TemporalOperator" />
         <xs:element name="TimePerformance" type="TimePerformance" />
         <xs:element minOccurs="0" maxOccurs="1" name="Parent"
            type="Parent" />
         <xs:element minOccurs="0" maxOccurs="1" name="SiblingLeft"
            type="SiblingLeft" />
         <xs:element minOccurs="0" maxOccurs="1" name="SiblingRight"
            type="SiblingRight" />
         <xs:element minOccurs="0" maxOccurs="unbounded" name="Object"
            type="Object" />
         <xs:element minOccurs="0" maxOccurs="1" name="SubTask"
            type="SubTask" />
      </xs:sequence>
      <xs:attribute name="Identifier" type="xs:string" use="required" />
      <xs:attribute name="Category" use="required" type="Category" />
      <xs:attribute name="Iterative" use="required" type="xs:boolean" />
      <xs:attribute name="Optional" use="required" type="xs:boolean" />
      <xs:attribute name="PartOfCooperation" use="required"
         type="xs:boolean" />
      <xs:attribute name="Frequency" type="xs:string" use="required" />
   </xs:complexType>



   <xs:complexType name="TemporalOperator">
      <xs:attribute name="name" type="TemporalOperatorName" />
   </xs:complexType>

   <xs:complexType name="TimePerformance">
      <xs:sequence>
         <xs:element name="Max" type="xs:string" />
         <xs:element name="Min" type="xs:string" />
         <xs:element name="Average" type="xs:string" />
      </xs:sequence>
   </xs:complexType>

   <xs:complexType name="Parent">
      <xs:attribute name="name" type="xs:string" use="required" />
   </xs:complexType>

   <xs:complexType name="SiblingLeft">
      <xs:attribute name="name" type="xs:string" use="required" />
   </xs:complexType>

   <xs:complexType name="SiblingRight">
      <xs:attribute name="name" type="xs:string" use="required" />
   </xs:complexType>

   <xs:complexType name="Object">
      <xs:sequence>
         <xs:element minOccurs="0" maxOccurs="unbounded" name="Platform"
            type="xs:string" />
         <xs:element name="InputAction" type="InputAction" />
         <xs:element name="OutputAction" type="OutputAction" />
      </xs:sequence>
      <xs:attribute name="name" type="xs:string" use="required" />
      <xs:attribute name="class" use="required" type="ObjectClass" />
      <xs:attribute name="type" use="required" type="ObjectType" />
      <xs:attribute name="access_mode" use="required" type="ObjectAccess" />
      <xs:attribute name="cardinality" use="required" type="ObjectCardinality" />
   </xs:complexType>

   <xs:complexType name="InputAction">
      <xs:attribute name="Description" type="xs:string" use="required" />
      <xs:attribute name="From" type="xs:string" use="required" />
   </xs:complexType>

   <xs:complexType name="OutputAction">
      <xs:attribute name="Description" type="xs:string" use="required" />
      <xs:attribute name="To" type="xs:string" use="required" />
   </xs:complexType>

   <xs:complexType name="SubTask">
      <xs:sequence>
         <xs:element minOccurs="1" maxOccurs="unbounded" name="Task" type="Task" />
      </xs:sequence>
   </xs:complexType>


   <!-- structured precondition modeling -->

   <xs:complexType name="ConditionGroup">
      <xs:choice minOccurs="2" maxOccurs="unbounded">
         <xs:element name="ConditionGroup" type="ConditionGroup" />
         <xs:element name="ConditionLiteral" type="ConditionLiteral" />
      </xs:choice>
      <xs:attribute name="operator" type="BinaryOperator" />
   </xs:complexType>

   <xs:complexType name="ConditionLiteral">
      <xs:attribute name="object" type="xs:string" />
      <xs:attribute name="value" type="xs:string" />
   </xs:complexType>

   <!-- Simple types -->
   <xs:simpleType name="Category">
      <xs:restriction base="xs:NMTOKEN">
         <xs:enumeration value="abstraction" />
         <xs:enumeration value="user" />
         <xs:enumeration value="interaction" />
         <xs:enumeration value="application" />
         <xs:enumeration value="cooperation" />
      </xs:restriction>
   </xs:simpleType>

   <xs:simpleType name="TemporalOperatorName">
      <xs:restriction base="xs:NMTOKEN">
         <xs:enumeration value="SequentialEnabling" />
         <xs:enumeration value="Disabling" />
         <xs:enumeration value="Choice" />
         <xs:enumeration value="Interleaving" />
         <xs:enumeration value="InterleavingInfo" />
         <xs:enumeration value="Synchronization" />
         <xs:enumeration value="SuspendResume" />
         <xs:enumeration value="SequentialEnablingInfo" />
         <xs:enumeration value="OrderIndependence"/>
      </xs:restriction>
   </xs:simpleType>

   <xs:simpleType name="ObjectClass">
      <xs:restriction base="xs:NMTOKEN">
         <xs:enumeration value="Text" />
         <xs:enumeration value="Numerical" />
         <xs:enumeration value="Object" />
         <xs:enumeration value="Description" />
         <xs:enumeration value="Position" />
         <xs:enumeration value="null" />
      </xs:restriction>
   </xs:simpleType>

   <xs:simpleType name="ObjectType">
      <xs:restriction base="xs:NMTOKEN">
         <xs:enumeration value="Perceivable" />
         <xs:enumeration value="Application" />
         <xs:enumeration value="null" />
      </xs:restriction>
   </xs:simpleType>

   <xs:simpleType name="ObjectAccess">
      <xs:restriction base="xs:NMTOKEN">
         <xs:enumeration value="Access" />
         <xs:enumeration value="Modification" />
         <xs:enumeration value="null" />
      </xs:restriction>
   </xs:simpleType>

   <xs:simpleType name="ObjectCardinality">
      <xs:restriction base="xs:NMTOKEN">
         <xs:enumeration value="Low" />
         <xs:enumeration value="Medium" />
         <xs:enumeration value="High" />
         <xs:enumeration value="null" />
      </xs:restriction>
   </xs:simpleType>


   <xs:simpleType name="BinaryOperator">
      <xs:restriction base="xs:string">
         <xs:enumeration value="and" id="and" />
         <xs:enumeration value="or" id="or" />
         <xs:enumeration value="xor" id="xor" />
         <xs:enumeration value="contains" id="contains" />
         <xs:enumeration value="starts" id="starts" />
         <xs:enumeration value="ends" id="ends" />
         <xs:enumeration value="gt" id="gt" />
         <xs:enumeration value="gteq" id="gteq" />
         <xs:enumeration value="lteq" id="lteq" />
         <xs:enumeration value="lt" id="lt" />
         <xs:enumeration value="eq" id="eq" />
         <xs:enumeration value="neq" id="neq" />
      </xs:restriction>
   </xs:simpleType>

</xs:schema>

5. CTT Coop XML Schema

This section is normative.

This section defines an XML schema [XSD1, XSD2] for CTT Coop as a basis for an XML serialization of CTT models for multiple cooperating users. This involves a task model for each individual role, plus a task model describing cooperative tasks that need to be performed by multiple users.

<?xml version="1.0" encoding="iso-8859-1"?>
<xs:schema xmlns="http://giove.isti.cnr.it/cttcoop"
 elementFormDefault="qualified"
 targetNamespace="http://giove.isti.cnr.it/cttcoop"
 xmlns:xs="http://www.w3.org/2001/XMLSchema"
 xmlns:ctt="http://giove.isti.cnr.it/ctt">
   <xs:import schemaLocation="Ctt.xsd"
     namespace="http://giove.isti.cnr.it/ctt"></xs:import>
   <xs:element name="COOPConcurTaskTrees">
      <xs:complexType>
         <xs:sequence>
            <xs:element ref="TaskModelCOOP" />
            <xs:element minOccurs="1" maxOccurs="unbounded"
              ref="ctt:TaskModel" />
         </xs:sequence>
      </xs:complexType>
   </xs:element>
   <xs:element name="TaskModelCOOP">
      <xs:complexType>
         <xs:sequence>
            <xs:element ref="TaskCOOP" />
         </xs:sequence>
         <xs:attribute name="NameTaskModelID" type="xs:string" use="required" />
      </xs:complexType>
   </xs:element>
   <xs:element name="TaskCOOP">
      <xs:complexType>
         <xs:sequence>
            <xs:element name="Name" type="xs:string" />
            <xs:element name="Type" type="xs:string" />
            <xs:element name="Description" type="xs:string"/>
            <xs:element minOccurs="0" maxOccurs="unbounded"
              name="Platform" type="xs:string" />
            <xs:element minOccurs="0" maxOccurs="1"
              name="Precondition" type="ctt:ConditionGroup"/>
            <xs:element minOccurs="0" maxOccurs="1"
              name="TemporalOperator"  type="ctt:TemporalOperator"/>
            <xs:element name="TimePerformance" type="ctt:TimePerformance" />
            <xs:element ref="Cooperation" />
            <xs:element minOccurs="0" maxOccurs="unbounded"
              name="Object" type="ctt:Object" />
            <xs:element minOccurs="0" maxOccurs="1"
              name="Parent" type="ctt:Parent" />
            <xs:element minOccurs="0" maxOccurs="1"
              name="SiblingLeft" type="ctt:SiblingLeft" />
            <xs:element minOccurs="0" maxOccurs="1"
              name="SiblingRight" type="ctt:SiblingRight"/>
            <xs:element minOccurs="0" maxOccurs="1" ref="SubTaskCOOP" />
         </xs:sequence>
         <xs:attribute name="Identifier" type="xs:string" use="required" />
         <xs:attribute name="Category" type="ctt:Category"/>
         <xs:attribute name="Iterative" use="required" type="xs:boolean"/>
         <xs:attribute name="Optional" use="required" type="xs:boolean"/>
         <xs:attribute name="Frequency" type="xs:string"/>
      </xs:complexType>
   </xs:element>
   <xs:element name="Cooperation">
      <xs:complexType>
         <xs:sequence>
            <xs:element minOccurs="1" maxOccurs="unbounded" ref="Role" />
            <xs:element ref="Cardinality" />
            <xs:element ref="Comments" />
         </xs:sequence>
      </xs:complexType>
   </xs:element>
   <xs:element name="Role">
      <xs:complexType>
         <xs:attribute name="name" type="xs:string" use="required" />
      </xs:complexType>
   </xs:element>
   <xs:element name="Cardinality" type="xs:string" />
   <xs:element name="Comments" type="xs:string" />
   <xs:element name="SubTaskCOOP">
      <xs:complexType>
         <xs:choice minOccurs="1" maxOccurs="unbounded">
            <xs:element minOccurs="0" maxOccurs="unbounded" ref="TaskCOOP" />
            <xs:element minOccurs="0" maxOccurs="unbounded" ref="TaskCONN" />
         </xs:choice>
      </xs:complexType>
   </xs:element>
   <xs:element name="TaskCONN">
      <xs:complexType>
         <xs:sequence>
            <xs:element name="Name" type="xs:string" />
            <xs:element ref="Connection" />
            <xs:element name="Type" type="xs:string"/>
            <xs:element name="Description" type="xs:string"/>
            <xs:element minOccurs="0" maxOccurs="unbounded"
              name="Platform" type="xs:string" />
            <xs:element name="Precondition" type="ctt:ConditionGroup"/>
            <xs:element minOccurs="0" maxOccurs="1"
              name="TemporalOperator" type="ctt:TemporalOperator" />
            <xs:element name="TimePerformance" type="ctt:TemporalOperator"/>
            <xs:element minOccurs="0" maxOccurs="unbounded"
              name="Object" type="ctt:Object" />
            <xs:element minOccurs="0" maxOccurs="1"
              name="Parent" type="ctt:Parent" />
            <xs:element minOccurs="0" maxOccurs="1"
              name="SiblingLeft" type="ctt:SiblingLeft"/>
            <xs:element minOccurs="0" maxOccurs="1"
              name="SiblingRight" type="ctt:SiblingRight" />
         </xs:sequence>
         <xs:attribute name="Identifier" type="xs:string" use="required" />
         <xs:attribute name="Category" type="ctt:Category" />
         <xs:attribute name="Iterative" use="required" type="xs:boolean"/>
         <xs:attribute name="Optional" use="required" type="xs:boolean"/>
         <xs:attribute name="Frequency" type="xs:string" />
      </xs:complexType>
   </xs:element>
   <xs:element name="Connection">
      <xs:complexType>
         <xs:sequence>
            <xs:element ref="Belong" />
         </xs:sequence>
      </xs:complexType>
   </xs:element>
   <xs:element name="Belong">
      <xs:complexType>
         <xs:attribute name="name" type="xs:string" use="required" />
         <xs:attribute name="instance" type="xs:string" use="required" />
      </xs:complexType>
   </xs:element>
</xs:schema>

Concur Task Trees (CTT)

W3C Working Group Submission 2 February 2012

Abstract

Table of Contents

1. Conformance

2. Introduction

3. CTT Metamodel

3.1 Hierarchy

3.2 Enabling

3.3 Choice

3.4 Enabling with information passing

3.5 Concurrent tasks

3.6 Concurrent communicating tasks

3.7 Task independence

3.8 Disabling

3.9 Suspend-Resume

4. CTT XML Schema

5. CTT Coop XML Schema

A. References

A.1 Normative references

A.2 Informative references