C to O-O Translation: Beyond the Easy Stuff

Can we reuse some of the huge code-base developed in C to take advantage of modern programming language features such as type safety, object-orientation, and contracts? This paper presents a source-to-source translation of C code into Eiffel, a modern object-oriented programming language, and the supporting tool C2Eif. The translation is completely automatic and supports the entire C language (ANSI, as well as many GNU C Compiler extensions, through CIL) as used in practice, including its usage of native system libraries and inlined assembly code. Our experiments show that C2Eif can handle C applications and libraries of significant size (such as vim and libgsl), as well as challenging benchmarks such as the GCC torture tests. The produced Eiffel code is functionally equivalent to the original C code, and takes advantage of some of Eiffel's object-oriented features to produce safe and easy-to-debug translations

DeepAM: Migrate APIs with Multi-modal Sequence to Sequence Learning

Computer programs written in one language are often required to be ported to other languages to support multiple devices and environments. When programs use language specific APIs (Application Programming Interfaces), it is very challenging to migrate these APIs to the corresponding APIs written in other languages. Existing approaches mine API mappings from projects that have corresponding versions in two languages. They rely on the sparse availability of bilingual projects, thus producing a limited number of API mappings. In this paper, we propose an intelligent system called DeepAM for automatically mining API mappings from a large-scale code corpus without bilingual projects. The key component of DeepAM is based on the multi-modal sequence to sequence learning architecture that aims to learn joint semantic representations of bilingual API sequences from big source code data. Experimental results indicate that DeepAM significantly increases the accuracy of API mappings as well as the number of API mappings when compared with the state-of-the-art approaches

Pitfalls and guide lines in the transition to object oriented software design methodologies

A research report submitted to the Faculty of Engineering, University of the Witwatersrand, Johannesburg, in partial fulfilment of the requirements for the degree of Master of Science in Engineering.Due to the dynamic nature of the software engineering industry there is a constant move towards new strategies for solving design problems. More specifically there is a move towards Object Oriented (OO) methodologies, presumably because of the various advantages offered in terms of maintainability, and reuse of code produced this way. As with various other aspects of the software industry there are however also problems encountered in this transition and lessons to be learned from the experience of companies who have already performed this change. This research report investigates possible guidelines for companies who are currently contemplating a change to the OO software design methodologies, by covering a collection of issues one should know about prior to this change. It also summarises the problems faced in the transition so far, the reasons for these problems and suggests possible solutions. Lastly it also investigates new trends in the OO arena. The emphasis is on South African companies and projects. The results obtained are compared with results obtained overseas to find out what the differences and similarities are. Areas of concern are also identified, where theoreticians' views have been ignored, and both South African and overeeas companies have not implemented any of the suggestions made.Andrew Chakane 201

Parsing for agile modeling

In order to analyze software systems, it is necessary to model them. Static software models are commonly imported by parsing source code and related data. Unfortunately, building custom parsers for most programming languages is a non-trivial endeavour. This poses a major bottleneck for analyzing software systems programmed in languages for which importers do not already exist. Luckily, initial software models do not require detailed parsers, so it is possible to start analysis with a coarse-grained importer, which is then gradually refined. In this paper we propose an approach to "agile modeling" that exploits island grammars to extract initial coarse-grained models, parser combinators to enable gradual refinement of model importers, and various heuristics to recognize language structure, keywords and other language artifacts

Migration d'interfaces utilisateurs textuelles de systèmes patrimoniaux vers le Web

Les interfaces utilisateurs détiennent une importance non négligeable dans tout logiciel applicatif, car elles constituent le premier contact entre les utilisateurs et le logiciel. La migration d'interfaces utilisateurs textuelles de systèmes patrimoniaux vers le Web vise à remédier les problèmes liés à l'accès limité de tels systèmes tout en améliorant l'aspect et la convivialité de ces interfaces. Fréquemment, cela implique à la fois le changement de la plate-forme d'exécution - d'une plate-forme textuelle vers une architecture Web - et la refonte complète des interfaces vers une technologie de présentation Web. Ce mémoire est une synthèse des méthodes et des techniques de migration d'interfaces utilisateurs textuelles vers le Web. Nous y abordons, dans un premier temps, les notions reliées aux systèmes patrimoniaux et au Web. Cela permet d'établir le contexte de notre étude à savoir l'environnement de départ et l'environnement cible dans une migration d'interfaces utilisateurs vers le Web. Dans un deuxième temps, nous exposons différentes techniques et approches de migration d'interfaces utilisateurs. Finalement, nous terminons notre présentation avec trois exemples de plates-formes de migration d'interfaces utilisateurs

Aviation System Analysis Capability Executive Assistant Design

In this technical document, we describe the design developed for the Aviation System Analysis Capability (ASAC) Executive Assistant (EA) Proof of Concept (POC). We describe the genesis and role of the ASAC system, discuss the objectives of the ASAC system and provide an overview of components and models within the ASAC system, and describe the design process and the results of the ASAC EA POC system design. We also describe the evaluation process and results for applicable COTS software. The document has six chapters, a bibliography, three appendices and one attachment

Using the Uniqueness of Global Identifiers to Determine the Provenance of Python Software Source Code

We consider the problem of identifying the provenance of free/open source software (FOSS) and specifically the need of identifying where reused source code has been copied from. We propose a lightweight approach to solve the problem based on software identifiers-such as the names of variables, classes, and functions chosen by programmers. The proposed approach is able to efficiently narrow down to a small set of candidate origin products, to be further analyzed with more expensive techniques to make a final provenance determination.By analyzing the PyPI (Python Packaging Index) open source ecosystem we find that globally defined identifiers are very distinct. Across PyPI's 244 K packages we found 11.2 M different global identifiers (classes and method/function names-with only 0.6% of identifiers shared among the two types of entities); 76% of identifiers were used only in one package, and 93% in at most 3. Randomly selecting 3 non-frequent global identifiers from an input product is enough to narrow down its origins to a maximum of 3 products within 89% of the cases.We validate the proposed approach by mapping Debian source packages implemented in Python to the corresponding PyPI packages; this approach uses at most five trials, where each trial uses three randomly chosen global identifiers from a randomly chosen python file of the subject software package, then ranks results using a popularity index and requires to inspect only the top result. In our experiments, this method is effective at finding the true origin of a project with a recall of 0.9 and precision of 0.77

Development of an integrated product information management system

This thesis reports on a research project undertaken over a four year period investigating and developing a software framework and application for integrating and managing building product information for construction engineering. The research involved extensive literature research, observation of the industry practices and interviews with construction industry practitioners and systems implementers to determine how best to represent and present product information to support the construction process. Applicable product models for information representation were reviewed and evaluated to determine present suitability. The IFC product model was found to be the most applicable. Investigations of technologies supporting the product model led to the development of a software tool, the IFC Assembly Viewer, which aided further investigations into the suitability of the product model (in its current state) for the exchange and sharing of product information. A software framework, or reusable software design and application, called PROduct Information Management System (PROMIS), was developed based on a non-standard product model but with flexibility to work with the IFC product model when sufficiently mature. The software comprises three subsystems namely: ProductWeb, ModelManager.NET and Product/Project Service (or P2Service). The key features of this system were shared project databases, parametric product specification, integration of product information sources, and application interaction and integration through interface components. PROMIS was applied to and tested with a modular construction business for the management of product information and for integration of product and project information through the design and construction (production) process