Preliminary Schedule (Based on Dr. Yacobellis' Spring, 2020, 313 Schedule – Subject to Change) Previous version (Spring 2020) Some Key Dates 02 June (week 3 Tuesday): Project 1 due at 11:55pm09 June (week 4 Tuesday): quiz 1 09 June (week 4 Tuesday): 2-person Project 3 team members assigned
16 June (week 5 Tuesday): test 1 16 June (week 5 Tuesday): Project 2 due at 11:55pm (update)
30 Jun3 (week 7 Tuesday): withdrawal deadline 07 July (week 8 Tuesday): quiz 2 outside class
07 July (week 8 Tuesday): Project 3 due at 11:55pm 13-14 July (week 9 Monday and Tuesday): test 2 - take this on your own before class starts on Tuesday
06 August (week 12 Thursday): test 3, last class; Project 4 due at 11:55pm
Twelve weeks of course: 24 class sessions
First week of course: May 19-21 (Tuesday through Thursday) Final week of course: August 4-6 (Tuesday through Thursday) Week 1: 19 May Video Recordings - Pre-work: using Zoom, installing required software, filling in pre-course survey
- Course overview and Course Roadmap
- Sakai and Piazza
Sessions - Class 1 - 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, Android Studio, Bitbucket, …
- course software with demo
- 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
- Class 2 – finishing the above plus prerequisite assessment – in-class team/group exercise
Reading/Podcasts - Typically in preparation for the following week Week 2: 26 May
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 – COMP 271 (Data Structures) recap; Object-Oriented basics
- announcements
- data structures review (see above topics)
- classes vs. objects
- UML class diagrams
- Class 2 – 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: 02 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
- Abstract Classes
- even more Java thought problems
- More on Test-Driven Development
- JUnit Annotations, test methods, and examples
Reading/Podcasts Homework - Project 1 due June 2 by 11:55pm
Week 4: 09 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 - outside class
- announcements
- test 1 next week; 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, Strategy Pattern, and Visitor Pattern
- brief project 3 introduction, team formation
Reading/Podcasts - Bob Tarr pdf slide sets on Factory, Strategy, and Visitor Design Patterns (in Sakai Week 4 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
Week 5: 16 June Session - test 1 outside of class
- Class 1
- announcements
- more Design Patterns
- Decorator and Composite
- Visitor revisited
- Resources
- tutorialspoint website
- Bob Tarr pdf slides on Sakai (Week 4)
- APPP Design Pattern references
- Decorator: part of Chapter 35
- Composite: Chapter 31
- Visitor: Chapter 35
- Class 2
- 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 - APPP chapters 13 & 14
- Overview of UML for C# Programmers; Working with Diagrams
- 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
- SE Radio episode 167 on unit testing
Homework - Project 2 due Tuesday night June 15 by 11:55pm - updated
Week 6: 23 June Video Recordings - Test 1 review (if not covered in Week 5)
Session - Class 1
- announcements
- project 3 team repositories: cs313413su18teamNp3
- continued project 3 detailed discussion - may be via Panopto recording
- 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
- 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 2
- 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
Reading/Podcasts Week 7: 30 June
Video Recordings - possibly SOLID follow-up sections
Session - Class 1
- announcements
- any remaining questions about project 3
- reminders: Quiz 2 on July 7 (2 SE Radio podcasts), test 2 on July 14
- brief review of Android framework
- possibly begin overview of Java 8-10
- Class 2
- Overview of Java 8-14
- in-class time to work on Project 3
Reading/Podcasts Week 8: 07 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
- This section may be in a Panopto video
- Class 2
- 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 Design Pattern
Homework - Project 3 due Tuesday night July 7
Week 9: 14 July Session - test 2 outside class
- Class 1
- Android
- stopwatch internals - objectives, architecture, and design
- mapping the stopwatch state machine to Java code
- clickcounter overview - event-based interaction
- clickcounter internals - objectives, architecture, and design (may be in Class 3)
- Class 3
- 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
- this may be partially or completely deferred to Week 10
Reading/Podcasts Week 10: 21 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
- 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
- this may have been completed in Week 9 (or at least started then)
- Class 2
- detailed discussion of testing in clickcounter and stopwatch examples
- in-class group exercise: create a comprehensive set of unit tests for Project 4 - possibly in Class 3
- also capture these to submit as part of each larger group’s Project 4 submission
- note: you don’t need to create the tests, just create a list of proposed tests
- maybe 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: 28 July
- 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:
- 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
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 – may be
covered on final exam (test 3)
Week
12: 04 August
- Class 1
- announcements
- test 3 on Thursday outside class - practice test in Week 12 folder
- Class 2 – test 3 (final exam) 80 minutes
outside class time on Thursday
- may include SE Radio episodes embedded systems (65)
and concurrency, part 1 (12)
Other
topics Homework
- Project 4 due Thursday night, August 6, 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
|
|