Segui questo link per vedere altri tipi di pubblicazioni sul tema: Exception Handling.
Tesi sul tema "Exception Handling"
Cita una fonte nei formati APA, MLA, Chicago, Harvard e in molti altri stili
Vedi i top-50 saggi (tesi di laurea o di dottorato) per l'attività di ricerca sul tema "Exception Handling".
Accanto a ogni fonte nell'elenco di riferimenti c'è un pulsante "Aggiungi alla bibliografia". Premilo e genereremo automaticamente la citazione bibliografica dell'opera scelta nello stile citazionale di cui hai bisogno: APA, MLA, Harvard, Chicago, Vancouver ecc.
Puoi anche scaricare il testo completo della pubblicazione scientifica nel formato .pdf e leggere online l'abstract (il sommario) dell'opera se è presente nei metadati.
Vedi le tesi di molte aree scientifiche e compila una bibliografia corretta.
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.
Testo completoAbstract (sommario):
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.
2
Gurunath, Pramod. "OCL exception handling." Thesis, Texas A&M University, 2004. http://hdl.handle.net/1969.1/1281.
Testo completoAbstract (sommario):
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.
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.
Testo completoAbstract (sommario):
CONSELHO NACIONAL DE DESENVOLVIMENTO CIENTÍFICO E TECNOLÓGICO<br>FUNDAÇÃO PADRE LEONEL FRANCA<br>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.<br>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.
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.
Testo completo
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.
Testo completoAbstract (sommario):
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.<br>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 é
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.
Testo completoAbstract (sommario):
PONTIFÍCIA UNIVERSIDADE CATÓLICA DO RIO DE JANEIRO<br>CONSELHO NACIONAL DE DESENVOLVIMENTO CIENTÍFICO E TECNOLÓGICO<br>FUNDAÇÃO DE APOIO À PESQUISA DO ESTADO DO RIO DE JANEIRO<br>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.<br>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.
7
Drew, Steve. "Exception handling with fail-safe semantics." Thesis, Queensland University of Technology, 1996. https://eprints.qut.edu.au/36827/1/36827_Digitised%20Thesis.pdf.
Testo completo
8
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.
Testo completoAbstract (sommario):
<p>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.</p>
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.
Testo completoAbstract (sommario):
PONTIFÍCIA UNIVERSIDADE CATÓLICA DO RIO DE JANEIRO<br>CONSELHO NACIONAL DE DESENVOLVIMENTO CIENTÍFICO E TECNOLÓGICO<br>FUNDAÇÃO DE APOIO À PESQUISA DO ESTADO DO RIO DE JANEIRO<br>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.<br>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.
10
Mahanga, Mwaka. "Unknown Exception Handling Tool Using Humans as Agents." UNF Digital Commons, 2015. http://digitalcommons.unf.edu/etd/563.
Testo completoAbstract (sommario):
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.
11
Derks, Wouter W. C. "Enhanced exception handling in sales order processing workflows." Thesis, Loughborough University, 2003. https://dspace.lboro.ac.uk/2134/34298.
Testo completoAbstract (sommario):
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.
12
Adams, Michael James. "Facilitating dynamic flexibility and exception handling for workflows." Thesis, Queensland University of Technology, 2007. https://eprints.qut.edu.au/16600/1/Michael_James_Adams_Thesis.pdf.
Testo completoAbstract (sommario):
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.
13
Adams, Michael James. "Facilitating dynamic flexibility and exception handling for workflows." Queensland University of Technology, 2007. http://eprints.qut.edu.au/16600/.
Testo completoAbstract (sommario):
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.
14
Nehmer, Nikolas [Verfasser]. "Exception Handling - A Systematic Log-Based Approach / Nikolas Nehmer." München : Verlag Dr. Hut, 2012. http://d-nb.info/1021719315/34.
Testo completo
15
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.
Testo completoAbstract (sommario):
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.
16
Ebert, Felipe. "An Exploratory Study on Exception Handling Bugs in Java Programs." Universidade Federal de Pernambuco, 2013. https://repositorio.ufpe.br/handle/123456789/11984.
Testo completoAbstract (sommario):
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.<br>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)<br>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<br>FACEPE e CNPq<br>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.
17
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.
Testo completoAbstract (sommario):
Thesis (S.B. and M.Eng.)--Massachusetts Institute of Technology, Dept. of Electrical Engineering and Computer Science, 2000.<br>Includes bibliographical references (leaves 43-45).<br>by Athicha Muthitacharoen.<br>S.B.and M.Eng.
18
Aldosary, Saad. "Investigation of multimodal template-free biometric techniques and associated exception handling." Thesis, University of Kent, 2015. https://kar.kent.ac.uk/54805/.
Testo completoAbstract (sommario):
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.
19
Pretnar, Matija. "Logic and handling of algebraic effects." Thesis, University of Edinburgh, 2010. http://hdl.handle.net/1842/4611.
Testo completoAbstract (sommario):
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.
20
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.
Testo completoAbstract (sommario):
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
21
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.
Testo completoAbstract (sommario):
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.<br>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.
22
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/.
Testo completoAbstract (sommario):
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.
23
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.
Testo completoAbstract (sommario):
Conselho Nacional de Desenvolvimento CientÃfico e TecnolÃgico<br>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.<br>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.
24
LÔBO, Rafael Brandão. "Deadlocks as runtime exceptions." Universidades Federais de Pernambuco, 2015. https://repositorio.ufpe.br/handle/123456789/17332.
Testo completoAbstract (sommario):
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)<br>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<br>CAPEs<br>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.<br>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.
25
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.
Testo completoAbstract (sommario):
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.
26
Sheng, Quanzheng Computer Science & 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.
Testo completoAbstract (sommario):
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.
27
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.
Testo completoAbstract (sommario):
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<br>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<br>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
28
Hamadi, Rachid Computer Science & 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.
Testo completoAbstract (sommario):
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.
29
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/.
Testo completoAbstract (sommario):
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.<br>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.
30
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/.
Testo completoAbstract (sommario):
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.<br>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.
31
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/.
Testo completoAbstract (sommario):
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.<br>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.
32
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.
Testo completoAbstract (sommario):
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.<br>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)<br>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)<br>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<br>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.<br>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.
33
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.
Testo completoAbstract (sommario):
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.<br>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)<br>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)<br>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<br>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.<br>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.
34
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.
Testo completoAbstract (sommario):
Orientador: Cecília Mary Fischer Rubira<br>Dissertação (mestrado) - Universidade Estadual de Campinas, Instituto de Computação<br>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<br>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<br>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<br>Mestrado<br>Sistemas de Informação<br>Mestre em Ciência da Computação
35
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.
Testo completoAbstract (sommario):
Orientador: Cecilia Mary Fischer Rubira<br>Dissertação (mestrado) - Universidade Estadual de Campinas, Instituto de Computação<br>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<br>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<br>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<br>Mestrado<br>Engenharia de Software<br>Mestre em Ciência da Computação
36
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.
Testo completoAbstract (sommario):
Orientador: Eliane Martins<br>Dissertação (mestrado) - Universidade Estadual de Campinas, Instituto de Computação<br>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<br>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<br>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<br>Mestrado<br>Ciência da Computação<br>Mestre em Ciência da Computação
37
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/.
Testo completoAbstract (sommario):
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.<br>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.
38
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/.
Testo completoAbstract (sommario):
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.<br>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.
39
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.
Testo completoAbstract (sommario):
CoordenaÃÃo de AperfeiÃoamento de Pessoal de NÃvel Superior<br>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.<br>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.
40
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.
Testo completoAbstract (sommario):
Orientador: Cecília Mary Fischer Rubira<br>Dissertação (mestrado) - Universidade Estadual de Campinas, Instituto de Computação<br>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<br>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<br>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<br>Mestrado<br>Ciência da Computação<br>Mestre em Ciência da Computação
41
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.
Testo completoAbstract (sommario):
Orientador: Cecília Mary Fischer Rubira<br>Tese (doutorado) - Universidade Estadual de Campinas, Instituto de Computação<br>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<br>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<br>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<br>Doutorado<br>Engenharia de Software<br>Doutor em Ciência da Computação
42
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.
Testo completoAbstract (sommario):
Orientador: Cecília Mary Fischer Rubira<br>Dissertação (mestrado) - Universidade Estadual de Campinas, Instituto de Computação<br>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<br>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<br>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<br>Mestrado<br>Ciência da Computação<br>Mestre em Ciência da Computação
43
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/.
Testo completoAbstract (sommario):
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<br>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
44
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.
Testo completoAbstract (sommario):
Thesis (M.Eng.)--Massachusetts Institute of Technology, Dept. of Electrical Engineering and Computer Science, 1999.<br>Includes bibliographical references (leaves 61-63).<br>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.<br>by Lijin Aryananda.<br>M.Eng.
45
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.
Testo completoAbstract (sommario):
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<br>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<br>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
46
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.
Testo completoAbstract (sommario):
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.
47
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.
Testo completoAbstract (sommario):
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.<br>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.
48
Cheng, Hsiung-Mao, and 鄭勳懋. "Exception Patterns for Exception Handling." Thesis, 2006. http://ndltd.ncl.edu.tw/handle/15324049072756016528.
Testo completoAbstract (sommario):
碩士<br>東海大學<br>資訊工程與科學系<br>94<br>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.
49
Huang, Chih-Chao, and 黃致超. "Obfuscation Using Exception Handling." Thesis, 2010. http://ndltd.ncl.edu.tw/handle/63883675873468173792.
Testo completoAbstract (sommario):
碩士<br>國立交通大學<br>資訊科學與工程研究所<br>99<br>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.
50
Lourenço, João Ricardo. "PreX – Preventive Exception Handling." Master's thesis, 2016. http://hdl.handle.net/10316/99218.
Testo completoAbstract (sommario):
Relatório Final de Estágio do Mestrado em Engenharia Informática apresentado à Faculdade de Ciências e Tecnologia da Universidade de Coimbra.<br>The exception handling mechanism has been one of the most used reliability tools in
programming languages for over four decades. Nearly all modern languages have some
form of “try-catch” model for exception handling and encourage its use. Nevertheless,
this model has not seen significant change, even in the face of new challenges, such as
concurrent programming and the advent of reactive programming. As it stands, the
current model is reactive, rather than proactive — exceptions are raised, caught, and
handled. Online Failure Prediction techniques generally work at a very high level, showing
potential for prediction of program crashes. However, these techniques have never
been at the hands of the programmers as an effective tool to improve software quality.
This work proposes an alternative exception handling model — PreX — where exceptions
are no longer caught but, rather, predicted and possibly prevented. By applying
recent advances in Online Failure Prediction to Exception Handling, PreX aims to fully
prevent exceptions, bringing failure prediction techniques to a much more fine-grained
level that the programmer can control. Predicting exceptions enables a range of preventive
measures that enhance the reliability and robustness of a system, offering new
revitalization strategies to developers. In addition to introducing the concept of PreX,
this work defines its model and architecture and provides a full evaluation of its prototype
implementation, showing that it offers significant advantages to developers and
that it can be applied to real-world projects.