CSCI 3675, Fall 2002

Last modified: 12/4/02

Announcements


Syllabus

This course introduces the student to characteristics of various kinds of programming languages. See the syllabus.


Office hours

MW 11:00-12:30, TTh 11:00--12:00 or by appointment.


Checking your grade

If you have obtained a password then you can check your grades as I have them recorded. This will be the only way that you can learn your grade at the end of the term before it has been posted on the student desktop.

You can obtain a password from me. To obtain one by email, send me email giving your name, the course, and the password that you want. Choose a string of 4 or 5 letters/digits. Be careful about upper and lower case letters. Your password will be exactly what you send to me.


Quizzes and exams

  1. Practice questions for quiz 1
  2. Answers to practice questions for quiz 1
  3. Practice questions for quiz 2
  4. Solutions to practice questions for quiz 2
  5. Practice questions for quiz 3
  6. Solutions to practice questions for quiz 3
  7. Practice questions for quiz 4
  8. Solutions to practice questions for quiz 4


Assignments

Programming assignments

  1. Programming assignment 1
  2. Programming assignment 2
  3. Programming assignment 3
  4. Programming assignment 4
  5. Programming assignment 5
  6. Programming assignment 6
  7. Programming assignment 7
  8. Programming assignment 8

Written assignments

  1. Homework assignment 1
  2. Homework assignment 2
  3. Homework assignment 3


320 Lab information


Unix accounts and Unix tutorial

All students will receive accounts on the Unix systems in Austin 320. If you have a prior account, it has not been modified. If you were on my class role and you did not have a prior account, then your account is your first initial followed by your middle initial followed by up to six letters of your last name.

A brief tutorial on unix is available.


Brief summary of course so far

  1. [8/21/02] We began talking about general goals of programming languages. See chapter 1 of the text.

  2. [8/26/02] We talked about programming language implementations, including compilers and interpreters. Each has its advantages. Then we turned to syntactic issues, including concrete syntax (what issues influence the choice of a particular syntax?) and the beginnings of abstract syntax (how do you describe the syntax of a programming language?). Language implementations are discussed in chater 2, and chapter 3 covers syntax.

  3. [8/28/02] We talked about describing syntax. Lexical rules tell how a program is broken up into lexemes and the lexemes converted to tokens. The syntactic rules tell the order in which the lexemes are combined to make programs and parts of programs, and also imparts structure to the program. A grammar is a collection of syntactic rules. We looked at examples of grammars, and showed how to create parse trees for portions of programs according to example grammars.

  4. [9/3/02] We continued to look at syntax. We did more examples, and saw extended BNF and syntax diagrams. We defined an ambiguous grammar, and saw examples of ambiguous and unambiguous grammars.

  5. [9/4/02] We discussed programming language paradigms and classification.

  6. [9/9/02] We discussed how the semantics of a data item might be described. A denotational semantics models each data item in terms of some value that we already understand. An formal semantics only tells the operations that are available on the data item, and some facts about how the operations relate to one another.

    We discussed different kinds of data, and how values can be represented in the language implementation. There is a distinction between how a data value is described to a programmer and how it is implemented in the computer. For example, a sequence of values might be described to the programmer simply as a sequence, but implemented as a tree. The choice of implementation depends on which operations will be supported, and which need to be efficient. Note that the choice of operations influences how data values are conveyed to the programmer. For example, if operations that modify a list are made available to the programmer, then the programmer must be made aware of when modifying one list will also change another list (due to memory sharing), and that can complicate the model of data that is presented to the programmer.

  7. [9/11/02] We discussed trees and representation of trees. We discussed memory management and garbage collection.

  8. [9/16/02] We discussed homework, then turned to naming mechanisms, and the scope of a binding.

  9. [9/18/02] We are skipping ahead to chapter 13 to cover material needed to do the next assignments. We will return to earlier chapters later. We began looking at functional programming. You write a definition of a function by writing equations that can be used to compute the values of expressions involving use of the function. Computation is performed by substitution.

  10. [9/24/02] We continued looking at functional programming, by doing more examples. We also discussed programming assignment 2.

  11. [9/26/02] We did some more examples of functional programming, and then turned to higher order functional programming, involving functions that operate on other functions. These can be made into very powerful factories for producing functions, reducing the amount of hand crafting of functions that needs to be done.

  12. [9/30/02] We did more examples of higher order functions. This is in chapter 14.

  13. [10/2/02] We discussed questions on higher order questions, and went over using lazy evaluation.

  14. [10/7/02] We discussed exercises and went over more on evaluation strategies and lazy evaluation. This material is in chapter 15. We have not discussed chapter 16.

  15. [10/9/02] We discussed the semantics of expressions, including both a functional setting and an imperative setting. Denotational semantics for functional programming is discussed in chapter 18.1. The semantics of expressions in an imperative setting is discussed in chapter 11.2 and 11.3. We began to discuss Scheme. Scheme is covered in chapter 17.

  16. [10/16/02] We discussed more material on Scheme.

  17. [10/21/02] We began to look at types, including the meaning of a type, and uses of types in programming languages. We also discussed programmer-defined types. This material is in chapter 19 and 21.

  18. [10/23/02] We discussed types, including type checking, constructors and destructors. This material is in chapter 21.

  19. [10/28/02] We introduced polymorphism, and looked at forms of polymorphism, and the meaning of polymorphism. This material is in chapter 20.

  20. [10/30/02] We discussed type inference and solving type equations. This is in chapter 20.

  21. [11/4/02] We began discussing object-based and object-oriented programming. This is in chapter 22 and 23.

  22. [11/6/02] We discussed classes and inheritance.

  23. [11/11/02] Quiz 3. We continued to discuss inheritance and classes.

  24. [11/13/02] We covered virtual methods and run-time dispatching.

  25. [11/18/02] We covered aspects of Java, including inner classes.

  26. [11/20/02] We began to look at language implementation issues, including managing the run-time stack,

  27. [11/25/02] Quiz 4. We covered the basics of exception handling, as well as implementation of exception handling using control frames.

  28. [11/27/02] Break.

  29. [12/2/02] We discussed bactracking and began to look at the concepts of logic programming.

  30. [12/4/02] We will see how to write and execute logic programs in the style of Prolog.