COP 4020 — Programming Languages 1 November 1, 2007
Homework 4: Declarative Concurrency
Due: problems 1, 3–5, Monday, October 29, 2007 at 11pm; problems 7–21, Monday, November 5, 2007
at 11pm
In this homework you will learn about the declarative concurrent model and basic techniques of declara-
tive concurrent programming. The programming techniques include stream programming and lazy functional
programming [Concepts] [UseModels]. A few problems also make comparisons with the declarative model
and with concurrency features in Java [EvaluateModels] [MapToLanguages].
Don’t use side effects (assignment and cells) in your Oz solutions (however, you can use them in the Java
code you write).
You should use helping functions whenever you find that useful. Unless we specifically say how you are
to solve a problem, feel free to use any functions from the Oz library (base environment), especially functions
like Map and FoldR.
For all programing tasks, you must run your code using the Mozart/Oz system. For these you must
also provide evidence that your program is correct (for example, test cases). Oz code with tests for various
problems is available in a zip file, which you can download from the course resources web page. For testing,
you may want to use tests based on our code in the course library file TestingNoStop.oz.
Turn in (on WebCT) your code and, if necessary, output of your testing for all questions that require code.
Please upload text files with your code that have the suffix .oz (or .java as appropriate), and text files with
suffix .txt that contain the output of your testing. Please use the name of the function as the name of the
file. (In any case, don’t put any spaces in your file names!)
If we provide tests and your code passes all of them, you can just indicate with a comment in the code
that your code passes all the tests. Otherwise it is necessary for you to provide us test code and/or test output.
If the code does not pass some tests, indicate in your code with a comment what tests did not pass, and try to
say why, as this write enhances communication and makes commenting on the code easier and more specific
to your problem than just leaving the buggy code without comments.
If you’re not sure how to use our testing code, ask us for help.
Your code should compile with Oz, if it doesn’t you probably should keep working on it. If you don’t
have time, at least tell us that you didn’t get it to compile.
Be sure to clearly label what problem each area of code solves with a comment.
You might loose points even if your code is passing all the tests, if you don’t follow the grammar or if
your code is confusing or needlessly inefficient. Make sure you don’t have extra case clauses or unnecessary
if tests, make sure you are using as much function definitions/calls as needed, check if you are making
unnecessary loops or passes in your code, efficient code means full mark, working code does not necessarily
mean full mark.
If you are using Windows Vista, then you cannot use Browse and must instead use Show (or to see
strings, System.showInfo). However, this is somewhat problematic because Show (and showInfo)
only show you the instantaneous view of their argument. In essence there will be a race condition between
other threads and the thread using Show. One way around this is to use the Wait operation in Oz (see
Section 10.1 of “The Oz Base Environment” [DKS06]). For example, write {Wait X} {Show X} where
the textbook has {Browse X}. In cases where you don’t have a single variable to wait on, you can introduce
delays using the Delay procedure (see Section 10.3 of “The Oz Base Environment” [DKS06]). For example,
use {Delay 5000} {Show Lst} where code in the textbook shows {Browse Lst}. You may have
to adjust the timing argument to delay (which is measured in milliseconds) to fit the problem.
Don’t hesitate to contact the staff if you are stuck at some point.
Read Chapter 4 of the textbook [RH04]. (See the syllabus for optional readings.)
Thread and Dataflow Behavior Semantics
The following problems explore the semantics of the declarative concurrent model.
1
