Software development can be considered as a specific type of knowledge work [11]. Characteristics like weakly-structured processes, high degree of personal decision involvement and only partial knowledge of the outcome are valid. These aspects complicate adequate support of development processes. In this paper we introduce a concept to support task-centric social software engineering in a team, using the concept of Task Patterns [9]. Task Patterns collect information artefacts created and used by developers when executing software development tasks of similar kind. These artefacts are organized with respect to their meaning for the described task class. With our approach we extend tools like Tasktop Pro for Eclipse [12] which support users in executing their tasks by functionalities for Task Pattern creation and enhancement for experience sharing. This is done by a structured re-use of the information collected by these tools for Task Patterns shared within a community.
This paper is structured as follows. First, we introduce our view on social software engineering and the possible fields of application for social information retrieval in software engineering projects. Second, task-centric software development and the Task Pattern concept are presented as foundation for the idea of using task-centric software engineering to support experience transfer. Third, Task Patterns for software engineering are presented as means for transferring personal experience in a collaborative development environment.
In this section we introduce the concept of social software engineering and show how social information retrieval (SIR) can be applied in software engineering projects.
Software engineering -especially in Open Source -is carried out in (large) teams. The times when developers worked alone on their code seem definitely to be over. Surely this is not a trend of the recent years, as Gerald M. Weinberg stated in 1971 that software engineering is a social user-centered activity where communication plays a key function [15] and that is supported by computers. Computer supported cooperative work (CSCW) is an interdisciplinary field of research focussing on the connection of collaborative work and technical support for it. As Ellis et al. define it CSCW looks at how groups work and seeks to discover how technology (especially computers) can help them work [3, p. 39]. So CSCW is part of the research conducted in the area of Computer Mediated Communication (CMC). CMC researches how people and groups communicate using web technologies and services like e-mail, blogs or bulletin boards. Restricting this collaborative work in groups to the domain of software engineering leads to the research area of collaborative (or social) software engineering. Regional and temporal distribution of software development teams require specific techniques for communication and coordination, especially with respect to the domain of knowledge sharing. Collaborative development environments (CDEs) are providing optimal support for coordinating activities and communication in the software engineering process conducted in teams [1].
Social Information Retrieval (SIR) deals with obtaining information by utilizing social processes. Information can be externalized artefacts as well as personal expertise, so SIR can allow the retrieval of stored data or domain experts. There are different techniques and methods for SIR [14]; techniques include collaborative filtering, subjective relevance judgements and social bookmarking. Methods for SIR comprise recommender systems, social navigation and social search. A mix of the methods and techniques yield an added value for the users of services. In software engineering projects the SIR needs structures to retrieve abstract information like documents and API desciptions as well as more concrete information like source code or best practise examples which fit the engineering requirements and guidelines of the specific team. A CDE can offer a social bookmarking approach allowing developers to bookmark important project-related documents and include these information in the ranking of search results. [6] show how methods and techniques of SIR can be successfully applied in the context of software requirements engineering.
With Task Pattern for software enginnering projects we propose a new type of SIR technique: building patterns from task execution. We will store and analyse tasks of developers, abstract from their specific context and create a Task Pattern from multiple task executions. This Task Pattern will be stored in a central Task Pattern Repository and can be accessed by every developer.
Tasks have proven as effective and efficient means to structure knowledge work.
A recent approach is task-centric software development, indicated by e.g. one million downloads of the task-centric development support tool MyLyn [12]. Still, task concepts in knowledge work and also software development are mainly utilized as mechanism to support a user in executing his tasks by organizing information objects. The Task Pattern concept has been proposed to re-use task execution knowledge to share experience and support the retrieval of structured information in a community.
Task-centric Software Development is the organization of programming activities based on tasks using e.g. a task management system. One respective application is MyLyn [5], an extension for the Eclipse IDE which observes the lines of code a user works on for a specific task. MyLyn is based on the following assumption:
The longer a user works on a specific element of the code in a task context, the higher is its relevance for the task. Empirical studies [13] prove that this assumption holds. Thus the software code can be organized in terms of tasks. If a developer interrupts a coding task and has to come back to it later, MyLyn filters the code resources based on the earlier observed relevant lines of code thus increasing the speed of resource access. MyLyn allows to share the relevant code parts for tasks in a given project in a community. This allows a community to understand certain lines of code as product of a coding task. This is a good first step, but lacks additional information. The process which lead to the product needs to be transferred additionally to provide more understanding, following Floyds process-product complementary view on software development [4]. Code examples might be worthless for a novice who can not access information describing involved technologies and frameworks. This information most probably has been used during the process of coding. This implicitly has been taken up by the developers of MyLyn, as they recently introduced Tasktop. Tasktop extends MyLyn beyond the observation of code relevant for a task: it observes the interaction with different kinds of information objects like e-mails, documents and web-resources as well. The data collected by MyLyn and Tasktop seems to be a valuable basis for task support beyond the individual organization. Both is integrated in Tasktop Pro for Eclipse. A structure to organize the data respectively can be Task Patterns which are introduced in the following.
Task Patterns are a structure to support individual task execution and to realize tool-supported experience sharing in knowledge work. They hint to working activities and information objects necessary to execute a specific class of tasks. For a user Task Patterns recommend work activities based on Abstraction Services. These Services support users in identifying subtasks, information objects or persons to collaborate with for a specific purpose in a given task class. They are capable to describe aspects of a task on different abstraction levels as described in [10].
Task Patterns are not centrally organized but originate from abstractions of different degrees on user task executions. These executions are explicit in task-centric information system [2] which can be extended by Task Pattern functionality. As such an interplay between a user task and the respective Task Pattern realizes an enhancement life-cycle [7]: by connecting task and Task Pattern and enriching the task by the abstracted pattern data each pattern re-use in the community enhances the pattern, as described in [10]. As such the Task Pattern is a structure for a knowledge worker to learn how to execute a task, meanwhile the structure is implicitly enriched by the knowledge worker himself. The resulting pattern is a community effort as it structures knowledge from real task executions in the community in a re-usable way. In the following we explain the concept of Task Patterns with Abstraction Services to support software engineering activities.
Software development tasks in general result in the creation of program code as product of the tasks. To create the respective program code developers often need to look up different information or learn specific techniques by using different information objects like API descriptions, wikis, development handbooks etc.
As described, task-centric software development uses tools like Tasktop Pro to automatically structure code and resources by means of tasks. We re-use this information for Task Patterns which mesh up the different types of information: code examples which stand for the product and abstract descriptions which help to understand the process which lead to the product. Currently these information types are not centrally organized, as code is spread across the development project source files and other resources need to be accessed via folder structure for files and bookmarks for web-resources. This leads to tedious informationretrieval activities by the developer and a retrieval process which often uses external data-sources like e.g. google code or development forums.
Next to Abstraction Services for information objects like documents, bookmarks or persons which help to structure documents or serve as expert finder, a The following example shows the application of Task Pattern. We assume that there is a community-embedded collaborative development environment (CCDE) that supports informal communication amongst developers and serves as project management tool for multiple different projects at the same time (cf. [8]). Furthermore we assume that the CCDE hosts multiple projects that connect with the social photo sharing site Flickr (http://www.flickr.com). So various developers from different projects try to upload photos to and display photos from Flickr using different programming languages. All developers are structuring their daily work using Tasktop and make use of the possibility to create, enhance and use patterns in the context of their local tasks. This already has resulted in a pattern on accessing and displaying Flickr photos. The pattern includes software code from 5 different tasks of this kind, realizing photo display in different user interfaces. An additional excerpt from the Flickr API and a "how-to" document are attached as well as a short e-mail discussion on caching of photo sets to increase the accessibility.
A developer wants to display Flickr photos. He queries the Task Pattern repository and identifies the described pattern based on its name. He attaches this pattern to his new task. Using Abstraction Services, the developer accesses the code examples but has problems in understanding specific parts of the implemented code. He refers to the attached documents which enable him to understand and re-use parts of the given code. Additionally he asks a colleague on a specific visualization technique including filters and receives a document on this. The document gets included in his tasktop system, as all his activities are tracked by the system. Due to the connection between task and Task Pattern the developer easily can attach the additional information to the pattern. The Code created by him gets automatically attached to the Code Abstraction Service.
As a realization we propose the extension of Tasktop Pro for Eclipse by interaction functionalities with Task Patterns and Abstraction Services as visible in the mockup fig. 2. A Task Pattern gives access to the Abstraction Services which provide access to documents, web resources, e-mails and example code (1). The example code can be used by an additional code view to browse the program code collected by the Abstraction Service during all different execution processes (2). The task list has to be extended by a mechanism to attach Task Pattern to tasks and the task list must show the attached Pattern with Abstraction Services to the activated tasks. This application is currently under development at the University of Paderborn.
Task Patterns in Software Engineering have been introduced as structure which re-uses task information to realize experience sharing. Thereby Task Pattern The re-use of the Task Pattern concept shows its applicability to different, more specialized domains of knowledge work. The domain of software engineering shows a specific benefit: one can assume that the product of most tasks is code. This allows the easy identification of information resources which represent the process of problem understanding and solving including the resulting code as product. Thus, one can provide a combination of resources to support the process of problem based learning and the examples of working products. The re-use of a tool like Tasktop Pro especially allows the extensive automation of the involved Task Pattern life-cycle [10]. Task Patterns for software engineering focus on support of the individual solution of discrete, individual programming tasks. With embedding Task Patterns for software engineering in a CCDE developers can make use of social processes of recommendation and tagging and thus share experience on similar, re-occurring tasks in a structured form which integrates support for the understanding of the development process as well as for the generated product.
The presented integration of the Task Pattern approach for social software engineering is currently under development at the University of Paderborn within
the scope of a master's thesis. The results will be evaluated and used to enhance the social experience within software engineering projects and help users to find help from others.