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

Analyzing feature implementation by visual exploration of architecturally-embedded call-graphs

ABSTRACT Maintenance, reengineering, and refactoring of large and complex software systems are commonly based on modifications and enhancements related to features. Before developers can modify feature functionality they have to locate the relevant code components and understand the components' interaction. In this paper, we present a prototype tool for analyzing feature implementation of large C/C++ software systems by visual exploration of dynamically extracted call relations between code components. The component interaction can be analyzed on various abstraction levels ranging from function interaction up to interaction of the system with shared libraries of the operating system. The user visually explores the component interaction within a multiview visualization system consisting of various textual and a graphical 3D landscape view. During exploration the 3D landscape view supports the user firstly in deciding early whether a call relation is essential for understanding the feature and, secondly, in finding starting points for fine-grained feature analysis using a top-down approach

Reverse Engineering Software Code in Java to Show Method Level Dependencies

With the increased dependency on the Internet and computers, the software industry continues to grow. However, just as new software is being developed, older software is still in existence and must be maintained. This tends to be a difficult task, as the developers charged with maintaining the software are not always the developers who designed it. Reverse engineering is the study of an application\u27s code and behavior, in order to better understand the system and its design. There are many existing tools that will assist the developer with this undertaking, such as Rational Rose®, jGRASP®, and Eclipse®. However, all the tools generate high level abstractions of the system in question, like the class diagram. It would be more beneficial to developers to have illustrations with more detailed information, such as the method level dependencies in the source code. In order to accomplish this task, a new framework has been developed that will allow the user to view both high level and lower level code detail. As users attempt to perform code maintenance, they will run the code through an existing tool, such as Rational Rose®, and then through the Method Level Dependency Generator component, to show the method level dependencies. These tools used together provide the software maintainer with more useful information, assisting with the software development process, including code design, implementation, and testing

mel - Model Extraction Language and Interpreter

There is a large body of research on extracting models from code-related artifacts to enable model-based analyses of large software systems. However, engineers do not always have access to the entire code base of a system: some components may be procured from third-party suppliers based on a model specification or their code may be generated automatically from models. Additionally, the development of software systems does not produce only source code as its output. Modern large software system have various artifacts relevant to them, such as software models, build scripts, test scripts, version control history data, and more. In order to produce a more complete view of a modern software system heterogeneous fact extraction of various artifacts is necessary - not just of source code. This thesis introduces mel— a model extraction language and interpreter for extracting “facts” from models represented in XMI; these facts can be combined with facts extracted from other system components to form a lightweight model of an entire software system. We provide preliminary evidence that mel is sufficient to specify fact extraction from models that have very different XMI representations. We also show that it can be easier to use mel to create a fact extractor for a particular model representation than to develop a specialized fact extractor for the model from scratch

A Re-engineering approach for software systems complying with the utilisation of ubiquitous computing technologies.

The evident progression of ubiquitous technologies has put forward the introduction of new features which software systems can sustain. Several of the ubiquitous technologies available today are regarded as fundamental elements of many software applications in various domains. The utilisation of ubiquitous technologies has an apparent impact on business processes that can grant organisations a competitive advantage and improve their productivity. The change in the business processes in such organisations typically leads to a change in the underlying software systems. In addressing the need for change in the underlying software systems, this research is focused on establishing a general framework and methodology to facilitate the reengineering of software systems in order to allow the incorporation of new features which are introduced by the employment of ubiquitous technologies. Although this thesis aims to be general and not limited to a specific programming language or software development approach, the focus is on Object-Oriented software. The reengineering framework follows a systematic step-based approach, with greater focus on the reverse engineering aspect. The four stages of the framework are: program understanding, additional-requirement engineering, integration, and finally the testing and operation stage. In its first stage, the proposed reengineering framework regards the source code as the starting point to understand the system using a static-analysis based method. The second stage is concerned with the elicitation of the user functional requirements resulting from the introduction of ubiquitous technologies. In the third stage, the goal is to integrate the system’s components and hardware handlers using a developed integration algorithm and available integration techniques. In the fourth and final stage, which is discussed in a general manner only in this thesis, the reengineered system is tested and put in the operation phase. The proposed approach is demonstrated using a case study in Java to show that the proposed approach is feasible and promising in its domain. Conclusions are drawn based on analysis and further research directions are discussed at the end of the study

A Unified Metamodel for Assessing and Predicting Software Evolvability Quality

Software quality is a key assessment factor for organizations to determine the ability of software ecosystems to meet the constantly changing requirements. Many quality models exist that capture and assess the changing factors affecting the quality of a software product. Common to these models is that they, contrary to the software ecosystems they are assessing, are not evolvable or reusable. The thesis first defines what constitutes a unified, evolvable, and reusable quality metamodel. We then introduce SE-EQUAM, a novel, ontological, quality assessment metamodel that was designed from the ground up to support quality unification, reuse, and evolvability. We then validate the reus-ability of our metamodel through instantiating a domain specific quality assessment model called OntEQAM that assesses evolvability as a non-functional software quality based on product and com-munity dimensions. A fuzzy logic based assessment process that addresses uncertainties around score boundaries supports the evolvability quality assessment. The presented assessment process also uses the unified representation of the input knowledge artifacts, the metamodel, and the model to provide a fuzzy assessment score. Finally, we further interpret and predict the evolvability as-sessment scores using a novel, cross-disciplinary approach that re-applies financial technical analy-sis, which are indicators, and patterns typically used for price analysis and the forecasting of stocks in financial markets. We performed several case studies to illustrate and evaluate the applicability of our proposed evolvability score prediction approach

Combining SOA and BPM Technologies for Cross-System Process Automation

This paper summarizes the results of an industry case study that introduced a cross-system business process automation solution based on a combination of SOA and BPM standard technologies (i.e., BPMN, BPEL, WSDL). Besides discussing major weaknesses of the existing, custom-built, solution and comparing them against experiences with the developed prototype, the paper presents a course of action for transforming the current solution into the proposed solution. This includes a general approach, consisting of four distinct steps, as well as specific action items that are to be performed for every step. The discussion also covers language and tool support and challenges arising from the transformation