Downloads & Free Reading Options - Results

Capstone week4

Capstone week4

Capstone week4

A curated list of awesome articles, videos, and other resources to learn and practice about software architecture, patterns, and principles. 🎨 Awesome Software Architecture Curated list of awesome articles and resources to learn and practice about software architecture, patterns and principles. this repository will be updated continuously, keep yourself up to date . 🚀 This awesome list is available in this link: https://mehdihadeli.github.io/awesome-software-architecture Support ⭐ Star this repository, And we will be happy together :) Thanks a bunch for supporting me! Contribution Contributions are always welcome! Please take a look at the contribution guidelines pages first. Thanks to all contributors , you're awesome and wouldn't be possible without you! The goal is to build a categorized community-driven collection of very well-known resources. To restore the repository download the bundle wget https://archive.org/download/github.com-mehdihadeli-awesome-software-architecture_-_2021-12-05_07-56-49/mehdihadeli-awesome-software-architecture_-_2021-12-05_07-56-49.bundle and run: git clone mehdihadeli-awesome-software-architecture_-_2021-12-05_07-56-49.bundle Source: https://github.com/mehdihadeli/awesome-software-architecture Uploader: mehdihadeli Upload date: 2021-12-05

A curated list of awesome articles, videos, and other resources to learn and practice about software architecture, patterns, and principles. 🎨 Awesome Software Architecture Curated list of awesome articles and resources to learn and practice about software architecture, patterns and principles. this repository will be updated continuously, keep yourself up to date . 🚀 This awesome list is available in this link: https://mehdihadeli.github.io/awesome-software-architecture Support ⭐ Star this repository, And we will be happy together :) Thanks a bunch for supporting me! Contribution Contributions are always welcome! Please take a look at the contribution guidelines pages first. Thanks to all contributors , you're awesome and wouldn't be possible without you! The goal is to build a categorized community-driven collection of very well-known resources. To restore the repository download the bundle wget https://archive.org/download/github.com-mehdihadeli-awesome-software-architecture_-_2021-12-08_09-36-09/mehdihadeli-awesome-software-architecture_-_2021-12-08_09-36-09.bundle and run: git clone mehdihadeli-awesome-software-architecture_-_2021-12-08_09-36-09.bundle Source: https://github.com/mehdihadeli/awesome-software-architecture Uploader: mehdihadeli Upload date: 2021-12-08

The Software–System Architecture of YEROTH–ERP– 3.0

We present a network software architecture for solving the problem of scaling large distributed simulations. The motivation for our effort is to expand the capability of virtual environments to serve large numbers (more than 1,000) of simultaneous users. The fundamental idea of our approach is to logically partition virtual environments by associating spatial, temporal, and functionally related entity classes with network multicast groups. Furthermore, we exploit the actual characteristics of the real-world large-scale environments that are simulated by focusing or restricting an entity's processing and network resources to its area of interest via a local Area of Interest Manager (AOIM) and a persistent object protocol. We first discuss related work in the area of networked virtual environments and the problems of developing scalable VEs. The dissertation also provides a taxonomy for discussing VEs in terms of communication methods, data, processes, and views. Moreover, we describe the Distributed Interactive Simulation (DIS) efforts and the limits of DIS today. Finally, we present our theory and the results of simulations using the AOIM. We used data from the U.S. Army National Training Center and the Janus combat model to show how the movement rates and densities of thousands of combat systems allows the use of the AOIM by an military entity to limit network traffic and simulation computation, maintain acceptable reliability, and minimize the effects of latency.

A distributed system is based on a layered set of abstractions of network communication. At a low level, current distributed systems use primitives such as datagrams, request/reply message-passing, reliable virtual circuits, or a combination of these. Future distributed systems will use high- performance large-scale communication networks, and will support a range of communication-intensive applications. What are the appropriate communication abstractions for such systems? In answer to this question, we have developed a communication abstraction called Real-Time Message Streams (RMS). An RMS is a simplex (unidirectional) stream with several performance and security parameters. These parameters express 1) the needs of RMS clients (user programs and communication protocols), and 2) the capabilities of the RMS provider (network and higher layers). This information can be used in two ways. First, RMS providers can eliminate unnecessary or redundant work, and can optimally schedule resources such as network bandwidth and CPU. Second, the RMS client can use the parameters to select optimal methods for achieving whatever reliability and flow control are needed. RMS is the communication primitive of the DASH distributed system currently being developed at UC Berkeley. This paper describes 1) the RMS abstraction itself, 2) the role of RMS and DASH communication architecture, and 3) techniques and algorithms for providing RMS at various system levels. (KR)

Although the concept of software diversity has been thoroughly adopted by software architects for many years, yet the advent of using diversity to achieve sustainability is overlooked. We argue that option thinking is an effective decision making tool to evaluate the trade-offs between architectural strategies and their long-term values under uncertainty. Our method extends cost-benefit analysis method CBAM. Unlike CBAM, our focus is on valuing the options which diversification can embed in the architecture and their corresponding value using real options pricing theory. The intuitive assumption is that the value of these options can provide the architect with insights on the long-term performance of these decisions in relation to some scenarios of interest and use them as the basis for reasoning about sustainability. The method aims to answer the following: (1) Is diversification of architectural decisions beneficial and when they can help in sustaining the software, (2) When, where and to what extent. The proposed model is illustrated and evaluated using a case study from the literature referred to as GridStix.

User interfaces that adapt their characteristics to those of the user are referred to as adaptive interfaces. We propose Adaptive Agent Oriented Software Architecture (AAOSA) as a new way of designing adaptive interfaces. AAOSA is a new approach to software design based on an agent-oriented architecture. In this approach agents are considered adaptively communicating concurrent modules which are divided into a white box module responsible for the communications and learning, and a black box which is responsible for the independent specialized processes of the agent. A distributed learning policy that makes use of this architecture is used for purposes of system adaptability.

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.

This Final Technical Report for the Software and Systems Test Track (SWTT) Architecture and Concept Definition Phase I effort provides documentation on the work accomplished by a Boeing-led team in developing a user Concept of Operations (CONOPS) and Architecture for the emerging SWTT. The objective of the SWTT is to provide an open collaborative research and development environment to demonstrate, evaluate and document the ability of novel tools, methods, techniques and run-time technologies to yield affordable and more predictable software intensive systems.

To implement the capabilities conceptualized in the National Military Strategy complex secure networks of weapon systems intelligence platforms and command-and-control mechanisms must be seamlessly integrated and maintained over time. Accurate and timely information will enable National Military Strategy key tenets to be realized. These networks are central warfighting platforms in the information age. As these capabilities are developed over time in an evolutionary manner interoperability on the Net-Centric Warfare (NCW) networks is essential and both hardware and software systems must be designed in an Open-systems Architecture (QA) fashion to accommodate the vast number of changes anticipated. Professional Program Management will be needed to successfully develop these key warfighting platforms. Materiel Developers will need to recognize the relatively immature nature of the software engineering domains and actively compensate for this immaturity. System software performance capabilities must be much more detailed than typical hardware-centric systems as the current state of software engineering disciplines is unlikely to satisfy implied yet critical performance requirements. Essential QA performance characteristics including Maintainability Upgradability lnterfaces/lnteroperability Reliability Safety and Security (MUIRSS) must be fully analyzed and clearly communicated to the software developer to ensure the DoD obtains the flexibility and longevity desired from NCW systems.

A centralized (or even distributed) system admits only one correct answer to a question at a time. In contrast, a decentralized one allows several agents to hold different opinions, all equally valid. While the term decentralization is familiar from political and economic contexts, it has been applied extensively, if indiscriminately, to describe recent trends in software architecture towards integrating services across organizational boundaries. This technical report investigates how decentralization can be defined in the context of software architecture; provides a formal model of two causes of decentralization (latency and agency); reviews historical trends forcing decentralization in software; and designs, implements, and evaluates a proposed software architectural style called DECentralized Event Notification Transfer (DECENT). The author believes its principal contributions will include the following: (1) formally exposing the often-tacit requirement for simultaneity between components; (2) novel rationales for adopting event-based communication, standardized application protocols, and stateless messaging; (3) describing application-layer internetworking of software services across several routers rather than a central bus; (4) a microkernel-like refactoring of traditional messaging middleware on top of a basic event model; (5) techniques for using consistent hashing to increase reliability, availability, and scalability of decentralized services; and (6) evaluation of the effectiveness of DECENT-style architecture for enabling 3rd and 4th parties to add properties such as security and interoperability without modifying the original services.

Software architecture is critical to the quality of a software-intensive system. For an acquisition organization, such as the Department of Defense (DoD), the ability to evaluate software architectures early in an acquisition can have a favorable impact on the delivered system. This technical note discusses the role of software architecture evaluations in a system acquisition and describes the contractual elements that are needed to accommodate architecture evaluations in an acquisition. The note then provides an example of contractual language that incorporates the Architecture Tradeoff Analysis MethodSM (ATAMSM) as a software architecture evaluation method in a system acquisition.

UAV systems architectures rank among the most complex ones with high safety requirements. Some new software tools have recently emerged that are worth to be known. This lecture was given to advertise four of them on the following topics : I) Static verification of real time software, to avoid run-time errors, typically what happen for Ariane V; 2) Simulation of real time architecture to optimize conception and validate the final choice; 3) edition of command and control software with interpreted properties like on-line automatic reprogramming; 4) optimization under constraints for continuous and discrete processes.

The Undersea Cooperative Cueing and Intervention (UC2I) Program objectives include a heavy emphasis on developing autonomy for both unmanned underwater vehicles (UUVs) and Unmanned Surface Vehicles (USVs). The mission objective is to utilize a collection of such assets, each with different sensors, range, endurance, speed, and communications capabilities to work together to rapidly search and map a minefield area on the order of 100 x 100 kilometers in five days or under. This program explores the gain achieved by utilizing assets in a coordinated manner. Working together includes not only intervehicle cueing and sharing of information, but also the transportation, launch and recovery of UUVs from USVs. The possible configurations of platform assets, sensors, sensing algorithms, navigation algorithms and autonomy algorithms is enormous. Of significant concern to the Navy and the execution of this program is the ability to explore this configuration space to find the most effective system for achieving mission objectives. Practically speaking, this not only requires that software solutions are decoupled from hardware solutions, but that the collection of software modules that comprise the sensing, navigation and vehicle autonomy algorithms are also decoupled from one another. This white paper outlines the plan and software architecture ground rules for the UC2I program to meet that objective.

Software engineers will typically spend 50% or more of the total software development time designing software architecture, and that architecture may provide up to 80% of a modern weapon system's functionality. Increasingly, these systems will operate within a network or other system-of-systems architecture. Obviously, the requirements driving that architectural design effort and the process for tracing requirement to functions, insight into the process, and control of the effort are critical for the successful development of the capability needed by the warfighter. The DoD typically monitors and controls system technical development through implementation of the Baselines, Audits and Technical Reviews within an overarching Systems Engineering Process (SEP) (Defense Acquisition University, 2004, December, chap. 4). Because of the relatively immature software engineering environment, significantly more analysis and development of the requirements is required. In addition, the software architectural design effort is dependent on in-depth requirements analysis, is resource intensive, and must occur very early in the process. Effective management and implementation of design metrics is essential in developing software that meets the warfighters' needs. This management and metrics effort supplements and supports the system technical development through the Baselines, Audits and Technical Reviews.

Software engineers will typically spend 50% or more of the total software development time designing software architecture, and that architecture may provide up to 80% of a modern weapon system's functionality. Increasingly, these systems will operate within a network or other system-of-systems architecture. Obviously, the requirements driving that architectural design effort and the process for tracing requirement to functions, insight into the process, and control of the effort are critical for the successful development of the capability needed by the warfighter. The DoD typically monitors and controls system technical development through implementation of the Baselines, Audits and Technical Reviews within an overarching Systems Engineering Process (SEP) (Defense Acquisition University, 2004, December, chap. 4). Because of the relatively immature software engineering environment, significantly more analysis and development of the requirements is required. In addition, the software architectural design effort is dependent on in-depth requirements analysis, is resource intensive, and must occur very early in the process. Effective management and implementation of design metrics is essential in developing software that meets the warfighters' needs. This management and metrics effort supplements and supports the system technical development through the Baselines, Audits and Technical Reviews.

The role of software ecosystems in the development and evolution of heterogeneously-licensed open architecture systems has received insufficient consideration. Such systems are composed of components potentially under two or more licenses, open source or proprietary or both, in an architecture in which evolution can occur by evolving existing components, replacing them, or refactoring. The software licenses of the components both facilitate and constrain the system's ecosystem and its evolution, and the licenses' rights and obligations are crucial in producing an acceptable system. Consequently, software component licenses and the architectural composition of a system determine the software ecosystem niche where a systems lies. Understanding and describing software ecosystem niches is a key contribution of this work. A case study of an open architecture software system that articulates different niches is employed to this end. We examine how the architecture and software component licenses of a composed system at design-time, build-time, and run-time help determine the system's software ecosystem niche and provide insight and guidance for identifying and selecting potential evolutionary paths of system, architecture, and niches.

This document provides information regarding architectural features of the ModSAF application. Various sections discuss the basic concepts of ModSAF, the physical and behavioral models, architectural support, functional components, design methodology, and the procedures for extending ModSAF with new objects or behaviors. The last chapter steps the reader through the process of defining, building, and executing new capabilities in ModSAF.

From the bitsavers.org collection, a scanned-in computer-related document. auspex :: m2000 :: M2000 Software Architecture Dec98

From the bitsavers.org collection, a scanned-in computer-related document. auspex :: m2000 :: M2000 Software Architecture Lab Dec98

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

YEROTH-ERP-3.0 SOFTWARE SYSTEM ARCHITECTURE !

YEROTH-ERP-3.0 SOFTWARE SYSTEM ARCHITECTURE !

YEROTH-ERP-3.0 SOFTWARE SYSTEM ARCHITECTURE !

This presentation, which Len Bass gave to the Academy of Software Engineering Education and Training on March 12, 2010, is based on the truism Software systems are constructed to satisfy business goals. The presentation also answers the questions raised by this truism: Why does the software architect need to know business goals? How does the software architect determine business goals for a system? Where in your curriculum is the material taught?

The software architecture for a software-intensive system defines the main elements of the system, their relationships, and the rationale for them in the system. Software architecture is fundamental to whether a system can achieve its quality objectives. Architecture evaluation is an approach for assessing whether a software architecture can support the system needs, especially its non-functional requirements (also known as quality requirements). Architecture evaluation can be used at different stages of a project, and is an effective way of ensuring design quality early in the lifecycle to reduce overall project cost and to manage risks. This report describes software architecture and architecture evaluation, and summarises some of the key benefits for software architecture evaluation that have been observed both in industry and in international Defence contexts. We make some general recommendations about architecture evaluation in the context of Australian defence acquisition.

The current state of the art techniques to describe and implement a hard real time embedded software architecture for missile systems range from inadequate to totally non-existent. Most of the existing software implementations within such systems consist of hand coded functionality, optimized for speed, with little or no thought to long term maintainability, and extensibility. Utilizing current state of the art software development technology, the first ever software architecture for hard real time missile software has been designed and successfully demonstrated. This component based layered abstraction pattern approach to software architecture revolutionizes reduced development time, cost, provides an order of magnitude decrease in error, and is the first such software architecture to function within the hard time constraints of the most extreme cases related to missile systems. Additionally, componentization of functionality allows for porting of software developed for one missile to any other missile with no modification. Hardware obsolescence is overcome by software abstraction layers which isolate the hardware instance from the software functionality providing a rapid, low cost transition of software from one instance of missile hardware to another. The end result of this research is a software architecture demonstrating the capability of managing complex functionality in an accurate, quantifiable, and cost effective manner.

SCA governs the structure and operation of software defined radios, enabling programmable radios to load waveforms, run applications, and network into an integrated system. Adherence to standards detailed in the SCA definition document allows hardware and software designers to know what equipment and programs to design. The SCA Hardware (HW) Framework tells the designer what minimum design specifications must be met by hardware devices. These specifications assure software written to the SCA guidance will run on SCA compliant hardware. Similar software specifications are provided for software applications. The core framework provides an abstraction layer between the waveform application and the software defined radio, enabling application porting to multiple vendors SDR products. NAVSYS is engaged in creating an SCA compliant prototype for an embedded Global Positioning System (GPS) waveform in a software defined radio. The intent is to optimize GPS services by providing position and time as an embedded waveform within a Software Defined Radio rather than requiring additional GPS chip sets. This paper will cover the design of the GPS devices and prototype software defined radio (PowerPC processor and Xilinx FPGAs) used to implement and test the GPS waveform under the SCA. This application necessitates the ability to switch tasking and adjust to various mission types within the radio framework. Test results are included showing the ability to run the GPS waveform under the SCA and demonstrating the GPS waveform with performance in tracking the GPS satellites. A discussion is also included on how the waveform could be ported to different SDRs running the SCA with different host processors and FPGAs. The flexibility of the design will allow SDR-enabled devices to be programmed to include GPS functionality running within the same radio that is supporting communications functions.

Modern weapon systems (including all space systems) are software-intensive, technology-driven systems; consequently, the early evaluation of software technologies is critical. Service Oriented Architecture (SOA) is a promising approach to implement Operationally Responsive Space (ORS) and Joint Warfighting Space (JWS). SOA qualifies as a Critical Technology Element (CTE), and as such requires a rigorous Technology Readiness Assessment (TRA) inquiry.

The first Carnegie Mellon(R) Software Engineering Institute (SEI) Software Architecture Technology User Network (SATURN) Workshop was held on April 6-7, 2005, at the SEI in Pittsburgh, Pennsylvania. Software systems engineers, architects, technical managers, and product managers exchanged best practices and lessons learned in applying SEI software architecture technology in an architecture-driven development or acquisition project. In the closing session, workshop participants noted the following highlights: peer collaboration, shared understanding, SEI technical staff presence, developing metrics that measure benefits, exploring case studies that highlight how to apply architecture-centric methods, learning what's new in software architecture, learning about the acquisition support available for software architecture, and agreeing that software architecture technology has reached the early majority. This report describes the workshop format, discussion, and results, as well as plans for future SATURN workshops.

A visual simulation software architecture is a reusable design for visual simulation applications. This thesis effort was the third stage in an ongoing refinement of such an architecture, named ObjectSim. The primary goals of this stage were to improve the architecture by eliminating its dependence on two platform-specific graphics libraries (named GL and Performer, from Silicon Graphics, Inc.), and to examine the potential for expanding the architecture to accommodate distributed simulations. The effort resulted in a new version of the architecture which allows the development of visual simulation applications which take full advantage of the aforementioned libraries without calling those libraries directly. This capability substantially improves the potential portability of future applications. ObjectSim also has other enhancements not found in its predecessors, but still does not accommodate distributed simulations. Insights into addressing the distributed simulation issue are, however, included in this thesis.

The architecture of a user interface software system can be described in terms of a fairly small number of key functional and structural choices. This report presents a design space that identifies these key choices and classifies the alternatives available for each choice. The design space is a useful framework for organizing and applying design knowledge. The report presents a set of design rules expressed in the terms of the design space. These rules can help a software designer to make good structural choices based on the functional requirements for a user interface system. Extension of this work might eventually provide automated assistance for structural design.

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.

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.

The ObjectAgent system is being developed to create an agent-based software architecture for autonomous distributed systems. Agents are used to implement all of the software functionality and communicate through simplified natural language messages. Decision-making and fault detection and recovery capabilities are built-in at all levels. During the first phase of development, ObjectAgent was prototyped in Matlab. A complete, GUI-based environment was developed for the creation, simulation, and analysis of multi-agent, multi-satellite systems. Collision avoidance and reconfiguration simulations were performed for a cluster of four satellites.

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/

Computer Organization And Design

Computer Organization And Design

The client is producing software-intensive, distributed systems in short development cycles (90 day increment spins). The DoD JCIDS process requires the documentation of systems in the form of certain DODAF products. Occasionally this documentation is created after the fact and not as a basis for Modeling & Simulation or software development (notion: coding is faster than architecting) Effort spent on architecture development is essentially wasted, since architecture products are not used for value-added delivery, and architecture models and code evolve separate from each other.

The client is producing software-intensive, distributed systems in short development cycles (90 day increment spins). The DoD JCIDS process requires the documentation of systems in the form of certain DODAF products. Occasionally this documentation is created after the fact and not as a basis for Modeling & Simulation or software development (notion: coding is faster than architecting) Effort spent on architecture development is essentially wasted, since architecture products are not used for value-added delivery, and architecture models and code evolve separate from each other.

The client is producing software-intensive, distributed systems in short development cycles (90 day increment spins). The DoD JCIDS process requires the documentation of systems in the form of certain DODAF products. Occasionally this documentation is created after the fact and not as a basis for Modeling & Simulation or software development (notion: coding is faster than architecting) Effort spent on architecture development is essentially wasted, since architecture products are not used for value-added delivery, and architecture models and code evolve separate from each other.

During many crises, access to sensitive emergency-support information is required to save lives and property. For example, for effective evacuations first responders need the names and addresses of non-ambulatory residents. Yet, currently, access to such information may not be possible because government policy makers and third-party data providers lack confidence that today's IT systems will protect their data. Our approach to the management of emergency information provides first responders with temporary, transient access to sensitive information, and ensures that the information is revoked after the emergency. The following contributions are presented: a systematic analysis of the basic forms of trusted communication supported by the architecture; a comprehensive method for secure, distributed emergency state management; a method to allow a user space application to securely display data; a multifaceted system analysis of the confinement of emergency information and the secure and complete revocation of access to that information at the closure of an emergency.

The software architecture of most systems is usually described informally and diagrammatically by means of boxes and lines. In order for these descriptions to be meaningful, the diagrams are understood by interpreting the boxes and lines in specific, conventionalized ways. The informal, imprecise nature of these interpretations has a number of limitations. In this paper we consider these conventionalized interpretations as architectural styles and provide a formal framework for their uniform definition. In addition to providing a template for precisely defining new architectural styles, this framework allows for analysis within and between different architectural styles.

The size, cost, and slow rate of change of Department of Defense (DOD) Information Technology (IT) systems make introducing new capabilities challenging. Without considering the whole system and its environment, design decisions may result in unintended operational and financial impacts, often not visible until later testing. These complex systems and their interactions are not cheap to maintain, impacting intellectual, programmatic, and organizational resources. Precise behavioral modeling offers a way to assess architectural design decisions prior to, during, and after implementation to mitigate the impacts of complexity, but this modeling cannot estimate those design decisions' effort and cost. This research introduces a methodology to extract Unadjusted Function Point (UFP) counts from architectural behavioral models utilizing a framework called Monterey Phoenix (MP), lightweight formal methods, and high-level pseudocode for use in cost estimation models such as COCOMO II. Additionally, integration test estimates are informed by extracts of MP model event traces. These unambiguous, executable architecture models and their views can be inspected and revised in order to facilitate communication with stakeholders, reduce the potential for software failure, and lower implementation costs.

The size, cost, and slow rate of change of Department of Defense (DOD) Information Technology (IT) systems make introducing new capabilities challenging. Without considering the whole system and its environment, design decisions may result in unintended operational and financial impacts, often not visible until later testing. These complex systems and their interactions are not cheap to maintain, impacting intellectual, programmatic, and organizational resources. Precise behavioral modeling offers a way to assess architectural design decisions prior to, during, and after implementation to mitigate the impacts of complexity, but this modeling cannot estimate those design decisions' effort and cost. This research introduces a methodology to extract Unadjusted Function Point (UFP) counts from architectural behavioral models utilizing a framework called Monterey Phoenix (MP), lightweight formal methods, and high-level pseudocode for use in cost estimation models such as COCOMO II. Additionally, integration test estimates are informed by extracts of MP model event traces. These unambiguous, executable architecture models and their views can be inspected and revised in order to facilitate communication with stakeholders, reduce the potential for software failure, and lower implementation costs.

Software Architecture Course Coursera

Thesis advisor(s): David R. Pratt