Type classes, first proposed during the design of the Haskell programming language, extend standard type systems to support overloaded functions. Since their introduction, type classes have been used to address a range of problems, from typing ordering and arithmetic operators to describing heterogeneous lists and limited subtyping. However, while type class programming is useful for a variety of practical problems, its wider use is limited by the inexpressiveness and hidden complexity of current mechanisms. We propose two improvements to existing class systems. First, we introduce several novel language features, instance chains and explicit failure, that increase the expressiveness of type classes while providing more direct expression of current idioms. To validate these features, we have built an implementation of these features, demonstrating their use in a practical setting and their integration with type reconstruction for a Hindley-Milner type system. Second, we define a set-based semantics for type classes that provides a sound basis for reasoning about type class systems, their implementations, and the meanings of programs that use them.

Rust is a relatively new programming language with a unique memory model designed to provide the ease of use of a high-level language as well as the power and control of a low-level language while preserving memory safety. In order to prove the safety and correctness of Rust and to provide analysis tools for its use cases, it is necessary to construct a formal semantics of the language. Existing efforts to construct such a semantic model are limited in their scope and none to date have successfully captured the complete functionality of the language. This thesis focuses on the K-Rust implementation, which is implemented in a rewrite-based semantic framework called K, and expands it to include a larger subset of the Rust language. The K framework allows Rust programs to be executed by the defined semantic model, and the implementation is tested with several Rust programs by comparing the results of execution to the Rust compiler itself.

This report documents a Process Control Language. It was written to provide an easy-to-use, user-friendly language to control a manufacturing-type process. It is not assumed the user is proficient or even familiar with any computer languages. The user should be able to grasp the simple set of commands available and begin writing user programs in a short period of time. Emphasis has been placed on error messages to inform the user of the type of error and enough information to correct it. The language was written in PDP-11 assembly language and run on a 11/34 computer in the Microcomputer Laboratory at the University of Central Florida.

This thesis discusses PRIMM which stands for Parallel Remote Interactive Management Model. PRIMM is a framework for object oriented applications that relies on grid computing. It works as an interface between the remote applications and the parallel computing system. The thesis shows the capabilities that could be achieved from PRIMM architecture.

Nowadays, event processing is becoming the backbone of many applications. Therefore, it is necessary to provide suitable abstractions to properly modularize the concerns that appear in event-driven applications. We identify four categories of languages that support event-driven programming, and identify their shortcomings in achieving modularity in the implementation of applications. We propose gummy modules and their implementation in the GummyJ language as a solution. Gummy modules have well-defined event-based interfaces, and can have a primitive or a composite structure. Composite gummy modules are means to group a set of correlated event processing concerns and restrict the visibility of events among them. We provide an example usage of gummy modules, and discuss their event processing semantics.

Multi-core processors are now ubiquitous and are widely seen as the most viable means of delivering performance with increasing transistor densities. However, this potential can only be realised if the application programs are suitably parallel. Applications can either be written in parallel from scratch or converted from existing sequential programs. Regardless of how applications are parallelised, the code must be efficiently mapped onto the underlying platform to fully exploit the hardware’s potential. This thesis addresses the problem of finding the best mappings of data and streaming parallelism—two types of parallelism that exist in broad and important domains such as scientific, signal processing and media applications. Despite significant progress having been made over the past few decades, state-of-the-art mapping approaches still largely rely upon hand-crafted, architecture-specific heuristics. Developing a heuristic by hand, however, often requiresmonths of development time. Asmulticore designs become increasingly diverse and complex, manually tuning a heuristic for a wide range of architectures is no longer feasible. What are needed are innovative techniques that can automatically scale with advances in multi-core technologies. In this thesis two distinct areas of computer science, namely parallel compiler design and machine learning, are brought together to develop new compiler-based mapping techniques. Using machine learning, it is possible to automatically build highquality mapping schemes, which adapt to evolving architectures, with little human involvement. First, two techniques are proposed to find the best mapping of data parallelism. The first technique predicts whether parallel execution of a data parallel candidate is profitable on the underlying architecture. On a typical multi-core platform, it achieves almost the same (and sometimes a better) level of performance when compared to the manually parallelised code developed by independent experts. For a profitable candidate, the second technique predicts how many threads should be used to execute the candidate across different program inputs. The second technique achieves, on average, over 96% of the maximum available performance on two different multi-core platforms. Next, a new approach is developed for partitioning stream applications. This approach predicts the ideal partitioning structure for a given stream application. Based on the prediction, a compiler can rapidly search the program space (without executing any code) to generate a good partition. It achieves, on average, a 1.90x speedup over the already tuned partitioning scheme of a state-of-the-art streaming compiler.

No description available.

Typescript. / Digitized by Kansas Correctional Industries

Linguagem para programação adaptativa se apresenta como um tema relativo às tecnologias adaptativas que suscita muitas pesquisas, até que venha a se constituir em mais uma ferramenta disponível ao programador. Nessa perspectiva, esta dissertação apresenta uma linguagem de alto nível, básica, que permita a geração de código adaptativo, bem como os requisitos e características de uma linguagem dessa natureza, recomendações sobre como projetar um software nessa linguagem e a representação gráfica do mesmo, o respectivo compilador e o ambiente de run-time no qual os programas serão executados. Apresenta, ainda, um exemplo de um programa fonte escrito na linguagem proposta. / Programming Languages for coding adaptive programs constitute a very rich research subject in the field of adaptive technology. It aims to offer a tool for programmers to express adaptive programs in a user-friendly, high-level, machine- readable, abstract notation. This MSc thesis presents the specification of requirements and desirable attributes for high-level languages allowing the automatic generation of adaptive code, and recommends a design methodology for conceiving and implementing adaptive programs using such languages as well. A graphical notation is suggested for that purpose, a compiler and a run-time environment are also considered and described. An example is given of the design and semi-formal specification of an adaptive software with the help of the suggested graphical notation, and finally the corresponding source program is encoded in the proposed language and executed.

This thesis is a textual analysis and discourse analysis that examines the social and programmatic construction of the videogame Minecraft by interrogating how code, design, and fan modifications limit and facilitate play in and outside the game. This thesis will argue that the constitution of gender--and subjectivity, more broadly--is reflected in the language, space, and bodies that shape the boundaries of the virtual world. What makes a player "cyborgian" when they embody a virtual avatar may have less to do the abstraction of agency into a computerized self and more to do with the way in which humans create and maintain conduits to exist between worlds that are both digital and material.