Develop an Interpreter Using TypeScript

Develop an Interpreter Using TypeScript, available at $54.99, has an average rating of 4.67, with 97 lectures, based on 3 reviews, and has 82 subscribers.

You will learn about Developing an Interpreter using TypeScript Understand Lexing, Parsing , Evaluation steps of the Parser Create a REPL for playing with the interpreter Develop interpreter for a custom programming language Develop and understand Pratt Parser logic This course is ideal for individuals who are Intermediate JavaScript / TypeScript developers It is particularly useful for Intermediate JavaScript / TypeScript developers.

Enroll now: Develop an Interpreter Using TypeScript

Summary

Title: Develop an Interpreter Using TypeScript

Price: $54.99

Average Rating: 4.67

Number of Lectures: 97

Number of Published Lectures: 97

Number of Curriculum Items: 97

Number of Published Curriculum Objects: 97

Original Price: ?999

Quality Status: approved

Status: Live

What You Will Learn

Developing an Interpreter using TypeScript

Understand Lexing, Parsing , Evaluation steps of the Parser

Create a REPL for playing with the interpreter

Develop interpreter for a custom programming language

Develop and understand Pratt Parser logic

Who Should Attend

Intermediate JavaScript / TypeScript developers

Target Audiences

Intermediate JavaScript / TypeScript developers

Hello everyone welcome to the course Develop an Interpreter using TypeScript.

This course is a comprehensive and practical guide that takes you on a journey of building your own interpreter using the TypeScript 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 TypeScript 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.

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.

Course Curriculum

Chapter 1: Introduction

Lecture 1: Introduction

Lecture 2: Birds Eye view of Interpreter

Lecture 3: Monkey Programming Language Overview

Chapter 2: Lexical Analysis

Lecture 1: Lexical Analysis Introduction

Lecture 2: Installation of Tools

Lecture 3: Initial Project Setup

Lecture 4: Configure Vitest as Test Runner

Lecture 5: Token Type

Lecture 6: Lexers Next Token Implementation

Lecture 7: Lexers Next Token Implementation Re-Explanation

Lecture 8: Extending the test to have input as valid Monkey Programming Language

Lecture 9: Implementing reading Identifier Tokens

Lecture 10: Skipping Whitespace and Lookup Ident method

Lecture 11: Reading Numbers

Lecture 12: Extend Single Character Tokens

Lecture 13: Updating Next Token Method

Lecture 14: Extend the Keywords

Lecture 15: Extending Tokens with Double Character Tokens

Lecture 16: Creating a REPL

Lecture 17: Fix for issue in REPL

Chapter 3: Parsing

Lecture 1: Introduction to Parser

Lecture 2: Introduction to Parsing Let Statements

Lecture 3: AST for Statement and Expression Node

Lecture 4: AST for Let and Identifiers

Lecture 5: Starting with Parser Implementation

Lecture 6: Test case for Parsing Let Statements

Lecture 7: Explanation of Test case

Lecture 8: Implementation of parseStatement method

Lecture 9: Completing the parsing of let statement

Lecture 10: Adding errors to Parser

Lecture 11: Parsing Return Statements

Lecture 12: Introduction to Parsing Expressions

Lecture 13: Refactoring AST Module

Lecture 14: Add string method to root AST Node

Lecture 15: Infix and Prefix Methods

Lecture 16: Identifier Expression Test case

Lecture 17: Parsing Identifiers Implementation

Lecture 18: Parse Integer Literals

Lecture 19: Test case for Prefix Expression

Lecture 20: Implementation of Prefix Expression

Lecture 21: Test case for Infix Expression

Lecture 22: Implementation of Infix Expression

Lecture 23: Operator Precedence Test

Lecture 24: How Pratt Parser works

Lecture 25: Refactoring Tests

Lecture 26: AST and Test for Boolean Expressions

Lecture 27: Implementation of Boolean Expression

Lecture 28: Implementation of Grouped Expressions

Lecture 29: AST for If Expression

Lecture 30: Test case for If Else Expression

Lecture 31: Implementation of If Else Expression

Lecture 32: AST and Test case for Function Literal

Lecture 33: Implementation of Function Literal

Lecture 34: AST and Test case for Call Expression

Lecture 35: Implementation of Call Expression

Lecture 36: Working on Todos

Lecture 37: Completion of Parser with update to REPL

Chapter 4: Evaluator

Lecture 1: Evaluation Introduction

Lecture 2: Object Representation

Lecture 3: Integer Representation

Lecture 4: Boolean and Null Representation

Lecture 5: Evaluation Implementation of Integer

Lecture 6: Evaluation Implementation of Boolean

Lecture 7: Null implementation

Lecture 8: Evaluation of Prefix Expression

Lecture 9: Evaluation of Infix (Integers)

Lecture 10: Evaluation of Infix (Integers) – Boolean Operators

Lecture 11: Evaluation of Infix (Boolean)

Lecture 12: Conditionals

Lecture 13: Return Statement

Lecture 14: Error Handling

Lecture 15: Let Statement

Lecture 16: Functions Pt.1

Lecture 17: Functions Pt.2

Lecture 18: End of Evaluation

Chapter 5: Adding Data Structures

Lecture 1: Introduction

Lecture 2: String Data Structure – Lexer

Lecture 3: String Data Structure – Parser

Lecture 4: String Data Structure – Evaluator

Lecture 5: String Data Structure – Concatenation

Lecture 6: Builtin Functions

Lecture 7: Builtin Function – len (string)

Lecture 8: Array – Lexer

Lecture 9: Array – Parsing

Lecture 10: Parsing Array Index Expressions

Lecture 11: Evaluate Array Literals

Lecture 12: Evaluate Array Index Expressions

Lecture 13: Array builtin Functions

Lecture 14: Hash Data Structure – Lexer

Lecture 15: Hash Data Structure – Parsing

Lecture 16: Hash Data Structure – Hash Key

Lecture 17: Hash Data Structure – Object Representation

Lecture 18: Hash Data Structure – Evaluation

Lecture 19: Hash Data Structure – Index Expression

Lecture 20: Builtin Method – Puts

Instructors

Code with HK
Instructor

Rating Distribution

1 stars: 0 votes

2 stars: 0 votes

3 stars: 0 votes

4 stars: 1 votes

5 stars: 2 votes

Frequently Asked Questions

How long do I have access to the course materials?

You can view and review the lecture materials indefinitely, like an on-demand channel.

Can I take my courses with me wherever I go?

Definitely! If you have an internet connection, courses on Udemy are available on any device at any time. If you don’t have an internet connection, some instructors also let their students download course lectures. That’s up to the instructor though, so make sure you get on their good side!