Develop An Interpreter Using Go Programming

Build an interpreter from scratch

What you'll learn

Creating an Interpreter from Scratch

Understanding different steps in building an Interpreter

Learn to build Interpreter using Go Programming

Follow TDD when building Interpreter using Go

Create data structures like Arrays & Hash

Requirements

Experience using Go Programming

Description

Hello everyone welcome to the course Develop an Interpreter using Go Programming.This course is a comprehensive and practical guide that takes you on a journey of building your own interpreter using the Go programming language. This course is inspired by the great book Writing An Interpreter In Go by Thorsten Ball. All credit to him as well. We will demystify the complex world of interpreters in this course.The course begins by introducing the fundamental concepts of interpreters and programming languages, making it accessible to both beginners and experienced developers. We will build an interpreter using Go for a custom programming language called Monkey through a hands-on approach.we will understand key concepts such as lexical analysis, parsing, and evaluating expressions. In the course we will learn how to design and implement a lexer and a recursive descent parser, providing you learners with a solid foundation in language processing techniques.The course will help developers seeking to deepen their understanding of language implementation. We will use Go as it is simple and easy to use.During the process of developing an interpreter, we will also learn more advanced topics like closures, first-class functions, and error handling.By the end of the course, you would have hopefully gained a deep understanding of how interpreters work and the skills to build your own programming language, opening up new possibilities for exploration and creativity in the world of software development.

Overview

Section 1: Introduction

Lecture 1 Introduction

Lecture 2 Birds eye view on Interpreter

Lecture 3 Installation

Lecture 4 Monkey Programming Language Introduction

Section 2: Lexical Analysis

Lecture 5 Lexer Stage

Lecture 6 Program we will use for lexing

Lecture 7 Manual Interpretation

Lecture 8 Token Type Struct

Lecture 9 Token type constants

Lecture 10 Lexer Testing

Lecture 11 Lexer new function

Lecture 12 Reading Character helper function

Lecture 13 Get the Next Token

Lecture 14 Updating the test for NextToken method

Lecture 15 Updating NextToken method

Lecture 16 Looking up Identifiers

Lecture 17 Ignoring Whitespace

Lecture 18 Reading Numbers

Lecture 19 Add more single character tokens

Lecture 20 Updating Lexer to parse newly added single character tokens

Lecture 21 Update test input with conditional expressions

Lecture 22 Adding new keywords to make test pass

Lecture 23 Interpreting Multiple Special Characters

Lecture 24 Adding an REPL

Section 3: Parser Phase

Lecture 25 Parser Introduction

Lecture 26 Note on Parser Generators

Lecture 27 Parser Types and selection

Lecture 28 Let Statements Intro

Lecture 29 AST Package with interfaces

Lecture 30 Handling let statement

Lecture 31 Getting started with Parser Package

Lecture 32 Recursive Descent using Pseudo Code

Lecture 33 Test for Parsing Let Statement Program

Lecture 34 Implementing Parse Program Logic

Lecture 35 Adding errors field to Parser

Lecture 36 Update expect peek method to add errors

Lecture 37 Add Return Statement Struct in AST Package

Lecture 38 Add test for Return Statment

Lecture 39 Update Parser to parse return statment

Lecture 40 Challenges in Parsing Expressions

Lecture 41 Expressions in Monkey Programming Language

Lecture 42 Adding Expression Statement Struct

Lecture 43 Add String Method to Node Interface

Lecture 44 Testing String method

Lecture 45 Starting implementation for Pratt Parser

Lecture 46 Add helper methods to add infix and prefix to a token type

Lecture 47 Add test for Parsing Identifiers

Lecture 48 Adding Precedence Constants

Lecture 49 Completing Parsing an Identifier

Lecture 50 Test for parsing Integer Literal

Lecture 51 Code to parse Integer Literal

Lecture 52 Add test for parsing Prefix Operator

Lecture 53 Creating Prefix Expression AST Type

Lecture 54 Finish implmenting parsing logic for Parse Expression

Lecture 55 Writing test case for Infix Expression

Lecture 56 Lets add InfixExpression type

Lecture 57 Implementation of Infix Expression Methods

Lecture 58 Adding Operator Precedence Test case

Lecture 59 Going over pratt parser algorithm

Lecture 60 Pratt Parser Call stack

Lecture 61 Refactor Parser test

Lecture 62 AST for Boolean

Lecture 63 Implementation of parser logic for Boolean expression

Lecture 64 Test and Implementation of Grouped Expression

Lecture 65 If Expression AST Representation

Lecture 66 If expression test cases

Lecture 67 Implementation of If expression

Lecture 68 Implementation of else block in if expression

Lecture 69 AST for function literal

Lecture 70 Add test case for parsing function literal

Lecture 71 Function Literal Parser Implementation

Lecture 72 AST structure for call expression

Lecture 73 Test case for parsing call expression

Lecture 74 Implementation of parsing call expression

Lecture 75 Fix precedence of call expression infix fn

Lecture 76 Test case for call expression argument parsing

Lecture 77 Revisting Let and Return Statement parsing to complete a TODO

Lecture 78 Updating REPL to make use of Parser package

Section 4: Evaluation

Lecture 79 Introduction to Evaluation

Lecture 80 Strategies for Evaluation

Lecture 81 Evaluation Pseudocode

Lecture 82 Representing Objects

Lecture 83 New Object Interface

Lecture 84 Integer Object

Lecture 85 Boolean and Null Objects

Lecture 86 Test for Evaluating Integer Expression

Lecture 87 Initial implementation of Eval for parsing Integer Expressions

Lecture 88 Completing the Read, Evaluate, Print Loop

Lecture 89 Implementation for Boolean object

Lecture 90 Implementation for Null Object

Lecture 91 Evaluation of Prefix Operator Bang

Lecture 92 Evaluation of Prefix Operator Minus

Lecture 93 Evaluation of Integer Infix Part 1

Lecture 94 Evaluation of Integer Infix Part 2

Lecture 95 Infix Boolean Evaluation

Lecture 96 Evaluating Conditionals

Lecture 97 Evaluation of return type

Lecture 98 Fix for nested conditionals with return type

Lecture 99 Error Object

Lecture 100 Error Object Implementation Part 1

Lecture 101 Error Object Implementation Part 2

Lecture 102 Test for Let Statement Evaluation

Lecture 103 Adding Environment Object

Lecture 104 Completing Implementation of Let Statement Evaluation

Lecture 105 Basic Function Evaluation

Lecture 106 Evaluation of Function Part 2

Lecture 107 Evaluation of Function Part 3

Lecture 108 Evaluation of Function Part 4

Lecture 109 Completing implementation of Function Evaluation

Lecture 110 Reason for unwrapping

Lecture 111 Getting in touch with concept of closure

Lecture 112 Section Conclusion

Section 5: Extending the Interpreter

Lecture 113 Introduction

Lecture 114 Test case for String data type (lexer phase)

Lecture 115 Finishing Lexer Phase for String data type

Lecture 116 Parser phase for String data type

Lecture 117 Evaluation Phase for String

Lecture 118 String Concatenation Implementation

Lecture 119 Builtin object

Lecture 120 Test case for len builtin function

Lecture 121 implementation of builtin len function

Lecture 122 Introduction to Array

Lecture 123 Lexer Phase of Array

Lecture 124 Parsing Phase of Array

Lecture 125 Parsing Index Expressions

Lecture 126 Evaluation of Array Literal

Lecture 127 Evaluation of Array Index Expression

Lecture 128 Modifying len builtin for arrays

Lecture 129 First and Last Builtin Functions

Lecture 130 Rest and Push Builtin Functions

Lecture 131 Hash Lexer Stage

Lecture 132 Hash Parsing Part 1

Lecture 133 Hash Parsing Part 2

Lecture 134 Hash Key

Lecture 135 Object System for Hash

Lecture 136 Evaluation of Hash

Lecture 137 Getting done with Hash data structure

Lecture 138 Final BuiltIn Function - puts

Section 6: Conclusion

Lecture 139 Conclusion

Lecture 140 Bonus Lecture

Beginner Go Programmers interested to understand how to build an Interpreter