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>

This thesis presents research to build and evaluate embedding of a textual form of state machines into high-level programming languages. The work entailed adding state machine syntax and code generation to the Umple model-oriented programming technology. The added concepts include states, transitions, actions, and composite states as found in the Unified Modeling Language (UML). This approach allows software developers to take advantage of the modeling abstractions in their textual environments, without sacrificing the value added of visual modeling. Our efforts in developing state machines in Umple followed a test-driven approach to ensure high quality and usability of the technology. We have also developed a syntax-directed editor for Umple, similar to those available to other high-level programming languages. We conducted a grounded theory study of Umple users and used the findings iteratively to guide our experimental development. Finally, we conducted a controlled experiment to evaluate the effectiveness of our approach. By enhancing the code to be almost as expressive as the model, we further support model-code duality; the notion that both model and code are two faces for the same coin. Systems can be and should be equally-well specified textually and diagrammatically. Such duality will benefit both modelers and coders alike. Our work suggests that code enhanced with state machine modeling abstractions is semantically equivalent to visual state machine models. The flow of the thesis is as follows; the research hypothesis and questions are presented in “Chapter 1: Introduction”. The background is explored in “Chapter 2: Background”. “Chapter 3: Syntax and semantics of simple state machines” and “Chapter 4: Syntax and semantics of composite state machines” investigate simple and composite state machines in Umple, respectively. “Chapter 5: Implementation of composite state machines” presents the approach we adopt for the implementation of composite state machines that avoids explosion of the amount of generated code. From this point on, the thesis presents empirical work. A grounded theory study is presented in “Chapter 6: A Grounded theory study of Umple”, followed by a controlled experiment in “Chapter 7: Experimentation”. These two chapters constitute our validation and evaluation of Umple research. Related and future work is presented in “Chapter 8: Related work”.

Graphics Processing Units (GPUs) have become a competitive accelerator for non-graphics applications, mainly driven by the improvements in GPU programmability. Although the Compute Unified Device Architecture (CUDA) is a simple C-like interface for programming NVIDIA GPUs, porting applications to CUDA remains a challenge to average programmers. In particular, CUDA places on the programmer the burden of packaging GPU code in separate functions, of explicitly managing data transfer between the host and GPU memories, and of manually optimizing the utilization of the GPU memory. We have designed hiCUDA, a high-level directive-based language for CUDA programming. It allows programmers to perform these tedious tasks in a simpler manner, and directly to the sequential code. We have also prototyped a compiler that translates a hiCUDA program to a CUDA program and can handle real-world applications. Experiments using seven standard CUDA benchmarks show that the simplicity hiCUDA provides comes at no expense to performance.

Graphics Processing Units (GPUs) have become a competitive accelerator for non-graphics applications, mainly driven by the improvements in GPU programmability. Although the Compute Unified Device Architecture (CUDA) is a simple C-like interface for programming NVIDIA GPUs, porting applications to CUDA remains a challenge to average programmers. In particular, CUDA places on the programmer the burden of packaging GPU code in separate functions, of explicitly managing data transfer between the host and GPU memories, and of manually optimizing the utilization of the GPU memory. We have designed hiCUDA, a high-level directive-based language for CUDA programming. It allows programmers to perform these tedious tasks in a simpler manner, and directly to the sequential code. We have also prototyped a compiler that translates a hiCUDA program to a CUDA program and can handle real-world applications. Experiments using seven standard CUDA benchmarks show that the simplicity hiCUDA provides comes at no expense to performance.