COMP1730/6730: Course content & Schedule

Note that the schedule of lectures is tentative and may change, particularly after the mid-semester break.

Week 1 (21st of Feb - 27th of Feb)#

Lectures:

Lecture 1 (Monday; Minh B): Introduction to the course and administrative matters (slides).
Lecture 2 (Tuesday; Minh B): Functional abstraction (slides).

Code:

Mortgage Calculator (Lecture 1)
The robot module (robot.py).
The robot program to make a tower of 4 blocks using functional abstraction (from Lecture 2).

Other Material:

Student Course Representative Information (slides).

Week 2 (28th of Feb - 6th of Mar)#

Lectures:

Lecture 3 (Monday; Amanda P): Values, types and expressions (slides)
Lecture 4 (Tuesday; Amanda P): Functions (slides)

Code:

Triangulation example (Lecture 4).
Data analysis with function (Lecture 4).
Triangulation example, with functions. The sin_of_deg and deg_to_rad functions are the ones used in the call stack example.
Approximate derivative (Lecture 4).

Reading guide:

In Downey: Chapters 1, 2 and 3.
In Punch & Enbody: Chapter 1 (excluding 1.10) and the beginning of Chapter 6, up to (not including) 6.3.3.

Week 3 (7th of Mar - 13th of Mar)#

Lectures:

Lecture 5 (Monday; Amanda P): Program control flow, part 1: Branching (slides).
Lecture 6 (Tuesday; Amanda P): Program control flow, part 2: Iteration (slides)

Code:

Reading guide:

In Downey: Chapter 5, Chapter 6 up to (not including) section “More Recursion”, and Chapter 7.
In Punch & Enbody: Chapter 2, except the parts about for loops (for example, section 2.2.13).

Week 4 (14th of Mar - 20th of Mar)#

No Monday lecture (Canberra Day).
Lecture 7 (Tuesday; Amanda P): Sequence data types, part 1 (slides).

Code:

Sensor modelling example

Reading guide:

Both books begin with strings as the first sequence type. We will get to strings in Week 5. However, parts of the relevant chapters describe properties of strings that are in fact common to all sequence types, and can be read without worrying about character representation.

In Downey: Chapter 8, up to (not including) section “String Methods”.
In Punch & Enbody: Section 4.1 (sections 4.1.1 and 4.1.2 are specific to strings, and will become relevant in Week 5).

Week 5 (21st of Mar - 27th of Mar)#

Lecture 8 (Monday; Minh B): Code quality, testing and debugging (slides).
Lecture 9 (Tuesday; Minh B): Strings and more sequences (slides).

Code:

Longest Repeated Substring

Reading guide:

In Downey: Chapter 8.
In Punch & Enbody: Chapter 4. Section 4.4 and 4.7 on string formatting can be skipped.
Downey’s book has a section on debugging in every chapter. The advice in the debugging sections of chapters 1 through 8 is all relevant and useful to debugging the kinds of programs we have written so far.

Week 6 (28th of Mar - 3rd of Apr)#

Lecture 10 (Monday; Minh B): Data Science (slides).
Lecture 11 (Tuesday; Minh B): Examples of code quality and debugging in Spyder (slides). NOTE: Slides updated after the lecture.

Code:

COVID-19 csv data file. Data Source: Johns Hopkins University GitHub repo
Code to analyse data. NOTE: Code updated after lecture 11.

Break#

Week 7 (18th of Apr - 24th of Apr)#

No Monday lecture (Easter holiday)
Lecture 12 (Tuesday; Amanda P): Sequence data types, part 2 (slides)

Code:

python tutor You can use this to step through the execution of small pieces of code, like we did in the lectures.

Reading guide:

In Downey: Chapter 10 (lists), Chapters 3, 5 and 6, and section “Global variables” in Chapter 11 (functions and scope).
In Punch & Enbody: Chapter 7, except 7.7 (lists). Note: Sections 7.5.2 and 7.9 contain examples that use file reading, which we have not covered yet. You can skip these sections, or just just copy-paste the file-reading code and not worry too much about it.

Week 8 (25th of Apr - 1st of May)#

No Monday lecture (ANZAC Day).
Lecture 13 (Tuesday; Amanda P): Functions, part 2 (slides).

Code:

Reading guide:

Chapter 6, up to (not including) section 6.3.4; Section 8.1; Section 9.6 (functions and scope).

Week 9 (2nd of May - 8th of May)#

Lecture 14 (Monday; Amanda P): Files and IO (slides).
Lecture 15 (Tuesday; Amanda P): Dictionaries and Sets (slides).

Code:

Reading guide:

In Downey: Chapter 14, up to section 14.4 “Catching Exceptions” (files), though the remainder of the chapter is useful reading if you want to do more complex file operations.
In Punch & Enbody: Chapter 5, up to (not including) section 5.6 (files).
In Downey: Chapter 11 up to section “Memos” and section “Sets” in Chapter 19 (Chapter 19 is covers a variety of topics, some of which we have already touched on, and some which we will not cover in this course.)
In Punch & Enbody: Chapter 9 up to (not including) section 9.6 (dictionaries and sets).

Week 10 (9th of May - 15th of May)#

Lecture 16 (Monday; Amanda P): Complexity (slides)
Lecture 17 (Tuesday; Minh B): Errors and Exceptions (slides)

Reading guide:

In Downey: Chapter 21 (“Analysis of Algorithms”, called Appendix B in the on-line editition) introduces complexity analysis of algorithms.
In Downey: Chapter 20 (called “Appendix A” in the on-line edition), and section “Catching Exceptions” in Chapter 14.
In Punch & Enbody: Section 5.6 and Sections 14.4 to 14.6 cover exceptions (with a focus on handling, unfortunately).

Week 11 (16th of May - 22nd of May)#

Lecture 18 (Monday): Guest lecture: Eric McCreath. (slides).
Lecture 19 (Monday; Minh B): Program control flow, part 3: Dynamic programming (slides).

Code:

process_audio.py (from Eric’s lecture)
recursive_tree.py (from Eric’s lecture)
dynamic programming implementation of “n choose k”
sequence alignment, recursive and dynamic programming

Reading guide:

Section “Memos” in Chapter 11 of Downey’s book briefly covers the idea behind dynamic programming (but considers only using a dictionary to store the intermediate results).

Week 12 (23rd of May - 29th of May)#

Lecture 20 (Tuesday; Minh B): Modules and programs (slides).
Lecture 21 (Tuesday): Exam revision (slides).

Reading guide:

There is only a short section called “Writing Modules”, in Chapter 14, in Downey’s book.