CSCI.4430/6430 Programming Languages-- Fall 2019

Instructor:  Carlos Varela
Office:  Lally 308 (x 6912)
Office Hours:  Tuesdays and Fridays, 12:30-1:45pm; or by appointment
Meeting Place:  Sage 3303
Meeting Hours:  Tuesdays and Fridays 2:00-3:50pm
TAs: Steven Haussman, Angelo Luna, Varun Rao, and Milo Trujillo
TAs' Office Hours
Mentors: Jay Franklin, Erick Granillo, Yang Li, Abigail Medina, Hayes Neuman, Myron Rios, Shashank Sundar, Tianyi Zhang.
Home pagehttps://www.cs.rpi.edu/academics/courses/fall19/csci4430
Submitty Home Page: https://submitty.cs.rpi.edu/f19/csci4430
Use Submitty to submit your assignments, check your grades, and post/answer questions in the discussion forums.
To contact the instructor, TAs, and mentors about the course, please email:  proglang AT cs DOT rpi DOT edu.


Course Description

This course will enable students to understand essential aspects of programming languages --i.e., theoretical foundations, syntax, semantics, data abstraction, control abstraction, types, scope of variables, and expression evaluation mechanisms.  Students will be exposed to different programming paradigms (computation models) including functional programming, concurrent programming, and logic programming. Students will write programming assignments in Oz, Haskell, SALSA, Erlang and/or Prolog.

Pre-requisites

CSCI.2300 Introduction to Algorithms and CSCI.2600 Principles of Software.

Course Themes

Programming Language Essentials. Functional, Concurrent, and Logic Programming Paradigms.

Learning Outcomes

When the students have successfully completed this course, they will be able to:

Programming Assignments


Course Contents

  1. Introduction
  2. Functional Programming
  3. Concurrent Programming
  4. Logic Programming


Tentative Course Syllabus

Date Topic Handouts Chapter/Section
08/30 Introduction to programming languages:  history, essentials, syntax, semantics, paradigms. pdf ppt functions.hs functions.oz PDCS Chapter 2
09/06 Lambda calculus:  alpha-renaming, beta-reduction, applicative and normal evaluation orders, Church-Rosser theorem, combinators, booleans pdf ppt combinators.hs eta.hs combinators.oz eta.oz PDCS Chapter 2
09/10 Lambda calculus: higher order programming, eta-conversion, recursion combinator, numbers, Church numerals
pdf ppt hop.oz hop.hs seq.oz lambda-booleans.hs lambda-booleans.oz lambda-numbers.hs rec.oz lambda-numbers.oz PDCS Chapter 2
09/13 Functional programming: lists, records, pattern matching, recursion (Haskell, Oz)
Programming Assignment 1 Due 09/26
pdf ppt pa1.html comb.oz lists.oz nth.oz pascal.oz comb.hs lists.hs nth.hs pascal.hs CTM Sections 1.1-1.7,3.2, 3.4.1-3.4.2, 4.7.2
09/17 Higher order programming: closures, procedural abstraction, genericity, instantiation, embedding. pdf ppt sqrt.oz sqrt.hs iterate.hs CTM Sections 3.2 and 3.6.1
09/20 Control abstractions: map, reduce, iterate, fold, filter pdf ppt explicit-lazy.oz mapreduce.oz iscombinator.oz mapreduce.hs iscombinator.hs CTM Sections 1.9,3.6,4.7
09/24 Lazy evaluation, infinite data structures, set comprehensions pdf ppt lazy-eval.hs lazy-eval.oz CTM Chapters 1.8 and 4.5
09/27 Type checking and type inference, abstract data types, monads pdf ppt stack.oz stack.hs list-monad.hs count-monad.hs type-limitations.hs CTM Chapters 2.8.3 and 3.7, EPL Chapter 4, GIH Section 9
10/01 Review for Exam 1 pdf ppt
10/04
Exam 1
10/08 Actors:  a model of concurrent computation pdf ppt PDCS Chapter 4
10/11 Actor programming languages (SALSA, Erlang) pdf ppt cell-treeproduct.zip Cell.salsa CellTester.salsa Tree.java TreeProduct.salsa TreeProductTester.salsa cell.erl cellTester.erl treeprod.erl PDCS Chapter 9, CPE Chapter 5
10/15 Concurrency control abstractions
Programming Assignment 2 Due 10/28
pdf ppt fibonnaci.zip Fibonacci.salsa Calculator.salsa fibonacci.erl PDCS Chapter 9, CPE Chapter 5
10/18 Distributed systems abstractions
pdf ppt zip
addressbook/AddressBook.salsa addressbook/AddUser.salsa addressbook/GetEmail.salsa addressbook/README.txt
dcell/Cell.salsa dcell/CellTester.salsa dcell/GetCellValue.salsa
dsquares/Square.salsa dsquares/SumSquares.salsa
squares/Square.salsa squares/SumSquares.salsa
addressbook.erl addressbook_client.erl dcell.erl dcellClient.erl dcellTester.erl squares.erl dsquares.erl
theatersFile.txt
PDCS Chapter 9, CPE Chapter 6
10/22
Mobility (SALSA) and fault-tolerance (Erlang) abstractions; garbage collection, visualization (SALSA), hot code loading (Erlang) pdf ppt migrate/Migrate.salsa dcell/MovingCellTester.salsa addressbook/MigrateBook.salsa addressbook_exception.erl PDCS Chapter 9, CPE Chapter 7
10/25 Object-oriented programming: inheritance, polymorphism (Oz, Java) TBA CTM 6.1-6.4.4, CTM 7.1-7.2
10/29
Declarative concurrency: dataflow variables, suspendable statements (Oz)
11/01 Review for Exam 2
11/05
Exam 2
11/08
Predicate calculus, first-order logic, Horn clauses, Clocksin-Mellish procedure.
11/12
Terms, resolution, unification, search, backtracking (Prolog); Relational computation model (Oz).
11/15
Prolog imperative control flow: cut(!), call, fail, not, repeat, findall. Closed-world assumption, generate-and-test. Lists, append relation (Prolog, Oz)
Programming Assignment 3 Due 12/02
11/19
Constraint satisfaction problems: propagate-and-search; natural language parsing: definite clause grammars
11/22 Prolog I/O, equalities, types, operators; Knowledge bases: assert, retract
11/26 Accumulators, difference lists
12/03 Constraint programming: computation spaces
12/06 Review for Exam 3
12/10
Exam 3


Reading Material


Software


Grading

The course consists of three main parts, covering respectively functional, concurrent, and logic programming. Evaluation for each part includes a programming assignment and a partial exam.

For functional programming, we will use Haskell and Oz. For concurrent programming, we will use SALSA and Erlang. For logic programming, we will use Prolog and Oz. You must understand both languages to be prepared for exams. However, you can choose any of the two supported programming languages per paradigm for programming assignments, or even your own (but do not expect help from the instructor or TAs if you choose your own). Programming assignments can be done either individually or in pairs. Do not show your code to any other group and do not look at any other group's code. Do not put your code in a public directory or otherwise make it public. You are encouraged to use the Submitty Discussions page to post questions so that other students can also answer/see the answers. There will be three grace days for late submissions throughout the semester, to be used in any combination of PAs, e.g., PA1 may be one day late and PA3 may be two days late, as long as PA2 was submitted on time. Late assignments beyond the three day grace period will receive a grade of 0.

Students may use for reference during exams: physical textbooks, printed course slides, and one personal crib sheet. No electronics will be allowed. All exam answers must be your own. Exam grades may be curved.

We will use the following weighting scheme for grades: The best two programming assignments will have a total grade weight of 40% (20% each), while the third one will have a weight of 10%. We will use the same weighting scheme for partial exams: the best two exam grades will be worth 40% of the total grade while the third one will count for 10% of the total grade. Final letter grades will then be assigned as follows:

Letter Grade Range
A [90-100]
A- [86.67-90)
B+ [83.33-86.67)
B [80-83.33)
B- [76.67-80)
C+ [73.33-76.67)
C [70-73.33)
C- [66.67-70)
D+ [63.33-66.67)
D [60-63.33)
F [0-60)

Academic Integrity

The Rensselaer Handbook of Student Rights and Responsibilities defines several types of academic dishonesty, all of which are applicable to this class.  Students found in violation of academic dishonesty policies will receive a failing grade for this course. Please contact the instructor if there is any question about academic (dis)honesty.


Last modified: Wed Sep 25 13:57:17 EDT 2019