Relevant bibliographies by topics / Exception Handling / Dissertations / Theses

Dissertations / Theses on the topic 'Exception Handling'

To see the other types of publications on this topic, follow the link: Exception Handling.
Author: Grafiati
Published: 4 June 2021
Last updated: 1 February 2022

Create a spot-on reference in APA, MLA, Chicago, Harvard, and other styles

Select a source type:

Consult the top 50 dissertations / theses for your research on the topic 'Exception Handling.'

Next to every source in the list of references, there is an 'Add to bibliography' button. Press on it, and we will generate automatically the bibliographic reference to the chosen work in the citation style you need: APA, MLA, Harvard, Chicago, Vancouver, etc.

You can also download the full text of the academic publication as pdf and read online its abstract whenever available in the metadata.

Browse dissertations / theses on a wide variety of disciplines and organise your bibliography correctly.

1

Shamal, Taher Sahand. "Exceptional Actors Implementing Exception Handling for Encore." Thesis, Uppsala universitet, Institutionen för informationsteknologi, 2017. http://urn.kb.se/resolve?urn=urn:nbn:se:uu:diva-330862.

Full text
Abstract:
Encore is an object-oriented programming language which uses the acto rmodel as its concurrency model, and is specifically aimed atimplementing concurrent and parallel systems. Communication between actors is done via asynchronous method calls, which store their results in futures, placeholder objects for later storing the result of a computation. Encore currently lacks an exception handling mechanism, which is an important part of programming languages, and helps programmers create more fault tolerant and robust software. This thesis presents an exception handling implementation for Encore, in whichfutures are used to propagate errors between actors. The implementation uses a modified version of the open-source library Exceptions4C as a basis, and enables basic exception handling through try-catch-finally expressions. It uses type-based matching that also considers subtyping, and allows the programmer to define and throw custom exception types. Apull-model is used to enable inter-process communication of exceptions, where receiving actors can choose to handle exceptions at any point by consuming associated futures. The implementation is a good first step,but there are Encore features such as streams which it does not yet support. Furthermore, it brings an overhead to programs, which can be reduced by redesigning parts of the exception handling model.
APA, Harvard, Vancouver, ISO, and other styles
2

Gurunath, Pramod. "OCL exception handling." Thesis, Texas A&M University, 2004. http://hdl.handle.net/1969.1/1281.

Full text
Abstract:
Object Constraint Language (OCL) is part of the Unified Modeling Language (UML) specification and can be used to enforce constraints on the attributes or methods of a class. It would greatly help the software developers if such non-executable OCL constraints specified in a UML model could be enforced on the executable code generated from the model. This thesis discusses the concepts, ideas and the approach in transforming a model developed in the Rational Rose software with OCL constraints into Java code shells, complete with fragments of code to detect the run-time violations of the constraints. The implementation and testing of a prototype tool that incorporates these ideas is also discussed.
APA, Harvard, Vancouver, ISO, and other styles
3

DAMASCENO, KARLA NAZARE FERREIRA. "CONTEXT-SENSITIVE EXCEPTION HANDLING." PONTIFÍCIA UNIVERSIDADE CATÓLICA DO RIO DE JANEIRO, 2006. http://www.maxwell.vrac.puc-rio.br/Busca_etds.php?strSecao=resultado&nrSeq=9181@1.

Full text
Abstract:
CONSELHO NACIONAL DE DESENVOLVIMENTO CIENTÍFICO E TECNOLÓGICO
FUNDAÇÃO PADRE LEONEL FRANCA
Tratamento de erros em aplicações móveis sensíveis ao contexto não é uma tarefa trivial devido às características peculiares destes sistemas, como mobilidade, comunicação assíncrona e aumento de imprevisibilidade. Mecanismos convencionais de tratamento de exceções não podem ser utilizados por vários motivos. Primeiro, a propagação de erros deve considerar as mudanças contextuais que ocorrem constantemente nestes sistemas. Segundo, as atividades de recuperação de erros e a estratégia de tratamento de exceções também precisam freqüentemente ser selecionadas de acordo com as informações de contexto. Terceiro, a própria caracterização de uma exceção pode depender do contexto dos dispositivos envolvidos. Embora vários middlewares orientados a contexto ofereçam suporte ao desenvolvimento de aplicações móveis, estes sistemas raramente fornecem suporte adequado ao tratamento de exceções. Este trabalho realiza uma análise das soluções existentes para tratamento de exceções, considerando os requisitos de sensibilidade ao contexto. Além disso, são propostos um modelo para tratamento de exceções sensível ao contexto e um mecanismo implementado a partir de MoCA (Mobile Collaboration Architecture). MoCA é um middleware publish-subscribe que oferece suporte ao desenvolvimento de aplicações móveis colaborativas através da incorporação de serviços de contexto. Finalmente, este trabalho avalia o mecanismo de exceções proposto através de sua utilização em alguns protótipos de aplicações colaborativas desenvolvidas a partir de MoCA. Através do mecanismo, foram implementadas diferentes estratégias de tratamento de exceções que consideram as informações de contexto das aplicações.
Context-sensitive exception handling on mobile systems is not a trivial task due to their intrinsic characteristics: mobility, asynchrony and increased unpredictability. Conventional mechanisms of exception handling can not be used for many reasons. First, error propagation needs considering the contextual changes that often occur in these systems. Second, error recovery and exception handling strategies also frequently need to be selected according to contextual information. Third, the characterization of an exception may depend on the contextual situation of involved devices. Even though there are now several context-oriented middleware systems that provide support for the development of mobile applications, they rarely provide explicit and adequate features for contextsensitive exception handling. This work presents an analysis of existing exception handling mechanisms, which to some extent consider the context-awareness requirements. Besides, it proposes a general model for context-sensitive exception handling and a supporting mechanism implemented using the MoCA (Mobile Collaboration Architecture) infrastructure. MoCA is a publish-subscribe middleware supporting the development of collaborative mobile applications by incorporating explicit services to empower software agents with contextsensitiveness. Finally, this paper reports our experience in implementing contextaware exception handling strategies in some prototype collaborative applications built with the MoCA system.
APA, Harvard, Vancouver, ISO, and other styles
4

Cacho, Nelio Alessandro Azevedo. "Supporting Maintainable Exception Handling with Explicit Exception Channels." Thesis, Lancaster University, 2008. http://ethos.bl.uk/OrderDetails.do?uin=uk.bl.ethos.527180.

Full text
APA, Harvard, Vancouver, ISO, and other styles
5

Sheikh, Muhammad Jamal. "Exception handling in software analysis." Thesis, McGill University, 2008. http://digitool.Library.McGill.CA:80/R/?func=dbin-jump-full&object_id=21999.

Full text
Abstract:
With the advancement in technology, software systems are more and more in control of devices that we use in our daily lives. Complex computer systems are increasingly built for highly critical tasks. Failures of such systems may have severe consequences ranging from loss of business opportunities, physical damage, to loss of human lives. Systems with such responsibilities should be highly dependable. Discovering and documenting potential abnormal situations and irregular user behavior that can interrupt normal system interaction is of tremendous importance in the context of dependable systems development. Exceptions that are identified during requirements elicitation have to be systematically carried over to a subsequent analysis phase, and included in the system specification in order to ensure that the implementation of the system later on can deal with all relevant exceptional situations. This thesis advocates a more methodical approach to exception handling by extending the requirements elicitation and analysis phases of the Fondue development process to address exceptions. Exceptions are discovered at the requirements stage of software development using a use-case based approach, and then mapped to the Fondue specification models: the environment model, in which exceptional messages that signal exceptional situations to the system, the concept model, in which exceptional state is specified that keeps track of the failures of secondary actors, and the operation model, in which recovery functionality is specified. The proposed ideas are illustrated by a comprehensive case study, the 407 ETR Electronic Toll Collection system.
Avec les avancements d'aujourd'hui, les appareils que nous utilisons dans notre vie quotidienne sont de plus en plus dans contrôles des systèmes informatiques. Les systèmes informatiques complexes prennent une nouvelle importance dans la réalisation des tâches hautement critiques. Un échec dans un tel système peut causer des pertes d'occasions d'affaires, des dommages physiques ou, dans le pire des cas, la perte de vies humaines. Les systèmes avec de telles responsabilités doivent être très fiables. La découverte et la documentation des situations potentiellement anormales, sans oublier le comportement irrégulier d'utilisateur qui peut interrompre les interactions régulières du système, sont d'une grande importance dans le contexte de développement de systèmes fiables. Les exceptions qui sont identifiées pendant la phase de collecte des spécifications doivent être systématiquement utilisées a la phase d'analyse, et doivent être également intégrées dans les spécifications systèmes pour assurer que l'implémentation du système peut réagir a toutes les situations exceptionnelles relatives. Cette thèse propose une approche plus méthodique pour la gestion des exceptions en prolongeant les phases de collection de spécifications et d'analyse du processus de développement Fondue pour y ajouter la gestion d'exceptions. Les exceptions sont découvertes dans la phase de spécification du cycle de développement en utilisant une approche cas d'utilisation "use case", pour ensuite les associer aux modèles de spécification Fondue : le modèle d'environnement ou se trouve les messages exceptionnels qui sont envoyés au système dans le cas d'une situation exceptionnelle, le modèle conceptuel, ou les états exceptionnels sont spécifiés un suivi des échecs des acteurs secondaires est effectué; et finalement le modèles opérationnel, ou les fonctionnalités sont spécifiées. Les idées proposées sont illustrées par une étude de cas é
APA, Harvard, Vancouver, ISO, and other styles
6

BARBOSA, EIJI ADACHI MEDEIROS. "RECOMMENDER SYSTEM FOR EXCEPTION HANDLING CODE." PONTIFÍCIA UNIVERSIDADE CATÓLICA DO RIO DE JANEIRO, 2012. http://www.maxwell.vrac.puc-rio.br/Busca_etds.php?strSecao=resultado&nrSeq=20357@1.

Full text
Abstract:
PONTIFÍCIA UNIVERSIDADE CATÓLICA DO RIO DE JANEIRO
CONSELHO NACIONAL DE DESENVOLVIMENTO CIENTÍFICO E TECNOLÓGICO
FUNDAÇÃO DE APOIO À PESQUISA DO ESTADO DO RIO DE JANEIRO
Mecanismos de tratamento de exceções são modelos comumente usados em linguagens de programação para a estruturação do fluxo de execução excepcional de módulos de software. Tais mecanismos possibilitam a detecção e a sinalização da ocorrência de exceções, permitindo que módulos de software tomem medidas corretivas que recuperem o sistema para um estado correto. Estudos recentes mostram que falhas recorrentes e problemas de desempenho em aplicações de software estão relacionados à má qualidade do código que implementa o tratamento de exceções. Os estudos preliminares realizados no contexto desta dissertação não apenas corroboram esses resultados, como também evidenciam uma série de outros fatos interessantes que ocorrem durante a evolução de sistemas de software. Em especial, percebeu-se que é bastante comum nas versões preliminares de um sistema a implementação de ações de tratamento de exceções ineficazes. Também se percebeu que pouco (ou nenhum) esforço é realizado em termos de melhorar o tratamento de exceções durante a evolução do sistema de software. Os trabalhos recentes que se propõem a auxiliar desenvolvedores de software a lidar com código de tratamento de exceções falham em auxiliá-los em uma tarefa primordial: implementar código de tratamento de exceções bem estruturado desde as primeiras versões de um sistema. Neste contexto, o presente trabalho propõe um sistema de recomendação capaz de prover exemplos de código tratando exceções de modo a auxiliar desenvolvedores a implementarem seu próprio código em suas aplicações. O sistema extrai informações estruturais do código sob desenvolvimento para buscar por exemplos em um repositório local a fim de recomendar exemplos de código com contexto parecido ao que o desenvolvedor está trabalhando. O sistema implementado neste trabalho recomenda exemplos de código implementados em Java.
Exception handling mechanisms are models commonly used in programming languages to structure the exceptional execution flow of software modules. These mechanisms enable the detection and signaling of exception occurrences, allowing these modules to take corrective actions to recover a module to a correct state. Recent studies show that recurrent failures and performance issues in software applications are related to the poor structuring of exception handling code. The preliminary studies performed in the context of this dissertation not only confirm these results, but also show other interesting facts that occur during software evolution. In particular, it was realized that it is often very common to observe ineffective exception handling actions in the first releases of a system. It was also realized that little (or no) effort was allocated to improve the quality of these action during the software evolution. Recent studies that aim aiding software developers to deal with exception handling elements fail in assisting them in a crucial task: implementing well-structured exception handling code since the first release of a system. In this context, this dissertation proposes a recommender system able to provide code fragments implementing exception handling code. The proposed strategy aims to assist developers in implementing their own code in their applications. The system extracts structural information from the code under development to search for examples in a local repository in order to recommend code examples that share similar structural context with the code that the developer is working on. The system implemented in the context of this dissertation recommends code examples implemented in Java.
APA, Harvard, Vancouver, ISO, and other styles
7

Tellefsen, Christian. "An Examination of Issues with Exception Handling Mechanisms." Thesis, Norwegian University of Science and Technology, Department of Computer and Information Science, 2007. http://urn.kb.se/resolve?urn=urn:nbn:no:ntnu:diva-9529.

Full text
Abstract:

Exception handling suffers from a fluke in its evolution. Some time in the 1970's, a researcher called Goodenough introduced the exception handling mechanism, known today as the tcode{try...catch} construct. At about the same time, two fellows called Parnas and Würges published a paper about "undesired events". This paper appears forgotten. The funny thing is, Parnas and Würges effectively described how to emph{use} exception handling mechanisms. There is a need to respond to this undesired event. Exception handling suffers from lack of design guidelines and a number of inconsistencies with the object-oriented paradigm, among other things. The thesis' main contribution is creating a library of exception challenges and the evaluation of safety facades, an approach that introduce an architecture and guidelines for designing exception handling. Through qualitative evaluation, this thesis shows how safety facades form an interesting new approach to exception handling.

APA, Harvard, Vancouver, ISO, and other styles
8

Adams, Michael James. "Facilitating dynamic flexibility and exception handling for workflows." Queensland University of Technology, 2007. http://eprints.qut.edu.au/16600/.

Full text
Abstract:
Workflow Management Systems (WfMSs) are used to support the modelling, analysis, and enactment of business processes. The key benefits WfMSs seek to bring to an organisation include improved efficiency, better process control and improved customer service, which are realised by modelling rigidly structured business processes that in turn derive well-defined workflow process instances. However, the proprietary process definition frameworks imposed by WfMSs make it difficult to support (i) dynamic evolution and adaptation (i.e. modifying process definitions during execution) following unexpected or developmental change in the business processes being modelled; and (ii) exceptions, or deviations from the prescribed process model at runtime, even though it has been shown that such deviations are a common occurrence for almost all processes. These limitations imply that a large subset of business processes do not easily translate to the 'system-centric' modelling frameworks imposed. This research re-examines the fundamental theoretical principles that underpin workflow technologies to derive an approach that moves forward from the productionline paradigm and thereby offers workflow management support for a wider range of work environments. It develops a sound theoretical foundation based on Activity Theory to deliver an implementation of an approach for dynamic and extensible flexibility, evolution and exception handling in workflows, based not on proprietary frameworks, but on accepted ideas of how people actually perform their work activities. The approach produces a framework called worklets to provide an extensible repertoire of self-contained selection and exception-handling processes, coupled with an extensible ripple-down rule set. Using a Service-Oriented Architecture (SOA), a selection service provides workflow flexibility and adaptation by allowing the substitution of a task at runtime with a sub-process, dynamically selected from its repertoire depending on the context of the particular work instance. Additionally, an exceptionhandling service uses the same repertoire and rule set framework to provide targeted and multi-functional exception-handling processes, which may be dynamically invoked at the task, case or specification level, depending on the context of the work instance and the type of exception that has occurred. Seven different types of exception can be handled by the service. Both expected and unexpected exceptions are catered for in real time. The work is formalised through a series of Coloured Petri Nets and validated using two exemplary studies: one involving a structured business environment and the other a more creative setting. It has been deployed as a discrete service for the well-known, open-source workflow environment YAWL, and, having a service orientation, its applicability is in no way limited to that environment, but may be regarded as a case study in service-oriented computing whereby dynamic flexibility and exception handling for workflows, orthogonal to the underlying workflow language, is provided. Also, being open-source, it is freely available for use and extension.
APA, Harvard, Vancouver, ISO, and other styles
9

BARBOSA, EIJI ADACHI MEDEIROS. "GLOBAL-AWARE RECOMMENDATIONS FOR REPAIRING EXCEPTION HANDLING VIOLATIONS." PONTIFÍCIA UNIVERSIDADE CATÓLICA DO RIO DE JANEIRO, 2015. http://www.maxwell.vrac.puc-rio.br/Busca_etds.php?strSecao=resultado&nrSeq=26804@1.

Full text
Abstract:
PONTIFÍCIA UNIVERSIDADE CATÓLICA DO RIO DE JANEIRO
CONSELHO NACIONAL DE DESENVOLVIMENTO CIENTÍFICO E TECNOLÓGICO
FUNDAÇÃO DE APOIO À PESQUISA DO ESTADO DO RIO DE JANEIRO
Tratamento de exceções e o modo mais comum de lidar com erros no desenvolvimento de software robusto. Tratamento de exceções refere-se ao processo de sinalizar exceções quando erros em tempo de execução são detectados e de tomar ações para responder à ocorrência destas exceções. Apesar de objetivarem a melhoria da robustez de software, sistemas de software ainda são implementados sem se basear em uma política explícita para tratamento de exceções. Cada política define as decisões de projeto que governam como tratamento de exceções deve ser implementado num sistema. Tais políticas não são comumente documentadas e são apenas implicitamente definidas no projeto do sistema. Desta forma, desenvolvedores tendem a introduzir no código fonte violações das políticas implícitas e tais violações comumente causam falhas em sistemas de software. Neste contexto, o objetivo desta tese é apoiar desenvolvedores na detecção e reparação de violações de tratamento de exceções. Para atingir este objetivo, duas soluções complementares foram propostas. A primeira solução é baseada numa linguagem específica de domínio que apoia a detecção de violações ao definir explicitamente políticas de tratamento de exceções que devem ser obedecidas no código fonte. A linguagem proposta foi avaliada num estudo centrado no usuário e num estudo de caso. Com as observações e as experiências coletadas no estudo centrado no usuário, nós identificamos algumas características da linguagem que dificultavam o seu uso e que motivaram novos construtos. Além disso, os resultados do estudo de caso mostraram que violações e falhas costumam ter causas comuns. Portanto, violações de tratamento de exceção podem ser usadas para detectar causas de faltas relacionadas à exceções. Para complementar a detecção de violações, este trabalho também propôs uma solução para apoiar o reparo de violações de tratamento de exceções. Reparar estas violações requer raciocinar sobre o impacto global que mudanças em tratamento de exceções pode ter em diferentes partes do sistema. Desta forma, este trabalho propôs uma estratégia heurística de recomendação que leva em conta o contexto global onde violações ocorrem a fim de produzir recomendações. Cada recomendação produzida consiste em uma sequência de modificações que servem como um plano detalhado de como uma violação de tratamento de exceções pode ser removida do código fonte. A estratégia de recomendação proposta também se beneficia de especificações explícitas de políticas, embora sua disponibilidade não seja obrigatória. Os resultados das nossas avaliações empíricas revelaram que a estratégia de recomendação proposta produziu recomendações capazes de reparar violações em aproximadamente 70 por cento dos casos. Quando especificações de políticas estão disponíveis, a estratégia produziu recomendações capazes de reparar violações em 97 por cento dos casos.
Exception handling is the most common way of dealing with exceptions in robust software development. Exception handling refers to the process of signaling exceptions upon the detection of runtime errors and taking actions to respond to their occurrence. Despite being aimed at improving software robustness, software systems are still implemented without relying on explicit exception handling policies. Each policy defines the design decisions governing how exception handling should be implemented in a system. These policies are often not documented and are only implicitly defined in the system design. Thus, developers tend to introduce in the source code violations of implicit policies and these violations commonly cause failures in software systems. In this context, the goal of this thesis is to support developers in detecting and repairing exception handling violations. To achieve this goal, two complementary solutions were proposed. The first solution is based on a domain-specific language supporting the detection of violations by explicitly defining exception handling policies to be enforced in the source code. The proposed language was evaluated with a user-centric study and a case study. With the observations and experiences gathered in the user-centric study, we identified some language characteristics that hindered its use and that motivated new language constructs. In addition, the results of the case study showed that violations and faults in exception handling share common causes. Therefore, violations can be used to detect potential causes of exceptionrelated failures. To complement the detection of exception handling violations, this work also proposed a solution for supporting the repair of exception handling violations. Repairing these violations requires reasoning about the global impact that exception handling changes might have in different parts of the system. Thus, this work proposed a recommender heuristic strategy that takes into account the global context of where violations occur to produce recommendations. Each recommendation produced consists of a sequence of modifications that serves as a detailed blueprint of how an exception handling violation can be removed from the source code. The proposed recommender strategy also takes advantage of explicit policy specifications, although their availability is not mandatory. The results of our empirical assessments revealed that the proposed recommender strategy produced recommendations able to repair violations in approximately 70 per cent of the cases. When policy specifications are available, it produced recommendations able to repair violations in 97 per cent of the cases.
APA, Harvard, Vancouver, ISO, and other styles
10

Mahanga, Mwaka. "Unknown Exception Handling Tool Using Humans as Agents." UNF Digital Commons, 2015. http://digitalcommons.unf.edu/etd/563.

Full text
Abstract:
In a typical workflow process, exceptions are the norm. Exceptions are defined as deviations from the normal sequence of activities and events. Exceptions can be divided into two broad categories: known exceptions (i.e., expected and predefined deviations) and unknown exceptions (i.e., unexpected and undefined deviations). Business Process Execution Language (BPEL) has become the de facto standard for executing business workflows with the use of web services. BPEL includes exception handling methods that are sufficient for known exception scenarios. Depending on the exception and the specifics of the exception handling tools, processes may either halt or move to completion. Instances of processes that are halted or left incomplete due to unhandled exceptions affect the performance of the workflow process, as they increase resource utilization and process completion time. However, designing efficient process handlers to avoid the issue of unhandled exceptions is not a simple task. This thesis provides a tool that handles unknown exceptions using provisions for exception handling with the involvement of human activities by using the BPEL4PEOPLE specification. BPEL4PEOPLE, an extension of BPEL, offers the ability to specify human activities within BPEL processes. The approach considered in this thesis involves humans in exception handling tools by providing an alternate sub process within a given business process. A prototype application has been developed implementing the tool that handles unknown exceptions. The prototype application monitors the progress of an automated workflow process and permits human involvement to reroute the course of a workflow process when an unknown exception occurs. The utility of the prototype and the tool using the Scenario Walkthrough and Inspection Methods (SWIMs) are demonstrated. We demonstrate the utility of the tool through loan application process scenarios, and offer a walkthrough of the system by using examples of instances with examples of known and unknown exceptions, as well as a claims analysis of process instances results.
APA, Harvard, Vancouver, ISO, and other styles
11

Derks, Wouter W. C. "Enhanced exception handling in sales order processing workflows." Thesis, Loughborough University, 2003. https://dspace.lboro.ac.uk/2134/34298.

Full text
Abstract:
In a general study of the literature eleven main areas of research were considered relevant to workflow management and its application in the domain of Sales Order Processing (SOP). It was concluded that exception handling may provide a unifying focus on the dynamic behaviour of workflow systems. Indeed this initial study revealed that current workflow approaches: (1) will overly constrain sales order processors as they seek to handle exceptions by imposing unrealistic and thus rigid ways of working onto their end-users; (2) do not support the needs of workflow system developers very well, since their workflow specifications are time-consuming to develop and maintain and are difficult to verify. Having made these observations this study conducted a detailed literature study and identified three main classes of workflow approaches, namely: traditional workflow approaches (i.e. SADT/IDEF0, Grai Nets, IDEF3, IEM and ClMOSA), ECA workflow approaches (i.e. WIDE and Rapide) and transactional workflow approaches (i.e. Sagas, ConTracts, and Partial Rollbacks). Subsequently it was decided to study specific properties of sales order processing exceptions and their effects.
APA, Harvard, Vancouver, ISO, and other styles
12

Nehmer, Nikolas [Verfasser]. "Exception Handling - A Systematic Log-Based Approach / Nikolas Nehmer." München : Verlag Dr. Hut, 2012. http://d-nb.info/1021719315/34.

Full text
APA, Harvard, Vancouver, ISO, and other styles
13

Rubira, Cecilia Mary Fischer. "Structuring fault-tolerant object-oriented systems using inheritance and delegation." Thesis, University of Newcastle Upon Tyne, 1994. http://hdl.handle.net/10443/1961.

Full text
Abstract:
Many entities in the real world that a software system has to interact with, e.g., for controlling or monitoring purposes, exhibit different behaviour phases in their lifetime, in particular depending on whether or not they are functioning correctly. That is, these entities exhibit not only a normal behaviour phase but also one or more abnormal behaviour phases associated with the various faults which occur in the environment. These faults are referred to as environmental faults. In the object-oriented software, real-world entities are modeled as objects. In a classbased object-oriented language, such as C++, all objects of a given class must follow the same external behaviour, i.e., they have the same interface and associated implementation. However this requires that each object permanently belong to a particular class, imposing constraints on the mutability of the behaviour for an individual object. This thesis proposes solutions to the problem of finding means whereby objects representing real-world entities which exhibit various behaviour phases can make corresponding changes in their own behaviour in a clear and explicit way, rather than through status-checking code which is normally embedded in the implementation of various methods. Our proposed solution is (i) to define a hierarchy of different subclasses related to an object which corresponds to an external entity, each subclass implementing a different behaviour phase that the external entity can exhibit, and (ii) to arrange that each object forward the execution of its operations to the currently appropriate instance of this hierarchy of subclasses. We thus propose an object-oriented approach for the provision of environmental fault tolerance, which encapsulates the abnormal behaviour of "faulty" entities as objects (instances of the above mentioned subclasses). These abnormal behaviour variants are defined statically, and runtime access to them is implemented through a delegation mechanism which depends on the current phase of behaviour. Thus specific reconfiguration changes at the level of objects can be easily incorporated to a software system for tolerating environmental faults.
APA, Harvard, Vancouver, ISO, and other styles
14

Ebert, Felipe. "An Exploratory Study on Exception Handling Bugs in Java Programs." Universidade Federal de Pernambuco, 2013. https://repositorio.ufpe.br/handle/123456789/11984.

Full text
Abstract:
Several studies argue that exception handling code is usually of poor quality and that it is commonly neglected by developers. Moreover, it is said to be the least understood, documented, and tested part of the implementation of a system. In spite of this scenario, there are very few studies that analyze the actual exception handling bugs that occur in real software systems and no study that attempts to understand developers’ perceptions about these bugs. In this work we present an exploratory study on exception handling bugs that employs two complementary approaches: a survey of 154 developers and an analysis of 220 bugs from the repositories of Eclipse and Tomcat. Respondents of our survey believe that exception handling bugs are more easily fixed than other kinds of bugs. There is also a significant difference in the opinion of the respondents pertaining to the quality of the exception handling code: more experienced developers tend to believe that it is worse. Analysis of the repositories of Eclipse and Tomcat revealed conflicting results. The fix time for exception handling bugs in Eclipse is significantly shorter than for other bugs. However, exception handling bugs have a significantly greater number of discussion messages than non-exception handling bugs. On the other hand, for Tomcat, we could not find a significant difference for fix time and exception handling bugs have significantly less discussion messages than other bugs. Moreover, we discovered that bug reports describing bugs stemming from overly general catch blocks, a well-known bad smell in programs that use exceptions, are rare, even though there are many opportunities for them to occur. In addition, empty catch blocks are not only prevalent, as previously reported in literature, but they are also commonly used as part of bug fixes, which includes fixes for exception handling bugs. Furthermore, we found very few bug reports whose causes are empty catch blocks, although developers often mention them as causes of bugs they have fixed in the past. And lastly, we present a proposal of the classification of exception handling bugs based on the data we collected.
Submitted by João Arthur Martins (joao.arthur@ufpe.br) on 2015-03-10T18:18:46Z No. of bitstreams: 2 Dissertaçao Felipe Ebert.pdf: 1326280 bytes, checksum: b28c0a4b3a4f5a5d84483b41a94a7a48 (MD5) license_rdf: 1232 bytes, checksum: 66e71c371cc565284e70f40736c94386 (MD5)
Made available in DSpace on 2015-03-11T17:40:09Z (GMT). No. of bitstreams: 2 Dissertaçao Felipe Ebert.pdf: 1326280 bytes, checksum: b28c0a4b3a4f5a5d84483b41a94a7a48 (MD5) license_rdf: 1232 bytes, checksum: 66e71c371cc565284e70f40736c94386 (MD5) Previous issue date: 2013-08-02
FACEPE e CNPq
Vários estudos afirmam que o código de tratamento de exceções em geral tem baixa qualidade e que é geralmente negligenciado por desenvolvedores. Além disso, acredita-se que essa parte da implementação de um sistema é a menos compreendida, documentada e testada. Apesar desse cenário, existem poucos estudos que analisam bugs de tratamento de exceções que ocorrem em sistemas de software reais e nenhum estudo que tente entender a percepção dos desenvolvedores sobre esses bugs. Neste trabalho, apresentamos um estudo exploratório sobre bugs de tratamento de exceções baseado em duas abordagens complementares: uma pesquisa com 154 desenvolvedores e uma análise de 220 bugs dos repositórios do Eclipse e Tomcat. Os desenvolvedores de nossa pesquisa acreditam que bugs de tratamento de exceções são mais facilmente corrigidos do que outros tipos de bugs. Há também uma diferença significativa na opinião dos desenvolvedores sobre a qualidade do código de tratamento de exceções: os desenvolvedores mais experientes tendem a acreditar que é pior. A análise dos repositórios do Eclipse e Tomcat revelou resultados conflitantes. O tempo de correção dos bugs de tratamento de exceções do Eclipse é significativamente menor do que o de outros tipos de bugs. Entretanto, os bugs de tratamento de exceções têm um número significativamente maior de comentários do que os bugs que não são de tratamento de exceções. Por outro lado, para o Tomcat, não conseguimos achar uma diferença significativa para o tempo de correção dos bugs e os bugs de tratamento de exceções tem um número significativamente menor de comentários do que os outros tipos de bugs. Além disso, descobrimos que os bugs decorrentes de blocos catch genéricos, um defeito bem conhecido em programas que usam exceções, são raros, embora existam várias oportunidades para que eles ocorram. Descobrimos também que blocos catch vazios não são só prevalentes, como previamente relatado na literatura, mas também geralmente usados como correções dos bugs, inclusive para bugs de tratamento de exceções. Também achamos poucos bugs reportados em que as causas deles são blocos catch vazios, embora desenvolvedores frequentemente mencionem eles como causas de bugs que já corrigiram no passado. E por fim, apresentamos uma proposta de classificação dos bugs de tratamento de exceções.
APA, Harvard, Vancouver, ISO, and other styles
15

Muthitacharoen, Athicha 1976. "An experimental analysis of exception handling services for multi-agent systems." Thesis, Massachusetts Institute of Technology, 2000. http://hdl.handle.net/1721.1/86529.

Full text
Abstract:
Thesis (S.B. and M.Eng.)--Massachusetts Institute of Technology, Dept. of Electrical Engineering and Computer Science, 2000.
Includes bibliographical references (leaves 43-45).
by Athicha Muthitacharoen.
S.B.and M.Eng.
APA, Harvard, Vancouver, ISO, and other styles
16

Aldosary, Saad. "Investigation of multimodal template-free biometric techniques and associated exception handling." Thesis, University of Kent, 2015. https://kar.kent.ac.uk/54805/.

Full text
Abstract:
The Biometric systems are commonly used as a fundamental tool by both government and private sector organizations to allow restricted access to sensitive areas, to identify the criminals by the police and to authenticate the identification of individuals requesting to access to certain personal and confidential services. The applications of these identification tools have created issues of security and privacy relating to personal, commercial and government identities. Over the last decade, reports of increasing insecurity to the personal data of users in the public and commercial domain applications has prompted the development of more robust and sound measures to protect the personal data of users from being stolen and spoofing. The present study aimed to introduce the scheme for integrating direct and indirect biometric key generation schemes with the application of Shamir‘s secret sharing algorithm in order to address the two disadvantages: revocability of the biometric key and the exception handling of biometric modality. This study used two different approaches for key generation using Shamir‘s secret sharing scheme: template based approach for indirect key generation and template-free. The findings of this study demonstrated that the encryption key generated by the proposed system was not required to be stored in the database which prevented the attack on the privacy of the data of the individuals from the hackers. Interestingly, the proposed system was also able to generate multiple encryption keys with varying lengths. Furthermore, the results of this study also offered the flexibility of providing the multiple keys for different applications for each user. The results from this study, consequently, showed the considerable potential and prospect of the proposed scheme to generate encryption keys directly and indirectly from the biometric samples, which could enhance its success in biometric security field.
APA, Harvard, Vancouver, ISO, and other styles
17

Pretnar, Matija. "Logic and handling of algebraic effects." Thesis, University of Edinburgh, 2010. http://hdl.handle.net/1842/4611.

Full text
Abstract:
In the thesis, we explore reasoning about and handling of algebraic effects. Those are computational effects, which admit a representation by an equational theory. Their examples include exceptions, nondeterminism, interactive input and output, state, and their combinations. In the first part of the thesis, we propose a logic for algebraic effects. We begin by introducing the a-calculus, which is a minimal equational logic with the purpose of exposing distinct features of algebraic effects. Next, we give a powerful logic, which builds on results of the a-calculus. The types and terms of the logic are the ones of Levy’s call-by-push-value framework, while the reasoning rules are the standard ones of a classical multi-sorted first-order logic with predicates, extended with predicate fixed points and two principles that describe the universality of free models of the theory representing the effects at hand. Afterwards, we show the use of the logic in reasoning about properties of effectful programs, and in the translation of Moggi’s computational ¸-calculus, Hennessy-Milner logic, and Moggi’s refinement of Pitts’s evaluation logic. In the second part of the thesis, we introduce handlers of algebraic effects. Those not only provide an algebraic treatment of exception handlers, but generalise them to arbitrary algebraic effects. Each such handler corresponds to a model of the theory representing the effects, while the handling construct is interpreted by the homomorphism induced by the universal property of the free model. We use handlers to describe many previously unrelated concepts from both theory and practice, for example CSS renaming and hiding, stream redirection, timeout, and rollback.
APA, Harvard, Vancouver, ISO, and other styles
18

Mourão, Hernâni. "Supporting Effective Unexpected Exception Handling in Workflow Management Systems Within Organizational Contexts." Doctoral thesis, Department of Informatics, University of Lisbon, 2008. http://hdl.handle.net/10451/14289.

Full text
Abstract:
Workflow Management Systems support the execution of organizational processes within organizations. Processes are modelled using high level languages specifying the sequence of tasks the organization has to perform. However, organizational processes do not have always a smooth flow conforming to any possible designed model and exceptions to the rule happen often. Organizations require flexibility to react to situations not predicted in the model. The required flexibility should be complemented with robustness to guarantee system reliability even in extreme situations. In our work, we have introduced the concept of WfMS resilience that comprises these two facets: robustness and flexibility. The main objective of our work is to increase resilience in Workflow Management Systems. From the events demanding for Workflow Management Systems resilience, we focused on ad hoc effective unexpected exceptions as those for which no previous knowledge exist is the organization to derive the handling procedure and no plan can be a priori established. These exceptions usually require human intervention and problem solving activities, since the concrete situation may not be entirely understood before humans start reacting to the event. After discussing existing approaches to increase WfMS resilience, we have identified five levels of conformity. The fifth level, being the most demanding one, requires unrestricted humanistic interventions to workflow execution. In this thesis, we propose a system to support unrestricted users' interventions to the WfMS and we characterize the interventions as unstructured activities. The system has two modes of operation: it usually works under model control and changes to unstructured activities support when an exception is detected. The exception handling activities are carried out until the system is placed back into a coherent mode, where work may proceed under model execution control
APA, Harvard, Vancouver, ISO, and other styles
19

Pears, Simon. "Using mobility and exception handling to achieve mobile agents that survive server crash failures." Thesis, Durham University, 2005. http://etheses.dur.ac.uk/2387/.

Full text
Abstract:
Mobile agent technology, when designed and used effectively, can minimize bandwidth consumption and autonomously provide a snapshot of the current context of a distributed system. Protecting mobile agents from server crashes is a challenging issue, since developers normally have no control over remote servers. Server crash failures can leave replicas, instable storage, unavailable for an unknown time period. Furthermore, few systems have considered the need for using a fault tolerant protocol among a group of collaborating mobile agents. This thesis uses exception handling to protect mobile agents from server crash failures. An exception model is proposed for mobile agents and two exception handler designs are investigated. The first exists at the server that created the mobile agent and uses a timeout mechanism. The second, the mobile shadow scheme, migrates with the mobile agent and operates at the previous server visited by the mobile agent. A case study application has been developed to compare the performance of the two exception handler designs. Performance results demonstrate that although the second design is slower it offers the smaller trip time when handling a server crash. Furthermore, no modification of the server environment is necessary. This thesis shows that the mobile shadow exception handling scheme reduces complexity for a group of mobile agents to survive server crashes. The scheme deploys a replica that monitors the server occupied by the master, at each stage of the itinerary. The replica exists at the previous server visited in the itinerary. Consequently, each group member is a single fault tolerant entity with respect to server crash failures. Other schemes introduce greater complexity and performance overheads since, for each stage of the itinerary, a group of replicas is sent to servers that offer an equivalent service. In addition, future research is established for fault tolerance in groups of collaborating mobile agents.
APA, Harvard, Vancouver, ISO, and other styles
20

Beque, Luciéli Tolfo. "Avaliação dos requisitos para teste de um sistema operacional embarcado." reponame:Biblioteca Digital de Teses e Dissertações da UFRGS, 2009. http://hdl.handle.net/10183/17799.

Full text
Abstract:
A sociedade está cada vez mais dependente de sistemas embarcados, sendo que na grande maioria das vezes eles operam de maneira invisível aos seus usuários. Essa dependência torna esses usuários vulneráveis a riscos, devido às falhas que podem ocorrer. Essas falhas podem provocar perdas de vidas ou sérios danos materiais e financeiros. Devido a estes fatos, a qualidade destes produtos torna-se um ponto essencial para se ter um sistema estável, livre de erros e com todas as suas funcionalidades sendo executadas. De encontro a isso, a etapa de teste apresenta-se como indispensável e de relevada importância para a obtenção de um produto com uma boa qualidade. Devido ao alto custo de produção e energia gasto com testes, surge a necessidade de novos estudos, sobre diversificados métodos, para se testar um sistema embarcado. Neste contexto, este trabalho tem como objetivo apresentar os estudos iniciais do teste de um Sistema Operacional Embarcado (SOE), através de um estudo de caso focado na rotina de tratamento de exceção do eCos (Embedded Configurable Operating System), pois ela apresenta uma forte interação entre software e hardware, sendo que esta interação é um dos principais desafios encontrados no teste de um software embarcado. Com isso, este trabalho pretende dar o passo inicial para pesquisas relacionadas aos testes de um Sistema Operacional Embarcado. Após a análise dos experimentos, pôde-se notar que a principal característica do Sistema Operacional Embarcado eCos, a configurabilidade, é um ponto de dificuldade extra para a realização dos testes, pois exige um estudo detalhado do código do SOE, o qual é totalmente genérico, antes do planejamento dos testes, podendo ser gasto muito tempo nessa atividade. Outro ponto é que o teste torna-se totalmente dependente do hardware. Entretanto, os resultados experimentais apresentados para o estudo de caso do presente trabalho foram satisfatórios.
Society is increasingly dependent on embedded systems, which in most cases operate in an invisible manner to its users. This dependence makes the user vulnerable to risks due to failures that may occur. These failures can cause loss of lives or serious property and financial damage. Because of these facts, the quality of these products becomes a key point to have a stable system, free of errors and with all the features running. This testing is of essential importance to obtain a product with good quality. Due to the high cost of production and energy spent on tests, there is a need for further studies on different methods, to test an embedded system. In this context, this work aims at presenting the initial studies as the testing of the Embedded Operating System. The case study was focused on the exception handling routine of the eCos (Embedded Configurable Operating System), because it has a strong interaction between software and hardware, and this interaction is one of the main challenges encountered in testing embedded software. Therefore, this work aims at taking the first steps towards research related to testing an Embedded Operating System. After analyzing the experiments, it was noted that the main feature of the Embedded Operating System, eCos, the configurability, is an extra point of difficulty for the tests. It requires a detailed study of the code eCos, which is completely general, before the planning of tests, and could be spent much time in this activity. Another point is that the test becomes totally dependent on hardware. However, the experimental results presented for the case study of this study showed satisfactory.
APA, Harvard, Vancouver, ISO, and other styles
21

Lima, Rafael de. "CatchML: a modeling language for context aware exception handling verification and specification in ubiquitous systems." Universidade Federal do CearÃ, 2013. http://www.teses.ufc.br/tde_busca/arquivo.php?codArquivo=13871.

Full text
Abstract:
Conselho Nacional de Desenvolvimento CientÃfico e TecnolÃgico
In ubiquitous systems, due to the complexity added by the use of contextual information, the application of context aware exception handling (CAEH) techniques has many challenges and in the literature several approaches have been found to define concepts and abstractions useful for modeling CAEH. However, only one of these approaches proposes a method for specification and verification of models in the field of ubiquitous systems, which provides a tool for specifying the CAEH model using a Java API, and also generates an error report to a text file. The disadvantage of this approach is that the designer should strive to understand programming details that are irrelevant to the analysis process of the exceptional behavior of the system. Then, this work aims to propose a domain specific language for modeling CAEH, which provides abstractions and constructors that allow to express relevant concepts and make the task of designing CAEH models simpler and more intuitive. In addition, the language is integrated with the tool mentioned before that allows automatic model verification. The errors generated by the verifier are now shown directly in the source code making their identification and correction easier for the designer. In order to evaluate the language, a case study is conducted to provide evidence of its viability as an alternative to modeling CAEH.
Em sistemas ubÃquos, devido à complexidade inserida pela utilizaÃÃo de informaÃÃes contextuais, a aplicaÃÃo de tÃcnicas de tratamento de exceÃÃo sensÃvel ao contexto (TESC) tem sido objeto de estudo para muitos pesquisadores. Na literatura sÃo encontradas diversas abordagens que definem conceitos e abstraÃÃes Ãteis para modelagem de TESC. Entretanto, apenas uma dessas abordagens propÃe um mÃtodo para especificaÃÃo e verificaÃÃo de modelos no domÃnio de sistemas ubÃquos o qual fornece uma ferramenta para especificaÃÃo do modelo de TESC atravÃs de uma API Java, e gera ainda um relatÃrio de erros em um arquivo texto. A desvantagem dessa abordagem à que o projetista deve se esforÃar para entender detalhes de programaÃÃo irrelevantes ao processo de anÃlise do comportamento excepcional do sistema. Esta dissertaÃÃo tem portanto como objetivo propor uma linguagem de domÃnio especÃfico para modelagem de TESC, com o intuito de oferecer abstraÃÃes e construtores que permitem expressar conceitos pertinentes e tornar a tarefa de projetar modelos de TESC mais simples e intuitiva. AlÃm disso, a linguagem à integrada com a ferramenta citada anteriormente, o que permite realizar a verificaÃÃo do modelo de forma automÃtica. Os erros gerados pelo verificador sÃo mostrados agora diretamente no cÃdigo do modelo facilitando a identificaÃÃo e correÃÃo dos mesmos pelo projetista. A fim de avaliar a linguagem, um estudo de caso à realizado para fornecer indÃcios de sua viabilidade como alternativa para modelagem de TESC.
APA, Harvard, Vancouver, ISO, and other styles
22

LÔBO, Rafael Brandão. "Deadlocks as runtime exceptions." Universidades Federais de Pernambuco, 2015. https://repositorio.ufpe.br/handle/123456789/17332.

Full text
Abstract:
Submitted by Fabio Sobreira Campos da Costa (fabio.sobreira@ufpe.br) on 2016-07-12T12:30:10Z No. of bitstreams: 2 license_rdf: 1232 bytes, checksum: 66e71c371cc565284e70f40736c94386 (MD5) DISSERTAÇÃO (2015-08-17) - RAFAEL BRANDAO LOBO.pdf: 1015468 bytes, checksum: d543b6f16adc4ce4d3aa4d59c8d546ff (MD5)
Made available in DSpace on 2016-07-12T12:30:10Z (GMT). No. of bitstreams: 2 license_rdf: 1232 bytes, checksum: 66e71c371cc565284e70f40736c94386 (MD5) DISSERTAÇÃO (2015-08-17) - RAFAEL BRANDAO LOBO.pdf: 1015468 bytes, checksum: d543b6f16adc4ce4d3aa4d59c8d546ff (MD5) Previous issue date: 2015-07-17
CAPEs
Deadlocks are a common type of concurrency bug. When a deadlock occurs, it is difficult to clearly determine whether there is an actual deadlock or if the application is slow or hanging due to a different reason. It is also difficult to establish the cause of the deadlock. In general, developers deal with deadlocks by using analysis tools, introducing application-specific deadlock detection mechanisms, or simply by using techniques to avoid the occurrence of deadlocks by construction. In this paper we propose a different approach. We believe that if deadlocks manifest at runtime, as exceptions, programmers will be able to identify these deadlocks in an accurate and timely manner. We leverage two insights to make this practical: (i) most deadlocks occurring in real systems involve only two threads acquiring two locks (TTTL deadlocks); and (ii) it’s possible to detect TTTL deadlocks efficiently enough for most practical systems. We conducted a study on bug reports and found that more than 90% of identified deadlocks were indeed TTTL.We extended Java’s ReentrantLock class to detect TTTL deadlocks and measured the performance overhead of this approach with a conservative benchmark. For applications whose execution time is not dominated by locking, the overhead is estimated as below 6%. Empirical usability evaluation in two experiments showed that students finished tasks 16.87% to 30.7% faster on the average using our approach with the lock being the most significant factor behind it, and, in one of the experiments they were able to identify the defects more accurately with a signficant 81.25% increase in the number of correct answers when deadlock exceptions where present.
Deadlocks são um tipo comum de bug de concorrência. Quando um deadlock acontece, é difícil determinar claramente se houve um deadlock de verdade ou se a aplicação está lenta ou travada por qualquer outro motivo. Também é difícil estabelecer a causa do deadlock. Em geral, desenvolvedores lidam com deadlocks de várias maneiras: utilizando ferramentas analíticas; utilizando mecanismos especificos da aplicação para detectar deadlocks; ou simplesmente usando técnicas para evitar a ocorrência de deadlocks no momento da construção do código. Neste trabalho, propomos uma abordagem diferente. Acreditamos que se deadlocks se manifestarem durante a execução na forma de exceções, programadores serão capazes de identificar esses deadlocks de forma mais precisa e mais rápida. Levamos em consideração alguns aspectos para tornar esta abordagem prática: (i) a maioria dos deadlocks que ocorrem em sistemas reais envolvem apenas duas threads adquirindo dois locks ou two-thread, two-lock (TTTL) deadlock; e (ii) é possível detectar TTTL deadlocks de forma suficientemente eficiente para uso prático na maioria dos sistemas. Conduzimos um estudo com bugs reportados em sistemas de software de larga escala e descobrimos que mais de 90% dos bugs identificados como deadlocks eram de fato TTTL. Extendemos a classe ReentrantLock de Java para detectar TTTL deadlocks e medimos seu overhead na performance com um benchmark bastante conservador onde medimos o overhead das operações de trava quando deadlocks não são possíveis. Para aplicações cujo tempo de execução não é dominado por travas, o impacto médio no tempo de execução é na ordem de 6%. Realizamos uma avaliação empírica para testar usabilidade através de dois experimentos. Nesta avaliação, mostramos que, em média, estudantes terminam tarefas de 16.87% a 30.7% mais rapidamente usando nossa abordagem, sendo o tipo de abordagem o fator de maior significância e, em um dos experimentos, estudantes foram capazes de identificar mais corretamente a causa dos bugs, mostrando que o número de respostas corretas aumentou significativamente em 81.25% quando as exceções propostas estavam presentes.
APA, Harvard, Vancouver, ISO, and other styles
23

Davari, Mahdad. "Improving an FPGA Optimized Processor." Thesis, Linköpings universitet, Datorteknik, 2011. http://urn.kb.se/resolve?urn=urn:nbn:se:liu:diva-71190.

Full text
Abstract:
This work aims at improving an existing soft microprocessor core optimized for Xilinx Virtex®-4 FPGA. Instruction and data caches will be designed and implemented. Interrupt support will be added as well, preparing the microprocessor core to host operating systems. Thorough verification of the added modules is also emphasized in this work. Maintaining core clock frequency at its maximum has been the main concern through all the design and implementation steps.
APA, Harvard, Vancouver, ISO, and other styles
24

Sheng, Quanzheng Computer Science &amp Engineering Faculty of Engineering UNSW. "Composite web services provisioning in dynamic environments." Awarded by:University of New South Wales. Computer Science and Engineering, 2006. http://handle.unsw.edu.au/1959.4/23457.

Full text
Abstract:
Web services composition is emerging as a promising technology for the effective automation of application-to-application collaborations. The application integration problems have been subject of much research in the past years. However, with growth in importance of business process automation and highly dynamic nature of the Internet, this research has taken on a new significance and importance. Adequate solutions to this problem will be very important to make enterprise systems more flexible, robust and usable in the future. In this dissertation, we present a novel approach for the declarative definition and scalable orchestration of composite Web services in large, autonomous, heterogeneous, and dynamic environments. We first propose a composition model for composing Web services in a personalized and adaptive manner. We model composite Web services based on statecharts. To cater for large amounts of dynamic Web services, we use the concept of service community that groups services together and is responsible for the runtime selection of services against user's preferences. We use the concept of process schema that specific users can adjust with their personal preferences. A set of exception handling policies can be specified to proactively react to runtime exceptions. We then propose a tuple space based service orchestration model for distributed, self-managed composite services execution. We introduce the concept of execution controller that is associated with a service and is responsible for monitoring and controlling service executions. The knowledge required by a controller is statically extracted from the specification of personalized composite services. We also present techniques for robust Web services provisioning. The techniques presented in this dissertation are implemented in Self-Serv, a prototype that provides a set of tools for Web service composition and execution. Finally, we conduct an extensive usability and performance study of the proposed techniques. The experimental results reveal that our system i) provides an efficient support for specifying, deploying, and accessing composite services; ii) is more scalable and outperforms the centralized approach when the exchanged messages become bigger; and iii) is more robust and adaptive in highly dynamic environments.
APA, Harvard, Vancouver, ISO, and other styles
25

Sales, Junior Ricardo Jos? "Uma abordagem para a verifica??o do comportamento excepcional a partir de regras de designe e testes." Universidade Federal do Rio Grande do Norte, 2013. http://repositorio.ufrn.br:8080/jspui/handle/123456789/18076.

Full text
Abstract:
Made available in DSpace on 2014-12-17T15:48:06Z (GMT). No. of bitstreams: 1 RicardoJSJ_DISSERT.pdf: 4102063 bytes, checksum: 92b62a467283fb011a1258e8b80ca7b4 (MD5) Previous issue date: 2013-02-01
Checking the conformity between implementation and design rules in a system is an important activity to try to ensure that no degradation occurs between architectural patterns defined for the system and what is actually implemented in the source code. Especially in the case of systems which require a high level of reliability is important to define specific design rules for exceptional behavior. Such rules describe how exceptions should flow through the system by defining what elements are responsible for catching exceptions thrown by other system elements. However, current approaches to automatically check design rules do not provide suitable mechanisms to define and verify design rules related to the exception handling policy of applications. This paper proposes a practical approach to preserve the exceptional behavior of an application or family of applications, based on the definition and runtime automatic checking of design rules for exception handling of systems developed in Java or AspectJ. To support this approach was developed, in the context of this work, a tool called VITTAE (Verification and Information Tool to Analyze Exceptions) that extends the JUnit framework and allows automating test activities to exceptional design rules. We conducted a case study with the primary objective of evaluating the effectiveness of the proposed approach on a software product line. Besides this, an experiment was conducted that aimed to realize a comparative analysis between the proposed approach and an approach based on a tool called JUnitE, which also proposes to test the exception handling code using JUnit tests. The results showed how the exception handling design rules evolve along different versions of a system and that VITTAE can aid in the detection of defects in exception handling code
Verificar a conformidade entre a implementa??o de um sistema e suas regras de design ? uma atividade importante para tentar garantir que n?o ocorra a degrada??o entre os padr?es arquiteturais definidos para o sistema e o que realmente est? implementado no c?digo-fonte. Especialmente no caso de sistemas dos quais se exige um alto n?vel de confiabilidade ? importante definir regras de design (design rules) espec?ficas para o comportamento excepcional. Tais regras descrevem como as exce??es devem fluir atrav?s do sistema, definindo quais s?o os elementos respons?veis por capturar as exce??es lan?adas por outros elementos do sistema. Entretanto, as abordagens atuais para verificar automaticamente regras de design n?o proveem mecanismos adequados para definir e verificar regras de design espec?ficas para a pol?tica de tratamento de exce??es das aplica??es. Este trabalho prop?e uma abordagem pr?tica para preservar o comportamento excepcional de uma aplica??o ou fam?lia de aplica??es, baseada na defini??o e verifica??o autom?tica em tempo de execu??o de regras de design de tratamento de exce??o para sistemas desenvolvidos em Java ou AspectJ. Para apoiar esta abordagem foi desenvolvida, no contexto deste trabalho, uma ferramenta chamada VITTAE (Verification and Information Tool to Analyze Exceptions) que estende o framework JUnit e permite automatizar atividades do teste de regras de design excepcionais. Foi realizado um estudo de caso preliminar com o objetivo de avaliar a efic?cia da abordagem proposta sobre uma linha de produto de software. Al?m deste, foi realizado um experimento cujo objetivo foi realizar uma an?lise comparativa entre a abordagem proposta e uma abordagem baseada na ferramenta JUnitE, que tamb?m prop?e testar o c?digo de tratamento de exce??es utilizando testes JUnit. Os resultados mostraram que as regras de design excepcionais evoluem ao longo de diferentes vers?es de um sistema e que a VITTAE pode auxiliar na detec??o de defeitos no c?digo de tratamento de exce??o
APA, Harvard, Vancouver, ISO, and other styles
26

Hamadi, Rachid Computer Science &amp Engineering Faculty of Engineering UNSW. "Formal Composition and Recovery Policies in Service-Based Business Processes." Awarded by:University of New South Wales. Computer Science and Engineering, 2005. http://handle.unsw.edu.au/1959.4/20666.

Full text
Abstract:
Process-based composition of Web services is emerging as a promising technology for the effective automation of integrated and collaborative applications. As Web services are often autonomous and heterogeneous entities, coordinating their interactions to build complex processes is a difficult, error prone, and time-consuming task. In addition, since Web services usually operate in dynamic and highly evolving environments, there is a need for supporting flexible and correct execution of integrated processes. In this thesis, we propose a Petri net-based framework for formal composition and recovery policies in service-based business processes. We first propose an algebra for composing Web services. The formal semantics of this algebra is expressed in terms of Petri nets. The use of a formal model allows the effective verification and analysis of properties, both within a service, such as termination and absence of deadlock, and between services, such as behavioral equivalences. We also develop a top down approach for the correct (e.g., absence of deadlock and termination) composition of complex business processes. The approach defines a set of refinement operators that guarantee correctness of the resulting business process nets at design time. We then introduce Self-Adaptive Recovery Net (SARN), an extended Petri net model for specifying exceptional behavior in business processes. SARN adapts the structure of the underlying Petri net at run time to handle exceptions while keeping the Petri net design simple and easy. The proposed framework caters for the specification of high-level recovery policies that are incorporated either with a single task or a set of tasks, called a recovery region. Finally, we propose a pattern-based approach to dynamically restructure SARN. These patterns capture the ways past exceptions have been dealt with. The objective is to continuously restructure recovery regions within the SARN model to minimize the impact of exception handling. To illustrate the viability of the proposed composition and exception handling techniques, we have developed HiWorD (HIerarchical WORkflow Designer), a hierarchical Petri net-based business process modeling and simulation tool.
APA, Harvard, Vancouver, ISO, and other styles
27

Xavier, Kleber da Silva. "Ambiente de testes utilizando verificação de componentes java com tratamento de exceções." Universidade de São Paulo, 2008. http://www.teses.usp.br/teses/disponiveis/45/45134/tde-11082008-134008/.

Full text
Abstract:
Um sistema de software que apresente problemas em sua execução pode gerar conseqüências desde um simples incômodo ao usuário, até desastres como a perda de uma sonda da NASA em Marte. As atividades de teste visam identificar erros nos sistemas de software, prevenindo estas conseqüências indesejáveis. Porém, os testes podem envolver entre 30% e 40% do esforço de desenvolvimento do sistema, e em sistemas críticos, seu custo pode ser de 3 a 5 vezes maior do que o custo combinado das demais atividades. Para tentar reduzir estes custos podemos automatizar parte das atividades. No presente caso, pretende-se minimizar os casos de teste gerados manualmente, utilizando uma técnica denominada verificação de modelos. Esta técnica consiste em verificar propriedades definidas formalmente através de expressões matemáticas, utilizando uma ferramenta de verificação que simula a execução do código. Além disso, um sistema que utilize um tratamento de condições excepcionais eficiente, tem sua manutenibilidade, robustez e confiabilidade melhoradas. Por isso, definimos propriedades relacionadas ao tratamento de exceções, como ponto de entrada para a verificação de modelos. Apresentamos um ambiente de testes criado para permitir a verificação destas propriedades com o verificador Java PathFinder e a exibição das estatísticas de cobertura de testes de acordo com o critério selecionado. Este ambiente facilita a execução dos testes, pois apresenta uma interface gráfica com o usuário que permite a configuração e execução dos testes sem que seja necessária a escrita de código pelo testador. Apresentamos também o resultado do uso deste ambiente para o teste de vários programas exemplo, utilizando desde código concorrente até diferentes estratégias de tratamento de exceção e discutimos as características, cuidados no uso e limitações das ferramentas utilizadas.
A software system that shows some failure at runtime execution may bring consequences that range from a simple user annoyance to great disasters such as the lost NASA probe on Mars. The test activities aim to find errors in software systems, preventing these undesirable consequences. However, tests may take between 30% and 40% of total development time, and on critical systems, its cost can be from 3 to 5 times greater than the combined cost of the other activities. In an effort to reduce these costs, we may automate some of the activities. In this work we intend to minimize test case manual generation, using a technique called model checking. This technique involves the checking of properties defined through the use of mathematical formulas, using a tool, that simulates code execution. In addition, a system with an efficient exception handling mechanism, has its maintainability, robustness and reliability enhanced. So, in this work we define exception handling related properties, as an input for model checking. We present a test tool created to allow checking of these properties using the Java PathFinder model checker, and to list the test coverage statistics, according to the selected test criteria. This tool makes easy the test execution, since it presents a graphical user interface that allows configuration and running of tests with no need to write any lines of code. We also show the results of running several tests with the GUI, using some programs implemented with concurrent code and several exception handling techniques and discuss the main features, pitfalls and limitations of the underlying tools.
APA, Harvard, Vancouver, ISO, and other styles
28

Ortega, Marcela Garcia. "Implementação do arcabouço WED-flow para controle de processos transacionais." Universidade de São Paulo, 2013. http://www.teses.usp.br/teses/disponiveis/45/45134/tde-17072013-111452/.

Full text
Abstract:
A área de gerenciamento de processos de negócio apresenta-se ativa e tem recebido atenção tanto da comunidade de pesquisa como da indústria. Uma das principais preocupações nessa área é a escolha da melhor abordagem para modelagem e implementação de processos de negócio. Atualmente, organizações possuem processos de negócio com complexas estruturas que são reavaliados e ajustados com frequência, exigindo flexibilidade das linguagens para modelagem de processos. Além disso, processos de negócio atuais também exigem ambientes para implementação capazes de garantir confiabilidade na execução de instâncias do processo modelado, especialmente em caso de falhas. Embora diversos modelos transacionais tenham sido propostos com o objetivo de garantir propriedades transacionais adaptadas ao contexto de processos de negócio, a implementação de processos transacionais ainda oferece um cenário com desafios teóricos e práticos. Neste trabalho apresentamos uma implementação da abordagem WED-flow para controle de processos transacionais. A WED-flow é uma abordagem que combina conceitos de modelos transacionais avançados, eventos e estados de dados com o objetivo principal de reduzir a complexidade no tratamento de exceções. A ferramenta de software desenvolvida é capaz de controlar a execução de instâncias de processos de negócio, permite a evolução incremental do modelo projetado e ainda disponibiliza a estrutura necessária para apoiar a implementação de mecanismos de recuperação para tratar interrupções em instâncias causadas por exceções.
Business processes management is an active area which have received increased attention from research and industry communities. A major concern is the selection of the best approach for modeling and implementing business processes. Nowadays, organizations have business processes with complex structures, which are reevaluated and adjusted frequently, requiring flexibility from modeling languages. In addition, current business processes also require implementation environments capable of ensuring execution reliability, especially in case of failures. Although several transactional models have been proposed in order to guarantee transactional properties adapted to the context of business processes, the implementation of transactional processes still offers a scenario with several theoretical and practical challenges. In this work, we present an implementation of WED-flow approach for controlling transactional processes. WED-flow is an approach which combines the concepts of advanced transactional models, events and data states for the purpose of reducing exception handling complexity. The developed software tool is able of controlling the execution of business processes instances, allows incremental evolution of the designed model and also provides the necessary structure to support recovery mechanisms implementation to handle instances interruptions caused by exceptions.
APA, Harvard, Vancouver, ISO, and other styles
29

Silva, Pedro Paulo de Souza Bento da. "Uma abordagem transacional para o tratamento de exceções em processos de negócio." Universidade de São Paulo, 2013. http://www.teses.usp.br/teses/disponiveis/45/45134/tde-24022014-094221/.

Full text
Abstract:
Com o intuito de tornarem-se mais eficientes, muitas organizações -- empresas, órgãos governamentais, centros de pesquisa, etc. -- optam pela utilização de ferramentas de software para apoiar a realização de seus processos. Uma opção que vem se tornando cada vez mais popular é a utilização de sistemas de Gestão de Processos de Negócio (GPN), que são ferramentas genéricas, ou seja, não são específicas a nenhuma organização, altamente configuráveis e ajustáveis às necessidades dos objetos de atuação de cada organização. Uma das principais responsabilidades de um sistema de GPN é prover mecanismos de tratamento de exceções à execução de instâncias de processos de negócio. Exceções, se forem ignoradas ou se não forem corretamente tratadas, podem causar o aborto da execução de instâncias e, dependendo da gravidade da situação, podem causar falhas em sistemas de GPN ou até mesmo em sistemas subjacentes (sistema operacional, sistema gerenciador de banco de dados, etc.). Sendo assim, mecanismos de tratamento de exceções têm por objetivo resolver a situação excepcional ou conter seus efeitos colaterais garantindo, ao menos, uma degradação controlada (graceful degradation) do sistema. Neste trabalho, estudamos algumas das principais deficiências de modelos atuais de tratamento de exceções, no contexto de sistemas de GPN, e apresentamos soluções baseadas em Modelos Transacionais Avançados para contorná-las. Isso é feito por meio do aprimoramento dos mecanismos de tratamento de exceções da abordagem de modelagem e gerenciamento de execução de processos de negócio WED-flow. Por fim, estendemos a ferramenta WED-tool, uma implementação da abordagem WED-flow, através do desenvolvimento de seu gerenciador de recuperação de falhas.
With the aim of becoming more efficient, many organizations -- companies, governmental entities, research centers, etc -- choose to use software tools for supporting the accomplishment of its processes. An option that becomes more popular is the usage of Business Process Management Systems (BPM), which are generic tools, that is, not specific to any organization and highly configurable to the domain needs of any organization. One of the main responsibilities of BPM Systems is to provide exception handling mechanisms for the execution of business process instances. Exceptions, if ignored or incorrectly handled, may induce the abortion of instance executions and, depending on the gravity of the situation, induce failures on BPM Systems or even on subjacent systems (operational system, database management systems, etc.). Thus, exception handling mechanisms aim to solve the exceptional situation or stopping its collateral effects by ensuring, at least, a graceful degradation to the system. In this work, we study some of the main deficiencies of present exception handling models -- in the context of BPM Systems -- and present solutions based on Advanced Transaction Models to bypass them. We do this through the improvement of exception handling mechanisms from WED-flow, a business process modelling and instance execution managing approach. Lastly, we extend the WED-tool, an implementation of WED-flow approach, through the development of its failure recovery manager.
APA, Harvard, Vancouver, ISO, and other styles
30

Lima, Rafael de. "CatchML: uma linguagem de domínio específico para modelagem do tratamento de exceção sensível ao contexto." reponame:Repositório Institucional da UFC, 2013. http://www.repositorio.ufc.br/handle/riufc/18515.

Full text
Abstract:
LIMA, Rafael de. CatchML: uma linguagem de domínio específico para modelagem do tratamento de exceção sensível ao contexto. 2013. 111 f. Dissertação (Mestrado em ciência da computação)- Universidade Federal do Ceará, Fortaleza-CE, 2013.
Submitted by Elineudson Ribeiro (elineudsonr@gmail.com) on 2016-07-12T15:18:44Z No. of bitstreams: 1 2013_dis_rlima.pdf: 1916774 bytes, checksum: 8d3c896a97a4692523fcd35305e73f1e (MD5)
Approved for entry into archive by Rocilda Sales (rocilda@ufc.br) on 2016-07-20T13:54:36Z (GMT) No. of bitstreams: 1 2013_dis_rlima.pdf: 1916774 bytes, checksum: 8d3c896a97a4692523fcd35305e73f1e (MD5)
Made available in DSpace on 2016-07-20T13:54:36Z (GMT). No. of bitstreams: 1 2013_dis_rlima.pdf: 1916774 bytes, checksum: 8d3c896a97a4692523fcd35305e73f1e (MD5) Previous issue date: 2013
In ubiquitous systems, due to the complexity added by the use of contextual information, the application of context aware exception handling (CAEH) techniques has many challenges and in the literature several approaches have been found to define concepts and abstractions useful for modeling CAEH. However, only one of these approaches proposes a method for specification and verification of models in the field of ubiquitous systems, which provides a tool for specifying the CAEH model using a Java API, and also generates an error report to a text file. The disadvantage of this approach is that the designer should strive to understand programming details that are irrelevant to the analysis process of the exceptional behavior of the system. Then, this work aims to propose a domain specific language for modeling CAEH, which provides abstractions and constructors that allow to express relevant concepts and make the task of designing CAEH models simpler and more intuitive. In addition, the language is integrated with the tool mentioned before that allows automatic model verification. The errors generated by the verifier are now shown directly in the source code making their identification and correction easier for the designer. In order to evaluate the language, a case study is conducted to provide evidence of its viability as an alternative to modeling CAEH.
Em sistemas ubíquos, devido à complexidade inserida pela utilização de informações contextuais, a aplicação de técnicas de tratamento de exceção sensível ao contexto (TESC) tem sido objeto de estudo para muitos pesquisadores. Na literatura são encontradas diversas abordagens que definem conceitos e abstrações úteis para modelagem de TESC. Entretanto, apenas uma dessas abordagens propõe um método para especificação e verificação de modelos no domínio de sistemas ubíquos o qual fornece uma ferramenta para especificação do modelo de TESC através de uma API Java, e gera ainda um relatório de erros em um arquivo texto. A desvantagem dessa abordagem é que o projetista deve se esforçar para entender detalhes de programação irrelevantes ao processo de análise do comportamento excepcional do sistema. Esta dissertação tem portanto como objetivo propor uma linguagem de domínio específico para modelagem de TESC, com o intuito de oferecer abstrações e construtores que permitem expressar conceitos pertinentes e tornar a tarefa de projetar modelos de TESC mais simples e intuitiva. Além disso, a linguagem é integrada com a ferramenta citada anteriormente, o que permite realizar a verificação do modelo de forma automática. Os erros gerados pelo verificador são mostrados agora diretamente no código do modelo facilitando a identificação e correção dos mesmos pelo projetista. A fim de avaliar a linguagem, um estudo de caso é realizado para fornecer indícios de sua viabilidade como alternativa para modelagem de TESC.
APA, Harvard, Vancouver, ISO, and other styles
31

Queiroz, Filho Carlos Alberto Batista de. "Um mecanismo de tratamento de excessões sensível ao contexo para sistemas ubíquos orientados a tarefas." reponame:Repositório Institucional da UFC, 2012. http://www.repositorio.ufc.br/handle/riufc/17525.

Full text
Abstract:
QUEIROZ FILHO, Carlos Alberto Batista de. Um mecanismo de tratamento de excessões sensível ao contexo para sistemas ubíquos orientados a tarefas. 2012. 95 f. : Dissertação (mestrado) - Universidade Federal do Ceará, Centro de Ciências, Departamento de Computação, Fortaleza-CE, 2012.
Submitted by guaracy araujo (guaraa3355@gmail.com) on 2016-06-08T16:21:00Z No. of bitstreams: 1 2012_dis_cabqueirozfilho.pdf: 1970524 bytes, checksum: 4c0037e9a7ae7b752cee99522d45b0b2 (MD5)
Approved for entry into archive by guaracy araujo (guaraa3355@gmail.com) on 2016-06-08T16:24:48Z (GMT) No. of bitstreams: 1 2012_dis_cabqueirozfilho.pdf: 1970524 bytes, checksum: 4c0037e9a7ae7b752cee99522d45b0b2 (MD5)
Made available in DSpace on 2016-06-08T16:24:48Z (GMT). No. of bitstreams: 1 2012_dis_cabqueirozfilho.pdf: 1970524 bytes, checksum: 4c0037e9a7ae7b752cee99522d45b0b2 (MD5) Previous issue date: 2012
The main purpose of ubiquitous computing is to provide information and features needed to help people in their daily tasks, proactively and transparently, at any time and anywhere. The development of ubiquitous systems involves a set of challenging requirements, including: context awareness, which allows systems to adapt their behavior to respond appropriately in the face of environmental changes, and dependability, which is related to the ability of systems provide a service which offer strong indications that are reliable. Regarding the attributes of dependability, neglecting them can bring grievances from small to severe risks to the physical integrity of the users. Exception handling is a major fault tolerance techniques used in software development to achieve greater levels of dependability. This technique, even though it is widely used in traditional software development, it is still not widely used in the development of ubiquitous systems. This is due to challenging requirements and characteristics of this type of system, among which we highlight the sensitivity to the context and distribution, which can make the necessary possibilities of handling exceptions in a system as a whole is greater than the sum of possibilities for exception handling of the parts that compose it. Therefore, this dissertation aims to propose a mechanism for exception handling context-sensitive ubiquitous systems for task-oriented. The proposed mechanism is available through a framework called foreheads, which allows the reuse mechanism. By using this framework, system functionality can be implemented on an abstraction task, which responds appropriately to changes in context, detecting and treating exceptional situations. To validate the proposed mechanism was implemented a prototype system of parking control ubiquitous as a proof of concept, which focuses on demonstration of how the tasks are implemented that make up this system and how they are defined exceptions contextual and their handlers.
O principal propósito da Computação Ubíqua é o fornecimento de informações e funcionalidades necessárias para ajudar as pessoas em suas tarefas cotidianas, de maneira proativa e transparente, a qualquer instante e em qualquer lugar. O desenvolvimento de sistemas ubíquos envolve um conjunto de requisitos desafiadores, dentre eles: sensibilidade ao contexto, que permite que os sistemas adaptem o seu comportamento para responder de forma apropriada diante de mudanças do ambiente; e dependabilidade, que está relacionado à capacidade dos sistemas de prestarem um serviço os quais ofereçam fortes indícios de que são confiáveis. Em relação aos atributos de dependabilidade, negligenciá-los pode trazer desde pequenas insatisfações até graves riscos à integridade física dos usuários. O tratamento de exceções é uma das principais técnicas de tolerância a faltas empregadas no desenvolvimento de software para atingir maiores níveis de dependabilidade. Essa técnica, apesar de já ser amplamente utilizada no desenvolvimento de software tradicional, ainda é pouco empregada no desenvolvimento de sistemas ubíquos. Isso ocorre em virtude das características e requisitos desafiadores desse tipo de sistema, dentre os quais se destacam a sensibilidade ao contexto e a distribuição, a qual pode fazer com que as possibilidades necessárias de tratamento de exceções de um sistema como um todo seja maior do que a soma das possibilidades de tratamento de exceções das partes que o compõe. Portanto, essa dissertação tem como objetivo propor um mecanismo de tratamento de exceções sensível ao contexto para sistemas ubíquos orientados a tarefas. O mecanismo proposto é disponibilizado através de um framework, denominado FRonTES, que permite a reutilização do mecanismo. Através da utilização desse framework, funcionalidades do sistema podem ser implementadas sob uma abstração de tarefa, que responde de maneira adequada a mudanças de contexto, detectando e tratando situações excepcionais. Para a validação do mecanismo proposto foi implementado um protótipo de sistema de controle de estacionamento ubíquo como uma prova de conceito, que foca na demonstração de como são implementadas as tarefas que compõem esse sistema e como são definidas as exceções contextuais e seus tratadores.
APA, Harvard, Vancouver, ISO, and other styles
32

Leite, Douglas Siqueira. "Projeto e implementação de um mecanismo de tratamento de exceções coordenadas para arquiteturas de componentes de serviços." [s.n.], 2010. http://repositorio.unicamp.br/jspui/handle/REPOSIP/275764.

Full text
Abstract:
Orientador: Cecília Mary Fischer Rubira
Dissertação (mestrado) - Universidade Estadual de Campinas, Instituto de Computação
Made available in DSpace on 2018-08-17T14:44:52Z (GMT). No. of bitstreams: 1 Leite_DouglasSiqueira_M.pdf: 1797650 bytes, checksum: ce96fe468509c785b633e1cde43729dd (MD5) Previous issue date: 2010
Resumo: Arquitetura Orientada a Serviços (Service-Oriented Architecture - SOA) _e um modelo arquitetural que visa melhorar a eficiência, agilidade e a produtividade de aplicações empresariais através do uso de serviços e composições de serviços, as quais podem ser executadas tanto de forma síncrona quanto assíncrona. Diferentes tecnologias de software podem ser usadas para implementar SOA, tais como Web services e Arquitetura de Componentes de Serviços (Service Component Architecture - SCA). A primeira _e baseada em padrões XML, ao passo que a segunda provê um modelo de componentes para implementação de serviços e composições de serviços. Em particular, quando composições de serviços assíncronos são executadas, um ou mais erros podem ocorrer concorrentemente nos diferentes serviços, possivelmente ao mesmo tempo, afetando a dependabilidade da composição. Dessa forma, mecanismos de tolerância a falhas são necessários a _m de prevenir que um defeito se manifeste na composição. Neste trabalho, apresentamos o projeto e implementação de um mecanismo de tratamento de exceções coordenadas para arquiteturas orientadas a serviços que permite a criação de composições de serviços assíncronos tolerante a falhas de uma forma flexível. Mais especifiçamente, nossa solução _e baseada em um mecanismo de tratamento de exceções global, definido pelo modelo Guardian, já que este oferece uma solução mais geral e flexível quando comparado com outras abordagens, tais como soluções baseadas em ações atômicas coordenadas. Nosso framework, denominado Guardian-SCA, foi implementado como parte do projeto Apache Tuscany SCA, usando o modelo de extensão do Tuscany e programação orientada a aspectos, aumentando assim a flexibilidade do framework
Abstract: Service-Oriented Architecture (SOA) is an architectural model that aims to enhance the efficiency, agility, and productivity of an enterprise by structuring services in terms of services compositions, which can be executed either synchronously or asynchronously. Different software technologies can be used to implement SOA, such as Web services and Service Component Architecture (SCA). The former is based on XML-based standards, while the latter provides a component model for implementing services and service compositions. In particular, when asynchronous services compositions are executed, one or more errors can occur concurrently, possibly at same time, affecting the composition's dependability. In this way, fault tolerance mechanisms are necessary in order to prevent the services compositions from reaching a failure state. In this work, we present the design and implementation of a coordinated exception handling mechanism, applicable to service-oriented architectures, which allows the creation of fault-tolerant asynchronous service compositions. More specifically, our solution is based on a global exception handling mechanism defined by the Guardian model, since it is more general and flexible when compared to other approaches, like CA Actions-based solutions. Our framework, named Guardian-SCA, was implemented as a part of the Apache Tuscany SCA project, using the Tuscany extension model and aspect-oriented programming with the aim to increase the framework's exibility
Mestrado
Sistemas de Informação
Mestre em Ciência da Computação
APA, Harvard, Vancouver, ISO, and other styles
33

Brito, Patrick Henrique da Silva. "Um metodo para modelagem de exceções em desenvolvimento baseado em componentes." [s.n.], 2005. http://repositorio.unicamp.br/jspui/handle/REPOSIP/276335.

Full text
Abstract:
Orientador: Cecilia Mary Fischer Rubira
Dissertação (mestrado) - Universidade Estadual de Campinas, Instituto de Computação
Made available in DSpace on 2018-08-05T04:18:48Z (GMT). No. of bitstreams: 1 Brito_PatrickHenriquedaSilva_M.pdf: 1701733 bytes, checksum: c2009f5302dc57e1c6d8e2d4a0c95c85 (MD5) Previous issue date: 2005
Resumo: Devido a grande popularização do Desenvolvimento Baseado em Componentes (DBC), ele vem sendo empregado inclusive no desenvolvimento de sistemas computacionais críticos. O emprego do DBC na construção de sistemas confiáveis evidencia a necessidade de se desenvolver componentes de software que sejam robustos e que possuam uma garantia maior do seu funcionamento correto. Tratamento de exceções é uma técnica bastante conhecida para a verificação e tratamento de erros em sistemas de software. Por'em, apesar da sua popularidade, o seu projeto e a implementação são constituídos de tarefas muito complexas que não recebem uma atenção adequada dos processos de desenvolvimento existentes. A situação É ainda mais crítica se levarmos em considera¸c¿ao os métodos para DBC. Este trabalho propõe um método para auxiliar a modelagem do comportamento excepcional de sistemas baseados em componentes, chamado MDCE+. Baseado no refinamento da metodologia MDCE, o MDCE+ apresenta dois diferenciais importantes, que reforçam o seu aspecto robusto: (i) o fato dele combinar as abordagens top-down e botton-up para o desenvolvimento de sistemas confiáveis; e (ii) o fato dele ser centrado na arquitetura. O foco na arquitetura de software contribui para uma melhor definição e análise do fluxo de exceções entre os componentes do sistema. Essa maneira estruturada de detectar e tratar exceções no contexto da ocorrência de falhas é particularmente relevante para sistemas que apresentam requisitos de confiabilidade extrema. O método MDCE+ é um método genérico que pode ser aplicada a processos de desenvolvimento modernos. Em particular, nesta dissertação o método MDCE+ foi adaptado ao processo UML Components e a uma metodologia de testes. Como maneira de avaliar esse método, foi desenvolvido um estudo de caso de um sistema financeiro real, com requisitos de tolerância a falhas. Dada a sua importância, o processo de avaliação do método MDCE+ foi dividido em tr¿es etapas: (i) preparação; (ii) execução; e (iii) análise dos resultados. Nesse estudo foi necessário tratar exceções na arquitetura do sistema, com o intuito de aumentar a disponibilidade dos serviços
Abstract: Due to the large adoption of the Component-Based Development (CBD), it has also been employed in the development of critical software systems. The development of dependable systems using the CBD paradigm evidences the necessity of developing software components that are robust and dependable. Exception handling is a well known technique for verify and treat errors in software systems. However, despite its popularity, its design and implementation are constituted of very complex tasks that do not receive the adequate attention from the existing development processes. This is still more critical in the context of CBD processes. This work presents the MDCE+, a method that assists the modeling of the exceptional behavior in component-based software development. Based in the refinement of the MDCE methodology, the MDCE+ presents two important differentials, that strengthen its robustness: (i) it combines the top-down and bottom-up strategies for the development of dependable systems; and (ii) it is centered in the software architecture. As a consequence of the focus given to the software architecture, the exceptions that flow between the system components are better defined and analyzed. This structured way to detect and to treat exceptions in the context of the occurrence of imperfections is particularly needed for developing dependable systems. The MDCE+ is a generic method that can be applied together with modern development processes. In particular, in this master thesis MDCE+ was adapted to the UML Components process and to a software test methodology. In order to evaluate this method, a case study of a real financial system with fault-tolerance requirements was developed. Given its importance, the evaluation process of the MDCE+ method was decomposed in three stages: (i) preparation; (ii) execution; and (iii) results analysis. In order to increase the services availability, in this study it was necessary to deal with exceptions in the software architecture
Mestrado
Engenharia de Software
Mestre em Ciência da Computação
APA, Harvard, Vancouver, ISO, and other styles
34

Ferreira, Jeferson 1973. "Validação do fluxo excepcional a partir do diagrama de atividades da UML 2.0." [s.n.], 2011. http://repositorio.unicamp.br/jspui/handle/REPOSIP/275746.

Full text
Abstract:
Orientador: Eliane Martins
Dissertação (mestrado) - Universidade Estadual de Campinas, Instituto de Computação
Made available in DSpace on 2018-08-18T15:53:22Z (GMT). No. of bitstreams: 1 Ferreira_Jeferson_M.pdf: 10344068 bytes, checksum: f13e5d139255d50754dc668d1bbf3fc6 (MD5) Previous issue date: 2011
Resumo: Para a construção de sistemas robustos, devem ser utilizadas técnicas de tolerância a falhas que podem ser implementadas através de mecanismos de tratamento de exceções. Esses mecanismos possibilitam o tratamento de possíveis exceções, ou até mesmo a continuação da execução das funcionalidades do sistema mesmo na presença de uma exceção. O uso dos mecanismos de tratamento de exceções para desenvolver sistemas de software em larga escala, juntamente com o fato de ser implementado por diversas linguagens modernas, confirma a importância desta prática de desenvolvimento. Por outro lado, o uso desses mecanismos tem suas desvantagens, impactando principalmente na complexidade dos sistemas. Um problema que ocorre com muita frequência é efetuar a validação do fluxo excepcional somente na fase de implementação. A detecção de um problema de especificação nesta etapa do processo, pode acarretar em um aumento nos custos e prazos para a entrega do software. Este trabalho apresenta uma abordagem que utiliza as técnicas de análise estática, normalmente empregadas para detectar falhas no código fonte, para antecipar a validação do fluxo excepcional de um componente de software durante o ciclo de desenvolvimento. A solução proposta utiliza as informações do fluxo de controle e fluxo de dados obtidas a partir de um modelo comportamental. O modelo utilizado nesta abordagem é o diagrama de atividades da UML, que passa por uma série de transformações até gerar um grafo de fluxo de controle interprocedimental. Durante este processo são executadas análises de fluxo de dados para inferir com precisão quais são os tipos de exceções podem ser lançadas em dado ponto do modelo. Também faz parte deste trabalho a apresentação de uma ferramenta de apoio para o processo de validação do fluxo excepcional. Esta ferramenta, denominada ADEX (Activity Diagram EXceptional flow analyzer), implementa os algoritmos utilizados para a conversão do diagrama de atividades no grafo de fluxo de controle interprocedimental. A ferramenta também oferece recursos para a visualização do fluxo de controle normal e excepcional do modelo
Abstract: In order to develop robust software, should be used fault tolerant techniques that can be implemented by exception handling mechanisms. These mechanisms allow the handling of possible exceptions or even the continued of execution of the system's functionalities, even in the presence of an exception. The use of exception handling mechanisms to develop large scale software systems together with the fact that several modern programming languages provide these mechanisms, confirm the importance of these mechanisms in practice. On the other hand, the use of these mechanisms has some disadvantages, principally impacting on the complexity of the systems. One problem that occurs very often is performing the validation of the exceptional flow only during the implementation phase. The detection of a specification problem at this stage of the process can lead the increasing of costs and delays to delivery the software. This paper presents an approach that uses static analysis techniques, usually used to detect anomalies in the source code, to antecipate the validation of the exceptional flow of a software component in the development cycle. The proposed solution uses the information of control flow and data flow gathered from a behavioral model. The model used in this approach is the UML activity diagram, which undergoes a series of transformations to generate a interprocedural control flow graph. During this process are performed data flow analysis to inferring precisely what kind of exceptions can be thrown at a specific point of the model. The presentation of a tool to support the validation of the exceptional flow, also is part of this work. This tool, called ADEX (Activity Diagram EXceptional flow analyzer), implements the algorithms used to convert the activity diagram in the interprocedural control flow graph. The tool also provides features for visualization of normal and exceptional control flow of the model
Mestrado
Ciência da Computação
Mestre em Ciência da Computação
APA, Harvard, Vancouver, ISO, and other styles
35

Pereira, David Paulo. "Um framework para coordenação do tratamento de exceções em sistemas tolerantes a falhas." Universidade de São Paulo, 2007. http://www.teses.usp.br/teses/disponiveis/45/45134/tde-08052007-130443/.

Full text
Abstract:
A adoção em larga escala de redes de computadores e gerenciadores de banco de dados contribuiu para o surgimento de sistemas de informação complexos. Atualmente, estes sistemas tornaram-se elementos essenciais na vida das pessoas, dando suporte a processos de negócio e serviços corporativos indispensáveis à sociedade, como automação bancária e telefonia. A utilização de componentes na estruturação destes sistemas promove maior qualidade e flexibilidade ao produto e agiliza o processo de desenvolvimento. Entretanto, para que estes benefícios sejam totalmente observados, é fundamental que os provedores de componentes de prateleira projetem especificações precisas, completas e consistentes. Geralmente, as especificações omitem ou negligenciam o comportamento dos componentes nas situações de falha. Desta forma, a utilização de componentes não confiáveis, cujos comportamentos não podem ser inteiramente previstos, compromete seriamente o projeto de sistemas tolerantes a falhas. Uma estratégia para a especificação de componentes tolerantes a falhas é informar a ocorrência de erros através de exceções e realizar a recuperação dos mesmos por rotinas de tratamento correspondentes. A especificação deve separar claramente o comportamento normal do excepcional, destinado à recuperação do erro. Entretanto, em sistemas concorrentes e distribuídos, a especificação apenas deste tratamento local não é suficiente. Uma exceção pode ser lançada em decorrência de erros sistêmicos (i.e. problemas de rede) que afetam todo o sistema. Assim, determinadas exceções devem ser tratadas em nível arquitetural, envolvendo os demais componentes no tratamento. O modelo conceitual de ações Atômicas Coordenadas (ações CA - Coordinated Atomic actions), bastante aplicado na estruturação de sistemas tolerantes a falhas, define um mecanismo geral para a coordenação do tratamento excepcional dos componentes, que cooperam na execução das atividades e competem por recursos compartilhados. Portanto, o modelo de ações CA oferece uma solução potencialmente viável para a especificação do tratamento de exceções em nível arquitetural. Este trabalho propõe um framework para a especificação do tratamento de exceções em nível arquitetural, baseando-se no modelo de aninhamento de ações CA e utilizando a linguagem orientada a eventos CSP (Communicating Sequential Processes). Sua principal característica é prover um protocolo padronizado para a coordenação do tratamento de exceções, que envolve a cooperação dos componentes do sistema. Além disso, é apresentada uma estratégia para a verificação formal dos sistemas na ferramenta FDR (Failure Divergence Refinement), com base no modelo de refinamento por rastros.
The widespread scale adoption of computer networks and database management systems has contributed to the arising of complex information systems. Nowadays, these systems have become essential aspects in the everyday life, supporting business processes and indispensable enterprise services to society such as banking automation and telephony. The usage of components in structuring of these systems promotes higher quality and flexibility to the product and accelerates the software development process. However, in order to fully observe the benefits it is essential that the suppliers of these COTS (commercial off-the-shelf) design precise, complete and consistent specifications. Generally, the specifications omit or neglect the behavior of these components in exceptional situations. Therefore, the usage of untrustworthy components whose behavior cannot be entirely foreseen seriously compromise the design of fault-tolerant systems. One of the strategies used for the specification of fault-tolerant components is to inform the occurrence of errors through exceptions and make its recovering by the correspondent exception handling routines. The specification should separate clearly the normal behavior from the exceptional one, specially designed for error recovery. However, in concurrent and distributed systems, specification of local exception handling is not enough. An exception could be raised as a result of systemic errors (i.e. network errors) which affect the entire system, thus specific types of exceptions should be treated at an architectural level involving all the other components in this handling activity. The conceptual model of Coordinated Atomic (CA) actions, often applied in the structuring of fault-tolerant systems, defines a general mechanism for coordination of exception handling with components that cooperate while executing activities and compete for shared resources. Therefore, the model of CA actions offers a perfectly viable solution for the specification of exception handling at an architectural level. This work proposes a framework for the specification of exception handling at an architectural level, based on the nesting model of CA actions and using the event-oriented language CSP (Communicating Sequential Processes). Its main characteristic is to provide a standardized protocol for coordination of exception handling that involves the cooperation of system components. Moreover, it is presented a formal strategy for system verification using the FDR (Failure Divergence Refinement) tool, based on the traces refinement model.
APA, Harvard, Vancouver, ISO, and other styles
36

Schwerz, André Luis. "Sistemas de informação cientes de processos, robustos e confiáveis." Universidade de São Paulo, 2016. http://www.teses.usp.br/teses/disponiveis/45/45134/tde-17042018-145500/.

Full text
Abstract:
Atualmente, diversas empresas e organizações estão cada vez mais empreendendo esforços para transformar rapidamente as suas potenciais ideias em produtos e serviços. Esses esforços também têm estimulado a evolução dos sistemas de informação que passaram a ser apoiados por modelos de alto nível de abstração para descrever a lógica do processo. Neste contexto, destaca-se o sucesso dos Sistemas de Informação cientes de Processos (PAIS, do inglês Process-Aware Information Systems) para o gerenciamento de processos de negócios e automação de processos científicos de larga escala (e-Science). Grande parte do sucesso dos PAIS é devido à capacidade de prover funcionalidades genéricas para modelagem, execução e monitoramento dos processos. Essas características são bem-sucedidas quando os modelos de processos têm um caminho bem-comportado no sentido de atingir os seus objetivos. No entanto, situações anômalas que desviam a execução desse caminho bem-comportado ainda representam um significativo desafio para os PAIS. Por causa dos vários tipos de falhas que desviam a execução do comportamento esperado, prover uma execução robusta e confiável é uma tarefa complexa para os atuais PAIS, uma vez que nem todas as situações de falha podem ser eficientemente descritas dentro da estrutura do fluxo tradicional. Como consequência, o tratamento de tais situações geralmente envolve intervenções manuais nos sistemas por operadores humanos, o que resulta em custos adicionais e significativos para as empresas. Neste trabalho é introduzido um método de composição para recuperação ciente de custos e benefícios que é capaz de encontrar e seguir caminhos alternativos que reduzam os prejuízos financeiros do tratamento de exceções. Do ponto de vista prático, esse método provê o tratamento de exceção automatizado e otimizado ao calcular os custos e benefícios de cada caminho de recuperação e escolher o caminho com a melhor relação custo-benefício disponível. Mais especificamente, o método de recuperação proposto estende a abordagem WED-flow (Workflow, Event processing and Data-flow) para permitir a composição ciente de custos e benefícios de passos de recuperação transacionais backward e forward. Por fim, os experimentos mostram que esse método de recuperação pode ser adequadamente incorporado para manipular exceções em uma ampla variedade de processos.
Nowadays, many corporations and organizations are increasingly making efforts to transform quickly and effectively their potential ideas into products and services. These efforts have also stimulated the evolution of information systems that are now supported by higher-level abstract models to describe the process logic. In this context, several sophisticated Process-Aware Information Systems (PAIS) have successfully been proposed for managing business processes and automating large-scale scientific (e-Science) processes. Much of this success is due to their ability to provide generic functionality for modeling, execution and monitoring processes. These functionalities work well when process models have a well-behaved path towards achieving their objectives. However, anomalous situations that fall outside of the well-behaved execution path still pose a significant challenge to PAIS. Because of the many types of failures that may deviate execution away from expected behaviors, provision of robust and reliable execution is a complex task for current PAIS, since not all failure situations can be efficiently modeled within the traditional flow structure. As a consequence, the treatment for such situations usually involves interventions in systems by human operators, which result in significant additional cost for businesses. In this work, we introduce a cost/benefit-aware recovery composition method that is able to find and follow alternative paths to reduce the financial side effects of exception handling. From a practical point of view, this method provides the automated and optimized exception handling, by calculating the cost and benefits of each recovery path, and choosing the recovery path with the best cost/benefits available. More specifically, our recovery method extends the WED-flow (Workflow, Event processing and Data-flow) approach for enabling cost/benefit-aware composition of forward and/or backward transactional recovery steps. Finally, the experiments point out that this recovery method can be suitably incorporated into exception handling within a wide variety of processes.
APA, Harvard, Vancouver, ISO, and other styles
37

Filho, Carlos Alberto Batista de Queiroz. "Um mecanismo de tratamento de excessÃes sensÃvel ao contexo para sistemas ubÃquos orientados a tarefas." Universidade Federal do CearÃ, 2012. http://www.teses.ufc.br/tde_busca/arquivo.php?codArquivo=9626.

Full text
Abstract:
CoordenaÃÃo de AperfeiÃoamento de Pessoal de NÃvel Superior
O principal propÃsito da ComputaÃÃo UbÃqua à o fornecimento de informaÃÃes e funcionalidades necessÃrias para ajudar as pessoas em suas tarefas cotidianas, de maneira proativa e transparente, a qualquer instante e em qualquer lugar. O desenvolvimento de sistemas ubÃquos envolve um conjunto de requisitos desafiadores, dentre eles: sensibilidade ao contexto, que permite que os sistemas adaptem o seu comportamento para responder de forma apropriada diante de mudanÃas do ambiente; e dependabilidade, que està relacionado à capacidade dos sistemas de prestarem um serviÃo os quais ofereÃam fortes indÃcios de que sÃo confiÃveis. Em relaÃÃo aos atributos de dependabilidade, negligenciÃ-los pode trazer desde pequenas insatisfaÃÃes atà graves riscos à integridade fÃsica dos usuÃrios. O tratamento de exceÃÃes à uma das principais tÃcnicas de tolerÃncia a faltas empregadas no desenvolvimento de software para atingir maiores nÃveis de dependabilidade. Essa tÃcnica, apesar de jà ser amplamente utilizada no desenvolvimento de software tradicional, ainda à pouco empregada no desenvolvimento de sistemas ubÃquos. Isso ocorre em virtude das caracterÃsticas e requisitos desafiadores desse tipo de sistema, dentre os quais se destacam a sensibilidade ao contexto e a distribuiÃÃo, a qual pode fazer com que as possibilidades necessÃrias de tratamento de exceÃÃes de um sistema como um todo seja maior do que a soma das possibilidades de tratamento de exceÃÃes das partes que o compÃe. Portanto, essa dissertaÃÃo tem como objetivo propor um mecanismo de tratamento de exceÃÃes sensÃvel ao contexto para sistemas ubÃquos orientados a tarefas. O mecanismo proposto à disponibilizado atravÃs de um framework, denominado FRonTES, que permite a reutilizaÃÃo do mecanismo. AtravÃs da utilizaÃÃo desse framework, funcionalidades do sistema podem ser implementadas sob uma abstraÃÃo de tarefa, que responde de maneira adequada a mudanÃas de contexto, detectando e tratando situaÃÃes excepcionais. Para a validaÃÃo do mecanismo proposto foi implementado um protÃtipo de sistema de controle de estacionamento ubÃquo como uma prova de conceito, que foca na demonstraÃÃo de como sÃo implementadas as tarefas que compÃem esse sistema e como sÃo definidas as exceÃÃes contextuais e seus tratadores.
The main purpose of ubiquitous computing is to provide information and features needed to help people in their daily tasks, proactively and transparently, at any time and anywhere. The development of ubiquitous systems involves a set of challenging requirements, including: context awareness, which allows systems to adapt their behavior to respond appropriately in the face of environmental changes, and dependability, which is related to the ability of systems provide a service which offer strong indications that are reliable. Regarding the attributes of dependability, neglecting them can bring grievances from small to severe risks to the physical integrity of the users. Exception handling is a major fault tolerance techniques used in software development to achieve greater levels of dependability. This technique, even though it is widely used in traditional software development, it is still not widely used in the development of ubiquitous systems. This is due to challenging requirements and characteristics of this type of system, among which we highlight the sensitivity to the context and distribution, which can make the necessary possibilities of handling exceptions in a system as a whole is greater than the sum of possibilities for exception handling of the parts that compose it. Therefore, this dissertation aims to propose a mechanism for exception handling context-sensitive ubiquitous systems for task-oriented. The proposed mechanism is available through a framework called foreheads, which allows the reuse mechanism. By using this framework, system functionality can be implemented on an abstraction task, which responds appropriately to changes in context, detecting and treating exceptional situations. To validate the proposed mechanism was implemented a prototype system of parking control ubiquitous as a proof of concept, which focuses on demonstration of how the tasks are implemented that make up this system and how they are defined exceptions contextual and their handlers.
APA, Harvard, Vancouver, ISO, and other styles
38

Braz, Alan 1980. "Método Ágil aplicado ao desenvolvimento de software confiável baseado em componentes." [s.n.], 2013. http://repositorio.unicamp.br/jspui/handle/REPOSIP/275637.

Full text
Abstract:
Orientador: Cecília Mary Fischer Rubira
Dissertação (mestrado) - Universidade Estadual de Campinas, Instituto de Computação
Made available in DSpace on 2018-08-23T09:09:24Z (GMT). No. of bitstreams: 1 Braz_Alan_M.pdf: 1903353 bytes, checksum: 9bff9aefdcc11d6d8fe46490302d6291 (MD5) Previous issue date: 2013
Resumo: Os Métodos Ágeis, ou Desenvolvimento Ágil de Software (DAS), tem se popularizado, na última década, por meio de métodos como Extreme Programming (XP) e Scrum e isso fez com que fossem aplicadas no desenvolvimento de sistemas computacionais de diversos tamanhos, complexidades técnica e de domínio, e de rigor quanto à confiabilidade. Esse fato evidencia a necessidade de processos de desenvolvimento de software que sejam mais rigorosos e que possuam uma quantidade adequada de modelagem e documentação, em especial no que concerne ao projeto arquitetural, com o objetivo de garantir maior qualidade no seu resultado final. A confiabilidade pode ser alcançada adicionando elementos de tratamento de exceções às fases iniciais do processo de desenvolvimento e à reutilização de componentes. O tratamento de exceções tem sido uma técnica muito utilizada na verificação e na depuração de erros em sistemas de software. O MDCE+ é um método que auxilia a modelagem do comportamento excepcional de sistemas baseados em componentes que, por ser centrado na arquitetura, melhora a definição e a análise do fluxo de exceções entre os componentes do sistema. Este trabalho propõe uma solução para guiar o desenvolvimento de sistemas confiáveis baseados em componentes por meio da adição de práticas do MDCE+ ao Scrum, resultando no método Scrum+CE (Scrum com Comportamento Excepcional). Esse processo passa a expor os requisitos excepcionais em nível das Estórias de Usuário, adiciona testes de aceitação mais detalhados, obriga a criação do artefato de Arquitetura Inicial e adiciona um novo papel de Dono da Arquitetura. Como forma de avaliar esse método proposto, foi realizado um experimento controlado com três equipes, que desenvolveram um sistema com requisitos de confiabilidade, utilizando Scrum e Scrum+CE. Foram coletadas métricas para comparar a eficiência do novo processo e o resultado obtido, com a utilização do Scrum+CE, foi à produção de software com melhor qualidade, porém com menor número de funcionalidades
Abstract: Agile Software Development (ASD) has been on mainstream through methodologies such as Extreme Programming (XP) and Scrum in the last decade enabling them to be applied in the development of computer systems of various size, technical and domain complexity and degress of reliability. This fact highlights the need for software development processes that are accurate and have an adequate amount of modeling and documentation, especially regarding the architectural design, aiming to increase the quality of the end result. The reliability can be achieved by adding elements of exception handling at early stages of development and through components reuse. Exception handling has been a widely used technique in detecting and fixing errors in software systems. The MDCE+ is a method that assists exceptional behavior modeling at components based systems, which is architecture-centric what improves the definition and flow analysis of exceptions between system components. This paper proposes a solution to guide the development of reliable systems based on components by adding MDCE+ practices to Scrum, resulting in the Scrum+CE method (Scrum with Exceptional Behavior). This process exposes the exceptional requirements, at the User Stories level, documents acceptance tests with more details, requires the creation of a high-level architecture artifact and adds a new role of Architecture Owner. In order to evaluate this proposed method, a controlled experiment was conducted with three teams, who developed a system with reliability requirements using Scrum and Scrum+CE. We collected metrics to compare the efficiency of the new process and the result was the production of software with better quality but with less features using Scrum+CE
Mestrado
Ciência da Computação
Mestre em Ciência da Computação
APA, Harvard, Vancouver, ISO, and other styles
39

Brito, Patrick Henrique da Silva. "Uma abordagem arquitetural para o desenvolvimento rigoroso de sistemas confiáveis baseados em componentes." [s.n.], 2009. http://repositorio.unicamp.br/jspui/handle/REPOSIP/275799.

Full text
Abstract:
Orientador: Cecília Mary Fischer Rubira
Tese (doutorado) - Universidade Estadual de Campinas, Instituto de Computação
Made available in DSpace on 2018-08-16T14:38:24Z (GMT). No. of bitstreams: 1 Brito_PatrickHenriquedaSilva_D.pdf: 1885619 bytes, checksum: 138c286c6050613085421c02716b1425 (MD5) Previous issue date: 2009
Resumo: A incorporação de tolerância a falhas em sistemas de software normalmente acarreta em um aumento da complexidade, o que consequentemente torna a sua análise mais difícil. Além disso, o uso de mecanismos de tratamento de exceções de uma maneira não-sistemática pode acarretar na adição de novas falhas ao sistema. Esta tese apresenta uma abordagem rigorosa e centrada na arquitetura para o desenvolvimento de sistemas de software tolerantes a falhas. Dependendo do modelo de falhas e da disponibilidade de recursos, abstrações arquiteturais diferentes podem ser utilizadas para representar explicitamente questões relacionadas a tolerância a falhas, tais como detecção e tratamento de erros e tratamento de falhas. Essas abstrações arquiteturais e os seus respectivos detalhamentos internos podem ser instanciados em componentes e conectores concretos durante o projeto de arquiteturas de software tolerantes a falhas. De forma complementar, a solução proposta também define atividades que combinam o uso e métodos formais e casos de teste baseados em modelos para sistematizar a verificação e validação do comportamento do sistema relativo à programação e tratamento de erros e tratamento de falhas no nível arquitetural. A verificação e validação de software ocorrem em duas fases complementares do processo de desenvolvimento do software, ambas baseadas em cenários arquiteturais que descrevem a programação e tratamento de erros envolvendo elementos arquiteturais (componentes e conectores). Primeiramente, utilizando a ferramenta de verificação de modelos ProB, que combina o uso de teoria de conjuntos matemáticos (B-Method) com álgebra de processos (CSP), a arquitetura de software é verificada formalmente com o intuito de antecipar a identificação de falhas relacionadas ao projeto do sistema. Segundo, casos de teste são gerados a partir da arquitetura de software utilizando uma abordagem baseada em modelos. O objetivo dos casos de teste gerados é verificar a consistência entre os modelos arquiteturais já verificados formalmente e a implementação do sistema. Finalmente, para auxiliar as atividades de verificação, a solução proposta também contempla a definição de regras de transformação automática de diagramas UML para especificação formal em B-Method e CSP. A diferença semântica existe entre a especificação semi-formal da UML e a especificação formal em B-Method e CSP é compensada utilizando-se estereótipos e "tags" nos modelos UML. A aplicabilidade prática da solução proposta foi avaliada no contexto de três estudos de caso: (i) uma aplicação com requisitos críticos de tempo real e confiabilidade; (ii) uma aplicação bancária real com requisitos críticos de confiabilidade e disponibilidades; e (iii) uma aplicação para dispositivos móveis
Abstract: The incorporation of fault tolerance into systems normally increases their complexity, which consequently makes their analysis more difficult. Moreover, the use of exception handling mechanisms to develop robust software systems in a non-systematic manner can be a source of many design faults. This thesis presents a rigorous and architecture-centric development approach for developing fault-tolerant software systems. Depending on the fault model and the resources available, different architectural abstractions can be employed for representing issues that are related to fault tolerance, such as error detection, and error and fault handling. These architectural abstractions and their internal views can be instantiated into concrete components and connectors for designing fault-tolerant software architectures. In a complementary way, the proposed rigorous solution also defines activities which use formal methods and model-based test cases do systematize the verification and validation of the system's behaviour related to error propagation and handling at the architecture level. The verification and validation occur in two complementary phases of the software development, both of them based on architectural scenarios describing error propagation and handling involving architectural elements (components and connectors). First, using the ProB model checker, which combines the use of set-theory (B-Method) and process algebra (CSP), the software architecture is formally verified in order to anticipate the identification of faults related to the system's model. Second, model-based test cases are generated in order to assess the consistency between the verified software architecture and the implementation of the software system. Finally, the proposed solution also defines rules for model transformation from UML diagrams to formal specification in B-Method and CSP. To overcome the gap between the semi-formal specification of UML and the formal models, the UML diagrams are complemented with predefined stereotypes and tags. The feasibility of our approach was evaluated in the context of three case studies: (i) a critical real-time application; (ii) a real banking system; and (iii) a mobile application
Doutorado
Engenharia de Software
Doutor em Ciência da Computação
APA, Harvard, Vancouver, ISO, and other styles
40

Iizuka, Bruno de Abreu 1985. "Variabilidade em tratamento de exceções em linha de produtos de software." [s.n.], 2012. http://repositorio.unicamp.br/jspui/handle/REPOSIP/275670.

Full text
Abstract:
Orientador: Cecília Mary Fischer Rubira
Dissertação (mestrado) - Universidade Estadual de Campinas, Instituto de Computação
Made available in DSpace on 2018-08-22T01:16:52Z (GMT). No. of bitstreams: 1 Iizuka_BrunodeAbreu_M.pdf: 5618330 bytes, checksum: 684e091ec25c7c909bfbdfeae38b8487 (MD5) Previous issue date: 2012
Resumo: Atualmente, muitos esforços vêm sendo feitos para se obter um maior grau de reutilização durante o desenvolvimento de sistemas. Linha de Produtos de Software (LPS) é uma abordagem que promove a reutilização de software. A Arquitetura de Linha de Produtos (ALP) provê uma perspectiva global das variabilidades da linha, ao passo que engloba os conceitos tradicionais de uma arquitetura de software. Devido às variabilidades de software de uma ALP, a evolução arquitetural é ainda mais complexa, do que quando comparado com evolução de arquiteturas de software convencionais. Tratamento de exceções é uma técnica bastante conhecida para a detecção e tratamento de erros em sistemas de software. Porém, apesar da sua popularidade, o seu projeto e a sua implementação são constituídos de tarefas muito complexas que não recebem uma atenção adequada dos processos de desenvolvimento existentes. Separação de interesses é um dos objetivos do tratamento de exceções para separar o comportamento normal e excepcional do sistema de software. No contexto de uma LPS, a separação de interesses é importante para o design das variabilidades de software relacionadas às estratégias do comportamento normal e do comportamento excepcional, como a escolha de diferentes tratadores de exceções por diferentes características. O objetivo principal deste trabalho é apresentar um método para especificar e implementar a variabilidade de tratamentos de exceções em LPS baseadas em componentes. O método MVTE (Método de Variabilidade de Tratamento de Exceções) é uma combinação de métodos já conhecidos na literatura (PLUS e UML Components) e os modelos COSMOS* e COSMOS*-VP. Para validar o método MVTE foram utilizados dois estudos empíricos, e para medir a sua qualidade foram utilizadas as métricas de impacto de mudanças, acoplamento entre módulos e difusão de interesses
Abstract: Nowadays, many efforts are being made to achieve a higher degree of reuse during the development of systems. Software Product Lines (SPL) is an approach to improve software reuse. A PLA provides a global view of the variability's of a SPL, while it embodies the concepts and advantages of the traditional software architecture. Due to its variability's, a PLA is harder to evolve than a conventional software architecture. Exception handling is a well known technique to detect and treat errors in software systems. However, despite its popularity, its design and implementation are constituted of very complex tasks that do not receive the adequate attention from the existing development processes. Separation of concerns is one of the overarching goals of exception handling in order to keep separate normal and exceptional behavior of a software system. In the context of a software product line (SPL); this separation of concerns is also important for designing software variability's related to normal and exceptional behavior, such as the choice of different handlers depending on the set of selected features. The main goal of this work is to present a method to specify and implement the variability of exception handling in SPL components-based. The method MVTE (Variability of Exception Handler Method) is a combination of methods known in the literature (PLUS and UML Components) and models COSMOS* and COSMOS*-VP. To validate the method MVTE, it was studied two empirical studies, and to measure their quality it was used the metrics impact change, coupling between modules and diffusion over concerns
Mestrado
Ciência da Computação
Mestre em Ciência da Computação
APA, Harvard, Vancouver, ISO, and other styles
41

Carvalho, Luciano Augusto Fernandes. "Teste estrutural de tratamento de exceções em programas OA: representação, critérios e avaliação." Universidade de São Paulo, 2013. http://www.teses.usp.br/teses/disponiveis/55/55134/tde-23082013-153713/.

Full text
Abstract:
O mecanismo de tratamento de exceções disponível em linguagens orientadas a objetos está sendo cada vez mais utilizado e representa cerca de 8% das linhas de código em programas escritos com linguagens de terceira geração, de acordo com algumas pesquisas. No entanto, este mecanismo está entre os menos compreendido pelos desenvolvedores e menos testado. A dificuldade de testar exceções aumenta na fase de teste de integração, porque exceções lançadas em um determinado nível e não tratadas podem subir na hierarquia de chamada. O uso de aspectos também pode introduzir novos tipos de defeitos, como por exemplo um adendo pode inserir lançamentos de exceções no programa sem que exista algum tratamento previsto para elas. Este trabalho apresenta uma proposta para testes de integração estrutural de fluxos de exceções de programas Java e AspectJ. Isto é feito propondo-se alterações na representação do fluxo de exceção no grafo de fluxo de controle integrado e propondo-se novos critérios baseados no fluxo de exceção. Além disso, essas propostas foram implementadas e geraram uma extensão da ferramenta chamada Ja-BUTi/AJ. Para avaliar a proposta deste trabalho, um estudo de caso e um experimento formal foram conduzidos. O estudo de caso teve como objetivo validar a extensão da JaBUTi/AJ desenvolvida e fazer uma avaliação inicial do custo de aplicação dos critérios propostos. O experimento formal realizou uma comparação entre as ferramentas JaBUTi/AJ e VITTAE no contexto do teste do fluxo de exceções. Ambos os estudos são apresentados e discutidos nesta dissertação
Exception handling mechanisms available in object-oriented languages have become increasingly used and account for about 8% of the lines of code in modern programs according to some empirical researches. Yet, this mechanism is among the least understood by programmers and the less tested. The difficulty of testing exceptions increases in the phase of integration testing (e.g. inter-class testing) because exceptions raised on a certain level and not handled can flow through the call hierarchy. Using aspects also cause other types of errors, e.g. an advice can insert exceptions not foreseen by the base program. This paper presents a proposal for structural integration testing of exception flows of Java and AspectJ programs. This is done by proposing changes to the classic control ow graph and by proposing new criteria based on the exception ow. Moreover, these proposals have been implemented in a tool named JaBUTi/AJ. To evaluate the proposal of this work, a case study and a formal experiment have been conducted. The case study had the objective of validating the JaBUTi/AJ extension developed and making a preliminary assessment of the cost to use the tool. The formal experiment made a comparison between the tools JaBUTi/AJ and VITTAE in the context of exception flow test. Both studies are presented and discussed in this dissertation
APA, Harvard, Vancouver, ISO, and other styles
42

Aryananda, Lijin 1975. "An exceptional handling service for the contract net protocol family." Thesis, Massachusetts Institute of Technology, 1999. http://hdl.handle.net/1721.1/9437.

Full text
Abstract:
Thesis (M.Eng.)--Massachusetts Institute of Technology, Dept. of Electrical Engineering and Computer Science, 1999.
Includes bibliographical references (leaves 61-63).
Autonomous agents are systems that inhabit complex and dynamic environments. Attaining robust behavior in such complex conditions is a key challenge for agent-based systems. This challenge is intensified in multi-agent settings, where a diverse set of agents communicate and coordinate with each other, resulting in non-deterministic system behaviors. The standard approach to this problem relies on the notion that each agent should be equipped as much as possible in order to survive on their own in its environment, leading to several serious limitations. Dellarocas and Klein (1999) propose an alternative approach, using a generic exception handling service for providing adaptability by detecting and handling domain independent exceptions. This thesis presents an evaluation and prototype implementation of this approach using a contract net setting. The feasibility of the approach is assessed, involving identification of contract net related domain independent exceptions and their handling strategies as well as an investigation of the minimum base level interfaces required from each agent. Experimental results showing a scenario in which agents relies on the exception handling service for dealing with agent death exception are demonstrated. Lastly, a thorough analysis and comparative study of the shared service approach versus other related works are presented.
by Lijin Aryananda.
M.Eng.
APA, Harvard, Vancouver, ISO, and other styles
43

Melo, Hugo Faria. "Caracterizando os fluxos excepcionais em linhas de produto de software: um estudo explorat?rio." Universidade Federal do Rio Grande do Norte, 2012. http://repositorio.ufrn.br:8080/jspui/handle/123456789/18058.

Full text
Abstract:
Made available in DSpace on 2014-12-17T15:48:02Z (GMT). No. of bitstreams: 1 HugoFM_DISSERT.pdf: 1847783 bytes, checksum: 58d9312a629dabdd3fe4b15c8dc44101 (MD5) Previous issue date: 2012-07-26
The Exception Handling (EH) is a widely used mechanism for building robust systems. In Software Product Line (SPL) context it is not different. As EH mechanisms are embedded in most of mainstream programming languages (like Java, C# and C++), we can find exception signalers and handlers spread over code assets associated to common and variable SPL features. When exception signalers and handlers are added to an SPL in an unplanned way, one of the possible consequences is the generation of faulty family instances (i.e., instances on which common or variable features signal exceptions that are mistakenly caught inside the system). In this context, some questions arise: How exceptions flow between the optional and alternative features an LPS? Aiming at providing answers to these questions, this master thesis conducted an exploratory study, based on code inspection and static analysis code, whose goal was to categorize the main ways which exceptions flow in LPSs. To support the study, we developed an static analysis tool called PLEA (Product Line Exception Analyzer) that calculates the exceptional flows of LPSs, and categorize these flows according to the features associated with handlers and signalers. Preliminary results showed that some types of exceptional flows have more potential to yield failures in exceptional behavior of SLPs
O mecanismo de tratamento de exce??es ? amplamente utilizado para a constru??o de sistemas robustos. No contexto de Linhas de Produto de Software (LPSs) n?o ? diferente. Uma vez que mecanismos de tratamento de exce??es est?o embutidos nas principais linguagens de programa??o da atualidade (como Java, C# e C++), podemos encontrar sinalizadores e tratadores de exce??es espalhados entre os artefatos de c?digo associados a caracter?sticas (do ingl?s: features) opcionais e obrigat?rias de uma LPS. Quando tratadores ou sinalizadores de exce??es s?o adicionados a uma LPS de forma n?o planejada, uma das poss?veis conseq??ncias ? a gera??o de produtos falhos (i.e., produtos em que exce??es lan?adas por features vari?veis ou obrigat?rias s?o erroneamente tratadas). Neste contexto, surge a pergunta: Quais as consequ?ncias de se usar o mecanismo de tratamento de exce??es em LPSs? Com o objetivo de responder a esta pergunta, este trabalho conduz um estudo explorat?rio, baseado em inspe??o de c?digo e an?lise est?tica de c?digo, cujo objetivo foi caracterizar as principais formas em que exce??es fluem em LPSs. Para apoiar a realiza??o deste estudo desenvolvemos a PLEA (Product Line Exception Analyzer), uma ferramenta baseada em analise est?tica de c?digo que calcula os fluxos excepcionais de uma LPS e os classifica de acordo com as features associadas aos seus tratadores e sinalizadores. Resultados preliminares mostraram que alguns tipos de fluxos excepcionais tem mais potencial para originarem falhas no comportamento excepcional das LPSs
APA, Harvard, Vancouver, ISO, and other styles
44

Olofsson, Gustav. "Onboard computer fault-tolerance detection and mitigation." Thesis, Luleå tekniska universitet, Institutionen för system- och rymdteknik, 2020. http://urn.kb.se/resolve?urn=urn:nbn:se:ltu:diva-81407.

Full text
Abstract:
The aim for this thesis is to design a software library responsible for preventing, detecting, handling and logging faults caused by radiation in a representable flight computer system based on the Cobham Gaisler GR740 quad-core LEON4FT processor chip. The LEON processor family is commonly used in space applications and it is based on the open SPARC instruction set and has been extended with fault tolerant features to cope with both on-chip radiation effects as well as upsets in external memory. The new GR740 device introduces a new computer architecture with multiple buses as compared to previous chips, Level-2 cache and a memory scrubber accelerating fault mitigation in external SDRAM memories. As the processor system design keeps getting more complex it also requires software to handle more hardware and new events, including central handling and logging routines of faults. The report describes the analysis performed to identify sources of faults and proposed suitable mitigation techniques, the established software requirements and how they are translated into a software architecture, then implemented and finally demonstrated on hardware. Along with this, it is shown how the developed demonstrator application software library can be integrated into the RTEMS real-time operating system commonly used in European space missions. The results are based on the demonstrator execution, and the results show that the software is functionally working and validates that the performance of the scrubber matches the derived scrubbing timings. After the project is completed, the software library design will be evaluated for use in Cobham Gaisler’s payload computer platform for the GOMX-5 mission. Radiation upsets will be emulated by injecting faults while running the developed API on demonstrator applications. Furthermore, implementation of software into NASA cFS/cFE will be analysed.
APA, Harvard, Vancouver, ISO, and other styles
45

Schröder, Ralf. "SDL-Datenkonzepte." Doctoral thesis, Humboldt-Universität zu Berlin, Mathematisch-Naturwissenschaftliche Fakultät II, 2003. http://dx.doi.org/10.18452/14926.

Full text
Abstract:
SDL in der 1996 standardisierten Sprachversion ist zur Zeit die im Telekommunikationsbereich am weitesten verbreitete Sprache zur Spezifikation von Protokollen. Ein wesentlicher Aspekt der Sprachentwicklung seit 1988 ist auch die Verfügbarkeit einer formalen Basis semantischer Konzepte. Für das Datenkonzept der Sprache wurde auf die algebraischen Technik ACT ONE zurückgegriffen. Obwohl Anspruch als auch praktischer Wert von SDL in der Ausführbarkeit als Spezifikationstechnik liegt, wird dieses gerade durch das verwendete Datenmodell beeinträchtigt. Verdeckt wird dieses Problem durch die Bereitstellung von vordefinierten Datentypen. Durch die Erweiterung von SDL um objektorientierte Konzepte im Jahr 1992 und durch die allgemein wachsende Bedeutung der Daten in Protokollbeschreibungen treten die vorhandenen Sprachprobleme bei den Daten immer mehr in der Vordergrund. Individuelle Lösungen zur Spezifikation von Daten in verfügbaren SDL-Werkzeugen sind die Folge. In der vorliegenden Arbeit werden sowohl die praxismotivierten Unzulänglichkeiten als auch die formalen Unstimmigkeiten im SDL-Datenkonzept aufgezeigt. Auf der Grundlage einer systematischen Analyse werden ein allgemeiner Anforderungskatalog und eine Methodik für Veränderungen am Datenkonzept erarbeitet. Zusätzlich werden wichtige Sprachmodifikationen mit dem Schwerpunkten Ausdruckskraft und Ausführbarkeit vorgestellt und bewertet. Es steht somit ein Instrumentarium zur Verfügung, das den unterschiedlichen SDL-Interessengruppen bei der Bewertung und Nutzung von SDL-Veränderungen dienlich ist. Die in der Arbeit vorgestellten Modifikationen des Datenkonzepts basieren auf den langjährigen Erfahrungen des Autors bei der Implementierung und dem Einsatz von Werkzeugen, die mit verschiedenen projektspezifischen Zielstellungen SDL-Beschreibungen in ausführbare Programme überführen. Die Kombination von SDL mit einer weiteren Spezifikationstechnik, ASN.1, spielt hier eine besondere Rolle. Durch die aktive Mitarbeit des Autors bei der SDL-Sprachstandardisierung werden in der Arbeit auch Vorschläge präsentiert, die über das Potential der vorhandenen Werkzeuge hinausgehen. Das schließt beispielsweise die Bewertung der neuen, in der Praxis noch nicht etablierten, SDL-Version aus dem Jahr 2000 mit ein.
SDL in the language version which was standardized in 1996 is the most-used language in the telecommunication domain for the specification of protocols today. An essential aspect of the language development since 1998 is the availability of a formal basis for semantic concepts. The algebraic technique ACT ONE is used for the data concept of the language. Although the requirement and the practical value of SDL is the execution a specification technique, this is impaired straight by the used data model. The problem is hidden by the supply of pre-defined data types. Because of the introduction of object oriented concepts in 1992 and because of the generally increasing importance of data for the protocol description the existing language problems are taking more and more attention. Individual solutions for the specification of data are the consequence with available SDL tools. In the presented document are pointed out the praxis motivated inadequacies as well as the formal discrepancy of the data concept. A general requirement catalogue and a methodology are designed for language modifications based on a systematic inspection of the SDL data concept. Furthermore important language modifications are introduced and evaluated with the focus to expression power and to execution. Instruments are provided thus, which are helpful to different SDL interest groups for the evaluation and for the application of SDL modifications. In the document presented data modifications are based on years of experience of the author in the implementation and application of tools that compile SDL specifications with different project-specific objectives into executable programs. The combination of SDL with a further specification technology, ASN.1, plays an important role here. Because of the active role of the author in the SDL standardization process also suggestions are presented going beyond the potential of the existing tools. That includes for example the evaluation of the new, in practice not yet established SDL version, published in 2000.
APA, Harvard, Vancouver, ISO, and other styles
46

Cheng, Hsiung-Mao, and 鄭勳懋. "Exception Patterns for Exception Handling." Thesis, 2006. http://ndltd.ncl.edu.tw/handle/15324049072756016528.

Full text
Abstract:
碩士
東海大學
資訊工程與科學系
94
In this paper, a software framework is proposed to help implementing robust Java applications. Based on the framework, the concept of exception patterns is introduced. With exception patterns, exception handling logic and application logic are decoupled and they can be implemented separately. Handling for new exception patterns can also be dynamically deployed without any further modification. By defining a strategical and global view of the exception patterns for an application in advance, application programmers redirect all the exceptions to the framework without knowing how to deal with them. It helps reduce the risk of delaying the exception handling design to the programming stage and therefore the effort of implementing a robust Java application is largely reduced while the capability of maintenance and reusability of the exception patterns are dramatically increased.
APA, Harvard, Vancouver, ISO, and other styles
47

Huang, Chih-Chao, and 黃致超. "Obfuscation Using Exception Handling." Thesis, 2010. http://ndltd.ncl.edu.tw/handle/63883675873468173792.

Full text
Abstract:
碩士
國立交通大學
資訊科學與工程研究所
99
There exist several reverse engineering tools that can easily recover source code from a lower level immediate representation. To protect intellectual property, obfuscation is one of the easiest and efficient way to achieve this goal. A good obfuscation tool can not only makes the obfuscated code much harder to understand but also ensures the correctness. Previous obfuscating approaches mostly use program transformation that base on opaque predicate to obfuscate control flow transfer. However, although these methods can provide a good resilient, they usually decrease performance a lot if applied on the whole program. In this paper, we use runtime exception to hide the real code. During obfuscation, the original program is obfuscated by changing each loop into a specific runtime exception and inserting bogus code after the runtime exception. The obfuscated code's correctness is maintained but the code is now unable to be decompiled. Experiment results show that our obfuscation technique increase less overhead and code size on SPECJVM2008.
APA, Harvard, Vancouver, ISO, and other styles
48

Zastre, Michael. "The case for exception handling." 2004. http://hdl.handle.net/1828/369.

Full text
APA, Harvard, Vancouver, ISO, and other styles
49

Krischer, Roy. "Advanced Concepts in Asynchronous Exception Handling." Thesis, 2010. http://hdl.handle.net/10012/5751.

Full text
Abstract:
Asynchronous exception handling is a useful and sometimes necessary alternative form of communication among threads. This thesis examines and classifies general concepts related to asynchrony, asynchronous propagation control, and how asynchronous exception handling affects control flow. The work covers four advanced topics affecting asynchronous exception-handling in a multi-threaded environment. The first topic is concerned with the non-determinism that asynchronous exceptions introduce into a program's control-flow because exceptions can be propagated at virtually any point during execution. The concept of asynchronous propagation control, which restricts the set of exceptions that can be propagated, is examined in depth. Combining it with a restriction of asynchrony that permits propagation of asynchronous exceptions only at certain well-defined (poll) points can re-establish sufficient determinism to verify a program's correctness, but introduces overhead, as well as a delay between the delivery of an asynchronous exception and its propagation. It also disturbs a programmer's intuition about asynchronous propagation in the program, and requires the use of programming idioms to avoid errors. The second topic demonstrates how a combined model of full and restricted asynchrony can be safely employed, and thus, allow for a more intuitive use of asynchronous propagation control, as well as potentially improve performance. The third topic focuses on the delay of propagation that is introduced when a thread is blocked, i.e., on concurrency constructs that provide mutual exclusion or synchronization. An approach is presented to transparently unblock threads so propagation of asynchronous termination and resumption exceptions can begin immediately. The approach does not require additional syntax, simplifies certain programming situations, and can improve performance. The fourth topic explores usability issues affecting the understanding of (asynchronous) exception handling as a language feature. To overcome these issues, tools and language features are presented that help in understanding exception handling code by providing additional run-time information, as well as assist in testing. For all topics, the necessary extensions to the syntax/semantics of the language are discussed; where applicable, a prototypical implementation is presented, with examples that demonstrate the benefits of the new approaches.
APA, Harvard, Vancouver, ISO, and other styles
50

"Data-oriented specification of exception handling." Chinese University of Hong Kong, 1990. http://library.cuhk.edu.hk/record=b5886601.

Full text
Abstract:
by Cheng Kar Wai.
Thesis (M.Phil.)--Chinese University of Hong Kong, 1990.
Bibliography: leaves [195-199]
ABSTRACT
Chapter CHAPTER 1 --- INTRODUCTION --- p.1
Chapter 1.1 --- Problem --- p.2
Chapter 1 .2 --- Approach --- p.3
Chapter 1.2.1 --- Programming Approach --- p.4
Chapter 1.2.2 --- Specification Approach --- p.5
Chapter 1.3 --- Thesis Organization --- p.11
Chapter CHAPTER 2 --- MODEL SPECIFICATION APPROACH --- p.12
Chapter 2 .1 --- Overview --- p.14
Chapter 2.2 --- Compilation Phases --- p.17
Chapter 2.3 --- Array Graph --- p.22
Chapter 2.4 --- Scheduling --- p.25
Chapter CHAPTER 3 --- SURVEY --- p.31
Chapter 3.1 --- Goodenough's Proposal --- p.31
Chapter 3.2 --- Exception Handling Models --- p.34
Chapter 3.3 --- Programming Languages --- p.40
Chapter 3.4 --- Data-Oriented Exception Handling --- p.49
Chapter 3.5 --- Specification Languages --- p.50
Chapter CHAPTER 4 --- EXCEPTION HANDLING SPECIFICATION --- p.55
Chapter 4.1 --- Data-Oriented Exceptions Specification --- p.55
Chapter 4.2 --- Assertions for Exception Handling --- p.59
Chapter 4.2.1 --- User-defined Exception Condition Assertion --- p.61
Chapter 4.2.2 --- Fatal Condition Assertion --- p.62
Chapter 4.2.3 --- Replacement Assertion --- p.64
Chapter 4.2.3.1 --- Scenario 1: Immediate Replacement --- p.68
Chapter 4.2.3.2 --- Scenario 2: Direct Dependency --- p.71
Chapter 4.2.3.3 --- Scenario 3: Indirect Dependency --- p.72
Chapter 4.2.3.4 --- Scenario 4: Lower Dimensionality --- p.74
Chapter 4.2.4 --- Message Vector Assertion --- p.76
Chapter CHAPTER 5 --- ARRAY GRAPH FOR EXCEPTION HANDLING --- p.78
Chapter 5.1 --- Subgraph Embedding --- p.78
Chapter 5.1.1 --- User-Defined Exception Conditions --- p.80
Chapter 5.1.2 --- Fatal Conditions --- p.82
Chapter 5.1.3 --- Pre-Defined Exception Conditions --- p.83
Chapter 5.1.4 --- Replacement Assertions --- p.85
Chapter 5.1.5 --- Message Vector Assertions --- p.89
Chapter 5.2 --- Data Dependency Interpretation --- p.91
Chapter 5.2.1 --- Immediate Replacement --- p.92
Chapter 5.2.2 --- Direct Dependency --- p.92
Chapter 5.2.3 --- Indirect Dependency --- p.93
Chapter 5.2.4 --- Shared Data Variable --- p.99
Chapter CHAPTER 6 --- SCHEDULING FOR EXCEPTION HANDLING --- p.104
Chapter 6.1 --- Backward Path Tracing --- p.106
Chapter 6.1.1 --- Forward Versus Backward Tracing --- p.106
Chapter 6.1.2 --- Assertion-Marking Strategy --- p.113
Chapter 6.2 --- Grain Scheduling --- p.116
Chapter 6.2.1 --- New Constraints --- p.120
Chapter 6.3 --- Delayed Exception Raise Event --- p.125
Chapter 6.4 --- Enhancement of Scheduling Algorithm --- p.126
Chapter 6.5 --- Control Flow Issues --- p.128
Chapter 6.5.1 --- Immediate Replacement --- p.130
Chapter 6.5.2 --- Direct Dependency --- p.131
Chapter 6.5.3 --- Indirect Dependency --- p.132
Chapter 6.5.4 --- Lower Dimensionality --- p.133
Chapter CHAPTER 7 --- MORE COMPLICATED SCHEDULING --- p.135
Chapter 7.1 --- Multiple Exception Handling Assertions --- p.137
Chapter 7.1.1 --- Overlapped Scopes of Exception Grain --- p.138
Chapter 7.1.2 --- Priorities in Scheduling --- p.156
Chapter 7.2 --- Single Replacement Assertion --- p.160
Chapter 7.2.1 --- Multiple Exception Conditions --- p.160
Chapter 7.2.2 --- Conditional Replacement --- p.163
Chapter 7 .3 --- Loop Optimization --- p.164
Chapter 7.4 --- Modifications to the Scheduling Algorithm --- p.177
Chapter 7.5 --- Implementation --- p.180
Chapter 7.5.1 --- Syntax Checking --- p.180
Chapter 7.5.2 --- Array Graph Construction --- p.182
Chapter 7.5.3 --- Array Graph Analysis --- p.185
Chapter 7.5.4 --- Generation of Schedule with Exception Handling Subgraph --- p.186
Chapter CHAPTER 8 --- CONCLUSIONS --- p.187
Chapter 8 .1 --- Future Work --- p.188
APPENDIX
Chapter 1. --- Backward Tracing/Assertion Marking Strategy
REFERENCE
APA, Harvard, Vancouver, ISO, and other styles
You might also be interested in the bibliographies on the topic 'Exception Handling' for other source types:
Journal articles Books
We offer discounts on all premium plans for authors whose works are included in thematic literature selections. Contact us to get a unique promo code!

To the bibliography