Multiple Programming Languages Research Articles

The Norwegian National Ground Segment; Preservation, Distribution and Exploitation of Sentinel Data

In order to take advantage of the Sentinel program, the Norwegian Space Agency decided to establish a national collaborative ground segment for satellite data with the purpose of simplifying data access, ensure support for operational national services and long term preservation of data. This is the NBS where MET Norway has the technical responsibility in terms of providing the infrastructure and storage capacity for data management. Serving the data through two separate platforms, the end users have access to the data in its original format in addition to Sentinel-1 and Sentinel-2 products in NetCDF-4/CF. Using the latter format, services like regridding, subsetting, visualization and aggregation are integrated utilizing OPeNDAP in combination with OGC WMS and OGC WPS. In addition, data uploading and retrieving operations are simplified for an end user since streaming of data by means of OPeNDAP is supported in multiple programming languages. Due to the strong coupling between space based earth observations, in-situ observation, model data etc, disseminating data in a generic data management system utilizing NetCDF-4/CF and OPeNDAP is convenient for seamless integration across branches. However, the current CF version is not mature for handling all parts of the Sentinel data but future development looks very promising.

Multi-programming language software systems modularization

A software system evolves over time to meet the user’s new requirements as well as to adapt to the environment. This causes it deviates from its original and documented structure. Hence, after a while, due to its low understandability, making new changes will not be easy. Modularization is utilized to extract the software system structure from the source code to understand it. Recently, there has been a significant increase in writing large-scale applications in collaboration with several programming languages; for example, Mozilla Firefox 3.7 is written in more than twenty programming languages. Understanding such applications for maintaining them is a challenging problem. Existing modularization methods to understand an application are only applicable to programs which are written in a programming language. This paper introduces the concept of multi-programming language modularization. It then presents a technique for modularization of applications which are written in multiple programming languages. The results on Mozilla Firefox demonstrate that the proposed approach can extract a modularization close to human experts, a capability which may help in understanding an application.

A Narrative Improvement Techniques Used with The Expert Systems

The technologies used for an expert system development have a vital role and take the design to the next level of innovation. These innovations offer essential help to save lots of energy, resources and conjointly to secure the specified infrastructure. The paper concentrates on the innovative technologies used for building an expert system. An expert system also contains associate Interface within users interact and an Interface Engine that performs data reasoning. The planned design interconnects multiple programming languages, hardware and software parts to build the system.

Rapid software prototyping for heterogeneous and distributed platforms

The software needs of scientists and engineers are growing and their programs are becoming more compute-heavy and problem-specific. This has led to an influx of non-expert programmers, who need to use and program high-performance computing platforms.With the continued stagnation of single-threaded performance, using hardware accelerators such as GPUs or FPGAs is necessary. Adapting software to these compute platforms is a difficult task, especially for non-expert programmers, leading to applications being unable to take advantage of new hardware or requiring extensive rewrites.We propose a programming model that allows non-experts to benefit from high-performance computing, while enabling expert programmers to take full advantage of the underlying hardware. In this model, programs are generically typed, the location of the data is encoded in the type system, and multiple dispatch is used to select functionality based on the type of the data. This enables rapid prototyping, retargeting and reuse of existing software, while allowing for hardware specific optimization if required.Our approach allows development to happen in one source language enabling domain experts and performance engineers to jointly develop a program, without the overhead, friction, and challenges associated with developing in multiple programming languages for the same project.We demonstrate the viability and the core principles of this programming model in Julia using realistic examples, showing the potential of this approach for rapid prototyping, and its applicability for real-life engineering. We focus on usability for non-expert programmers and demonstrate that the potential of the underlying hardware can be fully exploited.

Live programming in practice: A controlled experiment on state machines for robotic behaviors

Abstract Context Live programming environments are gaining momentum across multiple programming languages. A tenet of live programming is a development feedback cycle, resulting in faster development practices. Although practitioners of live programming consider it a positive inclusion in their workflow, no in-depth investigations have yet been conducted on its benefits in a realistic scenario, nor using complex API. Objective This paper carefully studies the advantage of using live programming in defining nested state machines for robot behaviors. We analyzed two important aspects of developing robotic behaviors using these machines: program comprehension and program writing. We analyzed both development practices in terms of speed and accuracy. Method We conducted two controlled experiments, one for program comprehension and another for program writing. We measured the speed and accuracy of randomized assigned participants on completing programming tasks, against a baseline. Results In a robotic behavior context, we found that a live programming system for nested state machine programs does not significantly outperform a non-live language in program comprehension nor in program writing in terms of speed and accuracy. However, the feedback of test subjects indicates their preference for the live programming system. Conclusions The results of this work seem to contradict the studies of live programming in other areas, even while participants still favor using live programming techniques. We learned that the complex API chosen in this work has a strong negative influence on the results. To the best of our knowledge, this is the first in-depth live programming experiment in a complex domain.

Design and Implementation of an Anonymous Vehicle Identification System Based on the IoT

Security has become an important issue that needs to be addressed in all cities of the world. Simultaneously, information technology is undergoing a period of great development, and it is important to exploit this development in the service of society, particularly in terms of urban security. An Anonymous Vehicle Identification (AVI) system design is thus presented in this research. Much previous research has dealt with the development and implementation of systems to identify anonymous vehicles, and all previously proposed systems appear to work efficiently; however, some are very expensive and others require the installation of many devices within a city. Further, some of them do not transfer information to a control centre in the city using the internet.The proposed AVI system presented in this paper is thus based on Internet of Things (IoT) and consists of two main parts: a handheld device used by officers, and a web application. The handheld device is used to send car licence plate number to a website which is controlled by an authorised person. The authorised person receives the data and requests information relating to the car (car number, owner’s name and mobile number, registered address, etc.) from the Central Traffic Police Directorate, before sending these to the officer’s handheld device to allow the officer to take action based on the information and instructions from the central office. The design of web application is based on several techniques and multiple programming languages including HTML, PHP, and Java Script. These languages are compatible with each other and have thus been combined to form the desired application.The proposed system was implemented practically and tested for about 50 cases; the results obtained during testing were very satisfactory and reflect good reliability within the system.

One tool, many languages: language-parametric transformation with incremental parametric syntax

We present a new approach for building source-to-source transformations that can run on multiple programming languages, based on a new way of representing programs called incremental parametric syntax. We implement this approach in Haskell in our Cubix system, and construct incremental parametric syntaxes for C, Java, JavaScript, Lua, and Python. We demonstrate a whole-program refactoring tool that runs on all of them, along with three smaller transformations that each run on several. Our evaluation shows that (1) once a transformation is written, little work is required to configure it for a new language (2) transformations built this way output readable code which preserve the structure of the original, according to participants in our human study, and (3) our transformations can still handle language corner-cases, as validated on compiler test suites.

Valection: design optimization for validation and verification studies

BackgroundPlatform-specific error profiles necessitate confirmatory studies where predictions made on data generated using one technology are additionally verified by processing the same samples on an orthogonal technology. However, verifying all predictions can be costly and redundant, and testing a subset of findings is often used to estimate the true error profile.ResultsTo determine how to create subsets of predictions for validation that maximize accuracy of global error profile inference, we developed Valection, a software program that implements multiple strategies for the selection of verification candidates. We evaluated these selection strategies on one simulated and two experimental datasets.ConclusionsValection is implemented in multiple programming languages, available at: http://labs.oicr.on.ca/boutros-lab/software/valection

Using Hands-On Physical Computing Projects to Teach Computer Programming to Biomedical Engineering Students

Rapid advancements in the multidisciplinary field of biomedical engineering (BME) require competitive engineers with skill sets in a broad range of subjects including biology, physiology, mechanics, circuits, and programming. Accordingly, such a need should be reflected in the training of BME students. Among those skills, computer programming is an essential tool that is used in a wide variety of applications. In this paper, we have provided our experience in incorporating project-based learning, a promising approach in active learning, for teaching computer programming to BME students. We describe a low-cost method for using physical, hands-on computing that directly relates to BME. Additionally, we detail our efforts to teach multiple programming languages in one semester and provide a detailed analysis of the outcomes. We also provide basic materials for other instructors to adapt to fit their own needs.

Porcupine: A visual pipeline tool for neuroimaging analysis.

The field of neuroimaging is rapidly adopting a more reproducible approach to data acquisition and analysis. Data structures and formats are being standardised and data analyses are getting more automated. However, as data analysis becomes more complicated, researchers often have to write longer analysis scripts, spanning different tools across multiple programming languages. This makes it more difficult to share or recreate code, reducing the reproducibility of the analysis. We present a tool, Porcupine, that constructs one’s analysis visually and automatically produces analysis code. The graphical representation improves understanding of the performed analysis, while retaining the flexibility of modifying the produced code manually to custom needs. Not only does Porcupine produce the analysis code, it also creates a shareable environment for running the code in the form of a Docker image. Together, this forms a reproducible way of constructing, visualising and sharing one’s analysis. Currently, Porcupine links to Nipype functionalities, which in turn accesses most standard neuroimaging analysis tools. Our goal is to release researchers from the constraints of specific implementation details, thereby freeing them to think about novel and creative ways to solve a given problem. Porcupine improves the overview researchers have of their processing pipelines, and facilitates both the development and communication of their work. This will reduce the threshold at which less expert users can generate reusable pipelines. With Porcupine, we bridge the gap between a conceptual and an implementational level of analysis and make it easier for researchers to create reproducible and shareable science. We provide a wide range of examples and documentation, as well as installer files for all platforms on our website: https://timvanmourik.github.io/Porcupine. Porcupine is free, open source, and released under the GNU General Public License v3.0.

Projected control graph for computing relevant program behaviors

Abstract Many software engineering tasks require analysis and verification of all behaviors relevant to the task. For example, all relevant behaviors must be analyzed to verify a safety or security property. An efficient algorithm must compute the relevant behaviors directly without computing all the behaviors. This is crucial in practice because it is computationally intractable if one were to compute all behaviors to find the subset of relevant behaviors. We present a mathematical foundation to define relevant behaviors and introduce the Projected Control Graph (PCG) as an abstraction to directly compute the relevant behaviors. We developed a PCG toolbox to facilitate the use of the PCG for program comprehension, analysis, and verification. The toolbox provides: (1) an interactive visual analysis mechanism, and (2) APIs to construct and use PCGs in automated analyses. The toolbox is designed to support multiple programming languages. Using the toolbox APIs, we conducted a verification case study of the Linux kernel to assess the practical benefits of using the PCG. The study shows that the PCG-based verification is faster and can verify 99% of 66,609 instances compared to the 66% instances verified by the formal verification tool used by the Linux Driver Verification (LDV) organization. This study has revealed bugs missed by the formal verification tool. The second case study is an interactive use of the PCG Smart View to detect side-channel vulnerabilities in Java bytecode.

Duplicate Detection in Programming Question Answering Communities

Community-based Question Answering (CQA) websites are attracting increasing numbers of users and contributors in recent years. However, duplicate questions frequently occur in CQA websites and are currently manually identified by the moderators. Automatic duplicate detection, on one hand, alleviates this laborious effort for moderators before taking close actions, and, on the other hand, helps question issuers quickly find answers. A number of studies have looked into related problems, but very limited works target Duplicate Detection in Programming CQA (PCQA), a branch of CQA that is dedicated to programmers. Existing works framed the task as a supervised learning problem on the question pairs and relied on only textual features. Moreover, the issue of selecting candidate duplicates from large volumes of historical questions is often un-addressed. To tackle these issues, we model duplicate detection as a two-stage “ranking-classification” problem over question pairs. In the first stage, we rank the historical questions according to their similarities to the newly issued question and select the top ranked ones as candidates to reduce the search space. In the second stage, we develop novel features that capture both textual similarity and latent semantics on question pairs, leveraging techniques in deep learning and information retrieval literature. Experiments on real-world questions about multiple programming languages demonstrate that our method works very well; in some cases, up to 25% improvement compared to the state-of-the-art benchmarks.

A multilingual and comparative approach to teaching introductory computer programming

We have experimented with a new approach to teaching computer programming to first-time programming students. The approach involved teaching multiple programming languages simultaneously. The hypot...

Live Multi-language Development and Runtime Environments

Context: Software development tools should work and behave consistently across different programming languages, so that developers do not have to familiarize themselves with new tooling for new languages. Also, being able to combine multiple programming languages in a program increases reusability, as developers do not have to recreate software frameworks and libraries in the language they develop in and can reuse existing software instead. Inquiry: However, developers often have a broad choice of tools, some of which are designed for only one specific programming language. Various Integrated Development Environments have support for multiple languages, but are usually unable to provide a consistent programming experience due to different language-specific runtime features. With regard to language integrations, common mechanisms usually use abstraction layers, such as the operating system or a network connection, which are often boundaries for tools and hence negatively affect the programming experience. Approach: In this paper, we present a novel approach for tool reuse that aims to improve the experience with regard to working with multiple high-level dynamic, object-oriented programming languages. As part of this, we build a multi-language virtual execution environment and reuse Smalltalk's live programming tools for other languages. Knowledge: An important part of our approach is to retrofit and align runtime capabilities for different languages as it is a requirement for providing consistent tools. Furthermore, it provides convenient means to reuse and even mix software libraries and frameworks written in different languages without breaking tool support. Grounding: The prototype system Squimera is an implementation of our approach and demonstrates that it is possible to reuse both development tools from a live programming system to improve the development experience as well as software artifacts from different languages to increase productivity. Importance: In the domain of polyglot programming systems, most research has focused on the integration of different languages and corresponding performance optimizations. Our work, on the other hand, focuses on tooling and the overall programming experience.

SERPENT validation and optimization with mesh adaptive search on stereolithography geometry models

The SERPENT Monte Carlo code has the unique capability to simulate neutron and gamma transport using a stereolithography (STL) geometry. The STL geometry can model irregular complex geometries often encountered, for example, in research reactors. This geometry type can be used in combination with an unstructured mesh-based interface to couple SERPENT to OpenFOAM for CFD analyses. The STL file format also allows printing the geometry model with 3D printers. This work validates SERPENT simulations based on the STL geometry using the GIACINT critical experimental facility and the YALINA Thermal subcritical experimental facility. The results and performances of SERPENT have been compared with those of the well-known MCNP code. Finally, SERPENT computing time has been significantly reduced by using its mesh adaptive search algorithm, which has been introduced to optimize simulations based on the stereolithography STL geometry, and a hybrid modeling that mixes combinatorial and STL geometries. In this work, the STL geometry model of SERPENT involved the use of multiple software and programming languages, including: CUBIT, PYTHON, C, and MATLAB.

APSIM Next Generation: Overcoming challenges in modernising a farming systems model

From 1990, the Agricultural Production Systems sIMulator (APSIM) has grown from a field-focused farming systems framework used by a small number of people, into a large collection of models used by thousands of modellers internationally. The software grew to consist of several hundred thousand lines of code in multiple programming languages. This has led to a large, complex software ecosystem that is difficult to maintain. In addition, systems modellers increasingly require software systems that integrate multiple disciplines, can represent evermore complex farming systems, can run on multiple operating systems (desktop, web, mobile), can operate at or be adjusted to multiple temporal and spatial scales (field, farm, region, continent, global) and run faster for larger simulation analyses. This is difficult to achieve in an aging framework.For these reasons, the APSIM Initiative is building the next generation of APSIM. This manuscript outlines the approach taken and lessons learnt.

Predicting Fork Visibility Performance on Programming Language Interoperability in Open Source Projects

Despite a variety of programming languages adopted in open source (OS) projects, fork variation on some languages has been minimal and slow to be adopted, and there is little research as to why this is so. We therefore employed a K-nearest neighbours (KNN) technique to predict the fork visibility performance of a productive language from a pool of programming languages adopted in projects. In total, 38 showcase OS projects from 2012 to 2016 were downloaded from the GitHub website and categorized into different levels of programming language adoption clusters. Among 33 languages, JavaScript is one of the popular languages that adopted by community. It has been predicted the language chosen when fork visibility is high can increase project longevity as a highly visible language is likely to occur more often in projects with a significant number of interoperable programming languages and high language fork count. Conversely, a low fork language reduces longevity in projects with an insignificant number of interoperable programming languages and low fork count. Our results reveal the survival of a productive language is in response to high language visibility (large fork number) and high interoperability of multiple programming languages.

On multi-language software development, cross-language links and accompanying tools: a survey of professional software developers

ContextNon-trivial software systems are written using multiple (programming) languages, which are connected by cross-language links. The existence of such links may lead to various problems during software development. There is little empirical evidence on the incidence of these problems and the experiences of professional developers in this field.AimWe want to provide empirical evidence on multi-language software development, cross-language linking, and tool support in industry, including the views of professional developers on benefits and problems in these areas.MethodsWe conducted a survey study to gather responses from 139 professional software developers.ResultsRespondents reported an average of 7 languages and 3 linked language pairs per project. Respondents saw benefits of multi-language development for the motivation of developers and the translation of requirements, but problems in understandability and changeability. Over 90% of respondents reported problems related to cross-language linking. Developers universally agree on the usefulness of tool support.ConclusionsMulti-language programming and cross-language linking seem common but lead to several problems. We suggest that future practical as well as research efforts focus on these issues by creating appropriate tool support and by developing better techniques for cross-language linking for improved changeability and understandability.

Multilingual Source Code Analysis: A Systematic Literature Review

Contemporary software applications are developed using cross-language artifacts, which are interdependent with each other. The source code analysis of these applications requires the extraction and examination of artifacts, which are build using multiple programming languages along with their dependencies. A large number of studies presented on multilingual source code analysis and its applications in the last one and half decade. The objective of this systematic literature review (SLR) is to summarize state of the art and prominent areas for future research. This SLR is based on different techniques, tools, and methodologies to analyze multilingual source code applications. We finalized 56 multi-discipline published papers relevant to multilingual source code analysis and its applications out of 3820 papers, filtered through multi-stage search criterion. Based on our findings, we highlight research gaps and challenges in the field of multilingual applications. The research findings are presented in the form of research problems, research contributions, challenges, and future prospects. We identified 46 research issues and requirements for analyzing multilingual applications and grouped them in 13 different software engineering domains. We examined the research contributions and mapped them with individual research problems. We presented the research contributions in the form of tools techniques and approaches that are presented in the form of research models, platforms, frameworks, prototype models, and case studies. Every research has its limitations or prospects for future research. We highlighted the limitations and future perspectives and grouped them in various software engineering domains. Most of the research trends and potential research areas are identified in static source code analysis, program comprehension, refactoring, reverse engineering, detection, and traceability of cross-language links, code coverage, security analysis, cross-language parsing, and abstraction of source code models.

A taxonomy of cross-language linking mechanisms in open source frameworks

Non-trivial software systems are written using multiple programming languages. While the logic of a system is encoded using one or several general-purpose languages, more specialized parts of the systems are realized using domain-specific languages for aspects such as the user interface, configuration mechanisms, querying of databases, or support for internationalization. To bind all of these different parts together, the artifacts in individual languages are connected by using cross-language links which address artifacts across language boundaries. Many different ways for specifying and using such links have been conceived, and developers have to adhere to the concrete rules mandated by the runtime, framework or library which later performs the link resolution. In this paper, we present a taxonomy of the mechanisms of encoding cross-language linking in well-known open source frameworks from a developers perspective, which shows the choices that have been made and the options available in practice. We describe the process we followed, which is based in part on a survey of language combinations on GitHub and a survey of professional developers, list the dimensions and characteristics of our taxonomy in full, show the classifications of 22 frameworks and mechanisms, four of which are described in detail, and discuss the impact of the choices on application developers.