Download
csca48 course summary n.
Skip this Video
Loading SlideShow in 5 Seconds..
CSCA48 Course Summary PowerPoint Presentation
Download Presentation
CSCA48 Course Summary

CSCA48 Course Summary

203 Views Download Presentation
Download Presentation

CSCA48 Course Summary

- - - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript

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

  13. Final Exam • 3 hours • no aids allowed • material from lectures, labs, exercises, assignments, reading • What's it like? • http://eres.library.utoronto.ca/ • 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?)