Traditional Software Engineering Research Articles

A Methodological Framework for Socio-Cognitive Analyses of Collaborative Design of Open Source Software

Open Source Software (OSS) development challenges traditional software engineering practices. In particular, OSS projects are managed by a large number of volunteers, working freely on the tasks they choose to undertake. OSS projects also rarely rely on explicit system-level design, or on project plans or schedules. Moreover, OSS developers work in arbitrary locations and collaborate almost exclusively over the Internet, using simple tools such as email and software code tracking databases (e.g. CVS). All the characteristics above make OSS development akin to weaving a tapestry of heterogeneous components. The OSS design process relies on various types of actors: people with prescribed roles, but also elements coming from a variety of information spaces (such as email and software code). The objective of our research is to understand the specific hybrid weaving accomplished by the actors of this distributed, collective design process. This, in turn, challenges traditional methodologies used to understand distributed software engineering: OSS development is simply too “fibrous” to lend itself well to analysis under a single methodological lens. In this paper, we describe the methodological framework we articulated to analyze collaborative design in the Open Source world. Our framework focuses on the links between the heterogeneous components of a project’s hybrid network. We combine ethnography, text mining, and socio-technical network analysis and visualization to understand OSS development in its totality. This way, we are able to simultaneously consider the social, technical, and cognitive aspects of OSS development. We describe our methodology in detail, and discuss its implications for future research on distributed collective practices.

An algebra for commitment protocols

Protocols enable unambiguous, smooth interactions among agents. Commitments among agents are a powerful means of developing protocols. Commitments enable flexible execution of protocols and help agents reason about protocols and plan their actions accordingly, while at the same time providing a basis for compliance checking. Multiagent systems based on commitments can conveniently and effectively model business interactions because the autonomy and heterogeneity of agents mirrors real-world businesses. Such modeling, however, requires multiagent systems to host a rich variety of protocols that can capture the needs of different applications. We show how a commitment-based semantics provides a basis for refining and aggregating protocols. We propose an approach for designing commitment protocols wherein traditional software engineering notions such as refinement and aggregation are extended to apply to protocols. We present an algebra of protocols that can be used to compose protocols by refining and merging existing ones, and does this at a level of abstraction high enough to be useful for real-world applications.

Teaching software engineering practices with Extreme Programming

Extreme Programming (XP), one of many models for software development, has challenged some traditional software engineering practices while taking others to the extreme. The controversial practices...

Project Management in a Software Product Line Organization

In traditional software engineering management, managers provide focused guidance to a team responsible for producing a specific result in a specified amount of time. Today, however, organizations are increasingly taking a product line approach to software to exploit product commonalities. Software product line organizations have unique practices and definitions. These unconventional features offer new challenges and directions for traditional management. How does the traditional concept of a - a temporary endeavor aimed at creating a unique product or service - hold up under this new paradigm? In this article, we discuss this question, along with how the idea of a project and management techniques must expand to fit a product line context. In particular, we show how the overall guidelines, policies, and procedures that Thayer and Pyster spoke of some years ago remain crucially important in product line organizations today.

A survey of component based system quality assurance and assessment

Component Based Software Development (CBSD) is focused on assembling existing components to build a software system, with a potential benefit of delivering quality systems by using quality components. It departs from the conventional software development process in that it is integration centric as opposed to development centric. The quality of a component based system using high quality components does not therefore necessarily guarantee a system of high quality, but depends on the quality of its components, and a framework and integration process used. Hence, techniques and methods for quality assurance and assessment of a component based system would be different from those of the traditional software engineering methodology. It is essential to quantify factors that contribute to the overall quality, for instances, the trade off between cost and quality of a component, analytical techniques and formal methods, and quality attribute definitions and measurements. This paper presents a literature survey of component based system quality assurance and assessment; the areas surveyed include formalism, cost estimation, and assessment and measurement techniques for the following quality attributes: performance, reliability, maintainability and testability. The aim of this survey is to help provide a better understanding of CBSD in these aspects in order to facilitate the realisation of its potential benefits of delivering quality systems.

CONCEPTUALIZATION, PROTOTYPING AND PROCESS OF HYPERMEDIA APPLICATIONS

Latest-generation hypermedia applications represent a new challenge in traditional design and development software engineering techniques. Although there is an impressive array of models to design hypertext applications, these models may not be specially suited for conceptualization-prototyping stages. In this paper, we provide a comprehensive software engineering approach for dealing with the conceptualization, prototyping, and process of hypermedia applications. This approach uses the Pipe Model to characterize hypermedia applications during the conceptualization stage, while prototyping is accomplished using XML and Java technologies. An XML-based representation of the Pipe structures is the input for a Java application that automatically builds the prototypes of the hypermedia application. This XML representation may reference to Subordinate Processes, i.e. compiled Java classes that implement a predefined interface and can be executed in the hypermedia application without interacting with the navigation. We also present the Plumbing and PlumbingXJ process models, two specializations of a well-known hypermedia process model, which integrate and manage the use of the Pipe model and its associated XML and Java technologies.

The usability problem for home appliances

Ordinary people already have great difficulty using the advanced features of digitally enabled household appliances, and the problem grows worse with time as more customization and programming features are added. This usability problem cannot be solved using the tiny displays and limited control buttons typically found on such devices. In this talk I will describe a new type of collaborative interface in which the appliance actively helps the user, especially with complex features that are only used occasionally. This interface provides a consistent and pervasive mechanism for answering the who-what-where-when-why-how questions that often cause users to consult a manual, call a help line, or simply give up. A crucial aspect of the interface architecture is the use of home networking to share a physically large and computationally powerful display among multiple appliances. Why is this a relevant talk for a software-engineering conference? A contributing factor to the usability crisis is the dominance of engineers in product design at many companies. The development of more-usable devices requires a broader conception of engineering that includes interaction design, artificial intelligence, and human factors - at a minimum. I will describe how these disciplines can complement traditional electrical and software engineering in the context of attempting to solve a commercially significant real-world problem.

Is security engineering really just good software engineering?

These days, if you say that you are doing research in the area of computer security you instantly receive attention. Sadly, the same cannot be said of software engineering. But are the two areas really so different? Both seem to be concerned with issues that range from the finely technical to the broadly social and that force us to make difficult tradeoffs among cost, performance, quality, and usability. Both seem to require that we conduct our research in an interdisciplinary context. In the end we realize that fully solving the security problem for ever larger and more complex systems is as intractable as fully solving the traditional software engineering problem. In this talk I will attempt to relate the challenges of security engineering and software engineering, and will argue that security engineering is more of a software engineering problem than many people would like to admit.

Going to extremes [extreme programming

Unless your organisation always delivers on time, has low staff turnover and is never surprised by the final cost or quality of its software, there is probably something wrong with the way you develop your products. Our industry has spent several decades trying to resolve this problem and yet a recent survey of 200 software projects showed ongoing problems. One development methodology, Extreme Programming generally shortened to XP and not to be confused with the Microsoft operating system, is creating interest is because it offers some radical alternatives to traditional software engineering principles and has shown its ability to create a reliable, sustainable and predictable process in certain types of projects. XP is intended as a process for small team delivering important business software in a rapidly changing world and over the last few years have demonstrated its suitability for such purpose.

Integrating formalism into undergraduate software engineering

This paper describes an approach and rational for using logic and formal methods in undergraduate software engineering education. Formal methods and logic provide a mathematical basis for modeling software analogous to the role of continuous mathematics in traditional engineering disciplines. Traditional software engineering techniques provide means for modeling software development processes and structuring specifications. Neither formal methods nor traditional approaches subsume the other, but are complimentary in software engineering education and practice. The course described here was a part of the standard Computer Engineering curriculum at The University of Cincinnati from 1993 through 1999. This paper reports on the course and observations over six years of teaching the course to undergraduate and graduate students.

Two for One: Squeezing Human-Computer Interaction and Software Engineering into a Core Computer Science Course

The final report of the Joint Task Force on Computing Curricula (CC2001) suggests that an updated computer science curricula must reflect the broadening nature of our discipline. Two areas that are included in the CC2001 are software engineering (SE) and human-computer interaction (HCI). While the first inclination might be to incorporate HCI concepts into a traditional SE course, we propose a different approach. This paper outlines a project-oriented HCI course in which we are able to emphasize some SE notions in the context of HCI concepts. Our course is also a maturation class for our students because they are exposed to a number of non-programming computer science activities, including project specification, software and interface design, user testing, prototyping and use of guidelines. We include an overview of course content that illustrates our approach. We also describe our coverage of specific CC2001 knowledge units and provide some feedback data for our course.

Built-In Contract Testing in Component Integration Testing

Assembling new software systems from prefabricated components is an attractive alternative to traditional software engineering practices which promises to increase reuse and reduce development costs. However, these benefits will only occur if separately developed components can be made to work effectively together with reasonable effort. Lengthy and costly in-situ verification and acceptance testing directly undermines the benefits of independent component fabrication and late system integration. This position paper outlines and introduces an approach for reducing manual system verification effort by equipping components with the ability to check their execution environments at run-time. When deployed in new systems, built-in tester components check the contract-compliance of their server components, including the run-time system, and thus automatically verify their ability to fulfill their own obligations. This comprises functional/behavioural contracts as well as quality-of-service contracts between individual components. Enhancing traditional component-based development methods with built-in contract testing in this way reduces the costs associated with component assembly, and thus makes the “plug-and-play” vision of component-based development closer to practical reality.

Web Components and the Semantic Web

Component-based software engineering on the Web differs from traditional component and software engineering. We investigate Web component engineering activites that are crucial for the development, composition, and deployment of components on the Web. The current Web Services and Semantic Web initiatives strongly influence our work. Focussing on Web component composition we develop description and reasoning techniques that support a component developer in the composition activities, focussing here on matching. We show how a component model can be integrated into a Semantic Web-style ontology for component development.

Teaching formal methods lite via testing

AbstractA new style of formal methods course is described, based on a pragmatic approach that emphasizes testing. The course introduces students to formal specification using Z, and shows how formal specification and testing can benefit each other, in both the validation and verification phases. It uses a tools‐based approach, with practical work that reinforces formal specification techniques as well as traditional software engineering skills, such as unit and system testing, inspection and defensive programming with assertions. The two main results are to identify several practical uses of formal specifications that are not widely practised or taught, and to demonstrate that teaching them results in a more interesting and relevant formal methods course. Copyright © 2001 John Wiley & Sons, Ltd.

Turing the tables

The most recent report of the Computing Curricula 2001 (CC2001) suggests that updated curricula must reflect the broadening nature of our discipline. Two areas that are included in the strawman draft of CC2001 are software engineering (SE) and human-computer interaction (HC). While the first inclination might be to incorporate these minimal HC concepts in a traditional SE course, we propose a different approach. This paper outlines a project oriented HC course in which we are able to emphasize SE in the context of HC concepts. We include an overview of course content that illustrates our approach.

Embracing change with extreme programming

Traditional software engineering means have been characterized by a rather predictable process in the past. Users tell once and for all exactly what they want. Programmers design the system that will deliver those features. They code it; test it, and all is well. But all was not always well. The users did not tell once and for all exactly what they wanted. They changed their minds, and the users were not the only problem. Programmers could misjudge their progress. The academic software engineering community took the high cost of changing software as a challenge, creating technologies like relational databases, modular programming, and information hiding. This is where extreme programming comes in. Rather than planning, analyzing, and designing for the far-flung future, XP exploits the reduction in the cost of changing software to do all of these activities a little at a time, throughout software development. The paper discusses the major practices of XP.

A market-driven approach to teaching software components engineering

The emergence of software component standards and tools for creating software components is leading to an increasing number of software component developers. Traditional software engineering education, however, emphasizes methods for developing large software packages. It is not clear whether such methods are appropriate for developing components. New techniques may be needed to teach the skills necessary for component development. We identify two skills software developers need to successfully develop components, which are not emphasized in traditional software engineering education: (a) uncovering multipledcustomer domain semanticss and (b) making explicit multipledcustomer framework semantics. Both skills are multiple constraint satisfaction problems. We further argue that training students to produce and market components in a simulated software components marketplace – rather than the more conventional “classroom teaching” + “component homework assignments/projects” – is an effective way of teaching such skills. We then describe an environment we created called SofTrade that simulates a components market and allows students to acquire the necessary skills. We provide a detailed case study of how a student componentdproducer team used market feedback to determine domain and framework semantics. We end by discussing the importance of marketddriven approaches for teaching software components engineering and how such approaches fit into existing software engineering curricula.

Learning to control the program evolution process with cultural algorithms

Traditional software engineering dictates the use of modular and structured programming and top-down stepwise refinement techniques that reduce the amount of variability arising in the development process by establishing standard procedures to be followed while writing software. This focusing leads to reduced variability in the resulting products, due to the use of standardized constructs. Genetic programming (GP) performs heuristic search in the space of programs. Programs produced through the GP paradigm emerge as the result of simulated evolution and are built through a bottom-up process, incrementally augmenting their functionality until a satisfactory level of performance is reached. Can we automatically extract knowledge from the GP programming process that can be useful to focus the search and reduce product variability, thus leading to a more effective use of the available resources? An answer to this question is investigated with the aid of cultural algorithms. A new system, cultural algorithms with genetic programming (CAGP), is presented. The system has two levels. The first is the pool of genetic programs (population level), and the second is a knowledge repository (belief set) that is built during the GP run and is used to guide the search process. The microevolution within the population brings about potentially meaningful characteristics of the programs for the achievement of the given task, such as properties exhibited by the best performers in the population. CAGP extracts these features and represents them as the set of the current beliefs. Beliefs correspond to constraints that all the genetic operators and programs must follow. Interaction between the two levels occurs in one direction through the extraction process and, in the other, through the modulation of an individual's program parameters according to which, and how many, of the constraints it follows. CAGP is applied to solve an instance of the symbolic regression problem, in which a function of one variable needs to be discovered. The results of the experiments show an overall improvement on the average performance of CAGP over GP alone and a significant reduction of the complexity of the produced solution. Moreover, the execution time required by CAGP is comparable with the time required by GP alone.

Techniques for the verification and validation of knowledge‐based systems: A survey based on the symbol/knowledge level distinction

AbstractVerification and validation are terms that have been used for several years in software engineering, and there are now many verification and validation techniques, plus considerable experience and expertise in using them. However, applying these techniques to knowledge‐based system is not straightforward. The essential differences between conventional systems and knowledge‐based systems suggest that these techniques must be expanded and adapted, but new techniques are also needed. This article has two major goals: first, it makes some comparisons between verification and validation as found in traditional software engineering and knowledge‐based systems, pointing out what is special about the latter as compared with the former; second, it provides a framework for a discussion of the various European work on verification and validation of knowledge‐based systems. The perspective put forward in this article allows for a vast amound of work to be surveyed and analysed beyond the implementation level, by differentiating the symbol level and the knowledge level within a knowledge‐based system.

Pursuing quality improvements: a cautionary note on software Japanization

Software quality debates have recently shadowed those in organizational behaviour and participative management, drawing inspiration from Japanese concepts of work organization and highlighting the positive impact of Kaizen and related team-working initiatives on group ties and supportive managerial relations. This paper underscores the danger of following the gurus of Japanese management too closely, of reifying packaged ‘solutions’ to quality problems and of pursuing universal principles of human resource management in the software sphere as elsewhere. The human side of software development is presented in terms of complex patterns of social interaction-incorporating organizational politics, personal conflicts and collective antagonisms-which potentially exert a powerful constraining influence on software Japanization. The message drawn from this is that software professionals should avoid importing human resource techniques wholesale in the hope of securing automatic quality improvements, and that greater thought is required in evaluating theoretical and prescriptive material from areas outside traditional software engineering.