Search

In this chapter we discuss several previous work on topics like interfaces for non-annotative approaches (such as aspect-oriented programming), separation of concerns and modularity, analyses on preprocessor-based systems, and dataflow analysis. Besides discussing, we compare these works to our approach, pointing out the differences between them.

SPL testing has been considered a challenging task, mainly due to the diversity of products that might be generated from an SPL. To deal with this problem, techniques for specifying and deriving product specific functional test cases have been proposed. However, there is little empirical evidence of the benefits and drawbacks of these techniques. To provide this kind of evidence, in a previous work we conducted an empirical study that compared two design techniques for black-box manual testing, a generic technique that we have observed in an industrial test execution environment, and a product specific technique whose functional test cases could be derived using any SPL approach that considers variations in functional tests. Besides revisiting the first study, here we present a second study that reinforce our findings and brings new insights to our investigation. Both studies indicate that specific test cases improve test execution productivity and quality.

In this chapter we review essential concepts we explore in this work. Firstly, we review software families and software product lines, since the problem we address here is critical in these contexts. We show the basic concepts and then move towards conditional compilation with preprocessors, a widely used mechanism to implement features in industrial practice. Despite the widespread usage, conditional compilation has several drawbacks. We then present the Virtual Separation of Concerns (VSoC) approach, which can minimize some of these drawbacks. In this work, we intend to address the lack of feature modularity. Thus, we need to catch dependencies between features and inform developers about them. To do so, we rely on dataflow analyses, the last topic we review in this chapter.

In Software Product Lines (SPL), we can bind reusable features to compose a product at different times, which in general are static or dynamic. The former allows customizability without any overhead at runtime. On the other hand, the latter allows feature activation or deactivation while running the application with the cost of performance and memory consumption. To implement features, we might use aspect-oriented programming (AOP), in which aspects enable a clear separation between base code and variable code. In this context, recent work provides AspectJ-based idioms to implement flexible feature binding. However, we identified some design deficiencies. Thus, to solve the issues of these idioms, we incrementally create three new AspectJ-based idioms. Moreover, to evaluate our new idioms, we quantitatively analyze them with respect to code cloning, scattering, tangling, and size by means of software metrics. Besides that, we qualitatively discuss our new idioms in terms of code reusability, changeability, and instrumentation overhead.

Submitted by Tatyanne Silva de Sousa Ferreira null (tatyanne@stj.jus.br) on 2014-01-17T14:01:56Z No. of bitstreams: 1 disposiçoes_finais_convençao.pdf: 41135 bytes, checksum: 98caa67d15701152620a01c03c676fa6 (MD5) Approved for entry into archive by Jussara Pontes da Cruz(jussara@stj.gov.br) on 2014-01-17T20:27:31Z (GMT) No. of bitstreams: 1 disposiçoes_finais_convençao.pdf: 41135 bytes, checksum: 98caa67d15701152620a01c03c676fa6 (MD5) Made available in DSpace on 2014-01-17T20:27:31Z (GMT). No. of bitstreams: 1 disposiçoes_finais_convençao.pdf: 41135 bytes, checksum: 98caa67d15701152620a01c03c676fa6 (MD5) Previous issue date: 2013-04

The review of the evolution of teaching of international law at the “Arcadas”, as the Law School of the University of Sao Paulo is well-known, has a relevant boundary due to the contribution of Vicente Marotta Rangel for decades, which comprehends a crucial period which, due to the influence of the armed forces rule, the teaching of international law became an optional subject in many law courses in the entire country. However, thanks to him, it was never interrupted in this Law School. The paper examines his long, fruitful life and the main publications of this master, who reached 90 years-old in March 2014, and received in December of the same year an International Colloquium on the Law of the Sea as a tribute.

Developers evolve software product lines (SPLs) manually or using typical program refactoring tools. However, when evolving a product line to introduce new features or to improve its design, it is important to make sure that the behavior of existing products is not affected. Typical program refactorings cannot guarantee that because the SPL context goes beyond code and other kinds of core assets, and involves additional artifacts such as feature models and configuration knowledge. Besides that, in a SPL we typically have to deal with a set of possibly alternative assets that do not constitute a well-formed program. As a result, manual changes and existing program refactoring tools may introduce behavioral changes or invalidate existing product configurations. To avoid that, we propose approaches and implement tools for making product line evolution safer; these tools check whether SPL transformations are refinements in the sense that they preserve the behavior of the original SPL products. They implement different and practical approximations of a formal definition of SPL refinement. We evaluate the approaches in concrete SPL evolution scenarios where existing product's behavior must be preserved. However, our tools found that some transformations introduced behavioral changes. Moreover, we evaluate defective refinements, and the toolset detects the behavioral changes.

This chapter introduces an extension of the Rational Unified Process (RUP) with a method that supports the progressive, and separate, implementation of three different aspects: persistence, distribution, and concurrence control. This complements RUP with a specific implementation method, called Progressive Implementation Method (Pim), and helps to tame the complexity of applications that are persistent, distributed, and concurrent. By gradually and separately implementing, testing, and validating such applications, we obtain two major benefits: the impact caused by the requirements changes during development is reduced and testing and debugging are simplified. In addition, the authors hope to contribute to solving the lack of a specific implementation method in RUP.

A feature model (FM) defines the valid combinations of features, whose combinations correspond to a program in a Software Product Line (SPL). FMs may evolve, for instance, during refactoring activities. Developers may use a catalog of refactorings as support. However, the catalog is incomplete in principle. Additionally, it is non-trivial to propose correct refactorings. To our knowledge, no previous analysis technique for FMs is used for checking properties of general FM refactorings (a transformation that can be applied to a number of FMs) containing a representative number of features. We propose an efficient encoding of FMs in the Alloy formal specification language. Based on this encoding, we show how the Alloy Analyzer tool, which performs analysis on Alloy models, can be used to automatically check whether encoded general and specific FM refactorings are correct. Our approach can analyze general transformations automatically to a significant scale in a few seconds. In order to evaluate the analysis performance of our encoding, we evaluated in automatically generated FMs ranging from 500 to 2,000 features. Furthermore, we analyze the soundness of general transformations.

In some domains, such as the mobile application domain, functional tests may not be feasible to automate due to limited test automation technology (multimedia support, etc.) or high cost to port automated tests for different phone models and operating systems. In this context, test teams should be able to estimate the effort required to manually execute tests on schedule.Although several effort estimation approaches have been proposed over the years, none of them are appropriate for estimating manual test execution effort. The main reason for that is the lack of size measures for test projects. In this paper, we present execution points, a measure for the size and execution complexity of tests that is calculated based on test specifications. We also show how to estimate manual test execution effort and capacity based on this measure. Finally, results from an empirical study suggested the viability of our proposed measure.

Summary form only given. The extractive and the reactive software product line (SPL) adoption strategies involve, respectively, bootstrapping existing products into a SPL and extending an existing SPL to encompass another product. In both cases, product line refactorings are useful to guide the SPL derivation process by extracting product variations and appropriately structuring them. They also help to assure the safety of the whole process by preserving SPL configurability. In this context, we describe FLiP, which is a suite of tools implemented as Eclipse plugins and has been designed and tested in the context of mobile game SPLs.

Testing is an important activity to ensure software quality. Big organizations can have several development teams with their products being tested by overloaded test teams. In such situations, test team managers must be able to properly plan their schedules and resources. Also, estimates for the required test execution effort can be an additional criterion for test selection, since effort may be restrictive in practice. Nevertheless, this information is usually not available for test cases never executed before. This paper proposes an estimation model for test execution effort based on the test specifications. For that, we define and validate a measure of size and execution complexity of test cases. This measure is obtained from test specifications written in a controlled natural language. We evaluated the model through an empirical study on the mobile application domain, which results suggested an accuracy improvement when compared with estimations based only on historical test productivity.

Concurrent programs are essential in the development of Web based information systems. The wide dissemination of these systems increased the need for methods to create correct and efficient concurrent programs, which are usually difficult to implement and test. This paper presents guidelines to improve the concurrent control structure of object-oriented software using aspect-oriented programming through AspectJ based on an existent object-oriented concurrency control implementation method. We have defined a simple aspect framework that can be extended to implement concurrency control in applications complying with a software architecture presented in this paper. The framework comprises a set of reusable aspects useful for modularizing concurrency control.

This paper presents our experience on assessing the modularity of software product lines through the dependencies found using design structure matrices. We conducted a case study on a mobile game software product line and we were able to identify some important dependencies between the modules.

Modularization of crosscutting concerns is the main benefit provided by aspect-oriented constructs. In order to rigorously assess the overall impact of this kind of modularization, we use design structure matrixes (DSMs) to analyze different versions (OO and AO) of a system. This is supported by the concept of semantic dependencies between classes and aspects, leading to a more faithful notion of coupling for AO systems. We also show how design rules can make those dependencies explicit and, consequently, yield a more modular design.

Submitted by Gabriela Evangelista Botelho null (gbotelho@stj.jus.br) on 2015-02-11T17:05:46Z No. of bitstreams: 1 direito_internacional_vida_casella.pdf: 580658 bytes, checksum: d8853a17eb00b8802806e8576b19d14e (MD5) Made available in DSpace on 2015-02-11T17:05:46Z (GMT). No. of bitstreams: 1 direito_internacional_vida_casella.pdf: 580658 bytes, checksum: d8853a17eb00b8802806e8576b19d14e (MD5) Previous issue date: 2007

It is important for a company to know if it is able to attend the clients' requests on time and according to their expectations, mainly in competitive markets. A usual activity performed to ensure quality is the test activity. Software testing is been considered so important that organizations can allocate teams exclusively for test activities. In this context, it is important that test managers know the capacity of their test team. This paper defines a capacity model for test execution teams and presents the use of simulation technique for estimating teams' capacities for executing tests in mobile applications. We also report our experiences using this model in an organizational setting

Submitted by Maria Helena Souza (mariahs@stj.jus.br) on 2015-02-23T15:22:51Z No. of bitstreams: 1 homologacao_sentenca_arbitral_casella.pdf: 675777 bytes, checksum: 8c38bc2bc4e40974dfbac4171bdcac03 (MD5) Made available in DSpace on 2015-02-23T15:22:51Z (GMT). No. of bitstreams: 1 homologacao_sentenca_arbitral_casella.pdf: 675777 bytes, checksum: 8c38bc2bc4e40974dfbac4171bdcac03 (MD5) Previous issue date: 2006

Porting is a critical task in mobile device game development. The high diversity of devices requires correspondingly customized versions of a single game. Managing the variabilities among these customized versions while exploring the latent game commonality cannot be solely addressed with a single technique. This paper contributes to this task by identifying and analyzing porting challenges, and by evaluating and contrasting existing approaches within industrial-strength case studies of J2ME games. Further, we present lessons learned, proposing more effective guidelines for this process, aiming at improving the quality of the resulting applications and porting process productivity.

As Web-based information systems usually run in concurrent environment, the complexity for implementing and testing those systems is significantly high. Therefore it is useful to have guidelines to introduce concurrency control, avoiding ad hoc control strategies, which may have a negative impact in efficiency and may not guarantee system safety. This paper defines guidelines for concurrency control in Web-based information systems implemented in Java with relational databases. In particular we show where Java and relational database concurrency control mechanisms should be used in order to implement our concurrency control strategy. Additionally, we analyze the performance of different concurrency controls approaches. The main point of the guidelines is to guarantee system correctness without redundant concurrency control, both increasing performance and guaranteeing safely.

A integração europeia, apesar de problemas pontuais, é importante demais para ser negligenciada, pela prática relevante que trouxe para o continente europeu, superando séculos de guerra e conflitos, e também pelas mudanças na teoria e nas concepções acadêmicas a respeito do direito; nesta experiência europeia de integração se combinam a realidade de processo coerente e a recorrência de mitos duradouros, e todos esses aspectos somente podem ser compreendidos mediante contextualização histórica.

In this paper we present JATS, a transformation system for the Java programming language. The system has been designed with the goal of making the process of creating and applying transformations as agile as possible. Also, it features a transformation language which has a syntax very similar to that of Java, decreasing the semantic gap between the transformation language and the language being transformed. JATS may be used to specify and apply a wide range of transformations, including refactorings, refinement laws and code generation.

Distribution has become an essential non-functional requirement of most applications. The same application may be required to use different distribution platforms simultaneously or during its evolution. However, distributed applications are considerably more difficult to design, implement and test than centralized systems even with the same functionality. We present an implementation method which guides the progressive transformation of an initially centralized application into a distributed one. The method helps to tame the inherent complexity of distributed systems and makes tests more effective. Additionally, it relies on a design pattern promoting extensibility and reuse of other layers such as the user interface and the business layers.

In this work we propose an extension of the MooZ formal specification language with support for parameterized packages. This enhances MooZ’s capabilities for software reuse and maintenance in the large. We discuss several design issues for MooZ’s structuring mechanisms: the distinction between inheritance and subtyping, values and objects, vertical and horizontal composition, packages and classes. We also analyse the impact of our design decisions on software reuse.