Development Of Complex Software Systems Research Articles

Discovery learning of object-oriented modelling with exploration modules in secondary Informatics education

Discovery learning is very desirable not only in secondary education, because it prepares learners for life-long learning. Within secondary Informatics education in Germany, pupils often acquire many concepts by learning to program. To be able to model, to design and to evaluate own solutions, learners must acquire many details of a programming language and apply complex software development environments. So a lot of time gets lost for important topics, like the working principles of Informatics systems. The research presented here focuses on learning by exploration instead. The basic idea is that before developing own (typically small) solutions, learners explore medium size solutions by means of special learner-adequate Informatics systems, named exploration modules (EMs) here. In this paper, the author presents important aspects of the development methodology of such software, its application to the educational field of object-oriented modelling and shows how EM prototypes have successfully been included in different learning scenarios of secondary Informatics education, Informatics teacher education, and in-service Informatics teacher training within the academic years 2001 to 2004.

The golden age of software architecture

Since the late 1980s, software architecture has emerged as the principled understanding of the large-scale structures of software systems. From its roots in qualitative descriptions of empirically observed useful system organizations, software architecture has matured to encompass a broad set of notations, tools, and analysis techniques. Whereas initially the research area interpreted software practice, it now offers concrete guidance for complex software design and development. It has made the transition from basic research to an essential element of software system design and construction. This retrospective examines software architecture's growth in the context of a technology maturation model, matching its significant accomplishments to the model's stages to gain perspective on where the field stands today. This trajectory has taken architecture to its golden age.

Research on Generic Adaptive Software Architecture Style

The generic adaptive software architecture style is studied. Through the analysis of the basic characteristics of adaptive software architecture, the generic framework for adaptive software architecture is extracted. The integrated reference model of adaptive software architecture (ASA-IRM) is proposed based on multiview modelling theory. The rules of model mapping and evolution in ASA-IRM are discussed. The algorithm of model mapping consistency is proposed based on metamodelling and graph transformation theories. Finally, an integrated support environment for ASA-IRM is developed. The adaptive software architecture can be used in the development of complex software system, especially in open, networked environment.

MANAGING CRITICAL KNOWLEDGE MANAGEMENT ISSUES IN GLOBAL SOFTWARE DEVELOPMENT PROJECTS

Software development is a complex, knowledgeintensive, and innovative process that frequently takes place in an extremely competitive and highly uncertain environment. For a long time, software developers have used traditional-structured approaches that are more disciplined and focus on coordinated actions to ensure the software goals are met. Recently, this traditional way of software development has faced challenges by an alternative approach, namely, Agile Method. The essences of Agile Method basically include the incorporation of autonomy into software development to nurture the creativity and resourcefulness of developers. In this paper, we identify the critical knowledge management (KM) issues currently arising in many global software development projects and the methods for their management. We also present a framework for the adoption of an agile method to manage complex software development projects in a global environment. This framework can be characterized as ‘Discipline at the Global Level, Be Agile at the Local Level.’

Should wildlife biologists use free software?

As wildlife scientists and professionals, most of us rely oncomputer software in our daily work. We invest a large pro-portion of our time in learning how to use different kinds ofsoftware effectively to do our jobs. Choosing which soft-ware to learn in the first place is therefore an importantlong-term decision. Many of us rely on commercial soft-ware such as Word, Excel, Outlook and SPSS or SAS whenwe analyse data, correspond with our colleagues by e-mail,and write papers.In this paper, we will briefly discuss some importantaspects of commercial software in general. More impor-tantly, we will introduce the reader to a specific alternativeto commercial software known as free software. Our im-pression is that the awareness of this phenomenon is muchsmaller among biologists than in other fields of science suchas mathematics, statistics, physics, and engineering. Freesoftware is software which is distributed freely, typicallyover the Internet, under a licence known as the GNU Gen-eral Public Licence (GPL) (Free Software Foundation, Inc.,1991). Like commercial software licenses, this licence re-lies on standard copyright law. The important difference isthat the recipient of the software is granted a number of ad-ditional rights by the copyright holder which permits the re-cipient of the software to make changes to the source code,provided that any modified version of the source code isalso made freely available under the the same license. Thiscontract therefore guarantees that any improvement made tothe software becomes freely available to the software’s ini-tial author. This potential reward becomes one of the mainmotivations for releasing the software as free software inthe first place.This licencing regime has dramatic consequences on theeffectiveness of the software development process. To un-derstand why, we need to understand approximately howthe process of complex software development typicallyworks in general. When an architect designs a new building,almost all the details of the design are typically completedbefore any building work is initiated. A common miscon-ception about software development is that software is de-signed in a way similar to this. In reality, however, mostsoftware, both commercial and free changes through grad-ual small incremental modifications of the source code afterreaching a certain level of complexity. Complex software is

Managing the Inconsistency of Software Requirements

Analyzing and handling the inconsistency in requirements is critical to the development of complex software systems. How to solve this problem directly influences the quality of requirements specification, as well as the final software production. Based on a common-recognized management framework of requirements inconsistency, this paper summarizes representative researches on this topic. The main aim is to get a comprehensive understanding of the current techniques and methods of inconsistency management. Finally, the paper also identifies some issues which are still open to further research.

An Experiential Case Study in IT Project Management Planning

The case covers key issues in information technology project management. It deals with developing a full set of project plans, including milestones, tasks, schedules, staffing, deliverables, and projected costs, for a complex software development project (Gido & Clements, 2003; Kerzner, 2003; Schwalbe, 2002). The essence of this case is the analyzing of a specific organizational setting with critical software needs and the developing of the needed plans. As in many similar situations, this organization is relatively complex, and the situation is not entirely clear. By reviewing the facts of the case, collecting outside information, conducting role playing interviews, analyzing requirements, and estimating schedules and costs, one can collect the information needed to develop baseline project plans for the software development envisioned in this case.

π-ARL

A key aspect of the formal development of any software system is the specification and stepwise refinement of its architecture. In a stepwise refinement, a sequence of steps starting from an abstract specification of the architecture leads to a concrete, implementation-centered, architectural model. Each refinement step typically leads to a more detailed architecture description that increases the determinism while implying properties of the abstract specification. Enabling stepwise architecture refinement is a new challenge for the formal development of complex software systems. This article describes π-ARL, a novel Architecture Refinement Language (ARL) that has been designed in the ArchWare European Project to address formal refinement of software architectures. It is a formal, well-founded theoretically language based on a rewriting logic. Its underlying approach for architecture refinement is underspecification, i.e. at a high-level of abstraction, when specifying an architectural element, certain aspects can be left open. The decrease of this underspecification establishes behaviour but also port, structure, and data refinement relations. The underlying foundation for architected behaviours is the higher order typed π-calculus. π-ARL focuses on formally modelling the stepwise refinement of software architectures through a set of architecture refinement primitives.

Formally refining software architectures with π-ARL

π-ARL is a formal (executable) architecture refinement language providing architecture-centric refinement primitives and constructs for their compositions. When applied, refinement actions expressed in π-ARL refine architectural models described in π-ADL outputting new refined models described in π-ADL. Enabling stepwise architecture refinement is a new challenge for the formal development of complex software systems. This article presents a simple but realistic case study of the use of π-ARL for architecture refinement. It illustrates the expressiveness and usefulness of π-ARL. The case study addresses the modelling and refinement of the software architecture of a Data Acquisition System. It covers a simple, yet frequent, architecture refinement that would be problematic for most other refinement techniques. Several refinement steps are performed, each dealing with a simple refinement, in order to achieve a concrete architecture.

Free and open source development practices in the game community

The free and open source software (FOSS) approach lets community of like-minded participants develop software systems and related artifacts that are shared freely instead of offered as closed-source commercial products. Free (as in freedom) software and open source are closely related but slightly different approaches and licensing schemes for developing publicly shared software. FOSS development communities don't seem to adopt modern software engineering processes. FOSS communities develop software that's extremely valuable, generally reliable, globally distributed, made available for acquisition at little or no cost, and readily used in its community. Free and open source software development practices gives rise to new view of how complex software systems can be constructed, deployed, and evolved. They rely on lean electronic communication media, virtual project management, and version management mechanisms to coordinate globally dispersed development efforts. These FOSS processes offer new directions for developing complex software systems. We look at the FOSS computer game community to provide examples of common development processes and practices.

Supporting risks in software project management

Complex software development is a risky job. The number of unsuccessful projects surpasses the number of successful developments, particularly when large projects are analyzed. This paper describes an approach to develop, retrieve, and reuse management knowledge and experience concerned with software development risks. Scenarios are used to model risk impact and resolution strategies efficacy within risk archetypes. A risk archetype is an information structure that holds knowledge about software development risks. A risk management process organizes the use of risk archetypes within an application development effort. The process resembles a reuse process framework, where two sub-processes are respectively responsible for identifying and reusing risk information. Simulating the impact of the expected risks can support some of the decisions throughout the software development process. The contribution of this paper is to show how risk archetypes and scenario models can represent reusable project management knowledge. An observational analysis of applying such an approach in an industrial environment and a feasibility study are also described.

COSA ? A generic cognitive system architecture based on a cognitive model of human behavior

This article presents an overview of COSA, a cognitive system architecture, which is a generic framework proposing a unified architecture for cognitive systems. Conventional automation and similar systems lack the ability of cooperation and cognition, leading to serious deficiencies when acting in complex environments, especially in the context of human-computer interaction. Cognitive systems based on cognitive automation can overcome these deficiencies. Designing such artificial cognitive systems can be considered a very complex software development process. Although a number of developments of artificial cognitive systems have already demonstrated great functional potentials in field tests, the engineering approach of this kind of software is still a candidate for further improvement. Therefore, wide-spread application of cognitive systems has not been achieved yet. This article presents a new engineering approach for cognitive systems, implemented by the COSA framework, which may be a crucial step forward to achieve a wide-spread application of cognitive systems. The approach is based on a new concept of generating cognitive behaviour, the cognitive process (CP). The CP can be regarded as a model of the human information processing loop whose behaviour is solely driven by "a-priori knowledge". The main features of COSA are the implementation of the CP as its kernel and the separation of architecture from application leading to reduced development time and increased knowledge reuse. Additionally, separating the knowledge modelling process from behaviour generation enables the knowledge designer to use the knowledge representation that is best suited to his modelling problem. A first application based on COSA implements an autonomous unmanned air vehicle accomplishing a military reconnaissance mission. Some of the application experiences with the new approach are presented.

ADK: An Agent Development Kit Based on a Formal Design Model for Multi-Agent Systems

The advent of multi-agent systems has brought us opportunities for the development of complex software that will serve as the infrastructure for advanced distributed applications. During the past decade, there have been many agent architectures proposed for implementing agent-based systems, and also a few efforts to formally specify agent behaviors. However, research on narrowing the gap between agent formal models and agent implementation is rare. In this paper, we propose a model-based approach to designing and implementing intelligent agents for multi-agent systems (MAS). Instead of using formal methods for the purpose of specifying agent behavior, we bring formal methods into the design phase of the agent development life cycle. Specifically, we use the formalism called agent-oriented G-net model, which is based on the G-net formalism (a type of high-level Petri net), to serve as the high-level design for intelligent agents. Based on the high-level design, we further derived the agent architecture and the detailed design for agent implementation. To demonstrate the feasibility of our approach, we developed the toolkit called ADK (Agent Development Kit) that supports rapid development of intelligent agents for multi-agent systems and we discuss the role of inheritance in agent-oriented development. As a potential solution for automated software development, we summarize the procedure to generate a model-based design of application-specific agents. Finally, to illustrate an application built on ADK, we present an air-ticket trading example.

A Framework and Architecture for Multi-Robot Coordination

In this paper, we present a framework and the software architecture for the deployment of multiple autonomous robots in an unstructured and unknown environment, with applications ranging from scouting and reconnaissance, to search and rescue, to manipulation tasks, to cooperative localization and mapping, and formation control. Our software framework allows a modular and hierarchical approach to programming deliberative and reactive behaviors in autonomous operation. Formal definitions for sequential composition, hierarchical composition, and parallel composition allow the bottom-up development of complex software systems. We demonstrate the algorithms and software on an experimental testbed that involves a group of carlike robots, each using a single omnidirectional camera as a sensor without explicit use of odometry.

A Framework and Architecture for Multi-Robot Coordination

In this paper, we present a framework and the software architecture for the deployment of multiple autonomous robots in an unstructured and unknown environment, with applications ranging from scouting and reconnaissance, to search and rescue, to manipulation tasks, to cooperative localization and mapping, and formation control. Our software framework allows a modular and hierarchical approach to programming deliberative and reactive behaviors in autonomous operation. Formal definitions for sequential composition, hierarchical composition, and parallel composition allow the bottom-up development of complex software systems. We demonstrate the algorithms and software on an experimental testbed that involves a group of carlike robots, each using a single omnidirectional camera as a sensor without explicit use of odometry.

PRIMA-UML: a performance validation incremental methodology on early UML diagrams

The development of complex software systems satisfying performance requirements is achievable only spending careful attention to performance goals throughout the lifecycle, and especially from its very beginning. Unified modeling language (UML) is quickly becoming a standard notation for specification and design of software systems. UML offers several diagrams for separating concerns of different system views, and this feature is helpful to derive early performance models that take into account combined data from these diagrams. In this paper, we introduce a methodology Performance Incremental Validation in UML (PRIMA-UML) aimed at generating a queueing network based performance model from UML diagrams that are usually available early in the software lifecycle. PRIMA-UML is incremental in that it combines information extracted from (and annotated into) different UML diagrams to piecewise build the performance model. Besides, this is not a “black box” approach, as the methodology is open to embed information coming from other UML diagrams (possibly in late lifecycle phases) for detailing, refining or domain tailoring the performance model. This work is a contribute to encompass the performance validation task as an integrated activity within the development process of complex systems. We apply the methodology to a quite simple example to show how effective it can be to get early performance insights.

Anomaly detection in concurrent Java programs using dynamic data flow analysis

Concurrency constructs are widely used when developing complex software such as real-time, networking and multithreaded client–server applications. Consequently, testing a program, which includes concurrency constructs is a very elaborate and complex process. In this work, we first identify the different classes of synchronization anomalies that may occur in concurrent Java programs. We then consider testing concurrent Java programs against synchronization anomalies using dynamic data flow analysis techniques. Moreover, we show how the data flow analysis technique can be extended to detect such anomalies.

A notation for problematic architecture interactions

The progression of component-based software engineering (CBSE) is essential to the rapid, cost-effective development of complex software systems. Given the choice of well-tested components, CBSE affords reusability and increases reliability. However, applications developed according to this practice can often suffer from difficult maintenance and control, problems that stem from improper or inadequate integrate solutions. Avoiding such unfortunate results requires knowledge of what causes the interoperability problems in the first place. The time for this assessment is during application design. In this paper, we define problematic architecture interactions using a simple notation with extendable properties. Furthermore, we delineate a multi-phase process for pre-integration analysis that relies on this notation. Through this effort, potential problematic architecture interactions can be illuminated and used to form the initial requirements of an integration architecture.

Fundamental concepts for practical software architecture

Architecture of software is a collection of design decisions that are expensive to change. How to identify which design decisions are expensive to change? What are architecture views and which views are needed to adequately describe the architecture of a specific system? How to create and manage software architecture for a product family? This tutorial offers answers to these and other questions that arise in the context of complex software development. We introduce a system of concepts useful in order to understand, design, and evaluate architecture of software intensive systems and system families. Our approach utilizes different software structures in order to control important system qualities related to its development, performance, and evolution. We draw our experience primarily from software embedded in voice and data communication systems. However the same principles can be applied to software architecture in other domains. This tutorial should be useful to engineers and technical managers involved in construction or evaluation of complex software.

On optimizing the satisfiability (SAT) problem

Most robotic systems tend to be complex to maintain and reuse because existing frameworks are based mainly on code-driven approaches. This means the software development process is reduced to the implementation of systems using specific programming languages. During the constant evolution, the systems grow in size and in complexity. Even when these approaches address the needs of robotic focused markets, currently used methodologies and toolsets fail to cope with the needs of such complex software development process. The general objective of our work is the definition of a methodological framework supported by a set of tools to deal with the requirements of the robotic software development process. A major challenge is to make the step from code-driven to model-driven in the development of robotic software systems. Separating robotics knowledge from short-cycled implementation technologies is essential to foster reuse and maintenance.