Downloads & Free Reading Options - Results

Capstone week4

Capstone week4

Capstone week4

Perma.cc archive of https://stackoverflow.com/questions/802050/what-is-opinionated-software created on 2022-02-03 12:56:11.454072+00:00.

Implementing large software, as software analyzers which aim to be used in industrial settings, requires a well-engineered software architecture in order to ease its daily development and its maintenance process during its lifecycle. If the analyzer is not only a single tool, but an open extensible collaborative framework in which external developers may develop plug-ins collaborating with each other, such a well designed architecture even becomes more important. In this experience report, we explain difficulties of developing and maintaining open extensible collaborative analysis frameworks, through the example of Frama-C, a platform dedicated to the analysis of code written in C. We also present the new upcoming software architecture of Frama-C and how it aims to solve some of these issues.

Agenda: Symptoms of failure, Concepts of scale, Root-cause analysis, Architectural tactics that can help, Typical problems and their resolution.

Architecture Report documents investigations towards the definition of a Process-based Software Engineering Environment (PSEE) Reference Architecture. Those investigations are in support of the definition of a component-based architectural approach for the rapid construction of PSEEs. It represents work in progress. these investigations were conducted within the Architectures and Models for Next Generation Process-based SEEs' project; they also revise and enhance prior related work. This document is to be the first in a series of Architecture Reports to be delivered by this contract (pending continuous funding). This document actually consists of eleven (11) reports and four (4) references which provide technical data related to the current state (art and practice) of SEEs including architectural recommendations, requirements, and lessons learned; the data was gathered from national and international efforts and systems, and includes recent developments in the commercial sector and research programs. A key underlying assumption of this work is community participation and community consensus; therefore, some of the documents have been jointly developed with members of the community.

Architectural decisions have a great impact on the consequent quality of software systems. As a result, it is important to evaluate how a software architecture meets its quality demands. Though much focus has been placed on modeling and describing the software architecture as a design artifact, we found that relatively little is known about the current experience with software architecture evaluation. This report details the results of two workshops on software architecture evaluation, held at the Software Engineering Institute (SEI) on November 9-10, 1995 and May 9-10,1996. The purpose of the workshops was to determine the state of industrial practice in the evaluation of software architectures with respect to a set of desired quality attributes, and to uncover recommendations for best practices. In this report, we summarize the findings of the two workshops, define a set of dimensions to characterize various software architecture evaluation techniques, and make concrete recommendations for implementing architecture evaluation practices.

Many software systems eventually undergo changes to their basic architectural structure. Such changes may be prompted by new feature requests, new quality attribute requirements, changing technology, or other reasons. Whatever the causes, architecture evolution is commonplace in real-world software projects. Today's software architects, however, have few techniques to help them plan such evolution. In particular, they have little assistance in planning alternatives, making trade-offs among these different alternatives, or applying best practices for particular domains. To address this, we have developed an approach for assisting architects in planning and reasoning about software architecture evolution. Our approach is based on modeling and analyzing potential evolution paths that represent different ways of evolving the system. We represent an evolution path as a sequence of transitional architectural states leading from the initial architecture to the target architecture along with evolution operators that characterize the transitions among these states. We support analysis of evolution paths through the definition and application of constraints that express rules governing the evolution of the system and evaluation functions that assess path quality. Finally, a set of these modeling elements may be grouped together into an evolution style that encapsulates a body of knowledge relevant to a particular domain of architecture evolution. We evaluate this approach in three ways. First, we evaluate its applicability to real-world architecture evolution projects. This is accomplished through case studies of two very different software organizations. Second, we undertake a formal evaluation of the computational complexity of verifying evolution constraints. Finally, we evaluate the implementability of the approach based on our experiences developing prototype tools for software architecture evolution.

XML (eXtensible Markup Language) is the ubiquitous low-level language of the World Wide Web, and forms the primary structure for the emerging Semantic Web. The Semantic Web is the vision, and ongoing implementation, of how the web will transform over time to connect disparate pieces of knowledge, data, and resources. Our purpose in this contract was to create a foundation for the Semantic Web, suitable for deployment within the Air Force Infosphere project. The concept behind the Infosphere is one of rapid data and knowledge interchange, between physical objects, models, and computational processes. In our work, we created two XML schemas, defining two applications: MXL and DXL. MXL (Multimodeling eXchange Language) defines dynamic system models at a fairly high level of abstraction, and DXL (Dynamics eXchange Language) defines a low-level, block-oriented, language for a wide variety of simulation applications. With initial results in 2001, these two languages represented the first thorough implementations of XML in simulation, and they led the way to subsequent, higher level ontology studies.

Different Department of Defense communities prepare models for architecture compliance (e.g., to maintain JCIDS requirements), for simulation purposes (e.g. for performance estimates) and software engineering (e.g, for model-based code generation). Little, if any, information transfer and model reuse takes place across these communities of interest, which leads to redundant efforts, models that are out of sync, and lost domain knowledge. Differences in methods, tools and data formats are a major reason for this disconnect. The charter of RT 24 was to investigate mechanisms that could help bridge the divide between the modeling & simulation, software engineering, and enterprise architecture modeling communities.

This thesis describes a web-based continuous learning module (CLM) for use in introducing members of the Department of the Navy's acquisition community to software reuse in the context of Naval Open Architecture. The CLM introduces the student to principles for effective software reuse, explains the unique challenges of software reuse, discusses software reuse within the context of the Naval Open Architecture under the current Department of Defense and DoN policy and guidance, provides a strategy for successful software reuse, and introduces the student to the Software Hardware Asset Reuse Enterprise (SHARE) repository established by the Navy's Open Architecture (OA) program.

From the bitsavers.org collection, a scanned-in computer-related document. burroughs :: MediumSystems :: Software :: 5026289 MCPVS Architecture 198707

Software Architecture Hour - Architecture and Security

The ATLAS High Level Trigger (HLT) consists of two selection steps: the second level trigger and the event filter. Both will be implemented in software, running on mostly commodity hardware. Both levels have a coherent approach to event selection, so a common core software framework has been designed to maximize this coherency, while allowing sufficient flexibility to meet the different interfaces and requirements of the two different levels. The approach is extended further to allow the software to run in an off-line simulation and reconstruction environment for the purposes of development. This paper describes the architecture and high level design of the software.

DESCRIPTION OF SOFTWARE SYSTEM ARCHITECTURE OF YEROTH-ERP-3.0. COMPARISON BETWEEN THICK-CLIENT AND WEB-BROWSER-BASED SOFTWARE SYSTEM ARCHITECTURES!

SeveUp App is the first online platform allowing BIM - Building Information Modeling - actors to simply access and exploit their BIM data, automatically. Visit: https://www.seve-up.com/

Available from National Technical Information Service, Springfield, Va

Today, intrusion detection systems provide for detecting intrusive patterns of interaction. Although the responses of such systems are typically limited to primitive actions, they can be supplemented with deception-based strategies. We propose a generic software architecture combining intrusion detection and deceptive response capabilities in a uniform structure. Detecting and responding to attacks are realized via runtime instrumentation of kernel-based modules. The architecture provides for dynamically adjusting system performance to maintain continuity and integrity of both legitimate services and security activities.

Today, intrusion detection systems provide for detecting intrusive patterns of interaction. Although the responses of such systems are typically limited to primitive actions, they can be supplemented with deception-based strategies. We propose a generic software architecture combining intrusion detection and deceptive response capabilities in a uniform structure. Detecting and responding to attacks are realized via runtime instrumentation of kernel-based modules. The architecture provides for dynamically adjusting system performance to maintain continuity and integrity of both legitimate services and security activities.

NASA is developing an architecture standard for software-defined radios used in space- and ground-based platforms to enable commonality among radio developments to enhance capability and services while reducing mission and programmatic risk. Transceivers (or transponders) with functionality primarily defined in software (e.g., firmware) have the ability to change their functional behavior through software alone. This radio architecture standard offers value by employing common waveform software interfaces, method of instantiation, operation, and testing among different compliant hardware and software products. These common interfaces within the architecture abstract application software from the underlying hardware to enable technology insertion independently at either the software or hardware layer. This paper presents the initial Space Telecommunications Radio System (STRS) Architecture for NASA missions to provide the desired software abstraction and flexibility while minimizing the resources necessary to support the architecture.

Software Architecture Course Coursera

Languages, compilers, and computer-aided design tools will be essential for scalable quantum computing, which promises an exponential leap in our ability to execute complex tasks. LIQUi|> is a modular software architecture designed to control quantum hardware. It enables easy programming, compilation, and simulation of quantum algorithms and circuits, and is independent of a specific quantum architecture. LIQUi|> contains an embedded, domain-specific language designed for programming quantum algorithms, with F# as the host language. It also allows the extraction of a circuit data structure that can be used for optimization, rendering, or translation. The circuit can also be exported to external hardware and software environments. Two different simulation environments are available to the user which allow a trade-off between number of qubits and class of operations. LIQUi|> has been implemented on a wide range of runtimes as back-ends with a single user front-end. We describe the significant components of the design architecture and how to express any given quantum algorithm.

The right software architecture is essential for a software-intensive system to meet its functional requirements as well as its quality requirements that govern real-time performance, reliability, maintainability, and a host of other quality attributes. Because an architecture comprises the earliest, most important, and most far-reaching design decisions, it is important for an acquisition organization to exercise its oversight prerogatives with respect to software architecture. Having the right software architecture documentation is a prerequisite for managing and guiding a software development effort and conducting in situ software architecture evaluations. Conducting an architecture evaluation to determine the software architecture's fitness for purpose is one of the most powerful, technical risk mitigation strategies available to a program office. This report provides an example reference standard for a Software Architecture Document (SAD). An acquisition organization can use this standard to contractually acquire the documentation needed for communicating the software architecture design and conducting software architecture evaluations. The example used in this report is drawn from an actual SAD written by a major U.S. Department of Defense contractor in a weapon system acquisition. The intent of this report is to provide an example for other acquisition efforts to use (and adapt as appropriate) in their own procurements.

Software architecture, configuration management, and configurable distributed systems are three areas of research that until now have evolved separately. Contributions in each field have focused on their respective area of concern. However, as solutions in the three fields tend to center around some notion of a system model, it is worthwhile to investigate their relationship in detail. In particular, the large amount of overlap among the system models developed in each area, combined with the complementary nature of the differences among them, suggests that an approach based on a common system model is viable. In this paper, we illustrate the benefits of using such a unified system model, identify the commonalities and differences among the existing system models, and present some of our initial experiments that we believe will lead to the development of a single system model that is usable in all three fields.

As software systems become more complex, the overall system structure-or software architecture-becomes a central design problem. A system's architecture provides a model of the system that suppresses implementation detail, allowing the architect to concentrate on the analyses and decisions that are most crucial to structuring the system to satisfy its requirements. Unfortunately, current representations of software architecture are informal and ad hoc. While architectural concepts are often embodied in infrastructure to support specific architectural styles and in the initial conceptualization of a system configuration, the lack of an explicit, independently-characterized architecture or architectural style significantly limits the benefits of software architectural design in current practice. In this dissertation, I show that an Architecture Description Language based on a formal, abstract model of system behavior can provide a practical means of describing and analyzing software architectures and architectural styles. This dissertation demonstrates this claim through WRIGHT, an architectural description language based on the formal description of the abstract behavior of architectural components and connectors. WRIGHT provides a practical formal basis for the description of both architectural configurations and of architectural styles. It is distinguished by the use of explicit, independent connector types as interaction patterns, the ability to describe the abstract behavior of components using a CSP-like notation, the characterization of styles using predicates over system instances, and a collection of static checks to determine the consistency and completeness of an architectural specification. We introduce techniques to support the analysis of large-scale systems, and demonstrate WRIGHT's expressiveness and practicality through three case studies.

The authors define an architecture for a software engineering environment that behaves as an intelligent assistant. This architecture consists of two key aspects, an objectbase and a model of the software development process. The objectbase is adapted from other research, but the model is unique in that it consists primarily of rules that define the preconditions and multiple postconditions of software development tools. Metarules define forward and backward chaining among the rules. The most significant contribution is opportunistic processing, whereby the environment automatically performs software development activities at some time between when their preconditions are satisfied and when their postconditions are required. Further, this model defines strategies that guide the assistant in choosing an appropriate point for carrying out each activity. (Author)

The authors define an architecture for a software engineering environment that behaves as an intelligent assistant. This architecture consists of two key aspects, an objectbase and a model of the software development process. The objectbase is adapted from other research, but the model is unique in that it consists primarily of rules that define the preconditions and multiple postconditions of software development tools. Metarules define forward and backward chaining among the rules. The most significant contribution is opportunistic processing, whereby the environment automatically performs software development activities at some time between when their preconditions are satisfied and when their postconditions are required. Further, this model defines strategies that guide the assistant in choosing an appropriate point for carrying out each activity. (Author)

Overview: Recent trends in open architecture (OA) software systems. Emerging challenges in achieving Better Buying Power (BBP) via OA software systems for Webbased and Mobile devices. New practices to realize cost-effective acquisition of OA software systems. Conclusions: Our research identifies how new Web/mobile software component technologies, IP and security requirements, and new business models interact to drive-down or drive-up acquisition costs. Managing acquisition costs for OA Web/mobile software components will be demanding. Acquisition workforce will need automated assistance, else acquisition process costs will dominate development costs for OA Web/mobile software components! New technical risks for component-based OA software systems can dilute the cost-effectiveness of BBP efforts. Need R&D leading to automated systems (SORMS) that can model and analyze OA system IP licenses and cybersecurity requirements. SORMS will empower the acquisition workforce, and Identify and manage cost-effectiveness trade-offs.

Overview: Recent trends in open architecture (OA) software systems. Emerging challenges in achieving Better Buying Power (BBP) via OA software systems for Webbased and Mobile devices. New practices to realize cost-effective acquisition of OA software systems. Conclusions: Our research identifies how new Web/mobile software component technologies, IP and security requirements, and new business models interact to drive-down or drive-up acquisition costs. Managing acquisition costs for OA Web/mobile software components will be demanding. Acquisition workforce will need automated assistance, else acquisition process costs will dominate development costs for OA Web/mobile software components! New technical risks for component-based OA software systems can dilute the cost-effectiveness of BBP efforts. Need R&D leading to automated systems (SORMS) that can model and analyze OA system IP licenses and cybersecurity requirements. SORMS will empower the acquisition workforce, and Identify and manage cost-effectiveness trade-offs.

Applying traditional manual US Navy testing practices to OA systems will limit many benefits of OA, such as system scalability, rapid configuration changes, and effective component reuse. Pairing profile-driven automated software testing with test reduction techniques should enable these benefits and keep resource requirements at feasible levels. Test cases generated by operational profiles have been shown to be more effective than those developed by other methods, such as random or selective testing, and more resource-efficient than exhaustive approaches. This research effort increases the fidelity of the operational profile, creating an environment model referred to as a High-Fidelity Profile Model (HFPM) that can statistically describe individual software inputs. Samples from the HFPM's probability distributions can generate operationally realistic or overly-stressful test cases for software modules under test. This process can be automated and paired with output checking functions, enabling automated effective software testing, and potentially improving reliability. Such models would be ideal for US Navy Open Architecture (OA) software because of the defined interface standards. HFPMs can enable effective testing in software reuse applications and are ideal for testing multiple releases of maturing software. This research defines the HFPM, presents a methodology to develop, validate, and apply it.

Applying traditional manual US Navy testing practices to OA systems will limit many benefits of OA, such as system scalability, rapid configuration changes, and effective component reuse. Pairing profile-driven automated software testing with test reduction techniques should enable these benefits and keep resource requirements at feasible levels. Test cases generated by operational profiles have been shown to be more effective than those developed by other methods, such as random or selective testing, and more resource-efficient than exhaustive approaches. This research effort increases the fidelity of the operational profile, creating an environment model referred to as a High-Fidelity Profile Model (HFPM) that can statistically describe individual software inputs. Samples from the HFPM's probability distributions can generate operationally realistic or overly-stressful test cases for software modules under test. This process can be automated and paired with output checking functions, enabling automated effective software testing, and potentially improving reliability. Such models would be ideal for US Navy Open Architecture (OA) software because of the defined interface standards. HFPMs can enable effective testing in software reuse applications and are ideal for testing multiple releases of maturing software. This research defines the HFPM, presents a methodology to develop, validate, and apply it.

We analyzed a series of ten systematically developed surface exploration systems that integrated a variety of hardware and software components. Design, development, and testing data suggest that incremental buildup of an exploration system for long-duration capabilities is facilitated by an open architecture with appropriate-level APIs, specifically designed to facilitate integration of new components. This improves software productivity by reducing changes required for reconfiguring an existing system.

The purpose of this thesis is to understand disparate organizational standard operating procedures (SOPs) covering agile software development and supporting functions, including business and technical feasibility analysis, contracts development, and personnel assessment. On the basis of SOP analysis, we developed a discrete-event software process simulation model of the architecture using Lifecycle Modeling Language (LML) action diagrams with the Model-Based Systems Engineering tool Innoslate. The action diagrams unify the SOPs to support both process architecture development and the ability to simulate actions independently or as a whole. The architecture illustrates that, in addition to the core function of software design and development, there are supporting functions that are necessary to successfully execute agile software development. The simulation model also serves as an accurate cost estimator for sprints. Historical data was available to calibrate model parameters for activity effort, staffing, and labor rates. The results of Monte Carlo simulations to forecast effort and cost for software sprints showed a high degree of accuracy against actuals. It is a viable alternative to other estimation methods and also provides risk assessment. The process model can be further calibrated and dynamically extended to support agile software development.

The purpose of this thesis is to understand disparate organizational standard operating procedures (SOPs) covering agile software development and supporting functions, including business and technical feasibility analysis, contracts development, and personnel assessment. On the basis of SOP analysis, we developed a discrete-event software process simulation model of the architecture using Lifecycle Modeling Language (LML) action diagrams with the Model-Based Systems Engineering tool Innoslate. The action diagrams unify the SOPs to support both process architecture development and the ability to simulate actions independently or as a whole. The architecture illustrates that, in addition to the core function of software design and development, there are supporting functions that are necessary to successfully execute agile software development. The simulation model also serves as an accurate cost estimator for sprints. Historical data was available to calibrate model parameters for activity effort, staffing, and labor rates. The results of Monte Carlo simulations to forecast effort and cost for software sprints showed a high degree of accuracy against actuals. It is a viable alternative to other estimation methods and also provides risk assessment. The process model can be further calibrated and dynamically extended to support agile software development.

The purpose of this thesis is to understand disparate organizational standard operating procedures (SOPs) covering agile software development and supporting functions, including business and technical feasibility analysis, contracts development, and personnel assessment. On the basis of SOP analysis, we developed a discrete-event software process simulation model of the architecture using Lifecycle Modeling Language (LML) action diagrams with the Model-Based Systems Engineering tool Innoslate. The action diagrams unify the SOPs to support both process architecture development and the ability to simulate actions independently or as a whole. The architecture illustrates that, in addition to the core function of software design and development, there are supporting functions that are necessary to successfully execute agile software development. The simulation model also serves as an accurate cost estimator for sprints. Historical data was available to calibrate model parameters for activity effort, staffing, and labor rates. The results of Monte Carlo simulations to forecast effort and cost for software sprints showed a high degree of accuracy against actuals. It is a viable alternative to other estimation methods and also provides risk assessment. The process model can be further calibrated and dynamically extended to support agile software development.

The Autonomous Multi-Agent Physically Interacting Spacecraft (AMPHIS) test bed examines the problem of multiple spacecraft interacting at close proximity. This thesis contributes to this on-going research by addressing the development of the software architecture for the AMPHIS spacecraft simulator robots and the implementation of a Light Detection and Ranging (LIDAR) unit to be used for state estimation and navigation of the prototype robot. The software modules developed include: user input for simple user tasking; user output for data analysis and animation; external data links for sensors and actuators; and guidance, navigation and control (GNC). The software was developed in the SIMULINK/MATLAB environment as a consistent library to serve as stand alone simulator, actual hardware control on the robot prototype, and any combination of the two. In particular, the software enables hardware-in-the-loop testing to be conducted for any portion of the system with reliable simulation of all other portions of the system. The modularity of this solution facilitates fast proof-of-concept validation for the GNC algorithms. Two sample guidance and control algorithms were developed and are demonstrated here: a Direct Calculus of Variation method, and an artificial potential function guidance method. State estimation methods are discussed, including state estimation from hardware sensors, pose estimation strategies from various vision sensors, and the implementation of a LIDAR unit for state estimation. Finally, the relative motion of the AMPHIS test bed is compared to the relative motion on orbit, including how to simulate the on orbit behavior using Hill's equations.

An often overbearing logistical problem that social network researchers and analysts face is the challenge of carrying out the basic data processing steps necessary to transform real-world source data into a form that is formatted specifically to the requirements of particular social network analysis software. In particular, this paper focuses on resolving the variety of real-world data forms that must be transformed into the format necessities of the software suite developed at the Center for Computational Analysis of Social and Organizational Systems (CASOS) at Carnegie Mellon University. This data processing or programming problem, while rather straightforward, can be daunting to non-I.T. users of these -- and any -- software tools, and at best case, laboriously costly for the programming savvy. This report outlines and describes a software architecture and user paradigm to address this ubiquitous problem. This report provides a basis for later detailed design and implementation of the ideas put forth in this report which will ultimately results in tangible features being made available and fully operational for users of the CASOS software suite (ORA, AutoMap, and Construct).

Architecture documentation has emerged as an important architecture-related practice. In 2002, researchers at the Carnegie Mellon (trademark) Software Engineering Institute completed Documenting Software Architectures: Views and Beyond (V&B), an approach that holds that documenting a software architecture is a matter of choosing a set of relevant views of the architecture, documenting each of those views, and then documenting information that applies to more than one view or to the set of views as a whole. Details of the approach include a method for choosing the most relevant views, standard templates for documenting views and the information beyond them, and definitions of the templates' content. At about the same time, the Institute of Electrical and Electronics Engineers (IEEE) was developing a recommended best practice for describing architectures for software-intensive systems -- ANSI/IEEE Std. 1471-2000. Like V&B, that standard takes a multi-view approach to the task of architecture documentation, and it establishes a conceptual framework for architectural description and defines the content of an architectural description. This technical note summarizes the two approaches and shows how a software architecture document prepared using the V&B approach can be made compliant with Std. 1471-2000.

Comparing software architectures for any nontrivial system is a difficult task. Software architectures are designed with particular requirements and constraints, and are often poorly documented. However, organizations often need to select a software architecture for future development from several candidate architectures. The Software Architecture Comparison Analysis Method (SACAM) was created to provide the rationale for an architecture selection process by comparing the fitness of architecture candidates for required systems. The SACAM compares architectures based on a set of criteria derived from the business goals of an organization. The SACAM was developed in a technical reuse context where an organization investigated architectural commonalities and differences to explore architectural designs for a software product line architecture. This report outlines a first version of the method and its underlying concepts.

The virtual proving ground (VPG) is a concept being developed within the U.S. Army Test and Evaluation Command to harness the power of state-of-the-art sophisticated modeling and simulation technologies to augment and enhance test and evaluation in support of product acquisition. VPG is a cohesive and comprehensive capability for testing concepts, virtual prototypes, hardware prototypes, subsystems, and full systems. A broad, far-reaching, and diverse set of capabilities is envisioned within the VPG. Critical to the successful implementation of the VPG is an architecture able to support or enable those capabilities. A major function of the VPG architecture will be to integrate dissimilar heterogeneous engineering level models and simulations of prototype and production hardware and the synthetic environments in which they operate. In 1996, the U.S. Army Aberdeen Test Center and the U.S. Army Research Laboratory jointly conducted 'Project Focus' to help determine the architectural requirements that support the VPG concept. This report contains a description of Project Focus and the architectural requirements that resulted from it.

Telemetry--the automated measurement and transmission of data from remote sources to receiving stations--plays a vital role in collecting critical information from flight vehicles and space assets. A telemetry system installed on a flight vehicle, for example, could transmit the vehicles air speed and Global Positioning System location to a flight termination system. Other data, such as the voltages, temperatures, and barometric or fuel pressures of onboard systems, may be of prime interest to flight-test engineers. Data are measured via onboard sensors, modulated onto a radio-frequency (RF) carrier, and transmitted, or telemetered, to a ground station. At the ground station, the telemetered information is received by a tracking antenna, demodulated, and reassembled into engineering data to provide real-time situational awareness of the flight vehicle and to be used in post-flight data analysis (e.g., of flight vehicle performance).

As the size of software systems increases, the algorithms and data structures of the computation no longer constitute the major design problems. When systems are constructed from many components, the organization of the overall system-the software architecture-presents a new set of design problems. This level of design has been addressed in a number of ways, including informal diagrams and descriptive terms, module interconnection languages, templates, and frameworks for systems that serve the needs of specific domains, and formal models of component integration mechanisms.

This document describes the lessons learned from STARS task PA12. Under this task, the Unisys STARS team developed a testbed for analyzing architecture description languages (ADLs) and a World Wide Web 'Software Architecture Technology Guide' to provide the DoD software engineering community with a broad range of information about software architecture technology. The lessons learned focus on issues associated with: Developing World Wide Web documents in general and the Software Architecture Technology Guide in particular. Establishing criteria for analyzing ADLs and developing scenarios for applying the criteria. Obtaining ADL technologies for analysis and analyzing them using the criteria and scenarios.

This document describes the lessons learned from STARS task PA12. Under this task, the Unisys STARS team developed a testbed for analyzing architecture description languages (ADLs) and a World Wide Web 'Software Architecture Technology Guide' to provide the DoD software engineering community with a broad range of information about software architecture technology. The lessons learned focus on issues associated with: Developing World Wide Web documents in general and the Software Architecture Technology Guide in particular. Establishing criteria for analyzing ADLs and developing scenarios for applying the criteria. Obtaining ADL technologies for analysis and analyzing them using the criteria and scenarios.

This document describes the lessons learned from STARS task PA12. Under this task, the Unisys STARS team developed a testbed for analyzing architecture description languages (ADLs) and a World Wide Web 'Software Architecture Technology Guide' to provide the DoD software engineering community with a broad range of information about software architecture technology. The lessons learned focus on issues associated with: Developing World Wide Web documents in general and the Software Architecture Technology Guide in particular. Establishing criteria for analyzing ADLs and developing scenarios for applying the criteria. Obtaining ADL technologies for analysis and analyzing them using the criteria and scenarios.

This document describes the lessons learned from STARS task PA12. Under this task, the Unisys STARS team developed a testbed for analyzing architecture description languages (ADLs) and a World Wide Web 'Software Architecture Technology Guide' to provide the DoD software engineering community with a broad range of information about software architecture technology. The lessons learned focus on issues associated with: Developing World Wide Web documents in general and the Software Architecture Technology Guide in particular. Establishing criteria for analyzing ADLs and developing scenarios for applying the criteria. Obtaining ADL technologies for analysis and analyzing them using the criteria and scenarios.

Attribute-driven software architecture design aims to provide decision support by taking into account the quality attributes of softwares. A central question in this process is: What architecture design best fulfills the desirable software requirements? To answer this question, a system designer needs to make tradeoffs among several potentially conflicting quality attributes. Such decisions are normally ad-hoc and rely heavily on experiences. We propose a mathematical approach to tackle this problem. Game theory naturally provides the basic language: Players represent requirements, and strategies involve setting up coalitions among the players. In this way we propose a novel model, called decomposition game, for attribute-driven design. We present its solution concept based on the notion of cohesion and expansion-freedom and prove that a solution always exists. We then investigate the computational complexity of obtaining a solution. The game model and the algorithms may serve as a general framework for providing useful guidance for software architecture design. We present our results through running examples and a case study on a real-life software project.

Attribute-driven software architecture design aims to provide decision support by taking into account the quality attributes of softwares. A central question in this process is: What architecture design best fulfills the desirable software requirements? To answer this question, a system designer needs to make tradeoffs among several potentially conflicting quality attributes. Such decisions are normally ad-hoc and rely heavily on experiences. We propose a mathematical approach to tackle this problem. Game theory naturally provides the basic language: Players represent requirements, and strategies involve setting up coalitions among the players. In this way we propose a novel model, called decomposition game, for attribute-driven design. We present its solution concept based on the notion of cohesion and expansion-freedom and prove that a solution always exists. We then investigate the computational complexity of obtaining a solution. The game model and the algorithms may serve as a general framework for providing useful guidance for software architecture design. We present our results through running examples and a case study on a real-life software project.

Attribute-driven software architecture design aims to provide decision support by taking into account the quality attributes of softwares. A central question in this process is: What architecture design best fulfills the desirable software requirements? To answer this question, a system designer needs to make tradeoffs among several potentially conflicting quality attributes. Such decisions are normally ad-hoc and rely heavily on experiences. We propose a mathematical approach to tackle this problem. Game theory naturally provides the basic language: Players represent requirements, and strategies involve setting up coalitions among the players. In this way we propose a novel model, called decomposition game, for attribute-driven design. We present its solution concept based on the notion of cohesion and expansion-freedom and prove that a solution always exists. We then investigate the computational complexity of obtaining a solution. The game model and the algorithms may serve as a general framework for providing useful guidance for software architecture design. We present our results through running examples and a case study on a real-life software project.