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

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

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

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

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

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

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

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

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

• Implementing classes II:
  • A deeper understanding of self .
• More practice implementing classes.

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

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

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

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

• Test 2 practice.
• [Maybe] Some other powerful Python classes.

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

• Input/Output (IO) :
  • Console IO.
  • File IO (for text files)
  • Socket IO.
• Procedural decomposition.

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

• More practice at nested loops.
• Finite state machines: Application to more complicated logic.
• Looping patterns: Summary.

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

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

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

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

• Dictionaries (brief introduction) :
  • Attributes are implemented using dictionaries.
• Test 3 Practice.
• Sprint 1 ends, Sprint 2 begins.

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

• Sprint 2 continues.

• Sprint 2 ends, Sprint 3 begins.

• Sprint 3 continues.

• Sprint 3 continues.

• Sprint 3 (and the project) ends.