• Introduction to Python.
• Tools for software development:
  • Eclipse (IDE - Integrated Development Environment) .
  • Python.
  • Pydev console.
  • SVN (Subversion, version control and turning in work) .
• Calling methods on objects (brief introduction) .
• Course introduction.

• Coding to a specification.
• Reading a simple program:
  • Function definitions.
  • The use of indentation for blocks of code.
  • The role of main.
  • Flow of control: sequential but interrupted by function calls .
• Objects: types and values (introduction) .
• Calling functions with arguments, capturing returned values.
• Using objects:
  • UML class diagrams (for a single class).
  • Constructing instances of a class (i.e., an object) .
  • Applying methods to objects.
  • Referencing and setting data attributes of objects.
• Application: Graphics.
• Debugging techniques I: Correcting syntax (aka compile-time) errors.

• Namespaces.
• Scope and lifetime of names in functions.
• Loops of the form 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.
• Debugging techniques II:
  • Identifying when a run-time has occurred.
  • Understanding a stack trace.

• Conditionals I: boolean values; if, if-else, if-elif...
• Accumulators: Counting, Graphical Patterns.
• Writing good unit tests.

• Reinforce all concepts to date.
• Pair programming.
• Application: Robots and Motion.
• Debugging techniques III:
  • Understanding simple run-time error messages
  • Using such messages to correct errors

• Practice tracing code by hand.
• Test 1 Practice.
• Debugging techniques IV:
  • Tracing by hand.
  • Using print statements.
  • Using a debugger.
  • Using the stack trace to know where to start

• Test 1.

• Implementing classes I:
  • Object-oriented Design; IS-A, HAS-A relationships in UML class diagrams.
  • How to define a class
  • Naming conventions for classes and instances of classes
  • Defining constructor (init) functions, data attributes, and methods.
  • Testing constructor (init) functions, data attributes, and methods.
  • What self means and how to use it.
• More practice tracing code by hand.

• Implementing classes II: A deeper understanding of:
  • Object-oriented Design; IS-A, HAS-A relationships in UML class diagrams.
  • Defining constructor (init) functions, data attributes, and methods.
  • Testing constructor (init) functions, data attributes, and methods.
  • What self means and how to use it.
• Debugging techniques V: Deciphering more complicated run-time error messages.

• Names are references to objects.
• Functions and methods that mutate their arguments.
• Box-and-pointer diagrams.
• Application:
  • Using the Robot Simulator.
  • Design/implement a class that has a Robot.

• Waiting for Events.
• Indefinite Loops.
• Boolean (Logical) Operators.
• Conditionals II:
  • Boolean (Logical) operators.
  • Nested conditionals.
  • Pitfalls.

• Sequences and indices.
• Patterns for iterating through sequences, I:
  • Forward/backwards, with steps.
  • Selecting items.
  • Counting/summing/etc.

• 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.

• Test 2 practice.
• [Maybe] String methods.
• [Maybe] Application: String processing.
• [Maybe] Some other powerful Python classes.
• Debugging techniques VI: Locating the source of a run-time error.

• Test 2.

• Procedural decomposition.
• Application:
  • Robots and Sensors.
  • Design/implement a solution to a robotics problem that requires procedural decomposition
  • In pairs using divide-and-conquer?

• Exceptions and try/except.
• Applications:
  • File I/O.
  • Console I/O.
  • Maybe Sockets

• 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.

• Nested Loops II: More complicated loops within loops.
• Finite state machines: Application to more complicated logic.
• Looping patterns: Summary.

• Test 3 Practice.

• Teaming:
  • Responsibilities.
  • Roles.
• Event-Driven Programming.
• Tkinter I: root/mainloop, frame, buttons, responding to button-clicks.
• Using a shared repository effectively.
• Implementing classes III:
  • Implementing classes that inherit from (aka extend) other classes.
  • Application: doing so in Tkinter.

• Project Kickoff.
• Agile/Scrum:
  • Sprints.
  • Features.
  • Sprint planning.
  • Stand-up meetings.
• Sprint 1 begins.
• 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.

• Test 3.
• Sprint 1 continues.

• Dictionaries. Attributes are implemented using dictionaries.
• Sprint 1 continues.

• Sprint 1 ends, Sprint 2 begins.

• Sprint 2 continues.

• Sprint 2 continues.

• Sprint 2 ends.
• Sprint 3 begins.

• Sprint 3 continues.

• Sprint 3 (and the project) ends.