This paper deals with the problem of evaluating and testing recovery and adaptation frameworks (RAF) for distributed software systems. We present TESS, a testbed for automatically generating distributed software architectures and their corresponding runtime applications, deploying them to the nodes of a cluster, running many different types of experiments involving failures and adaptation, and collecting in a database the values of a variety of failure recovery and adaptation metrics. Using the collected data, TESS automatically performs a thorough and scientific analysis of the efficiency and/or effectiveness of a RAF.This paper presents a case study on the use of TESS to evaluate DARE, a RAF developed by our group.

This paper describes the design of secure connectors that are used in the design of secure software architectures for distributed business applications. Mixing security concerns with business concerns in software architectures makes applications more complex. With the goal of making secure software architectures more maintainable and evolvable, the secure connectors proposed in this paper are designed separately from business application components by considering different communication patterns between the components as well as security services required by application components. Each secure connector encapsulates security relevant objects to provide application components with security services. In this paper, secure connectors are applied to design the software architectures of electronic commerce and automated teller machine applications.

This paper describes a preliminary investigation into the effect of multicore technology on the performance of real-time systems. In particular, it investigates the impact of varying the number of cores on multitasking performance and on different task configurations. Experimental results are presented for a real-time game application executing with several different hardware and software configurations.

This paper describes an architecture-based dynamic adaptation model and framework for adaptive software systems. The framework provides for a reusable adaptation infrastructure and uses a layered architecture pattern. It also provides separation of concerns from the system's software architecture and supports internal state information checkpointing and restoration. Any dynamic software adaptation process, whether instigated internally or externally, makes runtime changes only to affected components. The dynamic adaptation model separates adaptation-impacted parts of a system from those that need not be concerned with the dynamic adaptation.

Service Oriented Architecture (SOA) has emerged as a model for distributed computing that promotes flexible deployment and reuse. Software product lines (SPL) promote reusable development for product families. SOA systems need the capability of managing variability to address different client requirements. Our approach uses SPL concepts to model SOA systems as service families. SPL development relies on feature models to describe the commonality and variability of member applications. We introduce a multiple view SOA variability model based on feature modeling, which is described in UML and SoaML, the newly released SOA standard. Such a framework facilitates variability modeling of service families in a systematic and platform independent way.

Service Oriented Architecture (SOA) has emerged as a paradigm for distributed computing that promotes flexible deployment and reuse. A software product line (SPL) is a family of software systems that have some common functionality and some variable functionality. During application derivation, the common functionality is reused and a selection is made among the variable functionality. The challenge in SPL is to manage variability among the SPL members -- feature modeling is frequently used for this purpose. SOA systems currently lack a systematic approach for managing variability in service requirements. The approach described in this paper addresses this problem by applying SPL concepts to model SOA systems as service families. In this paper, we describe how to model variability in the architectural views of a multiple-view SOA variability model. The approach integrates feature modeling with service views using UML and SoaML, the newly released SOA standard. Such a framework facilitates variability modeling of service family architectures in a systematic and platform independent way.

This paper describes the advances in software design methods for concurrent, real-time and distributed applications from structured methods for centralized systems to distributed, object-oriented, component-based and service-oriented systems and product lines. The influence of software architectural and design patterns is also described. Current challenges for designing service-oriented architectures, adaptive software design, and evolutionary software design are also discussed.

This paper describes an integrated approach for the design and subsequent behavioral analysis of concurrent software designs for embedded systems. The approach integrates software design using the COMET concurrent object-oriented design method, colored Petri net (CPN) modeling, and performance measurement of the target system. The approach combines information from platform-independent and platform-specific models to construct analyses of software architectures for embedded systems. It allows an engineer/analyst to examine behavioral and performance properties of a software architecture design paired with a candidate implementation architecture. Applying the behavioral design patterns in the UML-based design along with corresponding CPN templates, the results from the analyses can be directly mapped back to the original design artifacts. The approach is illustrated using a robot controller case study

In many software development projects, performance requirements are not addressed until after the application is developed or deployed, resulting in costly changes to the software or the acquisition of expensive high-performance hardware. To remedy this, researchers have developed model-driven performance analysis techniques for assessing how well performance requirements are being satisfied early in the software lifecycle. In some cases, companies may not have the expertise to perform such analysis on their software; therefore they have an independent assessor perform the analysis. This paper describes an approach for conducting independent model-driven software performance assessments of UML 2.0 designs and illustrates this approach using a real-time signal generator as a case study

This paper describes a case study of a model driven development approach for software product lines based on Web Services. Feature selection drives the dynamic customization of the product line architecture and implementation to derive the application. During product line modeling, features and their dependencies are described in a feature model. During application engineering, features are selected by the application engineer and used to dynamically customize the product line architecture and implementation. A Radio Frequency Management product line is used to illustrate the approach.

Object-oriented concepts are crucial in software design because they address fundamental issues of adaptation and evolution. With the proliferation of object-oriented notations and methods, the Unified Modeling Language (UML) has emerged to provide a standardized notation for describing object-oriented models. However, for the UML notation to be effectively applied, it needs to be used with an object-oriented analysis and design method. This tutorial describes the COMET method for designing real-time and distributed applications, which integrates object-oriented and concurrency concepts and uses UML.

The research field of Intelligent Service Robots, which has become more and more popular over the last years, covers a wide range of applications from climbing machines for cleaning large storefronts to robotic assistance for disabled or elderly people. When developing service robot software, it is a challenging problem to design the robot architecture by carefully considering user needs and requirements, implement robot application components based on the architecture, and integrate these components in a systematic and comprehensive way for maintainability and reusability. Furthermore, it becomes more difficult to communicate among development teams and with others when many engineers from different teams participate in developing the service robot. To solve these problems, we applied the COMET design method, which uses the industry-standard UML notation, to developing the software of an intelligent service robot for the elderly, called T-Rot, under development at Center for Intelligent Robotics (CIR). In this paper, we discuss our experiences with the project in which we successfully addressed these problems and developed the autonomous navigation system of the robot with the COMET/UML method.

Object-oriented software development practices are being rapidly adopted within increasingly complex systems, including reactive, real-time and concurrent system applications. While data modeling is performed very well under current object-oriented development practices, behavioral modeling necessary to capture critical information in real-time, reactive, and concurrent systems is often lacking. Addressing this deficiency, we offer an approach for modeling and analyzing concurrent object-oriented software designs through the use of behavioral design patterns, allowing us to map stereotyped UML objects to colored Petri net (CPN) representations in the form of reusable templates. The resulting CPNs are then used to model and analyze behavioral properties of the software architecture, applying the results of the analysis to the original software design.

Object-oriented software development practices are being rapidly adopted within increasingly complex systems, including reactive, real-time and concurrent system applications. While data modeling is performed very well under current object-oriented development practices, behavioral modeling necessary to capture critical information in real-time, reactive, and concurrent systems is often lacking. Addressing this deficiency, we offer an approach for modeling and analyzing concurrent object-oriented software designs through the use of behavioral patterns captured through colored Petri nets

This tutorial addresses how to develop objectoriented requirements, analysis, and design models of software product lines using the Unified Modeling Language (UML) 2.0 notation.

Summary form only given. A software product line consists of a family of software systems that have some common functionality and some variable functionality. A better understanding of the product line can be obtained by considering the different perspectives, such as requirements modeling, static modeling, and dynamic modeling. This paper describes a multiple view UML based product line modeling approach for modeling software product lines based on Web services.

This paper describes how to model complex applications by modelling application requirements and designs separately from security requirements and designs using the UML notation. By careful separation of concerns, the security requirements are captured in security use cases and encapsulated in security objects separately from the application requirements and objects. The approach reduces system complexity caused by mixing security requirements with business application requirements with the goal of making complex systems more maintainable. Furthermore, the security use cases and objects can be reused by other software applications.

A software reconfiguration pattern is a solution to a problem in component-based software systems where the configuration needs to be updated while the system is operational. It defines how a set of components participating in a software pattern cooperate to change the configuration. This paper describes an approach for designing software reconfiguration patterns. It also describes how reconfiguration patterns can be used in reconfigurable software product line architectures. A change management model for dynamically evolving a software product line is also described. The paper concludes with a description of case studies and a proof-of-concept prototype.

To address behavioral modeling issues specific to concurrent software architectures, this paper outlines an approach for systematically modeling behavioral patterns found in concurrent software designs by applying colored Petri net (CPN) templates with UML artifacts. In this approach, CPNs are used as an underlying representation of the dynamic object-oriented architecture. These CPNs are then used to provide a simulated functional flow of the architecture and to analyze the concurrent behavior. By applying the results from the CPN analysis to the original UML model, an engineer can enhance the quality of the design and thereby gain additional insight to the behavioral properties of the software design prior to implementation.

This paper describes a multiple-view meta-modeling approach for software product lines using the Unified Modeling Language notation (UML). A multiple-view model for a software product line is an object-oriented domain model which defines the different aspects of a software product line, namely the use case model, static model, collaboration model, statechart model, and feature model, including the commonality and variability. The meta-model depicts life cycle phases, views within each phase, and meta-classes within each view. The relationships between the different views are described. Consistency checking rules are defined based on the relationships among meta-classes in the meta-model. Finally, tool support for the approach is described.

This paper describes a knowledge-based approach to automate a software design method for concurrent systems. The approach uses multiple paradigms to represent knowledge embedded in the design method. Semantic data modeling provides the means to represent concepts from a behavioral modeling technique, called Concurrent Object-Based Real-time Analysis (COBRA), which defines system behavior using data/control flow diagrams. Entity-relationship modeling is used to represent a design metamodel based on a design method, called COncurrent Design Approach for Real-Time Systems (CODARTS), which represents concurrent designs as software architecture diagrams, task behavior specifications and module specifications. Production rules provide the mechanism for codifying a set of CODARTS heuristics that can generate concurrent designs based on semantic concepts included in COBRA behavioral models and on entities and relationships included in CODARTS design metamodels. Together, the semantic data model, the entity-relationship model, and the production rules, when encoded using an expert system shell, compose CODA, an automated designer's assistant. CODA is applied to generate 10 concurrent designs for four real-time problems. The paper reports the degree of automation achieved by CODA. The paper also evaluates the quality of generated designs by comparing the similarity between designs produced by CODA and human designs reported in the literature for the same problems. In addition, it compares CODA with four other approaches used to automate software design methods.

The paper presents a novel application involving two important software engineering research areas: process modeling and software reuse. The Spiral Model is a risk-driven process model, which, depending on the specific risks associated with a given project, may be tailored to create a project-specific process model. The software reuse area is that of domain modeling of families of systems, which capture the similarities and variations among the members of the family. The domain modeling approach is used to create a domain model of a Spiral Process Model (SPM), thereby capturing the similarities and variations among a family of process models. The SPM domain model has been extended to capture the key process areas of the Software Engineering Institute's Capability Maturity Model (CMM). The domain model is used to generate project-specific process models. This approach allows managers to configure and reuse process models that manage the risks associated with new software development.

An application domain is defined as a family of systems that have some features in common and others that differentiate them. A domain model is a multiple view object oriented analysis model for the application domain that reflects the common aspects and variations among the members of the family of systems that constitute the domain. The paper describes the integration of the domain modeling method for analyzing and modeling families of software systems with the SOFL formal specification language. Aggregation hierarchies and generalization/specialization hierarchies are depicted using the UML static modeling notation. Object communication diagrams are depicted using the SOFL condition data flow diagram notation. SOFL is used for the formal specification of the kernel, optional and variant classes.

Object-oriented concepts are crucial in software design because they address fundamental issues of adaptation and evolution. With the proliferation of object-oriented notations and methods, the Unified Modeling Language (UML) has emerged to provide a standardized notation for describing object-oriented models. However, for the UML notation to be effectively applied, it needs to be used with an object-oriented analysis and design method. This tutorial describes the COMET method for designing real-time and distributed applications, which integrates OO and concurrency concepts and uses the UML notation.

Software designers use visual models, such as data flow/control flow diagrams or object collaboration diagrams, to express system behavior in a form that can be understood easily by users and by pogrammers, and from which designers can generate a software architecture. The research described in this paper is motivated by a desire to provide an automated designer's assistant that can generate software architectures for concurrent systems directly from behavioral models expressed visually as flow diagrams. To achieve this goal, an automated designer's assistant must be capable of interpreting flow diagrams in semantic, rather than syntactic, terms. While semantic concepts can be attached manually to diagrams using labels, such as stereotypes in the Unified Model Language (UML), this paper considers the possibility of providing autmated assistance to infer appropriate tags for symbols on a flow diagram. The approach relies upon constructing an underlying metamodel that defines semantic concepts based upon (1) syntactic relationships among visual symbols and (2) inheritance relationships among semantic concepts. Given such a metamodel, a rule-based inference engine can, in many situations, infer the presence of semantic concepts on flow diagram, and can tag symbols accordingly. Futher, an object-oriented query system can compare semantic tags on digram instances for conformance with their definition in the metamodel. To illustrate the approach, the paper describes a metamodel for data flow/control flow diagrams used in the context of a specific software modeling method, Concurrent Object-Based Real-time Analysis (COBRA). The metamodel is implemented using an expert-system shell, CLIPS V6.0, which integrates an object-oriented language with a rule-based inference engine. The paper applies the implemented metamodel to design software for an automobile cruise-control system and provides an evaluation of the approach based upon results from four case studies. For the case studies, the implemented metamodel recognized, automatically and correctly, the existence of 86% of all COBRA semantic concepts within the flow diagrams. Varying degrees of human assistance were used to correctly identify the remaining semantic concepts within the diagrams: in two percent of the cases the implemented metamodel reached tentative classifications that a designer was asked to confirm or override; in four percent of the cases a designer was asked to provide additional information before a concept was classified; in the remaining eight percent of the cases the designer was asked to identify the concept.

Designing complex distributed client/server applications that meet performance requirements may prove extremely difficult in practice if software developers are not willing or do not have the time to help software performance analysts. The paper advocates the need to integrate both design and performance modeling activities so that one can help the other. We present a method developed and used by the authors in the design of a fairly large and complex client/server application. The method is based on a software performance engineering language developed by one of the authors. Use cases were developed and mapped to a performance modeling specification using the language. A compiler for the language generates an analytic performance model for the system. Service demand parameters at servers, storage boxes, and networks are derived by the compiler from the system specification. A detailed model of DBMS query optimizers allows the compiler to estimate the number of I/Os and CPU time for SQL statements. The paper concludes with some results of the application that prompted the development of the method and language.

In this paper a reuse-oriented perspective is taken to designing and implementing configurable distributed applications. An application domain is defined as a family of systems that have some features in common and others that differentiate them. During domain engineering, reusable specifications, architectures and component types are developed, which capture the similarities and variations of the family of systems that compose the application domain. Target systems are generated by tailoring the reusable specification and architecture given the requirements of the target system, and configuring a target system based on the tailored architecture. The paper describes an automated approach for configuring distributed applications from a reusable architecture and library of predefined component types.

A reuse oriented perspective is taken to designing and implementing configurable distributed applications. An application domain is defined as a family of systems that have some features in common and others that differentiate them. During domain modeling, reusable specifications, architectures and component types are developed, which capture the similarities and variations of the family of systems that compose the application domain. Target systems are generated by tailoring the reusable specifications and architectures given the requirements of the target system, and configuring a target system based on the tailored architecture. The paper describes an approach for generating and configuring distributed applications from the domain model and a library of predefined component types.

This paper describes on-going efforts to integrate Petri nets with software design methods for concurrent and real time systems. Specifically, this paper presents an approach for integrating colored Petri nets with the Ada-based Design Approach for Real-Time Systems (ADARTS/sup SM/) and its sister method, CODARTS (Concurrent Design Approach for Real-Time Systems).

The Earth Observing System (EOS) Data and Information System (EOSDIS) is perhaps one of the most important examples of large-scale, geographically distributed, and data intensive systems. The paper presents various facets of a data and information architecture for EOSDIS. EOS data is organized by means of an object-oriented schema, while EOS knowledge is organized through multiple domain-specific thesauri, complemented by domain knowledge and rules. The information holdings are organized into the source data archives, a data warehouse which provides an integrated view of the information holdings, and information marts which generate value-added information products for specialized user communities. Finally a federated client-server architecture is proposed to allow non-EOSDIS systems to become members of the EOSDIS community, allowing them to access EOSDIS holdings, and sharing their own data with EOSDIS.

The Earth Observing System (EOS) Data and Information System (EOSDIS) is perhaps one of the most important examples of a large-scale, geographically distributed, and data-intensive systems. Designing such systems in a way that ensures that the resulting design will satisfy all functional and performance requirements is not a trivial task. This paper presents a performance oriented methodology to design large-scale distributed data intensive information systems. The methodology is then applied to the design of the EOSDIS Core System (ECS). Performance results, based on queueing network models of ECS are also presented.

Article Free Access Share on Objects and domain engineering (panel) Authors: Sanjiv Gossain Cambridge Technology Partners Cambridge Technology PartnersView Profile , Don Batory University of Texas at Austin University of Texas at AustinView Profile , Hassan Gomaa George Mason University George Mason UniversityView Profile , Mitch Lubars Scientific and Engineering Software Inc. Scientific and Engineering Software Inc.View Profile , Christopher Pidgeon Cambridge Technology Partners Cambridge Technology PartnersView Profile , Ed Seidewitz NASA Goddard Space Flight Center NASA Goddard Space Flight CenterView Profile Authors Info & Claims OOPSLA '95: Proceedings of the tenth annual conference on Object-oriented programming systems, languages, and applicationsOctober 1995Pages 333–336https://doi.org/10.1145/217838.217872Published:17 October 1995Publication History 1citation274DownloadsMetricsTotal Citations1Total Downloads274Last 12 Months19Last 6 weeks2 Get Citation AlertsNew Citation Alert added!This alert has been successfully added and will be sent to:You will be notified whenever a record that you have chosen has been cited.To manage your alert preferences, click on the button below.Manage my AlertsNew Citation Alert!Please log in to your account Save to BinderSave to BinderCreate a New BinderNameCancelCreateExport CitationPublisher SiteeReaderPDF

This paper describes a prototype domain modeling environment used to demonstrate the concepts of reuse of software requirements and software architectures. The environment, which is application-domain independent, is used to support the development of domain models and to generate target system specifications from them. The prototype environment consists of an integrated set of commercial-off-the-shelf software tools and custom developed software tools. The concept of reuse is prevalent at several levels of the domain modeling method and prototype environment. The environment is domain-independent thereby supporting the specification of diverse application domain models. The domain modeling method specifies a family of systems rather than a single system; optional features characterize the variations in functional requirements supported by the family, and individual family members are specified by the features they are to support. The knowledge-based approach to target system generation provides the rules for generating target system specifications from the domain model; target system specifications, themselves, may be stored in an object repository for subsequent retrieval and reuse.>

This paper discusses and compares the criteria used by different design methods for decomposing a real time system into tasks and modules. The criteria considered are coupling, cohesion and information hiding for module structuring and concurrency for tasks. The Structured Design method uses the module coupling and cohesion criteria. The NRL method and Object Oriented Design use information hiding as the primary criterion for identifying modules and objects respectively. The Darts design method uses a set of task structuring criteria for identifying the concurrent tasks in the system. A new design method for real time systems is introduced that uses both task structuring and information hiding module structuring criteria. The method is described and illustrated by means of an example of an automoble cruise control system.

Abstract A simulation model of the CERN (European Organization for Nuclear Research) SPS star computer network is described. The model concentrates on simulating the message handling computer, through which all messages in the network pass. The paper describes the main features of the model, the transfer time parameters in the model and how performance measurements were used to assist in the calibration of the model.

Abstract A system development methodology is outlined before describing its application to the development of a microcomputer system. Structured analysis techniques were used for determining the information flow through the system. The system was then structured into modules using structured design and information hiding techniques. The detailed design of the system was described in pseudocode. The system was coded in assembler supplemented by a set of structured programming macros. A systematic bottom‐up testing procedure was adopted for system integration.

This paper describes how two different modelling techniques, regression and simulation modelling, have been combined within a hybrid simulation/regression model of a virtual storage computer system. In the model, simulation techniques are used to model in detail a task's arrival, entering and leaving the multiprogramming set, and termination. The rest of the system is modelled in much less detail mainly using regression techniques. The application of this method to modelling an IBM VM/370 system is described.

Abstract Calibration and validation are two stages in the development of a performance model of a computer system during which the degree of confidence in the model is established. This paper describes a case study of the calibration and validation of a hybrid simulation/regression Load Adjusting Model of a batch computer system. During calibration, a given workload trace was applied to the Load Adjusting Model and the parameters of the model were adjusted using an iterative tuning procedure. During validation, the parameters of the model, established during calibration, were kept constant and the model was tested using different workload traces.

Abstract In a large operating system, the probability that bottlenecks exist is high. The outcome of modifications to the system attempting to overcome these bottlenecks are often not easy to predict. It is frequently difficult to discover: Whether an improvement has actually been made to the system. Where exactly the improvement in system performance, if any, is occurring. How to adjust parameters of the system to achieve an improved performance. Performance tools are described in this paper which were used to help resolve these points in the implementation of a Peripheral Processor and Channel Scheduling mechanism in the operating system used at CERN on a CDC 6000 system. The paper shows how analysis of the performance data provided a clearer appreciation of the performance of the scheduling mechanism.