• Title Implementing Programming Languages: An Introduction to Compilers and Interpreters
• Author(s) Aarne Ranta
• Publisher: College Publications (May 9, 2012)
• Paperback 224 pages
• eBook PDF
• Language: English
• ISBN-10: 1848900643
• ISBN-13: 978-1848900646
• Share This:  

Book Description

Implementing a programming language means bridging the gap from the programmer's high-level thinking to the machine's zeros and ones. If this is done in an efficient and reliable way, programmers can concentrate on the actual problems they have to solve, rather than on the details of machines. But understanding the whole chain from languages to machines is still an essential part of the training of any serious programmer. It will result in a more competent programmer, who will moreover be able to develop new languages. A new language is often the best way to solve a problem, and less difficult than it may sound.

This book follows a theory-based practical approach, where theoretical models serve as blueprint for actual coding. The reader is guided to build compilers and interpreters in a well-understood and scalable way. The solutions are moreover portable to different implementation languages. Much of the actual code is automatically generated from a grammar of the language, by using the BNF Converter tool. The rest can be written in Haskell or Java, for which the book gives detailed guidance, but with some adaptation also in C, C++, C#, or OCaml, which are supported by the BNF Converter.

The main focus of the book is on standard imperative and functional languages: a subset of C++ and a subset of Haskell are the source languages, and Java Virtual Machine is the main target. Simple Intel x86 native code compilation is shown to complete the chain from language to machine. The last chapter leaves the standard paths and explores the space of language design ranging from minimal Turing-complete languages to human-computer interaction in natural language.

• Aarne Ranta is a Professor of Computer Science at the University of Gothenburg, Department of Computer Science and Engineering, CEO and founder of Digital Grammars Gothenburg AB, and Principal investigator of REMU Project, Faculty ("Kollegium") co-chair of the Department of Computer Science and Engineering (with Wolfgang Ahrendt), and Coordinator of MOLTO (FP7-ICT-247914) from March 2010 to May 2013. Teaches Databases and Computational Syntax of Natural Language courses.

• Amazon

• Compiler Design and Construction
• Theory of Programming Languages

• Implementing Programming Languages: An Introduction to Compilers and Interpreters
• The Mirror Site (1) - PDF
• Errata of the Book

• Principles of Programming Languages (Mike Grant, et al.)

  This book is an introduction to the study of programming languages. The material has evolved from lecture notes used in a programming languages course for juniors, seniors, and graduate students at Johns Hopkins University.

• Introduction to Compilers and Language Design (Douglas Thain)

  This book offers a one semester introduction into compiler construction, enabling the reader to build a simple compiler that accepts a C-like language and translates it into working X86 or ARM assembly language.

• Compiler Design: Theory, Tools, and Examples (Seth Bergmann)

  This is an introductory level text for compiler design courses, that emphasizes problem solving skills. The concepts are clearly presented with sampler problems and diagrams to illustrate the concepts.

• Basics of Compiler Design (Torben Mogensen)

  This book presents techniques for making realistic, though non-optimizing compilers for simple programming languages using methods that are close to those used in 'real' compilers, albeit slightly simplified in places for presentation purposes.

• Compiler Construction (William M. Waite, et al)

  This is a modern text written by two leaders in the field. It demonstrates how a compiler is built, and provides the reader with a firm theoretical basis for compiler construction and sound engineering principles.

• Compiler Design in C (Allen I. Holub)

  It teaches real-world compiler design concepts and implementation, with the basics of compiler design, concentrating on the second pass (in a typical four-pass compiler), consisting of a lexical analyzer, parser, and a code generator, etc.

• Let's Build a Compiler (Jack w. Crenshaw)

  This book provides a practically-oriented introduction to high-level programming language implementation. It covers the fundamental principles of the subject in an accessible way and presents the necessary background theory.

• Parsing Techniques - A Practical Guide (Dick Grune, et al)

  Parsing techniques provide a solid basis for compiler construction and linguistics, and contribute to all existing software: they enable Web browsers to analyze HTML pages and PostScript printers to analyze PostScript, code generation in compilers, etc.

• Compiling Techniques (F. R. A. Hopgood)

  In this book, the problem-oriented language to be compiled will be assumed to be as machine independent and as complex as a language like Fortran or Algol. Most examples will be drawn from one or other of these languages.

• Compiler Construction (Niklaus Wirth)

  A refreshing antidote to heavy theoretical tomes, this book is a concise, practical guide to modern compiler design and construction by an acknowledged master. Readers are taken step-by-step through each stage of compiler design.

• An Introduction to Compilers (Dirk Vermeir)

  This book addresses the essential aspects of compiler design at a level that is perfect for today's undergraduate. It provides the clearest, most cohesive treatment of the topic available for the junioror senior-level student.

• Compiler Construction (Wikibooks)

  The purpose of this book is to provide practical advice on writing a compiler, together with some practical examples of both compilers and interpreters, in order to break away from the concept that building compilers and interpreters are impossible tasks.