To see the other types of publications on this topic, follow the link: Language compilers.
Dissertations / Theses on the topic 'Language compilers'
Create a spot-on reference in APA, MLA, Chicago, Harvard, and other styles
Consult the top 50 dissertations / theses for your research on the topic 'Language compilers.'
Next to every source in the list of references, there is an 'Add to bibliography' button. Press on it, and we will generate automatically the bibliographic reference to the chosen work in the citation style you need: APA, MLA, Harvard, Chicago, Vancouver, etc.
You can also download the full text of the academic publication as pdf and read online its abstract whenever available in the metadata.
Browse dissertations / theses on a wide variety of disciplines and organise your bibliography correctly.
1
Seefried, Sean Computer Science & Engineering Faculty of Engineering UNSW. "Language extension via dynamically extensible compilers." Awarded by:University of New South Wales. Computer Science and Engineering, 2006. http://handle.unsw.edu.au/1959.4/29524.
Full textAbstract:
This dissertation provides the motivation for and evidence in favour of an approach to language extension via dynamic loading of plug-ins. There is a growing realisation that language features are often a superior choice to software libraries for implementing applications. Among the benefits are increased usability, safety and efficiency. Unfortunately, designing and implementing new languages is difficult and time consuming. Thus, reuse of language infrastructure is an attractive implementation avenue. The central question then becomes, what is the best method to extend languages? Much research has focussed on methods of extension based on using features of the language itself such as macros or reflection. This dissertation focuses on a complementary solution: plug-in compilers. In this approach languages are extended at run-time via dynamic extensions to compilers, called plug-ins. Plug-ins can be used to extend the expressiveness, safety and efficiency of languages. However, a plug-in compiler provides other benefits. Plug-in compilers encourage modularity, lower the barrier of entry to development, and facilitate the distribution and use of experimental language extensions. This dissertation describes how plug-in support is added, to both the front and back-end of a compiler, and demonstrates their application through a pair of case studies.
2
Junaidu, Sahalu B. "A parallel functional language compiler for message-passing multicomputers." Thesis, University of St Andrews, 1998. http://hdl.handle.net/10023/13450.
Full textAbstract:
The research presented in this thesis is about the design and implementation of Naira, a parallel, parallelising compiler for a rich, purely functional programming language. The source language of the compiler is a subset of Haskell 1.2. The front end of Naira is written entirely in the Haskell subset being compiled. Naira has been successfully parallelised and it is the largest successfully parallelised Haskell program having achieved good absolute speedups on a network of SUN workstations. Having the same basic structure as other production compilers of functional languages, Naira's parallelisation technology should carry forward to other functional language compilers. The back end of Naira is written in C and generates parallel code in the C language which is envisioned to be run on distributed-memory machines. The code generator is based on a novel compilation scheme specified using a restricted form of Milner's 7r-calculus which achieves asynchronous communication. We present the first working implementation of this scheme on distributed-memory message-passing multicomputers with split-phase transactions. Simulated assessment of the generated parallel code indicates good parallel behaviour. Parallelism is introduced using explicit, advisory user annotations in the source' program and there are two major aspects of the use of annotations in the compiler. First, the front end of the compiler is parallelised so as to improve its efficiency at compilation time when it is compiling input programs. Secondly, the input programs to the compiler can themselves contain annotations based on which the compiler generates the multi-threaded parallel code. These, therefore, make Naira, unusually and uniquely, both a parallel and a parallelising compiler. We adopt a medium-grained approach to granularity where function applications form the unit of parallelism and load distribution. We have experimented with two different task distribution strategies, deterministic and random, and have also experimented with thread-based and quantum- based scheduling policies. Our experiments show that there is little efficiency difference for regular programs but the quantum-based scheduler is the best in programs with irregular parallelism. The compiler has been successfully built, parallelised and assessed using both idealised and realistic measurement tools: we obtained significant compilation speed-ups on a variety of simulated parallel architectures. The simulated results are supported by the best results obtained on real hardware for such a large program: we measured an absolute speedup of 2.5 on a network of 5 SUN workstations. The compiler has also been shown to have good parallelising potential, based on popular test programs. Results of assessing Naira's generated unoptimised parallel code are comparable to those produced by other successful parallel implementation projects.
3
Reig, Galilea Fermín Javier. "Compiler architecture using a portable intermediate language." Connect to e-thesis, 2002. http://theses.gla.ac.uk/686/.
Full textAbstract:
Thesis (Ph.D.) - University of Glasgow, 2002.<br>Ph.D. thesis submitted to the Department of Computing Science, University of Glasgow, 2002. Includes bibliographical references. Print version also available.
4
Cardone, Richard Joseph. "Language and compiler support for mixin programming." Access restricted to users with UT Austin EID Full text (PDF) from UMI/Dissertation Abstracts International, 2002. http://wwwlib.umi.com/cr/utexas/fullcit?p3077428.
Full text
5
Fross, Bradley K. "Splash-2 shared-memory architecture for supporting high level language compilers." Thesis, Virginia Tech, 1995. http://hdl.handle.net/10919/42064.
Full textAbstract:
<p>Modem computer technology has been evolving for nearly fifty years, and has seen many
architectural innovations along the way. One of the latest technologies to come about is
the reconfigurable processor-based custom computing machine (CCM). CCMs use field
programmable gate arrays (FPGAs) as their processing cores, giving them the flexibility
of software systems with performance comparable to that of dedicated custom hardware.
Hardware description languages are currently used to program CCMs. However, research
is being performed to investigate the use of high-level languages (HLLs), such as the C
programming language, to create CCM programs. Many aspects of CCM architectures,
such as local memory systems, are not conducive to HLL compiler usage. This thesis
proposes and evaluates the use of a shared-memory architecture on a Splash-2 CCM to
promote the development and usage of HLL compilers for CCM systems.</p><br>Master of Science
6
Seaton, Christopher Graham. "Specialising dynamic techniques for implementing the Ruby programming language." Thesis, University of Manchester, 2015. https://www.research.manchester.ac.uk/portal/en/theses/specialising-dynamic-techniques-for-implementing-the-ruby-programming-language(0899248b-bbec-4d4c-9507-f775f023407c).html.
Full textAbstract:
The Ruby programming language is dynamically typed, uses dynamic and late bound dispatch for all operators, method calls and many control structures, and provides extensive metaprogramming and introspective tooling functionality. Unlike other languages where these features are available, in Ruby their use is not avoided and key parts of the Ruby ecosystem use them extensively, even for inner-loop operations. This makes a high-performance implementation of Ruby problematic. Existing implementations either do not attempt to dynamically optimise Ruby programs, or achieve relatively limited success in optimising Ruby programs containing these features. One way that the community has worked around the limitations of existing Ruby implementations is to write extension modules in the C programming language. These are statically compiled and then dynamically linked into the Ruby implementation. Compared to equivalent Ruby, this C code is often more efficient for computationally intensive code. However the interface that these C extensions provides is defined by the non-optimising reference implementation of Ruby. Implementations which want to optimise by using different internal representations must do extensive copying to provide the same interface. This then limits the performance of the C extensions in those implementations. This leaves Ruby in the difficult position where it is not only difficult to implement the language efficiently, but the previous workaround for that problem, C extensions, also limits efforts to improve performance. This thesis describes an implementation of the Ruby programming language which embraces the Ruby language and optimises specifically for Ruby as it is used in practice. It provides a high performance implementation of Ruby's dynamic features, at the same time as providing a high performance implementation of C extensions. The implementation provides a high level of compatibility with existing Ruby implementations and does not limit the available features in order to achieve high performance. Common to all the techniques that are described in this thesis is the concept of specialisation. The conventional approach taken to optimise a dynamic language such as Ruby is to profile the program as it runs. Feedback from the profiling can then be used to specialise the program for the data and control flow it is actually experiencing. This thesis extends and advances that idea by specialising for conditions beyond normal data and control flow. Programs that call a method, or lookup a variable or constant by dynamic name rather than literal syntax can be specialised for the dynamic name by generalising inline caches. Debugging and introspective tooling is implemented by specialising the code for debug conditions such as the presence of a breakpoint or an attached tracing tool. C extensions are interpreted and dynamically optimised rather than being statically compiled, and the interface which the C code is programmed against is provided as an abstraction over the underlying implementation which can then independently specialise. The techniques developed in this thesis have a significant impact on performance of both synthetic benchmarks and kernels from real-world Ruby programs. The implementation of Ruby which has been developed achieves an order of magnitude or better increase in performance compared to the next-best implementation. In many cases the techniques are 'zero-overhead', in that the generated machine code is exactly the same for when the most dynamic features of Ruby are used, as when only static features are used.
7
Moon, Hae-Kyung. "Compiler construction for a simple Pascal-like language." Virtual Press, 1994. http://liblink.bsu.edu/uhtbin/catkey/897511.
Full textAbstract:
In this thesis a compiler called SPASCAL is implemented which translates source programs in a simple Pascal-like language called SPASCAL into target programs in the VAX assembly language. This thesis clearly describes the main aspects of a compiler: lexical analysis and syntactic analysis, including the symbol-table routines and the error-handling routines. This thesis uses regular expressions to define the lexical structure and a context-free grammar to define the syntactic structure of SPASCAL. The compiler is constructed using syntax-directed translation, context-free grammars and a set of semantic rules. SPASCAL Compiler is written with standard C in UNIX.<br>Department of Computer Science
8
Hessaraki, Alireza. "CCC86, a generic 8086 C-language cross compiler plus communication package." Virtual Press, 1987. http://liblink.bsu.edu/uhtbin/catkey/544004.
Full textAbstract:
The Cross Compiler is an excellent and valuable program development tool. It provides to the user a low level compiled language that allows character (byte), integer (8086 word) and pointer (8086 one word address) manipulation. It also allows recursion, has modern flow and a rich set of operators.The Communication Program which include file transfer utility allows the student to download or upload their C program to a PC. It allows use of the Modem. The file transferring can be done using XON/XOFF or XMODEM. It also supports INS 8250 UART chip, plus 16450 high speed device found in hardware such as IBM AT Serial/Parallel Adapter.<br>Department of Computer Science
9
Calnan, III Paul W. "EXTRACT: Extensible Transformation and Compiler Technology." Digital WPI, 2003. https://digitalcommons.wpi.edu/etd-theses/484.
Full textAbstract:
Code transformation is widely used in programming. Most developers are familiar with using a preprocessor to perform syntactic transformations (symbol substitution and macro expansion). However, it is often necessary to perform more complex transformations using semantic information contained in the source code. In this thesis, we developed EXTRACT; a general-purpose code transformation language. Using EXTRACT, it is possible to specify, in a modular and extensible manner, a variety of transformations on Java code such as insertion, removal, and restructuring. In support of this, we also developed JPath, a path language for identifying portions of Java source code. Combined, these two technologies make it possible to identify source code that is to be transformed and then specify how that code is to be transformed. We evaluate our technology using three case studies: a type name qualifier which transforms Java class names into fully-qualified class names; a contract checker which enforces pre- and post-conditions across behavioral subtypes; and a code obfuscator which mangles the names of a class's methods and fields such that they cannot be understood by a human, without breaking the semantic content of the class.
10
Cook, Philip John. "Incremental compilation in language-based environments /." [St. Lucia, Qld.], 2006. http://www.library.uq.edu.au/pdfserve.php?image=thesisabs/absthe19173.pdf.
Full text
11
Shapiro, David. "Compiling Evaluable Functions in the Godel Programming Language." PDXScholar, 1996. https://pdxscholar.library.pdx.edu/open_access_etds/5101.
Full textAbstract:
We present an extension of the Godel logic programming language code generator which compiles user-defined functions. These functions may be used as arguments in predicate or goal clauses. They are defined in extended Godel as rewrite rules. A translation scheme is introduced to convert function definitions into predicate clauses for compilation. This translation scheme and the compilation of functional arguments both employ leftmost-innermost narrowing. As function declarations are indistinguishable from constructor declarations, a function detection method is implemented. The ultimate goal of this research is the implementation of extended Godel using needed narrowing. The work presented here is an intermediate step in creating a functional-logic language which expands the expressiveness of logic programming and streamlines its execution.
12
Drake, Maria Rosa. "Object-oriented concurrent programming on the connection machine with COOL (Concurrent Object-Oriented Language)." FIU Digital Commons, 1995. http://digitalcommons.fiu.edu/etd/3083.
Full textAbstract:
The quest for speed and the need to solve ever more complex problems has led to the development of powerful computer systems, such as the Connection Machine. Concurrent processing promises a solution to the problem. COOL (Concurrent Object-Oriented Language) has been developed in order to provide the Connection Machine with a subset of C" which includes several concurrent constructs. The Connection Machine has an inherently parallel architecture which can be taken advantage of with software.
13
Vasudeo, Jyotindra. "The Design and Implementation of the Tako Language and Compiler." Thesis, Virginia Tech, 2006. http://hdl.handle.net/10919/33228.
Full textAbstract:
Aliasing complicates both formal and informal reasoning and is a particular problem in object-oriented languages, where variables denote references to objects rather than object values. Researchers have proposed various approaches to the aliasing problem in object-oriented languages, but all use reference semantics to reason about programs. This thesis describes the design and implementation of Takoâ a Java-like language that facilitates value semantics by incorporating alias-avoidance. The thesis describes a non-trivial application developed in the Tako language and discusses some of the object-oriented programming paradigm shifts involved in translating that application from Java to Tako. It introduces a proof rule for procedure calls that uses value semantics and accounts for both repeated arguments and subtyping.<br>Master of Science
14
Calnan, Paul W. "EXTRACT, Extensible Transformation and Compiler Technology." Link to electronic thesis, 2003. http://www.wpi.edu/Pubs/ETD/Available/etd-0429103-152947.
Full text
15
Deighan, John. "VPI PROLOG compiler project report." Master's thesis, This resource online, 1991. http://scholar.lib.vt.edu/theses/available/etd-01262010-020109/.
Full text
16
Stelly, Christopher D. "A Domain Specific Language for Digital Forensics and Incident Response Analysis." ScholarWorks@UNO, 2019. https://scholarworks.uno.edu/td/2706.
Full textAbstract:
One of the longstanding conceptual problems in digital forensics is the dichotomy between the need for verifiable and reproducible forensic investigations, and the lack of practical mechanisms to accomplish them. With nearly four decades of professional digital forensic practice, investigator notes are still the primary source of reproducibility information, and much of it is tied to the functions of specific, often proprietary, tools.
The lack of a formal means of specification for digital forensic operations results in three major problems. Specifically, there is a critical lack of:
a) standardized and automated means to scientifically verify accuracy of digital forensic tools;
b) methods to reliably reproduce forensic computations (their results); and
c) framework for inter-operability among forensic tools.
Additionally, there is no standardized means for communicating software requirements between users, researchers and developers, resulting in a mismatch in expectations. Combined with the exponential growth in data volume and complexity of applications and systems to be investigated, all of these concerns result in major case backlogs and inherently reduce the reliability of the digital forensic analyses.
This work proposes a new approach to the specification of forensic computations, such that the above concerns can be addressed on a scientific basis with a new domain specific language (DSL) called nugget. DSLs are specialized languages that aim to address the concerns of particular domains by providing practical abstractions. Successful DSLs, such as SQL, can transform an application domain by providing a standardized way for users to communicate what they need without specifying how the computation should be performed.
This is the first effort to build a DSL for (digital) forensic computations with the following research goals:
1) provide an intuitive formal specification language that covers core types of forensic computations and common data types;
2) provide a mechanism to extend the language that can incorporate arbitrary computations;
3) provide a prototype execution environment that allows the fully automatic execution of the computation;
4) provide a complete, formal, and auditable log of computations that can be used to reproduce an investigation;
5) demonstrate cloud-ready processing that can match the growth in data volumes and complexity.
17
Kuklínek, Lukáš. "Compiler of a Language with User-Defined Syntax for New Constructs." Master's thesis, Vysoké učení technické v Brně. Fakulta informačních technologií, 2013. http://www.nusl.cz/ntk/nusl-236221.
Full textAbstract:
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.
18
Song, Jun. "Compiling ACE for Distributed-Memory Machines." PDXScholar, 1992. https://pdxscholar.library.pdx.edu/open_access_etds/4568.
Full textAbstract:
Distributed-memory machines offer a very high level of performance, flexibility and scalability. But the memory organization of this kind of machine determines that processes on different processors must communicate explicitly by sending and receiving messages. As a result, the programmer faces the enormously difficult task of detailed planning of algorithm-irrelevant, low-level communication issues. This level of programming resembles writing assembly programs for a sequential machine. ACE is a message-passing language with abstract communication statements. It was defined by Dr. Jingke Li at Portland State University. The communication in ACE is still explicit, but it is abstracted to a higher level. The abstraction can help balance the needs of ease of programming and high performance. This thesis discusses how those high-level communication abstractions can be transformed into low-level communication routines. It presents the design and implementation of a compiler that transforms an ACE program into a C program with low-level communication routines. The compiler is implemented for the Intel iPSC/2 hypercube multiprocessor machine. Compared to their low-level counterparts, ACE programs are easier to write and are more understandable. Compared to their high level counterparts, more efficient code can be generated since the communication information is expressed explicitly in ACE and the compiler itself is much less complex. ACE also enables the users to fine tune some critical communication segments. Some well known parallel algorithms written in ACE are compiled by the compiler as examples, and experimental results of their performance are included.
19
Ahn, Ki Yung. "The Nax Language: Unifying Functional Programming and Logical Reasoning in a Language based on Mendler-style Recursion Schemes and Term-indexed Types." PDXScholar, 2014. https://pdxscholar.library.pdx.edu/open_access_etds/2088.
Full textAbstract:
Two major applications of lambda calculi in computer science are functional programming languages and mechanized reasoning systems (or, proof assistants). According to the Curry--Howard correspondence, it is possible, in principle, to design a unified language based on a typed lambda calculus for both logical reasoning and programming. However, the different requirements of programming languages and reasoning systems make it difficult to design such a unified language that provides both. Programming languages usually extend lambda calculi with programming-friendly features (e.g., recursive datatypes, general recursion) for supporting the flexibility to model various computations, while sacrificing logical consistency. Logical reasoning systems usually extend lambda calculi with logic-friendly features (e.g., induction principles, dependent types) for paradox-free inference over fine-grained properties, while being more restrictive in modeling computations.
In this dissertation, we design and implement a language called Nax that embraces benefits of both. Nax accepts all recursive datatypes, thus, allowing the same flexibility of defining recursive datatypes as in functional languages. Nax supports a number of Mendler-style recursion schemes that can express various kinds of recursive computations and also guarantee termination. Nax supports term-indexed types to support specifications of fine-grained properties. In addition, Nax supports a conservative extension of Hindley--Milner type inference.
The theoretical contributions of this dissertation include theories for Mendler-style recursion schemes and term-indexed types, which we developed to establish strong normalization and logical consistency of Nax.
20
Wells, Garrett. "The Future of iOS Development: Evaluating the Swift Programming Language." Scholarship @ Claremont, 2015. http://scholarship.claremont.edu/cmc_theses/1179.
Full textAbstract:
Swift is a new programming language developed by Apple for creating iOS and Mac OS X applications. Intended to eventually replace Objective-C as Apple’s language of choice, Swift needs to convince developers to switch over to the new language. Apple has promised that Swift will be faster than Objective-C, as well as offer more modern language features, be very safe, and be easy to learn and use. In this thesis I test these claims by creating an iOS application entirely in Swift as well as benchmarking two different algorithms. I find that while Swift is faster than Objective-C, it does not see the speedup projected by Apple. I also conclude that Swift offers many advantages over Objective-C, and is easy for developers to learn and use. However there are some weak areas of Swift involving interactions with Objective-C and the strictness of the compiler that can make the language difficult to work with. Despite these difficulties Swift is overall a successful project for Apple and should attract new developers to their platform.
21
Meng, Ziyuan. "Two-Bit Pattern Analysis For Quantitative Information Flow." FIU Digital Commons, 2014. http://digitalcommons.fiu.edu/etd/1326.
Full textAbstract:
Protecting confidential information from improper disclosure is a fundamental security goal. While encryption and access control are important tools for ensuring confidentiality, they cannot prevent an authorized system from leaking confidential information to its publicly observable outputs, whether inadvertently or maliciously. Hence, secure information flow aims to provide end-to-end control of information flow. Unfortunately, the traditionally-adopted policy of noninterference, which forbids all improper leakage, is often too restrictive. Theories of quantitative information flow address this issue by quantifying the amount of confidential information leaked by a system, with the goal of showing that it is intuitively “small” enough to be tolerated. Given such a theory, it is crucial to develop automated techniques for calculating the leakage in a system.
This dissertation is concerned with program analysis for calculating the maximum leakage, or capacity, of confidential information in the context of deterministic systems and under three proposed entropy measures of information leakage: Shannon entropy leakage, min-entropy leakage, and g-leakage. In this context, it turns out that calculating the maximum leakage of a program reduces to counting the number of possible outputs that it can produce.
The new approach introduced in this dissertation is to determine two-bit patterns, the relationships among pairs of bits in the output; for instance we might determine that two bits must be unequal. By counting the number of solutions to the two-bit patterns, we obtain an upper bound on the number of possible outputs. Hence, the maximum leakage can be bounded. We first describe a straightforward computation of the two-bit patterns using an automated prover. We then show a more efficient implementation that uses an implication graph to represent the two- bit patterns. It efficiently constructs the graph through the use of an automated prover, random executions, STP counterexamples, and deductive closure. The effectiveness of our techniques, both in terms of efficiency and accuracy, is shown through a number of case studies found in recent literature.
22
Traina, Antônio Fernando. "Proposta de uma linguagem Java para um ambiente paralelo-JAPAR." Universidade de São Paulo, 2000. http://www.teses.usp.br/teses/disponiveis/76/76132/tde-28042014-145402/.
Full textAbstract:
Com o crescente número de usuários de computadores, novas ferramentas têm sido apresentadas com a finalidade de aumentar a eficiência dos computadores, meio para que seus usuários disponham de recursos automatizados. Mais recentemente, máquinas ligadas em rede de computadores e o fenômeno Internet tornaram necessárias ferramentas específicas para este tipo particular de uso. Entre as principais respostas a essas necessidades surgiu a linguagem Java, que tem ganhado adeptos tanto na comunidade científica como no mercado. Surge daí a necessidade de buscar formas alternativas para o uso de computadores em rede. Entre as soluções propostas encontra-se a de arquiteturas e linguagens paralelas. Estas ferramentas, ainda em fase experimental, apresentam soluções que podem a médio e longo prazo serem viáveis, desde que estudos e pesquisas mostrem sua viabilidade. Neste trabalho investiga-se a aplicação do conceito de paralelismo em linguagens para rede, mais especificamente a linguagem Java. A proposta é estudar as possíveis formas para se explorar o paradigma de linguagens paralelas em ambientes Java. Para isto, apresenta-se uma pesquisa relativa as principais linguagens paralelas disponíveis na literatura, de forma a conhecer as melhores soluções apresentadas por essas linguagens. O trabalho apresenta também um estudo realizado em um conjunto de ferramentas Java disponíveis no mercado. Finalmente, propõe-se um novo ambiente que possa disponibilizar ao usuário os melhores recursos da linguagem Java, explorando as melhores soluções encontradas na literatura.<br>With the increasing number of computer users, new tools have been presented to improve the computers efficiency and to make automated resources available for those users. Nowadays, the use of computers in a network and the Internet phenomenon requires specific tools. Among them, the Java language appears as an important tool, which has been attracting users in both the scientific and commercial communities. At the same time the computer networks are becoming more popular and some problems have emergent concerned to the networks assessment and connections. It is necessary to look for alternative ways of handling the network computer systems. The parallel architectures and languages appear among the proposed solutions. These tools are still in an experimental phase, studies and researches being necessary additional to confirm their feasibility. In this work we investigate the application of parallelism concepts in languages for networks, and particular we deal with the Java language. The aim is to study the possible approaches for exploring the parallel languages paradigm in Java environments. Research about the main parallel languages available in the literature is presented, in order to check the best solutions proposed by those languages. The work also presents an investigation about the Java tools available in the commercial market. Finally a new environment is proposed that makes some of the best resources of language Java available to the users by exploring the best solutions found in the literature.
23
Chan, Robin Isaac Man-Hang. "An Estelle-C compiler for automatic protocol implementation." Thesis, University of British Columbia, 1987. http://hdl.handle.net/2429/26184.
Full textAbstract:
Over the past few years, much experience has been gained in semi-automatic protocol implementation
using an existing Estelle-C compiler developed at the University of British Columbia. However, with the continual evolution of the Estelle language, that compiler is now obsolete. The present study found substantial syntactic and semantic differences between the Estelle language as implemented by the existing compiler and that specified in the latest ISO document
to warrant the construction of a new Estelle-C compiler. The result is a new compiler which translates Estelle as defined in the second version of the ISO Draft Proposal 9074 into the programming language C. The new Estelle-C compiler addresses issues such as dynamic reconfiguration of modules and maintenance of priority relationships among nested modules. A run-time environment capable of supporting the new Estelle features is also presented. The implementation
strategy used in the new Estelle-C compiler is illustrated by using the alternating bit protocol found in the ISO Draft Proposal 9074 document.<br>Science, Faculty of<br>Computer Science, Department of<br>Graduate
24
Chelliah, M. "A Compiler and Symbolic Debugger for Occam." Thesis, Indian Institute of Science, 1989. http://hdl.handle.net/2005/77.
Full textAbstract:
We have implemented Occam, a parallel programming language, on a uniprocessor machine (MC-68020 based HORIZON I11 running on UNIX system V.2) with simulated concurrency. Occam is a descendant of CSP with a few convenient modifications like channels used for communication and procedures. Two additions to the original language, i.e., output guards and recursion have been proposed. Front end of the compiler was developed using LEX and YACC. An innovative code generator, generator based on tree pattern matching has been used to generate the back end of the compiler, which generates efficient MC-68020 assembly code. A kernel for process administration is the runtime support provided. It has been developed entirely in ' C ' and made available as a library. This is linked with the assembly module to generate the executable version of the input Occam program.
We have also interfaced our Occam compiler with Unix system V.2 source level debugger 'Sdb' so as to provide debugging support for Occam programmers. Issues involved in parallel debugging have been investigated and those demanding minimum effort have been incorporated in Occam debugger by modifying the runtime support of the uniprocessor implementation.
Modifications to the uniprocessor implementation so as to make it run on a shared memory multiprocessor machine(HCL MAGNUM-P with four MC-68030 processors) are also discussed. The support provided by MAGNUM-P at the architecture and operating system levels is explained in detail. Our Occam compiler for the multiprocessor generates code, but the generated code has not been tested since the machine is not yet ready.
25
Sarcar, Amritam. "Runtime assertion checking for JML on the eclipse platform using AST merging." To access this resource online via ProQuest Dissertations and Theses @ UTEP, 2009. http://0-proquest.umi.com.lib.utep.edu/login?COPT=REJTPTU0YmImSU5UPTAmVkVSPTI=&clientId=2515.
Full text
26
Shear, Raymond F. "Implementation of a Modula 2 subset compiler supporting a "C" language interface using commonly available UNIX tools /." Online version of thesis, 1989. http://hdl.handle.net/1850/10505.
Full text
27
Parthepan, Vijayeandra. "Efficient Schema Extraction from a Collection of XML Documents." TopSCHOLAR®, 2011. http://digitalcommons.wku.edu/theses/1061.
Full textAbstract:
The eXtensible Markup Language (XML) has become the standard format for data exchange on the Internet, providing interoperability between different business applications. Such wide use results in large volumes of heterogeneous XML data, i.e., XML documents conforming to different schemas. Although schemas are important in many business applications, they are often missing in XML documents. In this thesis, we present a suite of algorithms that are effective in extracting schema information from a large collection of XML documents. We propose using the cost of NFA simulation to compute the Minimum Length Description to rank the inferred schema. We also studied using frequencies of the sample inputs to improve the precision of the schema extraction. Furthermore, we propose an evaluation framework to quantify the quality of the extracted schema. Experimental studies are conducted on various data sets to demonstrate the efficiency and efficacy of our approach.
28
Morris, John Garrett. "Type Classes and Instance Chains: A Relational Approach." PDXScholar, 2013. https://pdxscholar.library.pdx.edu/open_access_etds/1010.
Full textAbstract:
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.
29
Orgill, Gregory Leavitt. "Java Performance of the Rijndael Encryption Algorithm Across Compilers and Virtual Machines." Diss., CLICK HERE for online access, 2005. http://contentdm.lib.byu.edu/ETD/image/etd681.pdf.
Full text
30
Coleman, Jesse J. "The design, construction, and implementation of an engineering software command processor and macro compiler /." Online version of thesis, 1995. http://hdl.handle.net/1850/12219.
Full text
31
McQueen, Sean. "Javascript and Politics: How a Toy Language Took Over the World." Scholarship @ Claremont, 2013. http://scholarship.claremont.edu/cmc_theses/758.
Full textAbstract:
The most important programming languages are the ones that manage to capitalize on emerging frontiers in computing. Although JavaScript started its life as a toy language, the explosive growth of the web since 1995 and the invention of the web application have transformed the language’s syntax, potential and importance. JavaScript today is powerful and expressive. But is the language good enough to power the future of the web? How does the messy political past of JavaScript affect web development today, and how will it affect web development in the future?
The paper first examines the political history of JavaScript from its origins at Netscape through today. Then a case study of pure JavaScript web development using the NodeJS and AngularJS is presented and analyzed. Finally, several potential paths forward for the language are considered, including a discussion and analysis of Microsoft’s TypeScript, Mozilla’s ASM.js and Google’s Dart.
32
Mbhambhu, Tsakani Joseph. "A Java bytecode compiler for the 8051 micro-controller." Thesis, Stellenbosch : Stellenbosch University, 2002. http://hdl.handle.net/10019.1/52645.
Full textAbstract:
Thesis (MScEng)--Stellenbosch University, 2002.<br>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.<br>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.
33
Jones, Philip E. C. "Common subexpression detection in dataflow programs /." Title page, contents and summary only, 1989. http://web4.library.adelaide.edu.au/theses/09SM/09smj78.pdf.
Full text
34
Yang, Lian. "The object-oriented design of a hardware description language analyser for the DIADES silicon compiler system." PDXScholar, 1990. https://pdxscholar.library.pdx.edu/open_access_etds/4260.
Full text
35
Wu, Xiaoqing. "Component-based language implementation with object-oriented syntax and aspect-oriented semantics." Birmingham, Ala. : University of Alabama at Birmingham, 2007. http://www.mhsl.uab.edu/dt/2007p/wu.pdf.
Full textAbstract:
Thesis (Ph. D.)--University of Alabama at Birmingham, 2007.<br>Additional advisors: Jeff Gray, Marjan Mernik, Alan Sprague, Murat Tanik. Description based on contents viewed June 25, 2007; title from title screen. Includes bibliographical references (p. 132-138).
36
Hernandez, Ivory. "Strong-DISM| A First Attempt to a Dynamically Typed Assembly Language (D-TAL)." Thesis, University of South Florida, 2017. http://pqdtopen.proquest.com/#viewpdf?dispub=10640802.
Full textAbstract:
<p> Dynamically Typed Assembly Language (D-TAL) is not only a lightweight and effective solution to the gap generated by the drop in security produced by the translation of high-level language instructions to low-level language instructions, but it considerably eases up the burden generated by the level of complexity required to implement typed assembly languages statically. Although there are tradeoffs between the static and dynamic approaches, focusing on a dynamic approach leads to simpler, easier to reason about, and more feasible ways to understand deployment of types over monomorphically-typed or untyped intermediate languages. On this occasion, DISM, a simple but powerful and mature untyped assembly language, is extended by the addition of type annotations (on memory and registers) to produce an instance of D-TAL. Strong-DISM, the resulting language, statically, lends itself to simpler analysis about type access and security as the correlation between datatypes and instructions with their respective memory and registers becomes simpler to observe; while dynamically, it disallows operations and further eliminates conditions that from high level languages could be used to violate/circumvent security.</p><p>
37
Opatřil, Petr. "Rozšíření programovacího jazyka C Plus a jeho překladače." Master's thesis, Vysoké učení technické v Brně. Fakulta informačních technologií, 2017. http://www.nusl.cz/ntk/nusl-363864.
Full textAbstract:
This thesis describes continuing development of new programming language C Plus conceived in earlier Bachelor’s Thesis oriented on enhancing C language with high level constructs with no additional cost. During development, several important languages were compared and C Plus along with its grammar were expanded, advantages of additions were discussed and compared with solutions in other languages. Described enhancements were implemented in the compiler.
38
Pimenta, José Miguel Mestre. "Temple - uma linguagem de programação para o ensino de programação." Master's thesis, Universidade de Évora, 2019. http://hdl.handle.net/10174/26085.
Full textAbstract:
A disciplina introdutória de programação é muitas vezes o primeiro contacto que os alunos de engenharia informática
têm com a programação. Muitos alunos demonstram dificuldades nessa primeira disciplina e a linguagem
de programação utilizada pode influenciar essas dificuldades. Nesta dissertação pretende-se averiguar o
estado atual das disciplinas introdutórias de programação para se poder criar uma linguagem de programação
adequada aos problemas existentes. Foi realizado um estudo para verificar a situação atual a nível mundial e
de Portugal, observando quais as linguagens de programação utilizadas na disciplina introdutória de programação,
considerando os cuidados a ter no ensino da programação, as dificuldades manifestadas pelos alunos
e professores e ainda qual o paradigma mais adequado para ser utilizado nesta primeira abordagem à programação.
Com base na informação adquirida foi criada uma linguagem que pretende colmatar alguns dos
problemas descobertos e ser uma alternativa às linguagens de programação existentes no ensino de programação; Abstract:
Temple - A Programming Language for Teaching
Programming
The introductory programming course is often the first contact that computer engineering students have with
programming. Many students demonstrate difficulties in this first discipline and the programming language
used can influence these difficulties. In this dissertation we intend to investigate the current state of the introductory
programming courses in order to create a new programming language appropriate to the existing
problems. A study was carried out to verify the current situation worldwide and in Portugal. We took a look at
which programming languages are used in the introductory programming courses, the problems that we should
pay attention to, the difficulties manifested by students and teachers and the most appropriate paradigm to be
used in this first approach to programming. Based on the information acquired, a language was created that
aims at solving some of the problems discovered and to be an alternative to the existing programming languages
to teach programming.
39
Miodrag, Đukić. "Ново решење компајлерске инфраструктуре за наменске процесоре". Phd thesis, Univerzitet u Novom Sadu, Fakultet tehničkih nauka u Novom Sadu, 2015. http://www.cris.uns.ac.rs/record.jsf?recordId=92654&source=NDLTD&language=en.
Full textAbstract:
Ова докторска теза описује и анализира приступ развоју Це компајлера занаменске процесоре. Такав компајлер захтева имплементацију посебнихтехника и алгоритама, претежно специфичних за нерегуларне процесорскеархитектуре, да би генерисао ефикасан код, и при том је потребно даиспуњава индустријске стандарде по питању робустности, разумљивостикода, могућности одржавања и проширивости. У ту сврху је предложенанова компајлерска инфраструктура над којом је имплементиран компајлерза Cirrus Coyote 32 ДСП. Квалитет генерисаног кода поређен је саквалитетом кода генерисног од стране већ постојећег компајлера за тајпроцесор. Уједно, одређени елементи организације компајлера суупоређени са популарним компајлерима отвореног кода GCC и LLVM.<br>Ova doktorska teza opisuje i analizira pristup razvoju Ce kompajlera zanamenske procesore. Takav kompajler zahteva implementaciju posebnihtehnika i algoritama, pretežno specifičnih za neregularne procesorskearhitekture, da bi generisao efikasan kod, i pri tom je potrebno daispunjava industrijske standarde po pitanju robustnosti, razumljivostikoda, mogućnosti održavanja i proširivosti. U tu svrhu je predloženanova kompajlerska infrastruktura nad kojom je implementiran kompajlerza Cirrus Coyote 32 DSP. Kvalitet generisanog koda poređen je sakvalitetom koda generisnog od strane već postojećeg kompajlera za tajprocesor. Ujedno, određeni elementi organizacije kompajlera suupoređeni sa popularnim kompajlerima otvorenog koda GCC i LLVM.<br>This PhD thesis describes and analyses an approach to development of Clanguage compiler for embedded processors. That kind of compiler requiresimplementation of special techniques and algorithms, mostly specific forirregular processor architectures, in order to be able to generate efficientcode, whereas still meeting industrial strength standard by beeing robust,understandable, maintainable, and extensible. For this purpose the newcompiler insfrastructure is proposed and on top of it a compiler for CirrusLogic Coyote 32 DSP is built. Quality of the code generated by that compileris compared with code generated by the previous compiler for the sameprocessor architecture. Some elements of the compiler design are alsocompared to popular open source compilers GCC and LLVM.
40
Li, Kaiyan. "Unified modeling language class diagram translator for the online design pattern library system." CSUSB ScholarWorks, 2003. https://scholarworks.lib.csusb.edu/etd-project/2194.
Full textAbstract:
The Unified Modeling Language (UML) is the successor to the wave of object-oriented analysis and design (OOA&D) methods that appeared in the late '80s and early '90s. The class diagram is one of the most useful diagrams in UML. The class diagram technique has become truly central within object-oriented methods.
41
Peters, Arthur. "The Basic Scheme for the Evaluation of Functional Logic Programs." PDXScholar, 2012. https://pdxscholar.library.pdx.edu/open_access_etds/914.
Full textAbstract:
Functional logic languages provide a powerful programming paradigm combining the features of functional languages and logic languages. However, current implementations of functional logic languages are complex, slow, or both. This thesis presents a scheme, called the Basic Scheme, for compiling and executing functional logic languages based on non-deterministic graph rewriting. This thesis also describes the implementation and optimization of a prototype of the Basic Scheme. The prototype is simple and performs well compared to other current implementations.
42
Santiago, Dionny. "A Model-Based AI-Driven Test Generation System." FIU Digital Commons, 2018. https://digitalcommons.fiu.edu/etd/3878.
Full textAbstract:
Achieving high software quality today involves manual analysis, test planning, documentation of testing strategy and test cases, and development of automated test scripts to support regression testing. This thesis is motivated by the opportunity to bridge the gap between current test automation and true test automation by investigating learning-based solutions to software testing. We present an approach that combines a trainable web component classifier, a test case description language, and a trainable test generation and execution system that can learn to generate new test cases. Training data was collected and hand-labeled across 7 systems, 95 web pages, and 17,360 elements. A total of 250 test flows were also manually hand-crafted for training purposes. Various machine learning algorithms were evaluated. Results showed that Random Forest classifiers performed well on several web component classification problems. In addition, Long Short-Term Memory neural networks were able to model and generate new valid test flows.
43
Brock, Walter A. "Alternative Approaches to Correction of Malapropisms in AIML Based Conversational Agents." NSUWorks, 2014. http://nsuworks.nova.edu/gscis_etd/20.
Full textAbstract:
The use of Conversational Agents (CAs) utilizing Artificial Intelligence Markup Language (AIML) has been studied in a number of disciplines. Previous research has shown a great deal of promise. It has also documented significant limitations in the abilities of these CAs. Many of these limitations are related specifically to the method employed by AIML to resolve ambiguities in the meaning and context of words. While methods exist to detect and correct common errors in spelling and grammar of sentences and queries submitted by a user, one class of input error that is particularly difficult to detect and correct is the malapropism. In this research a malapropism is defined a "verbal blunder in which one word is replaced by another similar in sound but different in meaning" ("malapropism," 2013).
This research explored the use of alternative methods of correcting malapropisms in sentences input to AIML CAs using measures of Semantic Distance and tri-gram probabilities. Results of these alternate methods were compared against AIML CAs using only the Symbolic Reductions built into AIML.
This research found that the use of the two methodologies studied here did indeed lead to a small, but measurable improvement in the performance of the CA in terms of the appropriateness of its responses as classified by human judges. However, it was also noted that in a large number of cases, the CA simply ignored the existence of a malapropism altogether in formulating its responses. In most of these cases, the interpretation and response to the user's input was of such a general nature that one might question the overall efficacy of the AIML engine. The answer to this question is a matter for further study.
44
Brandis, Marc Brandis Marc Michael. "Optimizing compilers for structured programming languages /." [S.l.] : [s.n.], 1995. http://e-collection.ethbib.ethz.ch/show?type=diss&nr=11024.
Full text
45
Fourniotis, Pavlatos Panayis. "Compiler optimisation of typeless languages." Thesis, University of Cambridge, 1998. https://www.repository.cam.ac.uk/handle/1810/275469.
Full textAbstract:
We have written an optimising compiler for a typeless, imperative, modular programming language. The optimiser, which works on a 3-address intermediate representation generated from the source program, uses some novel techniques described in this thesis. The techniques are universally applicable, although some are particularly useful in typeless compilation. We present a new register allocation and assignment scheme. Unlike traditional "colouring" allocators, our method separates the problem into distinct allocation and assignment phases. The former is achieved by using an iterative process to extend a local (within basic blocks) allocation method to the global (across basic blocks) domain. This obviates the need for a sophisticated assignment algorithm; we show how to use simple heuristics to assign registers after allocation. We also present a simple method for identifying loops in a program's intermediate representation and assigning loop nesting levels. Unlike traditional methods, this does not rely on the concept of flowgraph dominators, and is able to deal sensibly with irreducible flowgraphs and "unstructured" loops that interlock or partially overlap. The major part of the thesis concerns value range analysis. Based on the theoretical framework of abstract interpretation, we describe an analysis of the intermediate code that predicts safe approximations to the run-time value ranges of variables and memory used by the program being compiled. To be useful in compiling a typeless language, this analysis must be able to handle values of different kinds (integers, pointers, function addresses, etc.) We show how we can subsume some traditional optimisation techniques, such as constant propagation, into more powerful methods that take advantage of value range information to optimise a wider variety of cases. We also show how this information can be used to recover most of the benefits of types, without sacrificing the flexibility of typelessness. Besides the above, value range analysis allows a number of optimisations that were heretofore impossible. Many of these are improvements to register allocation; we investigate better treatments for variables that can be accessed by address. We also describe a method of removing memory accesses by allowing variables that are simultaneously live to share registers, and suggest a similar scheme for values stored in memory. Finally, we show how the results of value range analysis can be shared across different program modules and different compiler runs. The method used is powerful enough to be useful, but simple enough to integrate with old code that cannot be recompiled. Inter-modular optimisation can be transparent to the user, improving the results of value range analysis within a module without altering its functionality; or it can be visible, optimising modules with respect to each other.
46
Li, Shen Carmen C. Duren Russell Walker. "Evaluating Impulse C and multiple parallelism partitions for a low-cost reconfigurable computing system." Waco, Tex. : Baylor University, 2008. http://hdl.handle.net/2104/5280.
Full text
47
Thies, William Frederick 1978. "Language and compiler support for stream programs." Thesis, Massachusetts Institute of Technology, 2009. http://hdl.handle.net/1721.1/46793.
Full textAbstract:
Thesis (Ph. D.)--Massachusetts Institute of Technology, Dept. of Electrical Engineering and Computer Science, 2009.<br>This electronic version was submitted by the student author. The certified thesis is available in the Institute Archives and Special Collections.<br>Includes bibliographical references (p. 153-166).<br>Stream programs represent an important class of high-performance computations. Defined by their regular processing of sequences of data, stream programs appear most commonly in the context of audio, video, and digital signal processing, though also in networking, encryption, and other areas. Stream programs can be naturally represented as a graph of independent actors that communicate explicitly over data channels. In this work we focus on programs where the input and output rates of actors are known at compile time, enabling aggressive transformations by the compiler; this model is known as synchronous dataflow. We develop a new programming language, StreamIt, that empowers both programmers and compiler writers to leverage the unique properties of the streaming domain. StreamIt offers several new abstractions, including hierarchical single-input single-output streams, composable primitives for data reordering, and a mechanism called teleport messaging that enables precise event handling in a distributed environment. We demonstrate the feasibility of developing applications in StreamIt via a detailed characterization of our 34,000-line benchmark suite, which spans from MPEG-2 encoding/decoding to GMTI radar processing. We also present a novel dynamic analysis for migrating legacy C programs into a streaming representation. The central premise of stream programming is that it enables the compiler to perform powerful optimizations. We support this premise by presenting a suite of new transformations. We describe the first translation of stream programs into the compressed domain, enabling programs written for uncompressed data formats to automatically operate directly on compressed data formats (based on LZ77). This technique offers a median speedup of 15x on common video editing operations.<br>(cont.) We also review other optimizations developed in the StreamIt group, including automatic parallelization (offering an 11x mean speedup on the 16-core Raw machine), optimization of linear computations (offering a 5.5x average speedup on a Pentium 4), and cache-aware scheduling (offering a 3.5x mean speedup on a StrongARM 1100). While these transformations are beyond the reach of compilers for traditional languages such as C, they become tractable given the abundant parallelism and regular communication patterns exposed by the stream programming model.<br>by William Thies.<br>Ph.D.
48
Birka, Adrian 1980. "Compiler-enforced immutability for the Java language." Thesis, Massachusetts Institute of Technology, 2003. http://hdl.handle.net/1721.1/87385.
Full text
49
Reig, Galilea Fermín Javier. "Compiler architecture using a portable intermediate language." Thesis, University of Glasgow, 2002. http://theses.gla.ac.uk/686/.
Full textAbstract:
The back end of a compiler performs machine-dependent tasks and low-level optimisations that are laborious to implement and difficult to debug. In addition, in languages that require run-time services such as garbage collection, the back end must interface with the run-time system to provide those services. The net result is that building a compiler back end entails a high implementation cost. In this dissertation I describe reusable code generation infrastructure that enables the construction of a complete programming language implementation (compiler and run-time system) with reduced effort. The infrastructure consists of a portable intermediate language, a compiler for this language and a low-level run-time system. I provide an implementation of this system and I show that it can support a variety of source programming languages, it reduces the overall eort required to implement a programming language, it can capture and retain information necessary to support run-time services and optimisations, and it produces efficient code.
50
Minder, Patrik. "Introducing modified TypeScript in an existing framework to improve error handling." Thesis, Linköpings universitet, Programvara och system, 2016. http://urn.kb.se/resolve?urn=urn:nbn:se:liu:diva-129285.
Full textAbstract:
Error messages in compilers is a topic that is often overlooked. The quality of the messages can have a big impact on development time and ease oflearning. Another method used to speed up development is to build a domainspecific language (DSL). This thesis migrates an existing framework to use TypeScript in order to speed up development time with compile-time error handling. Alternative methods for implementing a DSL are evaluated based onhow they affect the ability to generate good error messages. This is done usinga proposed list of six usability heuristics for error messages. They are also usedto perform heuristic evaluation on the error messages in the TypeScript compiler. This showed that it struggled with syntax errors but had semantic errormessages with low amount of usability problems. Finally, a method for implementing a DSL and presenting its error messages is suggested. The evaluationof said method showed promise despite the existence of usability problems.<br>Felmeddelanden i kompilatorer är ett ämne som ofta förbises. Kvaliténpå felmeddelanden kan ha stor påverkan på utvecklingstid och lätthetatt lära. En annan metod för att sänka utvecklingstid är att bygga ettdomänspecifikt programmeringspråk. Detta examensarbete migrerar ettexisterande ramverk till TypeScript för att snabba på utvecklingstidmed felhantering i kompileringsstadiet. Alternativa metoder för attimplementera ett DSL evalueras baserat på hur de påverkar möjlighetenatt generera bra felmeddelanden. Detta görs med en föreslagen lista avsex heuristiker för felmeddelanden. De används också för att utföra enheuristik utvärdering på felmeddelandena i TypeScriptkompilatorn. Detta visade att den har svårt för syntaxfel men hademeddelanden för semantiska fel med låg mängdanvändbarhetsproblem. Till sist föreslås en metod för att implementeraett DSL och presentera dess felmeddelanden. Evalueringen av den nämndametoden visade lovande resultat trots förekomsten av användbarhetsproblem.