What to do, When
Tuesdays Thursdays Fridays
Preparation
for session
1
December 1
  • Course introduction. Flipped classroom.
  • Introduction to Python.
  • Tools for software development:
    • Eclipse (IDE - Integrated Development Environment) .
    • Python.
    • Pydev console.
    • SVN (Subversion, version control and turning in work) .
  • Reading a simple program, I:
    • Comments.
    • The print function.
    • Constructing objects.
    • Calling methods.
    • Referencing and setting instance variables.
  • What is software engineering (brief introduction) .
Preparation
for session
2
December 3
  • Numbers and arithmetic.
    • Arithmetic operators (+, -, , /, *) and expressions.
    • Parentheses and precedence.
  • Objects: types and values (introduction) .
    • Types: float, int, string, function, module.
    • String arithmetic.
  • Names/variables and assignment.
  • Calling functions:
    • Modules: import and the dot trick.
    • The builtins module.
  • Functions:
    • What are they, why are they important?
    • How do they work:
    • Sending arguments
    • Side effects
    • Returning a value (and capturing it in a variable)
  • Coding to a specification.
    • What is it, why is it important?
    • Functions as black boxes.
    • Doc-strings.
  • Reading a simple program, II:
    • Function definitions:
    • In the module.
    • In builtins and other modules.
    • The use of indentation for blocks of code.
    • The role of main.
    • Flow of control: sequential but interrupted by function calls .
  • Object-Oriented Programming (OOP)
    • What is it, why use it (brief introduction) .
    • Vs Procedural Programming.
  • Classes and objects:
    • Class vs instance of the class.
    • Methods (aka function attributes).
    • Instance variables (aka data attributes).
  • Using objects:
    • Constructing instances of a class.
    • Applying methods to objects.
    • Referencing and setting instance variables of objects.
  • Application: Graphics.
  • Debugging techniques I: Correcting syntax (aka compile-time) errors.
Preparation
for session
3
December 4
  • Scope and lifetime of names in functions. Namespaces.
  • Loops:
    • When is a loop needed?
    • What goes before the loop? Inside it? After it?
    • Implementing loops using for k in range(n): ....
  • Accumulators: Summing.
  • Implementing functions with parameters.
  • Using objects (reinforcing previous sessions) .
  • Testing:
    • Test-Driven Development (TDD).
    • Unit testing.
    • Writing simple tests.
  • Coding: First Solve It By Hand.
  • Code Reviews:
    • What are they, why do them.
    • How to do them (brief introduction) .
    • Code inspection checklists.
  • Debugging techniques II:
    • Identifying when a run-time has occurred.
    • Understanding a stack trace.
    • Tracing code by hand.
Preparation
for session
4
December 8
  • Conditionals I: boolean values; if, if-else, if-elif...
  • Accumulators: Counting, Graphical Patterns.
  • Using the loop variable vs using accumulators.
  • Writing good unit tests.
  • More practice tracing code by hand.
Preparation
for session
5
December 10
  • Reinforce all concepts to date.
  • Pair programming.
  • Conventions and advice for choosing names.
  • Practice tracing code by hand.
  • Application: Robots and Motion.
  • Debugging techniques III:
    • Understanding simple run-time error messages
    • Using such messages to correct errors
Preparation
for session
6
December 11
  • More practice tracing code by hand.
  • Test 1 Practice.
  • Debugging techniques IV:
    • Using print statements.
    • Using a debugger.
    • Using the stack trace to know where to start.
Preparation
for session
7
December 15
  • Tuesday in-class is an OPTIONAL review session.
  • Test 1: Wednesday 12/16 evening, 7 to 9 p.m.
    (so NOT Tuesday, NOT daytime.)
    Rooms (all in Crapo, NOT in Olin):
    Section 01(G-310), 02(G-313), 03(G-315), 04(G-317).

    Before this test, do Session 7 Preparation.

Preparation
for session
8
December 17
  • Names are references to objects.
  • Mutation:
    • What is it?
    • Why is it dangerous if abused?
    • Why is it useful?
    • Functions and methods that mutate their arguments.
  • is versus ==.
  • Box-and-pointer diagrams.
  • Floating point arithmetic (basic introduction) .
  • Other stuff that we should now get back to.
Preparation
for session
9
December 18
  • Reading a simple class definition:
    • class expression.
    • init
    • self
  • Implementing classes I:
    • Writing a class expression.
    • Defining constructor (init) methods.
    • Defining instance variables (aka data attributes):
    • For parameters of init.
    • For "remembering" attributes of the object.
    • Defining methods (aka function attributes) that:
    • Reference and/or set instance variables.
    • Require the introduction of an instance variable.
    • Call other methods.
    • Have parameters that are instances of the class (and not self)
    • Return an instance of the class.
    • What self means and how to use it.
  • Testing class implementations.
  • More practice tracing code by hand.
No class
December 22
  
No class
December 24
  
No class
December 25
  
No class
December 29
  
No class
December 31
  
No class
January 1
  
Preparation
for session
10
January 5
  • Implementing classes II:
    • A deeper understanding of self.
  • More practice implementing classes.
Preparation
for session
11
January 7
  • Waiting for Events.
  • Indefinite Loops.
  • Loops revisited:
    • When is a loop needed?
    • Use a definite or indefinite loop?
    • What goes before the loop? Inside it? After it?
  • Conditionals II:
    • Boolean (Logical) operators.
    • Nested conditionals.
    • Pitfalls.
  • Application: Robots and Sensors. Augmenting the Rosebotics library.
  • Debugging techniques V: Deciphering more complicated run-time error messages.
Preparation
for session
12
January 8
  • Sequences and indices.
  • Patterns for iterating through sequences, I:
    • Forward/backwards, with steps.
    • Selecting items.
    • Counting/summing/etc.
  • Debugging techniques VI: Locating the source of a run-time error.
Preparation
for session
13
January 12
  • Patterns for iterating through sequences, II:
    • Find (using linear search).
    • Max/min.
    • Two indices at each iteration.
    • Two sequences in parallel.
  • Building sequences using the + operator.
  • Building lists using mutation.
  • Building strings using split/join.
  • Debugging techniques VII: Debugging loops.
Preparation
for session
14
January 14
  • Reinforce all concepts to date.
  • String methods.
  • Application: String processing.
  • Application: Talking and Singing Robots.
Preparation
for session
15
January 15
  • Test 2 practice.
  • [Maybe] Some other powerful Python classes.
Preparation
for session
16
January 19
  • Test 2. Tuesday in-class is an OPTIONAL review session.
  • Test 2: Wednesday 1/20 evening, 7 to 9 p.m.
    (so NOT Tuesday, NOT daytime.)

    Rooms: Section 01(Olin 257), 02(Olin 259), 03(Olin 267), 04(Olin 269). These are NOT the same rooms as Test 1.

    Before this test, read Session 16 Preparation.

Preparation
for session
17
January 21
  • Inheritance:
    • The concept.
    • Reading classes in an inheritance hierarchy:
    • How self climbs the inheritance hierarchy.
    • Methods that override, in whole or in part.
    • Multiple inheritance (very brief introduction) .
  • Object-Oriented Design (OOD):
    • The IS-A and HAS-A concepts.
    • Reading IS-A and HAS-A relationships in UML class diagrams.
    • Doing OOD (very brief introduction)
  • Implementing classes III:
    • Augmenting an inherited class.
    • Writing simple classes that inherit (beyond just from object).
  • The object class.
  • Exceptions and try/except (in simple forms) .
  • Applications:
    • File I/O.
    • Console I/O.
    • Maybe Sockets.
Preparation
for session
18
January 22
  • Loops revisited:
    • When is a loop needed?
    • What goes before the loop? Inside it? After it?
  • Nested Loops I: Simple loops within loops.
  • Application:
    • Robots and Singing.
    • Blocking messages versus nonblocking messages.
    • Augmenting the Rosebotics library.
Preparation
for session
19
January 26
  • Nested Loops II: More complicated loops within loops.
  • Finite state machines: Application to more complicated logic.
  • Looping patterns: Summary.
Preparation
for session
20
January 28
  • Procedural decomposition.
  • Teaming:
    • Responsibilities.
    • Roles.
  • Application: ??
    • In teams of 4, with pair programming?
  • Using a shared repository effectively:
    • Avoiding conflicts.
    • Correcting conflicts.
Preparation
for session
21
January 29
  • Event-Driven Programming.
  • Tkinter I: root/mainloop, frame, buttons, responding to button-clicks.
  • Tkinter II: sharing functions across modules.
  • Tkinter III: sharing data across modules.
  • Project Kickoff.
  • Sprint 1 begins.
Preparation
for session
22
February 2
  • Agile/Scrum:
    • Sprints.
    • Features.
    • Sprint planning.
    • Stand-up meetings.
  • Materials made available for applications, including:
    • More Tkinter GUI objects.
    • Multiple threads and processes.
    • Multiple implementations of the same interface.
    • PID line-following.
    • Following waypoints.
    • Image processing.
    • Robot conversation (via LEDs + camera with vision processing, or via IR emitters and receivers) , protocols.
  • Sprint 1 continues.
Preparation
for session
23
February 4
  • Implementing classes IV:
    • Implementing classes that inherit from (aka extend) other classes.
    • Application: doing so in Tkinter.
  • Dictionaries:
    • Attributes are implemented using dictionaries.
  • Sprint 1 ends, Sprint 2 begins.
Preparation
for session
24
February 5
  • Test 3 practice.
  • Sprint 2 continues.
Preparation
for session
25
February 9
  • Test 2. Tuesday in-class is an OPTIONAL review session.
  • Test 2: Wednesday 2/10 evening, 7 to 9 p.m.
    (so NOT Tuesday, NOT daytime.)

    Rooms: Section 01(Olin 257), 02(Olin 259), 03(Olin 267), 04(Olin 269). These are the same rooms as Test 2.

    Before this test, read Session 25 Preparation.

  • Sprint 2 continues.
Preparation
for session
26
February 11
  • Sprint 2 continues.
Preparation
for session
27
February 12
  • Sprint 2 continues.
Preparation
for session
28
February 16
  • Sprint 2 ends.
  • Sprint 3 begins.
Preparation
for session
29
February 18
  • Sprint 3 continues.
Preparation
for session
30
February 19
  • Sprint 3 (and the project) ends.
Final exam during Finals Week. Date TBA.