English

CIn - Centro de Informática UFPE




Eventos Relacionados

Defesa de Dissertação de Mestrado Nº 1.393: "Bidimensional Exception Interfaces"

O aluno Thiago Bezerra Lima e Silva irá defender seu trabalho dia 25 de julho, às 10h, na sala D226 Início: 25/07/2014 às 10:00 Término: 25/07/2014 às 12:00 Local: Sala D226

Defesa de Dissertação de Mestrado Nº  1.393
 
Aluno: Thiago Bezerra Lima e Silva
Orientador: Prof. Fernando Jose Castor de Lima Filho
Título: Bidimensional Exception Interfaces
Data: 25/07/2014
Hora/Local: 10h –  Sala  D226
Banca Examinadora:
Prof. Leopoldo Motta Teixeira  (UFPE / CIn)
Prof. Nelio Alessandro Azevedo Cacho  (UFRN / DIMAp)
Prof.  Fernando Jose Castor de Lima Filho  (UFPE / CIn)
 
Abstract:
 
Exception handling is a technique for improving software modularity and reuse in the presence of exceptional conditions. Many mainstream programming languages, such as Java, Ada, C++, Python, and C#, implement exception handling mechanisms. These languages provide constructs to indicate the occurrence of an error (throw an exception) and to associate a set of recovery actions with the error to remedy the problem (handle the exception). Methods that throw exceptions and handle exceptions are known respectively as throwing sites and handling sites. Error recovery measures are implemented within exception handlers.
The Java programming language allows developers to specify the exception interface of a method using the throws clause. This mechanism supports static checking that is coherent with a statically-typed language. However, it is known to have limitations. In particular, throws clauses hinder understandability and maintainability due to their scattered nature and lack of information about the source of an exception, the place where it is handled, and everything in between. As a consequence, exceptions easily get "out of control" and, as system development progresses, exceptional control flow becomes less well-understood, with potentially negative consequences for program evolution. We observe that throws clauses scale well for methods that throw exceptions to large numbers of direct callers (horizontally), but not for long chains of method calls (vertically). Thus, we argue that appropriate mechanisms should be provided to specify horizontal and vertical exception interfaces.
In this dissertation, we formulate the notion of vertical and horizontal (hence, bidimensional) exception interfaces and present an extension to the Java language, called EPiC-Java that incorporates the proposed approach, a prototype compiler and a reengineering tool for that extension. Bidimensional exception interfaces are formalized as an extension to Featherweight Java. Finally, we show that the application of the proposed approach to three open-source systems resulted in a considerable reduction in the number of throws clauses and a comparatively smaller number of propagate clauses, thus suggesting that maintainability is improved.
 
Key-works: languages design, exception interfaces, checked exceptions
-----------------------------------------------------------------------------------------------------------------
Titulo: Interfaces de Exceções Bidimensionais
 
Tratamento de exceções é uma técnica usada para aperfeiçoar
modularidade e reuso de softwares na presença de condições
excepcionais. Muitas linguagens de programação populares como Java,
Ada, C++, Python e C# implementam mecanismos de tratamento de
exceções. Essas linguagens fornecem mecanismos para indicar a
ocorrência de um erro e associar um conjunto de ações de recuperação
ao erro. Métodos que lançam exceções e tratam exceções são conhecidos,
respectivamente, como "throwing sites" e "handling sites". Medidas de
recuperação são implementados em tratadores de exceção.
A linguagem de programação Java permite que desenvolvedores
especifiquem a interface de exceção de um método utilizando a cláusula
"throws". Esse mecanismo permite checagem estática e é coerente com
linguagens de tipagem estática. Por outro lado, é um mecanismo com
limitações conhecidas. Em particular, cláusulas throws inibem a
compreensão e manutenção de softwares devido a sua natureza
fragmentada e por não tornar explícito o local de origem de uma
exceção, o local onde ela é tratada, e tudo o que se encontra entre
esses dois locais. Consequentemente, exceções facilmente fogem ao
controle e, com o progresso no desenvolvimento de um software, o fluxo
de controle de exceções se torna mais complicado, com consequências
potencialmente negativas para a evolução do software. Nós observamos
que cláusulas throws escalam bem em métodos que lançam exceções para
um grande número de métodos chamadores diretos (ou seja, escalam
horizontalmente), mas não para longas cadeias de chamadas de métodos
(verticalmente). Assim, nós argumentamos que mecanismos apropriados
para especificar interfaces de exceções horizontais e verticais devem
ser fornecidos.
Nesta dissertação, nós formulamos a noção de interfaces de exceções
horizontais e verticais (portanto, bidimensionais) e apresentamos uma
extensão para a linguagem Java, chamada EPiC-Java, que incorpora a
abordagem proposta, um protótipo de compilador e uma ferramenta de
engenharia reversa para a extensão. Interfaces de exceção
bidimensionais são formalizadas como uma extensão de Featherweight
Java. Finalmente, nós mostramos que a aplicação da abordagem proposta
a três sistemas de código aberto resultou em uma redução considerável
no número de cláusulas throws e um número comparativamente menor de
cláusulas propagate, sugerindo assim, uma melhoria no processo de
manutenção.
 
Palavras chave: design de linguagens, interfaces de exceções, checked exceptions 
  • © Centro de Informática UFPE - Todos os direitos reservados
    Tel +55 81 2126.8430 - Cidade Universitária - 50740-560 - Recife/PE
Plano4 Consultoria Web