GZoltar: A graphical debugger interface

Tese de mestrado integrado. Engenharia Informática e Computação. Faculdade de Engenharia. Universidade do Porto. 201

A detailed description of two controlled experiments concerning the usefulness of assertions as a means for programming

Assertions or more generally "Programming by contract" have gained widespread acceptance in the computer science community as a means for correct program development. However, the literature lacks an empirically evaluation of the benefits a programmer gains by using assertions in his software development. This paper reports about two controlled experiments to close this gap. Both experiments compared "Programming by contract" to the traditional programming style without assertions. The evaluation suggests that assertions tend to decrease the programming effort and that assertions lead to more reliable programs compared to those programs written without using them

Programmiersprachen und Rechenkonzepte

Seit 1984 veranstaltet die GI--Fachgruppe 2.1.4 "Programmiersprachen und Rechenkonzepte", die aus den ehemaligen Fachgruppen 2.1.3 "Implementierung von Programmiersprachen" und 2.1.4 "Alternative Konzepte für Sprachen und Rechner" hervorgegangen ist, regelmäßi g im Frühjahr einen Workshop im Physikzentrum Bad Honnef. Das Treffen dient in erster Linie dem gegenseitigen Kennenlernen, dem Erfahrungsaustausch, der Diskussion und der Vertiefung gegenseitiger Kontakte

Mint Era : a testing environment for Java programs

Thesis (M. Eng.)--Massachusetts Institute of Technology, Dept. of Electrical Engineering and Computer Science, 2004.Includes bibliographical references (p. 99-100).We introduce MintEra, an automatic testcase generator and verifier. Using an simple, easy-to-read yet expressive language called AAL, users can specify representation- invariants and assertions within programs. MintEra uses the representation-invariant to generate testcases and translates assertions into Java run-time checks, which verify testcases. The tool then graphically visualize failed testcases to help users debug their code. MintEra encourages documentation of programs by using specification to test and verify code. Effectively, the tool checks code and specification against each other. Thus, MintEra helps users ensure correctness of their programs as well as their specification. In this thesis, we provide a number of extra features that we hope would develop MintEra into an effective tool that could be used by the general software engineering community.by Basel Y. Al-Naffouri.M.Eng

Détection d'erreur au plus tôt dans les systèmes temps-réel : une approche basée sur la vérification en ligne

La vérification en ligne de spécifications formelles permet de créer des détecteurs d'erreur dont le pouvoir de détection dépend en grande partie du formalisme vérifié à l'exécution. Plus le formalisme est puissant plus la séparation entre les exécutions correctes et erronées peut être précise. Cependant, l'utilisation des vérifieurs en-ligne dans le but de détecter des erreurs est entravée par deux problèmes récurrents : le coût à l'exécution de ces vérifications, et le flou entourant les propriétés sémantiques exactes des signaux d'erreur ainsi générés. L'objectif de cette thèse est de clarifier les conditions d'utilisation de tels détecteurs dans le cadre d'applications « temps réel » critiques. Dans ce but, nous avons donné l'interprétation formelle de la notion d'erreur comportementale « temps réel». Nous définissions la propriété de détection « au plus tôt » qui permet de d'identifier la classe des détecteurs qui optimisent la latence de détection. Pour illustrer cette classe de détecteurs, nous proposons un prototype qui vérifie un comportement décrit par un automate temporisé. La propriété de détection au plus tôt est atteinte en raisonnant sur l'abstraction temporelle de l'automate et non sur l'automate lui-même. Nos contributions se déclinent dans trois domaines, la formalisation de la détection au plus tôt, sa traduction pour la synthèse de détecteurs d'erreur à partir d'automate temporisés, puis le déploiement concret de ces détecteurs sur une plate-forme de développement temps réel, Xenomai. ABSTRACT : Runtime verification of formal specifications provides the means to generate error detectors with detection capabilities depending mostly on the kind of formalism considered. The stronger the formalism is the easier the speration between correct and erroneous execution is. Nevertheless, two recurring issues have to be considered before using such error detection mechanisms. First, the cost, at run-time, of such error detector has to be assessed. Then, we have to ensure that the execution of such detectors has a well defined semantics. This thesis aims at better understanding the conditions of use of such detectors within critical real-time software application. Given formal behavioural specification, we defined the notion of "behavioural error". Then, we identify the class of early detectors that optimize the detection latency between the occurence of such errors and their signalling. The whole generation process has been implemented for specifications provided as timed automata. The prototype achieves early error detection thanks to a preprocessing of the automaton to generate its temporal abstraction. Our contributions are threefold : formalisation of early detection, algorithms for timed automata run-time verification, and prototyping of such detectors on a real-time kernel, Xenomai

Scalable deep learning for bug detection

The application of machine learning (ML) and natural language processing (NLP) methods for creating software engineering (SE) tools is a recent emerging trend. A crucial early decision is how to model software’s vocabulary. Unlike in natural language, software developers are free to create any identifiers they like, and can make them arbitrarily complex resulting in an immense out of vocabulary problem. This fundamental fact prohibits training of Neural models on large-scale software corpora. This thesis aimed on addressing this problem. As an initial step we studied the most common ways for vocabulary reduction previously considered in the software engineering literature and found that they are not enough to obtain a vocabulary of manageable size. Instead this goal was reached by using an adaptation of the Byte-Pair Encoding (BPE) algorithm, which produces an open-vocabulary neural language model (NLM). Experiments on large corpora show that the resulting NLM outperforms other LMs both in perplexity and code completion performance for several programming languages. It continues by showing that the improvement in language modelling transfers to downstream SE tasks by finding that the BPE NLMs are more effective in highlighting buggy code than previous LMs. Driven by this finding and from recent advances in NLP it also investigates the idea of transferring language model representations to program repair systems. Program repair is an important but difficult software engineering problem. One way to achieve a “sweet spot” of low false positive rates, while maintaining high enough recall to be usable, is to focus on repairing classes of simple bugs, such as bugs with single statement fixes, or that match a small set of bug templates. However, it is very difficult to estimate the recall of repair techniques based on templates or based on repairing simple bugs, as there are no datasets about how often the associated bugs occur in code. To fill this gap, the thesis contributes a large dataset of single statement Java bug-fix changes annotated by whether they match any of a set of 16 bug templates along with a methodology for mining similar datasets. These specific patterns were selected with the criteria that they appear often in open-source Java code and relate to those used by mutation and pattern-based repair tools. They also aim at extracting bugs that compile both before and after repair as such can be quite tedious to manually spot, yet their fixes are simple. These mined bugs are quite frequent appearing about every 2000 lines of code and that their fixes are very often already present in the code satisfying the popular plastic surgery hypothesis. Furthermore, it introduces a hypothesis that contextual embeddings offer potential modelling advantages that are specifically suited for modelling source code due to its nature. Contextual embeddings are common in natural language processing but have not been previously applied in software engineering. As such another contribution is the introduction a new set of deep contextualized word representations for computer programs based on the ELMo (embeddings from language models) framework of Peters et al (2018). It is shown that even a low-dimensional embedding trained on a relatively small corpus of programs can improve a state-of-the-art machine learning system for bug detection of single statement fixes. The systems were evaluated on the DeepBugs dataset of synthetic bugs, a new synthetic test dataset, and a small dataset of real JavaScript bugs. Lastly, the final contribution is the first steps at answering whether neural bug-finding is useful in practice by performing an evaluation study over a small set of real bugs

Conjugate heat transfer coupling relying on large eddy simulation with complex geometries in massively parallel environments

Progress in scientific computing has led to major advances in simulation and understanding of the different physical phenomena that exist in industrial gas turbines. However' most of these advances have focused on solving one problem at a time. Indeed' the combustion problem is solved independently from the thermal or radiation problems' etc... In reality all these problems interact: one speaks of coupled problems. Thus performing coupled computations can improve the quality of simulations and provide gas turbines engineers with new design tools. Recently' solutions have been developed to handle multiple physics simultaneously using generic solvers. However' due to their genericity these solutions reveal to be ineffective on expensive problems such as Large Eddy Simulation (LES). Another solution is to perform code coupling: specialized codes are connected together' one for each problem and they exchange data periodically. In this thesis a conjugate heat transfer problem is considered. A fluid domain solved by a combustion LES solver is coupled with a solid domain in which the conduction problem is solved. Implementing this coupled problem raises multiple issues which are addressed in this thesis. Firstly' the specific problem of coupling an LES solver to a conduction solver is considered: the impact of the inter-solver exchange frequency on convergence' possible temporal aliasing' and stability of the coupled system is studied. Then interpolation and geometrical issues are addressed: a conservative interpolation method is developed and compared to other methods. These methods are then applied to an industrial configuration' highlighting the problems and solutions specific to complex geometry. Finally' high performance computing (HPC) is considered: an efficient method to perform data exchange and interpolation between parallel codes is developed. This work has been applied to an aeronautical combustion chamber configuration

Run-time monitoring of goal-oriented requirements specification.

The environment in which a software system operates is as important to the correct operation of the system as the software itself. Most software development involves making assumptions about the environment in which the resulting system will operate. These assumptions may cease to be valid if the environment changes, causing the system to fail to operate correctly. One solution to this problem is to use run-time requirements monitoring to deter mine, as a system operates, whether it is satisfying the requirements specified for it and to take action to rectify these problems. This thesis describes work that has been carried out in the area of run-time requirements monitoring. A framework has been developed for monitoring requirements which are formally specified using temporal logic and the KAOS goal-oriented requirements specification language. The framework uses AspecU to instrument the monitored system so that events are emitted which are used to determine whether the monitored system satisfies the requirements specification. The framework also provides a language which can specify a mapping between requirements and implementation which can be used to generate instrumentation code. The monitoring framework supports monitoring of soft goals by allowing the formal specification of metrics which can be used to determine whether soft goals are in fact being satisfied. These contributions are validated using a workforce scheduling system as a case study. This is a real world system and the requirements monitored were those considered useful by the developers of the system. The case study shows that the monitoring framework can be used to instrument a system to monitor hard and soft goals and that those goals can be monitored with reasonable performance overhead. Goal failures due to changes in the environment can be detected using the information supplied by the monitoring framework