Class 1: Introduction

Before the end of the day today, you should take the introductory survey.

Handouts

• A few administrative handouts, including notes on my philosophy of teaching and learning, my expectations of you, and some additional notes on academic honesty.
• A short guide to the Tiger language.
• A few pages from the K&R C book describing declarations.

Background

• I believe in beginning my courses with a short dialog concerning the topic of study. In particular, I think we should ask ourselves:
  • What are compilers?
  • Why do we study compilers? (Why do we have a course in compilers? Why do most CS departments include compilers in the undergraduate curriculum? Why have you chosen to take this class?)
  • How should we study compilers?
• You can find some of my notes on these questions below. However, this class will develop its own answers to these and related questions.

What are compilers?

• Compilers are programs that translate from one language (typically a high-level language, like Java, C, or Pascal) to another (typically a low-level language, like assembler, machine code, or C).
• To do this translation, they step through a number of phases, which we will discuss later.

Why study compilers?

• The joy of creating a significant computing artifact.
• CS is a field that involves both practice (e.g., programming) and theory (e.g., CS341). Compilers are a wonderful ``platform'' for studying both practice and theory. In fact, compilation motivated many of the early problems in theory.
• Many large programs include their own language. If you are ever called upon to help design such a language, you can draw upon these skills.
• Understanding how compilers work may help you program better (although I strongly discourage you from ``coding for the compiler'', particularly since newer compilation techniques may actually do worse with programs designed for earlier compilers).
• Compilation involves many important subfields of computer science, including
  • Formal language theory
  • Programming language design
  • Software design
  • Architecture

How should we study compilers?

• Do problems to ensure that we understand the underlying theories.
• Build one.

Course Organization and Policies

• There are tons of accompanying documents which you can find through the handouts page. We will go over these casually.
• Note that the department voted that CS362 is intended to serve some of the same purposes as CS223. Because of this, CS362 must involve
  • at least one public presentation;
  • group work; and
  • a significant project.
• The significant project is no problem, as any compiler is a pretty significant project. In fact, it is significant enough that you will be working on it in groups.
• For public presentations in CS362, I will be having you engage in debates on various design issues. You will each evaluate each other's debating skills.
• In addition to group programming and debate work, you will also do a number of written homeworks (often, simultaneous with the programming work). You should do those homeworks as individuals, although you may discuss ideas and answers with each other.
• There is a lot of extra software that we'll use in this class. Rather than burden Karen, I've received departmental permission to hire a class "software guru" who is in charge of installing and maintaining that software (and, occasionally, answering questions about it). If you are interested in that position (about 5 hpw), please let me know.

The phases of a compiler

• As mentioned earlier, a compiler does its translation in phases, a phase at a time.
• There are a variety of ways to express these phases and different compilers may choose different ways to break up the compilation process.
• The simplest is the two-phase compiler. The first phase (called the front end) translates from the original high-level language to a simple common intermediate language. The second phase (called the back end) translates the intermediate language to assembler or machine code.
• The front end is language dependent. The back end is machine dependent.