The purpose of this thesis is to estimate the potential performance improvement in sustaining engineering (SE) when an Open Architecture (OA) approach to system development is used. Its basis is that in Integrated Warfare Systems (IWS) acquisition, 80% of total lifecycle costs occur during the Operation and Support phase. This statistic demonstrates the necessity of measuring how the OA approach will affect software upgrades and maintenance processes for the AEGIS IWS lifecycle. Using the OA approach, advances in distance support and monitoring and maintenance-free operating periods are possible; these advances are significant in supporting the need to reduce costs and manpower while improving performance. To estimate the potential (Return on Investment) ROI that an OA approach might enable SE in the form of software maintenance and upgrades, this thesis will apply the Knowledge Value Added (KVA) methodology to establish the baseline, "As Is," configuration of the current solutions in AEGIS. The KVA analysis will yield the ROI's and the current models for the approach to software maintenance and upgrades. Based on the assumptions of OA design for original system development, new approaches to distance and maintenance and monitoring will be explored in "To Be" solutions, and the ROIs will be estimated. The "To Be" solutions are rooted in the assumptions of MFOP and ARCI, and the results indicate that these solutions yield a potential improvement of 720% and a cost savings of $3 65,104.63 over the current methodology for just one ship. For all ships using AEGIS, ROI improves by 71,967%--with a cost savings of $2 6,543,824.56. The conclusion is that OA enables extension of these best practice approaches to AEGIS maintenance and upgrade solutions.

The studies reported herein compare comprehension of Ut style literate programs to that of traditional modular programs documented by embedded comments. Novice and intermediate programmers participated in three experiments designed to determine the comprehensibility of literate programs written using a language-independent system for abstraction-oriented literate programming compared with programs written using traditional modular programming techniques (traditional modular programs). Programs were written in either the C or FORTRAN programming language. Half of the subjects in each group received a literate program, while the other half received a traditional modular program with embedded documentation. Subjects received a problem specification, input and output specifications, and a language reference for use in the study. Subjects were asked to perform a program maintenance task (complete an incomplete program). The maintenance task was used as a measure of comprehension; it simulates an actual task in the software engineering industry that requires program comprehension in order to be completed. The elapsed time to effect a solution was recorded. The completed programs were judged as correct, functionally correct with syntax errors, or incorrect; several reconstructive program comprehension measures were also collected and analyzed_ The clear overall result was that subjects using the literate programs found a solution (correct or functionally correct with syntax errors) more often than did subjects using the traditional modular programs with embedded comments. In fact, none of the subjects in this study who modified the traditional programs were able to effect a solution that was totally correct, nor even one that was functionally correct with syntax errors.

Patches to modern operating systems, including bug fixes and security updates, and the reboots and downtime they require, cause tremendous problems for system users and administrators. The aim of this research is to develop a model for dynamic update of operating systems, allowing a system to be patched without the need for a reboot or other service interruption. In this work, a model for dynamic update based on operating system modularity is developed and evaluated using a prototype implementation for the K42 operating system. The prototype is able to update kernel code and data structures, even when the interfaces between kernel modules change. When applying an update, at no point is the system's entire execution blocked, and there is no additional overhead after an update has been applied. The base runtime overhead is also very low. An analysis of the K42 revision history shows that approximately 79% of past performance and bug-fix changes to K42 could be converted to dynamic updates, and the proportion would be even higher if the changes were being developed for dynamic update. The model also extends to other systems such as Linux and BSD, that although structured modularly, are not strictly object-oriented like K42. The experience with this approach shows that dynamic update for operating systems is feasible given a sufficiently-modular system structure, allows maintenance patches and updates to be applied without disruption, and need not constrain system performance.

Thesis (Ph. D.)--West Virginia University, 2006. / Title from document title page. Document formatted into pages; contains xiii, 166 p. : ill. (some col.). Includes abstract. Includes bibliographical references (p. 130-140).

Software developers often encapsulate reusable code as Application Programming Interfaces (APIs). The co-evolution of applications and APIs may motivate an API migration: the replacement of application dependencies to an original API by dependencies to an alternative API that provides similar functionality and abstractions. In this dissertation, we investigate issues associated with API migration in object-oriented systems, with special focus on wrapping approaches. We present two studies and a set of developer interviews that elicit issues in the process and techniques used in API migration in practice. The results suggest that the most pressing issues relate to discovery and specification of differences between APIs, and to assessment of migration correctness. This dissertation introduces techniques and a method to address these issues. We propose the use of design patterns to support the specification of API wrappers. API wrapping design patterns encode solutions to common wrapping design problems. We present an initial catalog of such patterns that were abstracted from programming idioms found in existing API wrappers. We introduce the concept of compliance testing for API migration, a form of automated testing. Compliance testing supports the discovery of behavioral differences between a wrapper and its corresponding original API, as well as assessment of wrapper correctness. Compliance testing uses API contracts and assertion tunings to explicitly capture and enforce the notion of a “good enough” wrapper that is informal in practice. We present the Koloo method for wrapper-based API migration. The method prescribes practical steps to use compliance testing as a means to elicit the requirements for the API migration, and to assess its correctness. Koloo fits within the iterative, sample-driven general API migration process usually followed by developers in practice. We evaluate the Koloo method in an empirical study. The subjects cover the domains of XML processing, GUI programming and bytecode engineering. The results provide evidence that Koloo is superior to alternative methods in driving the development of a wrapper that is tailored for the application under migration. The results also show that API contracts help driving the evolution of the wrapper, and assertion tuning is necessary to relax the semantics of strict equality contracts, and useful to compromise on features that are difficult to emulate perfectly. Finally, we validate that the proposed design patterns are used in practical wrappers.

Thesis (M.Sc.)--York University, 2007. Graduate Programme in Computer Science. / Typescript. Includes bibliographical references (leaves 122-124). Also available on the Internet. MODE OF ACCESS via web browser by entering the following URL: http://gateway.proquest.com/openurl?url_ver=Z39.88-2004&res_dat=xri:pqdiss&rft_val_fmt=info:ofi/fmt:kev:mtx:dissertation&rft_dat=xri:pqdiss:MR31995

Thesis (M.S.)--West Virginia University, 2004. / Title from document title page. Document formatted into pages; contains ix, 109 p. : ill. (some col.). Includes abstract. Includes bibliographical references (p. 56-58).

Software developers often encapsulate reusable code as Application Programming Interfaces (APIs). The co-evolution of applications and APIs may motivate an API migration: the replacement of application dependencies to an original API by dependencies to an alternative API that provides similar functionality and abstractions. In this dissertation, we investigate issues associated with API migration in object-oriented systems, with special focus on wrapping approaches. We present two studies and a set of developer interviews that elicit issues in the process and techniques used in API migration in practice. The results suggest that the most pressing issues relate to discovery and specification of differences between APIs, and to assessment of migration correctness. This dissertation introduces techniques and a method to address these issues. We propose the use of design patterns to support the specification of API wrappers. API wrapping design patterns encode solutions to common wrapping design problems. We present an initial catalog of such patterns that were abstracted from programming idioms found in existing API wrappers. We introduce the concept of compliance testing for API migration, a form of automated testing. Compliance testing supports the discovery of behavioral differences between a wrapper and its corresponding original API, as well as assessment of wrapper correctness. Compliance testing uses API contracts and assertion tunings to explicitly capture and enforce the notion of a “good enough” wrapper that is informal in practice. We present the Koloo method for wrapper-based API migration. The method prescribes practical steps to use compliance testing as a means to elicit the requirements for the API migration, and to assess its correctness. Koloo fits within the iterative, sample-driven general API migration process usually followed by developers in practice. We evaluate the Koloo method in an empirical study. The subjects cover the domains of XML processing, GUI programming and bytecode engineering. The results provide evidence that Koloo is superior to alternative methods in driving the development of a wrapper that is tailored for the application under migration. The results also show that API contracts help driving the evolution of the wrapper, and assertion tuning is necessary to relax the semantics of strict equality contracts, and useful to compromise on features that are difficult to emulate perfectly. Finally, we validate that the proposed design patterns are used in practical wrappers.

Thesis (Ph. D.)--University of Hawaii at Manoa, 1994. / Includes bibliographical references (leaves 350-354). / Microfiche. / xx, 354 leaves, bound ill. 29 cm

Patches to modern operating systems, including bug fixes and security updates, and the reboots and downtime they require, cause tremendous problems for system users and administrators. The aim of this research is to develop a model for dynamic update of operating systems, allowing a system to be patched without the need for a reboot or other service interruption. In this work, a model for dynamic update based on operating system modularity is developed and evaluated using a prototype implementation for the K42 operating system. The prototype is able to update kernel code and data structures, even when the interfaces between kernel modules change. When applying an update, at no point is the system's entire execution blocked, and there is no additional overhead after an update has been applied. The base runtime overhead is also very low. An analysis of the K42 revision history shows that approximately 79% of past performance and bug-fix changes to K42 could be converted to dynamic updates, and the proportion would be even higher if the changes were being developed for dynamic update. The model also extends to other systems such as Linux and BSD, that although structured modularly, are not strictly object-oriented like K42. The experience with this approach shows that dynamic update for operating systems is feasible given a sufficiently-modular system structure, allows maintenance patches and updates to be applied without disruption, and need not constrain system performance.