Lightweight Multilingual Software Analysis

Developer preferences, language capabilities and the persistence of older languages contribute to the trend that large software codebases are often multilingual, that is, written in more than one computer language. While developers can leverage monolingual software development tools to build software components, companies are faced with the problem of managing the resultant large, multilingual codebases to address issues with security, efficiency, and quality metrics. The key challenge is to address the opaque nature of the language interoperability interface: one language calling procedures in a second (which may call a third, or even back to the first), resulting in a potentially tangled, inefficient and insecure codebase. An architecture is proposed for lightweight static analysis of large multilingual codebases: the MLSA architecture. Its modular and table-oriented structure addresses the open-ended nature of multiple languages and language interoperability APIs. We focus here as an application on the construction of call-graphs that capture both inter-language and intra-language calls. The algorithms for extracting multilingual call-graphs from codebases are presented, and several examples of multilingual software engineering analysis are discussed. The state of the implementation and testing of MLSA is presented, and the implications for future work are discussed.Comment: 15 page

Test Generation and Dependency Analysis for Web Applications

In web application testing existing model based web test generators derive test paths from a navigation model of the web application, completed with either manually or randomly generated inputs. Test paths extraction and input generation are handled separately, ignoring the fact that generating inputs for test paths is difficult or even impossible if such paths are infeasible. In this thesis, we propose three directions to mitigate the path infeasibility problem. The first direction uses a search based approach defining novel set of genetic operators that support the joint generation of test inputs and feasible test paths. Results show that such search based approach can achieve higher level of model coverage than existing approaches. Secondly, we propose a novel web test generation algorithm that pre-selects the most promising candidate test cases based on their diversity from previously generated tests. Results of our empirical evaluation show that promoting diversity is beneficial not only to a thorough exploration of the web application behaviours, but also to the feasibility of automatically generated test cases. Moreover, the diversity based approach achieves higher coverage of the navigation model significantly faster than crawling based and search based approaches. The third approach we propose uses a web crawler as a test generator. As such, the generated tests are concrete, hence their navigations among the web application states are feasible by construction. However, the crawling trace cannot be easily turned into a minimal test suite that achieves the same coverage due to test dependencies. Indeed, test dependencies are undesirable in the context of regression testing, preventing the adoption of testing optimization techniques that assume tests to be independent. In this thesis, we propose the first approach to detect test dependencies in a given web test suite by leveraging the information available both in the web test code and on the client side of the web application. Results of our empirical validation show that our approach can effectively and efficiently detect test dependencies and it enables dependency aware formulations of test parallelization and test minimization

Model-based, event-driven programming paradigm for interactive web applications

Applications are increasingly distributed and event-driven. Advances in web frameworks have made it easier to program standalone servers and their clients, but these applications remain hard to write. A model-based programming paradigm is proposed that allows a programmer to represent a distributed application as if it were a simple sequential program, with atomic actions updating a single, shared global state. A runtime environment executes the program on a collection of clients and servers, automatically handling (and hiding from the programmer) complications such as network communication (including server push), serialization, concurrency and races, persistent storage of data, and queuing and coordination of events.National Science Foundation (U.S.) (Grant CCF-1138967)National Science Foundation (U.S.) (Grant CCF-1012759)National Science Foundation (U.S.) (Grant CCF-0746856

Full Stack Application Generation for Insurance Sales based on Product Models

The insurance market is segregated in various lines-of-business such as Life, Health, Property & Casualty, among others. This segregation allows product engineers to focus on the rules and details of a speci c insurance area. However, having di erent conceptual models leads to an additional complexity when a generic presentation layer application has to be continuously adapted to work with these distinct models. With the objective to streamline these continuous adaptations in an existent presentation layer, this work investigates and proposes the usage of code generators to allow a complete application generation, able to communicate with the given insurance product model. Therefore, this work compares and combines di erent code generation tools to accomplish the desired application generation. During this project, it is chosen an existing framework to create several software layers and respective components such as necessary classes to represent the Domain Model ; database mappings; Service layer; REST Application Program Interface (API); and a rich javascript-based presentation layer. As a conclusion, this project demonstrates that the proposed tool can generate the application already adapted and able to communicate with the provided conceptual model. Proving that this autonomous process is faster than the current manual development processes to adapt a presentation layer to an Insurance product model.O mercado segurador encontra-se dividido em várias linhas-de-negócio (e.g. Vida, Saúde, Propriedade) que têm naturalmente, diferentes modelos conceptuais para a representação dos seus produtos. Esta panóplia de modelos leva a uma dificuldade acrescida quando o software de camada de apresentação tem que ser constantemente adaptado aos novos modelos bem como ás alterações efetuadas aos modelos existentes. Com o intuito de suprimir esta constante adaptação a novos modelos, este trabalho visa a exploração e implementação de geradores de código de forma a permitir gerar toda uma aplicação que servirá de camada de apresentação ao utilizador para um dado modelo. Assim, este trabalho expõe e compara várias ferramentas de geração de código actualmente disponíveis, de forma a que seja escolhida a mais eficaz para responder aos objectivos estabelecidos. É então selecionada a ferramenta mais promissora e capaz de gerar vários componentes de software, gerando o seu modelo de domínio, mapeamento com as respectivas tabelas de base de dados, uma camada de lógica de negócio, serviços REST bem como uma camada de apresentação. Como conclusão, este trabalho apresenta uma solução que é capaz de se basear num modelo proveniente do sistema de modelação de produto e assim gerar completamente a aplicação de camada de apresentação desejada para esse mesmo modelo. Permitindo assim, um processo mais rápido e eficaz quando comparado com os processos manuais de desenvolvimento e de adaptação de código-fonte existentes