CS 363 – Chapter 1 What is a programming language? Kinds of languages Some history

Languages Carl Sagan once said that to make a recipe from scratch, __________ Programming is difficult, but the language should help us Human language vs. prog. language No one gets job for knowing 12 prog lang  What languages have you worked with? Language should help us; just like how a car helps us get to work.

Definition A programming language is a language intended for expressing a computer program, and any program can be expressed in it. So conceivably, a program can be written in any language, but it’s important to choose appropriately.

Kinds of languages (1) Most are “imperative” Program = seq of statements: begin & end Variables, memory locations a. Von Neuman (verb centered) * b. Object oriented (noun centered) (for short programs, we tend to think von Neumann)

Kinds of languages (2) 2. Most miscellaneous lang are “declarative” NOT a sequence of statements, no order Variables sometimes not used often interactive a. Logical: enter facts, make queries b. Functional: everything is function call ! With effort, can make a declarative language behave imperatively

Some history Originally, all coding was binary Possible even today Instruction consists of opcode & operands Assembly & “pseudocode” languages Replace opcode with word (add, sub, …) Operands are still numbers Ex. load r1, 16 Ex. add r1, r2, r3 Machine dependent  Note that many operations are opposites + - * / etc.

General-purpose languages Starting around 1957 Our own variable names Mathematical operators “x = y+z” instead of “add r1, r2, r3” Can focus on abstraction/algorithm more *** Needs a compiler to translate to machine code! Each language has its own story…

Some influential languages Year Language Features/purpose 1957 FORTRAN Fast, numerical applications, arrays, mistakes 1960 Algol Nested structures, recursion, tries to do everything 1970 Pascal Simple & efficient; pointers 1972 C economical syntax, lots of pointers 1980 Ada Exceptions, concurrency, packages (classes) We’ll finish chapter 1 tomorrow on compilation

Compilation Read sections 1.4 – 1.6 Most languages are compiled; some are interpreted Compile = translate Input to compiler is source code Output is usually machine code

Interpreting and compiling Phases of a compiler

Interpreting A few languages are interpreted After editing program, can immediately run. Each statement is interpreted one at a time as the program is run. Run-time is slower than compiled language. Every time you run program, everything has to be interpreted from scratch. Interpreter doesn’t know what to expect, such as waste. Examples: SPIM simulator, Web browser, Word Although HTML is not a programming language

Compiling Most languages use a compiler… Step 1: Compile = translate Input is source code Output is machine code or assembly code Step 2: The machine code is decoded by machine (very fast)

Some compiling features Note: Not all compilers have these features. 1. Pre-processor Substitutes constants Expands macros Supports conditional compilation 2. Assembler 3. Linker

C Pre-processing example #define MAX 100 #define SWAP(x,y) {int t=x;x=y;y=t;} … // sort ascending for (i = 0; i < MAX; ++i) for (j = i+1; j < MAX; ++j) if (a[i] > a[j]) SWAP(a[i], a[j]); // sort descending if (a[i] < a[j]) Conditional compilation: for (i = 0; i < MAX; ++i) for (j = i+1; j < MAX; ++j) #ifdef ASCENDING if (a[i] > a[j]) #else if (a[i] < a[j]) #endif SWAP(a[i], a[j]);

Writing a compiler Suppose we have new language – Sumatra 1. Write first compiler in existing language, Java. Now, we have a Sumatra compiler, so any Sumatra program can be translated into machine language. From now on, we don’t need Java anymore. 2. Write next Sumatra compiler in Sumatra. Compile it using the first compiler. Another strategy is bootstrapping (p.21) kind of ugly

Steps in Compilation Front end (machine-independent) Scan Parse Semantic analysis Optimization Back end (machine-dependent) Code generation Minor point: We can do some machine-independent optimizations

Scanning & Parsing Scan = “lexical analysis” Break up code into tokens Ignore whitespace & comments Lexical errors are rare Parse = create a parse tree rep’n (p.30-31) Using tokens, understand program’s structure Enforce grammatical rules of language Generates syntax error messages  Why a tree rep’n? Because program is hierarchical (nested) structure.

Semantic analysis Create symbol table Check to see if variables used correctly All variables declared (exactly once) Check types in expressions & statements Ex. Can’t use ++ on JFrame object Check function parameters If all’s well, create syntax tree (p.34) Notice that many tokens no longer needed There are actually more examples of semantic errors!

Static vs. dynamic semantics Compiler can only check static semantics We are NOT running the program Dynamic semantics = behavior at run-time Arithmetic overflow? Exception? These should be handled by program, or else OS or run-time system might intervene

Code generation From symbol table, allocate registers or memory locations Traverse syntax tree to generate instructions Optimize = make code more efficient Eliminate redundancy or waste Replace long operations with short ones It’s worth it ! Re-state the 5 different phases of the compiler (scan, parse, semantic analysis, code gen, opt)