INES – National Institute of Science and Technology for Software Engineering

RSS feed


October 2021
« Nov    

  • Software Engineering in the Transition to Multicore Platforms

    Publicado em April 17th, 2012Projects

    In the last few years, both the software development industry and academia have shown a strong belief that multicore machines are an irreversible tendency. To exploit the power of multicore machines, applications must be capable of running in parallel. However, the construction of concurrent and parallel applications is know to be a difficult and error-prone activity. Although operating systems, architectures, and compilers can assist in the construction of parallel applications, most of the responsibility rests in the hands of programmers.

    In this scenario, a number solutions have been proposed to improve the performance of applications running on multicore machines and to ease their construction and maintenance. Nonetheless, many of these solutions ignore the needs of developers and the current state of the practice of the construction of concurrent and parallel applications. In addition, researchers rarely evaluate the efficacy new mechanisms for the construction of concurrent systems from a software engineering perspective. At the same time, there are only a few approaches to support developers to introduce concurrency control mechanisms in existing systems, further aggravating problems. Finally, even when existing systems are successfully made concurrent, developers have little support to switch between different techniques for concurrency control and to structure their applications so as to be capable of handling errors at runtime.

    This research project aims to propose new techniques, methods, and tools to support developers in the transition to multicore platform, from a Software Engineering standpoint. More specifically, it has the following goals:

    – Improve the current body of knowledge about the state-of-the-practice of the use of existing constructs for concurrency control and how their usage has evolved over time.

    – To develop refactoring techniques to introduce concurrency control mechanisms in systems that do not use them. The methods and techniques that we intend to develop should also ease the task of switching between different techniques.

    – To design and implement new approaches to handle errors in concurrent systems, since concurrency is an abundant source of problems in the construction of real-world applications.

  • INES researchers developing educational-oriented recommender systems

    Publicado em April 17th, 2012Projects

    INES researchers at C.E.S.A.R/ are investigating and developing educational-oriented recommender systems for providing students with personalized learning material respecting their individual needs. One of the main challenges of the research is to depict the student’s user model due to its granularity of characteristics to determines user’s interest. In order to offer students with appropriate learning resources and courses, machine learning and data mining techniques such as prediction, classification and clustering are being investigated and applied to an under-development recommendation system. The outcome of this work will be implemented at, an educational social network. Frederico Durao (C.E.S.A.R/, Marcel Caraciolo ( and Silvio Meira (C.E.S.A.R) are leading the research.

    , , , ,
  • Building Robust Applications by Integrating Exception Control Flow Mining into Automatic Test Case Generation

    Publicado em April 9th, 2012Projects

    This project aims to integrate some approaches to generate test cases into static analysis tools proposed by [Roberta et al, 2009] and [Garcia, 2011th; Garcia 2011B ]. The SAFE tool proposed by [Roberta et al, 2009] is a static analysis tool that calculates the exception control flows of applications written in Java or AspectJ. The  eFlowMining proposed by [Garcia, 2011th; Garcia 2011B] is a static analysis tool that capture, mine and visualize the main features of the exceptional control flow defined by multiple versions of applications written in various programming languages, such as: Java, C #, C, VB.NET and  F #.

    This project therefore aims to achieve the following goals:
    • Identification of key issues related to capture, analyze and view the exceptional control flow in software systems;
    • Identification of key issues related to support automatic generation of test cases for validating the exception control flow;
    • Development of new techniques, methods, algorithms and tools for validating the exceptional code of software systems;
    • Validation of the proposed solutions through case studies and controlled experiments.

  • Investigating Algorithms, Techniques and Tools for Search Based Software Engineering

    Publicado em March 27th, 2012About the Institute, Award, Expenses, News, Projects, Uncategorized

    Search Based Software Engineering (SBSE) is an emerging field in which Software Engineering problems are reformulated and modeled as optimization problems, and subsequently are solved using concepts, techniques, algorithms and search strategies. The search goal is to identify, among all possible solutions, one that is good enough according to appropriate metrics. The reformulation allows that problems, previously resolved by adopting intensively manual and intuitive methods, can be solved wholly or partially in a systematic and automated way. In addition, SBSE can provide solutions to problems considered intractable by other methods and techniques of Software Engineering, often leading to innovative solutions, not anticipated or even imagined.

    In such a context, the aim of this project is to adopt, investigate, evaluate and develop SBSE concepts, algorithms, techniques and strategies in order to solve problems that arise in several areas of the Software Engineering discipline. The scope is widely open for different types of problems. However, initially, it focuses on developing approaches for composition, selection and allocation of software development teams, in both co-located and distributed settings. In particular, this project will take into account problems related to communication and coordination among software development teams, which are geographically distributed around the world. As widely known, such communication and coordination problems arises due to their different technical skills, and, mainly, conflicting cultural, social, organizational and even legal aspects, that, jointly, can significantly impact on software development cost, time and quality. Besides, the project also deals with problems related to search, selection and certification of software components in the context of Global Software Development (GSD) applied to Software Product Lines (SPL).

    , , ,
  • Dependable Evolution of Software Product Lines

    Publicado em March 21st, 2012Projects

    An important competitive differential for software factories is the ability to launch similar products customized to the clients, in a fast and cost-reduced way, without compromising quality. This has been possible through software product line engineering. A software product line (PL) is a set of related software products that are generated from reusable assets. Products are related in the sense that they share common functionality. Assets correspond to components, classes, property files, and other artifacts that we compose or instantiate in different ways to specify or build the different products. This kind of reuse targeted at a specific set of products can bring significant productivity and time to market improvements.

    To obtain the benefits associated to the PL approach with reduced upfront investment, we can minimize the initial PL analysis and development process by bootstrapping existing related products into a PL. Through an extraction process, we separate variations from common parts and then discard duplicated common parts. A similar process applies to PL evolution, when, for instance, adding a new product requires extracting variations from parts previously shared by a number of products.

    Although useful to reduce initial investments and risks, this extraction and evolution process can be costly and tiresome. Manually extracting and modifying different code fragments, besides other kinds of assets, requires substantial effort, especially for checking necessary conditions to ensure that the evolution can be performed in a safe way. Nonetheless, it can also introduce defects, compromising the PL benefits in other cost and risk dimensions.

    We believe that the PL extraction and evolution process can benefit from semi-automatic refactorings, with formal basis, to ensure correctness and avoid running tests after the refactoring. Applying semi-automatic refactorings, guided by the developer, has the advantage of guaranteeing refactoring by construction. However, it imposes restrictions over the involved assets, such as the use of reflection, and demands from the developer the knowledge of the available transformations and the ability to identify which ones are better suited for a given situation. When the developer does not have such knowledge and ability, it is important to count with an alternative: verifying, ‘a posteriori’, that modifications to a PL really consist of a refactoring can be automatically performed in various situations, and approximated in the remaining ones.

    However, existing refactoring notions focus on justifying the transformation of a single program into another, they do not consider transforming a PL into another, or a set of a programs into a PL. In fact, a PL can have conflicting artifacts, such as two classes with the main method, or two versions of the same configuration file, which makes the assets from a PL an invalid program. This prevents such assets set to benefit from existing refactoring notions. Beyond such program refactoring limitations – without mentioning requirements, tests and design models – in a PL, we tipically need extra elements to automatically generate products: Feature Models (FMs) and Configuration Knowledge (CK).

    For these reasons, this project intends to propose, formalize, implement, and evaluate refactorings and refactoring checkers for PLs. In particular, we will define and implement refactoring catalogues, based on a behavior-preserving refinement notion. We will have catalogues that modify the PL as a whole, as well as individually modifying FMs and CK. Separate modifications to FM and CK are important to support compositional PL evolution. Besides that, we will reuse existing program and model refactoring catalogues for different languages. Similarly, we will have checkers for specific situations, such as when we modify only a single PL element (FM, CK, or assets), and checkers for changes that affect the PL as a whole.

    , , , ,
  • INES researchers have project funding approved by FAPESB

    Publicado em December 10th, 2011News, Projects

    INES researchers Christina Chavez, Claudio Sant’Anna and Manoel Mendonça had a new project — “A Service for Assessing the Quality of Open Source Software projects for Adoption in Corporate Environments” — approved by FAPESB (Fundação de Amparo à Pesquisa do Estado da Bahia). The funding includes scholarships, equipment and books.

    This project comprises one of the new goals submitted to INES, Edital 02 — Quality Assessment in Open Source Software — in the context of the project “Models, Techniques and Tools for Software Evolution”.

    Abstract: In recent years, open source software (OSS) has brought a number of opportunities that can be exploited by different kinds of stakeholders, from companies and government agencies to researchers, developers and users in general. The adoption of a solution based on OSS by companies or government agencies can bring many benefits but also may pose risks to the business. Free software has significant characteristics in terms of product and process — not always explicitly documented or available from repositories — that can be critical to support feasibility studies and decisions about adopting or not the software.
    This project’s main goal is therefore to provide a service for evaluating OSS projects for general use, including the use in corporate environments. The service includes the assessment of the products and processes associated with OSS projects to provide information for potential applicants to adopt it.

    , , ,