[HD] EECS4302 F26 - 2026-09-10 (Thursday) - Lecture 1

Overview

Jackie Wang introduces York’s EECS 4302 compiler course, outlining its Java-based assignments, compiler project, assessments, learning resources, and classroom expectations. The course connects theory from EECS 2001—regular languages, grammars, and parsing—to building a compiler with ANTLR 4, transforming an abstract syntax tree, and presenting the finished work.

Key takeaways

EECS 4302 expects students to connect EECS 2001 automata and grammar theory with practical compiler construction, including scanning, parsing, AST generation, and recursive transformation.
ANTLR 4 automates much of the scanner and parser infrastructure from token regular expressions and a context-free grammar, leaving students to implement the compiler-specific AST transformation.
The course uses Java for compiler assignments and the programming test; Eclipse is required for submissions, although students may develop in another editor if they can export the work to Eclipse.
Assessment combines three deadline-based programming assignments, a milestone-driven 24% project, an 80-minute programming test, a 10% written test, and a 50% cumulative final; attendance is planned as a bonus.
AI-generated code is permitted for assignments, but students remain responsible for verifying and debugging it; Wang cautions that skipping foundational understanding creates cognitive debt.
The project is intended to demonstrate the full compiler-development workflow, including implementation decisions, a written report, and a presentation.

Chapters

0:00 EECS 4302 Welcome, Course Purpose, and Student Support

Jackie Wang introduces EECS 4302 as a course on compilers and interpreters and says the first meeting will focus mainly on course organization.
Wang took the course as a York student in 2005 and describes compiler construction as a valuable synthesis of ideas from earlier courses.
Students can ask for advice about the course or compiler side projects during office hours or by appointment.

3:40 Classroom Expectations and the Six-to-Seven-Week Compiler Project

Wang asks students to avoid phones and headphones, limit unrelated laptop activity, and keep the small classroom focused.
The final project is planned for release about one week before reading week, giving students roughly six to seven weeks to work.
The project may include checkpoints, a report, and a presentation; solo or paired work may be possible depending on enrollment.

7:35 Lecture Website, Office Hours, and Java Preparation

Course materials will be organized on Wang’s lecture website, with eClass announcements and email used for important updates.
Office hours are scheduled for Mondays and Thursdays, 2–3 p.m., in Lassonde Building 2043; appointments are also available.
The compiler implementation and programming test use Java, with review resources linked for introductory Java, EECS 2030 inheritance and polymorphism, and EECS 2011 trees and recursion.

13:00 EECS 2001 Theory Review, Eclipse Submissions, and ANTLR Tutorial

The course revisits EECS 2001 topics including DFA and NFA, regular expressions, DFA minimization, context-free grammars, and top-down versus bottom-up parsing.
Eclipse is required for programming-test and project submissions because the tutorials and grading setup use its project structure; students may use another editor while developing if they can export to Eclipse.
GitHub is optional, and students may publish assignments or their finished project; a recorded ANTLR 4 tutorial will support assignment two and compiler development.

21:30 Syllabus Policies, Course Resources, and Optional Compiler Textbooks

Wang says the syllabus may change through week two and invites feedback, especially about how class attendance should affect grading.
Students who submit an honest best attempt on each of three programming assignments by the deadline receive the assignment credit, even if the work is incomplete.
There is no required textbook; optional references include Engineering a Compiler and a classic compiler text, while lecture slides and worked examples are the core materials.

30:55 Proposed Assessment Mix, Project Checkpoints, and Test Format

The proposed scheme assigns 6% to three programming assignments and 24% to the project, which is divided into milestones and a final submission.
The course also includes an 80-minute Java programming test, a paper-and-pen written test worth 10%, and a three-hour cumulative final exam worth 50%.
Wang plans practice opportunities for the programming test and may adjust assessment weights later based on students’ performance across tests and the final.

38:00 Attendance Bonus, iClicker Setup, and Key Assessment Dates

Students prefer attendance credit as a bonus rather than a graded requirement; Wang says the bonus will be at least 5% and will confirm the details on Tuesday.
Students should enroll in the EECS 4302 course through iClicker; a trial attendance check is planned for Tuesday, followed by regular use.
The programming test is scheduled for November 5 and the written test for November 19; project milestones will include file submissions and feedback.

44:30 Course Topics, Project Planning, and the 75-Minute Class Arrangement

Planned topics include compiler overviews, scanner and parser foundations, parsing algorithms, ANTLR 4, and the Composite and Visitor design patterns.
Assignment one is expected in week three, while assignment two and the project are planned for release around the end of week five, before reading week.
Because Wang teaches EECS 3342 immediately afterward, EECS 4302 meetings will end five minutes early at 75 minutes; the time will be recovered through tutorial help or asynchronous material.

49:15 AI Use, Verification, and the Value of Foundational Understanding

Wang argues that AI tools can automate difficult work but may hallucinate or misinterpret incomplete or ambiguous requirements.
Students using AI-generated compiler code remain responsible for testing, debugging, judging, and adapting the result before relying on it.
Relying on AI without understanding the underlying concepts can create cognitive debt that resurfaces during implementation or assessment.

51:50 General-Purpose Languages, DSLs, and Regular-Language Models

Java, C, C++, and Python are examples of general-purpose languages, while SQL is a domain-specific language for working with stored data and queries.
Propositions and predicates provide another specialized notation, suited to specifying constraints rather than building general applications.
The course’s assignment-two language and project compiler use small domain-specific languages; regular languages can be represented by DFAs, NFAs, epsilon-NFAs, and regular expressions.

57:40 Context-Free Grammars, Parsing Strategies, and Abstract Syntax Trees

Context-free grammars define recursive language structures and provide the basis for parsing programs.
The course studies both top-down and bottom-up parsing, with students implementing one parsing algorithm in Java for assignment three.
A grammar and input program allow the compiler to derive an abstract syntax tree (AST), which becomes the structure used for later transformations.

1:01:55 Compiler Pipeline: Scanning, Parsing, ANTLR 4, and AST Transformation

The compiler pipeline begins with scanning source code into tokens such as keywords and identifiers, then parsing those tokens into an AST.
ANTLR 4 can generate much of the scanner and parser machinery from regular-expression token definitions and a context-free grammar.
Students implement the recursive AST transformation that converts the parsed structure into the desired output, applying the compiler’s application-specific logic.

1:04:15 Next Lecture: Compiler Examples and Project Brainstorming

The course will begin its technical overview in the next Tuesday class, using compiler examples and past EECS 4302 projects.
Wang encourages students to start considering what compiler they might build and says the class can brainstorm ideas together.
Wang will post the confirmed attendance-bonus details through eClass.

Summary, takeaways, and chapters were generated by AI from the video's transcript and may contain errors. The video belongs to its creator, Jackie Wang.