Software function allocation methodology

One of the challenges of distributed computer systems is the effective allocation of software system functions among the hardware components of the distributed system. Software function allocation methodology (SFAM) provides computer software system designers with a thorough and flexible method to allocate software system functions among the hardware components of a distributed computer system. Software designers select and rank relevant design parameters, analyse how well different distributed computer system components meet the chosen parameters, and allocate the software function accordingly. The paper defines the problem, covers necessary terminology, and discusses the current state of research. The preconditions necessary for an analysis using SFAM are covered along with the environment in which SFAM should be used. Details of SFAM components are discussed. A complete outline of the SFAM methodology is provided, along with discussion of key points and frequent examples.     

RMS design methodology for automotive framing systems BIW

Today, markets increasingly require more customized products, with shorter life cycles. In response, manufacturing systems have evolved from mass production techniques, through flexible automation and mass customization, to produce at mass production costs. Manufacturing facilities must incorporate more flexibility and intelligence, evolving toward reconfigurable manufacturing systems (RMS). RMS are amid to posses such flexibility and responsiveness and said to be the next generation of world class systems. RMS are designed for rapid change in structure and for a quickly adjustable production capacity. This paper proposes a new methodology (high level process) of framework using flexible and reconfigurable manufacturing systems principles for automotive framing systems as well as to provide a guideline to support the structure of different stages of the design methodology. The proposed methodology is presented through a case study using data based on actual production systems of three different styles; (process and design data) which supports the hypothesis of the research.     

The distributed programming language SR—Mechanisms,design and implementation

SR is a new language for programming software containing many processes that execute in parallel. The language allows an entire software system that controls a potentially large collection of processors to be programmed as an integrated set of software modules. The key language mechanisms are resources, operations and input statements. The language supports separate compilation, type abstraction, and dynamic communication links; it also contains novel treatments of arrays and procedures. This paper gives an overview of the language mechanisms, discusses some of the major design decisions and describes one implementation.     

A behavioral analysis and verification approach to pattern-based design composition

Integrating software components to produce large-scale software systems is an effective way to reuse experience and reduce cost. However, unexpected interactions among components when integrated into software systems are often the cause of failures. Discovering these composition errors early in the development process could lower the cost and effort in fixing them. This paper introduces a rigorous analysis approach to software design composition based on automated verification techniques. We show how to represent, instantiate and integrate design components, and how to find design composition errors using model checking techniques. We illustrate our approach with a Web-based hypermedia case study.     

Self-healing systems — survey and synthesis

As modern software-based systems and applications gain in versatility and functionality, the ability to manage inconsistent resources and service disparate user requirements becomes increasingly imperative. Furthermore, as systems increase in complexity, rectification of system faults and recovery from malicious attacks become more difficult, labor-intensive, expensive, and error-prone. These factors have actuated research dealing with the concept of self-healing systems. Self-healing systems attempt to “heal” themselves in the sense of recovering from faults and regaining normative performance levels independently the concept derives from the manner in which a biological system heals a wound. Such systems employ models, whether external or internal, to monitor system behavior and use inputs obtaining therefore to adapt themselves to the run-time environment. Researchers have approached this concept from several different angles this paper surveys research in this field and proposes a strategy of synthesis and classification.     

FlexiFrag: A design pattern for flexible file sharing in distributed collaborative applications

The need for flexible file sharing in distributed systems is increasing in applications such as calendar management, collaborative editing of documents, collaborative software developments etc. The file sharing policies required in these applications are often very different from the traditional read/write policies. Hence, a flexible way of specifying and implementing sharing policies on individual files in file systems is required. We propose a distributed object-based system model of constructing file systems. The object-based system model is based on a pattern called FlexiFrag. We show how a distributed object-based system and in particular distributed file system can be constructed using the pattern in a flexible way.     

An empirical study on students’ ability to comprehend design patterns

Design patterns have become a widely acknowledged software engineering practice and therefore have been incorporated in the curricula of most computer science departments. This paper presents an observational study on students’ ability to understand and apply design patterns. Within the context of a postgraduate software engineering course, students had to deliver two versions of a software system; one without and one with design patterns. The former served as a poorly designed system suffering from architectural problems, while the latter served as an improved system where design problems had been solved by appropriate patterns. The experiment allowed the quantitative evaluation of students’ preference to patterns. Moreover, it was possible to assess students’ ability in relating design problems with patterns and interpreting the impact of patterns on software metrics. The overall goal was to empirically identify ways in which a course on design patterns could be improved.     

Soft systems methodology to information systems: a Wittgensteinian approach

Abstract. A logical foundation for information system design requires a theory of meaning. Ideational theories attach meaning to the ideas in the private world of a conscious subject. By contrast Wittgenstein held that language and meaning were primarily public and that a private, purely subjective, language was impossible. The iterative debate among stake-holders that takes place in the practice of soft systems methodology (SSM) can be understood as a Wittgensteinian language game in which meaning is created not just discovered. The conceptual models used in SSM can be developed into logico-linguistic models which express stipulative definitions. These definitions can be taken as a logical basis for information system design.     

Human aspects in object-oriented design: an assessment and a methodology

Abstract

Object-oriented design has attractive features, but using an object-oriented technique does not necessarily guarantee a good design. In this paper an assessment is made which is concerned with human aspects in object-oriented design. Particularly, the important role of user's mental models in object-oriented design is emphasized. The relationship between analogical reasoning and software reuse is examined. To support the assessment in regard to human aspects, some methodological considerations are outlined, which are further examined through case studies.     

Human aspects in object-oriented design: an assessment and a methodology

Object-oriented design has attractive features, but using an object-oriented technique does not necessarily guarantee a good design. In this paper an assessment is made which is concerned with human aspects in object-oriented design. Particularly, the important role of user's mental models in object-oriented design is emphasized. The relationship between analogical reasoning and software reuse is examined. To support the assessment in regard to human aspects, some methodological considerations are outlined, which are further examined through case studies.     

Modal approximation of xenon oscillations in nuclear reactors — an FEM-based approach

A modal expansion method for modelling dynamic space-dependent effects (xenon oscillations) in large nuclear reactors is presented. Based on the finite element method (FEM), modal expansion functions for various cases with practical significance can be calculated. In this way it is possible to derive a low order state space model describing the considered effect. The use of this model in on-line controller design and simulation is intended. Modal methods in connection with modern numerical algorithms turned out to be effective to treat distributed parameter systems governed by elliptic differential equations. This will be demonstrated by application to a VVER-1000 pressurized water reactor.     

Development and analysis — an intergrated approach

Due to the growing complexity and size of software systems, the development of correct and easy to maintain software has become more and more of a problem. This is especially true for distributed systems with real-time requirements. Therefore, great efforts have been made to overcome this problem. However, most approaches either do not consider every aspect of interest or are restricted to only one development phase. This paper describes OASIS, an open environment, that allows the integration of different analysis techniques in different system development phases, and presents the existing OASIS-toolset, that is already incorporated in this environment.     

Design for adaptability (DFAD)—a new concept for achieving sustainable design

This paper discusses the concepts associated with a new methodology, design for adaptation (DFAD), under development for achieving advanced sustainable designs. The DFAD methodology concept is based on the hypothesis that product life ends because a product is unable to adapt to change. A product may be retired for myriad reasons including that it is broken, out of style, or has become inefficient due to technology obsolescence. In these cases, the product was not able to adapt to change—it was unable to self-heal, it could not modify or reconfigure to meet changing fashion needs, or it could not be upgraded, for physical or economic reasons, to utilize new technology. To address these and similar issues, we are developing the DFAD methodology. DFAD is based on classical control theory and products are conceptualized and modeled as dynamic systems with feedback control strategies to respond, or adapt, effectively to changes in product performance criteria. The DFAD concept takes into account that changing performance requirements may be based on physical, cultural, environmental, and/or economic considerations, among others.     

DisCComp – A Formal Model for Distributed Concurrent Components

Most large-scaled software systems are structured in distributed components to manage complexity and have to cope with concurrent executed threads. System decomposition and concurrent flow of execution are orthogonal. A sound semantic model that is powerful enough to handle distributed concurrent components but also realistic enough to provide a foundation for component technologies actually in use is still missing. Therefore, the paper introduces such an operational semantics for distributed concurrent component-based systems. Based on this formal model, UML-based modeling techniques are introduced. Tool support for modeling, code generation, and system execution is provided.     

The design and use of the TMiner component-based data mining framework

This paper provides some practical guidelines for the design of data mining frameworks. It describes the rationale behind some of the key design decisions that guided the design, development, and implementation of the TMiner component-based data mining framework. TMiner is a flexible framework that can be used as a stand-alone tool or integrated into larger business intelligence (BI) solutions. TMiner is a general-purpose component-based system designed to support the whole KDD process into a single framework and thus facilitate the implementation of complex data mining scenarios.     

Efficient implementation of constrained min–max model predictive control with bounded uncertainties: a vertex rejection approach

Min–Max Model Predictive Control (MMMPC) is one of the strategies used to control plants subject to bounded additive uncertainties. The implementation of MMMPC suffers a large computational burden due to the NP-hard optimization problem that has to be solved at every sampling time. This paper shows how to overcome this by transforming the original problem into a reduced min–max problem in which the number of extreme uncertainty realizations to be considered is significantly lowered. Thus, the solution is much simpler. In this way, the range of processes to which MMMPC can be applied is considerably broadened. A simulation example is given in the paper.     

Why Aspect-Oriented Software Development And Model-Driven Development Are Not The Same – A Position Paper –

Aspect-Oriented Software Development (AOSD) and Model-Driven Development (MDD) are often said to be alike since both approaches are based on the selection of elements (i.e. join points in AOSD and model elements in MDD) and their subsequent adaptation (i.e. weaving in AOSD and transformation in MDD). But does this mean that AOSD and MDD are in fact two words for pretty much the same thing? In this position paper, we argue that there are essential differences between the aspect-oriented and the model-driven approach.