Preliminary Schedule (Based on Dr. Yacobellis' Spring,
2016, 313 Schedule – Subject to Change)
Previous version
(Spring 2016)
Week 1: 23 May
Video Recordings
- Pre-work: using
Adobe Connect, installing required software, filling in pre-course survey
- Course overview
and Course Roadmap
- Sakai and Piazza
Sessions
- Classes 1 & 2
- organizational
matters
- announcements
- brief introductions:
instructor, students
- Piazza discussion
forum (mandatory subscription – link through Sakai)
- prerequisites and
review topics: 271 313
overview
- software check –
Java 8, Android Studio, Bitbucket, …
- course software with demo
- motivation,
including embedded systems
- brief overview of
batch versus event-based programming
- requirements
- functional: y =
f(x)
- nonfunctional:
additional properties or characteristics of f, e.g.
- testability
- most
important nonfunctional requirement
- allows
testing whether functional requirements are met
- good
architecture often happens as a side-effect (APPP pp. 36-38)
- performance
- scalability
- e.g.
performance for large data sets: asymptotic order of complexity
(big-Oh) in terms of input size n
- reliability
- maintainability
- static versus
dynamic NFRs
- Test-Driven Design
(TDD)
- discussion
of projects 1 and 2
- course software
with demo
- Class 3 – prerequisite
assessment – in-class team/group exercise
Reading/Podcasts - Typically in preparation for the following week
Week
2: 30 May – no class May 30, Memorial Day
Video Recordings – none this week Data Structure Topics
- data structures
- linear vs.
nonlinear
- position-based
vs. policy-based (see also here)
- performance
- tying data
structure choices to requirements
- data abstraction
- addressing:
pointers, references
- aggregation (product
types): structs, records
- example: node in
a linked list
- variation (sum
types): tagged unions, multiple implementations of an interface
- example: mutable set
abstraction
- add element
- remove
element
- check
whether an element is present
- check if
empty
- how many
elements
- several
possible implementations
- reasonable:
binary search tree, hash table, bit vector (for small
underlying domains)
- less
reasonable: array, linked list
- see
also here
Sessions
- Class 1 (Tuesday)
– COMP 271 (Data Structures) recap; Object-Oriented basics
- announcements
- data structures review (see above topics)
- classes vs.
objects
- UML class
diagrams
- Class 2 (Thursday)
– Object-Oriented basics, part 2
- inheritance
- Java constructors and access control
- abstract classes
- Java polymorphism
- the Java Object
class and toString method
- Reference vs.
Value semantics
- equality vs.
identity
Reading/Podcasts
- OOPUJ chapters 4,
5
- Object Roles and Polymorphism;
Method Overloading
Week
3: 06 June
Video Recordings – none this week
Sessions
- Class 1
- announcements
- Quiz 1 next week, covering Software Engineering Radio episodes 1 and 2
- there's a sample set of Quiz 1 questions and answers in Sakai's Week 3 folder
- project 1 check-up,
including using Bitbucket and running Android Studio
- discussion
of project 2 if needed - focus on TODO's and questions to answer
- some thought
problems in Java
- basics
of object-oriented programming up to
genericity (Generics)
- Inheritance and
Composition, part 1 (maybe in Class 2)
- Class 2 – basics
of object-oriented programming up to
genericity (Generics)
- Inheritance
and Composition, part 2
- Interfaces
- more Java
thought problems
- Class 3 – basics
of object-oriented programming up to
genericity (Generics)
- Abstract
Classes
- even more Java thought problems
- More on
Test-Driven Development
- JUnit
Annotations, test methods, and examples
Reading/Podcasts
- OOPUJ chapter 6
- OO Software
Analysis and Design
- SE
Radio episode 2 on dependencies
- Bob Tarr pdf slide sets on Factory, Strategy, and Visitor Design Patterns (in Sakai Week 3 folder)
- Agile Principles, Patterns, and Practices in C# (APPP) chapters 1-3 and Design Patterns chapters as above
- Agile Practices; Extreme Programming Overview; Planning
- Factory, Strategy, and Visitor Design Patterns
Homework
- Project
1 due June 6 by 11:55pm
Week
4: 13 June
Video
Recordings
- Supplemental Java
topics – Java Collections, data structures, and Object-inherited methods
Session
- Class 1
- Quiz
1: short quiz on first 2 SE Radio episodes, patterns and dependencies
- announcements
- test 1 next week during the online class session; roadmap on Sakai
- basics
of object-oriented programming - through the rest of the
online document
- Generic types
- Supplemental
material: Java Collections, data structures, and Object-inherited
methods (see course slides and video)
- Optional topic -
Coad: modeling with UML and color: overview, book
chapter
- reverse
engineering JUnit tests (test 1
topic)
- Class 2
- introduction to
Design Patterns
- Resources
- tutorialspoint
website
- Bob
Tarr pdf slides on Sakai
- APPP
Design Pattern references
- Factory:
Chapter 29
- Strategy:
Chapter 22
- Visitor:
Chapter 35
- Design Patterns
overview
- Factory method,
and Strategy Pattern
- Class 3
- Visitor Pattern
- brief project 3
introduction, team formation
Reading/Podcasts
- Bob Tarr pdf slide sets on Decorator, Composite, and Visitor Design Patterns
- APPP chapters 4-6 and Design Patterns chapters as above
- Testing; Refactoring; A Programming Episode
- Decorator, Composite, and Visitor Design Patterns
Homework
- Project
2 due date postponed until June 20
Week
5: 20 June
Session
- Class
1 – test 1
- Class 2
- announcements
- more Design
Patterns
- Decorator and
Composite
- Visitor
revisited
- Resources
- tutorialspoint
website
- Bob
Tarr pdf slides on Sakai
- APPP
Design Pattern references
- Decorator:
part of Chapter 35
- Composite:
Chapter 31
- Visitor:
Chapter 35
- Class 3
- project 3
details, part 1
- Shapes interface
and Visitor<Result> generic interface
- concrete
Shapes: Circle, Rectangle, ...
- concrete
Visitors: Draw, Size, and Bounding Box
- project 3 TODOs
(Android Studio: Tools => View => TODO)
- project 3
Decorators: Outline, Stroke, Location, ...
- Android Canvas
and Paint classes and online documentation
- Unit tests using
Gradle and Mockito; the Fixtures class
Reading/Podcasts
Homework - Project 2 due Monday night by 11:55pm
Week
6: 27 June
Video Recordings
Session
- Class 1
- announcements
- team members
posted on Sakai and Piazza
- team
repositories: cs313sp16teamNp3
- continued project
3 detailed discussion
- more classes,
including Fixtures
- Mokito "white
box" unit tests (esp. for the Bounding Box Visitor)
- how
to run the unit tests
- expressions and vexpressions Java
examples - using a Visitor<Result> interface to visit arithmetic
expressions
- coding guidelines
- Class 2
- UML diagrams and
30-minute in-class group activity
- create a UML
class diagram for project 3 (hand-drawn is best)
- Submit (a
picture of) the diagram plus a brief write up about how you did it on
Sakai - one per group
- Class 3
Reading/Podcasts
Week
7: 04 July – no class July 4, Independence Day
Video Recordings
- possibly SOLID
follow-up sections
Session
- Class 1
- announcements
- any remaining
questions about project 3
- reminders: Quiz 2 on July 11 (2 SE Radio podcasts), test
2 on July 18
- principles of
object-oriented programming: SOLID
- S - Single
Responsibility Principle
- O - Open Closed
Principle
- L - Liskov
Substitution Principle
- I - Interface
Segregation Principle
- D - Dependency
Inversion Principle
- References
- SOLID and
other basic object-oriented design principles ("SOLID +
2"): presentation
- Class 2
- brief review of
Android framework
- in-class
time to work on Project 3
Reading/Podcasts
Homework
- Project 3 due Friday night
Week
8: 11 July
Session
- Class 1
- Quiz
2: short quiz on second 2 SE Radio episodes, unit
testing (167) and refactoring (46)
- announcements
- more design
patterns
- Adapter
- Facade
- Observer
- State -
including a review
- Command
- Class 2
- Class 3
- modeling and
introduction to Project 4 – larger group exercise
Reading/Podcasts
- APPP chapters 21, 23, 32, 36
- Command and Active Object: Versatility
- Façade and Mediator
- Observer: Evolving into a Pattern
- State
Week
9: 18 July
Session
- Class 1
- Class 2
- Android
- stopwatch example program
- State diagrams and basic UML State Machines
- Project 4 overview
- Class 3
- stopwatch internals - objectives, architecture, and design
- mapping the stopwatch state machine to Java code
Reading/Podcasts
Week
10: 25 July
Session
- Class 1
- announcements
- reminder: you should have
listened to SE Radio episode 65 last week on embedded systems!
- test 2 discussion
- as needed
- overview of clickcounter - event-based interaction
- UML Extended State Machines (with guards)
- brief Project 4 requirements review
- in-class group exercise: create a Project 4 dynamic UML extended state machine model
- capture these to submit as part of each larger group’s Project 4 submission
- Class 2
- continuation of in-class group UML extended state machine exercise
- detailed discussion of testing in clickcounter and stopwatch examples - will be done in offline video
- in-class group
exercise: create a comprehensive set of unit tests for Project 4 - possibly in Class 3 - cancelled
- also capture
these to submit as part of each larger group’s Project 4 submission
- Class 3
- time to work on
Project 4 in your larger groups
Reading/Podcasts
- APPP chapters 7-9, 18, 19
- What is Agile Design; The Single-Responsibility Principle; The Open/Closed Principle
- Sequence Diagrams
- Class Diagrams
- relevant
architectural/design patterns
- State pattern (APPP
chapter 36)
- event
listener/callback
- UI architectural
patterns
Week
11: 01 August
- Class 1
- brief review of
extended state diagrams
- event-driven
programming - Test 3 roadmap items
- Model-View-Adapter
in ClickCounter and Stopwatch
- Class 2
- concurrency and interleaving
- physical (hardware) vs. logical (software) concurrency
- CPU-bound versus I/O-bound activities
- run-to-completion versus coordination
- (conflicting) design forces:
- possibly time to work on Project 4 in your teams
- Class 3 – time to
work on Project 4 in your larger groups
Reading/Podcasts
- APPP chapter 10-12
- The Liskov Substitution Principle (LSP); The Dependency-Inversion Principle (DIP);
The Interface Segregation Principle (ISP)
- SE
Radio episode 12 on concurrency – will be covered on final exam (test 3)
Week
12: 08 August
- Classes 1 & 2
- announcements
- test 3 on Thursday - practice test
is in Week 13 on Sakai
- agile design:
process, not event: presentation
- design
smells:
usually subjective, sometimes objective
- rigidity:
difficult to change
- fragility:
easy to break
- immobility:
difficult to reuse
- viscosity
(of software, of environment): it is difficult to do the right thing
- accidental
complexity: e.g., overdesign
- needless
repetition (DRY)
- opacity
- design
perfume
- refactoring
- prime number checker - example of cloud-based execution (optional topic)
- cloud computing - X as a service (XAAS - optional topic)
- immutability (optional topic)
- possibly time to work on Project 4 in your teams
- Class
3 – test 3 (final exam)
- includes
SE Radio episodes embedded systems (65) and concurrency, part 1 (12)
Other topics
Homework
- Project
4 due Thursday night, August 11, by 11:55pm – last day of summer session class
Reading/Podcasts
Dr. Laüfer’s COMP 313/413 Course Outline (basis
for this course – some schedule compression for Summer session)
|
Overall
Outline of Topics (subject to revision)
- organization, motivation, introduction (1 week: 1
total)
- what makes software good?
- requirements: functional vs. nonfunctional
- the importance of testing
- basics of object-oriented programming (2 weeks: 3
total)
- semantics: reference vs. value, equality vs.
identity
- types and classes: relationships, polymorphism
- code organization: member access,
packages/namespaces
- agile development process (1 week: 4 total)
- overview
- testing
- refactoring
- continuous integration and delivery
- object-oriented design principles (2 weeks: 6 total)
- overview
- SOLID
- designing with interfaces
- agile object-oriented modeling (2 weeks: 8 total)
- main UML diagrams: class, state machine, sequence
- archetypes and colors
- software design patterns (2 weeks: 10 total)
- key patterns from APPP and HFDP
- concurrent programming (3 weeks: 13 total)
- distributed programming (1 week: 14 total)
- overview and principles
- connecting to web services
Typical
structure of a weekly session
- OOPUJ or APPP or PA topics
- project discussion and related topics
- pair/group presentation or other activity
Typical
assignments over a two-to-three-week period
- reading
- listening to SE (Software Engineering) Radio episodes
- programming project
|
|