Anais – ELA-ES – Sessão de Estudantes

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 decisionmaking 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 methods. 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 requirements 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 architectural properties: number of elements, number of ports, number of connections, coupling and introducing security mechanisms. These properties, which are not unique to
particular requirement, impact the requirements for performance, security, maintainability and modifiability, and their respective measured by software metrics. In order to
extract the architectural properties evaluated in architecture, this paper uses the modeling language SysML, which is a general purpose language that includes information
about hardware, software, processes and stakeholders, extended UML. It allows modeling 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 relationships between architectural elements that fit into our purpose. SysML allows the representation through notes and use the requirements diagram, architectural properties
as derived requirements. The work was implemented as proof of concept in a web system for evaluating postgraduate courses developed by UFRN. The study showed that,
through the use of SysML, changes in architectural properties affected their nonfunctional 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 organizações partem da premissa que a qualidade do software pode ser elevada devido ao
aumento da qualidade do processo de desenvolvimento. Contudo, é preciso criar mecanismos que institucionalizem a melhoria contínua dos processos. Esses programas
envolvem diversos conhecimentos que podem ser novos para os membros da organização. Um programa de MPS não deve ser visto como esforço único, mas sim como algo 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 organizacional é um processo de aperfeiçoar ações por meio de compreensão e conhecimento, ampliando os conhecimentos existentes. Além disso, a aprendizagem organizacional consiste em uma série de interações entre a adaptação no nível individual (ou de subgrupo) e adaptação no nível organizacional. Pesquisas tem sido realizadas buscando apoiar organizações que aprendem no contexto de aplicação, evolução e desenvolvimento
de software. Essas pesquisas utilizam mecanismos tecnológicos para apoiar a aprendizagem, 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 organizacional em MPS; identificação e avaliação de meios de transferência do conhecimento. Como resultados obtidos até o momento, tem-se uma revisão sistemática da literatura (RSL), onde foi possível identificar formas de disseminar o conhecimento em organizaçõ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 como 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 tecnologias propostas serão validadas através de diferentes Estudos Experimentais em Engenharia 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
1
Departamento 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 Engineering (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 development 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 integrate dynamically and consistently these requirements to cloud architecture. More recently, models for requirements at runtime have been developed, aiming at managing
the complexity of evolving software behavior while it is executing. Other works proposes an approach for the design of adaptive systems based on requirements and inspired 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 (autoconfiguration) 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 requirements elicitation with Mind Map Modelling used as a seed for generation of Goaloriented models; (ii) Composition (Safe) of Partial goal Models representing the variabilities 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 representation of variability of goals through partial goal-oriented model definition; (ii) the formal 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 Requirements 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
1
Department 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, Queensland in 2010-11, Christchurch and Japan in 2011 and the United States in 2012-13, highlighted the growing problem of natural disasters and the numerous economic and social 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 residents 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 information is particularly important in this context, since environmental changes and
floods are always bound to a geographical context. Thus, Spatial Decision Support Systems (SDSS) can be important technological resources. These are interactive systems
designed to support one or more users in making decisions in a semi-structured decision context. SDSS thus integrate technologies related to Geographic Information Systems (GIS) with the features of Decision Support Systems (DSS). However, these traditional systems in most cases use static and limited data to simulate or help on the decision-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 population, 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. Nevertheless, 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 exploring 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 decision 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¹
1
Centro 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
1
Departamento 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 representar até 80% dos recursos alocados durante o ciclo de vida de um sistema. Tipicamente, 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 gerenciamento 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 tipicamente quando requisições individuais são agrupadas, gerando-se projetos de manutençã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 economia 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 responsável pela criação anual dos projetos de manutenção. O estabelecimento de tal autoridade é particularmente complexa em projetos código-aberto. Assim, o principal
objetivo desse trabalho é propor uma abordagem automática e não-supervisionada para criação de projetos de manutenção agrupando requisições semanticamente similares. A abordagem proposta funciona conforme descrito a seguir: (i) cada requisição é
inicialmente pré-processada usando-se técnicas de processamento de linguagem natural, 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 similaridade do cosseno para verificar a similaridade entre as descrições textuais de duas 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 criando 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 muitos 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
1
2
Center for Informatics - Federal University of Pernambuco (UFPE)
3
4
Math Institute - Federal University of Bahia (UFBA)
Reuse in Software Engineering Group (RiSE), Brazil
Fraunhofer 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 strategy to cope with the increasing demand of large-scale products customization. Owing
to its capability of systematically reusing software artifacts, SPL has provided companies with an efficient and effective means of delivering products with higher quality at
a reduced cost, when compared to traditional software engineering strategies. However, 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 handling 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 implementation mechanisms particularities, which traverses abstractions at source code level. In this effect, this work analyzes the most occurring problems in variability implementation, 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 improvements 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 currently 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 occurring error in the mechanisms. The analysis of open source repositories will aid in
the identification of reported defects in variability implementation. Next, the case studies, involving the use of variability implementation mechanisms in three different programming languages, namely Java, C, and the iOS platform, might strengthen our generalizations. We plan to build the fault model by looking at software projects developed 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
1
Departamento 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 development because they specify software restrictions and how well the software shall perform its function. Usability has been pointed as the most important type of nonfunctional requirement for guaranteeing software quality. In Web applications, usability 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 forgotten 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 approach 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 documents will guide the development team through the implementation of Web applications meeting usability principals. Then, we will develop a tool support for the identification and validation of usability requirements, and a monitoring system to examine
how users perform tasks in low fidelity prototypes in order to identify further usability 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 (percentage of elicited usability requirements), and efficiency (speed when performing the
elicitation) of our approach. Also, the qualitative results from observational and industrial 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
1
Pontifí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 softwarebased 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 projects, 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 develop 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 information systems based on the social-technical paradigm, considering social, political,
cultural and ethical issues involved in understanding the problem in the process of requirements 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 Organizational
Semiotics. 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
1
Departamento de Computação – Universidade Federal de São Carlos (UFSCar)
2
Curso 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á alguns 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 documento 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 apresentado 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 requisitos; e ii) a existência de interesses não explícitos no texto do documento de requisitos, 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 interesses 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 semiautomatizado, denominado ONTOREQ, para identificação e classificação de interesses 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 pode ser custosa, pouco escalável e propensa a erros, sendo assim, uma suíte de ferramentas, denominada ONTOREQ-Toolkit, para automatização de algumas das atividades 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 usabilidade, serão utilizados questionários confeccionados com base no modelo TAM (Technology 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. Travassos
COPPE/ 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 acquired 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 alternative perspective to understand the relationships among experimentation, production, threats to validity and evidence. To propose and evaluate means to strengthen
quantitative studies in software engineering and making them less risky due to population 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 initial discussions regarding the observed secondary studies concerned with this metaphor. 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 constraints) 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, setting up and sampling SE quantitative studies’ population by using, for instance, alternative technologies such as social networks or other crowdsourcing technologies.
Keywords: population sampling, meta-analysis, food chains, experimental chains, evidence based software engineering.
Satisfying Requirements by Cloud Resources Using
Models at Runtime
Raphael Aquino Gomes1,2
Fábio Moreira Costa1
1
Institute of Informatics – Federal University of Goiás (UFG), Brazil
2
Federal 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 customers of cloud services express their resource requirements and how additional resources 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 computing. 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 environments. 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 resources needed to run an application is built by the system based on application requirements 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 according to the resource model generated. Initially, the private cloud formed by the organization’s computing infrastructure is analyzed to check the possibility of admitting a
new application given the resource model derived from thhe requirements specification. During application execution continuous monitoring is carried out to assess possible changes in the application requirements and/or resource availability. In the case
is made a requirements change, the resource specification is again generated and compared with the current one. If the two models are not compatible it is necessary perform again the derivation of resources, its discovery and allocation. The implementation 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 subsequent 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
1
Department 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 Politècnica de Valè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 engineering community lately, however, the issue of how common, variable and productspecific 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 developers 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 important for the goals of the system or its health. Therefore, the developer has to manually 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 semiautomated 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 contribute to the system quality but with a limited refactoring expenditure. Given an object-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 prioritization 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 component modifications, important modifiability scenarios for the system, and types of
code smells. Regarding the suggestion of refactorings, SpIRIT seeks to determine refactoring alternatives for each code smell of its ranking. After searching through the design space of refactoring alternatives, the tool should assess a set of candidate refactorings 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
1
Computer Science Department- Federal University of Bahia (UFBA)
2
RiSE Labs - Reuse in Software Engineering
tassio.vale@ufba.br, esa@dcc.ufba.br
Abstract. The combination of Service-Oriented Computing (SOC) and Software Product Lines (SPL) together has started to receive attention from researchers and practitioners seven years ago, since SOC and SPL can address issues of each other. This combination 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 implementation proposals for SOPLs. Therefore, we propose an investigation of available
implementation techniques for dynamic variability, aiming to create a systematic approach 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 picture. 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 failures 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 automatically 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- healing mechanism to correct the system state at runtime, which uses knowledge ac- quired while maintaining the software to incrementally build the knowledge base. This
mechanism is composed by a new instrumentation technique to trace the system execution, an inspection tool to aid in failures diagnosis, a contract validator to uses the diagnosis 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, autonomic- 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
1
Departamento de Ciência da Computação – Universidade Federal da Bahia (UFBA)
2
Departamento de Tecnologia da Informação – Instituto Federal da Bahia (IFBA)
3
Departamento de Ciência da Computação – Universidade Salvador (UNIFACS)
4
Instituto 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 diminui 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. Lidar 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 manutenção pendentes (por exemplo, não execução de testes, refatoração de código pendente, atualização de documentação pendente) como um tipo de dívida que traz um benefí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 software incorram em dívidas durante o processo de desenvolvimento uma vez que pequenas quantidades de dívida podem aumentar a produtividade. No entanto, sua presenç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 Software como uma possível solução para a árdua tarefa de compreender, e ajudar a manter 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 gerenciamento 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 visualizaçã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 executados 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 em
vocabulá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
Aprimorando a Verificação de Conformidade em
Programas Utilizando a Metodologia Design by
Contract
Alysson Milanez1 Tiago Massoni1 Rohit Gheyi1
1
Departamento 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 funcionalidade) e módulos clientes (que fazem uso da(s) funcionalidade(s) provida(s)), determinando 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 programas. Neste contexto, verificação dinâmica é uma técnica comum, em virtude da verificaçã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 corrigidas. 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 problema; 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 presentes 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, pretende-se obter como resultados do presente trabalho de Mestrado uma técnica semiautomática para a categorização de não-conformidades, uma implementação desta técnica 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 ferramenta e de seu método de aplicação. Deste modo, estaremos contribuindo para o desenvolvimento 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 categorias 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 - quando 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 categorizadas foram reportadas aos autores dos projetos; que nos reportaram que estão de acordo 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,
conformidade, categorização.
verificação
baseada
em
contrato,
nã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 Stereotypebased Management of Variability (SMarty). SMarty é uma abordagem para gerenciamento
de variabilidades em Linha de Produto de Software (LPS) baseada em UML. A abordagem 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 identificaçã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. Porém, nota-se a necessidade das abordagens existentes, para gerenciamento de variabilidades, serem validadas experimentalmente antes da transferência dessas para a indústria. Como a abordagem SMarty vem sendo consolidada nos últimos anos, com base na sua adoção por diversos projetos, surge a necessidade de validá-la experimentalmente. Para tanto, um conjunto de experimentos e possíveis replicações serão planejadas 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 variabilidades e retorno de investimento, bem como, com base nos diversos estudos experimentais 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
1
Instituto de Informática – Universidade Federal do Rio Grande do Sul (UFRGS)
2
Centro 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 software 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 dispositivos é de extrema importância, tendo em vista que a energia destes aparelhos é fornecida por uma bateria, logo um software que desperdiça energia (ou deixa de economizar) 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, estruturas e paradigmas de projetos de algoritmos, para então avaliar o impacto dessas técnicas 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 geral as estruturas recursivas demostram ter um desempenho inferior quando comparados 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 desenvolvimento software que impactam diretamente no desempenho e consumo de
energia de aplicações móveis para a plataforma Android, com isso prologando o tempo de duração da bateria dos dispositivos móveis como smartphones e tablets. Como
trabalhados futuros serão analisadas novas metodologias de desenvolvimento de software 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
1
Departamento 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.
2
Departamento 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
1
Informatics Department, Minho University, Portugal
2
Informatics Department, PUC-Rio, Brazil
3
Faculty of Computer Science, Universidad Politecnica de Valencia, Spain
pg19789@alunos.uminho.pt, bcafeo@inf.puc-rio.br, afgarcia@inf.puc-rio.br, simone@inf.pucrio.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 maintainability of the DSL artifacts and, hence, their adoption in mainstream software development, 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 guidance on how to objectively reveal them. Usability is a multi-faceted quality characteristic, which is challenging to quantify before a DSL is actually used by its stakeholders. 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 maintenance. 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 limitations 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
1
Departamento de Informática, Pontifícia Universidade Católica (PUC-Rio), Brasil
2
CIRAD, 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 Interest 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- implemented 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; Distributed Simulation; Multi-agent Systems.
Choosing between automatically tailored and predefined 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 tailoring according to the project context. However, this solution is complex and we wonder 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), frameworkbased approaches (e.g., RUP), constructive approaches (e.g., Situational Method Engineering), 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 predefine 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 approaches 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 select the one whose distance is the shortest. Both approaches will be compared according 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 difficulty 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
1
Department 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 information sharing between the various research groups, because it imposed a single , inflexible and centralized data schema. On the other hand, the Semantic Web technologies 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. Another 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 extracting 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 information 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¹
1
Instituto 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 objetorelacional (ORM), de modo a contornar as diferenças geradas pelos distintos paradigmas dessas tecnologias. As ferramentas ORM implementam um ou mais padrões arquiteturais 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 softwares 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 utilizados nessa fase é um ponto importante para o gerenciamento do software. Deste modo, 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 softwares através de ferramentas de versionamento, de modo a buscar determinadas modificações em esquema de dados, e assim, analisar o seu impacto ao restante do software. Para a mensuração do impacto causado pela modificação do esquema de dados, será 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 criar 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 software.
Palavras-chave: Engenharia de Software, Padrões, Orientação a Objetos, Banco de Dado Relacional, Manutenção de Software.
Software Remodularization Analysis Using Semantic
Clustering
Gustavo Jansen de Souza Santos, Marco Tulio Oliveira Valente1
1
Departamento 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 architectural erosion, leads to high costs with maintenance accumulating over time. Future modifications and improvements will take more time to understand which part of the system 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 cohesion inside the modules and reduces the coupling between classes of different modules. 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 extracts a set of semantic clusters, i.e. sets of classes with similar vocabularies. Semantic
Clustering combines Information Retrieval techniques for text manipulation and Hierarchical Clustering algorithms to retrieve semantic clusters. In our work, the vocabulary 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 recent work; these metrics measure the semantic information presented in the vocabulary. Next, we applied Semantic Clustering in two versions of a given remodularization 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 remodularizations 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 after remodularization tasks. This fact is an indication that developer’s efforts in remodularization 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
1
Departamento 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 desenvolvimento 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 documentaçã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ísticas da abordagem implementada pelo sistema, destacam-se: (i) fornecimento de exemplos 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 apresentados sejam mais úteis aos desenvolvedores que exemplos de uso incluindo métodos únicos; (ii) a utilização de diversos artifícios para melhorar a legibilidade de exemplos 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
1
Departamento 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 podem trocar mensagens ou inicializar serviços. No desenvolvimento de aplicações Android os problemas conhecidos com tratamento de exceção da linguagem Java persistem e, adicionalmente a plataforma possui algumas limitações de robustez, principalmente 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 trabalho: (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 excepcional, 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) implementação de um mecanismo de tratamento de exceções baseado no modelo propostos 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 robustez.
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 dependência entre funcionalidades. Essa falta, poderia ser minimizada se existisse documentaçã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 proposta que por meio de especificações executáveis escritas colaborativamente, as quais expressam os requisitos do sistema através de exemplificações do comportamento esperados 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étricas de controle, garantindo assim a consistência e o conhecimento agregado ao software legado também à sua evolução. Estas especificações são escritas em linguagem natural possibilitando redução na lacuna de comunicação entre membros da equipe e aumentando 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 comportamento 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 especificaçõ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) projeto(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 proposta 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, desenvolvimento 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
1
Instituto de Informática – Universidade Federal de Goiás (UFG)
2
Departamento 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 qualidade 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 requisitos 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 ponto 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 abordagens 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 pequeno 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 baseado no tamanho do mutante pretende-se, posteriormente, utilizar o tamanho do mutante 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 mutante é a maneira proposta aqui para tornar o Teste de Mutação mais barato, consequentemente 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
1
Computer 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 documentation to enable effective software reuse. We consider a library as a implementation 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 documentation 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 technology is the Question & Answer site Stack Overflow1. Unlike traditional documentation,
where the collection of resources (e.g., specifications and code examples) are understandably organized and explicitly linked to the elements of the API, the crowd documentation is created implicitly, without any organization or comprehensive links explicit 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 corresponds 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 Overflow 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 relevant 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
1
Departamento de Computação – Universidade Federal de São Carlos (UFSCar)
odair.souza@dc.ufscar.br, fabiano@dc.ufscar.br
Resumo. Os sistemas embarcados estão sendo cada vez mais empregados em diferentes domínios de aplicação e em diversos níveis de complexidade, tais como telecomunicações, eletrodomésticos, aplicações militares e aeroespaciais. Normalmente, o desenvolvimento de sistemas embarcados é baseado na elaboração de modelos próximos
à etapa de codificação. Para tal, utilizam-se processos de desenvolvimento baseado em
modelos. Nessa abordagem a etapa de modelagem é antecipada, assim como as atividades de Garantia da Qualidade. Portanto, devido à necessidade de antecipar a detecção de problemas na modelagem de projetos de sistemas embarcados, observa-se um
aumento nas pesquisas para buscar mais critérios, ferramentas, métodos e processos.
Essas pesquisas visam a aumentar o nível de qualidade dos sistemas embarcados produzidos, assim diminuindo os riscos associados a eventuais falhas desses sistemas.
Dessa forma, a realização das atividades para verificar o nível de qualidade dos modelos torna-se indispensável e imprescindível, pois dependendo do domínio de aplicação, uma falha no sistema pode causar graves prejuízos humanos e financeiros. Uma
das maneiras para se obter o nível de qualidade dos modelos é por meio de aplicação
de métricas. Em sistemas embarcados, as métricas de qualidade são em geral aplicadas
no artefato final, ou seja, no código fonte automaticamente gerado a partir dos modelos; caso o sistema seja modelado de forma inadequada, os problemas migrarão para os
artefatos subsequentes. Nesse contexto, o objetivo deste trabalho é viabilizar a medição do nível de qualidade dos modelos projetados para sistemas embarcados, e estabelecer um relacionamento entre as propriedades internas dos modelos com os atributos externos de qualidade. Objetiva-se desenvolver um ambiente para indicar o nível
de qualidade dos modelos de projetos de sistemas embarcados. Para atingir esse objetivo, o trabalho será realizado em duas etapas. A primeira consiste em prover recursos
para permitir a avaliação interna dos modelos, enquanto a segunda trata da atribuição
de níveis de qualidade a esses modelos. A avaliação interna será realizada através da
obtenção de medidas definidas por métricas. O nível de qualidade dos modelos, por
sua vez, será obtido por meio da associação dessas medidas internas com atributos externos de qualidade como, por exemplo, manutenibilidade, confiabilidade e compreensibilidade. Conjuntos de métricas internas e atributos externos de qualidade serão selecionados para possibilitarem o mapeamento e, como consequência, permitirem a atribuição de níveis de qualidade para os modelos avaliados.
Palavras-chave: Sistemas Embarcados, Engenharia de Software, Qualidade de Software, Mé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 factors, such as varying user profiles and runtime hardware and software platforms.
These conditions require interfaces that can adapt to the changes in the <user, platform, environment> triad, known as context. The Model-Based User Interface ap- proach has been proposed as a way to deal with these requirements. The Cameleon Reference 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 working in the Semantic Hypermedia Design Method (SHDM) and its implementation environment Synth, which aims to allow Model-Based development of Linked Data Applications. 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 architecture similar to the Cameleon Framework proposal, but a data and rule-based interface 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 Data. 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- templates a method for modeling interfaces, an implementation architecture and a framework for authoring and running the interface models. An architecture is also presented for building widgets as well as a concrete interface interpretation and ren- dering machine from a hierarchy specification. The overall goal of the proposal is to design interfaces more responsive to data and contexts, including situations of adaptation, generating more flexible and reusable interfaces for web applications. The major
distinguishing original contribution is the use of data- and model-driven rules integrated seamlessly with the various other models within the SHDM approach, directly
supported by an implementation environment. This approach leads to explicating design 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 desenvolvimento de software. Na prática, uma série de diretrizes que promovem a qualidade 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ódulos 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 é trivial. Diante disso, é proposto uma abordagem e uma ferramenta, nomeada como JMove, baseada em similaridade estrutural para indicar oportunidades de refatorações Move Method. Sua conjectura é que quanto mais similares os métodos em uma classe, maior será a qualidade da classe em termos de coesão e/ou acoplamento. Para determinar
e de similaridade que tem como objetivo medir a semelhança entre dois conjuntos quaisquer. Em linhas de pesquisa similares, 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 tridimensional para que o desenvolvedor identifique manualmente as oportunidades de refatoração. Inspirados nesse trabalho, foi proposto uma abordagem e uma ferramenta chamada JDeodorant que verifica os acessos a atributos e métodos para detectar casos de Feature 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 coeficiente 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étodos. Em uma avaliação realizada com treze sistemas de código aberto, JMove se mostrou 46% mais eficaz em detectar métodos mal localizados do que JDeodorant, que constitui 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
1
Sistemas 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êmse: 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²
1
Instituto 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 escorregamentos 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 informaçõ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 informações, da chuva acumulada nas últimas 4 horas para ser gerado, tornando-se desatualizado 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álculos. Neste contexto, este trabalho apresenta o desenvolvimento de um sistema computacional que gerará mapas de susceptibilidade combinando informações providas por
agentes adaptativos. Tais agentes utilizarão informações ambientais (chuva, declividade, uso do solo e ocupação) e técnicas de aprendizagem de máquina para inferir a susceptibilidade 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 Estado 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 susceptibilidade de novas áreas. Uma vez implementados, os agentes atuarão no aplicativo GeoDecision, uma plataforma SIG especializada em análise de susceptibilidade de encostas. 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
1
Instituto 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 developers 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 depends on the mandatory feature. In this example, when using emergent interfaces, developers 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 representativeness 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 precondition. 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 preconditions and postconditions. The idea is to take the postcondition of a method and calculate 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 hypothesis 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á dispõ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 objetivo proporcionar um uso racional de equipamentos e com a possibilidade de adequarse de acordo com a necessidade do usuário, diminuindo o custo. Outro ponto interessante a se destacar é o uso da transmissão de dados multimídias pela internet, a exemplo, 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 muitos 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 aplicativo 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, visualizando lado da computação em nuvem temos o desenvolvimento de serviços que utilizem 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 desenvolvimento 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 diretamente do repositório do serviço em nuvem, também será realizado a avalição da arquitetura 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
1
Lucas Gonçalves Cunha , José Luis Braga
1
1
Departamento 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 grandes 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 requisitos 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 objetivo 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, representados 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 estendida 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 é parametrizado de forma que seja possível analisá-lo em uma máquina de inferência. A inspeção é realizada através de uma segunda base contendo regras de produção. As regras 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 regras 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 descriçõ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 ferramenta é 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 linguagem, 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 Maciel 1
Luciana A. O. de Moraes1
1
Laborató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 atividades 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 quantidade 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 atividades 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 desenvolvimento 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 dados preliminares para análise de sua viabilidade, retroalimentando-o. Assim, após
contextualizar as pesquisas nas áreas e apresentar brevemente o modelo, foram analisados 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 pode ser de grande valia tanto para academia, quanto para fábricas de softwares. Esperase 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
1
Faculdade 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 systems developed (for web and desktop) for different domains (e.g. petroleum, ecommerce, etc). Based on this experience, an LES test group created a new test modeling 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 testmodeling tool became necessary. Thus, this paper presents the RSA-MBT, a new plugin 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
1
Instituto 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 conhecida 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 construir software de qualidade. Estas atividades são chamadas de periódicas, pois ocorrem 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 Orientado a Processos) que se destaca pelas inúmeras funcionalidades integradas disponibilizadas. 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 periódicas. Esta abordagem envolve: 1) uma metodologia para orientar o usuário – frequentemente, o engenheiro de processo ou gerente de projetos – a definir as características da atividade periódica; 2) uma linguagem de modelagem gráfica, baseada na linguagem 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 atividades 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 processos 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!