A Comparative Study of Code Query Technologies

When analyzing software systems we are faced with the challenge of how to implement a particular analysis for different programming languages. A solution for this problem is to write a single analysis using a code query language abstracting from the specificities of languages being analyzed. Over the past ten years many code query technologies have been developed, based on different formalisms. Each technology comes with its own query language and set of features. To determine the state of the art of code querying we compare the languages and tools for seven code query technologies: Grok, Rscript, JRelCal, SemmleCode, JGraLab, CrocoPat and JTransformer. The specification of a package stability metric is used as a running example to compare the languages. The comparison involves twelve criteria, some of which are concerned with properties of the query language (paradigm, types, parametrization, polymorphism, modularity, and libraries), and some of which are concerned with the tool itself (output formats, interactive interface, API support, interchange formats, extraction support, and licensing). We contextualize the criteria in two usage scenarios: interactive and tool integration. We conclude that there is no particularly weak or dominant tool. As important improvement points, we identify the lack of library mechanisms, interchange formats, and possibilities for integration with source code extraction components

Supporting software development through declaratively codified programming patterns

In current-day software development, programmers often use programming patterns to clarify their intents and to increase the understandability of their programs. Unfortunately, most software development environments do not adequately support the declaration and use of such patterns. To explicitly codify these patterns, we adopt a declarative meta programming approach. In this approach, we reify the structure of a (object-oriented) program in terms of logic clauses. We declare programming patterns as logic rules on top of these clauses. By querying the logic system, these rules allow us to check, enforce and search for occurrences of certain patterns in the software. As such, the programming patterns become an active part of the software development and maintenance environment. (C) 2002 Elsevier Science Ltd. All rights reserved

Supporting Software Development through Declaratively Codified Programming Patterns

In current-day software development, programmers often use programming patterns to clarify their intents and to increase the understandability of their programs. Unfortunately, most software development environments do not adequately support the declaration and use of such patterns. To explicitly codify these patterns, we adopt a declarative meta-programming approach. In this approach, we reify the structure of an (object-oriented) program in terms of logic clauses. We declare programming patterns as logic rules on top of these clauses. By querying the logic system, these rules allow us to check, enforce and search for occurrences of patterns in the software. As such, the programming patterns become an active part of the development and maintenance environment

Supporting Software Development through Declaratively Codified Programming Patterns ⋆ Abstract

In current-day software development, programmers often use programming patterns to clarify their intents and to increase the understandability of their programs. Unfortunately, most software development environments do not adequately support the declaration and use of such patterns. To explicitly codify these patterns, we adopt a declarative meta programming approach. In this approach, we reify the structure of an (object-oriented) program in terms of logic clauses. We declare programming patterns as logic rules on top of these clauses. By querying the logic system, these rules allow us to check, enforce and search for occurrences of certain patterns in the software. As such, the programming patterns become an active part of the software development and maintenance environment. Key words: programming patterns, logic programming, meta programming, tool support, object-oriented programmin

Uso de algoritmos genéticos para la creación automática de patrones de requisitos

Un factor crítico que influye en el éxito de un proyecto es la disponibilidad un conjunto de requisitos completo y de calidad que reflejen de manera completa y consistente las necesidades a las que el proyecto debe dar respuesta. Los patrones de texto son artefactos de conocimiento que se utilizan como plantillas para guiar a los ingenieros y analistas en la creación de requisitos y que permiten también validar su calidad; guían en la redacción de requisitos haciendo uso de lenguaje natural con ciertas restricciones sintácticas y de vocabulario que imponen los propios patrones para asegurar su calidad. Sin embargo, la generación de patrones para un dominio concreto es una actividad que requiere mucho tiempo, es costosa y debe ser realizada por especialistas. Esta tesis propone un método de generación automática de patrones de texto válidos para la creación de nuevos requisitos a partir de un conjunto inicial de requisitos de calidad en un dominio determinado. Se propone el uso de algoritmos genéticos y una estrategia de separación y conquista. El algoritmo genético encuentra patrones que reconocen a un número determinado de requisitos del conjunto a partir del conjunto inicial de requisitos. Aplicando la estrategia de separación y conquista, si estos patrones candidatos proporcionan un rendimiento adecuado, se incorporan al conjunto de soluciones y la búsqueda evolutiva continúa con un conjunto más pequeño de requisitos que incluye sólo los que aún no han sido conquistados. El resultado final de la doble iteración de algoritmo de conquista y algoritmo genético es un conjunto de patrones válidos, encontrados a partir del conjunto inicial de requisitos, que pueden ser usados para redactar nuevos requisitos en el mismo dominio o para validar la calidad de otros requisitos ya escritos, siempre en el mismo dominio. Se ha definido una metodología de trabajo completa y un algoritmo basado en el uso de programación genética junto con la estrategia de separación y conquista (Separate-and-Conquer) para obtener conjuntos de patrones de texto capaces de reconocer conjuntos de requisitos. A partir de la metodología se ha desarrollado una herramienta funcional completa, Twiga, con alta capacidad de parametrización para ajustar su funcionamiento a distintos contextos y objetivos de generación de conjuntos de patrones. Esta herramienta ha sido testeada y los rangos de funcionamiento de sus principales parámetros establecidos con un primer bloque de experimentos haciendo uso de requisitos artificiales, requisitos generados a partir de patrones preestablecidos y, por tanto, conocidos. Este entorno de experimentación controlado ha permitido definir los valores más adecuados de los parámetros a utilizar en casos de uso reales. Una vez ajustada la herramienta, se han realizado una serie de experimentos utilizando un corpus de requisitos reales proporcionado por el Grupo de Trabajo de INCOSE (International Council on Systems Engineering) en 2016 y que ya fue utilizado en experimento anteriores por el grupo de investigación. Los resultados muestran que este método puede generar conjuntos de patrones válidos, mejorando en un 233% los resultados experimentos previos del grupo que utilizaron otras aproximaciones, con valores de ratio de requisitos coincidentes por patrón de 2,87, frente a 1,23 obtenidos es los experimentos anteriores.A critical factor influencing the successful execution of any type of project is the availability of a complete set of requirements with the proper quality. Text patterns are knowledge artifacts used as templates to guide engineers and analysts in the process of creation of requirements, enabling the use of natural language with certain syntactic and vocabulary constraints imposed by the patterns themselves to ensure their requirement quality. However, generating patterns for a particular domain is a time-consuming, costly activity that must be performed by specialists. This thesis proposes a method for the automatic generation of text patterns from an initial subset of quality requirements. These patterns will be valid for the creation of new requirements or for validating the quality of another corpus of existing requirements of the same domain. The use of Genetic Algorithms and a Separate-and-Conquer strategy is proposed. The genetic algorithm finds, from the initial subset of requirements, patterns that recognize a given number of requirements in the subset. Applying the Separate-and-Conquer strategy, if these candidate patterns provide adequate performance, defined parametrically, they are incorporated into the final solution and the evolutionary search continues with a smaller subset of requirements that includes only those that have not yet been conquered. A complete working methodology based on the use of Genetic Algorithms together with the Separate-and-Conquer strategy have been defined to obtain sets of valid text patterns for the writing of new requirements. A complete functional tool, Twiga, has been developed based on this methodology, with a high capacity of parameterization to adjust its operation to different contexts and objectives. This tool has been tested and the operating ranges of its main parameters were established with a block of experiments using "artificial" requirements i.e., requirements generated automatically from pre-established and, therefore, known patterns. This controlled experimentation environment has made it possible to define the most appropriate values of the parameters to be used in actual use cases. With the main parameters adjusted using the previous experiments, a series of experiments have been performed using a corpus of requirements provided by the INCOSE (International Council on Systems Engineering) in 2016 and already used in previous investigations by the research group. The results show that this method can automatically generate a set of valid patterns suitable for the generation of new requirements, improving previous investigation by 233%, with values of the ratio of matching requirements per pattern of 2.87, compared to 1.23 obtained in previous methods.Programa de Doctorado en Ciencia y Tecnología Informática por la Universidad Carlos III de MadridPresidente: Gonzalo Génova Fuster.- Secretario: Susana Irene Díaz Rodríguez.- Vocal: Gustavo Adolfo Ramírez Gonzále

Graph Based Verification of Software Evolution Requirements

Due to market demands and changes in the environment, software systems have to evolve. However, the size and complexity of the current software systems make it time consuming to incorporate changes. During our collaboration with the industry, we observed that the developers spend much time on the following evolution problems: designing runtime reconfigurable software, obeying software design constraints while coping with evolution, reusing old software solutions for new evolution problems. This thesis presents 3 processes and tool suits that aid the developers/designers when tackling these problems.\ud The first process and tool set allow early verification of runtime reconfiguration requirements. In this process the UML models are converted into a graph-based model. The execution semantics of UML are modeled by graph transformation rules. Using these graph transformation rules, the execution of the UML models is simulated. The simulation generates a state-space showing all possible reconfigurations. The runtime reconfiguration requirements are expressed by computational tree logic or with a visual state-based language, which are verified over the generated state-space. When the verification fails a feedback on the problem is provided.\ud The second process and tool set are developed for computer aided detection of static program constraint violations. We developed a modeling language called Source Code Modeling Language (SCML) in which program elements from the source code can be represented. In the proposed process for constraint violation detection, the source code is converted into SCML models. The constraint detection is realized by graph transformation rules. The rules detect the violation and extract information from the SCML model to provide feedback on the location of the problem.\ud The third process and tool set provide computer aided verification of whether a design idiom can be used to implement a change request. The developers tend to implement evolution requests using software structures that are familiar to them; called design idioms. Graph transformations are used for detecting whether the constraints of the design idiom are satisfied or not. For a given design idiom and given source files in SCML, the implementation of the idiom is simulated. If the simulation succeeds, then the models are converted to source code.\u