Course overview

Introduction

What is an Abstract Syntax Tree? Visualizing Code Like a Compiler

How to View Abstract Syntax Tree Code With AST Explorer

The Best JavaScript AST Tools - ESLint, Babel, Terser, and More

Environment setup

Understanding Abstract Syntax Trees (AST)

How to Generate a JavaScript AST With Babel Plugins

Traversing an AST With Babel Traverse

Add Type Safety and Prevent Runtime Errors With AST

Working with Abstract Syntax Trees

Practical code audits

How to Audit Your Code With AST Programming

How to Add a Component and Update an AST

When to Use Abstract Syntax Tree Tooling to Refactor at Scale

Code Audits

How to Mutate an AST and Automatically Replace Code Components

How to Create Codemods Using jscodeshift

How to Unit Test jscodeshift Transforms With ts-jest

Codemods

How to Ensure Codebase is Up to Date With Linting Rules

How to Use ESLint to Create AST Rules With Babel Traverse

How to Test Custom ESLint Linting Rules With AST

Linting

node.js

In this course, we'll start with the fundamentals of abstract syntax trees (ASTs) and learn the basic mental models. This general AST knowledge can be translated to almost any tool that works with ASTs.

## Why this course?

Understanding and using ASTs unlocks the ability to make sweeping changes in a safe and reliable way in any size codebase.

## Course topics

Throughout this course, we'll have converted source code into ASTs, traversed, mutated, and generated ASTs. With these concepts we'll then explore several practical applications including things like code audits (static analysis), code transformations (codemods), and linting.

### Module 1

We'll learn the fundamentals of abstract syntax trees. 

- What is an AST?
- How to explore an AST
- Examples of JavaScript tools that work with ASTs

### Module 2

We'll learn how to work with ASTs.

- How to turn code into an AST
- How to programmatically navigate any AST 
- How to leverage TypeScript to prevent runtime errors

### Module 3

We'll learn how to statically analyze, or "audit" code to understand the state of the codebase using abstract syntax trees.

- An introduction to an example codebase and refactor
- Understanding the state of the current codebase
- When to use an AST-based tool versus doing something manually

### Module 4

We'll learn how to transform, or "codemod" code from one state to another using abstract syntax trees.

- How to make changes to an AST
- How to change ASTs with [jscodeshift](https://github.com/facebook/jscodeshift)
- How to test a code transform

### Module 5

We'll learn how to write rules, or "lint" code using abstract syntax trees.

- How to create rules for code
- How to create custom rules with [ESLint](https://eslint.org)
- How to test a rule

In this course, you'll learn the fundamentals of abstract syntax trees, what they are, how they work, and dive into several practical use cases of abstract syntax trees to maintain a JavaScript codebase.

Practical Abstract Syntax Trees

JavaScript tools that work with abstract syntax trees

How to parse, traverse, and generate abstract syntax trees

Practical skill set for maintaining large JavaScript codebases

This course is designed to provide a concrete understanding of the theory and practical uses of "abstract syntax trees" (ASTs).

Before we explore the practical uses, we need to gain a conceptual understanding of ASTs. At a high level, an 

intermediate representation of source code as a tree structure

 starts with a root. The root can then point to other values, and those values to others, and so on. This begins to create an implicit hierarchy, and also happens to be a great way to represent source code in a way computers can easily interpret.

Each one of these values (circles in the tree) are referred to as 

. The relationships between nodes are often described with terms like 

 is shown at the top, however if it's flipped, with the root node at the bottom and heading upwards, it starts to look like an actual tree with all its branches forking out.

Tree data structures are common in computer science and have many practical applications, such as searching and sorting data. There are also many different types of trees with different constraints. For example, a 

For the purpose of working with ASTs, the important aspect is understanding how a tree can be used to represent data and the relationships between nodes.

Some of the most prominent uses of ASTs are in compilers. A compiler accepts source code as input, and then outputs another language. This is often from a high-level programming language to something low-level, like machine code.

In the frontend web ecosystem, this includes tools like 

. These tools compile many modules into a bundle, and perform other optimizations such as transpiling from modern JavaScript to an older version, or minifying the code by renaming variables and functions to shorter names. Although they are a little different to conventional compilers, they follow many of the same fundamental steps.

---
title: What is an Abstract Syntax Tree? Visualizing Code Like a Compiler
description: Understand the basics of an AST and how it relates to real-world code
privateVideoUrl: "https://fullstack.wistia.com/medias/f4mkdzaypj"
---

# What is an Abstract Syntax Tree?

This course is designed to provide a concrete understanding of the theory and practical uses of "abstract syntax trees" (ASTs).

![Example abstract syntax tree](https://d2uusema5elisf.cloudfront.net/courses/practical-abstract-syntax-trees/module_01/lesson_01.01/public/assets/example-ast.png)

Before we explore the practical uses, we need to gain a conceptual understanding of ASTs. At a high level, an [abstract syntax tree](https://en.wikipedia.org/wiki/Abstract_syntax_tree) is an **intermediate representation of source code as a tree structure**. What does that mean? 🤔

### Tree (data) structure

A [tree data structure](https://en.wikipedia.org/wiki/Tree_(data_structure)) starts with a root. The root can then point to other values, and those values to others, and so on. This begins to create an implicit hierarchy, and also happens to be a great way to represent source code in a way computers can easily interpret.

![tree data structure example](https://d2uusema5elisf.cloudfront.net/courses/practical-abstract-syntax-trees/module_01/lesson_01.01/public/assets/tree-data-structure.png)

Each one of these values (circles in the tree) are referred to as **nodes**. The relationships between nodes are often described with terms like **child node**, **parent node**, **sibling node**, and so on.

By convention, the **root node** is shown at the top, however if it's flipped, with the root node at the bottom and heading upwards, it starts to look like an actual tree with all its branches forking out.

![tree data structure with root at the bottom](https://d2uusema5elisf.cloudfront.net/courses/practical-abstract-syntax-trees/module_01/lesson_01.01/public/assets/tree-data-structure-by-tree.png)

Tree data structures are common in computer science and have many practical applications, such as searching and sorting data. There are also many different types of trees with different constraints. For example, a [binary tree](https://en.wikipedia.org/wiki/Binary_tree) is a tree with at most two child nodes.

For the purpose of working with ASTs, the important aspect is understanding how a tree can be used to represent data and the relationships between nodes.

## ASTs and compilers

Some of the most prominent uses of ASTs are in compilers. A compiler accepts source code as input, and then outputs another language. This is often from a high-level programming language to something low-level, like machine code.

![compiler input and output](https://d2uusema5elisf.cloudfront.net/courses/practical-abstract-syntax-trees/module_01/lesson_01.01/public/assets/compiler-input-output.png)

In the frontend web ecosystem, this includes tools like [webpack](https://webpack.js.org) or [parcel](https://parceljs.org). These tools compile many modules into a bundle, and perform other optimizations such as transpiling from modern JavaScript to an older version, or minifying the code by renaming variables and functions to shorter names. Although they are a little different to conventional compilers, they follow many of the same fundamental steps.

Understand the basics of an AST and how it relates to real-world code

Learn

The newline Guide to Building Your First GraphQL Server with Node and TypeScript

Teach

Amelia Wattenberger

Author of Fullstack D3

Community

Practical Abstract Syntax Trees

Module 1: Introduction

Introduction:

Start Here

Introduction: (2:27)

Course overview

Module 2: Understanding Abstract Syntax Trees (AST)

Lesson 1: (5:55)

What is an Abstract Syntax Tree? Visualizing Code Like a Compiler

Lesson 2: (4:21)

How to View Abstract Syntax Tree Code With AST Explorer

Lesson 3: (1:46)

The Best JavaScript AST Tools - ESLint, Babel, Terser, and More

Lesson 4: (1:03)

Environment setup

Module 3: Working with Abstract Syntax Trees

Lesson 1: (6:29)

How to Generate a JavaScript AST With Babel Plugins

Lesson 2: (7:33)

Traversing an AST With Babel Traverse

Lesson 3: (9:31)

Add Type Safety and Prevent Runtime Errors With AST

Module 4: Code Audits

Lesson 1: (2:35)

Practical code audits

Lesson 2: (15:29)

How to Audit Your Code With AST Programming

Lesson 3: (2:32)

How to Add a Component and Update an AST

Lesson 4: (1:43)

When to Use Abstract Syntax Tree Tooling to Refactor at Scale

Module 5: Codemods

Lesson 1: (21:13)

How to Mutate an AST and Automatically Replace Code Components

Lesson 2: (10:03)

How to Create Codemods Using jscodeshift

Lesson 3: (5:55)

How to Unit Test jscodeshift Transforms With ts-jest

Module 6: Linting

Lesson 1: (8:44)

How to Ensure Codebase is Up to Date With Linting Rules

Lesson 2: (5:31)

How to Use ESLint to Create AST Rules With Babel Traverse

Lesson 3: (4:31)

How to Test Custom ESLint Linting Rules With AST

What is an Abstract Syntax Tree? Visualizing Code Like a Compiler