# NOTE: The schedule is auto-generated from this file.
# In hand-editing this file:
#   -- Use Git-Flavored Markdown (GFM) as desired.
# All that matters at this point is that each session's topics begin
#   Topics (with a colon after the s)
# and end with two blank (empty) lines.
#
# This file is written with GitHub-Flavored Markdown.
#  -- See https://help.github.com/articles/markdown-basics/ for basics, and
#  -- https://help.github.com/articles/github-flavored-markdown/
      for GitHub's modifications.
# Additional markup:
#   -- Parenthetical expressions are rendered in smaller text.
#   -- But ((...)) is rendered in normal text.


Note: (IMPORTANT) For most of the first 15 or so sessions,
students are not expected to be solid on all of the learning objectives
listed for that session from that session alone.
  - Rather, students are expected after the session to have
     * SOME understanding
     * of MOST of the concepts.
  - Forthcoming sessions will reinforce all the concepts of the session.
  - Students will typically become solid on ALL the topics of a session by the end
    of the following 2 or 3 sessions for sessions early in the course, and sooner
    for sessions later in the course.

Note:  Throughout, to "use" a concept means to use that concept as needed
in a program, for solving a given problem.

Session 1: Introduction to Python
Topics:
  - Introductions to:
      * The course as a _flipped classroom_.
      * What is _software engineering_?
      * What is _programming_?  A _programming language_?
  - Introduction to _Python_ (our programming language):
      * Arithmetic expressions, e.g., ```3.1 * (4 + 1.83)```.
      * Strings, e.g. ```"May the Force be with you"```.
      * _Names_, aka _variables_.
      * Calling _functions_ defined in _modules_.
  - Tools for software development:
      * Eclipse, our _Integrated Development Environment (IDE)_.
      * The _Pydev console_.
      * Subversion (SVN) / Subclipse, our way to acquire and turn in work via a _version control_ system.
  - Reading a simple program, I:
      * Comments.
      * The _print_ function.
      * Introduction to using objects:
        - Constructing objects.
        - Calling methods.
        - Referencing and setting instance variables.
  - Application: Turtle graphics.

Session 2: Calling Functions / Using Objects
Topics:
  - Executing (aka _running_) a program:
      * Hardware:
          - Memory.  Addresses.
          - The Central Processing Unit (CPU).
      * Software:
          - Names, aka variables.  References.
          - Evaluating expressions, executing statements.
  - Objects:
    * Types (_float, int, string, function, module_) and values.
    * Names, aka variables.
      - Assignment.
      - Names are _references_ to objects.
      - Dynamic typing versus static typing.
      - The importance of choosing good names.
  - Expressions:
    * Arithmetic operators: +, -, *, /, **.
    * Relational operators: <, <=, >, >=, !=, ==.
    * Parentheses and precedence.
    * String arithmetic.
  - Functions:
    * What are they, why are they important?
    * What is a function _call_?
      - Sending arguments to parameters.  Relationship to assignment.
      - Flow of control.
  - Statements.
  - Modules:
    * _import_ and the dot trick.
    * The _builtins_ module.
  - 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).
  - Coding to a specification:
    * What is it, why is it important?
    * Functions as black boxes.
    * Doc-strings.
  - Object-Oriented Programming (OOP):
    * What is it, why use it (brief introduction).
    * vs Procedural Programming.
  - Classes and objects:
    * Class vs instance of the class.
      - UML class diagrams (for a single class).
      - Object diagrams.
    * 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.

Session 3: Loops
Topics:
  - 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.
    * How a _stack_ implements 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:
    * Sending arguments to parameters.  Relationship to assignment.
      - Side effects.
      - Returning a value (and capturing it in a variable).


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

    * How do function calls work?
      - Session 4: Conditionals
Topics:
  - 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.

Session 5: Pair Programming
Topics:
  - 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.

Session 6: Tracing Code by Hand / Practice for Test 1
Topics:
  - 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.

Session 7: Test 1
Topics:
  - Test 1.

Session 8: Names are _References_ to Objects / Mutating Objects
Topics:
  - 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.
# Do a careful look for anything else that we skipped over
# that needs to be here!

Session 9: Implementing Classes, I
Topics:
  - 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.

Session 10: Implementing Classes, II
Topics:
  - Implementing classes II:
    * A deeper understanding of _self_.
  - More practice implementing classes.

Session 11: Inheritance  / Implementing Classes that Extend Other Classes

Session 12: Sequences, I / What is a Sequence? / Simple Iteration Through a Sequence

Session 13: Tracing Code by Hand (again) / Practice for Test 2

Session 14: Test 2

Session 15: Sequences, II / The Find and Max-Min Patterns / Building a Sequence via a Loop

Session 16: Sequences, III / The Two-Indices-Per-Iteration and Parallel-Sequences Patterns

Session 17: Loops within Loops

Session 18: Sequences within Sequences

Session 19: Input-Output

Session 20: Tracing Code by Hand / Practice for Test 3

Session 21: Test 3

Session 22: Event-Driven Programming / Graphical User Interface (GUI) Programming / Throw-away Project

Session 23: Project Kickoff / Sprint 1 Begins

Session 24: Sprint 1 Continues

Session 25: Sprint 1 Ends / Sprint 2 Begins

Session 26: Sprint 2 Continues

Session 27: Sprint 2 Continues

Session 28: Sprint 2 Ends / Sprint 3 Begins

Session 29: Sprint 3 Continues

Session 30: Sprint 3 Ends

Final Exam Period: Project Demonstrations


Session 11:
Topics:
  - 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.


Session 12:
Topics:
  - 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.


Session 13:
Topics:
  - 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.


Session 14:
Topics:
  - 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.

Session 15:
Topics:
  - Test 2 practice. 
  - [Maybe] Some other powerful Python classes.
 

Session 16:
Topics:
  - Test 2.


Session 17:
Topics:
  - Input/Output (IO):
    * Console IO.
    * File IO (for text files)
    * Socket IO.
  - Procedural decomposition.

Session 18:
Topics:
  - 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.

Session 19:
Topics:
  - More practice at nested loops.
  - Finite state machines: Application to more complicated logic. 
  - Looping patterns: Summary.


Session 20:
Topics:
  - 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.


Session 21:
Topics:
  - 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.


Session 22:
Topics:
  - 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.
# FIX THE ABOVE LIST TO MATCH REALITY.
  - Sprint 1 begins.


Session 23:
Topics:
  - 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.


Session 24:
Topics:
  - Dictionaries (brief introduction):
    * Attributes are implemented using dictionaries.
  - Test 3 Practice.
  - Sprint 1 ends, Sprint 2 begins.

Session 25:
Topics:
  - Test 3.
  - Sprint 2 continues.


Session 26:
Topics:
  - Sprint 2 continues.


Session 27:
Topics:
  - Sprint 2 ends, Sprint 3 begins.

Session 28:
Topics:
  - Sprint 3 continues.


Session 29:
Topics:
  - Sprint 3 continues.


Session 30:
Topics:
  - Sprint 3 (and the project) ends.