bluuebunny/crossref_metadata_2025 huggingface dataset:
Manipulating managed execution runtimes to support self-healing systems
Authors: Griffith Rean , Kaiser Gail
Published: November 2005

Self-healing systems require that repair mechanisms are available to resolve problems that arise while the system executes. Managed execution environments such as the Common Language Runtime (CLR) and Java Virtual Machine (JVM) provide a number of application services (application isolation, security sandboxing, garbage collection and structured exception handling) which are geared primarily at making managed applications more robust. However, none of these services directly enables applications to perform repairs or consistency checks of their components. From a design and implementation standpoint, the preferred way to enable repair in a self-healing system is to use an externalized repair/adaptation architecture rather than hardwiring adaptation logic inside the system where it is harder to analyze, reuse and extend. We present a framework that allows a repair engine to dynamically attach and detach to/from a managed application while it executes essentially adding repair mechanisms as another application service provided in the execution environment.
Connector-based self-healing mechanism for components of a reliable system
Authors: Shin Michael E. , Cooke Daniel
Published: November 2005

This paper describes the self-healing mechanism for components in reliable systems. Each component in a self-healing system is designed as a layered architecture, structured with the healing layer and the service layer. The healing layer of a self-healing component is responsible for detection of anomalous objects in the service layer, reconfiguration of the service layer, and repair of anomalous objects detected. The service layer of a self-healing component provides functionality to other components, which consists of tasks (concurrent or active objects), connectors, and passive objects accessed by tasks. A connector supports the self-healing mechanism for self-healing components as well as encapsulates the synchronization mechanism for message communication between tasks in a component. Connectors are involved in detection of anomalous objects, reconfiguration of components, and repair of anomalous objects. This paper also specifies connectors - the message queue self-healing connector. message buffer self-healing connector, and message buffer and response self-healing connector - which provide functionalities for the self-healing mechanism.
Towards autonomic web services
Authors: Gurguis Sherif A. , Zeid Amir
Published: November 2005

Autonomic Computing was introduced to reduce the complexity of managing computing systems; however, the heterogeneous nature existing in most computing systems introduces some difficulty to achieve this target. Moreover, the notion of service as a computing component that seamlessly collaborates with other services in a loosely-coupled manner to perform complicated tasks was introduced by Service-Oriented Architecture (SOA); and then, fertilized by Web Services that added open standards to different roles and operations involved in a community of services; however, in order to gain the expected benefits of Web Services, the latter should be able to survive in normal and abnormal conditions. Our research aims at finding a hyper solution to that two-dimensional problem by allowing both Autonomic Computing and Web Services paradigms to lend each other their distinct features. First, Web Services lend Autonomic Computing the concept of platform-independency; second, Autonomic Computing lends Web Services the attributes providing self-management. The focus of this paper will be on how the self-healing autonomic attribute can be implemented and applied using Web Services.
Hierarchical model-based autonomic control of software systems
Authors: Litoiu Marin , Woodside Murray , Zheng Tao
Published: November 2005

Various control algorithms are used in autonomic control to maintain Quality of Service (QoS) and Service Level Agreements (SLAs). Controllers are all based to some extent on models of the relationship between resources, QoS measures, and the workload imposed by the environment. This work discusses the range of algorithms with an emphasis on richer and more powerful models to describe non-linear performance relationships, and strong interactions among the system resources. A hierarchical framework is described which accommodates different scopes and timescales of control actions, and different control algorithms. The control algorithms and architectures can be considered in three stages: tuning, load balancing and provisioning. Different situations warrant different solutions, so this work shows how different control algorithms and architectures at the three stages can be combined to fit into different autonomic environments to meet QoS and SLAs across a large variety of workloads.
Better performance or better manageability?
Authors: Munawar Mohammad A. , Ward Paul A. S.
Published: November 2005

Competition among software providers creates enormous pressure on design and development teams to improve application performance. However, increased performance leads to systems whose behaviour is harder to predict. This in turn makes software harder to manage, or self-manage in the case of autonomic software. In this paper we elaborate on this problem, first in generic terms, and then taking memory-usage monitoring in a Java Virtual Machine as a specific example. We motivate the need for more research in developing monitoring techniques that can cope with the complexity of modern software systems. We finally present our own efforts in this direction.
Towards requirements-driven autonomic systems design
Authors: Lapouchnian Alexei , Liaskos Sotirios , Mylopoulos John , Yu Yijun
Published: November 2005

Autonomic computing systems reduce software maintenance costs and management complexity by taking on the responsibility for their configuration, optimization, healing, and protection. These tasks are accomplished by switching at runtime to a different system behaviour - the one that is more efficient, more secure, more stable, etc. - while still fulfilling the main purpose of the system. Thus, identifying and analyzing alternative ways of how the main objectives of the system can be achieved and designing a system that supports all of these alternative behaviours is a promising way to develop autonomic systems. This paper proposes the use of requirements goal models as a foundation for such software development process and sketches a possible architecture for autonomic systems that can be built using the this approach.
A software architecture approach for structuring autonomic systems
Authors: Balasubramaniam Dharini , Morrison Ron , Kirby Graham , Mickan Kath , Warboys Brian , Robertson Ian , Snowdon Bob , Greenwood R. Mark , Seet Wykeen
Published: November 2005

Autonomic systems manage themselves given high-level objectives by their administrators. They utilise feedback from their own execution and their environment to self-adapt in order to satisfy their goals. An important consideration for such systems is a structure which is conducive to self-management. This paper presents a structuring methodology for autonomic systems which explicitly models self-adaptation while separating functionality and evolution. Our contribution is a software architecture-based framework combining an architecture description language based on π-calculus for describing the structure and behaviour of autonomic systems, a development methodology for evolution and mechanisms for feedback and change.
From product lines to self-managed systems
Authors: Kim Minseong , Jeong Jaemin , Park Sooyong
Published: November 2005

Adaptability and/or high availability are requirements which have become more prevalent and important for computing systems in recent years. To support adaptability and availability, a system must be able to dynamically change its behavior at runtime as user requirements, execution environments, or technologies change. Our aim is to develop a dynamic software product line in which a product line member can be dynamically modified after its deployment and thus new products can be produced during runtime without newly developing the products. To do so, we present a runtime reconfiguration framework based on reconfigurable components in supporting building dynamic product lines, particularly within the embedded software domain. Ultimately, our framework supports dynamic reconfiguration and not only reusable, but also reconfigurable components development in the context of self-managed systems.
, i need you!
Authors: Kaminski Piotr , Agrawal Priyanka , Kienle Holger , Müller Hausi
Published: November 2005

In this position paper, we examine factors, such as trust and usability, which can affect the adoption of an autonomic system. We argue that a system that exhibits initiative and strong communication skills is more likely to be adopted, and propose to treat humans as modeled, managed elements in an autonomic control loop to achieve these goals. We then propose some synergistic design ideas to make communicating with users more effective, and to allow the system to learn from the users' actions.
Policies, grids and autonomic computing
Authors: Simmons Bradley , Lutfiyya Hanan
Published: November 2005

The goals of resource management fall within the overall aims of autonomic and grid computing, namely the sharing of resources automatically, and the allocation of resources depending on both application and business needs. Resource allocation can be guided by
policies
which encapsulate decisions made by the management system. Policies can be used to encapsulate many different types of management decisions including possible corrective actions when a performance requirement of an application is not being satisfied and actions to take place when there is more demand then supply. System policy is derived from the interactions between Service Level Agreements (contractual agreements between businesses) and locally specified management rules. This paper explores the potential use of mathematical models (e.g., optimisation models) for relating the various types of policies. It describes the current and proposed work in applying policies to resource management in the context of autonomic and grid computing systems.
Interoperability issues affecting autonomic computing
Authors: Smith Dennis , Morris Edwin , Carney David
Published: November 2005

Most autonomic systems consist of a number of components and systems. These systems require a high degree of interoperability between the constituent components and systems. We describe current research on the topic of interoperability that has relevance for autonomic systems and list a set of critical properties of interoperability that need to be considered in designing autonomic systems.
Dynamic integration of heterogeneous mobile devices
Authors: Bartelt Christian , Fischer Thomas , Niebuhr Dirk , Rausch Andreas , Seidl Franz , Trapp Marcus
Published: November 2005

In these days the trend "everything, every time, everywhere" becomes more and more apparent. As consequence of this trend everyone has a lot of small or invisible devices in his direct environment, e.g. mobile phones, PDAs, or music players. Also some network technologies to connect the different devices like (W)LAN or Bluetooth moved mainstream.Today in most domains the considered devices and technologies are integrated in isolated applications with fixed hardware settings. But humans live in changing environments and have varying requirements, so they need customizable systems which adapt dynamically. As many different types of devices exist, it is a big challenge to integrate them within one system. In this paper we introduce a concept that enables dynamic integration of heterogeneous devices at run time. Although our concept is at an early stage we built a promising implementation in the domain of assisted training to validate the basic principles.
Transparent shaping of existing software to support pervasive and autonomic computing
Authors: Sadjadi S. Masoud , McKinley Philip K. , Cheng Betty H. C.
Published: November 2005

The need for adaptability in software is growing, driven in part by the emergence of pervasive and autonomic computing. In many cases, it is desirable to enhance existing programs with adaptive behavior, enabling them to execute effectively in dynamic environments. In this paper, we propose a general programming model called
transparent shaping
to enable dynamic adaptation in existing programs. We describe an approach to implementing transparent shaping that combines four key software development techniques: aspect-oriented programming to realize separation of concerns at development time, behavioral reflection to support software reconfiguration at run time, component-based design to facilitate independent development and deployment of adaptive code, and adaptive middleware to encapsulate the adaptive functionality. After presenting the general model, we discuss two specific realizations of transparent shaping that we have developed and used to create adaptable applications from existing programs.
The C-Cube framework
Authors: Canfora Gerardo , Corte Piero , De Nigro Antonio , Desideri Debora , Di Penta Massimiliano , Esposito Raffaele , Falanga Amedeo , Renna Gloria , Scognamiglio Rita , Torelli Francesco , Villani Maria Luisa , Zampognaro Paolo
Published: November 2005

Web services constitute a promising technology to support autonomic computing. Automatic discovery of new services, their composition and binding based on Quality of Service (QoS) are just some of the most promising features that can be provided using web services. In other words, a service oriented system is able to automatically discover, bind, and use, at run time, the services that, among those available, offer a given piece of functionality with a QoS compatible with the system non-functional requirements.This paper describes our work-in-progress related to the development of an electronic marketplace, named
C
3
(Creation, Certification and Classification of Services) to enable the publication, semantic discovery, service buying, SLA negotiation and QoS-aware composition and replanning. The marketplace is mainly targeted to corporate intranets, although its technologies and approaches can be easily exported to a wider scenario.
Adaptive integration of third-party web services
Authors: Denaro Giovanni , Pezzé Mauro , Tosi Davide
Published: November 2005

Service based computing allows clients to dynamically bind services, and providers to modify the service implementation independently from their clients. The impossibility of statically determining which service implementation will be bound at runtime may lead to unexpected client-side failures. This position paper suggests a scenario in which service-based applications autonomously react to changes in the implementation of the used services, automatically detect possible integration mismatches, and dynamically execute suitable adaptation strategies. The proposed solution exploits ideas from autonomic computing and self-managed software. We propose a design methodology based on the definition of both test cases, to automatically diagnose service mismatches, and adaptation strategies, to overcome the revealed problems. We introduce a general runtime infrastructure that automatically embeds the test cases and the adaptation strategies into service based applications to guarantee self-adaptiveness.
An approach to implementing dynamic adaptation in C++
Authors: Fleming Scott D. , Cheng Betty H. C. , Stirewalt R. E. Kurt , McKinley Philip K.
Published: November 2005

This paper describes TRAP/C++, a software tool that enables new adaptable behavior to be added to existing C++ programs in a transparent fashion. In previous investigations, we used an aspect-oriented approach to manually define aspects for adaptation infrastructure, which were woven into the original application code at compile time. In follow-on work, we developed TRAP, a transparent shaping technique for automatically generating adaptation aspects, where TRAP/J is a specific instantiation of TRAP. This paper presents our work into building TRAP/C++, which was intended to be a port of TRAP/J into C++. Designing TRAP/C++ required us to overcome two major hurdles: lack of reflection in C++ and the incompatibility between the management of objects in C++ and the aspect weaving technique used in TRAP/J. We used generative programming methods to produce two tools, TrapGen and TrapCC, that work together to produce the desired TRAP/C++ functionality. Details of the TRAP/C++ architecture and operation are presented, which we illustrate with a description of a case study that adds dynamic auditing capabilities to an existing distributed C++ application.
Building component families to support adaptation
Authors: Biyani Karun N. , Kulkarni Sandeep S.
Published: November 2005

Autonomic systems undergo dynamic compositional adaptation that often require
state transfer and synchronization
to correctly initialize the state of the new component, while ensuring that multiple fractions of the component are added and removed consistently. In general, if there are
n
different components for a given functionality, then there exist
n
(
n
- 1) possible adaptations for selecting an appropriate component. Identifying all these adaptations is not an easy task. Moreover, as verification of such adaptations is also difflcult, it is desirable to reduce total number of these adaptations.We propose a
component family
design for systematically building a repository of components from the perspective of dynamic adaptation. For a family of
n
components, we show that it suffices to identify
n
different adaptations. Moreover, to add a new component to this family, it suffices to consider only two adaptations. We also propose a design to separate the adaptation concern from component functionality for simplifying the specification and verification of adaptation. We introduce the
enhanced-primitive
relation between two components; when such a relation is known to exist, we show that it is possible to simplify the adaptation and its verification.
A risk based economical approach for evaluating software project portfolios
Authors: Costa Hélio R. , de O. Barros Marcio , Travassos Guilherme H.
Published: November 2005

Software engineers have been applying economical concepts to shed light upon the value-related aspects of software development processes. Based on credit risk analysis concepts, we present an approach to estimate the probability distribution of losses and earnings that can be incurred by a software development organization according to its software project portfolio. Such approach is built upon an analogy that compares software projects to unhedged loans issued to unreliable borrowers. As loans may not be paid back, software projects may fail, leading their development organizations to losses. By applying this approach, an organization may estimate the variability of its expected profits related to a set of software projects. Initial calibrating data were acquired by accomplishing an experimental study.
Staffing a software project
Authors: Barreto Ahilton , Barros Márcio , Werner Cláudia
Published: November 2005

This paper presents an optimization based approach to support staffing a software project. The approach takes into account the characteristics of the project activities, the characteristics of the available human resources, and constraints established by the software development organization in charge of the project. According to these needs, the project manager selects a utility function to be maximized or minimized by the optimizer. We propose several utility functions, each addressing specific values which can be sought by the development organization.
A value-based approach to predicting system properties from design
Authors: Scaffidi Chris , Arora Ashish , Butler Shawn , Shaw Mary
Published: November 2005

Traditional engineering requires evaluating designs before implementing them. Evaluating a design predicts the properties of a reasonable implementation and the value of these properties to a stakeholder. Software engineering has some (though not enough) relevant evaluation techniques but lacks frameworks to compare, develop, and apply those techniques in a manner that respects h value varies by stakeholder. We present an adaptation of economists' value models that, given a design and a development method, predicts value to a client. We give examples supporting our approach. Even in its preliminary state, our approach helps to explain and characterize design evaluation techniques and shows sufficient promise to justify further development.
A tentative framework for connecting long-term business and product planning with iterative & incremental software product development
Authors: Vähäniitty Jarno
Published: November 2005

For a company in the software product business, it is essential to understand how to connect business management and software development [17] and employ a solid, value-based approach in its decision-making. However, software engineering literature (SE) commonly addresses what should be done at the "floor level" and leaves the link to business and product management unaddressed [14]. Also, existing software development models mostly adhere to the viewpoint of individual development projects and thus fail to sufficiently address common product development concerns such as multi-project or project portfolio management [20].
Metrics for software system families
Authors: Kiebusch Sebastian , Franczyk Bogdan , Speck Andreas
Published: November 2005

Due to the fact that the complexity and development effort of software systems is constantly increasing, software components have to be reused. Software system families are a promising solution to gain a cost reduction by reusing common software assets in different variants of similar products. To support the economic management of this development approach we need software metrics to estimate the effort of building software system families. In general techniques of size measurement and cost estimation for software system families are highly insufficient. Furthermore measurement and estimation approaches do not support a process orientation which characterizes the software of many domains. Therefore this paper describes the Process-Family- Points approach to measure the size and estimate the effort of process focused software system families in multiple domains. Every single step of this new metrics approach will be illustrated from a high level perspective to communicate a conceptional view of this innovative sizing and estimating method.
On the economics of requirements-based test case prioritization
Authors: Srikanth Hema , Williams Laurie
Published: November 2005

Software testing is a strenuous and expensive process. At least 50% of the total software cost is spent on testing activities [12]. Companies are often faced with time and resource constraints that limit their ability to effectively complete testing efforts. Companies generally save suites for reuse; test suite reuse accounts for almost half of the maintenance cost [9]. As the product goes thru several versions, executing all the test cases in a test suite can be expensive [9]. Prioritization of test cases can be cost effective when the time allocated to complete testing is limited [9]. Test case prioritization (TCP) involves the explicit planning of the execution of test cases in a specific order and is shown to improve the rate of fault detection [3, 9]. The current software TCP techniques are primarily coverage-based (statement, branch or other coverage) [3,9]. Coverage-based white-box prioritization techniques are most applicable for regression testing at the unit level and are harder to apply on complex systems [2]. These techniques require testers to read and understand the code, which can be time consuming [2], and may assume that all faults are equally severe.
Current practices and research opportunities in software business models
Authors: Kontio Jyrki , Jokinen Jani-Pekka , Mäkelä Markus M. , Leino Virve
Published: November 2005

This paper discusses the notion of a
business model
in the context of a software company, reviewing some common definitions for the term and then characterizing businesses according to different types of business models. We will conclude in discussing how different business models affect software engineering decisions and the software product itself.
On using Net Options Value as a value based design framework
Authors: Bajracharya Sushil Krishna , Ngo Trung Chi , Lopes Cristina Videira
Published: November 2005

We present our experiences using Net Options Value (NOV) as a framework for evaluating options in software design. We start with a brief introduction of the NOV model, provide summaries of analyses - where and how NOV has been applied, and list some of the open issues based on the early works in this area. In particular we present our approach to understand an important parameter of the NOV called the 'technical potential' of a module and outline our further research directions in using NOV.
A value-oriented theory of modularity in design
Authors: Cai Yuanfang , Sullivan Kevin J.
Published: November 2005

We were motivated to undertake the research we describe here by a conversation with two practicing software engineers, who described a dilemma they faced at work. They worked for small company that earned revenues by delivering to a large customer a stream of enhancements to a software tool. The engineers' jobs were to estimate the time to make enhancements and to implement selected enhancements. They were good at estimating, but dissatisfied with the system design, believing that it significantly slowed new feature implementation. They had proposed to management to restructure the tool. However, the management, concerned about disrupting the flow of enhancements thus revenues, and having no clear model of likely benefits, declined. The engineers believed that refactoring would increase the velocity of feature delivery, but they had no sense or ability to analyze the situation quantitatively or to frame it in a way that was compelling to business decision-makers. As a result, the engineers were dissatisfied, and the company incurred a possibly significant opportunity cost.
Functional group roles in software engineering teams
Authors: Beranek Georgine , Zuser Wolfgang , Grechenig Thomas
Published: November 2005

For building and leading successful software engineering teams it is vital to understand their team structure as well as many other "soft" factors, e.g. the personality and skills of individual team members. A key element of the team structure, besides power distribution, knowledge distribution etc., is the role distribution within the team. The role distribution has a twofold aspect: first, the formal role distribution, which is defined by the standard process and role model or the project management, and second, the informal role distribution which grows within a team by the natural interactions between the team members and is based to some extent upon their individual characteristics.This paper presents an empirical examination of the informal role distribution in student software engineering teams and compares the results to the concept of functional group roles.
Supporting distributed software design meetings
Authors: Dekel Uri
Published: November 2005

Although virtual conferencing tools have been successfully used in executive meetings, current tools appear inadequate for the needs of software designers. As a result, while distributed code writing is becoming widespread, almost all software design meetings are still carried out face-to-face incurring costs that undermine the potential of distributed software development.Our research strives to build successful tools for supporting distributed software design meetings. To do so, we must first identify the unique activities of software design which must be mimicked in the virtual world. This paper does so with a detailed study of two colocated design meetings. We discuss issues that must be tackled in the transition to virtual settings, outline requirements for such tools, and propose strategies for meeting these requirements. In doing so, we also identify problems in existing colocated meetings which could be alleviated with these tools.
Managing radical software engineers
Authors: Desouza Kevin C. , Awazu Yukika
Published: November 2005

Innovations in software engineering organizations frequently emerge from risky behavior. Most often, these risks are taken by only a small percentage of the software engineering staff -
radical engineers
(REs). They go against the status quo, experiment with new methods or technologies, and have the burden of bringing the innovations into the mainstream of the organization. Most organizations however, do a poor job of adequately and effectively managing
radical engineers
(REs). They can be found at either end of the order-chaos continuum. Successful software organizations are those that are able to balance between the extremes and manage REs effectively. In this paper, we discuss lessons learnt in managing REs from software organizations.
Co-Operative Method Development revisited
Authors: Dittrich Yvonne , Rönkkö Kari , Lindeberg Olle , Erickson Jeanette , Hansson Christina
Published: November 2005

During the last five years, we applied a research approach we call 'Co-operative Method Development' formulated on first experience with empirical research focusing especially on the social side of software engineering. This position paper summarizes the experiences and discusses the improvement and further development of this research approach based on our experiences in different research projects in co-operation with industrial partners.
HCI pattern semantics in XML
Authors: Gaffar Ashraf , Seffah Ahmed , Van der Poll John A.
Published: November 2005

User interface design is a multidisciplinary field at the crossroads between software engineering, computer science, psychology and cognitive science. HCI pattern writers focus on usability and human aspects of the interface. They use elaborate narrative formats to convey theories and practices of interaction design. Pattern users are typically software developers who need concise and pragmatic guidance of when and how patterns can be used. Narrative descriptions make it difficult to integrate patterns into design (CASE) tools. In this paper, we discuss how patterns can be represented in XML to effectively support their dissemination and assimilation in a programmable environment.
Customer relationships and Extreme Programming
Authors: Grisham Paul S , Perry Dewayne E.
Published: November 2005

Extreme Programming (XP) brings the customer and development team together into a tight functional unit, while eliminating many of the process activities of more structured software development processes. While agile methods may yield benefits in terms of product cost and quality, there is also a risk that the very practices that make agile methods effective may weaken the customer relationship. This paper examines XP from the perspective of customer satisfaction and motivates the need for more analysis of the social, psychological, and business factors in studies of software development methods.
The effect of human memory organization on code reviews under different single and pair code reviewing scenarios
Authors: Koru A. Günes , Ozok A. Ant , Norcio Anthony F.
Published: November 2005

Human memory organization has been shown to be related to how programmers understand programs. In recent years, agile methods brought the emphasis back on human and social aspects of software engineering with a set of new principles and practices. One of them, pair programming has been shown to improve quality and reduce the development costs. In this position paper, we propose a controlled experiment to evaluate the effect of human memory organization through chunking on code reviews under different single and pair code reviewing scenarios.
Effects of agile practices on social factors
Authors: Law Amy , Charron Raylene
Published: November 2005

Programmers are living in an age of accelerated change. State of the art technology that was employed to facilitate projects a few years ago are typically obsolete today. Presently, there are requirements for higher quality software with less tolerance for errors, produced in compressed timelines with fewer people. Therefore, project success is more elusive than ever and is contingent upon many key aspects. One of the most crucial aspects is social factors. These social factors, such as knowledge sharing. motivation, and customer collaboration, can be addressed through agile practices. This paper will demonstrate two successful industrial software projects which are different in all aspects; however, both still apply agile practices to address social factors. The readers will see how agile practices in both projects were adapted to fit each unique team environment. The paper will also provide lessons learned and recommendations based on retrospective reviews and observations. These recommendations can lead to an improved chance of success in a software development project.
The challenges in creating tools for improving the software development lifecycle
Authors: Spraragen Susan L.
Published: November 2005

Creating successful software systems for end user applications is a complex task. It is often proposed that tools can be built for development teams to help them do their job more efficiently and to help them communicate with their team members. The success of these tools relies on how well the technical community that builds software tools understands the needs of the technical community that uses these tools. How can we effectively apply a user centered design approach to building these tools?
Applying small group theory to analysis and design of CSCW systems
Authors: Sutcliffe Alistair
Published: November 2005

This paper introduces a social psychological theory -- Small Groups as Complex Systems -- as a contribution to software engineering and more specifically, design of CSCW systems. Small Group Theory is composed of local dynamics which model the internal view of a group; global dynamics that represent whole group emergent properties; and contextual dynamics that model the influences of the group's environment on its composition, coherence and behaviour. The potential contribution of Small Group Theory to the design of CSCW systems is investigated by model-based analysis of group members, supporting technology, and design principles motivated by the theory.
A communication architecture from rapid prototyping
Authors: Tai Grace
Published: November 2005

Communication issues can become a progress-impeding burden to software projects requiring advanced group collaboration. Human and social factors, such as conflicting personalities, educational backgrounds, or different communication styles, play a large part in group communication. During a recent rapid prototyping project with over 30 collaborators, including software engineers, UI designers and non-technical customers, we understood that effective and efficient communication would be crucial to the success of our project. The communication architecture that we evolved through the project incorporates human and social factors so that team members with different backgrounds (e.g., UI design, software engineering, non-technical) can communicate effectively in an agile development environment.
Examining team cohesion as an effect of software engineering methodology
Authors: Wellington Carol A. , Briggs Thomas , Girard C. Dudley
Published: November 2005

This paper describes an experiment in which student teams developed products using two different methodologies: the Team Software Process (TSP) as a plan-driven methodology and Extreme Programming (XP) as an agile methodology. We carefully define cohesion and derive instruments appropriate for measuring cohesion. Then, throughout the projects, the teams were surveyed to measure various aspects of team cohesion and those results support conclusions about how methodology was affecting cohesion. The results show that the measures developed lead to interesting observations that can be applied to current, non-academic projects. In addition, future work in broadening this study is justified.
Personality characteristics in an XP team
Authors: Young S. Michelle , Edwards Helen M. , McDonald Sharon , Thompson J. Barrie
Published: November 2005

There is a "folk belief" that certain personalities fit with particular systems development roles: however, there is little evidence to confirm this supposition. As part of a larger study an XP development team was investigated using a repertory grid approach (this is discussed in detail) to determine whether coherent personalities and characteristics emerge for different roles. The results, which are inevitably limited, suggest that this is the case. Further work remains to be done to build a large corpus of data for future analysis before firm mappings can be made between appropriate personality characteristics and software development roles.
A qualitative empirical evaluation of design decisions
Authors: Zannier Carmen , Maurer Frank
Published: November 2005

In this paper, we motivate examining software design decision making and provide the process by which the examination will occur. The objective is to provide qualitative results indicative of rational or naturalistic software design decision making. In a rational decision a decision maker evaluates decision alternatives and potential outcomes for each alternative using a utility function and probabilities of the outcome of each alternative. The utility function assigns a value to each possible alternative based on its outcome. The goal of rational decision making is selecting the optimal alternative. A naturalistic decision manifests itself in dynamic and continually changing conditions, embodies real-time reactions to these changes, embraces ill-defined tasks, and has a goal of selecting a satisfactory alternative. The proposed empirical qualitative study consists of inductive and deductive interviewing and deductive observations.
Concern management for constructing model compilers
Authors: Ubayashi Naoyasu , Tamai Tetsuo
Published: November 2005

Model-driven architecture (MDA) aims at automating software design processes. A model compiler transforms platform-independent models into platform-specific models automatically. In order to construct an effective model compiler, we need to take account of not only platform concerns but also other kinds of model transformation concerns including optimization, real-time constraints, and deployment. However, current model compilers do not provide a mechanism for managing these multiple concerns. We propose a method for constructing an extensible model compiler based on aspect-orientation. A modeler can manage multiple concerns and extend model transformation rules by defining new aspects in the process of modeling. In this paper, an aspect-oriented modeling language called AspectM is introduced for managing modeling-level aspects.
Using language clues to discover crosscutting concerns
Authors: Shepherd David , Pollock Lori , Tourwé Tom
Published: November 2005

Researchers have developed ways to describe a concern, to store a concern, and even to keep a concern's code quickly available while updating it. Work on identifying concerns (semi-)automatically, however, has yet to gain attention and practical use, even though it is a desirable prerequisite to all of the above activities, particularly for legacy applications. This paper describes a concern identification technique that leverages the natural language processing (NLP) information in source code. Developers often use NLP clues to help understand software, because NLP helps them identify concepts that are semantically related. However, few analyses use NLP to understand programs, or to complement other program analyses. We have observed that an NLP technique called lexical chains offers the NLP equivalent of a concern. In this paper, we investigate the use of lexical chaining to identify crosscutting concerns, present the design and implementation of an algorithm that uses lexical chaining to expose concerns, and provide examples of concerns that our tool is able to discover automatically.
ActiveAspect
Authors: Coelho Wesley , Murphy Gail C.
Published: November 2005

Developers must often deal with concerns that crosscut a program's structure. Understanding the crosscutting structure may help a developer understand and work with the concern. Current tools for presenting crosscutting structure suffer either from graphical complexity or a mismatch between the presentation and the underlying program structure. We introduce a concern presentation approach that overcomes these problems through a combination of automatic abstraction and interactive features that enable a developer to investigate relevant details. We sketch how the ActiveAspect tool we are developing implements this approach for presenting the crosscutting structure described by aspects in AspectJ.
Separating architectural concerns to ease program understanding
Authors: Jakobac Vladimir , Medvidovic Nenad , Egyed Alexander
Published: November 2005

This paper presents an iterative, user-guided approach to program understanding based on a framework for analyzing and visualizing software systems. The framework is built around a pluggable and extensible set of clues about a given problem domain, execution environment, and/or programming language. The approach leverages two orthogonal architectural views of a system and describes how a proper identification of boundaries for separate concerns helps in reasoning about the system.
Pattern transformation for two-dimensional separation of concerns
Authors: Wu Xiaoqing , Bryant Barrett R. , Gray Jeff , Mernik Marjan
Published: November 2005

Design patterns are utilized in software development to decouple individual concerns, so that a change in a design decision is isolated to one location of the code base. However, multidimensional concerns exist in software development and therefore no single design pattern offers a panacea toward addressing problems of change evolution. By analyzing the matrix of concerns during the software development process and utilizing transferable aspect-orientation and object-orientation, a pattern transformation based two-dimensional separation of concerns is described, which integrates the benefits derived from the Inheritance pattern and several GoF patterns. An example implementation is shown using Java and AspectJ.
Concern modeling in the concern manipulation environment
Authors: Harrison William , Ossher Harold , Sutton Stanley , Tarr Peri
Published: November 2005

The Concern Manipulation Environment (CME) is an AOSD environment in which software is organized and manipulated in terms of concerns. This paper is about ConMan, the CME concern manager, which supports the identification, definition, encapsulation, extraction and composition of concerns. ConMan models software in terms of concerns, relationships, constraints, units, artifacts, and associated information. The concern model is multidimensional and concerns can be defined extensionally and/or intensionally. ConMan is neutral with respect to artifact types and formalisms, and it can be used with both aspect-oriented and non-aspect oriented software and methods. ConMan is intended to serve both as a tool for directly modeling concerns and as a platform for developing alternative concern-modeling approaches.
Concern patterns and analysis
Authors: Memmert Juri
Published: November 2005

This paper describes a few concern patterns to identify latent or missing concerns in a concern model and how they impact the development process.
Just-in-time concern modeling
Authors: Robillard Martin P. , Murphy Gail C.
Published: November 2005

In this position paper, we propose the notion of just-in-time concern modeling. As some concerns emerge late in the software life cycle and can be ephemeral, we argue that mechanisms should be available to capture descriptions of concerns as they emerge or become relevant. Based on our experience with the FEAT concern modeling and analysis tool, we highlight the essential characteristics, benefits, and pitfalls of just-in-time concern modeling at the source code level.
Separation of concerns for evolving systems
Authors: Hamza Haitham S.
Published: November 2005

This paper describes an approach for separating and modeling concerns while considering system evolution. The objective is to reduce the need for
re-separation
and
re-modeling
of concerns when the system evolves in response to new or modified requirements. Software Stability Model (SSM) and the theory of Formal Concept Analysis (FCA) are used to analyze and encapsulate concerns into modules that are less likely to change over time. The approach is described and demonstrated through an example.
A model-driven approach to enforce crosscutting assertion checking
Authors: Zhang Jing , Gray Jeff , Lin Yuehua
Published: November 2005

Design by Contract provides an effective principle to enable the construction of robust software by describing properties of a module using logical assertions. This paper presents a model-driven approach for weaving assertion checking aspects into a large software system. The approach is based on a technique called two-level aspect weaving. At the top level, crosscutting assertions are weaved into a model by use of a model weaver. The second step of the weaving process occurs when the Model-Driven Program Transformation technique is applied to perform large-scale adaptation of the underlying source code from the contracts specified in the high-level models. The paper briefly presents a case study to illustrate the concept.
An approach to aspect refactoring based on crosscutting concern types
Authors: Marin Marius , Moonen Leon , van Deursen Arie
Published: November 2005

We argue for the importance of organizing generic crosscutting concerns by distinctive properties and describing them as
types.
A
type's
properties consist of a general intent, an implementation idiom criteria, and one (desired) aspect language mechanism to address the concerns within the specific
type.
We argue the usefulness of this approach for aspect refactoring, and in the areas of concern identification and aspect languages development.
An exploration of how comments are used for marking related code fragments
Authors: Ying Annie T. T. , Wright James L. , Abrams Steven
Published: November 2005

A software developer performing a change task to a system very often has to examine a concern that is scattered across the source code of the system. Although many mechanisms attempt to alleviate the problem of dealing with scattered code, many software developers are still using more ad-hoc approaches to mark related code. In this paper, we explore how developers use comments to mark related code. We found that developers use two basic kinds of conventions to mark related code in comments: by explicitly stating relationships in the comment and by using similar comments in related code elements. These conventions have several major issues. However, we observe that using comments to mark related code fragments offers several benefits. We hope that our observations can give insights into building better tool support for scattered code fragments.