In this thesis, the first chapter provides the general description of this interpreter. The second chapter contains a formal definition of the syntax of BASIC along with an introduction to the semantics. The third chapter contains the design of data structure. The fourth chapter contains the description of algorithms along with stages for testing the interpreter and the design of debug output. The stages and actions-are represented internally to the computer in tabular forms. For statement parsing working syntax equations are established. They serve as standards for the conversion of source statements into object pseudocodes. As the statement is parsed for legal form, pseudocodes for this statement are created. For pseudocode execution, pseudocodes are represented internally to the computer in tabular forms.

[pt] O Common Language Runtime (CLR) é uma plataforma criada com o objetivo de facilitar a interoperabilidade entre diferentes linguagens de programação, através de uma linguagem intermediária (a Common Intermediate Language, ou CIL) e um sistema de tipos comum (o Common Type System, ou CTS). Lua é uma linguagem de script flexível e de sintaxe simples; linguagens de script são frequentemente usadas para juntar componentes escritos em outras linguagens, para construir protótipos de aplicações, e em arquivos de configuração. Este trabalho apresenta duas abordagens de integração entre a linguagem Lua e o CLR, com o objetivo de permitir que scripts Lua instanciem e usem componentes escritos para o CLR. A primeira abordagem é a de criar uma ponte entre o interpretador Lua e o CLR, sem modificar o interpretador. Os recursos e a implementação desta ponte são mostrados, e ela é comparada com trabalhos que seguem a mesma abordagem. A segunda abordagem é a de compilar as instruções da máquina virtual do interpretador Lua para instruções da Common Intermediate Language Do CLR, sem introduzir mudanças na linguagem Lua. A implementação de um compilador de instruções Lua para CIL é mostrada, e o desempenho de scripts compilados por ele é comparado com o desempenho dos mesmos scripts executados pelo interpretador Lua e com o de scripts equivalentes compilados por outros compiladores de linguagens de script para o CLR. / [en] The Common Language Runtime (CLR) is a platform that aims to make the interoperability among different programming languages easier, by using a common language (the Common Intermediate Language, or CIL) and a common type system (the Common Type System, or CTS). Lua is a flexible scripting language with a simple syntax; scripting languages are frequently used to join components written in other languages, to build application prototypes, and in configuration files. This work presents two approachs for integratiion between the Lua language and the CLR, with the objective of allowing Lua scripts to instantiate and use components written for the CLR. The first approach is to create a bridge between the Lua interpreter and the CLR, without changing the interpreter. The features and implementation of this bridge are shown, and it is compared with other work following the same approach. The second approach is to compile the virtual-machine instructions of the Lua interpreter to instructions of the CLR s Common Intermediate Language, without introducing changes to the Lua language. The implementation of a Lua instructions to CIL compiler is shown, and the performance of scripts compiled by it is compared with the performance of the same scripts run by the Lua interpreter and with the performance of equivalent scripts compiled by compilers of other scripting language to the CLR.

Digital games are part of our culture and have gained significant attention over the last decade. The growing capabilities of home computers, gaming consoles and mobile phones allow current games to visualise 3D virtual worlds, photo-realistic characters and the inclusion of complex physical simulations. The growing computational power of those devices enables the usage of complex algorithms while visualising data. Therefore, opportunities arise for developers of interactive products such as digital games which introduce new, challenging and exciting elements to the next generation of highly interactive software systems. Two of those challenges, which current systems do not address adequately, are design support for creating Intelligent Virtual Agents and more believable non-player characters for immersive game-play. We start in this thesis by addressing the agent design support first and then extend the research, addressing the second challenge. The main contributions of this thesis are: - The POSH-SHARP system is a framework for the development of game agents. The platform is modular, extendable, offers multi-platform support and advanced software development features such as behaviour inspection and behaviour versioning. The framework additionally integrates an advanced information exchange mechanism supporting loose behaviour coupling. - The Agile behaviour design methodology integrates agile software development and agent design. To guide users, the approach presents a work-flow for agent design and guiding heuristics for their development. - The action selection augmentation ERGo introduces a "white-box" solution to altering existing agent frameworks, making their agents less deterministic. It augments selected behaviours with a bio-mimetic memory to track and adjust their activation over time. With the new approach to agent design, the development of "deepagent" behaviour for digital adversaries and advanced tools supporting their design is given. Such mechanisms should enable developers to build robust non-player characters that act more human-like in an efficient and robust manner. Within this thesis, different strategies are identified to support the design of agents in a more robust manner and to guide developers. These discussed mechanisms are then evolved to develop and design Intelligent Virtual Agents. Because humans are still the best measurement for human-likeness, the evolutionary cycle involves feedback given by human players.

The aim of this Diploma thesis is to get acquitained with the approaches to parallel programming and possibilities of their practical implementation, including possibilities of their usage in management. An important part of the Diploma thesis is the practical implementation of parallel program in a PC cluster environment, which was implemented in computer laboratory of Faculty of Management VŠE. The practical part consists of an example of decision-making under uncertainty (risk) which is solved with the employment of the Monte Carlo method.

With the amount of programming languages currently available there is a high risk of confusion anddoubtfulness in aspiring programmers of which to choose. It may be motivating for a beginner tochoose “the perfect language” when starting, to avoid learning multiple languages. This thesiscompares three popular languages on three separate aspects, their syntax, usefulness in differentareas, and performance in terms of speed. Syntax wise the results varied with some aspects beingvery similar across all three languages to completely different in others. In terms of usefulness inspecific areas the languages flexibility allowed them to develop applications in most fields, while beingdominant in different areas. The speed comparison resulted in python being the slowest across alltests, with Java and Javascript (running inside Nodejs) competing for first place.

The combination of solo percussion with live electronics is one of the newest genres of music today. An outgrowth of the instrument and fixed media genre, live electronic music combines a musician on stage performing with a computer or other technology performing real-time processes. This document is a collection of five works scored for percussion and the computer program Max intended for the collegiate level. In addition, there are explanations and schematics of the patches to help the performer learn how to use Max. This document could serve as supplemental material for an undergraduate percussion curriculum to help students gain experience performing with live electronics. Most students in university music departments are not exposed to technology unless they seek it out themselves. This may cause many student instrumentalists to be hesitant to play works with technology. However, as performing with electronics becomes more common, music students without this experience are at a disadvantage. Basic knowledge of audio equipment, having experience using a microphone, sound recording, and other technical know-how is essential to becoming a successful performer in a contemporary setting. Being able to perform with electronics creates new opportunities for repertoire, collaboration, and performance. Many universities are starting new programs dedicated to interdisciplinary studies such as digital humanities. These collaborative efforts bring together musicians, dancers, writers, visual artists, computer scientists, and others to create new work. Music students who have some background in performing and working with electronics could be a part of these collaborative efforts and help produce compelling, original work.

<p>The need for debugging tools for declarative programming languages has increased due to the rapid development of modeling and simulation tools/programs. Declarative equation-based programming languages have the problem of equation systems being over-, or under-constrained. This means that the system of equations has more equations than variables or more variables than equations respectively, making the system of equations unsolvable. In this study a static debugger is implemented in OpenModelica compiler for the equation-based programming language Modelica to make it easier for the programmer or modeler to locate the equation/s causing the unconstrained system of equations. The debugging techniques used by the debugger are developed by Peter Bunus. Those techniques are able to detect unconstrained systems of equations and give solutions by identifying the minimal set ofequation/s that should be removed or which variable/s should be added to an equation/s to make the system solvable. In this study the debugging techniques for detecting and giving a solution for over-constrained system of equations are shown suitable to be used for the programming language Modelica in the OpenModelica compiler.</p>

With growing trend in "cloud computing" and increase in the data moving into the Internet, the need to store large amounts of data by service providers such as Google, Yahoo and Microsoft has increased over time. Now, more than ever, there is a need to efficiently and securely store large amounts of data. This thesis presents an implementation of a Ramp Scheme that confidentially splits a data file into a configurable number of parts or shares of equal size such that a subset of those shares can recover the data entirely. Furthermore, the implementation supports a threshold for data compromise and data verification to verify that the data parts have not been tampered with. This thesis addresses two key problems faced in large-scale data storage, namely, data availability and confidentiality.

No description available.

One important aspect of the quality of programming languages is the effort required by a programmer to understand code written in the language. A historical case where this issue was at the forefront was in the debate between the proponents of high-level languages (HLL) and Assembly languages, where the main argument for HLLs were that they were easier for people to understand. Being one out of a series of articles arguing for a unified theory for software engineering, this article proposes the use of a specific theoretical model from the discipline of cognitive psychology as a tool for predicting language comprehension effort. Describing human problem solving faculties, the ACT-R model [Anderson and Lebiere 1998] predicts that the effort of understanding a program written in C is only 36,5% of the effort of understanding a comparable program written in Assembly. In order to validate the theory, an experiment was performed where a number of engineering students were exposed to tasks of program comprehension. This empirical assessment demonstrated that the effort of understanding a program written in C is 32,5% of the effort of understanding a comparable program written in Assembly. Comparing the results of the theoretical predictions and the empirical assessments of program comprehension effort, we find that the theoretical model performs surprisingly well. The prediction error for the execution of an Assembly program was 5,1% while the error for C was 6,8%. The prediction error for the ratio between the two program languages amounted to 12,6%. / <p>QC 20130618</p>