CSCM41 Programming in Java 2016/17

Messages

The solution of the second coursework is available.

General information

The url of this page is http://cs.swan.ac.uk/~csoliver/ProgrammingJava201617_Jj1AoYIgC1/index.html .
First week (3/10/2016 - 7/10/2016):
1. General preparations:
  1. Get access to the Linx lab: Faraday Tower 500.
  2. The main task is to get used to the environment (knowing your password, etc.).
  3. Specific Tasks:
    - Get your access information (username and password) from your e-mail.
    - Check that your login works.
    - Access the course home page, and store the link.
    - Browse the course home page, and get a bit familiar with it.
    - Buy the book.
2. One lecture Tuesday 14:00 - 15:00 in Glyndwr M.
From 10/10/2016 to 16/12/2016:
1. Tuesday, 14:00 - 15:00, lecture in Glyndwr A.
2. Thursday, 11:00 - 13:00, "lecture-lab" session in the Linux lab (Faraday tower 500).
3. Thursday 17:00 - 18:00, "exercise-lab" session (Linux lab).
The role of the lecture-lab sessions:
1. In these sessions a mixture of teaching and programming practice takes place.
2. We might not make use of all sessions.
The role of the exercise-lab sessions:
1. Active participation in all exercise lab session is awarded 10% of the overall module marks.
2. For each exercise lab sessions tasks are distributed.
3. During the exercise lab session, work on these tasks is expected.
4. "Active participation" means that during the whole lab session reasonable work related to the module is performed, typically related to the current tasks, but possibly also related to previous tasks, or to other questions or problems (of course, related to the module).
5. There are no tests (or exams) in the labs. Every student present for the full time and doing reasonable work gets acknowledged his/her active participation.
Assessment:
1. 10% is allocated to active participation in the exercise lab sessions.
2. Two courseworks are handed out, each worth 20%.
3. The remaining 50% is the January exam.
4. The exam is based on what we did in the lectures, the lab sessions, and the coursework.
Liam McNabb liammcnabb@gmail.com is the postgrad demonstrator.

The textbook

This module is based on the book
- "Introduction to Programming in Java"
- from Robert Sedgewick and Kevin Wayne,
- Addison-Wesley 2007 (ISBN-13 978-0-321-49805-2).
It is strongly recommended that you buy this book (for example at the Campus book shop).
The book's home page is here .
Additional to the book, at this web page a lot of useful information is available.
Here is Chapter 1 as pdf-file.
In this module we cover the essentials from the first three chapter.

Slides and material for the lectures

The additional programs you find here .

Week 1:
1. Tuesday (4/10/2016) 14-15: Preparations
2. And Section 1.1 First programs .

Week 2:

Tuesday (11/10/2016): Section 1.2 Basic types .

Thursday (13/10/2016):

We write 3 programs together.

Empty program:

class Empty {
  public static void main(String[] args) {}
}

Hello-World:

class HelloWorld {
  public static void main(String[] args) {
    System.out.println("Hello, World!");
  }
}

Hello-World with name provided as argument:

class UseArgument {
  public static void main(String[] args) {
    System.out.print("Hello, ");
    System.out.print(args[0]);
    System.out.println("!");
  }
 }

Hello-World with three further names:

class UseThree {
  public static void main(String[] args) {
    System.out.print("Hello, ");
    System.out.print(args[0]);
    System.out.print(", ");
    System.out.print(args[1]);
    System.out.print(", ");
    System.out.print(args[2]);
    System.out.println("!");
  }
 }

Here some remarks.

Week 3:
1. Tuesday (18/10/2016): Completing Section 1.2 Basic types .
2. Thursday (20/10/2016):
  1. We look at the program "IntOps" in detail ( here is the code).
  2. There are many problems with this program, and we try to write a "perfect" version of it.
  3. We learn:
    1. final for declaring constants: Don't use
```
    int a = Integer.parseInt(args[0]);
          
```
      but
```
    final int a = Integer.parseInt(args[0]);
          
```
      for a variable whose value shouldn't be changed anymore (i.e., we have a constant).
    2. The length-variable to be used with args for finding out how many command-line arguments were entered:
```
args.length
          
```
      is an integer, namely the number of command-line arguments.
    3. if for conditional execution: Via
```
if (args.length <= 1)
  System.err.println("ERROR[IntOpsI]: Two arguments are needed (two numbers).");
else
  ...
          
```
      we output an error-message in case we do not have two command-line arguments.
    4. Here is the improved version.
  4. The following material is for more advanced students, while if you are new to programming, then leave it for later.
  5. There are further serious problems with input handling: overflow and non-integer input. They can be handled using the following constructions.
    1. Integer.MIN_VALUE and Integer.MAX_VALUE for finding out the range of int's.
    2. try ... catch for error handling via catching exceptions.
  6. Finally we have problems with the structure of the code: too many nested if-then-else make the code messy, and it would be good if we had also conditional variable initialisation:
    1. The System.exit function allows early return with an exit-code.
    2. Conditional expressions allow to have several cases in the initialisation of variables.
  7. Here is the fully improved version.
Week 4:
1. Tuesday (25/10/2016): Section 1.3 Program flow (if-statement and while-loop).
2. Thursday (27/10/2016):
  1. Completed Section 1.3 Program flow (for-loop and Gambler-program).
  2. Loops are very important, so please make sure you understand this section.
  3. And understand the Gambler-program in detail!
3. Here some remarks and corrections.
Week 5:
1. Tuesday (1/11/2016): Section 1.4 Arrays (inclusive printing a random card).
2. Thursday (3/11/2016):
  1. Completing Section 1.4 Arrays (Deck for card shuffling, CouponCollector and SelfAvoidingWalk).
Week 6:
1. Tuesday (8/11/2016):
  1. Section 1.5 Input and output .
  2. See here for the input-output library we will use from now on.
  3. You can either copy the .java-files from this library to the directory with your program-files, or you can precompile the library (by "javac *"), and then just copy the .class-files.
  4. Additional material you find here.
2. Thursday (10/11/2016):
  1. Please enter all programs (still) by hand (no copy-and-paste).
  2. This session completes the part on the basics of programming (variables, expressions, basic types, loops, conditions, arrays).
  3. In the remainder of the module we will accelerate the speed.
  4. First ShowArgs.java is a little program helping you to understand the array of strings args, and how it gets its value; understand the following:
```
> java ShowArgs jj k ll "  b n " \" ""
[Ljava.lang.String;@6deee615
6
0 : "jj"
1 : "k"
2 : "ll"
3 : "  b n "
4 : """
5 : ""
         
```
  5. Post/pre-increment are demonstrated by this little program: Increment.java.
  6. RandomSeq.java is a simple example programs which outputs N (pseudo-)random numbers to standard output.
  7. Average.java shows how to read an arbitrary stream of numbers from standard input and computing their arithmetic mean.
  8. This program is improved over the book version by
    - using more expressive code,
    - checking for empty inputs,
    - handling of input errors,
    - and also allowing "arbitrarily" long input sequences (for all practical purposes).
  9. PlotFilter.java reads (all from standard input)
    1. first four floating-point numbers for min x/y-values and max x/y-values,
    2. and then an arbitrary sequence of points, specified by their x,y coordinates (as floating-point numbers),
    drawing each point when read.
  10. SinFunction.java plots the function sin(4x)+sin(20x) for 0 <= x <= pi.
    1. Have a look at the error handling, which uses error-code constants specified at class-level.
    2. Note also that the constants "4" and "20" are not hard-coded.
    3. The command-line argument N is the number of points except the first point, used to plot the function by connecting them.
    4. If N is not large enough, then the output can be very misleading.
Week 7:
1. Tuesday (15/11/2016):
  1. Section 2.1 Functions .
2. Thursday (17/11/2016):
  - Practising functions (see Section 2.1 Functions ).
  - Six programs have to be completed, filling the positions marked with "XXX":
    1. Write a function max(a,b), computing the maximum of two integers:
      - Template
      - Solution
    2. Write a function max(a,b,c), computing the maximum of three integers:
      - Template
      - Use the function handling 2 arguments!
      - Solution
    3. Write a function max(a,b,c,d), computing the maximum of four integers:
      - Template
      - Use the functions handling 2 and 3 arguments!
      - Solution
    4. Write a function max(a), computing the maximum of an array of integers:
      - Template
      - What happens for zero numbers?
      - Solution
    5. Write a function create(n), creating an integer array of length n, filled with 0, 1, ..., n-1:
      - Template
      - What happens for n <= 0?
      - Solution
    6. Write a function print_message(name), outputting "Hello, name!":
      - Template
      - Solution
Week 8:
1. Tuesday (22/11/2016):
  1. Section 2.2 Libraries and Clients .
2. Thursday (24/11/2016):
  1. Section 3.1 Data types .
  2. The following are additional exercises, with solutions provided.
  3. First an exercise for writing functions; write class "SimpleBernoulli" containing the following functions:
    1. Function "bernoulli", taking a floating-point number p from 0 to 1 as argument, and returning a boolean which is true with (pseudo-)probability p.
    2. Function "bernoulli_r", taking as arguments p as above and N, an integer, performing N random coin flips, and returning the number of heads.
    The main program reads N and p from the command-line, and prints the result of bernoulli_r(p,N). How many coin-flips can be performed within a few seconds?
    Here is the solution .
  4. Now come exercises for using libraries Libraries and Clients . Three programs have to be completed, filling the positions marked with "XXX", and one program has to be written from scratch.
    1. Write a program Statistics, taking a list of floating-point numbers as arguments and printing their count, their minimum and maximum, their sum, and their average, each on a new line. Use the library StdStats.
      Here is the solution . By the way, that's easy, but it has also disadvantages, namely?
    2. Using StdRandom.discrete:
      - Template
      - Complete function "count" which
        
        takes an array a of probabilities (as does StdRandom.discrete) and an integer N as arguments,
        
        performs N (pseudo-)random draws of natural numbers 0, ..., a.length-1 according to the probabilities in a,
        
        counts for each of these natural number how often they occur,
        
        and returns an array with these counts.
      - Complete function "output".
      - Run the program with some N, so that executions takes a few seconds.
      - Solution
    3. Write a program RandomPoints which draws N random points according to a Gaussian distribution:
      - Template
      - Solution
    4. Write a program Bernoulli which experimentally computes the relative frequency of 0 <= i <= N heads for N fair coin flips, and compares it with the approximation by the Gaussian distribution:
      - Template
      - Solution
Week 9:
1. Thursday (1/12/2016), first part of first hour:
  1. Completing using other classes ("constructors" and "methods") Data types .
  2. Two programs have to be completed, filling the positions marked with "XXX":
    1. Write a program AlbersSquares which shows two colours using two squares:
      - Template
      - Solution
    2. Write a program Grayscale to convert a colour-picture to a gray scale:
      - Template
      - Solution
2. Thursday (1/12/2015), second part of first hour: Discussing the solution of the first coursework.
Week 10:
1. Tuesday (6/12/2016):
  1. We consider first the question of "public" versus "private": Section 3.3 Designing data types .
2. Thursday (8/12/2016):
  1. First hour: Section 3.2 Creating data types .
  2. Plus a quick intro into "identify versus equality": EqualityIssues (only learning the principal role of method "equals", and how to write an equals-check for arrays).
Week 11:
1. Tuesday (13/12/2016)
  1. Revision and exam-preparation lecture .
2. Thursday (15/12/2016):
  1. Understanding null, and Java-Objects in general:
    1. An "object" in Java is a special thing. Therefore I refer to it as "Java-object".
    2. Objects of primitive data type (int's, boolean's, double's, char's, and some more) are NOT Java-objects.
    3. The speciality of Java-objects is that, unlike int's for example, you never have them "in your hands" --- only pointers.
    4. A variable for a Java-object is a pointer.
    5. That is, it is a memory address!
    6. There is a special exceptional ("singular") memory address, namely "null", which stands for something which is NOT THERE.
    7. Study the demo-program NullString carefully!
  2. We have another look at EqualityIssues , now considering the fine print (the "obscure cases").
  3. Understanding "pass-by-value" and "pass-by-reference":
    1. What is the output of PassByValue ?
    2. And which of the variables (arguments of function update and others) can be made final? The solution is provided here .
    3. Aliasing:
      1. What is the output of PotentialProblem ?
      2. What is the output of PotentialProblem2 ?
      3. What is the output of PotentialProblem3 ?
      Understand that aliasing can not occur in the first two examples, whatever we do, since the data types used for variable x are immutable. And understand why using a "proper class", i.e., an array here, provided the additional level of indirection in the third example so that aliasing finally occurs.

Exercise lab sessions

Remark: If some answer is already given, then understand why this is the correct answer.

Week 2 (13/10/2016):
1. Recall the program "UseArgument.java" from the book:
  1. If you have already written it, rewrite it from scratch, not using notes!
  2. Otherwise you find it above (material for Lectures Week 2): enter it and understand it.
  3. Now write the version "UseThree".
  4. It is called with, e.g.,
```
> java UseThree X Y Z
        
```
    and it outputs
```
Hello, X, Y, Z!
        
```
  5. It's really important that you get the syntax into your fingers.
2. Do the Exercises from Section 1.1 (see here at the bottom, Exercises 1 - 5).
3. If you wish to prepare for the lecture (otherwise, do this exercise later!), enter the program
```
public class LeftAssociative {
  public static void main(String[] args) {
    final int a = Integer.parseInt(args[0]);
    final int b = Integer.parseInt(args[1]);
    System.out.println(a + " + " + b + " = " + a + b); // not what is meant
    System.out.println(a + " + " + b + " = " + (a + b));
    System.out.println(a + b + " + " + "13" + " = " + (a + b + 13)); // understand this
  }
}
      
```
4. Play around with it, and understand what it is doing.
5. The key is to understand that we have variables of two types, int and String, and that automatic conversions are performed from int to String if needed.
Week 3 (20/10/2016):
1. Consider the exercises from Section 1.2 (see here Exercises 1 - 23).
  - Exercises 1.2.1 - 1.2.14 are about understanding expressions.
  - Write little programs which compute the expressions, possibly for all inputs (especially in the case of boolean expressions).
  - If you wish to write a new program, consider 1.2.14 - 1.2.23.
2. If you wish to prepare for the lecture, enter the three programs from the lecture/book (Flip, PowersOfTwo, Sqrt), run them with all sorts of different arguments, understand the outcome.
3. Especially try to crash the programs (missing or strange inputs, very large or very small numbers, ...).
Week 4 (27/10/2016):
1. Write a program which reads two integers and prints them out sorted in ascending order.
2. Write another program which reads three integers and prints them out sorted in ascending order.
3. Write better versions of "TenHellos.java" (printing "Hello World!" ten times), using first a while-loop and then a for-loop. Which is better?
4. Consider exercises 1.3.1 - 1.3.7 from the book (see here); perhaps first considering exercises 1, 3, 4 (perhaps writing a complete program), 6 (again perhaps writing programs to testing your answer) and 7.
See here for solutions. Additional exercises:
1. Write a program which reads an integer N and computes the sum 1 + 2 + ... + N.
2. Write a program which reads an integer N and computes the product 1 * 2 * ... * N; choose a suitable data type so that some interesting computations can be performed!
3. Enter the program "Gambler" from the lecture, and play around with it a bit.
4. Improve the output of "Gambler":
  - Print out the inputs, with additional explanations.
  - Print out the frequency wins/T (where T is the number of trials).
  - Print out the probability stake/goal of winning.
  - Print out the expected number of steps (stake)*(goal-stake).
  - Finally determine the average and the maximum number of steps it took to finish a trial (that is, the number of steps until cash either is 0 or goal), and print it out.
5. Consider exercises 1.3.8 - 1.3.31 from the book (see here).
Week 5 (3/11/2016):
1. Write a program "Deck32" (recall "Deck"), which uses only a deck of 32 cards, where the ranks do not include 2 up to 6.
2. Now combine "Deck" and "Deck32" into one program, where via a command-line argument it is decided whether 32 or 52 cards are to be used.
3. Consider exercises 1.4.1 - 1.4.9 from the book (see here).
4. Consider exercise 1.4.35 from the book ("Birthday.java", see here).
Week 6 (10/11/2016):
1. Consider exercises 1.5.1 - 1.5.3 from the book (see here):
  1. Write a program that reads in integers (as many as the user enters) from standard input and prints out the maximum and minimum values. Before entering the program, make a sketch on paper.
  2. Modify this program by rejecting non-positive entries, asking the user to re-enter the input (until he gets it correct). Before entering the program, extend the previous sketch. Hint: a while-loop is appropriate for testing the input values.
  3. Read N from the command-line and N floating-point number from standard input, and compute their mean value. Create an error message if not enough numbers were entered. Compute also the standard deviation as the square root of the sum of the squares of the differences from these numbers and the average, the whole then divided by N-1. Hint: For this computation you could store the numbers in an array.
  Always test your programs thoroughly!
2. Consider exercise 1.5.7 from the book: Read in N from the command-line plus N-1 integers from 1 to N from standard input, assuming that these numbers are different. Now determine the missing number (from the interval 1 .. N).
3. Additional exercises:
  1. Consider exercise 1.5.5 from the book: Write a program LongestRun.java that reads in a sequence of integers and prints out both the integer that appears in a longest consecutive run and the length of the run. For example, if the input is 1 2 2 1 5 1 1 7 7 7 7 1 1, then your program should print
```
        Longest run: 4 consecutive 7s.
        
```
  2. Improve PlotFilter.java by not asking for the minimum x/y values, but computing them from the input (so the first four special doubles from standard input are not needed anymore). Test with USA.txt, where you removed the first four numbers.
Week 7 (17/11/2016):
1. Consider exercises 2.1.1 - 2.1.4 from the book (see here).
2. As additional exercises you can consider 2.1.13, 2.1.14 and 2.1.17.
Week 8 (25/11/2016):
1. If you didn't finish the exercises from last week, then please finish them now (we are still on functions).
2. Consider exercises 2.1.5, 2.1.12, 2.1.18, 2.1.19 and 2.1.20 from the book (see here).
3. For exercise 2.1.18, if for example the input is the array (1,3,7), then the output should be (0,3/7,1). And if the input is (-10,-4,-1), then the output should be (0,6/9,1).
4. Additional exercises on multidimensional arrays:
  1. Hard-code a 3 x 3 array of integers with the values
```
1 2 3
4 5 6
7 8 9
        
```
    and print it out.
  2. Write a function print_array(A) in a class PrintArray which prints out an arbitrary two-dimensional array of integers, row-wise. Handle the general case, where every row can have a different length. And if null-pointers occur for a row , then print "[null]", while if the whole array is null, then print "[[null]]" (no exceptions should be thrown).
  3. Add a main function to class PrintArray which tests function print_array(A).
  4. Read natural numbers M and N from the command line, specifying an M x N array of integers. Then read from standard input (using StdIn) row-wise these M*N many integers, and store them in an array. Finally print them out, using PrintArray.print_array.
  See here for solutions.
Week 9 (1/12/2016):
1. See the two exercises above (writing programs AlbersSquares and Grayscale).
2. Further exercises using the data types "Color" and "Picture" from the lecture (see above):
  1. Exercise 3.1.2 from the book: Write a program that takes from the command-line three integers from 0 to 255 (representing red, green and blue), and then creates and shows a 256-by-256 picture of that colour.
  2. Exercise 3.1.3 from the book: Modify program "AlbersSquares" to take nine command-line arguments, representing now three colours, and then draw the 3*2=6 squares showing all the Albers squares with the large square in each colour and the small square in each different colour.
  3. Exercise 3.1.6 from the book: Write a program that takes the name of a picture file as a command-line input, and creates three images, one that contains only the red components, one for green, and one for blue.
  4. Exercise 3.1.4 from the book:
    - Write a program that takes the name of a grayscale picture-file as a command-line argument, and plots a histogram of the frequency of occurrences of each of the 256 grayscale intensities.
    - Use the library "StdStats" from Section 2.2 (provided here ).
3. Another (simple) array-exercises:
  1. Read N from the command-line.
  2. Create an NxN array A of integers, where the first row contains 0,1,..., the second row contains 1,2,..., and so on.
  3. Then add all the numbers on the principal diagonal (that is, A[0,0] + A[1,1] + ...), and print out the result.
  4. You can easily check whether your program works: the result should be N*(N-1).
  5. Use one function for creating the array.
  6. And use another function for computing the diagonal sum.
  The solution is here .
4. Finally we practise using static data members ("static instance variables"). Write a class StringExample:
  - Containing (static) constants size_a of value 4 and array a containing the four strings "AB", "XYZ", "EFG", "1234".
  - We also have size_b of value 3, and array b containing the three strings "M1", "T3", "y6".
  - Furthermore we have a static function check_a which takes one string argument x, and returns integers from 0 to 3 if the string x occurs in array a with that index, while otherwise -1 is returned.
  - And in the same vein we have check_b.
  - Both functions must use a loop for checking the membership in the respective array.
  - The main programs reads pairs of strings from standard input (as long as standard input has not been closed), and prints out the results of check_a, check_b.
  - For example "EFG T3" results in "2 1", and "X y6" results in "-1 2".
  Here is the solution .
Week 10 (8/12/2016):
1. Creating and using a trivial class:
  - Write a class Trivial, which stores two integers (via the constructor), and as member functions ("methods") allows to compute their sum and product, and translation to strings.
  - The objects of this class must be immutable.
  - Furthermore allow equality-comparison, where two Trivial-objects are considered equal if (and only if) the members are equal independent of their order.
  - And finally write a method multiply, which takes an integer as argument, and multiplies the object with this number. Note that you can't modify the object itself.
  - Write then a program Client, which reads four integers from the command-line, creates two objects of type Trivial accordingly, and outputs their sums and products and the objects themselves, and whether the two objects are equal, and finally outputs the multiplications of the second object with the sum of the first object.
  Here is the Trivial-solution , and here is the Client .
2. For example via
```
int[] a = null;
System.out.println(a);
      
```
  we can see an array-object whose value is null. Can you create an array-object with value null without explicitly assigning null? Study the solution .
3. On "length":
  1. What is the technical reason that one uses a.length for an array, but s.length() for a string?
  2. Could there be an underlying design-reason?
  3. See here for some demonstration.
4. Study "Charge.java" and "Potential.java", understand how it works, and play a bit around (using for example "charges.txt" as input).
5. Study Turtle.java and the application Spiral.java ; play a bit around with it, and write your own clients of class Turtle, creating some simple turtle-graphics.
Week 11 (15/12/2016):
1. Concluding exercises.
Additional exercises:
- More on arrays (and static functions):
  1. Counting random events:
    1. Write a program (class) "RandomNumbers" which takes two command-line arguments M and N.
    2. The program then creates N many random integers in the interval [1, M], counts how often each of these integers occurs, and then prints out the relative frequency for each of these M numbers (that is, the quotient "occurrences / N").
    3. Your program should work for large N, and thus should not store the N random numbers computed.
    4. For the creation of the random integer write a function random(M), which takes M as parameter, and returns a random integer from 1 to M.
    5. Hint: you need to use an integer-array of size M for performing the counting.
    Here is the solution .
- More on modules (or "libraries"):
  1. Implement the library class StdStats with (just) the static functions "min", "max" and "mean".
  2. Write a program "Stats" which is called with floating point numbers as command-line parameters, and which computes their minimum, maximum and average, using your library StdStats.
  3. For example, "Stats 4 5.2" would yield min=4, max=5.2, mean=4.6.
- Parsing strings (using methods from the String class)
  1. Read a string from the command-line and determine how many space-separated parts it has.
    - Call the class "CountParts", printing out how many parts there are.
    - In order to input a string containing spaces, you need to use single quotation marks, e.g.
```
> java CountParts 'hhg   j bbnbh bvc c'
5
          
```
    - This task is very easy using the split-method of the String-class; see Section 3.1 of the book (also available here ).
    - Examples for the split-functions are there .
    - Play around with various inputs (only spaces, leading spaces, trailing spaces, ...), to better understand the behaviour.
    - Here is a solution which also shows the parts with their indices.
  2. Modify the solution of the previous part, where now the string is split at the symbol "@".
    - Again, play around with it (what happens when spaces are used?).
    - Here is a solution which again shows the parts with their indices.
  3. Parse a string, where you extract all digits from it, adding them up, returning their sum and the original string without these digits:
    - For example
```
> java Crossfoot 'dg08 ha ns82g40h1 '
23
"dg ha nsgh "
          
```
    - To detect whether a character is a digit, use that characters are treated as integers, and thus can be compared by "<" etc., and can be added/subtracted.
    - Here is a solution .
- Recursion (we didn't do that section from Chapter 2):
  1. Enter the program "Htree" from the book.
  2. Write a modified program "Htree2", which asks for confirmation before continuing drawing parts of the tree.
  3. Also print out appropriate messages, so that you can follow in detail the recursion.
  4. Run the program for inputs up to 4, and make sure you understand what's going on!
  Here is a solution .

Coursework

First coursework

Available on Blackboard.
Deadline for submission is Tuesday 22/11/2016, 11:00.
See Debugging notes for some help on how to handle syntax- and runtime-errors.
You will obtain a personal e-mail with comments on your program and your mark (explained).
A solution is provided.

Second coursework

Available on Blackboard.
Deadline for submission is Wednesday 14/12/2016, 11:00.
You will obtain a personal e-mail with comments on your program and your mark (explained).
There will be a solution provided.

Reading

Oliver Kullmann

Last modified: Mon Jan 9 22:21:05 GMT 2017