What to do, When
Tuesdays |
Thursdays |
Fridays |
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)
.
|
|
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.
|
|
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.
|
|
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.
|
|
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
|
|
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.
|
|
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.
|
|
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.
|
|
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.
|
|
|
|
|
|
|
|
for session
10
January 5
|
- Implementing classes II:
- A deeper understanding of self.
- More practice implementing classes.
|
|
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.
|
|
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.
|
|
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.
|
|
for session
14
January 14
|
- Reinforce all concepts to date.
- String methods.
- Application: String processing.
- Application: Talking and Singing Robots.
|
|
for session
15
January 15
|
- Test 2 practice.
- [Maybe] Some other powerful Python classes.
|
|
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.
|
|
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.
|
|
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.
|
|
for session
19
January 26
|
- Nested Loops II: More complicated loops within loops.
- Finite state machines: Application to more complicated logic.
- Looping patterns: Summary.
|
|
for session
20
January 28
|
- Procedural decomposition.
- Teaming:
- Application: ??
- In teams of 4, with pair programming?
- Using a shared repository effectively:
- Avoiding conflicts.
- Correcting conflicts.
|
|
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.
|
|
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.
|
|
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.
|
|
for session
24
February 5
|
- Test 3 practice.
- Sprint 2 continues.
|
|
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.
|
|
for session
26
February 11
|
|
|
for session
27
February 12
|
|
|
for session
28
February 16
|
- Sprint 2 ends.
- Sprint 3 begins.
|
|
for session
29
February 18
|
|
|
for session
30
February 19
|
- Sprint 3 (and the project) ends.
|
|