We describe an observational investigation that explores whether creating open social student models using software metrics promotes reflection. Metric visualisations were shown to six groups in an undergraduate software engineering project course. Seeing their own visualisations prompted reflection on their codebase at a conceptual level as expected; this is as predicted by previous research. When viewing other’s visualisations, the focus changed to comparative statements with reasoning to explain differences showing that this increased performance orientation. Delayed queries showed that engagement was varied but increased in all groups.

Open Student Models (OSM) are beneficial for improving students' domain knowledge and meta-cognitive skills. The way in which the student model is displayed may be an important factor which has not been investigated adequately in the context of Intelligent Tutoring Systems (ITS). In our study, the control group had skill meters, while the experimental group additionally could access the OSM represented as a concept list, concept hierarchy or a concept map. The results show that OSM do have a positive effect on students' learning. However, the students showed clear preferences towards simpler representations than the more complex ones.

Collaborative software engineering (CSE) is a rapidly growing field. Tools such as IDEs are now beginning to incorporate new collaborative features. We have developed several real-time CSE tools which support fine-grained collaboration. In this paper we present an empirical evaluation to investigate the potential benefits of our tools for collaborative source code development. Our results show that for the two typical types of collaborative programming scenarios studied, users of CSE tools achieve task completion rates at least twice as fast as those obtained from their single-user counterparts. Additionally, participants indicated strong support for the concept of CSE tools. These results encourage us to continue developing our CSE tools, and to investigate their use in other software engineering contexts.

CAISE, a collaborative software engineering architecture, provides extensible real-time support for collaboration between participating tools and users. The architecture maintains a semantic project model constructed incrementally from software artifacts as they are developed; this model is used to determine the impact of changes at a semantic level. This information is relayed to developers, providing them with awareness of others' locations, and alerting them to potential conflicts and the need for closer collaboration. We use examples from CAISE-based tools to illustrate the potential of real-time collaborative software engineering to enhance awareness of other developers' actions.

The size, complexity and duration of typical software engineering projects means that teams of developers will work on them. However, with the exception of version control systems, the editors, diagrammers and other tools used will generally support only a single user. We present an architecture for bringing to software engineering development environments the advantages of awareness of the presence, intentions, and actions of others. Thus far, the applications of such facilities have been primarily in simple computer supported cooperative work (CSCW) tools, such as shared whiteboards, where the corresponding artifacts, unlike those of software engineering, are typically both simple and transient. We describe our implementation of the architecture and prototype tools and illustrate the benefits of providing support for real-time collaboration between developers located anywhere on the Internet. We also describe how our architecture, which is based on a parse tree representation of artifacts, may be extended readily to include new tools, languages, and notations or be customised to provide new awareness mechanisms.

The source code for computer programs is destined to be read by compilers and consequently its internal structure is heavily constrained. The compiler neither knows nor cares about such things as a program's internal structure, the relationships between its components and their specifications, the way design patterns are instantiated, the best way to explain its algorithms or how it is intended to be used. People do. Literate programming (LP) was invented by Donald Knuth as a way to address such problems. The idea is appealing but LP has not been adopted widely: the lack of good tools, difficulties with object-oriented languages and the limitations of a single psychological order are among the reasons. We report the development of theme-based literate programming (TBLP). Themes are extremely flexible: they may be aimed at particular reader groups or represent aspects of the program. Features of TBLP include an extended chunk model which accommodates a richer variety of types, an extended connection model which allows chunks to be threaded together into multiple themes, an enhanced processing model which generalises tangling and weaving and a chunk-level version management system. XML is used to represent the web structure and XML-based technologies such as XSLT are used in processing. This provides flexibility and extensibility, allowing users to define new chunk types. An application which implements TBLP is presented and the integration of TBLP with software engineering processes is discussed.

Internet and intranet Web sites have become an integral part of software development as well as the wider fields of commercial, educational and recreational activity. In order to improve our understanding of Web based software engineering we must first understand how Web sites are used. Information about the structure and usage of sites is valuable to administrators, maintainers, content developers and users. The volume and complexity of the data generated by typical tools is a major limitation. We describe the use of virtual worlds, including a novel extension of the perspective wall, for visualising Web site activity. Examples from our university environment are presented and discussed.

A suite of object oriented software metrics has recently been proposed by S.R. Chidamber and C.F. Kemerer (see ibid., vol. 20, p. 476-94, 1994). While the authors have taken care to ensure their metrics have a sound measurement theoretical basis, we argue that is premature to begin applying such metrics while there remains uncertainty about the precise definitions of many of the quantities to be observed and their impact upon subsequent indirect metrics. In particular, we show some of the ambiguities associated with the seemingly simple concept of the number of methods per class. The usefulness of the proposed metrics, and others, would be greatly enhanced if clearer guidance concerning their application to specific languages were to be provided. Such empirical considerations are as important as the theoretical issues raised by the authors.>