What to do, When
Tuesday |
Thursday |
Friday |
for session
1
March 8
|
-
Course introduction. Flipped classroom.
-
What is software engineering?
(brief introduction)
-
What is a programming language?
(brief introduction)
-
Introduction to Python
(programming language for this course).
-
Tools for software development:
-
Eclipse
(IDE - Integrated Development Environment).
-
Pydev console.
-
SVN / Subversion, how to turn in work, version control
(brief introduction).
-
Reading a simple program, I:
-
Comments.
-
The
print
function.
-
Constructing objects.
-
Calling methods.
-
Referencing and setting instance variables.
-
Application: Turtle graphics.
|
|
for session
2
March 10
|
-
Objects:
-
Types
(
float, int, string, function, module
)
and values.
-
Names
(aka variables).
Assignment.
-
Names are
references
to objects.
-
Expressions:
-
Arithmetic operators: +, -,
, /,
*.
-
Relational operators: <, <=, >, >=, !=, ==.
-
Parentheses and precedence.
-
String arithmetic.
-
Functions:
-
What are they, why are they important?
-
What is a function
call
?
-
How do function calls work?
-
Sending arguments
-
Side effects
-
Returning a value
(and capturing it in a variable)
-
Modules:
-
import
and the dot trick.
-
The
builtins
module.
-
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:
-
RoseGraphics.
-
Using an Application Programming Interface (API)
(brief introduction).
-
Debugging techniques I: Correcting syntax
(aka compile-time)
errors.
|
|
for session
3
March 11
|
-
Namespaces, Scope:
-
Local scope
(in functions).
-
Global scope
(in a module).
-
Builtins scope.
-
Lifetime of a name in a function:
-
When it comes into existence.
-
When it goes out of existence.
-
The stack
(for function calls).
-
Loops:
-
When is a loop needed?
-
What goes before the loop? Inside it? After it?
-
Implementing loops using
for k in range
(n)
: ...
.
-
Flow of control
(revisited to allow FOR loops).
-
Accumulators: Summing.
-
Implementing functions:
-
Parameters
(and actual arguments).
-
Side effects.
-
Returning values.
-
Doc-strings and coding to a specification
(revisited).
-
The
power
of 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 exception has occurred.
-
Understanding a stack trace.
-
Tracing code by hand.
|
|
for session
4
March 15
|
-
Conditionals:
-
boolean values
(
True
and
False
).
-
if, if-else, if-elif...
statements.
-
Flow of control
(revisited to allow conditionals).
-
Accumulators: Summing
(revisited)
, Counting, Graphical Patterns.
-
Using the loop variable vs using accumulators.
-
More practice tracing code by hand.
-
Code Reviews:
-
What are they, why do them.
-
How to do them
(brief introduction).
-
Code inspection checklists.
|
|
for session
5
March 17
|
-
Reinforce all concepts to date.
-
Pair programming.
-
Writing good unit tests.
-
Conventions and advice for choosing names.
-
More practice tracing code by hand.
-
Application:
-
Robots and Motion.
-
Using an Application Programming Interface (API)
(brief revisit).
-
Using the RoseBot API.
-
Debugging techniques III:
-
Understanding simple run-time error messages.
-
Using such messages to correct errors.
|
|
for session
6
March 18
|
-
More practice tracing code by hand.
-
More practice using pop-up help and the dot trick in Eclipse/PyDev.
-
Test 1 Practice.
-
Debugging techniques IV:
-
Using print statements.
-
Using a debugger.
-
Using the stack trace to know where to start.
|
|
for session
7
March 22
|
-
Test 1.
-
The regular in-class session on TUESDAY is an OPTIONAL review session.
-
The test itself is
Wednesday evening from 7:30 p.m. to 9:30 p.m.
(with an additional 30-minute grace period)
in Olin 267 (for Professor Mutchler's
section) and Olin 269 (for Professor
Fisher's section).
-
So NOT Tuesday, NOT daytime.
-
You MUST have completed this test's PRACTICE project
(including its paper-and-pencil exercise)
BEFORE you take this test.
-
It is your ADMISSION TICKET to the test.
-
Talk to your instructor if that poses a problem for you.
-
Exception: For Professor Fisher's section,
it is not a formal ADMISSION TICKET but is strongly
recommended.
|
|
for session
8
March 24
|
-
Names are
references
to objects
(revisited).
-
Mutation:
-
What is it?
-
Why is it dangerous if abused?
-
Why is it useful?
-
Functions and methods that mutate their arguments.
-
is
and
not is
versus
==
and
!=
.
-
Box-and-pointer diagrams.
-
More practice tracing code by hand.
-
Floating point arithmetic, roundoff
(basic introduction).
-
Integer arithmetic: % and //.
-
Multiple arguments in
range
expressions.
|
|
for session
9
March 25
|
-
Reading a simple class definition:
-
class
expression.
-
The
init
method.
-
The
self
parameter.
-
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.
-
Call other methods.
-
Require the introduction of an instance variable.
-
Have parameters
(other than
self
)
that are instances of the class.
-
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
March 29
|
-
Implementing classes II:
-
A deeper understanding of
self
.
-
More practice implementing classes.
|
|
for session
11
March 31
|
-
Sequences and indices.
-
Lists, tuples, strings.
-
The index vs the item at that index.
-
Patterns for iterating through sequences, I:
-
Forward/backwards, with steps.
Using three-argument
range
expressions.
-
Selecting items.
-
Counting/summing/etc.
-
Debugging techniques VI: Locating the source of a run-time error.
|
|
for session
12
April 1
|
-
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.
-
Using mutation:
-
via
append
(for lists)
-
plus
list
and
tuple
(for tuples)
-
plus
list
and
join
(for strings)
-
Using + versus
append
: comparing efficiencies.
-
Debugging techniques VII: Debugging loops.
|
|
No class - Spring Break
April 5
|
|
No class - Spring Break
April 7
|
|
No class - Spring Break
April 8
|
|
for session
13
April 12
|
-
Waiting for Events.
-
Indefinite Loops.
-
Flow of control
(revisited to allow WHILE loops).
-
while True: ... if <condition>: break
vs
while <condition>...
-
Loops
(revisited)
:
-
When is a loop needed?
-
What goes before the loop? Inside it? After it?
-
Use a definite or indefinite loop?
-
Implementing loops using
for k in range
(n)
: ...
.
-
Implementing loops using
while True: ... if <condition>: break ...
-
Conditionals
(revisited)
:
-
Boolean
(Logical)
operators.
-
Bitwise operators.
-
When to use
elif
and/or
`else
. When not to them.
-
Nested conditionals.
-
Pitfalls.
-
Application: Robots and Sensors.
-
Waiting for events.
-
Augmenting the RoseBot library.
-
Debugging techniques V: Deciphering more complicated run-time error messages.
|
|
for session
14
April 14
|
-
Reinforce all concepts to date.
-
Sequence, list and string methods.
-
The
in
and
not in
relational operators.
-
Application: String processing.
-
Application: Talking and Singing Robots.
-
Augmenting the RoseBot library.
-
Blocking messages versus nonblocking messages.
|
|
for session
15
April 15
|
-
Test 2 practice.
-
[Maybe] Some other powerful Python classes.
|
|
for session
16
April 19
|
-
Test 2.
-
The regular in-class session on TUESDAY is an OPTIONAL review session.
-
The test itself is
Wednesday evening from 7:30 p.m. to 9:30 p.m.
(with an additional 30-minute grace period)
in Olin 267 (for Professor Mutchler's
section) and Olin 269 (for Professor
Fisher's section).
-
So NOT Tuesday, NOT daytime.
-
You MUST have completed this test's PRACTICE project
(including its paper-and-pencil exercise)
BEFORE you take this test.
-
It is your ADMISSION TICKET to the test.
-
Talk to your instructor if that poses a problem for you.
|
|
for session
17
April 21
|
-
Input/Output
(IO)
:
-
Console IO.
-
File IO
(for text files)
-
Socket IO.
-
Procedural decomposition.
|
|
for session
18
April 22
|
-
Loops revisited:
-
When is a loop needed?
-
What goes before the loop? Inside it? After it?
-
Use a definite or indefinite loop?
-
When is a
nested
loop needed?
-
Nested Loops:
-
Application: printing on the console.
-
Application: sequences of sequences.
-
Application: 2-d graphics.
-
Replacing the inner loop by a function call.
Helper functions.
|
|
for session
19
April 26
|
-
More practice at nested loops.
-
Finite state machines: Application to more complicated logic.
-
Looping patterns: Summary.
|
|
for session
20
April 28
|
-
Inheritance
(brief introduction)
:
-
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, very brief introduction).
-
The
object
class.
-
Object-Oriented Design (OOD)
(brief introduction)
:
-
The
IS-A
and
HAS-A
concepts.
-
Reading
IS-A
and
HAS-A
relationships in UML class diagrams.
-
Implementing classes, III: Using
IS-A
and
HAS-A
relationships.
-
Application: Robots.
-
Augmenting simple classes in the RoseBot library that inherit
(beyond just from
object
).
-
Implementing simple classes that
HAS_A
RoseBot.
|
|
for session
21
April 29
|
-
Project Teams.
-
Meet each other, establish goals and expectations.
-
How a team project works:
-
Team member responsibilities.
-
Individual accountability.
-
Divide and conquer. Integration of the parts.
-
Event-Driven Programming.
-
Tkinter I:
-
Root/mainloop.
-
Frame.
-
Button. Using
lambda
functions to respond to button-clicks.
-
Entry. Using
lambda
functions and
get
to acquire values from Entries.
-
Using a shared repository effectively:
-
Avoiding conflicts.
-
Correcting conflicts.
-
When to commit
(and when not to).
-
The importance of commit messages.
-
Application: Throw-away project.
-
Using m0 and
my_frame
functions to structure the application.
-
Sharing a RoseBot object across modules.
-
Sharing functions across modules.
|
|
for session
22
May 3
|
-
Project Kickoff.
-
Project theme.
-
Project features.
-
How the project is graded.
-
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 begins.
|
|
for session
23
May 5
|
-
Using an Application Programming Interface (API)
(revisited).
-
Implementing classes IV:
-
Implementing classes that inherit from
(aka extend)
other classes.
-
Application: extending Tkinter classes.
-
Sprint 1 continues.
|
|
for session
24
May 6
|
-
Dictionaries
(brief introduction)
:
-
Attributes are implemented using dictionaries.
-
Test 3 Practice.
-
Sprint 1 ends, Sprint 2 begins.
|
|
for session
25
May 10
|
-
Test 3.
-
The regular in-class session on TUESDAY is an OPTIONAL review session.
-
The test itself is
Wednesday evening from 7:30 p.m. to 9:30 p.m.
(with an additional 30-minute grace period)
in Olin 267 (for Professor Mutchler's
section) and Olin 269 (for Professor
Fisher's section).
-
So NOT Tuesday, NOT daytime.
-
You MUST have completed this test's PRACTICE project
(including its paper-and-pencil exercise)
BEFORE you take this test.
-
It is your ADMISSION TICKET to the test.
-
Talk to your instructor if that poses a problem for you.
-
Sprint 2 continues.
|
|
|
for session
27
May 13
|
-
Sprint 2 ends, Sprint 3 begins.
|
|
|
|
for session
30
May 20
|
-
Sprint 3
(and the project)
ends.
|
|
PROJECT DEMOs during exam week, time TBD. |