Compreensão de aplicações web: o processo e as ferramentas

Já ninguém duvida que a compreensão de programas (CP) é uma área cada vez mais importante, e a sua aplicação cada vez mais abrangente na engenharia da programação, constituindo-se como um desafio permanente e actual para as ciências de computação. A compreensão de programas nasce da tentativa de melhorar os processos de manutenção de sistemas aplicacionais, mas de facto está também francamente associada ao processo de aprendizagem de linguagens de programação. Por isso, nesta linha de preocupações têm sido desenvolvidas inúmeras ferramentas de auxílio à compreensão de software para manutenção (alteração ou actualização de código), reverse-engineering/re-engineering, ou ensino de programação. A complexidade do processo de compreensão requer a existência de modelos de aprendizagem e representação de conhecimento. Uma questão que então se coloca muitas vezes, é saber se as ferramentas obedecem aos modelos cognitivos existentes; importa também saber como medir o seu real impacto na compreensão. Este artigo tem como objectivo a descrição de um conjunto de critérios a adoptar no sentido de avaliar se uma ferramenta pode efectivamente ajudar na compreensão de programas, apresentando-se uma aplicação prática. Dada a importância cada vez maior das aplicações que correm sobre a Web, o estudo incidirá sobre esse recente paradigma de programação. Procuraremos identificar o que de novo há neste tipo de programação que interessa realçar para o seu bom entendimento.FC

Evaluating the Impact of Live Programming on Collaborative Software Development

Collaboration is tricky, but often beneficial in the context of numerous software related activities, from learning core concepts, to the design and implementation of large software products. The growth of online classes, from small structured seminars to massive open online courses (MOOCs), and the isolation and impoverished learning experience some students report in these, points to an urgent need for tools that support remote pair programming in a distributed educational setting. In “the real world” software developers and designers work together to solve common problems, and meaningful and effective designer-developer collaboration improves the user experience. Supporting these with today’s often distributed work model presents important challenges.Two key techniques which are believed to be effective in promoting better coordination and collaboration are collaborative coding and live programming. Collaborative coding allows all the team members to get involved in the development process, and live programming enables them to see what they are building effortlessly and in real time.In this work, we first describe Jimbo, an integrated development environment (IDE) based on collaborative and live programming techniques, and a set of user studies aimed at evaluating whether these techniques are effective in promoting better coordination and collaboration in two different settings; distance learning and design-focused software development. Our results show that these techniques can improve the learning experience through pair programming and a tight code-artifact feedback loop. We will show how collaborative coding and live programming can help designers and developers bridge their knowledge and language gaps and develop mutual understanding, allowing designers to join the development process as first-class citizens – not dependent on the coders to compile and share output – or being forced to become coders.Keywords: pair programming, collaborative learning, collaboration, educational tools, live programming, remote pair-programming, programming environment, MOOC, IDE, distance learning, designer-developer collaboration, collaborative software developmen

Unique identification of elements in evolving models : towards fine-grained traceability in model-driven engineering

Model-driven engineering (MDE) is a widely accepted methodology in software engineering. At the same time, the ability to retrace the engineering process is an important success factor for software projects. In MDE, however, such traceability is often impeded by the inadequate management of model evolution. Although models have a very fine-grained structure, their different revisions and variants are prevalently managed as monoliths in a file-based software configuration management (SCM). This causes the identification problem: if the fine-grained elements are not assigned with globally unique identifiers, we cannot identify them over time. If such identifiers would be given, they can be misleading. As a consequence, we cannot comprehend the evolution of elements and traceability relationships among the elements cannot be managed sufficiently. This thesis presents a novel solution to the identification problem. It establishes a representation to describe the history of a model and its fine-grained elements inside. The key feature of the representation is a new kind of traceability relationship, called identification links. They allow us to identify elements of a given revision in other revisions or variants of the model. The identification is even applicable to anonymous elements and model fragments. It provides us with a broad spectrum of opportunities: e.g. management of fine-grained traceability links, evolution analysis, merging of development branches. Due to the expression of model evolution in the history representation, we are further able to capture the changes that have been applied to the traced elements. This thesis further presents an algorithm to infer the identification links automatically. The approach does not rely on persistent identifiers, but it utilizes a similarity-based model comparison technique to locate the model elements in other revisions. The algorithm and the history representation have been implemented in a prototype. It is metamodel and tool independent and can work with an arbitrary SCM. Existing modeling environments do not have to be modified. Traceability information and evolution information is accessible through a service interface and can thus be integrated in arbitrary tools. The evaluation of our approach by means of controlled experiments with data from real models attested excellent precision and recall values for the identification of model elements over time. Furthermore, different evolution analysis tools have already been built on our approach, which documents the practical applicability of our solution.Die modellgetriebene Entwicklung ist eine weit verbreitete Methode zur Softwareentwicklung. Die ungeeignete Versionierung von Modellen verhindert jedoch oftmals die Nachverfolgbarkeit des Entwicklungsprozesses. Trotz ihrer feinkörnigen Struktur werden Modelle oft monolithisch auf Basis dateibasierter Konfigurationsmanagementsysteme verwaltet. Modellelemente können in diesem Fall nicht über die Zeit hinweg identifiziert werden, weil globale Identifizierer entweder fehlen oder irreführend sein können. Aufgrund dieses Identifikationsproblems können Änderungen an Modellelementen nur sehr schwer nachvollzogen werden. Außerdem können Referenzen zur Nachverfolgbarkeit zwischen Elementen verschiedener Revisionen nicht sinnvoll verwaltet werden. Diese Dissertation löst das Identifikationsproblem. Sie führt eine Repräsentation ein, mit der die Historie von Modellen und deren feinkörnigen Elementen abgebildet werden kann. Ein zentraler Bestandteil dieser Repräsentation sind Identifizierungslinks, die es ermöglichen ein gegebenes Element in anderen Revisionen oder Varianten des Modells wiederzufinden. Der Ansatz unterstützt auch anonyme Elemente und komplette Modellfragmente. Diese neuartige Identifizierung ermöglicht z.B. die Verwaltung von feinkörniger Nachverfolgbarkeitsinformation, die Analyse von Modellevolution oder das Mischen von Entwicklungszweigen. Da die Repräsentation auch die Evolution eines Modells abbilden kann, können die Veränderungen identifizierter Elemente besser erfasst werden. Zudem wird in dieser Dissertation ein Algorithmus entwickelt, mit dem Identifizierungslinks zwischen Modellelementen verschiedener Revisionen inferiert werden. Dieser stützt sich nicht auf persistente Identifizierer, sondern nutzt einen ähnlichkeitsbasierten Differenzalgorithmus, um Elemente in anderen Revisionen wiederzufinden. Der Algorithmus und die Historienrepräsentation wurden in einem modelltyp- und werkzeugunabhängigen Prototyp implementiert, der mit beliebigen Konfigurationsmanagementsystemen zusammenarbeitet, ohne dass diese angepasst werden müssen. Die Informationen zur Nachverfolgbarkeit und Evolution von Modellelementen sind über eine Programmierschnittstelle abfragbar, die sich in beliebigen Werkzeugen nutzen lässt. Der beschriebene Ansatz wurde mit kontrollierten Experimenten auf Basis realer Modellhistorien erfolgreich evaluiert. Darüber hinaus wurde seine praktische Anwendbarkeit durch verschiedene darauf aufbauende Werkzeuge zur Evolutionsanalyse belegt

Assessing the effect of source code characteristics on changeability

Maintenance is the phase of the software lifecycle that comprises any modification after the delivery of an application. Modifications during this phase include correcting faults, improving internal attributes, as well as adapting the application to different environments. As application knowledge and architectural integrity degrade over time, so does the facility with which changes to the application are introduced. Thus, eliminating source code that presents characteristics that hamper maintenance becomes necessary if the application is to evolve. We group these characteristics under the term Source Code Issues. Even though there is support for detecting Source Code Issues, the extent of their harmfulness for maintenance remains unknown. One of the most studied Source Code Issue is cloning. Clones are duplicated code, usually created as programmers copy, paste, and customize existing source code. However, there is no agreement on the harmfulness of clones. This thesis proposes and follows a novel methodology to assess the effect of clones on the changeability of methods. Changeability is the ease with which a source code entity is modified. It is assessed through metrics calculated from the history of changes of the methods. The impact of clones on the changeability of methods is measured by comparing the metrics of methods that contain clones to those that do not. Source code characteristics are then tested to establish whether they are endemic of methods whose changeability decay increase when cloned. In addition to findings on the harmfulness of cloning, this thesis contributes a methodology that can be applied to assess the harmfulness of other Source Code Issues. The contributions of this thesis are twofold. First, the findings answer the question about the harmfulness of clones on changeability by showing that cloned methods are more likely to change, and that some cloned methods have significantly higher changeability decay when cloned. Furthermore, it offers a characterization of such harmful clones. Second, the methodology provides a guide to analyze the effect of Source Code Characteristics in changeability; and therefore, can be adapted for other Source Code Issues

Interactive scalable condensation of reverse engineered UML class diagrams for software comprehension

Software design documentation is a valuable aid in software comprehension. However, keeping the software design up-to-date with evolving source code is challenging and time-consuming. Reverse engineering is one of the options for recovering software architecture from the implementation code. However, reverse engineering techniques suffer from several problems; one of them is that the resultant diagrams offer too detailed information. Therefore, this thesis aims to provide an automated framework to simplify reverse engineered diagrams (specifically class diagram) for assisting software comprehension. This thesis presents a study to elicit software developer’s views on simplifying class diagrams. It also explores the suitability of object-oriented metrics as features for the class diagram simplification. This thesis introduces a novel approach for classifying class inclusion/exclusion by using object-oriented design metrics as features. In addition, a set of text metrics based on class names is invented to enhance the performance prediction by combining these text-based features with object-oriented design metrics. Based on this approach, an automated tool is developed to support software comprehension by providing interactive explorations of various design abstraction levels. Finally, the proposed framework and tool are validated through a user study.Algorithms and the Foundations of Software technolog