• Refine Query
  • Source
  • Publication year
  • to
  • Language
  • 110
  • 18
  • 4
  • 4
  • 2
  • 2
  • 1
  • 1
  • 1
  • Tagged with
  • 169
  • 169
  • 70
  • 54
  • 30
  • 26
  • 21
  • 20
  • 17
  • 16
  • 15
  • 15
  • 12
  • 11
  • 11
  • About
  • The Global ETD Search service is a free service for researchers to find electronic theses and dissertations. This service is provided by the Networked Digital Library of Theses and Dissertations.
    Our metadata is collected from universities around the world. If you manage a university/consortium/country archive and want to be added, details can be found on the NDLTD website.
21

Diagnosing and tolerating bugs in deployed systems

Bond, Michael David 09 October 2012 (has links)
Deployed software is never free of bugs. These bugs cause software to fail, wasting billions of dollars and sometimes causing injury or death. Bugs are pervasive in modern software, which is increasingly complex due to demand for features, extensibility, and integration of components. Complete validation and exhaustive testing are infeasible for substantial software systems, and therefore deployed software exhibits untested and unanalyzed behaviors. Software behaves differently after deployment due to different environments and inputs, so developers cannot find and fix all bugs before deploying software, and they cannot easily reproduce post-deployment bugs outside of the deployed setting. This dissertation argues that post-deployment is a compelling environment for diagnosing and tolerating bugs, and it introduces a general approach called post-deployment debugging. Techniques in this class are efficient enough to go unnoticed by users and accurate enough to find and report the sources of errors to developers. We demonstrate that they help developers find and fix bugs and help users get more functionality out of failing software. To diagnose post-deployment failures, programmers need to understand the program operations--control and data flow--responsible for failures. Prior approaches for widespread tracking of control and data flow often slow programs by two times or more and increase memory usage significantly, making them impractical for online use. We present novel techniques for representing control and data flow that add modest overhead while still providing diagnostic information directly useful for fixing bugs. The first technique, probabilistic calling context (PCC), provides low-overhead context sensitivity to dynamic analyses that detect new or anomalous deployed behavior. Second, Bell statistically correlates control flow with data, and it reconstructs program locations associated with data. We apply Bell to leak detection, where it tracks and reports program locations responsible for real memory leaks. The third technique, origin tracking, tracks the originating program locations of unusable values such as null references, by storing origins in place of unusable values. These origins are cheap to track and are directly useful for diagnosing real-world null pointer exceptions. Post-deployment diagnosis helps developers find and fix bugs, but in the meantime, users need help with failing software. We present techniques that tolerate memory leaks, which are particularly difficult to diagnose since they have no immediate symptoms and may take days or longer to materialize. Our techniques effectively narrow the gap between reachability and liveness by providing the illusion that dead but reachable objects do not consume resources. The techniques identify stale objects not used in a while and remove them from the application and garbage collector’s working set. The first technique, Melt, relocates stale memory to disk, so it can restore objects if the program uses them later. Growing leaks exhaust the disk eventually, and some embedded systems have no disk. Our second technique, leak pruning, addresses these limitations by automatically reclaiming likely leaked memory. It preserves semantics by waiting until heap exhaustion to reclaim memory--then intercepting program attempts to access reclaimed memory. We demonstrate the utility and efficiency of post-deployment debugging on large, real-world programs--where they pinpoint bug causes and improve software availability. Post-deployment debugging efficiently exposes and exploits programming language semantics and opens up a promising direction for improving software robustness. / text
22

Inverse software configuration management

McCrindle, Rachel Jane January 1998 (has links)
Software systems are playing an increasingly important role in almost every aspect of today’s society such that they impact on our businesses, industry, leisure, health and safety. Many of these systems are extremely large and complex and depend upon the correct interaction of many hundreds or even thousands of heterogeneous components. Commensurate with this increased reliance on software is the need for high quality products that meet customer expectations, perform reliably and which can be cost-effectively and safely maintained. Techniques such as software configuration management have proved to be invaluable during the development process to ensure that this is the case. However, there are a very large number of legacy systems which were not developed under controlled conditions, but which still, need to be maintained due to the heavy investment incorporated within them. Such systems are characterised by extremely high program comprehension overheads and the probability that new errors will be introduced during the maintenance process often with serious consequences. To address the issues concerning maintenance of legacy systems this thesis has defined and developed a new process and associated maintenance model, Inverse Software Configuration Management (ISCM). This model centres on a layered approach to the program comprehension process through the definition of a number of software configuration abstractions. This information together with the set of rules for reclaiming the information is stored within an Extensible System Information Base (ESIB) via, die definition of a Programming-in-the- Environment (PITE) language, the Inverse Configuration Description Language (ICDL). In order to assist the application of the ISCM process across a wide range of software applications and system architectures, die PISCES (Proforma Identification Scheme for Configurations of Existing Systems) method has been developed as a series of defined procedures and guidelines. To underpin the method and to offer a user-friendly interface to the process a series of templates, the Proforma Increasing Complexity Series (PICS) has been developed. To enable the useful employment of these techniques on large-scale systems, the subject of automation has been addressed through the development of a flexible meta-CASE environment, the PISCES M4 (MultiMedia Maintenance Manager) system. Of particular interest within this environment is the provision of a multimedia user interface (MUI) to die maintenance process. As a means of evaluating the PISCES method and to provide feedback into die ISCM process a number of practical applications have been modelled. In summary, this research has considered a number of concepts some of which are innovative in themselves, others of which are used in an innovative manner. In combination these concepts may be considered to considerably advance the knowledge and understanding of die comprehension process during the maintenance of legacy software systems. A number of publications have already resulted from the research and several more are in preparation. Additionally a number of areas for further study have been identified some of which are already underway as funded research and development projects.
23

Acquiring data designs from existing data-intensive programs

Yang, Hongji January 1994 (has links)
The problem area addressed in this thesis is extraction of a data design from existing data intensive program code. The purpose of this is to help a software maintainer to understand a software system more easily because a view of a software system at a high abstraction level can be obtained. Acquiring a data design from existing data intensive program code is an important part of reverse engineering in software maintenance. A large proportion of software systems currently needing maintenance is data intensive. The research results in this thesis can be directly used in a reverse engineering tool. A method has been developed for acquiring data designs from existing data intensive programs, COBOL programs in particular. Program transformation is used as the main tool. Abstraction techniques and the method of crossing levels of abstraction are also studied for acquiring data designs. A prototype system has been implemented based on the method developed. This involved implementing a number of program transformations for data abstraction, and thus contributing to the production of a tool. Several case studies, including one case study using a real program with 7000 Hues of source code, are presented. The experiment results show that the Entity-Relationship Attribute Diagrams derived from the prototype can represent the data designs of the original data intensive programs. The original contribution of the thesis is that the approach presented in this thesis can identify and extract data relationships from the existing code by combining analysis of data with analysis of code. The approach is believed to be able to provide better capabilities than other work in the field. The method has indicated that acquiring a data design from existing data intensive program code by program transformation with human assistance is an effective method in software maintenance. Future work is suggested at the end of the thesis including extending the method to build an industrial strength tool.
24

Diagnosing and tolerating bugs in deployed systems

Bond, Michael David. January 1900 (has links)
Thesis (Ph. D.)--University of Texas at Austin, 2008. / Vita. Includes bibliographical references.
25

Manutenção de Software: problemas típicos e diretrizes para uma disciplina específica / Software maintenance: typical problems and guidelines for a specific discipline

Paduelli, Mateus Maida 21 May 2007 (has links)
O volume crescente de software em funcionamento em todo tipo de organização vem despertando atenção para uma fase do ciclo de vida de software, até então considerada sempre de maneira secundária, a manutenção de software. O fato de geralmente não ser viável substituir os produtos de software de uma organização por outros baseados em tecnologias mais recentes, torna a manutenção daqueles sistemas legados um desafio adicional para a busca de técnicas e métodos para a manutenção de software. Os problemas oriundos dessa atividade precisam ser melhor compreendidos, e é justamente na definição e estudo dessas dificuldades que este trabalho se dedica. O confronto da teoria de engenharia de software com observações práticas conduz para a melhor definição de quais são os problemas típicos de manutenção de software e do que se dispõe para abordá-los. Finalmente, com base no entendimento formado sobre os problemas, neste trabalho são apresentdas diretrizes para guiar a elaboração de uma disciplina específica de manutenção de software para cursos de graduação na área de computação / The increasing volume of software being used in all types of organizations has been calling attention for a phase of the software life cycle, until now considered in a secondary way, the software maintenance. Since it is generally not possible to replace all software products used in an organization by others based on more recent technologies, the maintenance of those legacy systems becomes one more challenge for the search of techniques and methods to handle the software maintenance efficiently. The problems arising from this activity need to be better understood, and it is precisely on the definition and study of these difficulties that this work is devoted. The confrontation between the theory of software engineering and practice observations drives to the definition of typical problems of software maintenance and what exists to solve them. Besides, based on the understanding about these problems, this work also presents guidelines to drive the elaboration of a specific discipline of software maintenance for undergraduate courses in computing area
26

Manutenção de Software: problemas típicos e diretrizes para uma disciplina específica / Software maintenance: typical problems and guidelines for a specific discipline

Mateus Maida Paduelli 21 May 2007 (has links)
O volume crescente de software em funcionamento em todo tipo de organização vem despertando atenção para uma fase do ciclo de vida de software, até então considerada sempre de maneira secundária, a manutenção de software. O fato de geralmente não ser viável substituir os produtos de software de uma organização por outros baseados em tecnologias mais recentes, torna a manutenção daqueles sistemas legados um desafio adicional para a busca de técnicas e métodos para a manutenção de software. Os problemas oriundos dessa atividade precisam ser melhor compreendidos, e é justamente na definição e estudo dessas dificuldades que este trabalho se dedica. O confronto da teoria de engenharia de software com observações práticas conduz para a melhor definição de quais são os problemas típicos de manutenção de software e do que se dispõe para abordá-los. Finalmente, com base no entendimento formado sobre os problemas, neste trabalho são apresentdas diretrizes para guiar a elaboração de uma disciplina específica de manutenção de software para cursos de graduação na área de computação / The increasing volume of software being used in all types of organizations has been calling attention for a phase of the software life cycle, until now considered in a secondary way, the software maintenance. Since it is generally not possible to replace all software products used in an organization by others based on more recent technologies, the maintenance of those legacy systems becomes one more challenge for the search of techniques and methods to handle the software maintenance efficiently. The problems arising from this activity need to be better understood, and it is precisely on the definition and study of these difficulties that this work is devoted. The confrontation between the theory of software engineering and practice observations drives to the definition of typical problems of software maintenance and what exists to solve them. Besides, based on the understanding about these problems, this work also presents guidelines to drive the elaboration of a specific discipline of software maintenance for undergraduate courses in computing area
27

An implementation of a software engineering project management system : a tool for a prototype software engineering environment

Castle, Oliver Bert January 2010 (has links)
Typescript (photocopy). / Digitized by Kansas Correctional Industries
28

Model update system for modifications

Ding, Yulin, University of Western Sydney, College of Health and Science, School of Computing and Mathematics January 2007 (has links)
Model checking is an existing approach for automatic reasoning. The model checker is an important tool and has been applied to software engineering for system verification. As an extension of model checking, model update is a new concept and has been defined and developed in this dissertation. A model updater is employed as an automatic system modification tool for software verification. The combination of model checking and model update completes the task of automatic system verification. In this dissertation, a comprehensive theoretical foundation and prototype implementation for CTL model update are developed. First, five primitive updates which capture the basic atomic operations in a CTL Kripke model are identified and formalized. Next, the minimal change criteria for CTL model update based on these primitive operations are defined. Then, updating an original model to a new model satisfying CTL semantics based on previous primitive updates and minimal change rules is characterized. The related complexity of CTL model update is also analyzed. Following this research, formal algorithms in the form of pseudo code to be used as the guidance for future implementation are designed. Then, a prototype CTL model updater is implemented. This prototype CTL model updater is a stand alone utility and contains both model checking and update functions. The prototype is then applied to three well known models and has successfully been tested. During the implementation, as a byproduct, the approach for extracting a complete Kripke model from NuSMV is described. Also, during the implementation, an up-date model explosion problem is discovered and further minimal change rules based on the original minimal change rules are proposed which significantly reduce the number of minimally updated models. The corresponding theory is formalized and the complexity for solving the update model explosion problem is analyzed. / Doctor of Philosophy (Ph.D.)
29

A Design-rule-Based Constructive Approach To Building Traceable Software

Ghazarian, Arbi 18 February 2010 (has links)
The maintenance of large-scale software systems without trace information between development artifacts is a challenging task. This thesis focuses on the problem of supporting software maintenance through a mechanism for establishing traceability relations between the system requirements and its code elements. The core of the proposed solution is a set of design rules that regulates the positional (e.g., package), structural (e.g., class), and behavioral (e.g., method) aspects of the system elements, thus establishing traceability between requirements and code. We identify several types of requirements each of which can be supported by design rules. We introduce a rule-based approach to software construction and demonstrate that such a process can support maintainability through two mechanisms: (a) traceability and (b) reduction of defect rate. We distinguish our work from traditional traceability approaches in that we regard traceability as an intrinsic structural property of software systems. This view of traceability is in contrast to traditional traceability approaches where traceability is achieved extrinsically through creating maps such as the traceability matrices or allocation tables. The approach presented in this thesis has been evaluated through conducting several empirical studies as well as building a proof-of-concept system. The results we obtained demonstrate the effectiveness and usefulness of our approach.
30

A Design-rule-Based Constructive Approach To Building Traceable Software

Ghazarian, Arbi 18 February 2010 (has links)
The maintenance of large-scale software systems without trace information between development artifacts is a challenging task. This thesis focuses on the problem of supporting software maintenance through a mechanism for establishing traceability relations between the system requirements and its code elements. The core of the proposed solution is a set of design rules that regulates the positional (e.g., package), structural (e.g., class), and behavioral (e.g., method) aspects of the system elements, thus establishing traceability between requirements and code. We identify several types of requirements each of which can be supported by design rules. We introduce a rule-based approach to software construction and demonstrate that such a process can support maintainability through two mechanisms: (a) traceability and (b) reduction of defect rate. We distinguish our work from traditional traceability approaches in that we regard traceability as an intrinsic structural property of software systems. This view of traceability is in contrast to traditional traceability approaches where traceability is achieved extrinsically through creating maps such as the traceability matrices or allocation tables. The approach presented in this thesis has been evaluated through conducting several empirical studies as well as building a proof-of-concept system. The results we obtained demonstrate the effectiveness and usefulness of our approach.

Page generated in 0.1516 seconds