Implementation of a Modula 2 subset compiler supporting a \u27C\u27 language interface using commonly available UNIX tools

Modula 2 has been proposed as an appropriate language for systems programming. Smaller than PASCAL but more structured than \u27C\ Modula 2 is intended to be relatively easy to implement. A realization of a subset of Modula 2 for the MC68010 microprocessor is presented. Widely available UNIX tools and the \u27C language are used for the implementation. A mechanism for calling \u27C language functions from Modula 2 (and vice versa) is suggested. Critical source code, grammar, and an extensive bibliography pertinent to the implementation are included as appendices

Be My Guest: Normalizing and Compiling Programs using a Host Language

In programming language research, normalization is a process of fundamental importance to the theory of computing and reasoning about programs.In practice, on the other hand, compilation is a process that transforms programs in a language to machine code, and thus makes the programminglanguage a usable one. In this thesis, we investigate means of normalizing and compiling programs in a language using another language as the "host".Leveraging a host to work with programs of a "guest" language enables reuse of the host\u27s features that would otherwise be strenuous to develop.The specific tools of interest are Normalization by Evaluation and Embedded Domain-Specific Languages, both of which rely on a host language for their purposes. These tools are applied to solve problems in three different domains: to show that exponentials (or closures) can be eliminated from a categorical combinatory calculus, to propose a new proof technique based on normalization for showing noninterference, and to enable the programming of resource-constrained IoT devices from Haskell

Inter-module code analysis techniques for software maintenance

The research described in this thesis addresses itself to the problem of maintaining large, undocumented systems written in languages that contain a module construct. Emphasis is placed on developing techniques for analysing the code of these systems, thereby helping a maintenance programmer to understand a system. Techniques for improving the structure of a system are presented. These techniques help make the code of a system easier to understand. All the code analysis techniques described in this thesis involve reasoning with, and manipulating, graphical representations of a system. To help with these graph manipulations, a set of graph operations are developed that allow a maintenance programmer to combine graphs to create a bigger graph, and to extract subgraphs from a given graph that satisfy specified constraints. A relational database schema is developed to represent the information needed for inter-module code analysis. Pointers are given as to how this database can be used for inter-module code analysis

Programming Language interoperability in cross-platform software development

Recent years have witnessed the rising popularity of software that are constructed by combining various modules written in different programming languages. While the coexistence of multiple programming languages within the same codebase might bring certain benefits such as reusability and the ability to exploit the unique power of each language, this architecture certainly adds significant complexity to the development and maintenance process of such systems. This thesis proposes an approach to alleviate the pain of language interoperability in those systems by automating the binding code generation process between different languages. The proposed method uses the metadata extracted from the Interface Description Language (IDL) to systematically generate the Application Programming Interface (API) in each involved language. As a result, the code written in one language can seamlessly interact with code developed in others. The experiment results showed that the developed code generator has improved the stability, scalability, and modularity of multi-language software systems

Performance-Driven Interface Contract Enforcement for Scientific Components

Several performance-driven approaches to selectively enforce interface contracts for scientific components are investigated. The goal is to facilitate debugging deployed applications built from plug-and-play components while keeping the cost of enforcement within acceptable overhead limits. This paper describes a study of global enforcement using a priori execution cost estimates obtained from traces. Thirteen trials are formed from five, single-component programs. Enforcement experiments conducted using twenty-three enforcement policies are used to determine the nature of exercised contracts and the impact of a variety of sampling strategies. Performance-driven enforcement appears to be best suited to programs that exercise moderately expensive contracts