Login

**BaDshaH** · 06-29-2023, 09:27 AM

[Image: Sa-JVDs-E5z-L1-Ae3-KLMDVe8w-SJ5-Hm-AGVXy.jpg]

Published 6/2023
MP4 | Video: h264, 1920x1080 | Audio: AAC, 44.1 KHz
Language: English | Size: 5.29 GB | Duration: 14h 28m

Build an interpreter from scratch

[b]What you'll learn[/b]
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

[b]Requirements[/b]
Experience using Go Programming

[b]Description[/b]
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

Homepage