CIS-3030 (Programming Languages) Home Page

This is the home page for Peter Chapin's CIS-3030 course notes for the Spring 2019 semester. Here you will find slides, homework assignments, program samples, and links to other references of interest.

The course syllabus gives an overview of the course and its content, lists course resources, and describes the grading policy and related issues.
The homework submission area and grade book are on Moodle but all other course resources are here.
I have a general help session on the Williston campus on Thursday afternoons in BLP-210 from 2:00 to 4:00. Jeremy Ouellette runs a help session specifically for this class on the Randolph campus on Monday afternoons in CON-104 from 2:00 to 2:50.
We will be studying Scala in this course as a vehical for exploring various programming language design issues.
We will start the course using the Scala REPL via the sbt build tool. I have prepared a document that describes how to get set up.
In this class you will work on a project where you learn a new programming language of your choice. You may find a checklist of programming language features useful to guide your study. In what way does your new language support each of the features in the checklist? My Hello, World document describes a number of problems you can use to exercise your programming language (and your programming skills). The programming languages chosen by the students in the class are given in this list.
I prepared a summary of the core features of Scala that are important for this class.
As an extended example of functional programming, we will use the VuPP virtual machine simulator.
I prepared some notes about OOP related to the content of this course.
My home page contains other resources of potential interest.

Zoom

All live lectures will be accessed from the following Zoom URL: https://zoom.us/j/856025200.

The list below are approximate lecture-by-lecture topics for this course. The topics with links to Zoom lectures are for this (Spring 2019) edition of the course. The topics without links are approximate and subject to change.

2019-01-23. Introduction to the class. Described the Sandbox setup.
2019-01-25. Demonstrated basic expression evaluation and recursive method definitions using the REPL.
2019-01-30. Introduced tuple types and pattern matching for tuples. Also introduced generic methods.
2019-02-01. Introduced lists and list pattern matching.
2019-02-06. Introduced case classes and pattern matching with case classes.
2019-02-08. No class. Instructor out of town.
2019-02-13. More on case classes. Introduced Option and Either.
2019-02-15. Introduced Set and Map.
2019-02-27. Introduced functions as first class values. Introduced higher order functions.
2019-03-01. No class. Instructor at SIGCSE.
2019-03-06. Introduced IntelliJ, more on functional programming. Described Homework #4
2019-03-08. More on functional programming.
2019-03-13. Continued discussing functional programming through an introduction to foldLeft, and multiple parameter lists.
2019-03-15. Discussed closures and introduced the VuPP virtual machine simulator.
2019-03-20. More details on the VuPP virtual machine simulator and the requirements for Homework #6.
2019-03-22. Introduction to writing classes in Scala. Showed how to use subtype constraints to partially specialize a generic type (e.g., Ordered[A]).
2019-03-27. Review of the Rational number examples along with a discussion of type classes in Scala.
2019-03-29. ?
2019-04-03. Discussed variance, variance in overriding methods, and introduced function subtyping.
2019-04-05. Discussed lazy evaluation.
2019-04-17. More discussion about implementing Homework #6 (the VuPP VM). Described how Scala uses implicits to, in effect, add methods to existing classes.
2019-04-19. Discussed several issues related to generics in Scala, C++, and Ada.
2019-04-24. Discussed contracts and their interaction with OOP features (and how to use the LSP to understand that interaction) in the context of Ada.
2019-04-26. Discussed dynamic languages. Introduced nesC, an example of a "component oriented" language.
2019-05-01. Did a sample presentation on the D programming language. Finished discussing nesC.
2019-05-03. Introduced logic languages with XSB examples.
2019-05-08. Student presentations (Perl by Samuel Velasquez, Ada by Taylor Hegarty, and Cobol by Christopher Lucas).
2019-05-10. No class. Presentation day.

Slides

Homework

Homework #01 (Due: 2019-01-30) Hello, Scala!
Homework #02 (Due: 2019-02-06) Pairs, Lists and Patterns
Homework #03 (Due: 2019-02-15) Case Classes
Homework #04 (Due: 2019-03-13) Higher Order Workhorses
Homework #05 (Due: 2019-03-20) Functional Programming
Homework #06 (Due: 2019-03-29) VuPP Virtual Machine
Homework #07 (Due: 2019-04-05) Intervals

Samples

This worksheet shows some of the samples used in the introductory slide set.
This worksheet shows some basic features of Scala in a context where you can play around with them.
This worksheet demonstrates the basics of tuples.
This worksheet demonstrates case classes.
This worksheet demonstrates tail recursion.
This worksheet demonstrates some basic concepts in Scala's treatment of functions as first class values. It also demonstrates Scala's abbreviated syntax for lambdas.
Closures can be simulated in C and more cleanly so in C++. The new C++ standard can do even better with its lambda expressions.
This worksheet demonstrates for comphrehensions and their de-sugaring to applications of various higher order methods.
The Rational1.scala sample shows an immutable rational number class. The associated worksheet shows how the class can be used. The file Rational.java shows a Java class that implements approximately the same functionality. Compare the Scala and Java versions to get insight on how the Scala code works.
Tree.scala and its associated ScalaIDE worksheet show a binary search tree implementation in Scala.
The Rational2.scala sample shows a variation on the Rational number class that supports equals, hashCode, ordering, and type classes. The associated worksheet how how the class can be used.
This sample demonstrates how to add strings of roman numerals to Scala's Numeric type class. The associated worksheet shows the type class in action.
The following samples illustrate the issue of method dispatching in a constructor. The concern is that it is possible, in Scala, under certain conditions, to invoke a method on an uninitialized object.
- SuperCtor.scala. This program shows how Scala allows one to call methods on uninitialized objects under certain conditions.
- superctor.cpp. This program shows how C++ turns off dynamic dispatching in constructors so as to avoid accidentally calling methods on uninitialized objects.
- animals.ads and animals.adb show how Ada handles this situation.
Variance.scala shows some interesting issues related to variance.
VarianceWorksheet.sc is a ScalaIDE worksheet tht demonstrates some issues in variance.
VarianceOverriding.scala shows the interaction between function type variance rules and method overriding.
FunctionSubtyping.scala shows how function subtyping works in Scala.
ImplicitDemo.scala shows how implicit conversions can be used in Scala to augment an existing class with additional methods without resorting to OOP-style extension.
The following samples illustrate various aspects of generic programming.
- Generics.scala. Demonstrates some issues in generic programming in Scala.
- generics.cpp. Demonstrates some issues in generic programming in C++. Compare to Generics.scala above.
- generics.adb. Demonstrates some issues in generic programming Ada. Compare to Generics.scala and generics.cpp above.
- Rational.hpp. A C++ template for rational numbers where the underlying integer type is a template parameter.
- VeryLong.hpp. This C++ class implements arbitrary precision integer math. It can be used as a type parameter to the Rational class above.
- VeryLong.cpp. The body of the class VeryLong is here for interest. It is not important to the way VeryLong is used.
- spica-trees.ads. An Ada generic package that provides an interface to various kinds of trees.
- spica-binary_search_trees.ads. An Ada package specification for generic binary search trees that implement the generic interface defined earlier.
- spica-binary_search_trees.adb. The body of the generic binary search tree package.
The files searchers.ads and searchers.adb demonstrate the LSP as applied to contracts in Ada 2012. The file main.adb is a main program that demonstrates the package.
The D Programming Language. If you do a presentation on the language you have been studying during the semester, this is a sample presentation that you can use as a model for your own.
— Samples below are subject to change —

Articles

Computerworld interview with Martin Odersky.
Is Scala Complex?. This article by Martin Ordersky explores what it means for a programming language to be simple.
Functional Programming: Why no one uses functional languages. A short essay on why functional languages are not used more despite their advantages. [required reading]
Multiple Inheritance Considered Useful. An article by Jack W. Reeves that appeared in Dr. Dobb's Journal in 2006 on why multiple inheritance in C++ is a good thing. [required reading]