As GPGPU computing becomes more popular, it will be used to tackle a wider range of problems. However, due to the current state of GPGPU programming, programmers are typically required to be familiar with the architecture of the GPU in order to effectively program it. Fortunately, there are software packages that attempt to simplify GPGPU programming in higher-level languages such as Java and Python. However, these software packages do not attempt to abstract the GPU-acceleration process completely. Instead, they require programmers to be somewhat familiar with the traditional GPGPU programming model which involves some understanding of GPU threads and kernels. In addition, prior to using these software packages, programmers are required to transform the data they would like to operate on into arrays of primitive data. Typically, such software packages restrict the use of object-oriented programming when implementing the code to operate on this data. This thesis presents GPUMap, which is a proof-of-concept GPU-accelerated map function for Python. GPUMap aims to hide all the details of the GPU from the programmer, and allows the programmer to accelerate programs written in normal Python code that operate on arbitrarily nested objects using a majority of Python syntax. Using GPUMap, certain types of Python programs are able to be accelerated up to 100 times over normal Python code. There are also software packages that provide simplified GPU acceleration to distributed computing frameworks such as MapReduce and Spark. Unfortunately, these packages do not provide a completely abstracted GPU programming experience, which conflicts with the purpose of the distributed computing frameworks: to abstract the underlying distributed system. This thesis also presents GPU-accelerated RDD (GPURDD), which is a type of Spark Resilient Distributed Dataset (RDD) which incorporates GPUMap into its map, filter, and foreach methods in order to allow Spark applicatons to make use of the abstracted GPU acceleration provided by GPUMap.

The program MANDO efficiently performs computations involving pairs of operators, a single operator, and operators applied to functions, saving time and cost over pencil-·and-paper methods. A versatile but compact data structure, defined under SPIT-BOL's facility for creation of datatypes, contains the operators (and functions) and provides a means for systematically referencing their relevant parts. On input, functions and operators are written in a restricted but natural string format, for which the program can readily convert them to the internal data structure. Central to the method of operation of the derivative routine is its ability to differentiate a function written as a string. This allows for a certain compactness in the internal form. To counteract the relative slowness of string processing in the derivative routine, the program keeps a table of derivatives repeated during the processing . The table is checked for the presence of the function and its derivative before the derivative sequence is applied. Some simplification is performed. The simplification relies on the ordering sequence, followed by a sequence which cancels or combines terms that are alike, except, in general, for numerical multipliers.

Tato práce si klade za cíl navrhnout a implementovat experimentální programovací jazyk s podporou uživatelsky definovaných syntaktických konstrukcí. Nový jazyk je kompilován do nativní binární podoby a vyžaduje statickou typovou disciplínu v době překladu. Jazyk se skládá ze dvou hlavních komponent. První z nich je minimalistické jádro založené na principech zásobníkově orientovaných jazyků. Druhou částí je mechanismus pro definici nových syntaktických konstrukcí uživatelem. Poté jsou shrnuty poznatky nabyté při návrhu a experimentování s prototypem překladače tohoto jazyka.

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.

The purpose of this thesis was the development of a generalized structural-dynamics computer program to calculate the response of multi-degree-of-freedom systems. The user of this computer program, having a limited background in matrix algebra and vibrational analysis, can gain numerical and graphical information concerning the dynamic response of multi-degree-of-freedom structures. The user, with a minimal amount of FORTRAN experience, will find this thesis ideally suited for his needs.

The Cognitive Dimensions of Notations (CDs) is an evaluation framework consisting of a set of heuristics meant to be used as discussion tools for usability evaluation of notational systems. Programming languages and frameworks are examples of notational systems, and the development of new such languages and frameworks could improve by analysing the properties with CDs. However, the CDs framework has been criticized for not truly being a scientific method as well as being unfit to be used in certain specific research fields, even though the general nature of the framework allows for it. In this paper, the CDs are applied to evaluate SwiftUI, a declarative user interface framework for iOS. The possibilities and limitations of CD is discussed in relation to this CD example, as well as previous criticism and other evaluation frameworks. The paper concludes with visions for the future of the CDs framework. / Cognitive Dimensions of Notations (CDs) är ett utvärderingsramverk bestående av ett flertal heuristiker vars syfte är att användas som diskussionsverktyg vid användarbarhetsutvärderingar av notationssystem. Utvecklingen av nya notationssystem, exemplevis nya programmeringsspråk och ramverk, kan förbättras genom att använda CDs för att analysera dess egenskaper. Kritik har dock riktats mot CDs i att metoden inte är vetenskaplig nog samt att den inte är applicerbar på vissa specifika forskningsområden trots utvärderingsramverkets breda användningsområde. I denna masteruppsats används CDs för att utvärdera SwiftUI, ett deklarativt ramverk för att skapa användargränssnitt på iOS. Möjligheter och begränsningar av att använda CDs i detta syfte diskuteras tillsammans med föregående kritik och relaterade utvärderingsramverk. Avslutningsvis diskuteras framtida möjligheter för CDs.

<p>Analizirani su važniji predstavnici čisto-funkcionalnih programskih jezika i važniji načini njihove implementacije . Na osnovu uočenih osobina, jezici su podeljeni na klase. Definisan je novi medjujezik za implementaciju čisto-funkcionalnih programskih jezika kojim je moguće predstaviti vi&scaron;e klasa funkcionalnih programskih jezika nego postojećim medjujezicima. Konstruisani su algoritmi translacije 4 vi&scaron;a funkcionalna jezika u medjujezik i algoritmi prevodjenja medjujezika u ma&scaron;inske jezike 5 apstraktnih ma&scaron;ina. Diskutovani su neki praktični aspekti implementacije nedjujezika i izvr&scaron;ene analize performansi nekoliko&nbsp; realizovanih prevodilaca.</p> / <p>Important purely functional languages and important ways of their implementation are analyzed. Based on observed characteristics, functional languages are divided into appropriate classes. A new specialized intermediate code for implementation of functional programming languages is defined, which enable a representation of more classes of high-level functional languages than existing intermediate codes. Algorithms for translation of four high-level functional languages into intermediate code are constructed, as well as algorithms for compilation of intermediate code into five abstract machine languages. Performance of several implemented compilers are analyzed.</p>

Our work applies the dataflow algorithm to an area outside its traditional scope: functional languages. Our approach relies on a monadic intermediate language that provides low-level, imperative features like computed jumps and explicit allocations, while at the same time supporting high-level, functional-language features like case discrimination and partial application. We prototyped our work in Haskell using the HOOPL library and this dissertation shows numerous examples demonstrating its use. We prove the efficacy of our approach by giving a novel description of the uncurrying optimization in terms of the dataflow algorithm, as well as a complete implementation of the optimization using HOOPL.

Game engine programming involves a great number of software components, many of which perform similar tasks; for example, memory allocation must take place in the renderer as well as in the creation routines while other tasks such as error logging must take place everywhere. One area of all games which is critical to the success of the game is that of game balance and tuning. These balancing initiatives cut across all areas of code from the player and AI to the mission manager. In computer science, we’ve come to call these types of concerns “cross cutting”. Aspect oriented programming was developed, in part, to solve the problems of cross cutting: employing “advice” which can be incorporated across different pieces of functionality. Yet, despite the prevalence of a solution, very little work has been done to bring cross cutting to game engine programming. Additionally, the discipline involves a heavy amount of code rewriting and reuse while simultaneously relying on many common design patterns that are copied from one project to another. In the case of game balance, the code may be wildly different across two different games despite the fact that similar tasks are being done. These two problems are exacerbated by the fact that almost every game engine has its own custom DSL (domain specific language) unique to that situation. If a DSL could showcase the areas of cross cutting concerns while highlighting the ability to capture design patterns that can be used across games, significant productivity savings could be achieved while simultaneously creating a common thread for discussion of shared problems within the domain. This dissertation sought to do exactly that- create a metalanguage called GAMESPECT which supports multiple styles of DSLs while bringing aspect-oriented programming into the DSL’s to make them DSAL (domain specific aspect languages). The example cross cutting concern was game balance and tuning since it’s so pervasive and important to gaming. We have created GAMESPECT as a language and a composition framework which can assist engine developers and game designers in balancing their games, forming one central place for game balancing concerns even while these concerns may cross different languages and locations inside the source code. Generality was measured by showcasing the composition specifications in multiple contexts and languages. In addition to evaluating generality and performance metrics, effectiveness was be measured. Specifically, comparisons were made between a balancing initiative when performed with GAMESPECT vs a traditional methodology. In doing so, this work shows a clear advantage to using a Metalanguage such as GAMESPECT for this task. In general, a line of code reduction of 9-40% per task was achieved with negligible effects to performance. The use of a metalanguage in Unreal Engine 4 is a starting point to further discussions concerning other game engines. In addition, this work has implications beyond video game programming. The work described highlights benefits which might be achieved in other disciplines where design pattern implementations and cross-cutting concern usage is high; the real time simulation field and the field of Windows GUI programming are two examples of future domains.

This thesis presents Lighthouse, an experimental branch of the Haskell-based House operating system which integrates Li et al.'s Lightweight Concurrency framework. First and foremost, it improves House's viability as a "real operating system" by providing a new extensible scheduler framework which makes it easy to experiment with different scheduling policies. In particular, Lighthouse extends Concurrent Haskell with thread priority and implements a priority-based scheduler which significantly improves system responsiveness when compared with GHC's normal round-robin scheduler. Even while doing this, it improves on House's claim of being "written in Haskell" by moving a whole subsystem out of the complex C-based runtime system and into Haskell itself. In addition, Lighthouse also includes an alternate, simpler implementation of Lightweight Concurrency which takes advantage of House's unique setting (running directly on uniprocessor x86 hardware). This experience sheds light on areas that need further attention before the system can truly be viable---primarily interactions between blackholing and interrupt handling. In particular, this thesis uncovers a potential case of self-deadlock and suggests potential solutions. Finally, this work offers further insight into the viability of using high-level languages such as Haskell for systems programming. Although laziness and blackholing present unique problems, many parts of the system are still much easier to express in Haskell than traditional languages such as C.