Objectives

To master some of the fundamental concepts that underlie programming language syntax and semantics through a comparative study of several languages and their features; to learn several new programming language features and paradigms; to gain the ability to study conceptual linguistic issues without being confused or blinded by a particular language's implementation; to gain insight into the problem of designing new languages.

Prerequisites

Programming proficiency in one but preferably two high-level languages such as Java, C#, or Perl. A previous course in Data Structures and Algorithms.

Readings

The primary textbook for this class is:

• Michael L. Scott, Programming Language Pragmatics, Second Edition, Morgan Kaufmann, 2005. (ISBN 0-12-633951-1)

You'll probably do very well to pick up texts covering some of the main languages we'll be covering in this class:

• Larry Wall, Tom Christiansen, and John Orwant, Programming Perl, 3rd edition, O'Reilly, 2000. (ISBN 0596000278)
• Jeffrey Ullman, Elements of ML Programming, ML97 Edition, Prentice Hall, 1998. (ISBN 9780137903870)
• James Gosling, Bill Joy, Guy Steele, Gilad Bracha, The Java Language Specification, 3rd Edition, Addison-Wesley Professional, 2005. (ISBN 978-0321246783)
• Dave Thomas, Chad Fowler, and Andy Hunt, Programming Ruby: The Pragmatic Programmers' Guide, 3rd Edition, Pragmatic Programmers LLC, 2008. (ISBN 978-1-9343560-8-1)
• Bjarne Stroustrup, The C++ Programming Language, Special 3rd Edition, Addison-Wesley Professional, 2000. (ISBN 0201700735)
• David Flanagan, JavaScript: The Definitive Guide, 5th edition, O'Reilly, 2006. (ISBN 9780596101992)
• Brian W. Kernighan and Dennis M. Ritchie, The C Programming Language, 2nd edition. Prentice Hall, 1988. (ISBN 0131103628)
• Wesley Chun, Core Python, 2nd edition, Prentice Hall, 2007. (ISBN 978-0132269933)

You may also wish to buy some books (or consult online sources) that cover specific programming languages. The languages we will be covering most heavily in this course will be Java, Ruby, C, ML, and JavaScript. Moderate attention will be focused on Ada, C++, C#, Python, and Perl. A smaller amount of attention will be spent on Fortran, Lisp, Scheme, SQL, Smalltalk, Scala, Groovy, D, ActionScript, and Prolog, as well as a few others. Note that this list includes old as well as modern languages in order to cover the evolution of ideas in the field of programming languages.

Additional papers and readings will be assigned throughout the course (inlcuding my own course notes, practice problems, and sample code). If you have projects or papers to work on you'll have to find some additional readings on your own. Use judgement when researching on the web; a fair amount of information is often wrong, and much of the so-called sample code is especially atrocious. Still, please take the time for self-study and practice, practice, practice writing code.

Assignments and Grading

You'll have several homework sets containing in-depth theoretical questions and non-trivial programming problems, and quizzes and a final exam with less difficult material. Graduate students will write a short paper on a modern, experimental, or esoteric language of their choice. To help prepare you to meet industry expectations for college graduates, most assignments will take the form of open source software products. Unless otherwise specified, you are required to keep all work in your CVS repository and prepare all homework solutions with LaTeX document preparation system. Exams will cover material from lectures not previously assigned for homework: don't whine about this.

Generally, coursework may be done in groups of no more than two students; however, while only one solution set is turned in per group, both students are responsible for understanding all of its content and may be asked at any time for an oral explanation of any solution. Collaboration with other groups is fine but must be limited: you may share ideas and approaches but nothing resembling a solution (not even pseudocode). You must also acknowledge any help received.

Your final grade will be weighted as follows:

Letter grades are figured according to the usual scale: 90% or more of the total points gets you an A, 80% a B, 70% a C, and so on. These are minimal requirements; for example, if you get 82 points you are guaranteed a B- or better, though you might still get an A since 82 may be the top score.

Homework is due at the beginning of class; late assignments are docked 30% per class. Missing class just to get an assignment done on time will not be tolerated; the only good excuses for missing class are excellent surf conditions, family problems, sickness, and personal emergencies. Skipping class just puts your fellow students at an advantage: we often spend class time going over things that will be "on the exam".

Your programming style will play a huge part in determining your score on the programming assignments. I will not hesitate to assign D's or F's to working programs which are poorly structured, under-commented, have poor identifier names and abbreviations, contain inappropriate hard-coded values, or are not easily maintainable. Appearance of the grading policy in this syllabus constitutes fair warning of the consequences of poorly written code.

Topics and Tentative Schedule

We'll be covering Scott's textbook rather closely because the book is actually great. The chapters we will cover are: 1, 2.1, 3, 6-9, parts of 10, 12, and 13. However, we will differ a little from Scott's presentation by making heavy use of ML and Ruby throughout the main part of the course.

• INTRODUCTION: Why study programming languages; Examples of languages with brief case studies; History and evolution; Programming paradigms; Good, bad and successful languages. (Ch. 1 and Course Notes)
• OVERVIEW OF SELECTED LANGUAGES: Tours of Ruby, JavaScript, and ML, highlighting interesting and unique features; Comparisons with popular languages such as Java and C. (Course notes)
• LANGUAGE SPECIFICATION: Mathematical definition of language; Syntax, semantics and pragmatics; Forms of syntax specification: CFG, BNF, EBNF, other notations; A look at semantic specification; Differences between syntax errors and static semantic errors. (Ch. 2.1, Course Notes)
• NAMES AND BINDINGS: The meaning of and importance of name, binding, scope (static and dynamic) and extent (static, stack, and heap); Application to constants, variables, types, subroutines, and modules; Shallow vs. deep binding; Closures; Aliasing, overloading, and polymorphism. (Ch. 3)
• EXPRESSIONS AND STATEMENTS (CONTROL FLOW): Operator precedence, associativity, arity and fixity; Evaluation order, short-circuiting; Structured and unstructured control flow; Sequencing, selection, iteration, recursion and non-determinacy. (Ch. 6)
• TYPES: Type systems; Static vs. dynamic typing, strong vs. weak typing, and manifest vs. implicit typing; Type checking, type equivalence, type coercion, and type inference; Primitive types, numbers, text, enumerations, and pointers; Structs (records), unions, arrays, sets, streams; Abstract and generic types; Construction, assignment, equality-testing, and destruction. (Ch. 7)
• SUBROUTINES: The runtime stack and activation records; Calling conventions; Passing arguments and returning values; Higher-order functions and functional programming; Closures revisited; Pattern matching for function arguments; Exceptions; Coroutines; Generic subroutines. (Ch. 8 and 10)
• OBJECT-ORIENTATION: Tenets of object-orientation: encapsulation, inheritance and dynamic method binding; Issues with multiple inheritance; Implementation issues; Class-based vs. prototype-based systems; Pure vs. hybrid object systems. (Ch. 9)
• CONCURRENCY: Motivation; multiprocessing vs. multithreading; Communication and synchronization issues; Shared memory vs. message passing; Language-intrinsic concurrency vs. library managed concurrency; Implementation. (Ch. 12)