Department of Computer Science		Bowdoin College
Fall 1990

CS 250 -- Programming Languages 
Syllabus

	This course will examine the history and design principles that
underly modern programming languages.  We will also study important
programming paradigms that have emerged in computer science.  
	These design principles include syntax, semantics, data types and
data structures, scope, modularity, abstraction, control flow, and the
overall influence of application domain on the design of language styles
and features.  
	A programming "paradigm" is a distinguished style of problem
solving and algorithmic development.  We are familiar with the procedural
paradigm, which is the most common and widely used.  However,
alternative paradigms also thrive in various application domains.  These
include: object-oriented programming, functional programming,  logic
programming, and programming with parallelism.  Appropriate languages
that support these paradigms include: SMALLTALK and Eiffel (object-
oriented), Lisp (functional), Prolog (logic programming), and Ada and
Modula-2 (concurrency)
	DECStation/Unix, Mac, and PC implementations of these languages
will be used to support the laboratory work for this course.  The course
will be conducted in seminar fashion, with student presentations added to
lectures and discussions.  Two tests, some laboratory and written
assignments, and one substantial laboratory project will comprise the
major work for the course.

Meeting Times: MWF 10:00 (210 Adams)
	Lab sessions (to be arranged)

Instructor: Allen Tucker (211 Adams)--office hours by appointment

Text (to be purchased): MacLennan, Bruce, Principles of Programming
	Languages, Holt (1987).

Supplementary Readings (to be handed out):
	1.  Tucker, Allen, Programming Languages, McGraw-Hill (1986).
	2.  Meyer, Bertrand, Object-Oriented Software Construction,
	Prentice-Hall, 1988.
	2.  Sethi, Ravi, Programming Languages: Concepts and Constructs,
	Addison-Wesley, 1989.
	3.  Selected reprints on object-oriented programming, functional
	programming, concurrency, and logic programming.
	
Course Outline:

Week of	Topics							Readings

Sept   3	History and overview of programmng		Chapters 1-3
		language design and implementation; 		& handouts
		early languages, data structures, naming
		(lab-intro to Unix and Emacs)
    	10	Syntactic structures, control structures	Chapters 4, 5
		(lab-Pascal and FORTRAN on Unix)	 	& handout
    17,24	Semantics; implementation of procedural	Chapter 6
		languages (lab-run-time properties of 
		Pascal and FORTRAN programs)			

Oct 1		***Test #1--October 5***

      8,15	Data abstraction, inheritance, and		Chapters 7,12
		object-oriented programming; 			& handouts
		Modula-2, Ada, SMALLTALK, and Eiffel			
		(lab-oop in C++)        

    22,29	Functional programming; Lisp			Chapter 9,10
								& handout
Nov 5		***Test #2--November 9***

    12,19	Logic programming; Prolog			Chapter 13
								& handout
	26	Concurrent programming; "rendezvous"		Chapter 8
		in Ada						& handout

Dec 4		Epilogue: programming language design		

      6-10	***Reading period***
    11-18	***Final exam period; final projects due***
	
The Project:  The project will require the design and implementation of
	a case study problem using one of the four paradigms--object-
	oriented, functional, logic, or concurrent.  This will be accompanied
	by an in-class presentation and a final paper.  The purpose of the
	paper is to summarize your understanding of the paradigm and its
	applicability to the case study problem that you have implemented.