Dissertations on Software Architecture
The following dissertations on software architecture were extracted from the Dissertations Abstracts Online Database.
Dissertation Abstracts Online is a definitive subject, title, and author guide to virtually every American dissertation accepted at an accredited institution since 1861. Selected Masters theses have been included since 1962. In addition, since 1988, the database includes citations for dissertations from 50 British universities that have been collected by and filmed at The British Document Supply Centre. Beginning with DAIC Volume 49, Number 2 (Spring 1988), citations and abstracts from Section C, Worldwide Dissertations (formerly European Dissertations), have been included in the file.
Title: Achieving usability via design architecture and patterns:
The things we implement that affect usability
Author(s): Paul, Ashutosh
Degree: M.Comp.Sc.
Year: 2003
Pages: 00076
Institution:
Concordia University (Canada); 0228
Advisor: Adviser Ahmed Seffah
Source: MAI, 42, no. 03 (2003): p. 971 Standard No: ISBN: 0-612-83918-4
Abstract: Current, software architectures for interactive systems assumed that usability is only important when designing the user interface component including the presentation and dialogs. Therefore, most of the architectural models such as MVC and PAC de-coupled the application semantic and the user interface, which was essential for achieving usability. However, this fallacious dichotomy does not address all the usability concerns. For example, semantic feedback leads tight coupling between the application and the user interface, because it has to be analyzed at both the application and the presentation levels. There are two approaches to cope with semantic feedback. We can either place semantic feedback in the presentation or in the application. The two approaches result in much communication between the model and the views. This thesis proposes a new architectural model, called MVCforUsability, for incorporating usability concerns in software architecture. In particular, we discuss the cause/effect relationships that exist between the internal attributes that we generally use to assess the software quality and the usability factors that we use to quantify the usability of the software system. Our investigations propose the following methodological approach: (1) Identify the internal software attributes that affect software usability, such as modularity, functionality, etc. (2) Define the relationship between these internal attributes and external usability factors in terms of typical scenarios. (3) Describe design patterns or improve existing ones for each typical scenario. (4) Discuss how these patterns can be used to improve the MVC model.
SUBJECT(S) Descriptor: COMPUTER SCIENCE Accession No: AAIMQ83918 Database: Dissertations
Title: Adaptable protocol stack architecture for future sensor
networks
Author(s): Kumar, Rajnish
Degree: Ph.D.
Year: 2006
Pages: 00147
Institution: Georgia Institute of Technology; 0078
Advisor: Adviser Umakishore Ramachandran
Source: DAI, 68, no. 01B
(2006): p. 393
Abstract: Current technology trends suggest that futuristic wireless sensor networks (FWSN) are well equipped to support applications such as video surveillance and emergency response that have, in addition to high computation and communication requirements, a need for dynamic data fusion. Because of the dynamic and heterogeneous nature of FWSN environment, adaptability is emerging as a basic need in designing network protocols. Adaptability can be broadly supported at two levels: network level and node level. At the network level, different nodes are the entities that adapt their roles in a cooperative manner to improve network level cost metrics. Similarly, at the node level, different protocol modules are the entities that adapt their behavior in a holistic manner to best perform the roles assigned to the node. The goal of this thesis is to provide an adaptable protocol stack architecture for data fusion applications. Towards this goal, the thesis presents a software architecture called SensorStack, that raises and answers three set of questions. First, towards network-level adaptability, how best to dynamically adapt the placement of a fusion application task graph on the network? How best to support such an adaptation in an application-specific manner? We have designed a distributed role assignment algorithm and implemented it in the context of DFuse, a framework for distributed data fusion. Simulation results show that the role assignment algorithm significantly increases the network lifetime over static placement. Second, towards node-level adaptability, how best to facilitate cross-layering on a node to foster agile adaptation of a node's behavior commensurate with the network-level changes? SensorStack provides information exchange service (IES), a framework for cross-module information exchange. IES can be thought of as a centrally controlled bulletin-board within each node where different modules can post available data, or request information, and get notification when information becomes available. IES preserves the benefits of layering while facilitating adaptability. IES has been implemented in TinyOS and Linux, to show both the feasibility of the design as well as demonstrate the utility of cross-layering to increase application longevity. Third, how best to integrate node-level and network-level adaptability? How best to design a scalable dissemination protocol for sharing information across nodes? Towards tying the network and node level adaptability together, control data published in IES needs to be shared across the network. SensorStack uses a probabilistic broadcast-based dissemination service (IDS) for control data. Simulation experiments show that IDS allows nodes to share IES data more efficiently than using multiple diffusion trees. More broadly, an efficient and reliable dissemination of information over a large area is a critical ability of a sensor network for various reasons such as software updates and transferring large data objects (e.g., camera images). Thus, for bulk data broadcast, we design FBcast, an extension of the probabilistic broadcast based on the principles of modern erasure codes. Simulation results on TOSSIM show that FBcast offers higher reliability with lower number of retransmissions than traditional broadcasts.
SUBJECT(S) Descriptor: COMPUTER SCIENCE Accession No: AAI3248717 Database: Dissertations
Title: Adaptable software architecture generation using the NFR
approach
Author(s): Subramanian, Narayanan
Degree: Ph.D.
Year: 2003
Pages: 00225
Institution: The University of Texas at Dallas; 0382
Advisor: Supervisor Lawrence Chung
Source: DAI, 64, no. 04B (2003): p.
1802
Abstract: Adaptability is emerging as an important non-functional requirement (NFR) for software systems. Briefly stated, adaptability is the ability of software systems to withstand changes in their environment. In general, a software system will be adaptable provided its software architecture is itself adaptable in the first place. However, there are very few systematic methods to develop adaptable architectures and almost all of them fail to provide traceability to adaptability requirements and lack ability to represent NFRs, their decompositions, and design artifacts. This thesis uses the NFR Approach to generate adaptable architectures that not only provides a mechanism to trace architectures to requirements but also provides a rich ontology to represent various software artifacts. The thesis first explores the nature of adaptability itself, defines adaptability in a manner consistent with most of the current definitions of adaptability, and explores the constituents of a software architecture such as components, connections, patterns, constraints, styles and rationales. Next, the thesis identifies adaptable constituents of architecture and, to aid in this effort, the Adaptable Software Architecture Framework (ASAF) is proposed that helps in identifying and cataloging adaptable architectural constituents and subsequently searching the catalogs for the most appropriate constituents for a given problem. One of the premises used in this thesis is that using adaptable constituents helps generate adaptable architectures. The ASAF is based on the well-known NFR Framework that helps deal with NFRs at different software development phases including the architecture development phase. Using ASAF, the adaptable architectural constituents are identified and then stored in a knowledge base for later reuse; when required, a search through the knowledge base is made for the most appropriate constituents satisfying the particular requirements and an architecture is developed using these constituents. All these steps together comprise the NFR Approach as applied to adaptable architecture generation. The ASAF also helps in developing a framework for architecture adaptability metrics, called the Process-Oriented Metrics for Software Architecture Adaptability (POMSAA), which generates architectural adaptability metrics in an intuitive manner. POMSAA has been applied to two commercial systems developed at Anritsu Company. In order to validate ASAF, a prototype implementation called the Adaptable Software Architecture Assistant (ASAA) is developed that helps in the semi-automatic generation of adaptable architectures. ASAF and ASAA are used in three different software systems. The results of the application of ASAF and ASAA and the feedback from the industry experts are encouraging and give hope to systematic and semi-automatic generation of adaptable architectures.
SUBJECT(S) Descriptor: COMPUTER SCIENCE Accession No: AAI3087128 Database: Dissertations
Title: An adaptive distributed virtual computing environment
(ADViCE): Design and evaluation
Author(s): Kim, Dongmin
Degree: Ph.D.
Year: 2000
Pages: 00146
Institution: Syracuse University; 0659
Advisor: Adviser Salim Hariri
Source: DAI, 62, no. 03B (2000): p. 1463
Standard No: ISBN: 0-493-18897-5
Abstract: The next generation of network-centric applications will utilize a large number of computing and storage systems that are connected by global high-speed networks. We refer to the environment that provides transparent computing and communication services for large-scale parallel and distributed applications as a metacomputing environment. In this dissertation we present the design and the experimental results of the Adaptive Distributed Virtual Computing Environment, (ADViCE). ADViCE is a three-tiered software architecture that consists of an Application Editor to assist in application development and specification, an Application Scheduler to perform transparent application scheduling and resource configuration, and an ADViCE Runtime System to run and manage the application execution. The Application Editor is a web-based graphical user interface that helps users to develop parallel and distributed applications. In ADViCE the application development process is based on a data-flow programming paradigm. The Application Editor generates its output in terms of an Application Flow Graph (AFG) in which the nodes represent task computations and the links denote communication and/or synchronization among the nodes (tasks). The Application Editor provides menu-driven, functional building blocks of task libraries. A node of an AFG is a well-defined function or task selected from a given task library. ADViCE provides a large set of task libraries grouped in terms of their functionality, such as matrix operations. Fourier analysis. C3I (command, control, communication, and information), applications, etc. ADViCE provides an initial/runtime scheduler (Initial/Runtime Mapping Service) that provides efficient task-to-resource mapping of application flow graphs, and which uses performance prediction of individual tasks to achieve efficient resource allocations. Scheduling decisions are based on task specifications (i.e., hardware/software requirements) in the application flow graph, locations and configurations of resources, and up-to-date resource loads. The ADViCE Runtime System consists of two parts: the Application Control Service (ACS), and the Application Data Service (ADS). The ACS is responsible for monitoring the ADViCE resources, setting up the execution environment for a given application, monitoring the execution of application tasks on the assigned computers, and maintaining the performance, fault tolerance, and quality of service (QoS) requirements. The ADS is responsible for providing low latency and high-speed communication and synchronization services for inter-task communications.
SUBJECT(S) Descriptor: COMPUTER SCIENCE Accession No: AAI3009866 Database: Dissertations
Title: Adaptive dynamic thread scheduling for simultaneous
multithreaded architectures with a detector thread
Author(s): Shin, Chulho
Degree: Ph.D.
Year: 2002
Pages: 00107
Institution: University
of Southern California; 0208
Advisor: Adviser Jean-Luc Gaudiot
Source:
DAI, 64, no. 06B (2002): p. 2760
Abstract: Simultaneous Multithreading (SMT) attempts to attain the high resource utilization by allowing instructions from multiple independent threads to coexist in a processor and compete for shared resources. Earlier studies, however, have shown that the performance of a realistic SMT architecture begins to saturate as the number of hardware contexts increases beyond four or five. In this work, we attempt to prove our contention that a single fixed hardware thread scheduling strategy cannot provide optimal results for the various unpredictable thread combinations it faces. We propose an approach that partially schedules threads in software in the form of a detector thread at nominal hardware and software costs. Our approach offers the capability to adaptively switch thread scheduling policies depending on the situations which are likely to vary constantly in a hard-to-predict manner. We show that there is much room for performance improvement for the adaptive dynamic thread scheduling approach. The results we have obtained by simulating a realistic SMT architecture show that no single fetch policy is the best solution for more than 50% of the total time. We show that significant performance improvement for SMT with eight contexts can be attained by allowing switching of fetch policies. We propose a software architecture for the detector thread and evaluate various heuristics for determining better fetch policies which comprise the core function of the software. We found that, under a restrictive configuration, our approach could outperform a fixed scheduling by up to 30%.
SUBJECT(S) Descriptor: COMPUTER SCIENCE ENGINEERING, ELECTRONICS AND ELECTRICAL Accession No: AAI3093914 Database: Dissertations
Title: An adaptive integration architecture for software reuse
Author(s): Williams, Denver Robert Edward
Degree: Ph.D.
Year: 2001
Pages: 00221
Institution: University of Central Florida; 0705
Advisor: Major Professor Ali Orooji
Source: DAI, 62, no. 05B (2001): p.
2388 Standard No: ISBN: 0-493-24058-6
Abstract: The problem of building large, reliable software systems
in a controlled, cost-effective way, the so-called software crisis problem, is
one of computer science's great challenges. From the very outset of computing
as science, software reuse has been touted as a means to overcome the software
crisis issue. Over three decades later, the software community is still
grappling with the problem of building large reliable software systems in a
controlled, cost effective way; the software crisis problem is alive and well.
Today, many computer scientists still regard software reuse as a very powerful
vehicle to improve the practice of software engineering. The advantage of
amortizing software development cost through reuse continues to be a major
objective in the art of building software, even though the tools, methods,
languages, and overall understanding of software engineering have changed
significantly over the
Years. Our work is primarily focused on the
development of an Adaptive Application Integration Architecture Framework.
Without good integration tools and techniques, reuse is difficult and will
probably not happen to any significant
Degree. In the development of the
adaptive integration architecture framework, the primary enabling concept is
object-oriented design supported by the unified modeling language. The concepts
of software architecture, design patterns, established a generic framework.
This framework is applied to solve the Enterprise Application Integration (EAI)
problem in the telecommunications operations support system (OSS) enterprise
marketplace. The proposed adaptive application integration architecture
framework facilitates application reusability and flexible business process
re-engineering. The architecture addresses the need for modern businesses to
continuously redefine themselves to address changing market conditions in an
increasingly competitive environment. We have developed a number of Enterprise
Application Integration design patterns to enable the implementation of an EAI
framework in a definite and repeatable manner. The design patterns allow for
integration of commercial off-the-shelf applications into a unified enterprise
framework facilitating true application portfolio interoperability. The notion
of treating application services as infrastructure services and using business
processes to combine them arbitrarily provides a natural way of thinking about
adaptable and reusable software systems. We present a mathematical formalism
for the specification of design patterns. This specification constitutes an
extension of the basic concepts from many-sorted algebra. In particular, the
notion of signature is extended to that of a vector, consisting of a set of
linearly independent signatures. The approach can be used to reason about
various properties including efforts for component reuse and to facilitate
complex large-scale software development by providing the developer with design
alternatives and support for automatic program verification.
SUBJECT(S) Descriptor: COMPUTER SCIENCE Accession No: AAI3013917 Database: Dissertations
Title: ADVANCES IN ARCHITECTURES AND ALGORITHMS FOR HIGH
PERFORMANCE ROBOT CONTROL
Author(s): WHITCOMB, LOUIS LITCHFIELD
Degree:
PH.D.
Year: 1992
Pages: 00209
Institution: YALE UNIVERSITY; 0265
Source: DAI, 53, no. 10B, (1992): 5380
Abstract: This thesis addresses two practical problems in robot control. The first problem is how, in order to implement control algorithms whose computational need exceeds the most powerful available computer, to harness multiple computers to do the job. In particular performance measures of update and latency are defined for distributed digital controllers. These quantities are measured in an actual working system, and experimentally demonstrated (i) to depend intimately on both the computation and communication structure of the implementation vary dramatically with changes in the system structure, a significant point which has been largely ignored in the robotics literature, and (ii) to vary dramatically with changes in the system communication protocol. The effect controller latency and update rate on stability and performance of closed loop robot tracking is experimentally demonstrated. As a testbed for the experiments reported herein, a distributed robot control hardware and software architecture is developed for the Yale-GMFanuc A-500 robot arm. This implementation (i) demonstrates the advantages of message passing architectures over conventional shared-memory bus-based architectures, (ii) utilizes a modular architecture comprised of (at present) control, actuator, and host subsystems and (iii) supports the utility medium-grained real-time distributed control architectures. The second problem addressed in this thesis is the mathematical development and comparative experimental testing of a class of globally stable adaptive control laws for robot reference trajectory tracking. This class of control laws is the only reported class of controllers whose stability can be globally demonstrated with respect to the commonly accepted rigid-body robot dynamical model. A new member of this class, an adaptive controller for reference trajectory tracking of robot arms, is presented with a rigorous proof of global stability. Finally, this thesis presents the first comparative experimental study of the new and several established globally stable adaptive controllers. The study, obtained from both a GMFanuc A-500 industrial arm and the new "Yale Buhgler" three degree of freedom direct drive juggling robot (i) reconciles several previous contrasting empirical studies, (ii) demonstrates and compares the superior tracking performance of the adaptive algorithms, and (iii) examines contexts which compromise their advantage.
SUBJECT(S) Descriptor: ENGINEERING, ELECTRONICS AND ELECTRICAL ENGINEERING, INDUSTRIAL COMPUTER SCIENCE Accession No: AAG9306978 Database: Dissertations
Title: Agent-based simulation of socio-technical systems: Software
architecture and timing mechanisms
Author(s): Lee, Seung Man
Degree:
Ph.D.
Year: 2002
Pages: 00142
Institution: Georgia Institute of
Technology; 0078
Advisor: Director Amy R. Pritchett
Source: DAI, 63,
no. 12B (2002): p. 6035 Standard No: ISBN: 0-493-93192-9
Abstract: An agent-based simulation was proposed for the analysis of large-scale complex socio-technical systems in which various types of entities interact with each other to achieve their own goals. The main issues that must be addressed for agent-based simulation to be a valuable design and effective analysis tool were demonstrated. An agent-based simulation architecture using an object-oriented framework was developed in order to resolve these issues. The agent-based simulation architecture allows heterogeneous agents with varying fidelity to be incorporated into the simulation. Timing mechanisms that advance simulation time and select the proper agent to be executed are crucial in simulations to yield correct simulation results. New timing mechanisms, asynchronous with complete resynchronization and asynchronous with partial resynchronization, were developed to improve the computational efficiency of large-scale agent-based simulation. The experiment comparing different timing methods highlighted the gains in computational efficiency achieved with the new timing mechanisms and also emphasized the importance of identifying when agents must be synchronized for proper interactions. A methodology of evaluating the performance of timing mechanisms in terms of computational efficiency and accuracy was developed by recasting the decision problem of when agents should be synchronized for correct interactions as a signal-detection problem in which it is desired to minimize both false alarms and missed detections in the face of uncertainty about the future dynamics. An intelligent mechanism for predicting these interaction times was proposed and developed using a backpropagation neural network. An experiment was conducted to compare the performance of this mechanism with conservative methods of predicting interaction times. It was found that the modular, intelligent prediction mechanism provides significant improvement over more conservative prediction methods in terms of computational efficiency and accuracy.
SUBJECT(S) Descriptor: ENGINEERING, INDUSTRIAL Accession No: AAI3073492 Database: Dissertations
Title: AIRCRAFT PRELIMINARY DESIGN SOFTWARE DEVELOPMENT
Author(s): SASTRAHUSADA, SAJOGI
Degree: M.S.
Year: 1992
Pages:
00188
Institution: MISSISSIPPI STATE UNIVERSITY; 0132
Advisor: Major
Professor: A. GEORGE BENNETT
Source: MAI, 32, no. 01, (1992): 0288
Abstract: The objective of this study is to develop a software architecture that implements the aircraft preliminary design computation for educational purposes. The software uses menus to guide students through the design process easily. It provides an editor capability to allow the student to change variables for parameter studies. For consistency, the program utilizes a single database to store all aircraft parameters. Help text is provided for most screen displays for quick assistance. In addition, graphic utilities are included to provide the student with displays of the aircraft geometry, mission constraints, and performance plots. The software is designed to be user-friendly, and can be easily modified. Additional subroutines can also be added to perform new functions. The preliminary design software modules include mission analysis, preliminary sizing, geometry, weight estimates, aerodynamics, propulsion, performance, and stability and control.
SUBJECT(S) Descriptor: ENGINEERING, AEROSPACE Accession No: AAG1353421 Database: Dissertations
Title: Analytical design of evolvable software for high-assurance
computing
Author(s): Hoover, Carol Lynn
Degree: Ph.D.
Year: 2001
Pages: 00310
Institution: Carnegie-Mellon University; 0041
Advisor:
Adviser Daniel P. Siewiorek
Source: DAI, 62, no. 01B (2001): p. 421
Standard No: ISBN: 0-493-11609-5
Abstract: Software is a ubiquitous feature of today's world. The goodness of products and services is frequently dependent on the goodness of the related software. Optimal software performs correctly and requires minimal effort and cost to develop and maintain. The development of optimal software is an admirable goal but is difficult to achieve. In particular, software maintenance and evolution is costly and error-prone. The significance of the problem is magnified for high-assurance applications which require the certainty that the software will behave reliably despite budget constraints and product evolution. Though automated software development is the ideal solution, design for evolution is the practical solution. For most applications, analysis of the required behavior (behavioral analysis) and translation into a blueprint for building the software (software design) are necessary. High-level design involves the organization of the required behavior into building blocks or components. Design for evolution is the generation of a software architecture that can be changed with minimal human effort to produce a class of similar applications. Design for evolution makes feasible the cost-effective development of high-assurance applications. This dissertation presents a semi-automatable research approach for designing an evolvable software architecture. The research approach focuses on the partition of basic elements of a software solution into reusable components that localize the effects of change. The input to the partitioning process is a set of software requirements along with an analysis of the required behavior and planned or feasible evolution of the product line. The output is a partition of the required behavior into components that reduce the effort associated with developing a software product line. The dissertation provides an analytical verification of the research approach through proof and constructive examples. Empirical results validate the effectiveness of the research approach in comparison to human intuition, experience, or other training. The research approach is novel and fills a gap in the systematic generation of software architectures that minimize the effort associated with product-line evolution. The dissertation describes in detail the degree to which the research approach is automatable and specifies, more generally, future research needed to achieve full automation of software architecture generation.
SUBJECT(S) Descriptor: ENGINEERING, ELECTRONICS AND ELECTRICAL COMPUTER SCIENCE Accession No: AAI3002741 Database: Dissertations
Title: THE APPLICATION OF OPTIMAL TRANSPUTER ARCHITECTURE TO
CONCURRENT PROCESSING IN THE IMPLEMENTATION OF VISION PROCESSING ALGORITHMS
Author(s): BENNETT, IAN BRAMLEY
Degree: PH.D.
Year: 1989
Pages:
00320
Institution: COUNCIL FOR NATIONAL ACADEMIC AWARDS (UNITED KINGDOM);
0935
Source: DAI, 50, no. 10B, (1989): 4621
Abstract: Available from UMI in association with The British Library. Repetitive low level image processing transformations can be performed at high speeds by SIMD arrays, DSP and dedicated VLSI devices. These strategies cannot be adopted with more complex and time consuming data dependent algorithms. A flexible and programmable component must be used, and the use of many such devices in parallel, using dynamic load balancing techniques, is necessary to enable acceptable execution performance to be obtained. The transputer is a powerful new microprocessor with unique on chip communications facilities. Together with the new parallel programming language, occam, the transputer was specifically designed for parallel processing applications. Large transputer networks can be used for computationally intensive applications. This work has investigated the use of transputers for performing image processing algorithms of all three levels of complexity. Techniques were devised and implemented for the execution of low, medium and high levels of image processing algorithms on a multi-transputer network. A software architecture using SUPPLY and DEMAND processes was designed, and dynamic work load balancing was achieved, operating on a ternary tree network of up to 32 transputers. Some 80 image processing algorithms were successfully implemented within the software architecture. In particular, the more complex operation of Feature Extraction was achieved using the multi-transputer system. The Features extracted, involving Convex Hull, Convex Hull Deficiencies, Areas and Perimeters, and Shape Factors were used to build a Feature Vector. The use of this Feature Vector in Scene Interpretation, to realise Learn and Recognise functions has been investigated. The results of the work clearly show that while the system proposed is not as effective at executing repetitive, data intensive transformations as methods mentioned earlier, it can execute more complex Feature Extraction and Scene Interpretation algorithms efficiently. An Efficiency of 85% was achieved for Convex Hull formation, using 32 transputers.
SUBJECT(S) Descriptor: COMPUTER SCIENCE Accession No: AAGDX87669 Database: Dissertations
Title: AN APPROACH TO SOFTWARE ARCHITECTURE DESIGN SPECIFICATION
Author(s): YANG, CHEN-CHAU
Degree: PH.D.
Year: 1980
Pages:
00140
Institution: NORTHWESTERN UNIVERSITY; 0163
Source: DAI, 41, no.
06B, (1980): 2250
SUBJECT(S) Descriptor: COMPUTER SCIENCE Accession No: AAG8026955 Database: Dissertations
Title: AQUA: AN ADAPTIVE QUALITY OF SERVICE ARCHITECTURE FOR
DISTRIBUTED MULTIMEDIA APPLICATIONS
Author(s): KRISHNAMURTHY, LAKSHMAN
Degree: PH.D.
Year: 1997
Pages: 00186
Institution: UNIVERSITY
OF KENTUCKY; 0102
Advisor: Director: RAJ YAVATKAR
Source: DAI, 58, no.
02B, (1997): 0801
Abstract: Multimedia applications demand predictable quality of service (QoS) and access to endsystem and network resources. For example, a network-based video player must be able to execute thirty times a second and must obtain the necessary amount of CPU time, memory, bus bandwidth, and network bandwidth to be able to receive a compressed video stream, uncompress it, and display it without any glitches. Operating systems (OS) and network resources must be managed to deliver predictable QoS. The problem of providing predictable QoS to multimedia applications in a general-purpose OS is challenging for several reasons. First, an application's resource requirements cannot be estimated in advance and tend to vary significantly during its lifetime. Second, the amount of available resources on an endsystem changes dynamically at run time. Third, applications need simultaneous access to several resources to accomplish a task; these resources must be managed in an integrated fashion to deliver the desired QoS. This research studies the characteristics and requirements of multimedia applications and observes that these applications are flexible in their resource requirements and are amenable to graceful adaptation when required resources are in short supply. Based on these observations, this these proposes a unifying software architecture for resource management to deliver predictable QoS guarantees to multimedia applications. The new architecture, called AQUA (Adaptive QUality of Service Architecture), is based on an innovative, cooperative model of resource management. In AQUA, applications specify their resource requirements in advance, but may provide only a partial QoS specification. The OS allocates the requested resource(s) based on an estimate of available resources. As the application's resource requirements or the resource availability changes at run time, applications and the OS renegotiate resource allocations to ensure predictable service within the constraints of available resources. Applications are expected to dynamically adapt when adequate resources are not available or additional resources become available. For each resource producer, AQUA typically includes two components, a resource controller and a resource scheduler. Resource consumers use a QoS manager that estimates resource needs and negotiates on their behalf. A resource-independent negotiation library allows resource negotiation, and a usage-estimation library provides a resource-independent interface to estimate resource usage and QoS delivery. These components spare an application programmer the burden of handling the details of QoS negotiation. AQUA has been implemented and evaluated in a network of Sun Workstations running Solaris 2.4 interconnected using FORE ATM switches. AQUA has been applied to resources such as the CPU, the network-I/O resource, the ATM network, and the display colormap. The thesis explores how applications can manage multiple resources in an integrated fashion, and how AQUA can be used to implement a QoS-aware a World Wide Web. Our experimental evaluation demonstrates the viability and versatility of AQUA in providing predictable QoS and access to endsystem resources. A key contribution of our work is the cooperative model of organizing applications and resource providers to achieve predictable QoS in a dynamic and adaptive fashion. In the process of applying the framework to resources in a commercial OS, we discovered many shortcomings of existing systems in resource management and have developed pragmatic approaches to solve these problems.
SUBJECT(S) Descriptor: COMPUTER SCIENCE Accession No: AAG9722145 Database: Dissertations
Title: Architectural level risk assessment
Author(s): Hassan,
Ahmed E.
Degree: Ph.D.
Year: 2004
Pages: 00189
Institution:
West Virginia University; 0256
Advisor: Chairs Hany H. Ammar Katerina D.
Goseva-Popstojanova
Source: DAI, 65, no. 12B (2004): p. 6552 Standard No:
ISBN: 0-496-92380-3
Abstract: Many companies develop and maintain large-scale software systems for public and financial institutions. Should a failure occur in one of these systems, the impact would be enormous. It is therefore essential, in maintaining a system's quality, to identify any defects early on in the development process in order to prevent the occurrence of failures. However, testing all modules of these systems to identify defects can be very expensive. There is therefore a need for methodologies and tools that support software engineers in identifying the defected and complex software components early on in the development process. Risk assessment is an essential process for ensuring high quality software products. By performing risk assessment during the early software development phases we can identify complex modules, thus enables us to enhance resource allocation decisions. To assess the risk of software systems early on in the software's life cycle, we propose an architectural level risk assessment methodology. It uses UML specifications of software systems which are available early on in the software life cycle. It combines the probability of software failures and the severity associated with these failures to estimate software risk factors of software architectural elements (components/connectors), the scenarios, the use cases and systems. As a result, remedial actions to control and improve the quality of the software product can be taken. We build a risk assessment model which will enable us to identify complex and noncomplex software components. We will be able to estimate programming and service effort, and estimate testing effort. This model will enable us also to identify components with high risk factor which would require the development of effective fault tolerant mechanisms. To estimate the probability of software failure we introduced and developed a set of dynamic metrics which are used to measure dynamic of software architectural elements from UML static models. To estimate severity of software failure we propose UML based severity methodology. Also we propose a validation process for both risk and severity methodologies. Finally we propose prototype tool support for the automation of the risk assessment methodology.
SUBJECT(S) Descriptor: ENGINEERING, ELECTRONICS AND ELECTRICAL COMPUTER SCIENCE Accession No: AAI3159339 Database: Dissertations
Title: Architectural solutions to agent-enabling e-commerce
portals with pull/push abilities
Author(s): Ulmer, David B.
Degree:
D.P.S.
Year: 2004
Pages: 00134
Institution: Pace University; 0483
Advisor: Adviser Lixin Tao
Source: DAI, 65, no. 02B (2004): p. 852
Abstract: The Internet-based World Wide Web has had an enormous impact on business and society. It has succeeded largely because of its open architecture and ease-of-use. Although it was originally designed for distributed and interactive information sharing, it has evolved into a powerful business platform in which electronic commerce is driving fundamental change in consumer buying patterns. However, because of the ubiquitous nature of electronic marketplaces on the Internet, buyers have an enormous variety of items available to them, effectively overwhelming them with choices. A new e-commerce paradigm is in high demand in which software agents can play an important role in automating many transactional activities like the discovery, comparison, selection, purchase of products or services, and the shipping of products. But so far, the Web-based marketplaces are mainly designed for human interaction and do not support efficient interaction with software agents. This dissertation studies the current e-commerce software architecture and the special needs of transaction software agents, enhances the current e-commerce software architecture for agent support, and designs the corresponding interfaces and supporting systems. The interface design and supporting systems will accommodate the format and interface needs of the human users, while enhancing the transactional capabilities of software agents through an adaptable and robust interface. Transaction agents can operate in either a pull or push manner, which require different supporting systems and architecture. Web services are utilized that facilitate an Agent-Enabling Interface (AEI) API for exposing the business logic of an e-commerce portal by leveraging existing Internet protocols. This design is further enhanced to enable the transaction agent to react to marketplace changes and delayed transactions via callback from the server, implemented through a deviation from the current software architecture with a server-side Callback tier. The client-side supporting system is also proposed and designed to work with generic transaction agents. It features a Generic Middleware between Agents and Portals (GMAP) that insulates the transaction agent and minimizes its modification to enable e-commerce portal interoperability. The supporting systems on the client and server communicate via Web services and provide the functionality required to enable a transaction agent to address, and call the business logic of an e-commerce portal thus preserving the back-end of the portal. In summary, this research defines solutions that improve the interoperability between transaction software agents and e-commerce portals via client and server supporting systems. Using an exposed business API, this enhancement enables agents to execute the same business logic as the human-based interface thus eliminating changes to the back-end of the portal to support transaction agents.
SUBJECT(S) Descriptor: COMPUTER SCIENCE BUSINESS ADMINISTRATION, MANAGEMENT Accession No: AAI3119929 Database: Dissertations
Title: Architectural styles and the design of network-based
software architectures
Author(s): Fielding, Roy Thomas
Degree: Ph.D.
Year: 2000
Pages: 00162
Institution: University of California,
Irvine; 0030
Advisor: Chair Richard N. Taylor
Source: DAI, 61, no. 07B
(2000): p. 3683 Standard No: ISBN: 0-599-87118-0
Abstract: The World Wide Web has succeeded in large part because
its software architecture has been designed to meet the needs of an
Internet-scale distributed hypermedia system. The Web has been iteratively
developed over the past ten
Years through a series of modifications to the
standards that define its architecture. In order to identify those aspects of
the Web that needed improvement and avoid undesirable modifications, a model
for the modern Web architecture was needed to guide its design, definition, and
deployment. Software architecture research investigates methods for determining
how best to partition a system, how components identify and communicate with
each other, how information is communicated, how elements of a system can
evolve independently, and how all of the above can be described using formal
and informal notations. My work is motivated by the desire to understand and
evaluate the architectural design of network-based application software through
principled use of architectural constraints, thereby obtaining the functional,
performance, and social properties desired of an architecture. An architectural
style is a named, coordinated set of architectural constraints. This
dissertation defines a framework for understanding software architecture via
architectural styles and demonstrates how styles can be used to guide the
architectural design of network-based application software. A survey of
architectural styles for network-based applications is used to classify styles
according to the architectural properties they induce on an architecture for
distributed hypermedia. I then introduce the Representational State Transfer
(REST) architectural style and describe how REST has been used to guide the
design and development of the architecture for the modern Web. REST emphasizes
scalability of component interactions, generality of interfaces, independent
deployment of components, and intermediary components to reduce interaction
latency, enforce security, and encapsulate legacy systems. I describe the
software engineering principles guiding REST and the interaction constraints
chosen to retain those principles, contrasting them to the constraints of other
architectural styles. Finally, I describe the lessons learned from applying
REST to the design of the Hypertext Transfer Protocol and Uniform Resource
Identifier standards, and from their subsequent deployment in Web client and
server software.
SUBJECT(S) Descriptor: COMPUTER SCIENCE Accession No: AAI9980887 Database: Dissertations
Title: Architecture assessment of information-system families: A
practical perspective
Author(s): Dolan, Thomas John
Degree: Ph.D.
Year: 2001
Pages: 00232
Institution: Technische Universiteit
Eindhoven (The Netherlands); 0426 Publication: Technische Universiteit
Eindhoven, Den Dolech 2, Eindhoven, The Netherlands
Source: DAI, 63, no.
01C (2001): p. 122 Standard No: ISBN: 90-386-0943-4
Abstract: Information processing and the software systems supporting it-information systems-are playing a more prominent role in modern society as information in digital form is increasingly being utilised and exchanged between corporations and individuals. The growing market opportunities for information systems coupled with the ongoing skills shortage across the entire software-development industry has led to an increasing interest in a product-family approach to information-system development. This approach seeks to apply an industrial and market perspective to information-system development and life-cycle management. From this perspective an information system (or a related set of such systems) is produced efficiently and sold to a market such that the multiple individual customers comprising the market can customise the system to their own situation. Efficiency is achieved through reuse based on commonality in the application and technology domains, and customisation is supported through the provision of flexibility in the products and services associated with the family. The family approach to product development has proven successful in other industries e.g. the automobile, and contrasts with the project-based, single-customer approach associated with the majority of conventional information-system development. Balancing the forces of flexibility (accommodating change) and reuse (controlling costs) in the dynamic market and technology environments associated with information-system families is a non-trivial challenge. The work described in this thesis supports the information-system family producer in managing the flexibility required of the family, via leveraging an essential family asset-the architecture. An outline method (FAAM-Family Architecture Assessment Method) is provided enabling the family development team to elicit, analyse, and uncover architectural support for a selection of system qualities associated with important flexibility requirements. The method facilitates ongoing family architecture improvement by enabling a structured dialogue between stakeholders and architect in relation to the selected system qualities, from an early phase in the family life cycle. The method is based on the pioneering work of the SAAM method [Kazman, et al., 1996] in software architecture analysis. SAAM uses stakeholder input to derive requirements and scenarios to illustrate system qualities, in indicating how well an architecture addresses a set of system qualities. The FAAM method has been validated in two industrial case studies, which have been reported herein. These serve not only to test the theory of the method but also provide concrete illustration of how the method is implemented. (Abstract shortened by UMI.)
SUBJECT(S) Descriptor: COMPUTER SCIENCE Accession No: AAIC807240 Database: Dissertations
Title: An architecture-based approach for service-oriented
software development
Author(s): Mudiam, Sudhakiran Venkata
Degree:
Ph.D.
Year: 2003
Pages: 00142
Institution: Arizona State
University; 0010
Advisor: Adviser Gerald C. Gannod
Source: DAI, 64, no.
06B (2003): p. 2756
Abstract: Legacy applications are prime candidates for software
reuse as they have been relied upon for several
Years and often have a
strong organizational commitment. Migrating existing legacy applications is a
very likely requirement when moving to and adopting a new technology. A
service-based development paradigm is one in which components are viewed as
services. In this model, services interact and can be providers or consumers of
data and behavior. This dissertation describes an architecture-based approach
for the synthesis of services from legacy components and their subsequent
integration with service-requesting client applications. The technique utilizes
an architecture description language to describe services and achieves run-time
integration using current middleware technology. This dissertation demonstrates
and evaluates the approach by synthesizing and integrating example applications
using the automated tools that have been created. The approach involves
capturing the interface of legacy components as a software architecture
specification. Once specified, the architecture specification is used to
generate a service by wrapping the legacy components rising automated tools. In
addition, once these services are stored in a repository, a software
architecture specification is used to specify a client to utilize the services.
This specification is then used to generate the client application using
another automated cool. When the generated client application is executed or a
network, it requests the interested services and binds and integrates with
there.
SUBJECT(S) Descriptor: COMPUTER SCIENCE Accession No: AAI3094979 Database: Dissertations
Title: ARCHITECTURE-BASED SPECIFICATION-TIME SOFTWARE EVOLUTION
(SUBTYPING)
Author(s): MEDVIDOVIC, NENAD
Degree: PH.D.
Year: 1999
Pages: 00265
Institution: UNIVERSITY OF CALIFORNIA, IRVINE; 0030
Advisor: Chair: RICHARD N. TAYLOR
Source: DAI, 59, no. 11B, (1999):
5937
Abstract: Software architectures shift the focus of developers from lines-of-code to coarser-grained architectural elements and their overall interconnection structure. Architectures have the potential to substantially improve the development and evolution of large, complex, multi-lingual, multi-platform, long-running systems. In order to achieve this potential, specific architecture-based modeling, analysis, and evolution techniques must be provided. To date, software architecture research has produced an abundance of techniques for architecture modeling and analysis, while largely neglecting architecture-based evolution. This dissertation motivates, presents, and validates a methodology for software evolution at architecture specification-time. The methodology consists of a collection of techniques that, individually and in concert, support flexible, systematic evolution of software architectures in a manner that preserves the desired architectural relationships and properties. The methodology is comprehensive in its scope: it addresses the evolution of individual architectural building blocks-components and connectors-as well as entire architectures; it also supports the transfer of (evolved) architecture-level decisions into implemented systems. The unique aspects of the methodology are: component evolution via heterogeneous subtyping, well suited to a wide range of design and reuse circumstances; connector evolution , facilitated by evolvable interfaces and heterogeneous communication protocols; architecture evolution, facilitated by minimal component interdependencies and heterogeneous, flexible connectors; analysis of architectures for consistency, where the architect possesses the authority to override the analysis tool; off-the-shelf component and connector reuse, necessary for economic viability in large-scale software development; and implementation generation, aided by a well-bounded implementation space and accomplished via a component-based, evolvable environment. The dissertation is validated empirically, by constructing a series of demonstration applications, and analytically, by evaluating the manner and degree to which the applications validate the claims of the dissertation. The dissertation is concluded by examining its impact on the tension between flexibility and formality, which characterizes current software architecture research.
SUBJECT(S) Descriptor: COMPUTER SCIENCE Accession No: AAG9912025 Database: Dissertations
Title: An architecture for authorization and delegation in
distributed object-oriented agent systems
Author(s): Nikander, Pekka Ilmari
Degree: D.Tech.
Year: 1999
Pages: 00226
Institution:
Teknillinen Korkeakoulu (Helsinki) (Finland); 5766 Publication: Pekka Nikander,
Suvannontie 12 A 1, FIN-00510, Helsinki, Finland
Source: DAI, 61, no. 03C
(1999): p. 852 Standard No: ISBN: 952-91-0786-2
Abstract: Public key infrastructures and authentication protocols, in the sense they are currently known, have been publicly studied since 1978 [23]. In this work I demonstrate how I, together with the research group I have had the privilege to direct, have further developed these concepts in the Object-Oriented field. In our research, we have implemented a public key based system that allows distributed agents to securely co-operate in an insecure network. In this thesis, I focus on the following four interrelated aspects. First, I define a concrete secure software architecture for distributed software agents. Second, I describe our implementation of an Object-Oriented protocol framework for cryptographic protocols. Third, I show how an authorization based Public Key Infrastructure can be used to manage the security of Java based, Object-Oriented software Agents. And finally, I describe how this infrastructure can be extended to support distributed, secure agent execution and permission delegation. In the work as a whole, my goal has been an open, extensible security architecture that allows distributed software agents to co-operate securely. In this context, security1 mainly means two things. First, the agents must be able to trust in the underlying computing machinery, and also trust in each other. Second, the agents must be able to delegate rights among themselves, and to create secure connections between any two communicating agents. The distributed secure software architecture can be considered a high level framework where the protocol framework and the Public Key Infrastructure (PKI) plug in. It defines the security related subsystems for typical Object-Oriented execution environments, focusing on distribution and thereby cryptographic means of implementing security. The Object-Oriented protocol framework provides a supportive base, on top of which various cryptographic protocols can be built. In this sense, cryptographic protocols include both session encryption protocols used to protect actual data traffic between communicating parties and key management and authentication protocols, used to create secure channels used for the actual data transfer. The Public Key Infrastructure (PKI) is needed to provide sufficient trust relationships and an initial security context to the communicating parties so that the authentication and key management protocols can be operated. In this work, my sole focus has been on an authorization based (as opposed to identity based) PKI. In practical terms, this means that the secure channels created within such an authorization framework automatically get strong relationship semantics, providing the communicating parties explicit information about the level and form of trust mediated. Finally, the architecture with its protocol and PKI components makes it possible to create Object-Oriented software agents, distribute them into the network, and let them collaborate in a secure way. In our system, agents are represented as collections (JAR packages) of Java classes. The agent code may be loaded into a trusted Java Virtual Machine, where it is run. The running agents are able to create and evaluate trust relationships between each other, allowing dynamic delegation and creation of secure communication channels. 1Security per se is, naturally, a much larger concept. However, for the purposes of this study, I have concentrated on these two aspects of security in defining the presented security architecture.
SUBJECT(S) Descriptor: COMPUTER SCIENCE Accession No: AAIC803129 Database: Dissertations
Title: AN ARCHITECTURE FOR END-TO-END QUALITY OF SERVICE PROVISION
AND ITS EXPERIMENTAL VALIDATION
Author(s): NAHRSTEDT, KLARA
Degree:
PH.D.
Year: 1995
Pages: 00194
Institution: UNIVERSITY OF
PENNSYLVANIA; 0175
Advisor: Supervisor: JONATHAN M. SMITH
Source: DAI,
56, no. 08B, (1995): 4432
Abstract: High-speed cell switched networks and new computer peripherals supporting various media types suggest novel applications. In particular, these technologies enable the class of long-lived distributed multimedia applications with strict real-time requirements. Until now, a dedicated circuit was required to meet these requirements, as today's packet switched network and end-point technologies (e.g., workstation operating systems) cannot support this application class. This thesis argues that a proper software architecture coupled with cell switched networks can approximate the behavior of a dedicated circuit. The use of software to control multiplexing offers the additional benefit of programmable service customization. This thesis proposes one architecture, and demonstrates its success experimentally. My approach negotiates requirements and guarantees between the application and the network, including the operating system (OS), in a call set-up period prior to use of the network by the application. I establish customized virtual circuits and allocate resources appropriate to the application requirements and OS/network capabilities. These customizations can be renegotiated dynamically. To facilitate this resource management process I have developed a new paradigm, called 'QoS Brokerage', to support Quality of Service. This paradigm requires new services and protocols across all layers of the protocol stack, as well as rearchitecting the application/network interface. I used an application-driven approach to define requirements for the experimental evaluation of our architecture and the brokerage process. This forced an examination of requirement representations and an investigation of the differences between application and network models for QoS, control flows, and guarantee provision in networks. The architecture addresses the important issues of locating essential functions and decision-making points in such a system. The architecture also provides services such as tuning, translation, admission and QoS negotiation/renegotiation, which support the required functionalities. The transmission protocol stack is implemented as a set of generic services, embedded in our Real-Time Application Protocol (RTAP) and Real-Time Network Protocol (RTNP), which are tuned by the deal the QoS Broker achieved. As a driving application I used a master/slave telerobotics application for which I implemented the communication system Omega with functionalities, services, and protocols as outlined above using a dedicated 155 Mbps ATM LAN. This application employs media with diverse requirements and provides a good platform for testing how closely one can approximate a dedicated circuit and controller with workstation hosts and cell-switching. The results show that my software architecture can support this complex control system. It is the first such system to accomplish this goal for telerobotics over ATM. As a consequence of the implementation, I have identified the key barriers to extending these techniques to a larger domain.
SUBJECT(S) Descriptor: COMPUTER SCIENCE Accession No: AAI9543128 Database: Dissertations
Title: An architecture for the autonomous generation of
preference-based trajectories
Author(s): Lennon, Jamie
Degree: Ph.D.
Year: 2006
Pages: 00247
Institution: University of Maryland,
College Park; 0117
Advisor: Adviser Ella Atkins
Source: DAI, 67, no.
03B (2006): p. 1541 Standard No: ISBN: 978-0-542-61859-8
Abstract: Numerous techniques exist to optimize aircraft and spacecraft trajectories over cost functions that include terms such as fuel, time, and separation from obstacles. Relative weighting factors can dramatically alter solution characteristics, and engineers often must manually adjust either cost weights or the trajectory itself to obtain desirable solutions. Further, when humans and robots work together, or when humans task robots, they may express their performance expectations in a "fuzzy" natural language fashion, or else as an uncertain range of more or less acceptable values. This work describes a software architecture which accepts both fuzzy linguistic and hard numeric constraints on trajectory performance and, using a trajectory generator provided by the user, automatically constructs trajectories to meet these specifications as closely as possible. The system respects hard constraints imposed by system dynamics or by the user, and will not let the user's preferences interfere with the system and user needs. The architecture's evaluation agent translates these requirements into cost functional weights expected to produce the desired motion characteristics. The quality of the resulting full-state trajectory is then evaluated based on a set of computed trajectory features compared to the specified constraints. If constraints are not met, the cost functional weights are adjusted according to precomputed heuristic equations. Heuristics are not generated in an ad hoc fashion, but are instead the result of a systematic testing of the simulated system under a range of simple conditions. The system is tested in a 2DOF linear and a 6DOF nonlinear domain with a variety of constraints and in the presence of obstacles. Results show that the system consistently meets all hard numeric constraints placed on the trajectory. Desired characteristics are often attainable or else, in those cases where they are discounted in favor of the hard constraints, failed by small margins. Results are discussed as a function of obstacles and of constraints.
SUBJECT(S) Descriptor: ENGINEERING, AEROSPACE ARTIFICIAL INTELLIGENCE Accession No: AAI3212641 Database: Dissertations
Title: Architecture-independent programming and software synthesis
for networked sensor systems
Author(s): Bakshi, Amol B.
Degree: Ph.D.
Year: 2005
Pages: 00121
Institution: University of Southern
California; 0208
Advisor: Adviser Viktor K. Prasanna
Source: DAI, 67,
no. 06B (2005): p. 3214 Standard No: ISBN: 978-0-542-71802-1
Abstract: Networked sensor systems such as wireless sensor networks (WSNs) are a relatively new class of distributed computing systems that are closely coupled to the physical environment and provide embedded sense-and-response capabilities. For various reasons, programming the global behavior of such systems by individually configuring each sensor node is not feasible for complex applications. Macroprogramming models seek to provide high level abstractions for the application developer to specify collective behaviors that are then automatically compiled into low level operations at the individual node. This thesis proposes a data driven macroprogramming model called the Abstract Task Graph (ATaG) for architecture-independent development of networked sensing applications. Architecture independence allows application development to proceed prior to decisions being made about the target deployment, and also allows the same application to be automatically synthesized when needed onto different deployments. In ATaG, the application is modeled as a set of abstract tasks that represent types of information processing functions in the system, and a set of abstract data items that represent types of information exchanged between abstract tasks. Code that implements the actual information processing is provided by the user. Appropriate numbers and types of tasks can then be instantiated to match the actual network configuration, with each node incorporating the user-provided code, automatically generated glue code, and a runtime engine. The runtime engine called DART has a component-based software architecture, and manages all low level aspects of coordination and communication in the network. A prototype environment for visual programming and software synthesis has been implemented with an integrated functional simulation and visualization front end.
SUBJECT(S) Descriptor: COMPUTER SCIENCE Accession No: AAI3219853 Database: Dissertations
Title: ARCHITECTURE INDEPENDENT VIRTUAL MEMORY MANAGEMENT FOR
PARALLEL AND DISTRIBUTED ENVIRONMENTS: THE MACH APPROACH
Author(s):
TEVANIAN, AVADIS, JR.
Degree: PH.D.
Year: 1987
Pages: 00159
Institution: CARNEGIE-MELLON UNIVERSITY; 0041
Source: DAI, 49, no. 11B,
(1987): 4909
Abstract: Recent technological advances in memory managed architectures, multiprocessor systems and software architectures dictate a re-evaluation of the virtual memory management support provided by an operating system. The problems posed by multiprocessor systems and the portability issues raised by the large variety of memory management units available have not been satisfactorily addressed by past virtual memory systems. In addition, increases in virtual memory functionality that can be provided by memory managed architectures have gone largely unnoticed by system designers. This thesis describes the design, implementation and evaluation of the Mach virtual memory management system. It demonstrates that it is possible to build a virtual memory system that exhibits architecture independence, multiprocessor and distributed system support and advanced functionality without an adverse effect on performance. In fact, the performance of this virtual memory system is shown to often exceed that of commercially developed memory management systems targeted at specific hardware architectures.
SUBJECT(S) Descriptor: COMPUTER SCIENCE Accession No: AAG8814734 Database: Dissertations
Title: Architecture specification and implementation for
component-based systems
Author(s): Zhang, Shifeng
Degree: Ph.D.
Year: 2005
Pages: 00139
Institution: The University of Nebraska -
Lincoln; 0138
Advisor: Supervisor Steve Goddard
Source: DAI, 66, no.
05B (2005): p. 2687 Standard No: ISBN: 0-542-16057-9
Abstract: Component-Based Software Engineering (CBSE) has become an area of intense research and commercial focus with the complexity of software systems increasing. To help design component-based systems, Software Architecture (SA) has become a prospective research method and direction. SA is system-centric and views a software system as a collection of components and their interaction (connectors). Existing component middleware technologies (CTs), e.g., CORBA, DCOM, and Java Beans, provide a solid base to implement component-based systems. Those CTs are component-centric; they are primarily concerned with standardizing external component properties. Both SA and CTs are crucial aspects of CBSE, yet there has been limited interaction between the two domains in today's research. The goal of this dissertation research is to bridge the gap between SA and CTs: use existing component middleware technologies to build systems specified by software architecture technology. A component and component interaction model is presented to clarify what a component is and what component interaction is. Then, an Architecture Description Language (ADL), xSADL, is introduced that can specify and analyze the architectures of software systems at the design stage. xSADL specifies a complex software system as a collection of components and connectors. In the specification of a connector, xSADL can help designers deal with two kinds of architectural mismatches: behavior mismatch and message mismatch. Connectors often are considered to be explicit at the level of SA specifications, but implicit in CT-based implementations. Current CTs, such as CORBA, DCOM, and Java Beans, do not support explicit connector implementations. To support explicit connector implementations, a component framework, 3CoFramework, is presented in which a connector is raised to the level of a component at the implementation stage. In addition to the components and connectors, 3CoFramework also provides a management role, called a coordinator, to provide distributed component and connector management. xSADL helps to design software systems as component-based systems while 3CoFramework helps to implement the architecture designs as component-based applications. To integrate xSADL and 3CoFramework, a Computer Aided Software Engineering (CASE) tool, is presented also. The CASE tool has two purposes. First, it provides a GUI development environment to create xSADL documents. Second, it provides code generation functions to help transform xSADL designs into 3CoFramework-based implementations.
SUBJECT(S) Descriptor: COMPUTER SCIENCE Accession No: AAI3176811 Database: Dissertations
Title: ASAP for developing adaptive software within dynamic
heterogeneous environments
Author(s): Ko, Ren-Song
Degree: Ph.D.
Year: 2003
Pages: 00197
Institution: Michigan State University;
0128
Advisor: Adviser Matt W. Mutka
Source: DAI, 64, no. 05B (2003): p.
2265
Abstract: As the improvement of hardware technology and increased deployment of wireless infrastructures, computer systems are increasingly heterogeneous and dynamic. Heterogeneity and dynamic raise several challenges for software developers and users. Such challenges are software portability, software or computing environments configuration, unexpected environments, and platforms with limited resources. A feasible approach for these challenges is to develop adaptive software that may be aware of environments and adapt itself. We propose and implement the adaptive software architecture project (ASAP), which includes the software framework (FRAME), Component/Constraint Markup Language (CSML), and on-line adaptation, for the challenges under dynamic heterogeneous environments. Software may have a list of constraints for the environment. During execution, software may use the list to determine whether the environmental changes, and then the software responds accordingly. ASAP may support applications in different domains, including ad hoc systems that are temporarily organized. FRAME provides the APIs for adding adaptation to software. The adaptation and functionality of software are separately specified and implemented under FRAME, and hence, lessen development complexity. To further alleviate the complexity of developing adaptive software under FRAME, a high-level adaptive software specification language, CSML, may be used to specify the architecture of the software system and the constraints. The code for adaptation will be automatically generated by CSML. Then, developers only need to inherit the generated code to implement the functionality. To avoid an unnecessary performance impact, ASAP uses two different on-line adaptation schemes, Brew and component reassembly, to let software respond to different scales of environmental changes. For small environmental changes, people may use Brew to repair the affected software without terminating the software. Otherwise, the execution of the software will be temporarily suspended to invoke the component reassembly, and then resumed with appropriate implementations of the components. Also, two approaches, partial reassembly and caching, are proposed to further reduce the performance impact of reassembly. Three different applications are used to evaluate various features of ASAP. The GO game demonstrate the basic features of ASAP, including distributed component assembly. The Java MPEG Player has time constraints, which may not be satisfied under certain conditions and may be repaired by Brew. The last application demonstrates how ASAP may be used to realize behavior-based approach for the adaptive robotic control systems. Different performance results are also presented and discussed.
SUBJECT(S) Descriptor: COMPUTER SCIENCE Accession No: AAI3092170 Database: Dissertations
Title: Assessing the complexity of software architecture
Author(s): AlSharif, Mohsen Nawaf
Degree: Ph.D.
Year: 2005
Pages: 00170
Institution: Florida Institute of Technology; 0473
Advisor: Major Adviser Walter Pat Bond
Source: DAI, 65, no. 12B (2005):
p. 6465 Standard No: ISBN: 0-496-92599-7
Abstract: Software is an integral part of our daily activity and we are constantly requiring more functionality to be implemented. However; functionality is not the determining factor for the longevity and success of software; in fact, non-functional requirements (i.e. software quality) are the most important factor. (Bass, Clements, and Kazman 1998) Software quality can be evaluated throughout the software development life cycle; however, the earlier it is evaluated, the sooner problems can be discovered and fixed. Software architecture is the first artifact of software development following requirements analysis, and its existence allows us to evaluate the software very early on. Throughout the literature researchers have investigated different approaches to assess software architecture against specific external quality attributes, such as maintainability and reliability, neglecting internal quality attributes, such as coupling, complexity and cohesion that are known to have an influence on external quality attributes. (Briand, Morasca, and Basili 1996) Assessing architecture internal quality attributes is the subject addressed by this dissertation.
SUBJECT(S) Descriptor: COMPUTER SCIENCE Accession No: AAI3159528 Database: Dissertations
Title: AUTOMATED COMPONENT RETRIEVAL AND ADAPTATION USING FORMAL
SPECIFICATIONS
Author(s): PENIX, JOHN J.
Degree: PH.D.
Year: 1998
Pages: 00201
Institution: UNIVERSITY OF CINCINNATI; 0045
Advisor:
Adviser: PERRY ALEXANDER
Source: DAI, 59, no. 06B, (1998): 2859
Abstract: This work describes the use of formal specifications to assist and automate a system design process based on reusable components and architectures. Specifically, we focus on automated support for two reuse-related component-based design activities: (1) identification and retrieval of library components pertinent to the problem at hand, and (2) identification and application of structures for architectures) available for adapting these components. Formally verifying that a logical relationship holds between two specifications (a.k.a. specification matching (134)) to determine component reusability can be carried out using automated theorem proving. However, attempting specification matching over a large library of components is not a practical retrieval mechanism. To make specification matching efficient, it must be restricted to a small subset of the database. We have developed a heuristic for determining this subset of components based on the semantics provided by formal component interface specifications. A feature-based indexing scheme is used to classify components and allow efficient retrieval. A set of domain dependent classification rules state logical conditions defining when a component should be assigned specific features. If one of these conditions can be inferred from the component specification then the component is assigned the appropriate feature. We provide a formal argument that this method of classification ie appropriate for determining component reusability. We empirically evaluate the retrieval performance of an implementation of this mechanism over a library of 63 list manipulation components. The results indicate that the method performs as well as other specification-based retrieval systems, but with a faster response time. In most cases, component retrieval will not locate a component that completely satisfies a problem specification; solving a problem will require a component to be adapted or multiple components to be combined. We propose to use a formal model of software architecture, architecture theories, to automate component adaptation and composition. An architecture theory constrains the behavior of a system in terms of the behavior of its subcomponents via a collection of axioms. This relationship is specified declaratively, abstracting away implementation and focusing on the relationship between the system and component specifications. We show that architecture theories can be used to adapt and combine retrieved components to satisfy a problem specification. We develop several methods for controlling the selection of architectures during adaptation based on the results of component retrieval. The adaptation system is evaluated by constructing and adapting variations of the KWIC problem from the Model Problems in Software Architecture Archive and the JPEG compression algorithm.
SUBJECT(S) Descriptor: COMPUTER SCIENCE ENGINEERING, ELECTRONICS AND ELECTRICAL Accession No: AAG9835825 Database: Dissertations
Title: AUTOMATIC GENERATION OF CONTEXT-SENSITIVE ANIMATED HELP
(USER INTERFACE)
Author(s): SUKAVIRIYA, PIYAWADEE
Degree: D.SC.
Year: 1991
Pages: 00254
Institution: THE GEORGE WASHINGTON
UNIVERSITY; 0075
Advisor: Adviser: JAMES D. FOLEY
Source: DAI, 52, no.
08B, (1991): 4322
Abstract: Context-sensitive animated help uses simple 2-dimensional animation to demonstrate how to perform a computer application task within the context in which help is requested. To automatically generate such help, descriptive information about an application, its interface design, and runtime context must be available to a help generation system. This dissertation addresses how to represent domain-independent help knowledge, which is suitable for automatic generation of procedural animated help. The dissertation also presents the design of a help architecture which allows help and user interface components to share runtime contextual information. Within the environment this architecture supports, help can be tailored specifically to the user's current context. In this dissertation research, a knowledge representation model is developed that sufficiently details an application interface for both animated help generation and user interface control purposes. The knowledge model captures the semantics of application actions, their relationships to user interface components and functionality, and interface details required to support accurate demonstrations that are adaptable to current contexts. A model for a runtime support architecture with an integrated help component is also developed, in which help and user interface components share a common knowledge base to generate context-sensitive animated help automatically at runtime and to assist the management of use interfaces. The animated help component has access to contextual information, and employs artificial intelligence planning techniques to tailor animation scripts specifically to current contexts. Based on these models, a system called Cartoonist is implemented to demonstrate the usefulness of both the knowledge representation and the software architecture models.
SUBJECT(S) Descriptor: COMPUTER SCIENCE Accession No: AAG9200864 Database: Dissertations
Title: Automating software architecture selection and generation
Author(s): Glaze, Gregory D.
Degree: M.S.S.E.
Year: 2004
Pages:
00074
Institution: The University of Alabama in Huntsville; 0278
Advisor: Chair Harry S. Delugach
Source: MAI, 43, no. 02 (2004): p. 553
Standard No: ISBN: 0-496-02118-4
Abstract: One of the most complex phases in software engineering is the transition from requirements to design. This transition is often begun in a biased manner in that software engineers often select an architectural style that best fits their skills, rather than one that best fits the problem. The Concept Scoring Method (CSM) allows software engineers to automatically generate a software architecture from requirements specified in a conceptual graph (CG). The method consists of two phases: (1) Architectural Style Selection, and (2) Software Architecture Generation. In the Architectural Style Selection phase, we will score each architectural style based on defined rules. The architectural style with the highest score is the architectural style of choice for the requirements CG. The Software Architecture Generation phase could certainly be automated based on the derived rules for scoring the requirements conceptual graphs, but this phase will be performed manually during this research for illustration.
SUBJECT(S) Descriptor: COMPUTER SCIENCE Accession No: AAI1422341 Database: Dissertations
Title: Bridging technical spaces: Model translation from TA to XMI
and back again
Author(s): Hildebrand, Kristina Diew
Degree: M.Math.
Year: 2006
Pages: 00094
Institution: University of Waterloo
(Canada); 1141
Source: MAI, 45, no. 03 (2006): p. 1531 Standard No: ISBN:
978-0-494-23410-5
Abstract: There are many different techniques and notations for extracting architecturally interesting information from the source code of existing software systems. This process is known as reverse engineering. One current problem with reverse engineering techniques is that models of software systems cannot easily be transferred from one notation and storage format to another. We refer to this as the problem of bridging technical spaces. In this work, we approach the issue of bridging between the SWAG technical space and the UML technical space. The SWAG technical space, named after the Software Architecture Group at the University of Waterloo, consists of fact extractors, fact manipulators, schemas, and a fact storage language---the Tuple-Attribute language (TA). The UML technical space consists of the UML metamodel, the XML Metadata Interchange (XMI) format for encoding UML models, and various UML modeling tools. We have designed and implemented a plugin for MagicDraw UML, which will import, export, and merge between XMI-encoded UML models and TA-encoded Function-Level Schema models. We document evidence of what is referred to as a bridge domain ---a technical space which exists between two encodable spaces. The metamodels of the two notation languages that we have focused on are very rich and flexible, but neither technical space is capable of fully expressing an accurate architectural model of any given software system; however, each technical space is capable of maintaining certain semantic information relevant to that technical space through multiple merge operations.
SUBJECT(S) Descriptor: MATHEMATICS COMPUTER SCIENCE Accession No: AAIMR23410 Database: Dissertations
Title: CLIENT-SERVER DATABASES: ARCHITECTURES AND PERFORMANCE
ANALYSIS (DATABASE ARCHITECTURE)
Author(s): DELIS, ALEXIOS
Degree:
PH.D.
Year: 1993
Pages: 00207
Institution: UNIVERSITY OF MARYLAND
COLLEGE PARK; 0117
Advisor: Chairman: NICK ROUSSOPOULOS
Source: DAI,
54, no. 05B, (1993): 2592
Abstract: The introduction of powerful workstations connected through LAN networks inspired the design of new DBMS architectures which offer high performance characteristics. This thesis studies a number of such software architecture configurations, namely: Standard Client-Server (SCS), Page-Server (PS), RAD-Unify type of DBMS (RU), Client-Server with Multiple Disks (CS-MD), Enhanced Client-Server (ECS), and Enhanced Client-Server with Log Buffers(ECS-LB). Their specific functional components and design rationales are discussed. We use simulation models to provide a performance comparison against different job workloads. Through experimentation, we investigate performance and scalability for all architectures and show that the ECS configuration is almost linearly scalable to the number of attached clients for light updates. Under heavier updates ECS-LB offers the best scalable option since it avoids disk log operations. ECS and especially ECS-LB consistently outperform SCS, RU, PS, and CS-MD except for pure update workloads. In our experiments, CS-MD offers an almost ten-fold improvement over SCS, while PS provides two to three times better performance than SCS. RU maintains better throughput rates than SCS--yet worse than those of PS--for few clients per server, while its performance drops notably in the high range of clients. Finally, a number of strategies for propagating server updates to the clients are outlined and their performance is examined.
SUBJECT(S) Descriptor: COMPUTER SCIENCE Accession No: AAG9327408 Database: Dissertations
Title: A common component-based software architecture for military
and commercial PC-based virtual simulation
Author(s): Lewis, Joshua
Degree: Ph.D.
Year: 2006
Pages: 00195
Institution: University
of Central Florida; 0705
Advisor: Adviser Michael D. Proctor
Source:
DAI, 67, no. 09B (2006): p. 5195 Standard No: ISBN: 978-0-542-86834-4
Abstract: Commercially available military-themed virtual simulations have been developed and sold for entertainment since the beginning of the personal computing era. There exists an intense interest by various branches of the military to leverage the technological advances of the personal computing and video game industries to provide low cost military training. By nature of the content of the commercial military-themed virtual simulations, a large overlap has grown between the interests, resources, standards, and technology of the computer entertainment industry and military training branches. This research attempts to identify these commonalities with the purpose of systematically designing and evaluating a common component-based software architecture that could be used to implement a framework for developing content for both commercial and military virtual simulation software applications.
SUBJECT(S) Descriptor: COMPUTER SCIENCE Accession No: AAI3233661 Database: Dissertations
Title: COMPLEXITY MEASURES FOR SYSTEMS DESIGN
Author(s): HALL,
NANCY ROSE
Degree: PH.D.
Year: 1983
Pages: 00123
Institution:
POLYTECHNIC UNIVERSITY; 0179
Source: DAI, 44, no. 03B, (1983): 0849
Abstract: A considerable amount of work has taken place in the
area of software complexity measures during the past several
Years. Most of
this work has addressed complexity measurement for source code or design
language. For large (> 100,000 source lines of code), complex systems,
additional techniques are needed to measure complexity during the software
architecture phase of the lifecycle, prior to the time that major design
decisions have been made. These measurement techniques should be intuitive,
easy to apply, and should produce an internally consistent set of results. The
principal result of this thesis is development of methods for measuring the
software complexity associated with networks of communicating modules. These
measures can be applied to systems that are at rest (static measures) and in
execution (dynamic measures). The methods described herein are easy to apply,
produce internally consistent results, and point out techniques which can be
used to reduce complexity. These methods therefore address an area which
previously has had little attention in terms of software complexity measures,
namely the software architecture and software design phases of a software
development project, when software modules and interfaces are defined. Methods
developed include: (1) An application of the graph-theoretic measure developed
by McCabe to software architectures, as represented by networks of
communicating modules. The nodes in the network are modules, and the edges
represent transfer of control and data between modules. (2) A general measure
which allows the complexity associated with allocation of resources, such as
CPU, tape, disk, etc., to be measured. (3) A method that combines module
complexity and network complexity, so that design tradeoff studies can be done
in order to determine whether it is advantageous to have distinct modules for
service functions, such as mathematical subroutines, data management routines,
etc. (4) Dynamic measures which allow measurement of network complexity during
execution, including complexity which results from creation and deletion of
modules, module interruption, etc.
SUBJECT(S) Descriptor: COMPUTER SCIENCE Accession No: AAG8316762 Database: Dissertations
Title: A component framework of a distributed control systems
family
Author(s): Niemela, Eila Helena
Degree: Ph.D.
Year: 2000
Pages: 00258
Institution: Oulun Yliopisto (Finland); 0409 Publication:
Technical Research Centre of Finland, P.O.B. 2000, FIN-02044 VTT, Finland
Source: DAI, 61, no. 03C (2000): p. 852 Standard No: ISBN: 951-38-5549-X
Abstract: A component framework is based on a software architecture, a set of components and their interaction mechanisms. This thesis examines the component-based software development by reviewing the requirements for a component framework, proposing a model of a component framework of a distributed control systems family and demonstrating results with cases drawn from the control systems families. The control systems families are studied and three main problems are discovered. A lack of appropriate modelling methods prevents describing product features and variability at the software architecture level. Interoperability and adaptability of software components are inadequate in most cases. Furthermore, integrators and maintenance staff need support software for extending and upgrading systems. The component framework of a distributed control systems family introduces two dimensions: tiers and elements. The three tiers of the component framework define the subsystems in the first tier, integration platform in the second tier, and the product family in the third their. The tiers explain the domain, technology and business viewpoints of the framework, correspondingly. The elements define the product features, software architecture, components and their interaction mechanisms. The development and utilisation of the component framework have three main tasks, described as the viewpoints of the component-based software development, concurrent software engineering and software configuration management. The development of the component framework is presented by the development of the reuse assets: the product features, product-family architecture and software components. The architecture styles, key-mechanisms, services and components of each tier are depicted. The framework mixes agent, layered, client-server and rule-based system architectures and their mechanisms to provide a coherent solution for software flexibility required by the product families. The results are analysed as regards the evaluation criteria. Variability and adaptability are examined at the architecture and component level, as well as the interoperability of tiers, services and applications and interchangeability of product features and components. The adaptive approach restricts the affects of the changes in the business, technology and application domain to the corresponding tiers that provide their own mechanisms for adaptability. The integration tier could be reused community-wide, whereas the subsystem tier is domain-specific and the product-family tier is always an organisation-dependent solution.
SUBJECT(S) Descriptor: COMPUTER SCIENCE Accession No: AAIC802792 Database: Dissertations
Title: Component framework technology for adaptable and manageable
protocol stacks
Author(s): Michiels, Sam
Degree: Dr.
Year: 2003
Pages: 00170
Institution: Katholieke Universiteit Leuven (Belgium);
5605
Source: DAI, 67, no. 01C (2003): p. 336
Abstract: The context of this dissertation and the corresponding challenges are formed by network services and their requirements to the underlying protocol stack. The relevance of this research is confirmed by three recent trends in network services and their execution environment: growing reliance of businesses and individuals on network connectivity, highly dynamic network characteristics, and a wide range of connected client device types. These three trends reveal a common challenge for protocol stack software: offering support for flexibility at design-, development-, and execution-time, tailored to application- and/or network-specific characteristics. This dissertation presents DiPS+ (Distrinet Protocol Stack+), a sophisticated software architecture and component framework to support the development of protocol stacks that are easily customizable to application- and environment-specific requirements. DiPS+ has been used to address three core research tracks in protocol stack development: self-adaptability and management, testing, and framework optimization. The strength of this dissertation is that these three tracks are not addressed by individual solutions, yet share a well-defined software architecture and component framework underneath. The DIPS+ component framework does not only offer programmers support in developing protocol stacks, but also lays the foundation for a robust and lightweight development process and a balanced software life-cycle.
SUBJECT(S) Descriptor: COMPUTER SCIENCE Accession No: AAIC822636 Database: Dissertations
Title: COMPOSING HETEROGENEOUS SOFTWARE ARCHITECTURES
(ARCHITECTURE MISMATCHES)
Author(s): ABD-ALLAH, AHMED ABD-EL-SHAFY
Degree: PH.D.
Year: 1996
Pages: 00141
Institution: UNIVERSITY
OF SOUTHERN CALIFORNIA; 0208
Advisor: Adviser: BARRY W. BOEHM
Source:
DAI, 57, no. 09B, (1996): 5740
Abstract: A persistent problem in software engineering is how to put complex software systems together out of smaller subsystems, the problem of software composition. The emergence of software architectures and architectural styles has introduced a higher level of abstraction at which we can create and compose software systems. We examine the problem of providing formal semantics to the composition of different architectural styles within software systems, i.e. the problem of composing heterogeneous architectures. We describe a model of pure styles, and a model of their composition. Our model of pure styles is highlighted by a uniform representation for describing many different styles. An architectural style space of major conceptual features is introduced which allows new styles to be rapidly incorporated into the model, including commercial-off-the-shelf packages which embody a specific style(s). We show a disciplined approach to the process of architectural composition, and show how architecture mismatches can be generated during composition. Finally, we describe a prototype tool which is built on top of the models.
SUBJECT(S) Descriptor: COMPUTER SCIENCE Accession No: AAG9705062 Database: Dissertations
Title: Composing style-based software architectures from
architectural primitives
Author(s): Mehta, Nikunj Rohitkumar
Degree:
Ph.D.
Year: 2004
Pages: 00326
Institution: University of Southern
California; 0208
Advisor: Adviser Nenad Medvidovic
Source: DAI, 65, no.
11B (2004): p. 5837 Standard No: ISBN: 0-496-16223-3
Abstract: Software architectures provide high-level abstractions to deal with the complexity and richness of large-scale software systems. Often, similar architectural organization is found in different software systems. Architectural styles are an approach to exploit such similarities between different architectures. A style is useful in the design of architectures due to guarantees of desirable stylistic properties across architectures based on that style. Styles are also believed to bring economies of scale in the design and implementation of architectures. Although there are many systematic techniques for describing and selecting styles, there is considerably less underpinning for the systematic design and construction of style-based architectures. This dissertation motivates, presents, and validates a methodology for the composition of style-based software architectures from architectural primitives. This methodology, embodied as the Alfa framework, is a collection of related techniques that support the expression of stylistic constraints as well as architectural organization through the use of architectural primitives. Not only does the Alfa framework ensure the conformance of stylistic constraints in architectures using those styles, but it is also amenable to scalable implementation of architectural designs. Moreover, our methodology is comprehensive in its scope: it supports the data, structural, topological, interaction, and behavioral concerns in styles and architectures. The unique aspects of Alfa are: explicit recognition of architectural primitives that underlie a wide range of styles and architectures; type checking of data in styles and architectures, to ensure validity of architectural compositions; effective analysis of architectures for conformance to style(s) used in them, to preserve stylistic properties; and scalable implementation of architectural primitives and their composition, to support architectural prototyping. The key proposition of the dissertation is demonstrated through a case study that applies Alfa to distributed systems. The dissertation is validated analytically by deducing the algorithmic complexity of Alfa's conformance analysis; and quantitatively, by measuring the scalability of Alfa-based architectural implementations in terms of memory usage and processing time. The dissertation is concluded by inferring the consequences of Alfa on the design, analysis, and implementation of software systems.
SUBJECT(S) Descriptor: COMPUTER SCIENCE Accession No: AAI3155448 Database: Dissertations
Title: A connector-centric approach to architectural access
control
Author(s): Ren, Jie
Degree: Ph.D.
Year: 2006
Pages:
00206
Institution: University of California, Irvine; 0030
Advisor:
Adviser Richard N. Taylor
Source: DAI, 67, no. 03B (2006): p. 1529 Standard
No: ISBN: 978-0-542-57854-0
Abstract: An important problem is the architectural access control question: how can we describe and check access control issues at the software architecture level? We propose a connector-centric approach for software architectural access control. Our approach is based on a unified access control model incorporating the classic model, the role-based model, and the trust management model. We design a secure software architecture description language, Secure xADL, that extends the xADL language with constructs necessary to describe access control issues. Secure xADL extends descriptions of components, connectors, their types, sub-architectures, and the global architecture with subject, principal, permission, resource, privilege, safeguard, and policy. We use the XACML language as the basis for architectural security policy modeling. Four types of contexts for architectural access control are also identified: (1) the nearby constituents of components and connectors, (2) the types of components and connectors, (3) the containing sub-architecture, and (4) the global architecture. We present an algorithm to check architectural access control: given a secure software architecture description written in Secure xADL, if a component A wants to access another component B, should the access be allowed? Tool support is provided as part of the ArchStudio architecture development environment, including an editor, a checker, the secure architecture controller, and a run-time framework enabling important architectural operations: instantiating components and connectors, connecting components to connectors, and message routing. Connectors play a central role in our approach. They can propagate privileges within the architecture, decide whether architectural connections can be made, and route messages according to their security policies. Our hypotheses are: an architectural connector may serve as a suitable construct to model architectural access control; the connector-centric approach can be applied to different types of componentized and networked software systems; the access control check algorithm can check the suitability of accessing interfaces; in an architecture style based on event routing connectors, our approach can route events in accordance with the secure delivery requirements. To validate these hypotheses, we have performed an informal analysis of the algorithm, developed two applications, Secure Coalition and Impromptu, and modeled the security architecture of Firefox and DCOM.
SUBJECT(S) Descriptor: COMPUTER SCIENCE Accession No: AAI3209313 Database: Dissertations
Title: A CONTEXT-DRIVEN AGENT-MEDIATED SOFTWARE ARCHITECTURE FOR
ELECTRONIC COMMERCE AND THE ASSOCIATED LEGAL AND SOCIAL ISSUES
Author(s):
POWER, ROBERT GREGORY
Degree: M.COMP.SC.
Year: 1999
Pages: 00115
Institution: DALTECH-DALHOUSIE UNIVERSITY (CANADA); 1326
Advisor:
Adviser ANDREW RAU-CHAPLIN
Source: MAI, 37, no. 06 (1999): p. 1886 Standard
No: ISBN: 0-612-39693-2
Abstract: In this thesis the idea and subsequent design of a structured, virtual marketplace (Vmart) is presented along with its inherent legal issues. In Vmart, a customer starts with a design in some domain and seeks to purchase a set of components that satisfy that design and its associated performance specifications. The design is represented by a data model serving as a shopping list (i.e. detailed requirements and constraints) and a shopping cart (i.e. currently selected items). The Vmart architecture consists of agents representing customers and suppliers, a pool of historical data and the data model. An agent representing a particular customer consults the data model for functional constraints on a desired product, solicits additional product constraints from the customer, queries appropriate supplier agents for possible matches, chooses the best alternatives to present to the customer and eventually completes a commercial transaction. Supplier agents provide product descriptions to consumer agents and complete transactions when chosen as the supplier for a product. Historical records of all transactions and agent conversations are maintained. In addition to technical issues, this architecture raises many complex legal and social issues. (Abstract shortened by UMI.)
SUBJECT(S) Descriptor: COMPUTER SCIENCE BUSINESS ADMINISTRATION, MARKETING LAW Accession No: AAGMQ39693 Database: Dissertations
Title: CONTROLLING THE INTERACTIONS OF ARCHITECTURAL DESIGN
COMPONENTS USING SCOPING RULES (SOFTWARE DESIGN)
Author(s): MANCORIDIS,
SPIROS
Degree: PH.D.
Year: 1996
Pages: 00189
Institution:
UNIVERSITY OF TORONTO (CANADA); 0779
Advisor: Adviser: R. C. HOLT
Source: DAI, 57, no. 08B, (1996): 5159 Standard No: ISBN: 0-612-11793-6
Abstract: Software designers rely on programming language constructs and machine readable system models to specify dependencies between the components of a software system. In large software systems with hundreds of components, the overall system structure, called the software architecture or architectural design, may become obfuscated by the numerous components and their inter-dependencies. For this reason software designers often use informal diagrams to separately describe software architectures. Although software architecture diagrams communicate important information to developers, the fact that they are informal implies that they may not be interpreted consistently by all developers. Moreover, informal diagrams do not lend themselves to mechanical processing, making the development of tools to detect inconsistencies between architectural diagrams and source code, extremely difficult. Ideally, software designers would have at their disposal formal diagrams for specifying architectural designs and tools for checking the syntax of architectural diagrams as well as the consistency between these diagrams and the implementation source code. Our work bridges the gap between source code and software architecture by incorporating information about source code components and their inter-dependencies into architectural design diagrams in a formal way. The controlling of dependencies among the source code and architectural design components is done using scoping rules. These scoping rules are specified using ASF (Architectural Scoping Formalism), which uses sets of rules, presented visually, to specify scoping constraints. This visual formalism is convenient for the system designer, easily understood by the practitioner, and can be used to automatically generate checking tools. We have studied the scoping rules of several programming languages and have specified these rules using ASF. Based on the experience gained from this study. ASF was used to specify alternative scoping rules that are more appropriate for architectural design. These ASF specifications were produced using tools that are part of our prototype environment for architectural design. The prototype is based on our configurable tool integration framework, which supports the specification, visualization, and checking of software architectures.
SUBJECT(S) Descriptor: COMPUTER SCIENCE Accession No: AAGNN11793 Database: Dissertations
Title: Coordination-oriented architecture for large software
systems
Author(s): Coifan, Gabriel M.
Degree: M.A.Sc.
Year: 1999
Pages: 00187
Institution: University of Ottawa (Canada); 0918
Advisor: Adviser Moshe Krieger
Source: MAI, 39, no. 01 (1999): p. 261
Standard No: ISBN: 0-612-52291-1
Abstract: After nearly fifty
Years of existence, software
development. evolved from craftsmanship to science, only lately breaking
grounds towards an engineering discipline. The last ten
Years brought along
a tremendous development of the software industry, fueled by a multitude of
factors like the exponential increase in the computing power (associated with
lower costs), combined though with increasing user needs, expectations, and
increasing costs of software development. This rapid advance caught the
software community ill prepared and suddenly uncovered what proved to be the
two most important problems of the software industry today: how to derive
proper requirements for a wide class of applications and how to handle the
complexity of the solution. A number of significant attempts have been made so
far in order to cope with complexity; taken chronologically, modularization and
information hiding, object orientation, design patterns and software
architectures are the most popular of them. None of them is complete; for good
design one needs to have, along with the appropriate structure, the matching
design methodologies, processes and tools. Development of more reliable
software at a reasonable cost is more and more of a problem; today's demands
from software products outgrow development capabilities. By analogy with more
established engineering fields, it is clear that one needs disciplined and well
defined requirement management, design and implementation methodologies in
order to develop quality software. The purpose of the thesis is to introduce
coordination-based design, as a step forward towards managing software
complexity on the architectural level and improving non-functional
characteristics of software systems: reliability, efficiency, maintainability,
and usability. We also provide a critical view on basic ideas, trends and
terminology in Software Architecture, develop a framework to define the need
for Software Architecture and properly place it in the design context.
SUBJECT(S) Descriptor: ENGINEERING, ELECTRONICS AND ELECTRICAL COMPUTER SCIENCE Accession No: AAIMQ52291 Database: Dissertations
Title: A coordination perspective on software architecture:
Towards a design handbook for integrating software components
Author(s):
Dellarocas, Chrysanthos Nicholas
Degree: Ph.D.
Year: 1996
Pages:
00001
Institution: Massachusetts Institute of Technology; 0753
Advisor:
Supervisor Thomas W. Malone
Source: DAI, 57, no. 03B (1996): p. 1907
Abstract: This thesis argues that many of the difficulties associated with building software applications by integrating existing components are related to a failure of current programming languages to recognize component interconnection as a separate design problem, orthogonal to the specification and implementation of a component's core function. It proposes S scYNOPSIS, an architectural description language which supports two orthogonal abstractions: activities, for representing the functional pieces of an application, and dependencies, for describing their interconnection relationships. Coordination processes, defined as an attribute of dependencies, describe implementations of interconnection protocols. Executable systems can be generated from S scYNOPSIS descriptions by successively replacing activities with more specialized versions and managing dependencies with coordination processes, until all elements of the description are specific enough for code generation to take place. Furthermore, it proposes a "design handbook", consisting of a vocabulary of common dependen