Towards detecting and solving aspect conflicts and interferences using unit tests

Aspect Oriented Programming (AOP) is a programming paradigm that aims at solving the problem of crosscutting concerns being normally scattered throughout several units of an application.Although an important step forward in the search for modularity, by breaking the notion of encapsulation introduced by Object Oriented Programming (OOP), AOP has proven to be prone to numerous problems caused by conflicts and interferences between aspects.This paper presents work that explores the proven unit testing techniques as a mean to help developers describe the behavior of their aspects and to advise them about possible conflicts and interferences

Incremental modular testing for AOP

By designing systems as sets of modules that can be composed into larger applications, developers unleasha multitude of advantages. The promise of AOP (Aspect-Oriented Programming) is to enable developers toorganize crosscutting concerns into separate units of modularity making it easier to accomplish this vision.However, AOP does not allow unit tests to be untangled, which impairs the development of properly testedindependent modules. This paper presents a technique that enables developers to encapsulate crosscuttingconcerns using AOP and still be able to develop reusable unit tests. Our approach uses incremental testingand invasive aspects to modify and adapt tests. The approach was evaluated in a medium scale project withpromising results. Without using the proposed technique, due to the presence of invasive aspects, some unittests would have to be discarded or modified to accommodate the changes made by them. This would havea profound impact on the overall modularity and, in particular, on the reusability of those modules. We willshow that this technique enables proper unit tests that can be reused even when coupled with aspect-orientedcode

Empirical Evaluation of a Live Environment for Extract Method Refactoring

Complex software can be hard to read, adapt, and maintain. Refactoring it can create cleaner and self-explanatory code. Refactoring tools try to guide developers towards better code, with more quality. However, most of them take too long to provide feedback, support, and guidance on how developers should improve their software. To reduce this problem, we explored the concept of Live Refactoring, focusing on visually suggesting and applying refactorings, in real-time. With this in mind, we developed a Live Refactoring Environment that visually identifies, recommends, and applies Extract Method refactorings. To validate it, we conducted an empirical experiment. Early results showed that our approach improved several code quality metrics. Besides, we also concluded that our results were significantly different and better than the ones from refactoring the code manually without further help

Towards a Pattern Language for the Masters Student

Every year, thousands of new students begin their Masters in STEM related topics. Despite being regarded as a common occurrence by the faculty, it represents the culmination of years of studying and preparation for their professional life. Notwithstanding, these students face well-known recurrent problems: how to choose a topic, how to choose an advisor, how to start researching, and how to deal with all the unknowns associated with academic research. Although there are several books on how to write a thesis, most of them avoid prescriptive recommendations on topics beyond research per se or focus on doctoral students, for which the duration and motivation are significantly different. In this paper, we draft a pattern language comprised of thirty patterns that we have observed from supervising over a hundred masters students within the last decade

Automatically Generating Websites from Hand-drawn Mockups

Designers often use physical hand-drawn mockups to convey their ideas to stakeholders. Unfortunately, these sketches do not depict the exact final look and feel of web pages, and communication errors will often occur, resulting in prototypes that do not reflect the stakeholder's vision. Multiple suggestions exist to tackle this problem, mainly in the translation of visual mockups to prototypes. Some authors propose end-to-end solutions by directly generating the final code from a single (black-box) Deep Neural Network. Others propose the use of object detectors, providing more control over the acquired elements but missing out on the mockup's layout. Our approach provides a real-time solution that explores: (1) how to achieve a large variety of sketches that would look indistinguishable from something a human would draw, (2) a pipeline that clearly separates the different responsibilities of extracting and constructing the hierarchical structure of a web mockup, (3) a methodology to segment and extract containers from mockups, (4) the usage of in-sketch annotations to provide more flexibility and control over the generated artifacts, and (5) an assessment of the synthetic dataset impact in the ability to recognize diagrams actually drawn by humans. We start by presenting an algorithm that is capable of generating synthetic mockups. We trained our model (N=8400, Epochs=400) and subsequently fine-tuned it (N=74, Epochs=100) using real human-made diagrams. We accomplished a mAP of 95.37%, with 90% of the tests taking less than 430ms on modest commodity hardware (approximate to 2.3fps). We further provide an ablation study with well-known object detectors to evaluate the synthetic dataset in isolation, showing that the generator achieves a mAP score of 95%, approximate to 1.5 x higher than training using hand-drawn mockups alone

Visually-defined Real-Time Orchestration of IoT Systems

In this work, we propose a method for extending Node-RED to allow the automatic decomposition and partitioning of the system towards higher decentralization. We provide a custom firmware for constrained devices to expose their resources, as well as new nodes and modifications in the Node-RED engine that allow automatic orchestration of tasks. The firmware is responsible for low-level management of health and capabilities, as well as executing MicroPython scripts on demand. Node-RED then takes advantage of this firmware by (1) providing a device registry allowing devices to announce themselves, (2) generating MicroPython code from dynamic analysis of flow and nodes, and (3) automatically (re-)assigning nodes to devices based on pre-specified properties and priorities. A mechanism to automatically detect abnormal run-time conditions and provide dynamic self-adaptation was also explored. Our solution was tested using synthetic home automation scenarios, where several experiments were conducted with both virtual and physical devices. We then exhaustively measured each scenario to allow further understanding of our proposal and how it impacts the system's resiliency, efficiency, and elasticity

Disciplined Reuse of Aspects (State of the Art & Work Plan)

This document describes the work plan and state of the art for the PhD work of André Restivo started in 2006. Acceptance of this document by a steering committee is mandatory for the final registration in the Doctoral Programme in Informatics Engineering (ProDEI) at the Engineering Faculty of University of Porto