1. CSCA48 Course Summary

2. Announcements Exam period office hours: will be posted
Check your marks!
A1, E1, E2, E3, labs, midterms all posted
Will post to Piazza when E4 and A2 marks available
Report errors before the final exam
Fill out course evaluations on intranet!
By Monday, April 9th

3. Course Summary This course introduced the science of computing
Tools and techniques that affect all parts of the software lifecycle: specification, design, testing, and implementation

4. Topics classes & inheritance abstract data types (ADTs)
object oriented analysis (OOA)
exceptions
testing
recursion
memory model
trees (including BSTs and heaps)
sorting
linked lists
time analysis (big O)
pygame basics

5. Abstract Data Types (ADTs)
Standard abstractions that have proven useful in computer science
Abstract: the user doesn't want to know how it works (implementation), but how it will work (public interface)
Data: what information are you recording?
Type: a structure that encapsulates a concept that is common to an entire set (type) of instances

6. ADTs we've seen stack queue priority queue list
operations: push(item), pop(), is_empty()
queue
operations: enqueue(item), dequeue(), is_empty()
priority queue
operations: insert(item, priority), extract_max(), is_empty()
list
operations: insert, remove, get item at index

7. Data Structures Data Structure: a particular way to implement an ADT.
"regular" lists
linked lists
trees
made from linked structures (with Node class)
made from lists
Binary Search Trees
Heaps
On the exam:
Trace through insert / remove algorithms for BSTs and heaps
Write functions dealing with trees and linked lists
more on data structures in CSCB63

8. Testing
Test-driven development: a common, successful industry-developed approach to writing code
Write header, write docstring, write some tests, then implement
Add tests as you think of them
Mantras: 0, 1, many; even, odd; empty, full; general case
Tests serve to document code, especially at early stages
Test documentation needs to be clear about why tests exists
On the exam:
Design a set of test cases
Be able to use assert statements
Do not need to write unittest code from scratch

9. Implementation Properties of a good program On the exam:
Abstraction: what real-world objects are you modeling?
Reuse: design your code to avoid duplication
Encapsulation: each method/function should do one thing; each class should model one concept
Exception handling: design your code to fail gracefully
On the exam:
Object Oriented Analysis!
Example: Give the class structure for a tic-tac-toe game. For each class, write the header and docstring for every method.
more on designing large programs in CSCB07

10. Recursion Thinking recursively Termination / base case
Recursion vs. iteration
Examples
Fast sorting: mergesort, quicksort, heapsort
Tree traversals
CSCC24 is compellingly riddled with recursion

11. Complexity and Time Analysis
How efficient is this program?
On the exam:
Big O notation
e.g. If a heap has n elements, extract_max takes O(log n) steps
Which operation is faster?
e.g. For a singly-linked list: Inserting near the front is faster than inserting near the end.
Do not need to write profiling code or read profiling output
More on analysis of programs in B36, C63, C73

12. What's next? Systems Theory Communications and security
Operating Systems
What can you compute?
Compilers
Proving code is correct
Programming languages
Analyzing running time and space used
Databases
Proving your algorithm takes minimal time and/or space
Communications and security
Network protocols
Time/space trade-offs
Security
New data structures
Concurrency
Human-computer Interaction
Software Engineering
Psychology
Requirements analysis
Usability studies
Design patterns, architecture
Interface design
Metrics to access / predict cost, quality, complexity
Tools for making robust software design in a team

13. Final Exam 3 hours no aids allowed
material from lectures, labs, exercises, assignments, reading
What's it like?
Recent exams are in Python
Older exams are in Java, but still have questions that work in Python
last pages are reference sheets (like on midterms)

14. Sorts of Questions Trace code (give output, draw memory model)
Write test cases
Play with linked lists, trees, stacks, queues, etc
lots of this!
Design / implement / use a class
Analyze runtime (big O, which is faster?)