PUC!

Anais da

Primeira Escola Latino America de Engenharia de Software

ELA-ES 2013

Volume II Sessão de Estudantes

PUC-Rio, Rio de Janeiro, Brasil

9 a 12 de Julho de 2013

Departamento de Informática

PONTIFÍCIA UNIVERSIDADE CATÓLICA DO RIO DE JANEIRO

RUA MARQUÊS DE SÃO VICENTE, 225 - CEP 22451-900

RIO DE JANEIRO - BRASIL

Organização

Coordenador Geral

Carlos José Pereira de Lucena (PUC-Rio, BR)

Coordenadores de Programa

Alessandro Garcia (PUC-Rio, BR)

Nelly Bencomo (Aston University, UK)

Coordenadores de Organização

Ingrid Oliveira de Nunes (UFRGS, BR)

Bruno Barbieri de Pontes Cafeo (PUC-Rio, BR)

Coordenadores da Sessão de Estudante

Elder José Reioli Cirilo (PUC-Rio, BR)

Bruno Barbieri de Pontes Cafeo (PUC-Rio, BR)

Eiji Adachi Medeiros Barbosa (PUC-Rio, BR)

Coordenador do Painel da Indústria

Isela Macia Bertran (General Electric Global Research, BR)

Coordenador Financeiro

Francisco Dantas de Medeiros Neto (UERN, BR)

Coordenador de Publicidade

Vanius Zapalowski (UFRGS, BR)

Organizadores Locais

Davy Baía (PUC-Rio, BR)

Carolina Valadares (PUC-Rio, BR)

Eiji Adachi Medeiros Barbosa (PUC-Rio, BR)

Supporting Requirements Engineering Processes in Small Software Enterprises

Alcides Quispe, Sergio F. Ochoa

Computer Science Department, Universidad de Chile, Santiago, Chile

{aquispe, sochoa}@dcc.uchile.cl

Abstract. Selecting software development practices according to the features of the project to address, has been emphasized as relevant research topic by the software engineering community. A one-size fits-all approach does not work for software development in general, and also to perform the Requirements Engineering (RE) activities. RE practices play an important role in the success of a software project, particularly when they are run by Small Software Enterprises (SSEs), due these organizations are usually fragile in terms of human, technological and economic resources. Therefore, selecting the most appropriate RE practices according to the project features, tends to be mandatory for them. Although several RE practices have been included in software processes proposed for SSEs (e.g. ISO/IEC 29110, MoproSoft, MPS.BR, Tutelkan Reference Process, REPM, Uni-REPM, and OWPL), it is difficult to identify which RE practices are specifically appropriate to address specific projects. The current proposals do not provide guidelines to support this selection of RE practices. Trying to address this problem, this thesis work has developed a general RE process that embeds a minimal set of RE best practices and includes variability points. This process can be tailored according to the project characteristics, which have been captured through a project context meta-model. It includes several project attributes (e.g. project type, application domain, customer type, project duration, etc.) that they have been obtained from the empirical observation of various SSE in Chile. Once developed the RE general process for SSE, we used a MDE tailoring approach to support the adaptation of the RE process according to the characteristics of particular projects. Two types of scenarios were used as support for the development and validation of the proposed approach: a) an academic scenario, where real software projects are undertaken by undergraduate students of the fifth year of Computer Science at the Universidad de Chile; and b) a software industry scenario, where four Chilean SSEs (that are part of the ADAPTE research project: www.adapte.cl) contributed in this research. The preliminary results indicate that the eighteen practices embedded in the RE general process are good enough to cover the RE practices needed for project types usually developed by SSEs. Considering that SSEs represent an important percentage of the software industry in Latin America, as elsewhere in the world (88% in Chile; 70% in Brazil; 78% in Canada; 94% in the USA; and 91% in Finland), the results of this research work could have a major impact.

Keywords: Requirement Engineering Practices, Requirement Engineering Process, Small Software Companies, Software Process Tailoring.

Analyzing Architectural Properties During Design of Architectures Using SysML Models

Daniel Cunha da Silva, Jair Cavalcanti Leite

Department of Computer Science and Applied Mathematics (DIMAp) Federal University of Rio Grande do Norte (UFRN)

danielcs@ppgsc.ufrn.br, jair@dimap.ufrn.br

Abstract. Decisions to design software architectures of software-intensive systems are driven mainly by functional and non-functional requirements. Requirements have a significant impact on the overall structure of the architecture. Thus, the decision-making performed by architects for tradeoff between different requirements is not, in most cases, a trivial task. This problem is recognized by the literature that says there is currently a lack of tools or techniques to assist the architect in this sense, and when there are, many of them are carried out on an ad hoc or through non-integrated meth-ods. In order to assist the design activity and solve the problem mentioned above, this work presents a way to anticipate possible conflicts among non-functional require-ments occasioned by architectural decisions taken by analyzing the properties of the architecture. To assist in this analysis were used software metrics associated with the properties. The idea is to verify that during the design of architecture, the decisions are taken that, consequently, generate adjustments in the architectural properties, affect the non-functional requirements. This effect can be measured by a metric associated with such architectural properties. Currently, work has raised the following architec-tural properties: number of elements, number of ports, number of connections, cou-pling and introducing security mechanisms. These properties, which are not unique to particular requirement, impact the requirements for performance, security, maintaina-bility and modifiability, and their respective measured by software metrics. In order to extract the architectural properties evaluated in architecture, this paper uses the mod-eling language SysML, which is a general purpose language that includes information about hardware, software, processes and stakeholders, extended UML. It allows mod-eling the behavior and design of a system and its environment, and its relationship with non-functional requirements using constraints and parameters. In this approach we use SysML to include the specification of requirements and traceability relation-ships between architectural elements that fit into our purpose. SysML allows the rep-resentation through notes and use the requirements diagram, architectural properties as derived requirements. The work was implemented as proof of concept in a web sys-tem for evaluating postgraduate courses developed by UFRN. The study showed that, through the use of SysML, changes in architectural properties affected their non-functional requirements of the system, assisting architects in decision-making. It was also verified that the analysis was facilitated by the use of SysML. As future work we intend to identify other architectural properties of other non-functional requirements and applying SysML to represent other elements involved in the design activity, such rationales, architectural patterns and styles, among others.

Keywords: Non-functional requirements, architectural properties, decision-making and SysML.

Tecnologias Facilitadoras de Aprendizagem Organizacional em Programas de Melhoria de Processo

de Software Davi Viana e Tayana Conte

Instituto de Computação – Universidade Federal do Amazonas (UFAM)

{davi.viana, tayana}@icomp.ufam.edu.br

Resumo. A Melhoria de Processo de Software (MPS) tem se tornado uma estratégia constante em organizações para aumentar a qualidade dos seus produtos. Essas orga-nizações partem da premissa que a qualidade do software pode ser elevada devido ao aumento da qualidade do processo de desenvolvimento. Contudo, é preciso criar me-canismos que institucionalizem a melhoria contínua dos processos. Esses programas envolvem diversos conhecimentos que podem ser novos para os membros da organi-zação. Um programa de MPS não deve ser visto como esforço único, mas sim como al-go evolutivo necessitando, assim, de constante aprendizagem. Desta forma, busca-se focar no seguinte questão de pesquisa: “Como facilitar a aprendizagem organizacional em programas de Melhorias de Processo de Software?”. A aprendizagem organizacio-nal é um processo de aperfeiçoar ações por meio de compreensão e conhecimento, am-pliando os conhecimentos existentes. Além disso, a aprendizagem organizacional con-siste em uma série de interações entre a adaptação no nível individual (ou de subgru-po) e adaptação no nível organizacional. Pesquisas tem sido realizadas buscando apoi-ar organizações que aprendem no contexto de aplicação, evolução e desenvolvimento de software. Essas pesquisas utilizam mecanismos tecnológicos para apoiar a aprendi-zagem, como wikis e sistemas de gerenciamento do conhecimento. Contudo, somente a tecnologia não é suficiente, uma vez que as pessoas estão no centro do processo de aprendizagem, pois são elas que criam e compartilham o conhecimento. Desta forma, esta proposta de Doutorado visa pesquisar tecnologias (técnicas, métodos, processos e ferramentas) que apoiem a aprendizagem organizacional em programas de MPS do ponto de vista dos profissionais de software, contando com as seguintes inovações: identificação do ciclo de vida das lições aprendidas/conhecimento da organização; questões que podem influenciar positivamente e negativamente a aprendizagem orga-nizacional em MPS; identificação e avaliação de meios de transferência do conhecimen-to. Como resultados obtidos até o momento, tem-se uma revisão sistemática da litera-tura (RSL), onde foi possível identificar formas de disseminar o conhecimento em or-ganizações de software. A revisão permitiu identificar também fatores que influenciam no compartilhamento de conhecimento, como a influência das comunidades de prática e treinamentos. Adicionalmente, foi realizado um estudo qualitativo que analisou co-mo as lições aprendidas de projetos são compartilhadas na organizações. A partir dos resultados da RSL, serão criados modelos visuais das tecnologias disponíveis com o objetivo de identificar melhores formas de facilitar a aprendizagem organizacional em organizações de software. Em seguida, as tecnologias identificadas e as novas tecnolo-gias propostas serão validadas através de diferentes Estudos Experimentais em Enge-nharia de Software e irão compor o arcabouço de tecnologias facilitadoras. Espera-se que essas tecnologias integrem-se às atividades do programa de MPS promovendo meios de aprendizagem dos conhecimentos necessários.

Palavras-chave: Melhoria de Processo de Software, Aprendizagem Organizacional, Engenharia de Software Experimental.

MoDre4CLouD - A Framework for Agile Requirements Modelling for Cloud Computing

Fernando Wanderley1 1Departamento de Informática – Faculdade de Ciências e Tecnologia – Universidade

Nova de Lisboa (FCT/UNL), Lisboa, Portugal.

f.wanderley@campus.fct.unl.di, p191@fct.unl.pt

Abstract. The complexity and social impact of emerging technologies is dramatically growing and poses new challenges to many engineering disciplines. Requirements En-gineering (RE) is not an exception, and will be our target one. Among these emerging technologies we highlight the strong growth of Cloud Computing (CC) adoption. CC represents a fundamental shift on how cloud applications need to be built and run. The different nature of cloud application development will drive changes in software de-velopment process frameworks, which will become more agile and practice-oriented. So, the traditional requirements models need to be flexible enough making them able to adapt quickly to environment dynamic behaviour changes (e.g. CC environment) especially related to context-aware systems. Another important factor is that there is much less work covering the usage of MDD for early requirements models in general and mainly for cloud requirements models in particular. It would be desirable to inte-grate dynamically and consistently these requirements to cloud architecture. More re-cently, models for requirements at runtime have been developed, aiming at managing the complexity of evolving software behavior while it is executing. Other works pro-poses an approach for the design of adaptive systems based on requirements and in-spired in control theory to monitor its requirements at runtime. Other proposals focus on requirements adaptive systems. KAOS-based proposals use linear temporal logic to specify requirements. For example, RELAX is based on SHALL statements and fuzzy branching temporal logic, which is also more complex than the approach we propose. Tropos-based proposals use the Belief-Desire-Intention model as reference architecture for cloud systems. Therefore, the main goal here is to propose an Agile Requirements Modelling Framework for Cloud Systems (MoDrE4Cloud), flexible (auto-configuration) and able to represent a set of dynamic variations in the context of cloud systems architecture. The main components of this framework are: (i) Agile require-ments elicitation with Mind Map Modelling used as a seed for generation of Goal-oriented models; (ii) Composition (Safe) of Partial goal Models representing the varia-bilities of goals and soft-goals; (iii) and then the architectural derivation from these models by MDD techniques. As the main contributions, we’ll have: (i) The representa-tion of variability of goals through partial goal-oriented model definition; (ii) the for-mal definition of the dynamic composition of these partial models to represent more flexible dynamic behavior; (iii) an agile process of generating these partial models through Mind Maps adoption; (iv) finally, to develop MDD techniques to build early RE models for cloud applications and from them derive architectural models.

Keywords: Goal-Oriented Requirements, Model-Driven Engineering, Agile Require-ments Modelling, Cloud Computing, Software Architecture.

Providing real-time decision support in flood management using volunteered information

Flávio E. A. Horita1, João Porto de Albuquerque1

1Department of Computer Systems, ICMC/USP – University of São Paulo (USP)

{horita, jporto}@icmc.usp.br

Abstract. The recent catastrophic events in Haiti, Pakistan and Chile in 2010, Queens-land in 2010-11, Christchurch and Japan in 2011 and the United States in 2012-13, high-lighted the growing problem of natural disasters and the numerous economic and so-cial damages caused. Within this context, floods have an important role, they occur when the water level exceeds its usual state, causing significant losses for both resi-dents and governments of the affected region. As a result, the Flood Management (FM) acquires pronounced importance as a measure of adaptation to climate change and the consequent increasing frequency in the occurrence of floods. Thus, FM is composed by three phases, pre-flood planning, emergency management and post-flood, all these phases aims to execute activities to improve the capacity of communities on resist to changes or adapt in order to achieve a new level of functioning or structure. In all its phases, information plays a key role in ensuring the reduction of impacts. Therefore, it is important that there are accurate, timely and complete information about the current state of environmental, social, structural and economic variables. Geographical infor-mation is particularly important in this context, since environmental changes and floods are always bound to a geographical context. Thus, Spatial Decision Support Sys-tems (SDSS) can be important technological resources. These are interactive systems designed to support one or more users in making decisions in a semi-structured deci-sion context. SDSS thus integrate technologies related to Geographic Information Sys-tems (GIS) with the features of Decision Support Systems (DSS). However, these tradi-tional systems in most cases use static and limited data to simulate or help on the deci-sion-making. Thus, it becomes necessary to develop procedures for their modification in accordance with changing conditions in the local emergency. In this context, VGI (Volunteered Geographic Information), i.e. information provided by the local popula-tion, who are smart, familiar with the area and equipped with appropriate devices, presents itself as an alternative to provide rich and updated information in order to facilitate community organization and reaction measures of official agencies. Never-theless, these voluntary information create a huge number information that highlight issues related with its, credibility, quality and integration. In this sense, this proposal aims to develop an approach to support the process of decision making in FM explor-ing the integration of VGI and SDSS focused on increasing the capacity of prevention, control and response of communities affected by floods. Among its expected results, we highlight the development of software tools and processes to integrate of available data, increase and analyze the quality of volunteer information and support the deci-sion making process by community members, agencies and official organizations.

Keywords: Spatial Decision Support Systems, VGI, Floods Management, Decision Support Systems, Crowdsourcing.

Do Language Constructs for Concurrent Execution Have Impact on Energy Efficiency?

Gustavo Pinto1 and Fernando Castor¹

1Centro de Informática – Universidade Federal de Pernambuco (UFPE)

ghlp@cin.ufpe.br, castor@cin.ufpe.br

Abstract. Multicore applications can use many different approaches to manage parallel execution. These techniques have different trade-offs in terms of performance and generality. In this study, we present an approach that aims analyze whether taking energy consumption into account creates additional trade-offs. Furthermore, since parallel programming enables programmers to run their applications faster, a common belief is that this application will also consume less energy. We call this as the “Race to idle” philosophy. In summary: faster programs will consume less energy because they will have the machine idle fast. In this poster, we demonstrate that it could not be necessarily true, at least for concurrent systems. Our study has analyzed the performance and energy consumption of three benchmark applications written in Java and Scala, using a number of techniques to manage parallel execution. We ran these experiments in a number of different configurations while varying a group of attributes (the number of threads in use, the JVM implementation and the clock frequency), in order to verify if these changes have impact on the application energy consumption, energy efficiency and performance. Our study shows that these factors could create great variations. For example, for a CPU-bound problem, the ForkJoin framework can perform better while using less energy. At the same time for a heavily IO-bound problem, it can consume about 10% more energy than a sequential implementation, although still 30% faster. Other techniques have great differences as well, and no single solution was the best in all aspects. Moreover, our experiments show that factors such as the nature of the problem to be solved, the CPU clock frequency, and the JVM implementation can create variations. The general conclusion that we can draw from this study is that yes, language constructs for parallel execution can impact energy consumption. Our approach indicates that it is possible to switch from one technique to another in order to consume less energy. These results lead us to conclude that it is very difficult to generalize a relationship between performance and energy consumption for concurrent systems. For these systems, winning the race to idle does not imply in more energy efficiency. This study is a step towards a better understanding of the interplay between energy efficiency and performance. Currently, however, it would still be very difficult to organize this information in a catalog. In the future, we intent to address this problem by conducting a broader-scoped study. The results of this new study will provide input for us to derive a catalog of energy code smell for concurrent software. Then we plan to proceed with the design of refactoring catalog that will enable application programmer to safely restructure their applications to use less energy.

Keywords: Energy-Efficiency, Language Constructs, Parallel Execution

Agrupamento Automático de Solicitações de Manutenção

Henrique S. C. Rocha1, Marco Túlio de Oliveira Valente 1

1Departamento de Ciência da Computação – Universidade Federal de Minas Gerais

hscr@ufmg.br, mtov@dcc.ufmg.br

Resumo. Manutenção de software é uma das fases mais relevantes no ciclo de vida de projetos de software. Alguns estudos apontam, por exemplo, que essa fase pode repre-sentar até 80% dos recursos alocados durante o ciclo de vida de um sistema. Tipica-mente, tarefas de manutenção são criadas a partir de requisições dos usuários de um sistema. Entretanto, em diversos sistemas, requisições de manutenção são tratadas de forma ad-hoc e isolada, à medida que as mesmas são criadas em um sistema de geren-ciamento de issues, como Bugzilla. Essa política contínua para tratamento de manuten-ções tem como desvantagem o fato de não propiciar ganhos de escala, que ocorrem ti-picamente quando requisições individuais são agrupadas, gerando-se projetos de ma-nutenção de software. Em outras palavras, uma abordagem mais adequada consiste no agrupamento de diversas requisições de usuários durante um determinado período de tempo, com a consequente criação de projetos de manutenção. Se esses projetos incluí-rem requisições similares, então os desenvolvedores poderão implementá-los de uma forma mais rápida e ágil. Como benefício final, tais políticas podem propiciar uma e-conomia de escala se comparadas ao tratamento clássico tradicional. No entanto, uma dificuldade de abordagens periódicas é que elas dependem de uma autoridade com conhecimento global sobre todo desenvolvimento do software, a qual será como res-ponsável pela criação anual dos projetos de manutenção. O estabelecimento de tal au-toridade é particularmente complexa em projetos código-aberto. Assim, o principal objetivo desse trabalho é propor uma abordagem automática e não-supervisionada pa-ra criação de projetos de manutenção agrupando requisições semanticamente simila-res. A abordagem proposta funciona conforme descrito a seguir: (i) cada requisição é inicialmente pré-processada usando-se técnicas de processamento de linguagem natu-ral, para, por exemplo, remover stop-words, tratamento de stemming, etc; (ii) dada uma nova requisição, se ela for semanticamente similar àquelas contidas em um projeto de manutenção ainda em aberto, então ela será alocada ao mesmo; (iii) caso contrário, cria-se um novo projeto para essa requisição. No estágio atual do trabalho, usa-se a si-milaridade do cosseno para verificar a similaridade entre as descrições textuais de du-as requisições de manutenção. Por fim, cada projeto de manutenção fica aberto por um período de tempo pré-definido. Após esse período, o projeto é fechado e designado para uma equipe de desenvolvimento. Para testar e avaliar a abordagem, estamos cri-ando um dataset sobre requisições de manutenção em sistemas de código aberto. Para validar a qualidade dos projetos propostos por nossa solução, pretende-se adotar uma variação do coeficiente de Jaccard, com o objetivo de expressar a existência de arquivos modificados em comuns pelas requisições incluídas em cada projeto. Se existirem mui-tos arquivos em comum, então isto é uma evidência de que nossa abordagem é capaz de introduzir ganhos efetivos de escala no tratamento de manutenções de software.

Palavras-chave: Manutenção de Software; Mineração de Texto; Economia de escala.

Evidence of Software Inspection on Requirement Specification for Software Product Lines

Iuri Santos Souza1,3, Gecynalda Soares da Silva Gomes1, Ivan do Carmo Machado1,3, Paulo Anselmo da Mota Silveira Neto2,3, Eduardo Santana de

Almeida1,3,4, Silvio Romero de Lemos Meira2,3

1Math Institute - Federal University of Bahia (UFBA) 2Center for Informatics - Federal University of Pernambuco (UFPE)

3Reuse in Software Engineering Group (RiSE), Brazil 4Fraunhofer Project Center (FPC) for Software and Systems Engineering, Brazil

iurisin@dcc.ufba.br, gecynalda@yahoo.com, ivanmachado@dcc.ufba.br, pamsn@cin.ufpe.br, esa@dcc.ufba.br, srlm@cin.ufpe.br

Abstract. Requirement engineering is the discipline responsible for capturing, specifying, and detailing the software and systems requirements, and their behaviors and interactions. In Software Product Line (SPL) engineering, it is also responsible for capturing, specifying, and detailing the variations. Requirements are usually specified in natural language, which might lead to issues such as ambiguity, inconsistency, omissions, and lack of clarity. This poster reports on a portion of the analysis of the effects of applying an inspection approach in the specification of functional requirements, in the light of an industrial SPL project, in which the inspection team assessed one hundred and forty-four requirements. We performed an empirical study in order to investigate and identify correlations, tendencies, define predictive models and estimate non-conformities. The results showed that issues of completeness and ambiguity presented the highest non-conformity occurrences, and that the inspection meeting was the task, which demanded most effort. Errors coming from domain knowledge understanding, specification, and organization, were the main responsible for the non-conformities. This poster is a good opportunity to show and discuss practical and open issues revealed by the industrial study and also it can raise questions for other contributions. This work is a step toward a precise guide for the inspection activity in SPL, and interesting directions can be revealed from the work started here.

Keywords: Software Product Line Engineering; Requirement Engineering; Software Inspection; Causal Analysis; Experimental Study

Fault Model-Based Variability Testing Ivan do Carmo Machado, Eduardo Santana de Almeida

Computer Science Department – Federal University of Bahia (UFBA), Salvador, BA, Brazil

ivanmachado@dcc.ufba.br, esa@dcc.ufba.br

Abstract. Software Product Line (SPL) engineering has emerged as an important strat-egy to cope with the increasing demand of large-scale products customization. Owing to its capability of systematically reusing software artifacts, SPL has provided compa-nies with an efficient and effective means of delivering products with higher quality at a reduced cost, when compared to traditional software engineering strategies. Howev-er, such a benefit does not come for free. SPL demands cost-effective quality assurance techniques that attempt to minimize the overall effort, while improving fault detection rates. Software testing, as one of the most important quality assurance techniques, have been largely explored to address this particular topic. An extensive analysis of existing techniques showed us that current SPL testing practices are mainly focused on han-dling variability at a higher level of abstraction, e.g., through the analysis of feature models, rather than carrying out about issues faced at the source code level. However, we believe that improvements in fault detection rates for variability testing in an SPL entail a more in-depth attention, that is, one should care about the variability imple-mentation mechanisms particularities, which traverses abstractions at source code lev-el. In this effect, this work analyzes the most occurring problems in variability imple-mentation, aiming at constructing a fault model for variability testing, to serve as a driver for test case generation. Our research goal is to analyze the test effectiveness im-provements enabled by the use of fault models in variability testing. We intend to build a defect classification scheme for variability implementation, that consists of the synthesis of evidence from three main sources: literature analysis; analysis of open source repositories; and case studies involving the development of SPL projects. The resulting scheme will serve as a basis for the fault model that will emerge. We are cur-rently underway on such synthesis of evidence. It has been supported by a series of empirical studies. The literature analysis aims at leveraging reports on commonly oc-curring error in the mechanisms. The analysis of open source repositories will aid in the identification of reported defects in variability implementation. Next, the case stud-ies, involving the use of variability implementation mechanisms in three different pro-gramming languages, namely Java, C, and the iOS platform, might strengthen our gen-eralizations. We plan to build the fault model by looking at software projects devel-oped in such different programming languages, and compare the outcomes, so as to enable further refinements.

Keywords: Software product line engineering, software testing, variability testing, fault model, empirical software engineering.

Beauty Technology as an Interactive Computing Platform

Katia Vega1 Hugo Fuks1 1Departamento de Informática – Pontificia Universidade Católica do Rio de Janeiro

kvega@inf.puc-rio.br, hugo@inf.puc-rio.br

Abstract. Wearables add more than physical, social and psychological variables. The accessibility, reliability and miniaturization of technology give the opportunity to embed sensors and actuators into wearables to increase the possibilities of interacting with the world. Nowadays we cannot think of Wearable Computers just as an exploration of the capabilities of devices into clothing but also about breaking through barriers of technology to make them useful to us in a way never imagined. This work introduces the term ‘Beauty Technology’ as an emerging field in Wearable Computers. We propose the use of products on the skin surface that hides electronics, are easy to attach and remove, are ergonomic to the human body and highlight the wearer’s personality. Imagine that you don't need a card for opening your office door, or for paying your bus ticket. Imagine that you don't need any ticket for entering to your show or movie session. Go and buy at the supermarket or rent a book at the library without any wallet or ID card, just point and have it, everything at the top of your finger: your nails. Beauty Technology Nails embed technology components into false nails in order to interact with the world in different ways and through different surfaces. They could create personalized gestures and musical instruments. These nails contain embedded magnets for amplifying the wearers’ capabilities by giving the sense of reading magnetic fields but also give them access to different objects with magnetic switches and interact with magnetic sensors. A RFID nails’ wearer made a secret combination of finger movements to open the door in the project called “Abrete Sesamo”. “Aquadjing” is another project that a Dj could change between different tracks by touching into the water with her RFID nails.

Blinking is something fascinating. It acts by the natural movement of your eyes and also gives us the possibility to understand different physical or psychological illness just with blinking. Even more, we could make gestures or create our own ones. What if we are not just could understand blinking but also activate the world with just a blink? Beauty Technology proposes the use of makeup for understanding blinking and other face movements. We used conductive makeup that connects sensors and actuators by the use of conductive materials that stick to the skin as well-defined eyeliners and eyebrows. Removable tattoos were used as aesthetics lights on the body skin and for enacting with the world by skin capacitance sensitivity. We also used black false eyelashes that were chemically metalized to react to blinking. As an example, a character called “Arcana” is a futuristic angel that communicates by amplifying her blinking and creates gestures that activates different music tracks and displays different images. Superhero is another example of the conductive false eyelashes and makeup used to levitate objects just by blinking.

Keywords: Beauty Technology, Wearable Computers.

A Methodology for the Elicitation of Usability Requirements in the Development of Web Applications

Luis Rivero and Tayana Conte

Instituto de Computação – Universidade Federal do Amazonas (UFAM)

{luisrivero,tayana}@icomp.ufam.edu.br

Abstract. Non-functional requirements play a fundamental role in software develop-ment because they specify software restrictions and how well the software shall per-form its function. Usability has been pointed as the most important type of non-functional requirement for guaranteeing software quality. In Web applications, usabili-ty is crucial because it can determine whether the application succeeds or fails due to its effects in the users’ productivity and satisfaction. Usability requirements describe needs for the outlined system, such as the ability to prevent errors and reduce mental workload. However, despite their importance, usability requirements are usually for-gotten or unconsidered during the software development process. The main reason for this lack of attention to usability requirements is that the technologies (techniques, processes or tools) that have been proposed to address them, are usually applied late in the development, where it is too expensive to develop usability requirements or fix usability problems. In this doctorate project, we aim to provide a solution for the late identification of usability requirements in Web projects. We are proposing an ap-proach that will integrate several technologies to understand the users’ needs and identify usability requirements in the beginning of the development process. First, we will perform a systematic literature review to understand the current state of the field of Web usability requirements, and identify research opportunities. We will use these results to propose a set of techniques for the elicitation of usability requirements that will allow software engineers to produce descriptive elicitation documents such as: textual specifications, mockups specifications and navigational models. Such docu-ments will guide the development team through the implementation of Web applica-tions meeting usability principals. Then, we will develop a tool support for the identi-fication and validation of usability requirements, and a monitoring system to examine how users perform tasks in low fidelity prototypes in order to identify further usabili-ty requirements. Also, to evaluate and evolve our approach, we will follow a research methodology based on empirical studies. During feasibility studies, we will evaluate the set of technologies by comparing them with other technologies that have been proposed for similar purposes. Thus, we will perform quantitative analyses and measure the accuracy (number of correct usability requirements), effectiveness (per-centage of elicited usability requirements), and efficiency (speed when performing the elicitation) of our approach. Also, the qualitative results from observational and indus-trial case studies will be used to improve the performance of our approach in order to be used in the software industry. Our goal is to provide our approach, allowing the software development industry to: (a) develop Web applications that are intuitive and easy to navigate; and (b) reduce the cost in the development of Web applications by addressing usability problems in the beginning of the development.

Keywords: Usability; Requirements Elicitation Technologies; Elicitation Artifacts; Web Applications.

Predicting Requirements Based on Organizational Changes

Marília Guterres Ferreira1 Julio Cesar Sampaio do Prado Leite1

1Pontifícia Universidade Católica do Rio de Janeiro, PUC - Rio, Brasil

{mferreira, julio}@inf.puc-rio.br

Abstract. Software evolution is a fact in industry life. Most of the changes in software-based systems are caused by changes in organizations from their need to adapt to a more and more competitive and dynamic environment. Those changes’ costs are far higher than the initial software development costs. In those software evolution pro-jects, most of the time the software has to be developed from scratch because the maintenance on the running system is very difficult and consequently expensive and time-consuming. This research comes from the realization that some of the problems could be avoided if some requirements could be elicited in advance. If when we devel-op new software systems, we try to anticipate the ways in which they might change, then the software can be modified more easily to implement the new requirements. As most changes in software come from organizational change, to be able to predict how the organization will evolve, we should first define what its current state is and then determine for which state it will go. In this context Organizational Semiotics seems to be a promising theory. Organizational Semiotics is a discipline that studies the use of signs and their effects on social practices. On this subject, there is Stamper’s School which proposes a set of methods, MEASUR research program, to the design of infor-mation systems based on the social-technical paradigm, considering social, political, cultural and ethical issues involved in understanding the problem in the process of re-quirements engineering. The general objective of this research is defining a strategy to anticipate requirements change and consequently make the software evolution less traumatic, less expensive and in less time. For this, we propose a 5-steps preliminary method. First we define the current state of the organization in two steps, the problems and then the semantic and norms, based in methods from Organizational Semiotics, PAM, SAM and NAM respectively. Then, based on the changes that the system might cause in the organization, the steps 3 and 4 define the future state of the organization, i.e., the new problems and the new requirements, again supported by OrganizationalSemiotics. Finally, the software-based system to be develop should address the current needs and be prepared for the ones anticipated, thus the software evolution will be less difficult. The strategy presented in this study is incremental, once the current model is defined, the next steps determine what is needed to be added, excluded or modified. It is an epistemic tool that aims to help in the design of the problems and requirements of the organization, either in the present and in the future. The expected results are to make the software evolution process less difficult and in a shorter time.

Keywords: Requirements Engineering, Software Evolution, Organizational Semiotics, Anticipating Requirements, Organizational Change.

ONTOREQ: Um Processo para Identificação e Classificação de Interesses em Documentos de Requisitos com base em Ontologias de Domínio

Paulo Afonso Parreira Júnior1,2

, Rosângela Aparecida Dellosso Penteado1

1Departamento de Computação – Universidade Federal de São Carlos (UFSCar) 2Curso de Bacharelado em Ciência da Computação – Universidade Federal de

Goiás/Câmpus Jataí (CAJ/UFG)

paulo_junior@dc.ufscar.br, rosangela@dc.ufscar.br

Resumo. Um software produzido com qualidade deve possuir módulos específicos

que agrupam um conjunto de requisitos relacionados (interesses). Entretanto, há al-

guns tipos de interesses para os quais essa clara alocação em módulos não é possível,

apenas com a utilização das abstrações usuais de engenharia de software, tais como

casos de uso, classes e objetos, entre outros. Tais interesses são denominados Interesses Transversais (ITs) e referem-se a requisitos de software que se encontram espalhados ou

entrelaçados com outros requisitos, o que pode dificultar o desenvolvimento e a evolu-

ção do software. Exemplos clássicos de ITs são logging, persistência, distribuição, entre

outros. Este trabalho está inserido no contexto da Engenharia de Requisitos Orientada

a Aspectos (EROA) e seu enfoque está na identificação de interesses, a partir do docu-

mento de requisitos do software, e na classificação desses interesses como “base” ou

“transversais”. Na literatura, há estudos comparativos de abordagens para EROA, os

quais mostram que o processo de identificação e classificação de interesses tem apre-

sentado baixa cobertura e precisão, principalmente em relação aos ITs. Isso se deve, em

grande parte, a dois problemas principais: i) a baixa qualidade do documento de re-

quisitos; e ii) a existência de interesses não explícitos no texto do documento de requi-

sitos, isto é, interesses que emergem a partir do relacionamento entre outros interesses.

Como exemplo desse segundo caso, pode-se citar o interesse de concorrência que, em

geral, pode emergir da necessidade de se atender, simultaneamente, a outros dois inte-

resses do software, a saber: segurança e desempenho. Este trabalho difere dos demais

existentes, pois tem como objetivo o desenvolvimento e avaliação de um processo se-

miautomatizado, denominado ONTOREQ, para identificação e classificação de inte-

resses em documentos de requisitos, com base em ontologias de domínio. A inovação

está na utilização de ontologias de domínio como base para minimizar os problemas

citados anteriormente. Para isso, propõe-se: i) criar ontologias específicas para ITs, com

o intuito de auxiliar na identificação de interesses implícitos no texto dos requisitos; e

ii) criar/reutilizar ontologias específicas para o domínio do software a ser tratado, para

verificar a qualidade de seus requisitos. A execução manual do processo proposto po-

de ser custosa, pouco escalável e propensa a erros, sendo assim, uma suíte de ferra-

mentas, denominada ONTOREQ-Toolkit, para automatização de algumas das ativi-

dades desse processo deve ser desenvolvida. A avaliação do processo ONTOREQ será

realizada por meio de estudos de caso, cujo objetivo é averiguar se a eficácia e a efici-

ência desse processo são maiores do que as das abordagens existentes na literatura,

quando o mesmo é aplicado a sistemas de software de diversos domínios e níveis de

complexidade. Para avaliação da ONTOREQ-Toolkit, quanto a sua utilidade e usabili-

dade, serão utilizados questionários confeccionados com base no modelo TAM (Tech-nology Acceptance Model).

Palavras-chave: Processo, Identificação e Classificação de Interesses, Engenharia de

Requisitos Orientada a Aspectos, Early Aspects, Ontologias de Domínio.

An Ecological Perspective Towards the Evolution of Quantitative Studies in Software Engineering

Rafael M. de Mello, Guilherme H. TravassosCOPPE/ PESC– Universidade Federal do Rio de Janeiro (UFRJ)

rmaiani, ght@cos.ufrj.br

Abstract. Context: Two of the most common external threats to validity in quantitative studies in software engineering (SE) are concerned with defining the population by convenience and nonrandom sampling assignment. Although these limitations can be reduced by increasing the number of replications and aggregating their results, the ac-quired evidence rarely can be generalized to the field. Objective: To investigate the state of practice of meta-analysis in SE and its limitations, intending to propose an al-ternative perspective to understand the relationships among experimentation, produc-tion, threats to validity and evidence. To propose and evaluate means to strengthen quantitative studies in software engineering and making them less risky due to popu-lation and sampling issues. Method: To use the underlying idea from the Theory of Food Chains to alternatively understand the impact of external threats to validity in the SE experimental cycle (experimental chains). Next, to accomplish an initial technical literature survey to observe basic features of secondary studies aggregating primary studies results. Third, to organize a set of experimental chain’s concepts and make ini-tial discussions regarding the observed secondary studies concerned with this meta-phor. Results: By applying the experimental chains concepts it was initially observed that, although important and necessary, most of the current effort in the conduction of quantitative studies in SE does not produce (mainly due to population/sampling con-straints) results strong enough to positively impact the engineering of software. It promotes an imbalance between research and practice. However, more investigation is necessary to support this claim. Conclusion: We argue that research energy has been lost in SE studies due to population/sampling constraints. Therefore, we believe more investigation must be undertaken to understand how better organizing, enlarging, set-ting up and sampling SE quantitative studies’ population by using, for instance, alter-native technologies such as social networks or other crowdsourcing technologies.

Keywords: population sampling, meta-analysis, food chains, experimental chains, evi-dence based software engineering.

Satisfying Requirements by Cloud Resources Using Models at Runtime

Raphael Aquino Gomes1,2 Fábio Moreira Costa1

1Institute of Informatics – Federal University of Goiás (UFG), Brazil 2Federal Institute of Goiás (IFG), Brazil

raphael@ifg.edu.br, fmc@inf.ufg.br

Abstract. Besides the definition of Non-Functional Requirements (NFR) in software development, another problem is to establish the hardware resources needed to meet these requirements. Cloud computing is a promising alternative for providing these required resources. However to enable and enhance the dynamic management of shared cloud resources two issues need to be addressed. They refer to how the cus-tomers of cloud services express their resource requirements and how additional re-sources are provided by the complementary use of external cloud infrastructures. To reduce these difficulties it is crucial to move some activities performed at design time to development and execution time. One strategy to achieve this goal is the use of models at runtime, which allows the customer to express their resource requirements based on the needs of the applications that will run on these resources; and a more precise management of available computational power. This work presents a group of solutions for requirements specification and resource discovery using cloud compu-ting. The general goal of this research proposal is to develop a specification language for NFRs as well the mechanisms needed to dynamically transform NFR specifications into a specification of the resources needed to host the application on cloud environ-ments. Several works propose the use of models@run.time but most of them focus on the development of architectural models of the system, especially in the self-adaptive systems area. Despite the existence of a series of works related to the specification of requirements for systems in general, the ones that are related to cloud environments are those that consider SOA environments. In our research the definition of the re-sources needed to run an application is built by the system based on application re-quirements specified by the user. After defining the necessary resources application deployment is performed taking into account both organization’s local resources and third party resources allocated from public clouds. Resource allocation is made accord-ing to the resource model generated. Initially, the private cloud formed by the organi-zation’s computing infrastructure is analyzed to check the possibility of admitting a new application given the resource model derived from thhe requirements specifica-tion. During application execution continuous monitoring is carried out to assess pos-sible changes in the application requirements and/or resource availability. In the case is made a requirements change, the resource specification is again generated and com-pared with the current one. If the two models are not compatible it is necessary per-form again the derivation of resources, its discovery and allocation. The implementa-tion of the proposed approach will be made in the form of a working prototype, which will be used to demonstrate and evaluate concepts, also serving as a basis for a subse-quent complete implementation.

Keywords: Requirements Specification, Models@run.time, Cloud Computing.

Understanding Lehman’s Laws of Software Evolution in Software Product Lines: An Experimental Study

Raphael Pereira de Oliveira1, Eduardo Santana de Almeida1, Gecynalda Soares da Silva Gomes2, Silvia Abrahão3 and Emilio Insfran3

1Department of Computer Science, 2Department of Statistics Federal University of Bahia, Av. Adhemar de Barros, s/n, 40170-110, Salvador, Brazil

{raphaeloliveira, esa}@dcc.ufba.br, gecynalda@yahoo.com

3Department of Information Systems and Computation Universitat Polite ̀cnica de Vale ̀ncia, Camino de Vera, s/n, 46022, Valencia, Spain

{sabrahao, einsfran}@dsic.upv.es

Abstract. Software Product Lines (SPL) has gained the attention of the software engi-neering community lately, however, the issue of how common, variable and product-specific assets evolve needs a broader investigation. This study evaluated the Lehman’s Laws of Software Evolution in an SPL industrial project in order to understand how the SPL assets evolve over the time. The industrial project has 45 modules and a total of 70.652 requests in the bug tracking system collected over 10 years. We applied the Augmented Dickey-Fuller Test and linear regression analysis to evaluate the statistical trends over the years of the collected data related to the laws. The results of the study showed that three laws were completely accepted (continuous change, increasing complexity and declining quality) and one was completely rejected (feedback system). The other laws were partly accepted or partly rejected, depending on the SPL asset (common, variable or product-specific). So far, the study has been evaluated in the medical domain with just one small (roughly 50 employees) company. Finally, besides the continuous change for all assets in an SPL, we found that complexity is raising and quality is decreasing in an SPL industrial project over the years. Based on this study, we intend to propose some guidelines for evolving an SPL.

Keywords: Software Product Lines; Software Evolution; Lehman’s Laws of Software Evolution; Empirical Study.

An Approach to Prioritize Code Smells for Refactoring Santiago Vidal, Claudia Marcos,

Andrés Diaz Pace ISISTAN Research Institute, UNICEN University, Argentina

svidal@exa.unicen.edu.ar, cmarcos@ exa.unicen.edu.ar, adiaz@ exa.unicen.edu.ar

Abstract. Software evolution and maintenance involve high costs in the development process, particularly as systems become larger and complex. A usual concern that makes system maintenance and evolution difficult is the existence of structural design problems, which were not sufficiently taken care of in early development stages. These design problems are often described as code smells. A code smell is a symptom in the source code that helps to identify a design problem. In this way, code smells allow de-velopers to detect fragments of code that should be re-structured, in order to improve the quality of the system. A technique commonly used to fix code smells is refactoring. Different semi-automated tools can be applied to identify code smells in a system. However, a major limitation of existing tools is that they usually find numerous code smells. This is a challenging problem for the developer, for a number of reasons. First, she can get overwhelmed by the amount of information to be analyzed. Second, the effort needed to fix all the code smells usually exceeds the budget that the developer has available for refactoring. Third, in practice, not all code smells are equally im-portant for the goals of the system or its health. Therefore, the developer has to manu-ally peruse the list of code smells and select a set of smells that will be fixed. In this context, the provision of tool support for assisting the developer to quickly identify high-priority code smells becomes essential. In our research, we propose a semi-automated approach called SpIRIT (Smart Identification of Refactoring opportunITies) that treats refactoring as a cost-effective activity. By cost-effective, we mean that the analysis and re-structuring efforts are driven by a handful of code problems considered as critical for the current system, so that solving those problems will positively con-tribute to the system quality but with a limited refactoring expenditure. Given an ob-ject-oriented system with a number of code smells, SpIRIT assists the developer in two tasks: (i) prioritizing the code smells, and (ii) suggesting candidate refactorings for each smell using a cost-benefit analysis. The novel aspect of our approach is the prioritiza-tion of code smells based on assessing their relationships with modifiability issues. Our assessment of a code smell instance is determined by the following factors: past com-ponent modifications, important modifiability scenarios for the system, and types of code smells. Regarding the suggestion of refactorings, SpIRIT seeks to determine refac-toring alternatives for each code smell of its ranking. After searching through the de-sign space of refactoring alternatives, the tool should assess a set of candidate refactor-ings in terms of the improvement that their application would produce in the system.

Keywords: Software evolution, Code Smells, Refactoring

Variability Realization in Service-Oriented Product Lines Tassio Vale1,2 Eduardo Santana de Almeida1,2

1Computer Science Department- Federal University of Bahia (UFBA) 2RiSE Labs - Reuse in Software Engineering

tassio.vale@ufba.br, esa@dcc.ufba.br

Abstract. The combination of Service-Oriented Computing (SOC) and Software Prod-uct Lines (SPL) together has started to receive attention from researchers and practi-tioners seven years ago, since SOC and SPL can address issues of each other. This com-bination results in a specific type of product line, called Service-Oriented Product Line (SOPL), and the area that studies the development of SOPLs is called Service-Oriented Product Line Engineering (SOPLE). Dynamic product reconfiguration involves making changes to a deployed product configuration at runtime, and SOPLE is a way to handle it for context-aware computing and adaptive systems scenarios. There is a lack of im-plementation proposals for SOPLs. Therefore, we propose an investigation of available implementation techniques for dynamic variability, aiming to create a systematic ap-proach for developing SOPLs. As first results, our systematic mapping study did not identified processes for implementing service-oriented product lines. In fact, there are studies addressing specific issues of SOPL implementation without looking the big pic-ture. On the other hand, we investigate existing variability implementation techniques trying to figure out their applicability in a SOPLE environment. As future work, we intend to perform an exploratory study by developing a testbed in order to identify similarities and differences among single system, service-oriented, product line and SOPLE implementations. After, evidence from the mapping study and testbed will guide the conception of the approach, that will be evaluated through a case study.

Keywords: Service-Oriented Computing, Software Product Lines, Service-Oriented Product Lines, Variability Implementation Techniques.

i

Using Run-Time Data and Maintenance Knowledge to Reduce Mean Time to Recovery

Thiago Araújo, Arndt von Staa Departamento de Informática, Pontifícia Universidade Católica (PUC-Rio), Brasil

{taraujo, arndt}@inf.puc-rio.br

Abstract. Even software systems developed with strict quality control may expect fail- ures during its lifetime. A maintenance team must identify these failures, diagnose them and correct the system state. In many cases some of these steps can be automati- cally handled by a self-healing mechanism. However, it is necessary to provide specific knowledge about the system to allow proper healing. This work proposes a self- hea-ling mechanism to correct the system state at runtime, which uses knowledge ac- qui-red while maintaining the software to incrementally build the knowledge base. This mechanism is composed by a new instrumentation technique to trace the system execu- tion, an inspection tool to aid in failures diagnosis, a contract validator to uses the di- agnosis results to detect future failures from known faults, and a recovery tool that may trigger routines based in the detected failures. The main contribution of this work is the knowledge representation that facilitates the autonomic steps integration. The instrumentation technique and the inspection tool were evaluated in a real software system, presenting low effort to instrument and diagnose failures. The contract verifier and the recovery tool will be evaluated in an on-going research.

Palavras-chave: software quality, software maintenance, fault tolerant systems, auto-nomic- computing, self-healing.

Identificação e Gerenciamento da Dívida Técnica na Evolução e Manutenção de Software Utilizando

Recursos de Visualização de Software Thiago Souto Mendes12, Rodrigo Oliveira Spínola3, Manoel Mendonça14

1Departamento de Ciência da Computação – Universidade Federal da Bahia (UFBA)2Departamento de Tecnologia da Informação – Instituto Federal da Bahia (IFBA) 3Departamento de Ciência da Computação – Universidade Salvador (UNIFACS)

4Instituto Fraunhofer-BA (Fraunhofer-BA)thiagomendes@dcc.ufba.br, rodrigoospinola@gmail.com, mgmendonca@dcc.ufba.br

Resumo. A qualidade de softwares que passam por manutenção frequentemente di-minui ao longo do tempo ao se considerar aspectos como sua estrutura interna, adesão a normas, documentação, e facilidade de entendimento para futuras manutenções. Li-dar com esta questão considerando a metáfora de dívida técnica, do inglês technical debt, tem ajudado alguns profissionais a debater questões associadas à manutenção de software. O conceito de dívida técnica contextualiza o problema das tarefas de manu-tenção pendentes (por exemplo, não execução de testes, refatoração de código penden-te, atualização de documentação pendente) como um tipo de dívida que traz um bene-fício a curto prazo para o projeto (normalmente em termos de maior produtividade ou menor tempo de liberação de versões do software), mas que poderão ter de ser pagas com juros mais tarde no processo de desenvolvimento. É comum que projetos de sof-tware incorram em dívidas durante o processo de desenvolvimento uma vez que pe-quenas quantidades de dívida podem aumentar a produtividade. No entanto, sua pre-sença traz riscos para o projeto e dificulta a gestão de projetos de software uma vez que os gerentes terão que decidir se a dívida será paga e, em caso positivo, quanto da dívida deve ser paga e quando. Mas, antes mesmo de gerenciar a dívida em projetos de software, é necessário identificá-la. Neste contexto, a compreensão do software pode ser considerada um pré-requisito para as atividades de manutenção. As técnicas de visualização de informação e de software têm sido utilizadas na Engenharia de Sof-tware como uma possível solução para a árdua tarefa de compreender, e ajudar a man-ter e evoluir sistemas de software. Entretanto, elas ainda não têm sido usadas como recurso para apoiar a identificação e acompanhamento da dívida técnica em projetos de software. Neste cenário, este projeto de pesquisa busca investigar soluções para o seguinte problema: aprimorar práticas de manutenção de software de forma que seja possível monitorar a qualidade do software em manutenção utilizando a metáfora da dívida técnica. Para isso, busca-se responder à seguinte questão de pesquisa: “É possí-vel utilizar técnicas de visualização de software para apoiar a identificação e gerenci-amento da dívida técnica em projetos de software?”. Ao final deste projeto de pesquisa espera-se alcançar os seguintes resultados: (a) Realização de um mapeamento sistemá-tico sobre dívida técnica e visualização de software; (b) Definição de técnicas de visua-lização de software que podem apoiar a identificação de dívida técnica em projetos de software;(c) Construção de um ambiente de gestão da dívida técnica que considere técnicas de visualização de software; (d) Estudos de casos referentes ao trabalhos exe-cutados e resultados analisados. O trabalho conta com a colaboração dos professores D.Sc Rodrigo Spínola (UNIFACS), Carolyn Seaman, PhD (UMBC, EUA), Forrest Shull, PhD (Fraunhofer-MD, EUA), Davide Falessi, PhD (Fraunhofer-MD, EUA).

Palavras-chave: Dívida Técnica, Visualização de Software, Engenharia de Software Experimental, Manutenção de Software, Evolução de Software.

Expansão Automática de Query baseada emvocabulário para busca de código

Adriano Carvalho de Paula1 Otávio Augusto Lazzarini Lemos1

1 Instituto de Ciência e Tecnologia – Universidade Federal do São Paulo (UNIFESP)

{adriano.carvalho, otavio.lemos}@unifesp.br

��� � ��������"�#����#��$'�"���"�!%��$����$��%$���*��� "-$���#�����%#�������6������ �"��� ���"��$�&�����#�������%$��1/�����&��%1/�����#��$'�"������ �"$��%��"���"�:�#������6�����������$�"�!%����� "���$�������$�&����������%#�������6�����3�� ����� �������� �������������������������������%#��"� �"�%����%�1/���# ��4��������%#%-"�����&� "��%"�"� ���&����"� �#� $�"��#� �(�$�#� %$���*���#� ���� �%$�"� ��� �6����� �� #�"� �%#�������##�� "� �#$����� �#!%�#� #�"-���&�#$������%������"�������� ������������� �����������������!%��%#��"���19�#���$"�� ���&"�#� �"���%���$�"��#�������#���������$"�"�6�����"���&��$�����������-#����3���������"��%$���$������$��#��7����#�����$7����#�������� ���&"�����&��+ �����������"������##����������������� "���#/������%#�������"������3�� �������#��"����%#�������6����� %����� �"���#$�#��� ����%���$3����� "���##�"�� ��� "��% �"�1/�� ��� �6����� !%�� %$���*�� ��#�#� ��� $�#$�� ����� ��$"���� �"���"�%��"�� ���������%#������������ ��$���3��#��%$���*����� ���&"�#����&����� ������ �$���������� ��� &����%�-"��� $���3�� �� ��$�� ����$�&����$�� #%�� ���$�&������� ���"������#�"-��� �����$����������($��#/�������""����$������ ������%� ������������ #��!%� � ������� ���������&����1/��������"������������� �������#����"�����*�1/������( �"����$�#������� �"$��� �1/�� "���##�����#�������:#$"������%��#�����"��%��1/���� 6#��"��%�1/����$3��������#��&��&���� ���"-�#�"���$��"��������$��������#�����#��&��&����$�����#��$'�"��� �"��$������������%�1/������%#$�#�

��������������� �%#��� ��� �6��������$��� "�%#�� ��� #��$'�"��� �( ��#/�� �%$��-$���� ��!%�")���%#�������6������%����� �"�$�#$��

Aprimorando a Verificação de Conformidade em Programas Utilizando a Metodologia Design by

Contract Alysson Milanez1 Tiago Massoni1 Rohit Gheyi1

1Departamento de Sistemas e Computação – Universidade Federal de Campina Grande (UFCG)

alyssonfilgueira@copin.ufcg.edu.br, massoni@dsc.ufcg.edu.br, rohit@dsc.ufcg.edu.br

Resumo. Programação por Contratos (Design by Contract - DBC) é uma metodologia que estabelece contratos entre módulos fornecedores (que proveem alguma funciona-lidade) e módulos clientes (que fazem uso da(s) funcionalidade(s) provida(s)), deter-minando os direitos e deveres de cada parte. Um dos benefícios de DBC é a verificação baseada em contratos, como forma de verificar a conformidade destes com os progra-mas. Neste contexto, verificação dinâmica é uma técnica comum, em virtude da verifi-cação por meio de provas formais ser de difícil escalabilidade. Com a verificação, é possível detectar violações dos contratos - não-conformidades (por parte do módulo cliente ou fornecedor). Uma vez detectadas, tais não- conformidades precisam ser cor-rigidas. As ferramentas que atualmente realizam verificação dinâmica de programas com contratos não fornecem informações ao programador acerca do que causou o pro-blema; informam apenas que há uma não-conformidade em determinado trecho do programa e o tipo da não-conformidade detectada. O processo para categorização é completamente manual: o programador, de posse da lista de não-conformidades pre-sentes em seu sistema vai ao código e inspeciona-o em busca de entender e solucionar o(s) problema(s) detectado(s). Com o intuito de tornar este processo mais prático, pre-tende-se obter como resultados do presente trabalho de Mestrado uma técnica semiau-tomática para a categorização de não-conformidades, uma implementação desta técni-ca para programas Java/JML - por meio do aprimoramento da ferramenta JMLOK já existente, e o relato de estudos de caso e experimentos avaliando o potencial desta fer-ramenta e de seu método de aplicação. Deste modo, estaremos contribuindo para o de-senvolvimento de sistemas que utilizem DBC como forma de aprimorar o projeto dos programas, e por consequência, sua qualidade geral. Recentemente propusemos um modelo para a classificação de não-conformidades, com suas causas prováveis. As ca-tegorias e suas causas são: invariant error - pré-condição fraca ou invariante forte ou restrição de valor nulo; precondition error - pré-condição forte ou pós-condição fraca; postcondition error - pós-condição forte ou pré-condição fraca; history constraint error - pré-condição fraca ou restrição forte ou restrição de valor nulo; evaluation error - quan-do uma expressão não pode ser avaliada em virtude do lançamento de uma exceção. Este modelo foi usado para manualmente classificar 79 não-conformidades detectadas pela ferramenta JMLOK em projetos JML de código aberto - mais de 29 KLOC e de 9 K linhas de especificação JML (que chamamos KLJML). As não-conformidades categori-zadas foram reportadas aos autores dos projetos; que nos reportaram que estão de a-cordo com nossa categorização. Atualmente estamos no processo de implementação do módulo de categorização na ferramenta JMLOK.

Palavras-chave: Design by Contract, verificação baseada em contrato, não-conformidade, categorização.

Validação Experimental da Abordagem SMarty para Gerenciamento de Variabilidade em Linha de Produto

de Software Anderson da Silva Marcolino, Edson A. Oliveira Junior

Departamento de Informática – Universidade Estadual de Maringá (UEM)

andersonmarcolino@gmail.com, edson@din.uem.br

Resumo. Este projeto se propõe a validação experimental da abordagem Stereotype-based Management of Variability (SMarty). SMarty é uma abordagem para gerenciamento de variabilidades em Linha de Produto de Software (LPS) baseada em UML. A abor-dagem de LPS vem sendo consolidado nos últimos anos como uma forma efetiva de reutilização de artefatos de software. LPSs baseadas em UML vêm sendo bem vistas pela comunidade com base na literatura existente. Ao utilizar modelos UML para iden-tificação e representação de variabilidades, a abordagem SMarty mantém um padrão já estabelecido pela OMG, visto que a UML é amplamente conhecida na indústria. Po-rém, nota-se a necessidade das abordagens existentes, para gerenciamento de variabi-lidades, serem validadas experimentalmente antes da transferência dessas para a in-dústria. Como a abordagem SMarty vem sendo consolidada nos últimos anos, com ba-se na sua adoção por diversos projetos, surge a necessidade de validá-la experimen-talmente. Para tanto, um conjunto de experimentos e possíveis replicações serão plane-jadas e conduzidas para SMarty em seus vários níveis de abstração como, por exemplo, casos de uso e classes. As principais contribuições deste trabalho referem-se à valida-ção experimental da abordagem SMarty fornecendo evidências de sua efetividade em LPSs baseadas em UML permitindo, assim, apresentar indícios à indústria para a sua efetiva adoção como uma forma padronizada e sistemática de gerenciamento de varia-bilidades e retorno de investimento, bem como, com base nos diversos estudos expe-rimentais propostos, desenvolver um framework de experimentação para abordagens de gerenciamento de variabilidade para LPSs baseadas em UML.

Palavras-chave: Linha de Produto de Software, Gerenciamento de Variabilidades, SMarty, Validação Experimental, UML.

Geração de Bechmarks para Avaliação de Diferentes Métodos de Desenvolvimento de Algoritmos para

Plataforma Android Andrws Aires Vieiras1 Cristian Maruan2 Felipe Marques2 Júlio C. B. Mattos2

1Instituto de Informática – Universidade Federal do Rio Grande do Sul (UFRGS) 2Centro de Desenvolvido Tecnológico – Universidade Federal de Pelotas (UFPel)

andrwsvieira@inf.ufrgs.br, {cmbosin, felipem, julius}@inf.ufpel.edu.br

Resumo. Em aplicações embarcadas, as características como, desempenho, consumo de energia, redução do tamanho de software e/ou hardware, entre outros aspectos, devem ser consideradas. Dentre os atuais sistemas embarcados, os dispositivos móveis com sistema operacional Android estão em pleno destaque no mercado atual devido ao grande número de dispositivos comercializados. Com isso se faz necessário avaliar a qualidade do software desenvolvido. Dentro os aspectos de qualidade de um softwa-re embarcado, pode-se destacar que um bom software embarcado é aquele aproveita da melhor forma os recursos computacionais disponíveis, deste modo uma análise de requisitos não funcionais durante o desenvolvimento de aplicativos para estes disposi-tivos é de extrema importância, tendo em vista que a energia destes aparelhos é forne-cida por uma bateria, logo um software que desperdiça energia (ou deixa de economi-zar) não é um software que apresenta um bom nível de qualidade, pois normalmente o consumidor deseja que a bateria de seu dispositivo móvel resista o maior tempo possí-vel. Neste contexto, este trabalho propõe a implementação de diversas aplicações (benchmarks) para a plataforma Android, fazendo uso de diferentes métodos, estrutu-ras e paradigmas de projetos de algoritmos, para então avaliar o impacto dessas técni-cas na plataforma Android. Para avaliar as aplicações que foram desenvolvidas neste trabalho, foram usadas ferramentas e aplicações de profiling (Traceview, PowerTutor, etc) que forneceram dados de energia consumida, potência dissipada, tempo de execu-ção, entre outros dados. Com base nos resultados alcançados foi possível determinar quais técnicas utilizadas durante o desenvolvimento de software foram mais eficientes do ponto de vista de desempenho, economia de energia e uso do de memória. Em ge-ral as estruturas recursivas demostram ter um desempenho inferior quando compara-dos aos demais, também foi comprovado que a substituição de cálculos extensos por tabelas estáticas apresenta ganhos de desempenho e energéticos bem significados com apenas um irrelevante acréscimo no uso de memória para os padrões atuais. Já quanto as Collections do Java quando submetidas ao benchmark desenvolvido neste trabalho, a que apresentou melhor performance foi a ArrayList. A contribuição dos resultados obtidos neste trabalho está no fato de apresentar diversas alterações no projeto de de-senvolvimento software que impactam diretamente no desempenho e consumo de energia de aplicações móveis para a plataforma Android, com isso prologando o tem-po de duração da bateria dos dispositivos móveis como smartphones e tablets. Como trabalhados futuros serão analisadas novas metodologias de desenvolvimento de sof-tware e novos benchmarks serão desenvolvidos para que novas análises possam ser realizadas. E ainda como principal futuro objetivo será desenvolvida uma ferramenta que dado um código fonte Android como entrada, otimize tal código a fim de obter um melhor desempenho e menor consumo energético.

Palavras-chave: Plataforma Android, Sistemas Embarcados, Sistemas Móveis, Técnicas de Desenvolvimento de Software, Análise de Requisitos não Funcionais.

Uso de sistemas baseado em conhecimento como facilitadores na elicitação de requisitos para

especificação usando iStar Cristiane Aparecida Lana1 José Luis Braga1 Antônio de Pádua Oliveira2

1Departamento de Informática – Programa de Pós-Graduação em Ciência da Computação (PPGCC) – Universidade Federal de Viçosa (UFV), Viçosa, MG.

2Departamento de Informática e Ciências da Computação – Universidade Estadual do Rio de Janeiro (UERJ), Rio de Janeiro, RJ.

cristiane.lana@ufv.br, zeluis@dpi.ufv.br, padua@ime.uerj.br

Resumo. O desenvolvimento de sistemas de informações cada dia mais complexos exige modelos que descrevem aspectos além das entidades e atividades. Pesquisas da década de 90 já apontavam a importância de capturar as intenções dentro de um contexto organizacional. Diversos são os métodos propostos para elicitação de Requisitos Não-Funcionais (RNF) entre eles está o Léxico Ampliado de Linguagem (LAL), que elicita, analisa e rastreia RNFs. Baseado nas técnicas de elicitação do LAL e de sistemas baseados em conhecimento da inteligência artificial, este trabalho visa a aplicação de sinônimos para melhorar a elicitação de requisitos não-funcionais, fornecendo elementos mais precisos para preenchimento dos frameworks do LAL. Este procedimento auxiliará um melhor entendimento do contexto do problema, e as intenções dos agentes que atuam em seu ambiente. Intenções podem estar explícitas e facilmente identificáveis em termos utilizados nas descrições de requisitos, ou podem estar implícitas no contexto, escondidas por detrás de sinônimos ou frases que representam intenções. Esta é a parte mais difícil da explicitação dos requisitos, e existem técnicas da inteligência artificial que podem conduzir o engenheiro de requisitos a olhar termos ou seus sinônimos dentro do contexto, levando-o a descobrir requisitos escondidos. O ambiente de desenvolvimento escolhido para aplicar as técnicas de inteligência artificial é o CLIPS - C Language Integrated Production System, que será utilizado para representar a base de conhecimentos sobre o problema, emprestando a máquina de inferência para auxiliar o analista de requisitos na elicitação. Inicialmente, será escolhido a forma de representar o conhecimento para gerar a base de sinônimos (BS) que conterá todos os RNFs (extraídos dos trabalhos de Lawrence Chung) e seus sinônimos. Após a elaboração da BS, será feita a descrição do modelo do LAL e sua descrição em formato de fatos (base de fatos – BF) utilizando a sintaxe do CLIPS. Em seguida será necessário criar regras que implementem o conhecimento e que será utilizado para verificar a ocorrência de sinônimos na BF, representado como regras de produção (regras de inferência) do CLIPS. Os resultados deste trabalho permitirá gerar modelos de Dependências Estratégicas (SD) e de Razões Estratégicas (SR) do iStar mais precisos, com menos ambiguidades.

Palavras-chave: Requisitos, Requisitos Não-funcionais, Clips, Léxico Ampliado de Linguagem, Engenharia de Software

Quantifying Usability of Domain-Specific Languages Diego de Lara e Albuquerque1,2 , Bruno Cafeo2, Alessandro Garcia2, Simone

Barbosa2, Silvia Abrahão3 António Nestor Ribeiro1 1Informatics Department, Minho University, Portugal

2Informatics Department, PUC-Rio, Brazil3Faculty of Computer Science, Universidad Politecnica de Valencia, Spain

pg19789@alunos.uminho.pt, bcafeo@inf.puc-rio.br, afgarcia@inf.puc-rio.br, simone@inf.puc-rio.br, sabrahao@dsic.upv.es, anr@uminho.pt

Abstract. A domain-specific language (DSL) aims to improve the maintainability of artifacts otherwise produced with general-purpose languages. However, the maintai-nability of the DSL artifacts and, hence, their adoption in mainstream software deve-lopment, is largely dependent on the usability of the language. More than a single DSL is often proposed to address the same software engineering problem. However, it is often hard to early identify their usability strengths and weaknesses if there is no gui-dance on how to objectively reveal them. Usability is a multi-faceted quality characte-ristic, which is challenging to quantify before a DSL is actually used by its stakehol-ders. There is even less support and experience on how to quantitatively evaluate the usability of DSLs used in software maintenance. In this context, this paper reports a study to compare the usability of textual DSLs under the perspective of software main-tenance. A usability metrics suite was developed based on the Cognitive Dimensions of Notations (CDN) framework. We compared two textual DSLs to detect architectural degradation problems through several versions of two evolving systems. The results suggested the proposed metrics were useful: (1) to early identify the DSL usability li-mitations to be addressed, (2) to reveal specific features of the DSLs favoring software maintenance tasks, and (3) to successfully analyze eight usability dimensions that are critical in many DSLs.

Keywords: DSL, architectural degradation, code anomalies, usability, maintenance

i

Using Interest Management to Improve Load Balancing in Distributed Simulations

Felipe C. Bacelar1, Carlos J. P. de Lucena1 Pierre Bommel2

1Departamento de Informática, Pontifícia Universidade Católica (PUC-Rio), Brasil 2CIRAD, Unidade Green, Montpellier, France

{fbacelar, lucena}@inf.puc-rio.br, bommel@cirad.fr

Abstract. This paper presents an approach to distribute an agent-based simulation over a network of computers. The developed work aims at improving the load balancing of the simulation distribution. In order to reach such objective, we propose to use an In- terest Management technique presented by Brian Logan and Georgios Theodoropoulos who proposed to distribute a simulation by dynamically partitioning the environment according to the Interest of the agents. In order to assess its efficiency, we have re- im-plemented this model using the distribution mechanisms provided by some of the main multi-agent system platforms.

Palavras-chave: Load Balancing; Interest Management; Spheres of Influence; Distribu-ted Simulation; Multi-agent Systems.

Choosing between automatically tailored and pre-defined software processes

Felipe González Martínez, María Cecilia Bastarrica Computer Science Department, Universidad de Chile, Chile

fgonzale@dcc.uchile.cl, cecilia@dcc.uchile.cl

Abstract. Software companies define processes to guide their development activities. This de- finition is complex and expensive, and still no single process is efficient to deal with different projects. The company has a series of alternatives: either use the same process for all projects being inefficient and producing low quality products, or having project specific processes. Coun- ting on project specific processes may be achieved through different strategies. We will consider having a series of pre-defined processes, or tailoring a general process in order to adapt it to the characteristics of each project. For the last years we have developed a MDE-based solution for optimal process tailo-ring according to the project context. However, this solution is complex and we won-der when it is worthy to apply it. Even though we assume that pre-defined processes may not be optimal for certain cases, their definition and maintenance simplicity may still be cost- effective. Moreover, we hypothesize that automatically tailoring is only convinient when there is the need for a large number of pre-defined processes. There is a series of stategies that have been proposed for dealing with process tailoring. Among them we can find: template-based tailoring (e.g., Crystal Methodology), framework-based approaches (e.g., RUP), constructive approaches (e.g., Situational Method Engi-neering), and self-emerging process tailoring (e.g., agile methods). However there is no empirically based comparison about the convenience of using one or another. We have been already developed and applied the MDE-based tailoring in real world companies, so we have already defined Method Libraries. For a particular company, we will pre-define three different processes and specify the project context that fits each of them. Then, for three pro- jects, we will define their context, and we will follow both approa-ches comparing the results. For the MDE-based tailoring, the optimal context-adapted process will be computed. For selecting one of the pre-defined processes, the project context will be compared with the context of each pre-defined process, and we will se-lect the one whose distance is the shortest. Both approaches will be compared accor-ding to two dimensions. On the one hand, the productivity of the resul- ting process, i.e., number of unnecessary process elements included, and on the other hand the diffi-culty of either selecting the appropriate process or computing the optimal one. The most commonly tailoring approach used in industry is manually tailoring processes, that is expensive and error prone. Automatically tailoring and pre-defined processes are more consistent ways of dealing with this issue. Our work intends to clarify when it is better to apply each of them.

Palavras-chave: Software process tailoring, model-driven engineering.

A New Approach for Mining Software Repositories using Semantic Web Tools

Fernando Silva1 Daniel Schwabe1 1Department of Informatics, PUC-Rio, Rio de Janeiro, Brazil

ffreitas@inf.puc-rio.br, dschwabe@inf.puc-rio.br

Abstract. The Mining of Software Repositories is a field of research that extracts and analyzes information available in software repositories,such as version control systems and issue trackers. By the fact that these repositories have distinct access forms and different formats, the research community has mirrored the artifacts present in these sources into a centralized relational database. However, this complicates the infor-mation sharing between the various research groups, because it imposed a single , in-flexible and centralized data schema. On the other hand, the Semantic Web technolo-gies such as RDF representations, ontologies based on OWL and SPARQL queries have enabled this and other information domains to represent the same information that would be represented by a relational mode. One of the main advantages of this new model is that these tools are designed to deal with decentralized information, but in allowing the integration and extension of the information in a simpler manner. Anoth-er advantage is the fact that these technologies provide for semantic expressiveness not hitherto exists in other forms of representation, allowing specialized tools to check the logical consistency of the data and perform derivations of new facts from existing facts. The objective of this work is to extend the existing approaches that use Semantic Web tools to mine information not considered in these works. This extension will be through the introduction of a set of ontologies and a extraction platform capable of ex-tracting and representing these new data. One of these information is the relationship between revisions of version control and the changes that occur in the Abstract Syntax Trees of files modified by these revisions. Additionally, this new approach also allows modeling the interdependence of software projects, their licenses and extracting in-formation from builds generated by continuous integration tools. The validation of this approach is demonstrated through a set of questions that are asked by developers and managers during the execution of a project and have been identified in various works in the literature. We show how these questions were translated into SPARQL queries and how this approach can answer the questions that are not answered or are partially answered in other tools.

Keywords: Software Maintenance, Semantic Software Engineering, Software

Repositories

i

Análise do impacto de mudanças no esquema de dados com a utilização de padrões de persistência

Gabriel Fernandes Pereira1 Alexandre Torres¹ Marcelo S. Pimenta¹ Renata Galante¹

1Instituto de Informática – Universidade Federal do Rio Grande do Sul (UFRGS)

gmfvpereira@inf.ufrgs.br, atorres@inf.ufrgs.br, mpimenta@inf.ufrgs.br, galante@inf.ufrgs.br

Resumo. O uso de linguagens orientadas a objetos, em conjunto com bancos de dados relacionais, cria a necessidade da utilização de ferramentas de mapeamento objeto-relacional (ORM), de modo a contornar as diferenças geradas pelos distintos paradig-mas dessas tecnologias. As ferramentas ORM implementam um ou mais padrões ar-quiteturais para persistência de dados, que foram catalogados por diferentes autores. Cada padrão de mapeamento possui características que indicam a sua aplicabilidade em um determinado contexto. Padrões mais simples, costumam ser indicados para sof-twares pequenos, e padrões mais elaborados são indicados para softwares de maior porte. A indicação do padrão de mapeamento a ser utilizado é fortemente baseada na quantidade de esforço que o padrão irá gerar para sua implementação e sua manuten-ção ao longo do ciclo de vida do software. Visto que a manutenção é considerada a fase mais custosa de um software, a escolha de um padrão que minimize os recursos utili-zados nessa fase é um ponto importante para o gerenciamento do software. Deste mo-do, propomos uma análise empírica, realizada com estudo de caso, para a avaliação do comportamento dos padrões de persistência frente a determinadas modificações em esquema de dados. Analisaremos o quanto um padrão de persistência consegue isolar a lógica de domínio de modificações desnecessárias. Estudaremos o histórico de sof-twares através de ferramentas de versionamento, de modo a buscar determinadas mo-dificações em esquema de dados, e assim, analisar o seu impacto ao restante do softwa-re. Para a mensuração do impacto causado pela modificação do esquema de dados, se-rá realizado um estudo analítico e manual, de modo a interpretar os tipos de modifica-ções existentes. Temos como objetivo realizar um estudo inicial para identificação do impacto que cada tipo de modificação de dados pode causar ao restante do software. Com isso, teremos uma base para uma avaliação empírica automatizada que verificará o comportamento em aplicações de maior porte. Ao final do trabalho pretendemos cri-ar uma classificação do impacto causado por cada tipo de modificação no esquema de dados, auxiliando assim na análise de impacto que uma modificação causará ao sof-tware.

Palavras-chave: Engenharia de Software, Padrões, Orientação a Objetos, Banco de Da-do Relacional, Manutenção de Software.

Software Remodularization Analysis Using Semantic Clustering

Gustavo Jansen de Souza Santos, Marco Tulio Oliveira Valente1

1Departamento de Ciência da Computação – Universidade Federal de Minas Gerais (UFMG)

{gustavojss, mtov}@dcc.ufmg.br

Abstract. As a software system evolves, it gets larger and complex, and its structure erodes unless work is explicitly performed. This slow phenomenon, called architectur-al erosion, leads to high costs with maintenance accumulating over time. Future mod-ifications and improvements will take more time to understand which part of the sys-tem needs to be modified. Also, these changes may require other changes that were not planned, in scattered parts of the system. Remodularization consists in a sequence of modifications to organize a system’s architecture into a set of modules. The state of the art recommends the use of structural, static dependencies in source code to access the quality of a modularization. Thus, a new architecture is applied if it improves co-hesion inside the modules and reduces the coupling between classes of different mod-ules. However, recent work started to argue about this structural evaluation, stating that coupling and cohesion do not seem to be the dominant driving forces when it comes to modularization. In our work, we propose that software architects consider conceptual relation of classes, extracted from the identifiers and comments that define vocabulary of a software system. We used Semantic Clustering, an approach that ex-tracts a set of semantic clusters, i.e. sets of classes with similar vocabularies. Semantic Clustering combines Information Retrieval techniques for text manipulation and Hie-rarchical Clustering algorithms to retrieve semantic clusters. In our work, the vocabu-lary is obtained from the identifiers in a class, including attributes and methods, and also from comments. We also use a set of conceptual quality metrics proposed in re-cent work; these metrics measure the semantic information presented in the vocabu-lary. Next, we applied Semantic Clustering in two versions of a given remodulariza-tion effort (before and after) in order to analyze the evolution of semantic clusters in comparison to the system’s architecture. Our case study consists in two remodulariza-tions of JHotDraw, both driven by its own developers. We compared the semantic clusters and, with the support of conceptual quality metrics, we concluded that the semantic clusters are more spread over the JHotDraw’s architecture as new packages were created. On the other hand, these clusters are more concentrated in both existing and new packages. Thus, the semantic clusters are closest to the package structure af-ter remodularization tasks. This fact is an indication that developer’s efforts in remo-dularization may consider conceptual aspects, by splitting and grouping architectural entities regarding the intent semantics expressed in their vocabularies.

Keywords: Software Architecture, Software Maintenance, Information Retrieval.

APIMiner 2.0: Recomendação de Exemplos de Uso de APIs usando Regras de Associação

Hudson Silva Borges1 Heitor Augustus Xavier Costa2 Marco Tulio Valente1

1Departamento de Ciência da Computação – Universidade Federal de Minas Gerais 2 Departamento de Ciência da Computação – Universidade Federal de Lavras

hsborges@dcc.ufmg.br, heitor@dcc.ufla.br, mtov@dcc.ufmg.br

Resumo. Atualmente, a utilização de código de terceiros no processo de desenvolvi-mento de sistemas consolidou-se como uma prática comum. Geralmente disponíveis na forma de bibliotecas ou frameworks, a utilização desse tipo de código ocorre por meio de uma API (Application Programming Interface). Entretanto, a inexistência de do-cumentação adequada leva a um contexto em que a compreensão e domínio de APIs têm se mostrado cada vez mais difícil. Nesse contexto, propõe-se o sistema APIMiner 2.0, que estende a plataforma APIMiner utilizando regras de associação envolvendo elementos de APIs para extração e agregação automatizada de exemplos de uso em documentação, disponibilizada no formato JavaDoc. Dentre as principais característi-cas da abordagem implementada pelo sistema, destacam-se: (i) fornecimento de exem-plos de uso que envolvem mais de um método da API, com o objetivo de expressar diferentes formas de usar essa API. Essa característica faz com que os exemplos apre-sentados sejam mais úteis aos desenvolvedores que exemplos de uso incluindo méto-dos únicos; (ii) a utilização de diversos artifícios para melhorar a legibilidade de exem-plos de uso obtidos por meio de técnicas de slicing estático. Por exemplo, problemas como a não identificação de variáveis em um slicing tradicional são contornados com a inserção de declarações abstratas de variáveis; (iii) a utilização de técnicas de minera-ção de dados, mais precisamente mineração de conjuntos de itens frequentes e regras de associação, com o objetivo de identificar co-ocorrências de chamadas de métodos de uma API. Por exemplo, suponha que um determinado usuário de uma API solicite exemplos de uso para o método M1() e que no processo de mineração, identificou-se que na maioria das vezes esse método é utilizado em conjunto com o método M2(). Assim, a solução proposta recomenda exemplos de uso que envolvem esses dois mé-todos aos usuários. Uma instanciação da plataforma para a API do sistema operacional Android está publicamente disponível na web (www.apiminer.org) e tem recebido milhares de acessos mensais. Ela dispõe de 287.263 exemplos de uso extraídos de 155 projetos, sendo 21.598 exemplos relativos a 1.952 padrões de uso extraídos para a API do Android.

Palavras-chave: API, Compreensão de Programas, Regras de Associação, Slicing de Programas.

Tratando Exceções em Aplicações Android Juliana Oliveira1 Nélio Cacho1 Thiago Sena1

1Departamento de Informática e Matemática Aplicada – Universidade Federal do Rio Grande do Norte (UFRN)

juliana@ppgsc.ufrn.br, neliocacho@dimap.ufrn.br, lord.sena@gmail.com

Resumo. O crescente uso de dispositivos móveis tem impulsionado o desenvolvimento de aplicações que fornecem diversos serviços para auxiliar à população nas atividades cotidianas, esses serviços vão desde uma aplicação que funciona como agenda ou que recomenda locais turísticos. A plataforma Android tem se estabelecido como principal sistema operacional usado por esses dispositivos. Tal plataforma provê um conjunto de abstrações que suportam o desenvolvimento dos mais variados tipos de soluções. Uma destas abstrações é chamada de Intent. O Intent é um mecanismo de envio de mensagem que possibilita a comunicação de uma aplicação com os recursos fornecidos pelo sistema operacional Android. Por exemplo, através dos Intents, componentes po-dem trocar mensagens ou inicializar serviços. No desenvolvimento de aplicações An-droid os problemas conhecidos com tratamento de exceção da linguagem Java persis-tem e, adicionalmente a plataforma possui algumas limitações de robustez, principal-mente em relação aos Intents. Por exemplo, não existe um contrato explícito entre o emissor e o receptor de um Intent, não existe um formato para os dados que um Intent pode enviar e receber, e finalmente não existe uma definição das mensagens que são consideradas inválidas. Portanto a plataforma é vulnerável e não fornece tratamento de exceção adequado entre seus componentes. Isto possibilita a ocorrência de muitas exceções não checadas que podem gerar erros e o possível crash da aplicação, o que pode tornar a experiência do usuário muito negativa. Temos como objetivos deste tra-balho: (a) definição de um modelo de tratamento de exceções específico para aplica-ções Android, definindo abstrações para separação do código normal do código excep-cional, nesse estágio iremos definir se utilizaremos Java Annotations para descrever tais abstrações, ou se as mesmas deverão ser incorporadas à linguagem, este modelo deve levar em conta às características inerentes à plataforma, no que diz respeito às abstra-ções definidas pela mesma, sua característica assíncrona e o seu ciclo de vida; (b) im-plementação de um mecanismo de tratamento de exceções baseado no modelo propos-tos para a linguagem de programação Java; (c) aplicação do modelo em, pelo menos, duas aplicações Android; (d) avaliação da solução proposta por meio de analise de ro-bustez.

Palavras-chave: Tratamento de exceções, Android.

Reengenharia por Exemplos: Uma proposta para evolução de sistemas legados baseada em

comportamento Laís Berlatto, Duncan Dubugras A. Ruiz, Sabrina Marczak

Faculdade de Informática – Pontifícia Universidade Católica do Rio Grande do Sul

lais.berlatto@acad.pucrs.br, duncan.ruiz@pucrs.br, sabrina.marczak@pucrs.br

Resumo. Sistemas legados representam um grande problema para empresas no que tange à mantenabilidade e integração de novas soluções, pois possuem um alto risco associado, principalmente ao processo de reengenharia. Exemplificando, incluir uma nova funcionalidade no sistema pode gerar erros pela falta de conhecimento da de-pendência entre funcionalidades. Essa falta, poderia ser minimizada se existisse docu-mentação, o que raramente ocorre, visto que o conhecimento em geral está centralizado em poucas pessoas. Sendo assim, este trabalho tem por objetivo construir uma propos-ta que por meio de especificações executáveis escritas colaborativamente, as quais ex-pressam os requisitos do sistema através de exemplificações do comportamento espe-rados deste, sejam capazes de envolver e guiar todo o projeto de reengenharia em um processo de validação contínua. Este processo será suportado por um sistema de métri-cas de controle, garantindo assim a consistência e o conhecimento agregado ao softwa-re legado também à sua evolução. Estas especificações são escritas em linguagem natu-ral possibilitando redução na lacuna de comunicação entre membros da equipe e au-mentando a concisão do desenvolvimento, formalizando uma única fonte de verdade, construindo em conjunto uma documentação viva, que quando executada, é capaz de garantir a integração de um novo módulo ao sistema e que este possuirá o comporta-mento equivalente ao substituído. Para realizar este processo, propõe-se uma análise modular, tendo em vista o acoplamento de módulos para focar o redesenvolvimento produzindo o mínimo produto viável, derivando-se os exemplos do comportamento do sistema através da análise de satisfatibilidade dos requisitos do negócio, provendo assim uma otimização da arquitetura do sistema em relação ao anterior e, também, o alinhamento entre especificações e esta nova arquitetura. A validação contínua verifica de maneira eficiente se o sistema realiza o que as especificações delimitam. As especifi-cações representam um meio de manter a documentação relevante e confiável com um custo menor, pois a informação do trabalho a ser executado é produzida sob demanda, refletindo positivamente no processo futuro de evolução evitando problemas causados pela falta de conhecimento compartilhado sobre o sistema. Para verificar a viabilidade da proposta, visa-se conduzir um estudo de caso empírico, que implantará no(s) proje-to(s) selecionado(s), compreendido(s) dentro de categorias que eliminam parcialmente possíveis limitações para a aplicação da proposta, um método que representa a propos-ta teórica apresentada. Neste estudo, pretende-se verificar se os passos definidos pelo método são viáveis em um cenário real. Os resultados serão avaliados com base nas métricas especificadas visando identificar se o comportamento mensurado da nova aplicação é equivalente ao do antigo sistema. Espera-se que este método seja capaz de otimizar o tempo para a compreensão dos reais requisitos, garantindo um alinhamento com a arquitetura, propiciando que a migração do sistema ocorra com sucesso e com um menor risco e custo agregado.

Palavras-chave: sistemas legados, reengenharia, especificações executáveis, desenvol-vimento guiado por exemplos, métricas.

Análise de Mutantes: Uma Abordagem Baseada no Tamanho do Mutante

Leonardo da Silva Sousa1, Auri Marcelo Rizzo Vicenzi1, Cássio Rodrigues1, Márcio Delamaro2

1Instituto de Informática – Universidade Federal de Goiás (UFG) 2Departamento de Sistemas de Computação (SSC) - Universidade de São Paulo

(USP)

leonardosousa@inf.ufg.br, auri@inf.ufg.br, cassio@inf.ufg.br, delamaro@icmc.usp.br

Resumo. O Teste de Software é imprescindível caso queira se alcançar e garantir a qua-lidade do software desenvolvido. Dessa maneira foi proposto algumas técnicas para se testar um software, entre tais técnicas existe o Teste de Mutação. No Teste de Mutação utiliza-se de defeitos comuns no processo de implementação para poder gerar os re-quisitos de testes. A técnica consiste em gerar um conjunto de programas alternativos, chamados de mutantes, que se diferem do programa original em um determinado pon-to no código. Esse ponto de diferença representa um defeito no programa. Após a cria-ção dos mutantes, casos de testes são aplicados no programa original e nos mutantes com o objetivo de verificar se os casos de testes são capazes de evidenciar a diferença de comportamento entre o programa original e cada mutante. Essa abordagem de teste se destaca devido sua eficácia em medir a qualidade do software, entretanto ela sofre com o alto custo computacional necessário para sua execução. Existem algumas abor-dagens que visam diminuir o custo do Teste de Mutação. O objetivo deste trabalho é diminuir o custo dessa técnica analisando os mutantes através de outro ângulo. A ideia é utilizar a caracterização semântica de defeitos, propostos por A. J. Offutt, para criar um conjunto de casos de testes baseado no tamanho do mutante. O tamanho de um mutante é definido neste trabalho como sendo a quantidade de casos de testes que são capazes de matar o mutante. Espera-se comprovar que um mutante considerado pe-queno seja mais significativo do que um mutante grande, pois apenas poucos casos de testes são capazes de matá-lo. Dessa maneira acredita-se que esses casos de testes que matam os mutantes pequenos são bons candidatos para enriquecer o conjunto de casos de teste. Tendo sucesso em montar um bom conjunto de casos de testes apenas basea-do no tamanho do mutante pretende-se, posteriormente, utilizar o tamanho do mutan-te como base para encontrar apenas operadores de mutação que produzam mutantes que são pequenos. Restringir os operadores de mutação baseado no tamanho do mu-tante é a maneira proposta aqui para tornar o Teste de Mutação mais barato, conse-quentemente mais acessível.

Palavras-chave: análise semântica, tamanho e teste de mutação.

Automated Construction of Cookbooks for API's Using Questions & Answers Social Network Sites

Lucas Batista Leite de Souza1 Marcelo de Almeida Maia1 1Computer Science Department – Federal University of Uberlândia (UFU)

lucas.facom.ufu@gmail.com, marcmaia@facom.ufu.br

Abstract. Developers of reusable software elements—such as software libraries—generally have the responsibility to provide high-quality and comprehensive docu-mentation to enable effective software reuse. We consider a library as a implementa-tion of some functionality that is meant to be reused by other developers. In case of object-oriented programming languages such as Java and C#, a library consists of a coherent collection of classes. In general, a library has two parts: the public interface and the private implementation. The former contains software elements (e.g. classes and methods) that other developers are allowed and expected to use; this part is called the application programming interface or API. The latter implements the library’s functionality, but is usually not exposed to the library’s users. The API documentation, when exists, usually has poor quality and lacks examples and explanations. Recently, a new culture and philosophy emerged and they are changing the characteristics of software documentation. This change is the result of a broad set of accessible social media technology (wikis, blogs, Questions and Answers sites, forums). The documen-tation available in those kind of social media is called crowd documentation, that is, a type of documentation where a big number of contributors, the crowd, evaluates and contributes for the set of documents. One of the most important social media technolo-gy is the Question & Answer site Stack Overflow1. Unlike traditional documentation, where the collection of resources (e.g., specifications and code examples) are under-standably organized and explicitly linked to the elements of the API, the crowd docu-mentation is created implicitly, without any organization or comprehensive links ex-plicit to the elements of the API. In the case of Stack Overflow, the information related to a particular subject is scattered over several different threads. The goal of this work is to use the data available in the Stack Overflow for the construction of cookbooks for API's. Each cookbook will be formed by a set of items (recipes) in which each one cor-responds to a relevant concept related to one API. Each recipes will be linked to few threads from Stack Overflow. To build the tutorials, we will construct two subsystems: the first one will be responsible for analyzing the questions and answers in Stack Over-flow to select the topics that will constitute the tutorial. The second subsystem will be responsible for selecting the information that each topic will contain, i.e., the most rel-evant threads related to its concept. For the evaluation of the created cookbooks we will perform an experiment with human subjects.

Keywords: API, Software Documentation, Crowd Documentation, Social Media, Stack Overflow.

1 http://www.stackoverflow.com

Estudando a Difusão da Inovação Em Ecossistemas de Software

Müller Miranda, Renato Ferreira, Cleidson de Souza

Instituto de Ciências Exatas e Naturais – Universidade Federal do Pará (UFPA)

{mulgsm, renpina}@gmail.com, cleidson.desouza@acm.org

Resumo. Slinger Jansen define ecossistema de software como um conjunto de soluções de softwares e um grupo especialistas no domínio que compõem soluções relevantes para a comunidade de usuários. Google Android, Libre Office, Mozilla Firefox e Linux são alguns exemplos destes ecossistemas, pois possuem a característica de disponibilizarem ferramentas que facilitam o desenvolvimento de aplicações visando sua adoção por engenheiros de software. Um dos fatores de sucesso de um ecossistema está ligado ao esforço para criação de novas aplicações para o mesmo, e esse esforço está associado a complexidade de utilização das ferramentas para o rápido desenvolvimento de novos produtos. Entre essas ferramentas podemos identificar o Software Development Kit (SDK), que é o pacote de instalação para que a engenheiros de software tenham integração com o ecossistema proposto para o desenvolvimento de aplicações. Outros exemplos de ferramentas são os frameworks, que definem padrões e especificam como os diferentes componentes da plataforma se comunicam, as bibliotecas que são utilizadas com a finalidade de reaproveitamento de código, e as Application Program Interfaces (API) que são as funcionalidades expostas por uma biblioteca ou framework. Além destas ferramentas, existem outros fatores determinantes para a difusão de um ecossistema de software como por exemplo, os possíveis benefícios financeiros, a documentação das APIs do ecossistema, etc. O objetivo deste trabalho é fazer uma análise científica das características que envolvem a difusão da inovação em ecossistemas de software. Assim, pretende-se definir as diversas características que podem ser determinantes para aceitação ou rejeição de um ecossistema de software, a partir da teoria de inovação de Rogers. A teoria de inovação de Rogers foi desenvolvida para estudar o fenômeno da difusão de inovações, e considera ideias, práticas ou objetos que sejam percebidos como novo por quem os adota, portanto é uma teoria geral que pode ser aplicada em diversas situações. A teoria identifica os principais fatores que influenciam a adoção de uma tecnologia, a saber: vantagem relativa, compatibilidade, complexidade, testabilidade e observabilidade. Neste trabalho estes fatores serão mapeados para aspectos computacionais que possam ser avaliados no contexto de ecossistemas de software. Por exemplo, a complexidade poderia ser mapeada a partir da (in)existência de ferramentas e exemplos de aplicações que permitem o desenvolvimento de aplicações para o ecossistema. Depois deste mapeamento, pretende-se coletar dados para compreender o processo de difusão de inovação de ecossistemas de software para dispositivos móveis. A coleta de dados será feita através de entrevistas com engenheiros de software, bem como através de mineração de repositórios. As informações resultantes desta pesquisa podem trazer benefícios às empresa de softwares de diferentes seguimentos ao auxiliarem as mesmas na tomada de decisão quanto a política de adoção e desenvolvimento de seus ecossistemas de softwares, portanto, impactando positivamente o sucesso destes ecossistemas.

Palavras-chave: Ecossistemas de Software, Inovação, Rogers, Plataforma.

i

Ambiente para Avaliação de Modelos de Sistemas Embarcados Baseada em Métricas Odair Moreira de Souza1, Fabiano Cutigi Ferrari1

1Departamento de Computação – Universidade Federal de São Carlos (UFSCar) odair.souza@dc.ufscar.br, fabiano@dc.ufscar.br

Resumo. Os sistemas embarcados esta ̃o sendo cada vez mais empregados em diferen- tes domi ́nios de aplicac ̧a ̃o e em diversos ni ́veis de complexidade, tais como telecomu- nicac ̧o ̃es, eletrodome ́sticos, aplicac ̧o ̃es militares e aeroespaciais. Normalmente, o de- senvolvimento de sistemas embarcados e ́ baseado na elaborac ̧a ̃o de modelos pro ́ximos a ̀ etapa de codificac ̧a ̃o. Para tal, utilizam-se processos de desenvolvimento baseado em modelos. Nessa abordagem a etapa de modelagem e ́ antecipada, assim como as ativi- dades de Garantia da Qualidade. Portanto, devido a ̀ necessidade de antecipar a detec- c ̧a ̃o de problemas na modelagem de projetos de sistemas embarcados, observa-se um aumento nas pesquisas para buscar mais crite ́rios, ferramentas, me ́todos e processos. Essas pesquisas visam a aumentar o ni ́vel de qualidade dos sistemas embarcados pro- duzidos, assim diminuindo os riscos associados a eventuais falhas desses sistemas. Dessa forma, a realizac ̧a ̃o das atividades para verificar o ni ́vel de qualidade dos mode- los torna-se indispensa ́vel e imprescindi ́vel, pois dependendo do domi ́nio de aplica- c ̧a ̃o, uma falha no sistema pode causar graves prejui ́zos humanos e financeiros. Uma das maneiras para se obter o ni ́vel de qualidade dos modelos e ́ por meio de aplicac ̧a ̃o de me ́tricas. Em sistemas embarcados, as me ́tricas de qualidade sa ̃o em geral aplicadas no artefato final, ou seja, no co ́digo fonte automaticamente gerado a partir dos mode- los; caso o sistema seja modelado de forma inadequada, os problemas migrara ̃o para os artefatos subsequentes. Nesse contexto, o objetivo deste trabalho e ́ viabilizar a me- dic ̧a ̃o do ni ́vel de qualidade dos modelos projetados para sistemas embarcados, e esta- belecer um relacionamento entre as propriedades internas dos modelos com os atribu- tos externos de qualidade. Objetiva-se desenvolver um ambiente para indicar o ni ́vel de qualidade dos modelos de projetos de sistemas embarcados. Para atingir esse obje- tivo, o trabalho sera ́ realizado em duas etapas. A primeira consiste em prover recursos para permitir a avaliac ̧a ̃o interna dos modelos, enquanto a segunda trata da atribuic ̧a ̃o de ni ́veis de qualidade a esses modelos. A avaliac ̧a ̃o interna sera ́ realizada atrave ́s da obtenc ̧a ̃o de medidas definidas por me ́tricas. O ni ́vel de qualidade dos modelos, por sua vez, sera ́ obtido por meio da associac ̧a ̃o dessas medidas internas com atributos ex- ternos de qualidade como, por exemplo, manutenibilidade, confiabilidade e compreen- sibilidade. Conjuntos de me ́tricas internas e atributos externos de qualidade sera ̃o sele- cionados para possibilitarem o mapeamento e, como conseque ̂ncia, permitirem a atri- buic ̧a ̃o de ni ́veis de qualidade para os modelos avaliados.

Palavras-chave: Sistemas Embarcados, Engenharia de Software, Qualidade de Softwa- re, Me ́tricas para Modelos.

!"!# $%"$%#

&''&''(&''

!" # # $# $ % " ! & ! ! ' # ( #$)*$+",! $)*$+ " " - - ! . ( ! ! %

$ % / ! $)*$+ 0 $)*$+

, . , 1 ,#

Rule-based Approach to Modeling and Generation User Interfaces

Vagner Nascimento, Daniel Schwabe Departamento de Informática, Pontifícia Universidade Católica (PUC-Rio), Brasil

vnascimento@inf.puc-rio.br, dschwabe@inf.puc-rio.br

Abstract. Modern day interfaces must deal with a large number of heterogeneity fac- tors, such as varying user profiles and runtime hardware and software platforms. These conditions require interfaces that can adapt to the changes in the <user, plat- form, environment> triad, known as context. The Model-Based User Interface ap- pro-ach has been proposed as a way to deal with these requirements. The Cameleon Refe-rence Model is the current reference framework for User Interfaces gaining adop- tion, which proposes four abstraction levels for modeling UIs: Task and Domain, Ab- stract Interface, Concrete Interface, Final User Interface. In the past years we have been wor-king in the Semantic Hypermedia Design Method (SHDM) and its implementation en-vironment Synth, which aims to allow Model-Based development of Linked Data Ap-plications. While SHDM includes a proposed Abstract Interface Model, it lacks more refined models capable of dealing with the complexities of UIs as outlined above. In this work, is presented a new set of User Interface models and its implementation ar-chitecture similar to the Cameleon Framework proposal, but a data and rule-based in-terface definition model capable of taking into account the semantics of the data it is manipulating and deal with changes of the context, especially in the case of Linked Da-ta. These rules define criteria for situations like the activation of an interface (Inter- face Selection Rules); the selection of elements that participate in the abstract composi- tion (Abstract Interface Selection Rules) and also for the mapping of specific widgets that will be used in the rendering stage (Concrete Mapping Rules). The proposal con- tem-plates a method for modeling interfaces, an implementation architecture and a fra-mework for authoring and running the interface models. An architecture is also pre-sented for building widgets as well as a concrete interface interpretation and ren- de-ring machine from a hierarchy specification. The overall goal of the proposal is to de-sign interfaces more responsive to data and contexts, including situations of adapta- tion, generating more flexible and reusable interfaces for web applications. The major distinguishing original contribution is the use of data- and model-driven rules inte- grated seamlessly with the various other models within the SHDM approach, directly supported by an implementation environment. This approach leads to explicating de- sign decisions associated to the various levels of abstraction, as they become explicit in the rules, as opposed to embedded in the interface code.

Palavras-chave: SHDM, Interface, Adaptation, Semantic Web, Data-driven design.

Oportunidades de Refatoração Move Method Vitor Sales1, Ricardo Terra1, Marco Túlio Valente1

1Departamento de Ciência da Computação - Universidade Federal de Minas Gerais (UFMG)

vitormsales@dcc.ufmg.br, terra@dcc.ufmg.br, mtov@dcc.ufmg.br

Resumo. A qualidade de sistemas é sempre um objetivo recorrente em projetos de de-senvolvimento de software. Na prática, uma série de diretrizes que promovem a quali-dade de sistemas deve ser seguida por processos de desenvolvimento de software, tais como um projeto arquitetural bem definido e o esforço no desenvolvimento de módu-los coesos e pouco acoplados. No entanto, desenvolvedores ao não implementarem métodos nas classes mais apropriadas originam pelo menos dois problemas: (i) Feature Envy, que se refere a métodos que utilizam mais ou que são mais utilizados por classes diferentes daquela qual está implementado e (ii) violações arquiteturais, que se refere ao fato de um método violar a arquitetura planejada do sistema. Independentemente do problema, uma solução efetiva consiste na aplicação de refatorações Move Method. Não obstante, a tarefa de apontar os métodos mal localizados em um sistema não é tri-vial. Diante disso, é proposto uma abordagem e uma ferramenta, nomeada como JMo-ve, baseada em similaridade estrutural para indicar oportunidades de refatorações Mo-ve Method. Sua conjectura é que quanto mais similares os métodos em uma classe, mai-or será a qualidade da classe em termos de coesão e/ou acoplamento. Para determinar VLPLODULGDGH�HQWUH�PpWRGRV��p�XVDGR�XP�FRHÀFLHQWe de similaridade que tem como ob-jetivo medir a semelhança entre dois conjuntos quaisquer. Em linhas de pesquisa simi-lares, a ferramenta Crocodile emprega o coeficiente de Jaccard entre métodos e atributos. Na prática, a ferramenta exibe as distâncias calculadas em uma perspectiva tridimensi-onal para que o desenvolvedor identifique manualmente as oportunidades de refatora-ção. Inspirados nesse trabalho, foi proposto uma abordagem e uma ferramenta chama-da JDeodorant que verifica os acessos a atributos e métodos para detectar casos de Fea-ture Envy. Além disso, esse trabalho utiliza o coeficiente de Jaccard para definir uma métrica de coesão considerada pré-requisito para ocorrer uma sugestão de refatoração Move Method. A ferramenta JDeodorant indica quais métodos devem ser movidos, além da informação da potencial classe de destino. JMove também se baseia em um coefici-ente de similaridade, mas considerando o conjunto de tipos com os quais um método estabelece dependência estrutural, e não a quantidade de acessos a atributos ou méto-dos. Em uma avaliação realizada com treze sistemas de código aberto, JMove se mos-trou 46% mais eficaz em detectar métodos mal localizados do que JDeodorant, que cons-titui a principal ferramenta já proposta com esse objetivo.

Palavras-chave: Refatoração, Mover Método, Feature Envy, Recomendação, Coeficiente de Similaridade.

Projeto Arquitetural para Integração de Aplicações Distribuídas para Apoiar Coleta de Dados em Campo

Adriano Vale de Oliveira1 Nágila Natália de Jesus Torres1 Adailton Magalhães Lima1

1Sistemas de Informação – Universidade Federal do Pará – Castanhal (UFPA) adriano.oliveira@castanhal.ufpa.br, adailton@ufpa.br

Resumo. Arquitetura de Software é fundamental para qualidade dos produtos de Software, pois as técnicas utilizadas em projetos arquiteturais promovem a identificação dos componentes, padrões, estilos de comunicação e facilitam a evolução do Software. Nesta pesquisa existem dois softwares desenvolvidos em realidades distintas: o primeiro, denominado SIVISA, possui foco na coleta de dados sobre Saúde Animal (detalhes em www.sistemadecoleta.blogspot.com.br/2013/05/o-que-e-sivisa.html); o segundo é uma plataforma distribuída baseada na nuvem denominada Maritaca (disponível em maritaca.unifesp.br:8080/maritaca/index.html). Ambos disponibilizam software para coleta de dados em campo (como formulários socioeconômicos sobre saúde pública, censos, etc.) em plataformas web e móvel, porém seus objetivos caminham em direções distintas (no rigor no controle dos usuários responsáveis pela coleta dos dados; na necessidade de conexão contínua com rede de dados, etc.), impedindo que a integração entre estas aconteça de forma natural. Portanto, se faz necessário o projeto e implementação de uma arquitetura que permita a interoperabilidade entre tais arquiteturas. O projeto arquitetural em desenvolvimento objetiva adequar a arquitetura da aplicação Maritaca à realidade da região nordeste paraense onde não há conexão contínua com redes de dados, e funcione assim em conjunto com a aplicação SIVISA. Para alinhar as aplicações é necessário elaborar um projeto de arquitetura de Software que possibilite mapear e documentar os componentes, para proporcionar uma utilização otimizada dos recursos das plataformas. Como bases para o desenvolvimento desta integração foram necessárias pesquisas de trabalhos relacionados ao tema, destacando-se: “Projeto Maritaca: Arquitetura e Infraestrutura para Coleta Móvel de Dados Usando Smartphones” [Conceição, 2013], que descreve a arquitetura da plataforma Maritaca. Uma aplicação similar é o AndCollector [Mota, 2009], que é desenvolvido em Android e capaz de gerar formulários de coleta, porém este não possui suporte escalável de dados, pois foi desenvolvido para rodar centralizado em dispositivos móveis. Além disso, a “Utilização do MTColeta e Dispositivos Móveis para o recadastramento Imobiliário de Prefeituras” mostra o uso do MTColeta na coleta em campo, entretanto, este está limitado à já defasada tecnologia dos PDAs. Para integrar em nível arquitetural as aplicações, é necessário utilizar-se de engenharia reversa para entender e identificar os componentes dos sistemas (Maritaca e SIVISA), além de realizar adaptações em um gerador de códigos para aplicações Android integrante da arquitetura Maritaca. As documentações e diagramas UML de toda a integração arquitetural estão sendo desenvolvidas e disponibilizadas aos envolvidos dos dois projetos no endereço: www.sistemadecoleta.blogspot.com.br. Dessa forma, como resultados esperados têm-se: tornar o Maritaca acessível ao levantamento de dados em campo para Saúde Animal; tornar o SIVISA um cliente do Maritaca, com o modelo arquitetural cliente – servidor; disponibilizar os dados coletados pela aplicação móvel do Maritaca ao SIVISA, e, por fim, realizar testes de interface, caixa preta e caixa branca no Software resultante deste projeto de integração arquitetural. Palavras-chave: Arquitetura de Software, Integração, Dispositivos Móveis, Coleta de Dados.

Um Sistema Multiagentes para Análise de Susceptibilidade de Escorregamentos

RODRIGUES, A D R.1,2 PAES, R. B¹, NETO B F S¹, CARVALHO, T M O² 1Instituto de Computação – Universidade Federal de Alagoas(UFAL)

andreymcz@gmail.com, rodrigo@ic.ufal.br, baldoino@ic.ufal.br

²ALTA Geotecnia Ambiental

taise.carvalho@altageotecnia.com

Resumo. Devido à ocupação antrópica de áreas de risco no Brasil, o mapeamento e monitoramento de regiões susceptíveis a desastres naturais, dentre eles os escorrega-mentos de terra, tem sido o foco principal do Ministério das Cidades. Eventos desta natureza podem ocasionar perdas de vidas e prejuízos econômicos significativos, como os megadesastres desencadeados por chuvas intensas ocorridos no Rio de Janeiro e em Santa Catarina nos anos de 2010 e 2011. Dada a quantidade e dinamicidade das infor-mações necessárias para modelar e prever esses desastres, tornou-se necessário o uso de sistemas computacionais para suprir esta demanda, destacando-se dentre eles os sistemas de informação geográfica(SIG). Entretanto, os sistemas SIG são concebidos de forma genérica, muitas vezes não tendo um aspecto adaptativo desejável. Em um caso específico, o mapa de susceptibilidade a escorregamentos precisa , dentre outras in-formações, da chuva acumulada nas últimas 4 horas para ser gerado, tornando-se desa-tualizado após algumas horas. Uma abordagem para este problema é o uso de agentes adaptativos, responsáveis por coletar e atualizar parâmetros necessários para os cálcu-los. Neste contexto, este trabalho apresenta o desenvolvimento de um sistema compu-tacional que gerará mapas de susceptibilidade combinando informações providas por agentes adaptativos. Tais agentes utilizarão informações ambientais (chuva, declivida-de, uso do solo e ocupação) e técnicas de aprendizagem de máquina para inferir a sus-ceptibilidade de novas áreas. Em particular, o sistema é composto por dois tipos de agentes: (i) aqueles que utilizam históricos de precipitação e se baseiam em estágios de alerta de acordo com a quantidade de chuva estipulada pelo Serviço geológico do Es-tado do Rio de Janeiro (DRM-RJ); e (ii) aqueles que utilizam técnicas de aprendizagem de máquina, tais como máquinas de suporte vetorial e KNN, para inferir a susceptibi-lidade de novas áreas. Uma vez implementados, os agentes atuarão no aplicativo Geo-Decision, uma plataforma SIG especializada em análise de susceptibilidade de encos-tas. O sistema multi agentes analisará a utilização dos mapas no aplicativo, coletando informações relevantes para a criação e atualização de um mapa de susceptibilidade na região geográfica de interesse do usuário. Deste modo, espera-se que o sistema, uma vez funcionando, se aperfeiçoe na predição de áreas susceptíveis a partir da coleta de novos dados de escorregamentos, monitorando e identificando áreas susceptíveis em tempo real. Tais dados podem ser utilizados por órgãos governamentais competentes na gestão de riscos ambientais.

Palavras-chave: Sistemas auto adaptativos e autônomos, máquinas de suporte vetorial, escorregamentos de terra, aprendizagem de máquina.

SISCOD: Uma Proposta para a Redução de Infrações de Trânsitos em Rodoviárias Brasileiras

Eliseu R. de Souza¹, Susany P. Silva¹, Fabrício W. da S. Garcia¹, Aline F. dos A. Lima¹, Marcos C. da R. Seruffo¹, Adailton M. Lima¹

Universidade Federal do Pará - Campus Castanhal Av. dos Universitários, s/n, Jaderlândia, 68746-360, Castanhal - Pará - Brasil

¹Faculdade de Sistema de Informação

{eliseu.souza, susany.silva, fabricio.garcia, aline.lima}@castanhal.ufpa.br {seruffo, adailton}@ufpa.br

Resumo. Os índices de acidentes de trânsito no Brasil crescem a cada dia devido à má conduta dos motoristas nas rodovias, mesmo diante da implantação de novas leis no decorrer dos últimos anos, ainda são elevados os índices de acidentes de trânsito causados por excesso de velocidade, embriaguez e falta de habilitação dos condutores. Existem várias tentativas que os órgãos de trânsito utilizam para minimizar esses acidentes, como por exemplo: multas com valores significativos, radares eletrônicos - que possuem sistemas que identificam o veículo que comete infração no trânsito - e blitz - que são realizadas para fiscalizar as rodovias e diminuir a ocorrência de infrações. No entanto, a implantação de tais práticas ainda não conseguiu mitigar os problemas com acidentes de trânsito no Brasil. Nesse sentido, este artigo propõe um Sistema de Controle de Ocorrências e Diligências (SISCOD), o qual seja capaz de registrar infrações através de denúncias realizadas pelos cidadãos, no momento em que presenciarem violações às leis de trânsito. As ocorrências ao serem registradas e processadas, acionam os agentes de trânsito mais próximos, de acordo com o local de origem do incidente, viabilizando assim que as viaturas policiais ou de trânsito interceptem o infrator poucos minutos após a ocorrência, minimizando transtornos no que se refere ao tráfego de veículos nas rodovias e a impunidade dos infratores. O referido sistema será desenvolvido seguindo a metodologia ágil XP (Extreme Programming), pois esta permite mudanças nos requisitos no decorrer de todo o ciclo de vida do software, já que os mesmos podem sofrer mudanças durante todo o processo de desenvolvimento. Além disso, a metodologia XP apresenta valores, regras e práticas que permitem desenvolver a aplicação de forma mais rápida, dando ênfase na comunicação entre os stakeholders, que é de fundamental importância para a compreensão correta dos requisitos da aplicação. Com a utilização dessa metodologia é possível fazer modificações controladas na aplicação, ou seja, mudanças que não afetem drasticamente estimativas - como o prazo e custo do produto - e que não comprometam a qualidade do mesmo. Diante ao exposto, pode-se afirmar que a metodologia XP é a mais adequada para a implementação do SISCOD, tanto por apresentar as características citadas acima, como por viabilizar a programação pareada, minimizando erros no código fonte, uma vez que esse deve ser revisado por outro programador, o que é de extrema necessidade devido à natureza da aplicação.

Palavras-chave: Métodos Ágeis, Infrações de Trânsito, Metodologia XP.

Aplicação de Técnicas de Engenharia de Software no Desenvolvimento de Sistemas Educacionais

Fabrício W. da S. Garcia¹, Aline F. dos A. Lima¹, Marcos C. da R. Seruffo¹, Zilda L. R. Paiva²

Universidade Federal do Pará - Campus Castanhal Av. dos Universitários, s/n, Jaderlândia, 68746-360, Castanhal - Pará - Brasil

¹Faculdade de Sistema de Informação ²Faculdade de Letras

{fabricio.garcia, aline.lima}@castanhal.ufpa.br, {seruffo, zramalho}@ufpa.br

Resumo. A adesão de novas tecnologias em ambientes escolares tem proporcionado experiências enriquecedoras em sala de aula, permitindo uma grande geração e disseminação de conhecimentos. Instituições de ensino que buscam aliar seus métodos educacionais a recursos tecnológicos viabilizam a seus alunos uma forma diferenciada de Ensino/Aprendizado (E/A), onde a interação aluno-aluno e aluno-professor é fortemente estimulada através do computador e de recursos audiovisuais. Nesse sentido, o presente trabalho objetiva apresentar o módulo educacional SIDICON (Sistema de Informação sobre Diversidade e Consciência), que é uma ferramenta de E/A baseada na utilização de padrões, a qual visa melhorar as práticas pedagógicas utilizadas em escolas públicas de ensino fundamental da Amazônia Paraense, por meio de um ensino diferenciado via computador. O desenvolvimento do SIDICON seguiu as etapas tradicionais de construção de software (coleta, análise e validação de requisitos, projeto de software, codificação, implantação e testes), sendo que estas fases foram norteadas pelo modelo de ciclo de vida iterativo incremental, o qual permitiu desenvolver a aplicação em múltiplos ciclos, realizando ajustes e incrementando novas funcionalidades ao término de cada etapa do ciclo de vida do software. Para o melhor controle dos processos de desenvolvimento, utilizou-se o método de gestão PDCA (Plan, Do, Check, Act), que é constituído basicamente de quatro etapas que acompanham cada ciclo de construção do software, as fases do PDCA são, respectivamente: planejamento, o qual objetivou identificar a problemática e delinear uma forma de resolvê-la, permitindo definir os objetivos do módulo educacional; execução, onde foram desenvolvidos diagramas fundamentados na Engenharia de Software (ES) e estabelecidos os aspectos visuais do aplicativo, como o design, menus, botões e a codificação das funcionalidades; controle, em que foram realizados testes relacionados às funcionalidades do módulo educacional; na ultima etapa foram identificados possíveis bugs e inconsistências, os quais foram corrigidos no decorrer de cada iteração. Ao término do desenvolvimento do SIDICON, realizou-se a implantação do sistema em uma escola pública do município de Castanhal – PA, onde se pôde coletar informações relacionadas aos benefícios e a satisfação dos alunos com o sistema. Constatou-se que o índice de aprovação do SIDICON foi de 95%, os resultados relacionados à classificação do sistema foram: Excelente 25%, Bom 63%, Regular 12% e Ruim 0%. Os resultados obtidos da aplicação do módulo educacional foram animadores, pois mostraram que a abordagem indicada neste trabalho possibilitou a construção de uma ferramenta educacional de qualidade, além de expor o quão benéfico pode ser a inserção de tecnologias para auxiliar o E/A nas escolas, proporcionando uma forma de aprendizado diferenciada e prazerosa para os alunos.

Palavras-chave: Informática na educação, recursos tecnológicos, engenharia de software, PDCA.

Improving Emergent Interfaces by using Design by Contracts and Weakest Precondition

Francisco Dalton1 Márcio Ribeiro1

1Instituto de Computação – Universidade Federal de Alagoas (UFAL)

fdbd@ic.ufal.br, marcio@ic.ufal.br

Abstract. Software product line features might be implemented using preprocessors, where conditional compilation directives like #ifdef and #endif encompass feature code. Despite their widespread usage, preprocessors have several drawbacks, making devel-opers susceptible to commit errors during maintenance tasks. In this context, when maintaining a feature, we might use emergent interfaces, which capture dependencies between this feature and the other ones, bringing awareness of the features we really might impact due to our maintenance task. For example, suppose we should maintain a mandatory feature. In particular, we are supposed to change the value of variable x declared in method m. This method contains four optional features implemented using #ifdefs, A, B, C, and D, but only A and D uses variable x. This means that A and D de-pends on the mandatory feature. In this example, when using emergent interfaces, de-velopers are aware of dependencies like these ones. So, they can focus on two features, instead of analyzing four. However, emergent interfaces are still not representative enough to provide feature modularization, since when changing a feature, developers still need to check and analyze the ones pointed by emergent interfaces (here, A and D). Consequently, developers wastes time and effort instead of focusing only on the maintenance task. To minimize this problem and enable a better interface representa-tiveness with a richer set of information, in this work we propose an extension to emergent interfaces by using Design by Contracts and the Dijkstra weakest precondi-tion. The contracts have semantic information such as “features A and D require x > 0”. Now, as long as we follow this contract, we are able to change the x value without breaking the behavior of A and D and even without the need of analyzing them. To capture this semantic information, we rely on contracts written in languages such as Java Modeling Language (JML), where we can annotate each method with precondi-tions and postconditions. The idea is to take the postcondition of a method and calcu-late the weakest precondition that have to be fulfilled at the beginning of the method to ensure the right execution. We intend to formalize our approach based on a catalog of feature dependencies we will build and their relationship with contracts. Our hy-pothesis is that, if our interfaces contain semantics information about the features we might impact, developers can maintain a feature without the need of analyzing the others, improving comprehensibility and reducing effort. We intend to evaluate this hypothesis by using controlled experiments with human subjects.

Keywords: Software Product Lines, Preprocessors, Features, Design by Contract, Emergent Interfaces.

Um sistema móvel de armazenamento e reprodução de vídeo utilizando computação em nuvem

Lourival Leite Cavalcante Júnior

Faculdade de Sistemas de Informação – Universidade Federal do Pará (UFPA) cavalcantebsi@gmail.com

Resumo. Com o grande aumento da utilização de dispositivos móveis em todo lugar e sempre conectados a Internet é aparente a valorização de determinados serviços que facilitem as experiências dos usuários. Esses aparelhos são pequenos, móveis e já dis-põem de recursos significativos, porém, ainda limitados. Para minimizar essa limita-ção, faz-se necessária a utilização de serviços para driblar as limitações relacionadas ao armazenamento e processamento internos, por exemplo. Nesse contexto, a computação em nuvem surge como uma plataforma independente de sistemas que tem como obje-tivo proporcionar um uso racional de equipamentos e com a possibilidade de adequar-se de acordo com a necessidade do usuário, diminuindo o custo. Outro ponto interes-sante a se destacar é o uso da transmissão de dados multimídias pela internet, a exem-plo, podemos selecionar um vídeo e adiciona-lo em um repositório online, após essa etapa, esse mesmo vídeo poderá ser acessado e visualizado diretamente na internet, sem a necessidade de download do mesmo para o dispositivo usado para acessar o serviço. O aumento da utilização desses serviços dar-se pelo aumento e melhoramento de equipamentos e da largura de banda disponibilizados para dispositivos moveis, as redes 3g que permitem um acesso a internet rápida e de qualidade a parti de qualquer lugar onde tenha a cobertura, facilitando assim a mobilidade. Atualmente existe mui-tos serviços que disponibilizam conteúdos de vídeos online, como Youtube, Vimeo, entre outros, com base nesses serviços o presente trabalho propõe-se a desenvolver um apli-cativo baseado na arquitetura de sistemas distribuídos, acoplando o serviço em nuvem com a reprodução de vídeos em dispositivos moveis através do acesso a internet, visu-alizando lado da computação em nuvem temos o desenvolvimento de serviços que uti-lizem o S3 e CloudFront da plataforma Amazon Web Services. Será também realizado um estudo para o levantamentos de dados sobre a utilização de softwares distribuídos no cenário de transmissões de vídeos utilizando redes celulares 3g e também rede Wifi na Mesorregião Metropolitana de Belém, Pará. Como resultados esperados temos, o de-senvolvimento de uma aplicação nativa para android que esteja diretamente ligada a um serviço de armazenamento em nuvem que realize a gravação de vídeos e faça seu upload automático, após essas etapas o usuário poderá visualizar o vídeo gravado dire-tamente do repositório do serviço em nuvem, também será realizado a avalição da ar-quitetura distribuída para a transmissão de dados multimídias. Os dados coletados e o aplicativos desenvolvido será disponibilizado abertamente para os usuários, não sendo cobrado nada para a obtenção dos mesmos.

Palavras-chave: Computação em nuvem, reprodução de vídeos e sistemas distribuí-dos.

Ferramenta para elaboração de modelos intencionais a partir de Léxico Ampliado da Linguagem

Lucas Gonçalves Cunha1, José Luis Braga1 1Departamento de Informática – Universidade Federal de Viçosa (UFV)

lucas.cunha@ufv.br, zeluis@dpi.ufv.br

Resumo. A extração de informações sobre um determinado domínio é uma das gran-des dificuldades na geração de um software. Os aspectos intrínsecos e a linguagem peculiar de cada domínio exigem conhecimento e experiência do engenheiro de requi-sitos para o sucesso no apanhado das informações. Existem trabalhos que mostram que uso de técnicas de baseados em inteligência artificial podem auxiliar no processo de elicitação de requisitos. Baseado nestes trabalhos, o presente trabalho tem como ob-jetivo a elaboração de uma ferramenta utilizando a técnica de sistemas baseados em conhecimento para auxiliar a construção de modelos intencionais de software, repre-sentados segundo a notação do iStar. O iStar tem como principal base a representação de contextos organizacionais, onde atores dependem uns dos outros para que metas sejam alcançadas, recursos sejam fornecidos, tarefas sejam realizadas e metas flexíveis sejam atendidas. O método proposto basea-se na elaboração de uma base de dados contendo o vocabulário explicitado através do Léxico Ampliado da Linguagem – LAL. O LAL é baseado na premissa que em uma organização existe uma linguagem esten-dida da linguagem natural, que é utilizada pelos atores da organização, composta por símbolos e caracterizada como linguagem da aplicação. O vocabulário obtido é para-metrizado de forma que seja possível analisá-lo em uma máquina de inferência. A ins-peção é realizada através de uma segunda base contendo regras de produção. As re-gras são utilizadas para identificar os elementos do iStar presentes nas descrições do LAL. Os elementos identificados são anotados na base de fatos, visto que algumas re-gras dependem de elementos identificados previamente. A inspeção das regras sobre a base de conhecimento é feita até que não se consiga encontrar mais elementos nas des-crições. Com os elementos elicitados, são feitas validações a respeito da integridade e plenitude dos modelos, também através de regras inseridas na base. Devido a grande dificuldade encontrada durante o processo, a total automação tem grande propensão a erros, logo incapacidades de raciocínio por parte da ferramenta ou ambiguidades são tratadas com intervenções do engenheiro de requisitos através de diálogos simples, para que este sugira uma solução mais precisa. A intervenção do engenheiro também é necessária para o melhoramento da base de regras. A cada modelo gerado a ferra-menta é capaz de sugerir regras a respeito de termos classificados segundo decisões anteriores feitas pelo engenheiro de requisitos. O estado atual em que se encontra o desenvolvimento do trabalho não possibilita verificar a efetividade, em números, do uso da abordagem no processo de elaboração dos modelos.

Palavras-chave: sistemas baseados em conhecimento, iStar, léxico ampliado da lin-guagem, engenharia de requisitos.

Verificação de um modelo para elaboração do Projeto de WebApps com ações integradas da WebE e IHC

Patricia Cristiane de Souza1, Cristiano Maciel1 Luciana A. O. de Moraes1

1Laboratório de Ambientes Virtuais Interativos. Instituto de Computação – Universidade Federal de Mato Grosso (UFMT)

patriciacs@ufmt.br, cmaciel@ufmt.br, lucianamoraes.analista@gmail.com

Resumo. Com o crescimento acelerado da internet, os sistemas web também ganharam um grande impulso. Todavia, todo esse crescimento gerou problemas ao se elaborar Aplicações Web (WebApps), uma vez que há uma quantidade considerável de perfis de usuários na internet e com isso, tanto o processo de desenvolvimento quanto as ativi-dades da Interação Humano-Computador (IHC), acabam por não serem alinhadas e utilizadas de maneira eficaz. Um agravante a mais nesta situação é a pouca quantida-de de literatura que aborda metodologias para desenvolvimento de WebApps, bem como as técnicas de IHC dentro da Engenharia Web. O processo de Engenharia Web (WebE) sugerido por Lowe and Pressman (2009) apresenta um arcabouço ágil com o uso de um modelo de processo ágil, em que distintos métodos são usados em ativida-des tais como, comunicação, planejamento, modelagem, construção e implantação. Na busca da utilização prática de processos para WebE considerando a IHC, com vistas a definição de atividades para projetos interdisciplinares do curso de pós-graduação lato sensu em Engenharia de Sistemas para Web da Universidade Federal de Mato Grosso, é que constatou-se a necessidade de melhor investigar estas áreas. Face ao exposto, tem sido desenvolvida uma pesquisa que visa compor um modelo que permita um alinhamento das atividades de IHC com a fase de projeto do desenvolvimento de uma WebApp. Tal pesquisa possui diversas etapas, tais quais, o estudo bibliográfico, o de-senvolvimento de um modelo e a consequente verificação desse, com potenciais usuá-rios. Com a socialização do modelo de Souza et. al (2012, 2013), foi possível obter da-dos preliminares para análise de sua viabilidade, retroalimentando-o. Assim, após contextualizar as pesquisas nas áreas e apresentar brevemente o modelo, foram anali-sados qualitativamente e quantitativamente os dados dos experimentos realizados. Dessa análise, podemos relatar, que 100% dos participantes da socialização disseram que o modelo apresentado é bem estruturado, levando-se a inferir que tal modelo po-de ser de grande valia tanto para academia, quanto para fábricas de softwares. Espera-se desta forma, discutir esta importante temática com as comunidades de Engenharia de Software (ES) e IHC, possibilitando contribuir no alinhamento das áreas envolvidas na pesquisa, em prol da criação de WebApps de qualidade, voltadas aos seus usuários e fazendo uso de metodologias de desenvolvimento.

Palavras-chave: Engenharia Web, Interação Humano Computador, Engenharia de Software, Aplicações Web.

Avaliação empírica da metodologia Lean Startup em um Empreendimento Tecnológico de Software

Nágila Natália de Jesus Torres1, Adriano Vale de Oliveira¹, Eduardo Leal Guerra1

1Faculdade de Sistemas de Informação – Universidade Federal do Pará (UFPA) nagila.ufpa@gmail.com, adriano.v.d.oliveira@gmail.com, eguerra@ufpa.br

Resumo. A importância do empreendedorismo para o desenvolvimento econômico das nações já é consenso tanto na indústria, na academia, quanto nos governos. Uma diversidade de programas de apoio ao empreendedorismo espalhados pelo mundo tem buscado incentivar a formação de novos empreendedores para alavancar a criação de novas empresas. Nesse contexto, juntamente com o crescimento da Internet, temos visto nos últimos anos o surgimento de vários negócios digitais no mundo alavancados por Startups representadas por gigantes como Google, Apple e Facebook. As Startups são empresas ou instituições humanas ou simplesmente pessoas que queiram transformar ideias em produtos inovadores, que estão inseridas em um contexto de extrema incerteza e com pouca disponibilidade de recursos financeiros. O termo surgiu nos Estados Unidos da América (EUA) na década de 80 a 90 e atualmente tem-se disseminado de maneira vertiginosa. Entretanto, uma pesquisa realizada pela Havard Business Scholl mostrou que 75% de todas as Startups falham e que isso pode ser justificado pelo uso dos modelos de gestão tradicionais, nos quais o mercado e os clientes são bem conhecidos, o que não se adequa ao contexto das Startups. Para superar essa dificuldade, surge a metodologia Lean startup como uma nova forma de gestão de negócio diferenciada e inovadora, especificamente constituída para um contexto de extrema incerteza, a qual conduz o negócio a uma direção sustentável em pouco tempo. A metodologia em tela é composta por um conjunto de práticas ágeis, derivadas da manufatura enxuta, com alguns ajustes e refinamentos, combinadas com as metodologias ágeis de desenvolvimento de software. Lean startup desenvolve um plano estratégico de forma paralela ao desenvolvimento do empreendimento, pois este é mutável à medida que são descobertos os anseios dos clientes de maneira mais apurada, através da técnica do produto mínimo viável (Minimun Valuable Product - MVP), através do qual os empreendedores poderão descobrir o que os possíveis clientes querem e o que agrega valor à eles, adaptando a ideia inicial ao cliente e não o inverso. Embora a metodologia seja usada por empresas como a HP, Instagram, Apple, Google e Facebook, poucos trabalhos científicos de avaliação da metodologia foram realizados. Este trabalho consiste na avaliação empírica da metodologia Lean Startup, sob o contexto de um estudo de caso de desenvolvimento de um novo empreendimento da indústria de software. Nosso estudo dará ênfase na utilização deste tipo de metodologia por empreendedores cursando o último ano de graduação de um curso da área de computação. A pesquisa em questão objetiva avaliar as dificuldades, facilidades e impactos na aplicação da metodologia proposta ao desenvolvimento de uma Startup. Ao final do projeto pretende-se divulgar os resultados e compartilhar as experiências com empreendedores em geral, especialmente os estudantes de graduação na área da computação do Brasil.

Palavras-chave: Lean startup, Startups, desenvolvimento ágil e empreendedorismo.

RSA-MBT: A Test Tool for Generating Test Artifacts Based on Models

Andrew Diniz da Costa, Ricardo Venieris, Gustavo Carvalho, Carlos José Pereira de Lucena

Laboratory of Software Engineering - Pontifical Catholic University of Rio de Janeiro

Rio de Janeiro, Brazil

{acosta, lucena}@inf.puc-rio.br, {rvenieris, guga}@les.inf.puc-rio.br

Abstract. Model-Based Testing (MBT) has attracted the attention of many industries and, hence, it has provided several approaches reported in the literature. The Software Engineering Lab (LES) at the Pontifical Catholic University of Rio de Janeiro has worked extensively on coordinating and carrying out tests of large-scale software sys-tems developed (for web and desktop) for different domains (e.g. petroleum, e-commerce, etc). Based on this experience, an LES test group created a new test model-ing language called UML Testing Profile for Coordination (UTP-C) to model relevant test data. However, to use the advantages of the new modeling, an appropriate test-modeling tool became necessary. Thus, this paper presents the RSA-MBT, a new plug-in developed for the Rational Software Architecture (RSA) tool, to generate a set of test artifacts from UTP-C diagrams.

Keywords: Rational Tool, UML Testing Profile, Model Based Test, Software Testing, Multi-agent System.

Apoio automatizado para a utilização de atividades periódicas em processos de desenvolvimento de

software Tiago Davi O. de Araújo1, Thiago Jorge A. dos Santos1

1Instituto de Ciências Exatas e Naturais – Universidade Federal do Pará (UFPA) tiagodavi70@gmail.com, thiago.tjas@gmail.com

Resumo. Uma das áreas de maior destaque na Engenharia de Software é a área co-nhecida como Tecnologia de Processos de Software que envolve a construção de ferramentas e ambientes computadorizados para a modelagem, execução, simula-ção e evolução de processos de desenvolvimento de software. Durante o processo de software, algumas atividades devem ser desempenhadas no intuito de se cons-truir software de qualidade. Estas atividades são chamadas de periódicas, pois ocor-rem repetidas vezes durante o desenvolvimento e em vários momentos diferentes do processo. O ambiente WebAPSEE – desenvolvido pelo Laboratório de Engenharia de Software da Universidade Federal do Pará (LABES – UFPA) - é um PSEE (Process Centered Software Engineering Environment – Ambiente de Engenharia de Software Ori-entado a Processos) que se destaca pelas inúmeras funcionalidades integradas dis-ponibilizadas. Um dos trabalhos recentes do grupo envolveu a concepção de um apoio automatizado para definição e execução de modelos de processos com atividades pe-riódicas. Esta abordagem envolve: 1) uma metodologia para orientar o usuário – fre-quentemente, o engenheiro de processo ou gerente de projetos – a definir as caracterís-ticas da atividade periódica; 2) uma linguagem de modelagem gráfica, baseada na lin-guagem adotada pelo ambiente WebAPSEE; e, 3) uma semântica de execução para os novos elementos incorporados à linguagem de execução de processos contendo as ati-vidades periódicas. Este é ainda um trabalho em andamento, e se vislumbra benefícios para reduzir o esforço dos usuários na implantação de práticas de melhoria de proces-sos nas organizações de desenvolvimento de software.

Palavras-chave: Atividades Periódicas, WebAPSEE, Tecnologia de Processos, Processo de Software, Ambiente de apoio.

Promoção

Patrocínio!