Thesis (MScEng)--Stellenbosch University, 2002. / ENGLISH ABSTRACT: This report describes the development of a Java Bytecode Compiler (JBC) for the 8051 micro-controller. Bytecodes are found in the class file generated when a Java source file is compiled with the java compiler (javac). On Java platforms, the Java Virtual Machine (JVM) interprets and executes the bytecodes. Currently existing Java platforms do not support programming the 8051 using Java. As an 8-bit micro-controller with only 64 KB of total memory, the 8051's word size and memory is too limited to implement a NM. Moreover, full applications of the 8051 require that it handles hardware interrupts and access 110 ports and special registers. This thesis proposes a JBC to compile the standard bytecodes found in the class file and generate equivalent assembly code that can run on the 8051. The JBC was tested on the 8051 compatible AT89C52*44 micro-controller with a program that simulates an irrigation controller. The code generated by the JBC executes correctly but is large in size and runs slower than code of a program written in assembly. Conclusions drawn are that the JBC can be used to compile Java programs intended for the 8051 and its family of micro-controllers. In particular, it is especially a good tool for people who prefer Java to other languages. The JBC is suitable for smaller programs that do not have efficiency as a major requirement. / AFRIKAANSE OPSOMMING: Hierdie tesis beskryf die ontwikkeling van 'n Java "Bytecode" samesteller (Java Bytecode Compiler, JBC) vir die 8051 mikro beheerder argitektuur. "Bytecodes" is die produk van die standaard Java samesteller "javac" en word deur 'n platform spesifieke Java Virtuele Masjien gelees en uitgevoer. Geen NM is huidig beskikbaar vir die 8051 argitektuur nie. Die gekose 8-bis 8051 mikro beheerder het 'n beperkte interne geheue van 64kB. Hierdie beperking maak dit nie geskik vir 'n IVM nie. Daar moet ook voorsiening gemaak word om hardeware onderbrekings te hantering en te kan kommunikeer met die poorte en spesiale registers van die mikro beheerder. JBC word ontwikkel wat die standaard "Bytecode" kompileer na geskikte masjien kode wat dan op die mikro beheerder gebruik kan word. Die JBC is ontwikkel en toets en 'n eenvoudige besproeiing program is geskryf om op 'n Atmel AT89C52*44 te loop. Die kode werk goed maar is nog nie geoptimeer nie en loop onnodig stadig. Optimerings metodes word aanbeveel en bespreek. Die gevolgtrekking is dat die huidige JBC kan gebruik word om Java kode te skryfvir die 8051 beheerder. Dit maak die hardeware platform nou beskikbaar aan Java programmeerders. Daar moet wel gelet word dat die JBC op die oomblik net geskik is vir klein programme en waar spoed nie die primêre vereiste is nie.

Nowadays, most computer systems are equipped with powerful parallel devices such as Graphics Processing Units (GPUs). They are present in almost every computer system including mobile devices, tablets, desktop computers and servers. These parallel systems have unlocked the possibility for many scientists and companies to process significant amounts of data in shorter time. But the usage of these parallel systems is very challenging due to their programming complexity. The most common programming languages for GPUs, such as OpenCL and CUDA, are created for expert programmers, where developers are required to know hardware details to use GPUs. However, many users of heterogeneous and parallel hardware, such as economists, biologists, physicists or psychologists, are not necessarily expert GPU programmers. They have the need to speed up their applications, which are often written in high-level and dynamic programming languages, such as Java, R or Python. Little work has been done to generate GPU code automatically from these high-level interpreted and dynamic programming languages. This thesis presents a combination of a programming interface and a set of compiler techniques which enable an automatic translation of a subset of Java and R programs into OpenCL to execute on a GPU. The goal is to reduce the programmability and usability gaps between interpreted programming languages and GPUs. The first contribution is an Application Programming Interface (API) for programming heterogeneous and multi-core systems. This API combines ideas from functional programming and algorithmic skeletons to compose and reuse parallel operations. The second contribution is a new OpenCL Just-In-Time (JIT) compiler that automatically translates a subset of the Java bytecode to GPU code. This is combined with a new runtime system that optimises the data management and avoids data transformations between Java and OpenCL. This OpenCL framework and the runtime system achieve speedups of up to 645x compared to Java within 23% slowdown compared to the handwritten native OpenCL code. The third contribution is a new OpenCL JIT compiler for dynamic and interpreted programming languages. While the R language is used in this thesis, the developed techniques are generic for dynamic languages. This JIT compiler uniquely combines a set of existing compiler techniques, such as specialisation and partial evaluation, for OpenCL compilation together with an optimising runtime that compile and execute R code on GPUs. This JIT compiler for the R language achieves speedups of up to 1300x compared to GNU-R and 1.8x slowdown compared to native OpenCL.

A concurrent program is one in which a number of processes are considered to be active simultaneously . It is possib l e to t hink of a process as being a separate sequential program executing independently of other processes, although perhaps communicating with them at desired pOints . The concurrent program, as a whole, can be executed in one of two ways: il ii) in true concurrent manner, wi th each process executing on a dedicated processor in a quasi - concurrent manner, where a processor's processes . time is multiplexed between single the There are two motivations for the study of concurrency in programming languages : i) concurrent programming facilities can be exploited in systems where one has more t han one processor . As technology i mproves, machines having multiple processors will proliferate ii) concurrent p r ogramming facilities may allow programs to be structured as independent , bu t co - operating, processes which can then be implemented on a single processor system . This structure may be more natural to the programmer then the traditional sequential structures. An example is provided by Conway's - 1- Clearly, languages Pascal) problem [Ben82] . by their very nature, traditional sequential- type (Fortran, Basic, Cobol and earlier versions of prove inadequate for the purposes of concurrent programming without considerable extension (which some manufacturers have provided, rendering their compilers non standard-conforming). The general convenience of high level languages provides strong motivation for their development for rea l time programming. Modula - 2 [Wir83] is but one of a number of such r ecently developed languages, designed not only to fulfil a "sequential" role but also to offer facilities for concurrent programming. Developed by Niklaus Wirth in 1979 as a successor to Pascal and Modula, it is intended to serve under the banner of a generalpurpose systems - implementation language. This thesis investigates concurrency i n Modula - 2 and takes the following form: i ) an analYSis of the concurrent facilities offered ii) problems and difficulties associated with these facilities iii) improveme nts and enhancements, including the feasibility of using Modula - 2 to simulate constructs found in other languages, such as the Hoare monitor [Hoa74] and the Ada rendezvous [Uni81]. - 2- Each section concludes with an appraisal of the work conducted in that section . The final section consists of a critical assessment of those Modula - 2 language constructs and facilities provided for the implementation of concurrency and a brief look at concurrency in Modula, Modula-2's predecessor. - Introduction. / KMBT_363 / Adobe Acrobat 9.53 Paper Capture Plug-in

This thesis describes a theoretical study and an industrial application in the area of formal systems development, verification and formal testing using the specification language CSP-CASL. The latter is a comprehensive specification language which allows to describe systems in a combined algebraic / process algebraic notation. To this end it integrates the process algebra CSP and the algebraic specification language CASL. In this thesis we propose various formal development notions for CSP-CASL capable of capturing informal vertical and horizontal software development which we typically find in industrial applications. We provide proof techniques for such development notions and verification methodologies to prove interesting properties of reactive systems. We also propose a theoretical framework for formal testing from CSP-CASL specifications. Here, we present a conformance relation between a physical system and a CSP-C ASL specification. In particular we study the relationship between CSP-CASL development notions and the implemented system. The proposed theoretical notions of formal system development, property verification and formal testing for CSP-CASL, have been successfully applied to two industrial application: an electronic payment system called EP2 and the starting system of the BR725 Rolls- Royce jet engine control software.

Domain-specific, “little” languages are commonplace in computing. So too is the need to implement such languages; to meet this need, we have created SPARK (Scanning, Parsing, And Rewriting Kit), a toolkit for little language implementation in Python, an object-oriented scripting language. SPARK greatly simplifies the task of little language implementation. It requires little code to be written, and accommodates a wide range of users—even those without a background in compiler theory. Our toolkit is seeing increasing use on a variety of diverse projects. SPARK was designed to be easy-to-use with few limitations, and relies heavily on Earley's general parsing algorithm internally, which helps in meeting these design goals. Earley's algorithm, in its standard form, can be hard to use; indeed, experience with SPARK has highlighted several problems with the practical use of Earley's algorithm. Our research addresses and provides solutions for these problems, making some significant improvements to the implementation and use of Earley's algorithm. First, Earley's algorithm suffers from the performance problem . Even under optimum conditions, a standard Earley parser is burdened with overhead. We extend directly-executable parsing techniques for use in Earley parsers, the results of which run in time comparable to the much-more-specialized LALR(1) parsing algorithm. Second is what we call the delayed action problem. General parsers like Earley must, in the worst case, read the entire input before executing any semantic actions associated with the grammar rules. We attack this problem in two ways. We have identified conditions under which it is safe to execute semantic actions on the fly during recognition; as a side effect, this has yielded space savings of over 90% for some grammars. The other approach to the delayed action problem deals with the difficulty of handling context-dependent tokens. Such tokens are easy to handle using what we call “Schrödinger's tokens,” a superposition of token types. Finally, Earley parsers are complicated by the need to process grammar rules with empty right-hand sides. We present a simple, efficient way to handle these empty rules, and prove that our new method is correct. We also show how our method may be used to create a new type of LR(0) automaton which is ideally suited for use in Earley parsers. Our work has made Earley parsing faster and more space-efficient, turning it into an excellent candidate for practical use in many applications. / Graduate

Thesis (MTech (Business Information Systems))--Cape Peninsula University of Technology, 2017. / The skill of programming necessitates knowing programming tools, problem solving and effective techniques of program design and implementation. Most students are incapable of fully understanding and utilising the feature set of Integrated Development Environments (IDEs). The feature set of certain IDEs comes with a lot of functionalities and students have to spend a lot of their time studying the features of the IDE without paying much attention to the syntax and semantics of the programming language. The main objective of this study was to examine the perceptions of students on interactive environments for teaching Object-Oriented concepts using the Java programming language in two integrated development environments. This was done by adopting the ISO 9126 model to select generic external system quality characteristics and sub-characteristics that might influence student evaluation of an IDE. The proposed model was applied on NetBeans and JCreator LE 5.0 as IDEs for teaching Java programming using OOP concepts. The study adopted a mixed method research approach using interviews and questionnaires. A single-case study was used for data collection and analysis. The approaches collected data from two groups of students using either NetBeans or JCreator and who were learning OOP concepts. The study further looked at the students’ class tests and exam results in an effort to have an objective overview of how students performed. These groups of students were at two different campuses of the selected University. Each group had already been exposed to the Java syntax. The result from this study was general guidelines to establish an interactive OOP development environment for teaching and learning of Java programming that enhances OOP comprehension. This research study involved human subjects. It was, therefore, a requirement to seek ethics approval. Additionally, the objects involved were students of a selected University and as such a consent letter was sought from the University.

CAPES / A materialização original do Paradigma Orientado a Notificações (PON) implementada na linguagem de programação C++ possibilitou a criação de aplicações sob o domínio desse paradigma. Apesar de tais contribuições para com o paradigma, o desenvolvimento de aplicações no PON ainda apresenta baixo nível de maturidade e certo nível de dificuldade. Tais dificuldades advêm principalmente da nova forma de estruturar os programas, onde os mesmos seguem um fluxo de notificações, o que difere da programação convencional. Ademais, até o momento, apenas algumas aplicações foram desenvolvidas, com escopos relativamente pequenos, o que não contribui efetivamente para a consolidação do paradigma e, particularmente, para o aprendizado via um conjunto efetivo de exemplos. Neste sentido, primeiramente, a própria estrutura geral do framework foi relida e reapresentada sob o viés de padrões de projeto, assim como houve contribuições na própria implementação desse. Subsequentemente, este trabalho teve como objetivo principal de estudo o nortear do desenvolvimento de aplicações baseadas no PON de maneira mais simplificada e eficiente, usando os avanços aqui citados. Isso se deu particularmente pela apresentação de padrões de desenvolvimento de software voltados para esse paradigma e infraestrutura, os quais buscam uma implementação mais purista envolvendo quesitos como redução do uso de implementações multiparadigmas, simplificação no desenvolvimento, garantia de determinismo, entre outras. De modo geral, as novas funcionalidades/recursos para a concepção de aplicações através do Framework PON facilitaram e melhoraram seu uso. / The original materialization of Notification Oriented Paradigm (NOP) previously implemented in the C++ programming language allowed the creation of applications under the domain of this paradigm. Although these contributions to the paradigm, the development of NOP applications still has a low level of maturity and a certain degree of difficulty. Such difficulties arise essentially from the new form of structuring programs, in which such applications follow a notification flow, which differs from the conventional programming. Moreover, so far, only a few applications have been developed, with relatively small scope, which does not contribute effectively to the consolidation of the paradigm, and particularly for learning through an effective set of examples. Henceforth, firstly, the general structure of the framework has been reread and reintroduced under the bias of design patterns, even as there were contributions in its implementation. Subsequently, the main goal of this paper is to guide the development of applications based on NOP in a more streamlined and efficient manner, using the advances mentioned here. This was achieved particularly by the presentation of technical software implementations aimed to this paradigm and its infrastructure, which pursues a manner to conceive more purist implementations, involving issues such as reducing the use of multiparadigms implementations, simplifying the development, ensuring determinism, and so far. In general, the new features for conceiving applications based on the NOP Framework made easier and better its use.

CAPES / A materialização original do Paradigma Orientado a Notificações (PON) implementada na linguagem de programação C++ possibilitou a criação de aplicações sob o domínio desse paradigma. Apesar de tais contribuições para com o paradigma, o desenvolvimento de aplicações no PON ainda apresenta baixo nível de maturidade e certo nível de dificuldade. Tais dificuldades advêm principalmente da nova forma de estruturar os programas, onde os mesmos seguem um fluxo de notificações, o que difere da programação convencional. Ademais, até o momento, apenas algumas aplicações foram desenvolvidas, com escopos relativamente pequenos, o que não contribui efetivamente para a consolidação do paradigma e, particularmente, para o aprendizado via um conjunto efetivo de exemplos. Neste sentido, primeiramente, a própria estrutura geral do framework foi relida e reapresentada sob o viés de padrões de projeto, assim como houve contribuições na própria implementação desse. Subsequentemente, este trabalho teve como objetivo principal de estudo o nortear do desenvolvimento de aplicações baseadas no PON de maneira mais simplificada e eficiente, usando os avanços aqui citados. Isso se deu particularmente pela apresentação de padrões de desenvolvimento de software voltados para esse paradigma e infraestrutura, os quais buscam uma implementação mais purista envolvendo quesitos como redução do uso de implementações multiparadigmas, simplificação no desenvolvimento, garantia de determinismo, entre outras. De modo geral, as novas funcionalidades/recursos para a concepção de aplicações através do Framework PON facilitaram e melhoraram seu uso. / The original materialization of Notification Oriented Paradigm (NOP) previously implemented in the C++ programming language allowed the creation of applications under the domain of this paradigm. Although these contributions to the paradigm, the development of NOP applications still has a low level of maturity and a certain degree of difficulty. Such difficulties arise essentially from the new form of structuring programs, in which such applications follow a notification flow, which differs from the conventional programming. Moreover, so far, only a few applications have been developed, with relatively small scope, which does not contribute effectively to the consolidation of the paradigm, and particularly for learning through an effective set of examples. Henceforth, firstly, the general structure of the framework has been reread and reintroduced under the bias of design patterns, even as there were contributions in its implementation. Subsequently, the main goal of this paper is to guide the development of applications based on NOP in a more streamlined and efficient manner, using the advances mentioned here. This was achieved particularly by the presentation of technical software implementations aimed to this paradigm and its infrastructure, which pursues a manner to conceive more purist implementations, involving issues such as reducing the use of multiparadigms implementations, simplifying the development, ensuring determinism, and so far. In general, the new features for conceiving applications based on the NOP Framework made easier and better its use.

Orientador: Rodolfo Jardim de Azevedo / Dissertação (mestrado) - Universidade Estadual de Campinas, Instituto de Computação / Made available in DSpace on 2018-08-16T21:29:21Z (GMT). No. of bitstreams: 1 Firmino_RaoniFassina_M.pdf: 582747 bytes, checksum: c50225f2dc75c4235a785d90a82d71b2 (MD5) Previous issue date: 2010 / Resumo: Esta dissertação concentra-se no atual momento de transição entre as atuais e as novas arquiteturas de processadores, oferecendo uma alternativa para minimizar o impacto desta mudança. Para tal utiliza-se a plataforma Java, que possibilita que o desenvolvimento de aplicações seja independente da arquitetura em que serão executadas. Considerando a arquitetura Cell B.E. como uma nova plataforma que promete desempenho elevado, este trabalho propõe melhorias na Máquina Virtual Java que propiciem um ganho de desempenho na execução de aplicações Java executadas sobre o processador Cell. O objetivo proposto é atingido por meio da utilização do ambiente disponível na própria plataforma Java, o Java Native Interface (JNI), para a implementação de interfaces entre bibliotecas nativas construídas para a arquitetura Cell - com a intenção de obter o máximo desempenho possível - e as aplicações Java. É proposto um modelo para porte e criação das interfaces para bibliotecas e mostra-se a viabilidade da abordagem proposta através de implementações de bibliotecas selecionadas, consolidando a metodologia utilizada. Duas bibliotecas foram portadas completamente como prova de conceito, uma multiplicação de matrizes grandes e o algoritmo RC5. A multiplicação de matrizes obteve um desempenho e escalablidade comparável ao código original em C e em escala muitas vezes superior ao código JNI para arquitetura x86 a ao código Java executando em arquiteturas x86 e Cell. O RC5 executou apenas aproximadamente 0,3 segundos mais lento que o código C original (perda citada em segundos pois se manteve constante independente do tempo levado para as diferentes configurações de execução) / Abstract: This dissertation focuses on the present moment of transition between the current and new processor architectures, offering an alternative to minimize the impact of this change. For this, we use the Java platform, which enables an architecture-independent application development. Considering the Cell BE architecture as a new platform that promises high performance, this paper proposes improvements in the Java Virtual Machine that provide performance gains in the execution of Java applications running on the Cell processor. The proposed objective is achieved through the use of the environment available on the Java platform itself, the Java Native Interface (JNI), to implement interfaces between native libraries built for the Cell architecture - with the intention of obtaining the maximum possible performance - and the Java applications. It is proposed a model to port and build interfaces to libraries and it shows the viability of the proposed methodology with the implementation of selected libraries, consolidating the used methodology. Two libraries were completely ported as proof of concept, a multiplication of large matrices and a RC5 algorithm implementation. The matrices multiplication achieved scalability and performance in the same basis as the native implementation and incomparable with JNI implementation targering x86 architecture and Java implementation running in x86 and Cell architectures. The RC5 was just 0.3 seconds slower than the original C code (the loss is put in seconds since it was constant, independent of the execution time taken by different configurations of execution) / Mestrado / Computação / Mestre em Ciência da Computação

Orientadores: Marcos Lordello Chaim, Eliane Martins / Dissertação (mestrado profissional) - Universidade Estadual de Campinas, Instituto de Computação / Made available in DSpace on 2018-08-10T17:57:17Z (GMT). No. of bitstreams: 1 Moura_AndreToledoPizade_M.pdf: 1281133 bytes, checksum: 77e24a926c93bfe938f8d72bdd3140c6 (MD5) Previous issue date: 2006 / Resumo: Refatoração é o ato de modificar o código fonte de um programa de computador sem, contudo, modificar seu comportamento observável. Em outras palavras, é alterar a estrutura de um sistema de software sem que isso provoque qualquer efeito no resultado final de suas funcionalidades. As modificações são feitas visando deixar o código mais fácil de ser entendido por terceiros que venham a modificá-lo e, conseqüentemente, diminuir os custos de sua manutenção. Entretanto, esta atividade é complexa e sujeita a erros, uma vez que normalmente é realizada de forma manual e depende das habilidades e da obediência a padrões do mantenedor que está analisando o código. Os pontos do software onde refatorações devem ser aplicadas constituem oportunidades de refatoração. A construção de sistemas automáticos para a detecção de oportunidades de refatoração requer a implementação de ambientes para análise de código e de tratamento regras para identificação de padrões no código fonte. Este trabalho apresenta o SOCRATES ¿ Sistema Orientado a objetos para CaRacterização de refaToraçõES ¿ cujo objetivo é fornecer auxílio automático para a identificação dos pontos candidatos a serem refatorados, isto é, oportunidades de refatoração. Para atingir este objetivo, SOCRATES utiliza uma arquitetura leve. Essa arquitetura é baseada em ferramentas livres e disponíveis e requer pouca codificação adicional. A codificação adicional é utilizada para que as ferramentas trabalhem em conjunto e para que os algoritmos de identificação das oportunidades de refatoração sejam implementados de forma eficiente. A presente versão do SOCRATES identifica de maneira automática a oportunidade de refatoração parâmetro obsoleto e mostra que os conceitos arquiteturais utilizados são válidos / Abstract: Refactoring is the activity of modifying a computer program¿s source code without changing its external behavior. In other words, it consists of changing a software system¿s structure without affecting its functionalities. The changes are done in order to let the code more understandable for humans that might work on it. In this sense, its goal is to lower maintenance costs. Nevertheless, this activity is complex and error prone since it is usually carried out manually and is dependent on the maintainer¿s abilities and on his/her obedience to coding standards. The points of the software where refactorings should be applied are called refactoring opportunities. Building automatic systems to detect refactoring opportunities requires the implementation of environments which include source code analyzers and the treatment of rules to detect related patterns and standards. This work introduces SOCRATES ¿ Sistema Orientado a objetos para CaRacterização de refaToraçõES (Object Oriented System for Characterization of Refactorings) ¿ its main purpose is to automatically detect points to be refactored in the software, i.e., refactoring opportunities. To achieve this objective, SOCRATES is built upon a lightweight architecture. This architecture is based on open source tools and requires few additional coding. The additional coding was done to make the tools work together so that refactoring opportunities searcher algorithms could effectively work. The present version of SOCRATES identifies the obsolete parameter refactoring opportunity and shows that the architecture fundamentals used are valid / Mestrado / Engenharia de Computação / Mestre em Computação