CS-320: Computer language processing

About
Privacy
Disclaimer

Graph Chatbot

Lectures in this course (73)

Lambda Functions: Syntax and Examples

Covers the syntax and examples of lambda functions, including parameters, types, bodies, and environments.

Constructing a Lexer: First Symbols

Covers the computation of 'nullable' and 'first' for regular expressions, converting expressions into a lexer, and handling token priorities.

Language Server Protocol: Implementation for IME Compiler

Covers the Language Server Protocol implementation for the IME compiler, focusing on features like auto-completion and signature helpers.

Constructing a Lexer: First Symbols

Covers the computation of 'nullable' and 'first' for regular expressions.

High-Order Functions: Unification Theory

Covers high-order functions, parser, and type checker concepts.

Regular Expressions to Automata

Explores the conversion of regular expressions to automata for efficient character classification.

WASM Virtual Machine: Group 13

Explores the development of a WebAssembly Virtual Machine by Group 13, covering pipeline stages, interpreter structure, and stack management.

From Regular Expressions to Automata

Explores the transition from regular expressions to finite automata, covering lexer creation, different automata types, and conversion processes.

Implicit Parameters: Basics and Applications

Introduces implicit parameters in Scala, showcasing their implementation in a Logger class and their application in a SimpleAI object.

Introduction to Grammars

Introduces automata, regular languages limitations, context-free grammars, and balanced parentheses grammars.

Syntax Trees: Parse vs AST

Explains syntax trees, parse vs AST, while language syntax, AST classes, and grammar ambiguities.

Code Formatter: Customizable Pretty Printing

Introduces a code formatter for customizable pretty printing, including options like if on separate lines and challenges faced in managing comments' positions.

C Backend: Compiler Structure and Abstract Data Types

Explores the structure of a C backend compiler and abstract data types.

LL(1) Parsing

Covers LL(1) parsing, formalization, automation, constraints, and parsing tables.

Multithreading: Code Generation and Type Checking

Covers multithreading, code generation, and type checking in compiler implementation.

Scallion tutorial: building Parser[A]

Covers the basics of building Parser[A] using Scallion, LL(1) conflicts, and left factoring.

CYK Parsing Algorithm for General Grammars

Introduces the CYK parsing algorithm for context-free grammars, explaining its handling of ambiguity and importance in parsing general grammars.

Foreign-function interface to JavaScript

Covers the implementation of a foreign-function interface to JavaScript in Scala, focusing on features like opening and reading files.

CYK Algorithm for Parsing General Grammars

Explores parsing general grammars using the CYK algorithm and Chomsky Normal Form.

Chomsky Normal Form Transformation

Explains the steps to convert a grammar into Chomsky Normal Form.

Page 2 of 4