Software Engineering Approach Research Articles

An early software engineering approach to teaching cs1, cs2 and ai

We propose the use of a new design-first approach called Problem Stereotypes and Solution Frameworks, for teaching CS1 and CS2. A problem stereotype is a category of problems that can be solved using similar techniques. A solution framework is a typical solution to a problem, parts of which can be reused to solve other problems of this stereotype. Students are introduced to a stereotype through a selection of related problems, and common features among these are identified. Homework problems are selected from the same stereotype, with students expected to follow the "recipe" provided by the given examples to generate their own solutions. Using this approach reduces the stress level for beginner students, and prevents them falling prey to the "CS is HARD" myth. We present the results of our experience with this approach in two introductory classes and an upper-division Artificial Intelligence (AI) class at SUNY Brockport.

Why is medical software so hard?

Medical software is regarded as both a success and a risk factor for quality and efficiency of medical care. First, reasons are given in what respects the medical industry is special: it is highly complex and variable, exposed to risks of privacy/confidentiality but also of denied access to authorized personnel, and medical users are a highly qualified and demanding population. Then some software technology and engineering approaches are presented that partially master these challenges. They include various divide and conquer strategies, process and change management approaches and quality assurance approaches. Benchmark institutions and comprehensive solutions are also presented. Finally, some challenges are presented that call for approaches other than technical to achieve user “buy in”, handle the outer limits of complexity, variability and change. Here, methods from psychology, economics and game theory complement domain knowledge and exploratory experimentation with new technologies.

Intuition's Role in Decision Making

Intuition might be a better decision-making approach for software engineering than you suppose.

Software engineering within a dynamic digital business ecosystem

The goal of fast adaptations and modifications according to continuous change requests is common to all software engineering methodologies. In most cases, sooner or later this results in a mismatch between the software specification and the actual implementation with related disadvantages such as the impossibility of performing validations of related models. We present here an aspect of the digital business ecosystem concept that gives incentives for more responsible software engineering approaches in general by offering a platform for automatic composition of services and re-adaptation of the specifications based on actual changes. The main innovation is a natural language based modelling notation that enables ecosystems of companies to use software described in a high-level language that can also be understood by non-technical users.

Abstracts of Recent PhDs

An architecture-centric approach for software engineering with situated multi-agent systems

A product-line architecture for web service-based visual composition of web applications

A web service-based web application (WSbWA) is a collection of web services or reusable proven software parts that can be discovered and invoked using standard Internet protocols. The use of these web services in the development process of WSbWAs can help overcome many problems of software use, deployment and evolution. Although the cost-effective software engineering of WSbWAs is potentially a very rewarding area, not much work has been done to accomplish short time to market conditions by viewing and dealing with WSbWAs as software products that can be derived from a common infrastructure and assets with a captured specific abstraction in the domain. Both Product Line Engineering (PLE) and Agile Methods (AMs), albeit with different philosophies, are software engineering approaches that can significantly shorten the time to market and increase the quality of products. Using the PLE approach we built, at the domain engineering level, a WSbWA-specific lightweight product-line architecture and combined it, at the application engineering level, with an Agile Method that uses a domain-specific visual language with direct manipulation and extraction capabilities of web services to perform customization and calibration of a product or WSBWA for a specific customer. To assess the effectiveness of our approach we designed and implemented a tool that we used to investigate the return on investment of the activities related to PLE and AMs. Details of our proposed approach, the related tool developed, and the experimental study performed are presented in this article together with a discussion of planned directions of future work.

JADE: A software framework for developing multi-agent applications. Lessons learned

Since a number of years agent technology is considered one of the most innovative technologies for the development of distributed software systems. While not yet a mainstream approach in software engineering at large, a lot of work on agent technology has been done, many research results and applications have been presented, and some software products exists which have moved from the research community to the industrial community. One of these is JADE, a software framework that facilitates development of interoperable intelligent multi-agent systems and that is distributed under an Open Source License. JADE is a very mature product, used by a heterogeneous community of users both in research activities and in industrial applications. This paper presents JADE and its technological components together with a discussion of the possible reasons for its success and lessons learned from the somewhat detached perspective possible nine years after its inception.

Collaboration, Process Control, and Fragility in Evolutionarily Product Development

Evolutionary development is an agile software engineering approach that embraces continuous customer collaboration to assist the construction of a gradually evolving product. Its benefits and challenges are revealed in a longitudinal study we performed of a medium-sized company's transition from a traditional plan-based software process to an evolutionary process

Towards an empirical method of efficiency testing of system parts: A methodological study

Current usability evaluation methods are essentially holistic in nature. However, engineers that apply a component-based software engineering approach might also be interested in understanding the usability of individual parts of an interactive system. This paper examines the efficiency dimension of usability by describing a method, which engineers can use to test, empirically and objectively, the physical interaction effort to operate components in a single device. The method looks at low-level events, such as button clicks, and attributes the physical effort associated with these interaction events to individual components in the system. This forms the basis for engineers to prioritise their improvement effort. The paper discusses face validity, content validity, criterion validity, and construct validity of the method. The discussion is set within the context of four usability tests, in which 40 users participated to evaluate the efficiency of four different versions of a mobile phone. The results of the study show that the method can provide a valid estimation of the physical interaction event effort users made when interacting with a specific part of a device.

Runtime Analysis and Adaptation of a Hard Real-Time Robotic Control System

The increasing complexity of technical systems often leads to problems when they are to be maintained, changed or extended. Nature inspired concepts like selfmanagement or self-organization have found their way into technical systems to overcome the complexity problems. In turn those systems exhibit beneficial self-* properties like self-optimization, self-healing or self-protection. This paper presents a software architecture for the control of parallel kinematic machines and its evolvement to a selfadaptive system that strives to optimize, protect and heal itself. A software engineering approach for the development of self-managing components is introduced that is supported by behavior validation in a specialized simulation environment. The first realization of a self-manager, responsible for the distribution of control components, is described in detail to show that self-management is feasible in robotic control. The self-manager uses formal analysis techniques during the runtime of the system to make sure it always conforms to its real-time requirements.

An application of augmented MDA for the extended healthcare enterprise

Mobile health systems extend the Enterprise Computing System (ECS) of the healthcare provider by bringing services to the patient any time and anywhere. We propose a methodology for the development of such extended ECSs which applies a model-driven design and development approach augmented with formal Validation and Verification (V&V) to address quality and correctness and to support model transformation. At the University of Twente we develop context aware m-health systems based on Body Area Networks (BANs). A set of deployed BANs are supported by a server. We refer to this distributed system as a BAN System. Development of such distributed m-health systems requires a sound software engineering approach and this is what we target with the proposed methodology. The methodology is illustrated with reference to modelling activities targeted at real implementations. BAN implementations are being trialled in a number of clinical settings including epilepsy management and management of chronic pain.

On the Use of a Reflective Architecture to Augment Database Management Systems

The Database Management System (DBMS) used to be a commodity soft- ware component, with well known standard interfaces and semantics. However, the performance and reliability expectations being placed on DBMSs have increased the demand for a variety add-ons, that augment the functionality of the database in a wide range of deployment scenarios, offering support for features such as clustering, replica- tion, and self-management, among others. A well known software engineering approach to systems with such requirements is reflection. Unfortunately, standard reflective in- terfaces in DBMSs are very limited. Some of these limitations may be circumvented by implementing reflective features as a wrapper to the DBMS server. Unfortunately, these solutions comes at the expense of a large development effort and significant per- formance penalty. In this paper we propose a general purpose DBMS reflection architecture and interface, that supports multiple extensions while, at the same time, admitting efficient imple- mentations. We illustrate the usefulness of our proposal with concrete examples, and evaluate its cost and performance under different implementation strategies.

A light-weight software engineering approach to developing small-scale information systems using .NET 2.0

Applied database management systems (DBMS) courses that require information systems projects present formidable challenges to both students and instructors. Students assume the twin responsibilities of (1) learning major theoretical concepts (e.g. the relational model, data modeling, database design, and standard structured query language (SQL)) while (2) mastering the syntax and semantics of a specific complex technology (e.g. MySQL, Oracle, MSSQL). Dealing with the project problem domain also adds to demands on student time and understanding. Consequently, instructors are increasingly challenged to organize course content, technology instruction, and project resources so that students can complete non-trivial course projects in a reasonable time frame. This tutorial will introduce a light-weight software engineering approach to guiding student project development in an introductory database management systems course. This iterative and incremental approach to database programming projects is predicated on the database application principle of firm separation of logic via the N-tier model and the software engineering tenet of well-specified requirements. Students enrolled in an introductory DBMS course follow this methodology to complete GUI client/server team projects. Database and software engineering skills and understanding developed in this course are then applied to more substantive 2- and 3-tier individual projects in an advanced DBMS course and team projects in a capstone software engineering course.

A software engineering approach for the development of heterogeneous robotic applications

One of the most evident characteristics of robotic applications is heterogeneity: large robotic projects involve many different researchers with very different programming needs and areas of research, using a variety of hardware and software that must be integrated efficiently (i.e.: with a low development cost) to construct applications that satisfy not only classic robotic requirements (fault-tolerance, real-time specifications, intensive access to hardware, etc.) but also software engineering aspects (reusability, maintainability, etc.). Most existing solutions to this problem either do not deal with such heterogeneity or do not cover specific robotic needs. In this paper we propose a framework for the integration of heterogeneous robotic software through a software engineering approach: the BABEL development system, which is aimed to cover the main phases of the application lifecycle (design, implementation, testing, and maintainance) when unavoidable heterogeneity conditions are present. The capabilities of our system are shown by its support for designing and implementing diverse real robotic applications that use several programming languages (C, C++, JAVA), execution platforms (RT-operating systems, MS-Windows, no operating system at all), communication middleware (CORBA, TCP/IP, USB), and also a variety of hardware components (Personal Computers, microcontrollers, and a wide diversity of sensor and actuator devices in mobile robots and manipulator arms).

What business process modelers can learn from programmers

For building business process models (BPM), business process analysts usually use graphical languages like BPMN or UML. One purpose of such models is to serve as a base for communication between the stakeholders in the software development process. Furthermore, modern model-centric software engineering approaches have the potential to enable the generation of software directly from the models. For these reasons, the quality of BPMs is critical for the success of software development. This raises the question, how we can benefit from well-established practices for improving the quality of software if we switch from code-centric to BPM-centric software engineering. In this article, we discuss how to apply concepts comparable to structured programming to BPMs. The main contribution is a discussion of the benefits of style checking for improving the quality of BPMs. By analyzing 285 BPMs (modeled as Event Driven Process Chains (EPC)), we found that checking restrictions for “good modeling style” has three positive effects: It can improve the quality of the BPM by substituting “bad constructs” automatically, it helps to identify erroneous models and it can make model-to-code transformations much easier.

A formal approach to model refactoring and model refinement

Model-driven engineering is an emerging software engineering approach that relies on model transformation. Typical kinds of model transformations are model refinement and model refactoring. Whenever such a transformation is applied to a consistent model, we would like to know whether the consistency is preserved by the transformation. Therefore, in this article, we formally define and explore the relation between behaviour inheritance consistency of a refined model with respect to the original model, and behaviour preservation of a refactored model with respect to the original model. As it turns out, there is a strong similarity between these notions of behaviour consistency and behaviour preservation. To illustrate this claim, we formalised the behaviour specified by UML 2.0 sequence and protocol state machine diagrams. We show how the reasoning capabilities of description logics, a decidable fragment of first-order logic, can be used in a natural way to detect behaviour inconsistencies. These reasoning capabilities can be used in exactly the same way to detect behaviour preservation violations during model refactoring. A prototype plug-in in a UML CASE tool has been developed to validate our claims.

Mapping Commonalities and Differences in Software Engineering and Graphic Design Approaches to Multimedia Systems Development

Many studies that highlight tensions between Software Engineers and Graphic Designers in Multimedia Systems Development advocate interventions based upon differences, not commonalities. Yet continuing problems with methods acceptance suggest that it may be timely to focus on what unites the two design communities as well as what divides them. In this paper we report the results of an empirical study of sixteen multimedia designers. We find that although clear and persistent differences do exist, there is evidence that the two communities are moving closer together, often in surprising ways. Our results suggest that methods need to be based upon a good understanding of commonalities (as a minimum requirement or common core) and differences (as a set of features particularly important to one or other of the communities) rather than being based upon commonalities or differences only. Our results have implications for researchers seeking to understand further the behaviour of multimedia systems designers, for method developers who need to accommodate this behaviour in a single method or methods, and for managers who must select and implement such methods.

Design Methodology of Networked Software Evolution Growth Based on Software Patterns

Recently, some new characteristics of complex networks attract the attentions of scientists in different fields, and lead to many kinds of emerging research directions. So far, most of the research work has been limited in discovery of complex network characteristics by structure analysis in large-scale software systems. This paper presents the theoretical basis, design method, algorithms and experiment results of the research. It firstly emphasizes the significance of design method of evolution growth for network topology of Object Oriented (OO) software systems, and argues that the selection and modulation of network models with various topology characteristics will bring un-ignorable effect on the process of design and implementation of OO software systems. Then we analyze the similar discipline of “negation of negation and compromise” between the evolution of network models with different topology characteristics and the development of software modelling methods. According to the analysis of the growth features of software patterns, we propose an object-oriented software network evolution growth method and its algorithms in succession. In addition, we also propose the parameter systems for OO software system metrics based on complex network theory. Based on these parameter systems, it can analyze the features of various nodes, links and local-world, modulate the network topology and guide the software metrics. All these can be helpful to the detailed design, implementation and performance analysis. Finally, we focus on the application of the evolution algorithms and demonstrate it by a case study. Comparing the results from our early experiments with methodologies in empirical software engineering, we believe that the proposed software engineering design method is a computational software engineering approach based on complex network theory. We argue that this method should be greatly beneficial for the design, implementation, modulation and metrics of functionality, structure and performance in large-scale OO software complex system.

Developing inclusive e-learning systems

The requirement for e-inclusion relates to the employment of appropriate development strategies for software applications and services so as to accomplish accessibility and increased interaction quality at deployment time. Inclusive e-learning is the outcome from the application of e-inclusion design and implementation methods in the context of e-learning systems. This paper reports consolidated development experience from the construction of the following e-learning systems: (a) training applications for hand-motor impaired users and for people with cognitive disabilities; (b) learner-adapted courseware and (c) a universally accessible educational computer game. In this context, the primary emphasis is placed on the reporting of the design and implementation aspects to accommodate the inclusive system characteristics, rather than on the typical e-learning software engineering approaches.

Towards model-driven end-user development in CALL

The purpose of this article is to introduce end-user development (EUD) processes to the CALL software development community. EUD refers to the active participation of end-users, as non-professional developers, in the software development life cycle. Unlike formal software engineering approaches, the focus in EUD on means/ends development is especially relevant to CALL application design, which traditionally suffers from idiosyncratic development efforts, minimal organisational support, and poor documentation practices. With the continued emphasis on teacher-led development in CALL, there is an urgent need to investigate appropriate frameworks, methodologies and tools that assist end-user developers to produce quality-driven, fit-for-purpose CALL applications. To this end, we promote the use of model-driven architectures (MDA) in EUD environments, and describe how MDA strategies lead to better alignment between software engineering and CALL design practices. Our discussion in this article seeks to achieve two objectives: (1) to underscore current limitations and possible future directions in CALL software development; and (2) to inform end-user developers in CALL of an appropriate and accessible software engineering framework for language learning environments.