Key Learning Objectives

This course is organized around a several dozen key learning objectives. They include basic concepts, issues, notations, and techniques. The lectures, exams and labs will be built around these.

1. concepts

   You should be able to define them, discuss how they relate to one-another, give examples, recognize instances, and discuss their meanings.

2. issues

   You should be able to discuss the considerations to be weighed, recognize the situations where they are relevent, interpret the issues in the context of a particular problem, and make and justify decisions based on them.

3. representations

   You should understand the purposes and key elements of each. You should be able to present information in these forms. You should be able to answer questions about systems described in these formats.

4. techniques

   You should be familiar with the purpose of and steps in each technique, and the considerations that go into performing those steps correctly.

sprint planning
daily standup

Lecture	Subject	Concepts	Issues	Representations	Techniques
1	Introduction	scope of s/w engr characteristics of s/w (vs h/w) criticality of methodology	challenges of building s/w challenges of legacy s/w why projects fail
2	Basic Project Skills	configuration management change control version control distributed version control standard build environment gate keeping	problems of reproducability goals of version control centralized vs distributed change control trade-offs goals of build automation	hierarchical workspaces	work partitioning work scheduling time management post mortems base releases and branches conflict management git
3	S/W Process Models	s/w definition s/w planning s/w construction s/w deployment work products phases, activities, tasks	value of check-lists choosing the right model Big Requirements Up Front? managing concurrency safe phase overlap planned iteration	waterfall model incremental model spiral model
4	Requirements	stake holder types of requirements requirements vs specifications clarity consistency testability traceability	criticality of requirements costs of early mistakes requirements stablility requirements problems scope creep	requirement specification	surveys reqts elicitation reqts validation reqts prioritization
5	Users, Roles, Use Cases	role scenario use case (vs specification) behavioral requirements	good user classifications understanding users/needs why a graphical language why a standard language	user story cards UML use case diagrams UML activity diagrams UML state diagrams	user characterization scenario development task analysis
6	Quality Quality Assurance	dimensions of quality Q/A roles & activities process assurance process improvement	testing vs Q/A costs of defects defect amplification efficacy of Q/A techniques when to do Q/A		defect removal techniques
7	System Models and Modeling	UML system views descriptive vs analytical models queueing models markov models discrete event simulation	reasons to model reasons to prototype agile modeling principles model life span choice of model type choice of model representation	component digrm deployment digrm architectural diagrams	mathematical models U/I prototypes mechanism prototypes proof-of-concept
8	Architecture (what)	hierarchies of design architecture (vs design) modularity information hiding cohesion complexity/simplicity elegance testability	criticality of architecture scope of architecture elements of good design appropriate abstraction criticality of interfaces interface stability mechanism/policy separation		managing complexity
9	Architecture (how)	nature of design process extensibility portability	anticipating change designing for change solving hard problems anti-architectural forces intuitive objects why design is difficult		domain object analysis top-down design bottom-up design evaluating an architecture
10	Design Reviews	reviews walk-throughs	relative costs of approaches effectiveness of approaches problems and solutions vs. pair programming		review roles review prep review activities review reports
11	U/I Design	Content Architecture	principles of UI design examples: game usability web UIs vs GUIs principles of CLI design	web site mapping	usability testing UI design process
12	Class Design	component specifications classes class associations class dependencies packages	reasons to define classes Liskov Substitution Principle Dependency Inversion Principle Release/Requse Equivalency Principle Common Closure Principle	class digrms package digrms object digrms	OO-design classes in non-OO languages
13	Routine and Algorithm Design	macros & inlines	reasons to define routines routine design principles appropriate macro use routine names routine length defining parameters functions vs procedures	pseudo-code swim-lane digrms UML sequence digrms tabular designs	developing routine design program into your language
14	Design Patterns	object abstraction flow control patterns concurrency patterns			architectural design patterns (pipe/filter, layered, repositories, client-server) class design patterns (singleton, bridge, adaptor, proxy, object pool) algorithmic design patterns (iterator, observer, strategy, visitor, )
15	Test Cases and Testability	test cases & suites black-box testing white-box testing code coverage static complexity testability	limitations of testing characteristics of a good test black-box vs white-box 100% code coverage? testing & risk psychological issues	test case specifications test plan	specfication-based testing equivalence partitioning boundary value analysis orthogonal array testing structural testing data flow testing
16	Robustness	correctness, robustness reliability, availability defect, fault, error, failure defensive programming	causes of defects causes of failures error detection principles	MTBF FIT rates fault handling reqts	assertions fire-walls/barricades defensive instrumentation fail mode enumeration error prioritization error detection error containment error testing error handling techniques exceptions
17	Bugs & Debugging	back-traces bug tracking system bug report life cycle bug fields priority and severity	minimal failure cases good bug reports hypothesis confirmation similar bugs psychological issues	core dumps stack traces execution traces bug reports	bug triage scientific debugging method forensic analysis diagnostic instrumentation correct bug fixing root-cause analysis
18	Integration Strategy Testing Methodology	incremental integration continuous integration unit testing regression testing system testing test harnesses train model integration	architecture & integration development & integration testing & integration choosing integration strategy daily builds & smoke tests program vs routine testing in-vivo vs in-vitro testing		test driven development test harnesses
19	System Testing Performance	system testing alpha testing beta testing Pareto principle release phases	unit vs system testing testing and bug discovery release criteria performance principles automated testing	bug arrival rates call counting profiling	scenario-based testing load/stress testing compatability/interoperability testing load generation
20	Maintainability	elements of maintainability elements of readability elements of coding style statement layout code style as docn style tools	comment types when/how to comment coding standards module layout indentation syles commenting styles external documentation	javadoc doxygen
21	Agile Process	agile philosophy Agile Aliance Principles SCRUM sprint product owner	failings of formal process Agile vs planned process? how much process? sprint cadence	product backlog sprint backlog
22	Productivity, and Colaboration	colaboration benefits leadership training mentoring	contributors to productivity range of individual productivity challenges of pair programming just in time s/w development refactoring vs up-front design agile team empowerment global s/w development		eXtreme Programming Pair Programming refactoring collective code ownership
23	Estimation & Risk	work estimates confidence bands COnstructive COst MOdel types of risk	estimation principles productivity estimation technical risks management risks unexpected events features/quality/schedule proj size vs productivity proj size and activities proactive vs reactive mgt	estimate confidence risk assessment risk management plan	size estimation backlog grooming risk identification risk mitigation risk monitoring
24	Scheduling Tracking Management	task dependencies critical path resource dependencies critical resource sprint velocity project management	SMART milestones quantifying progress project warning signs causes of schedule slippage dealing w/schedule slippage adding more resources communication vs proj size	SCRUM points PERT Charts Gantt charts PNR effort/time curve burn-down graph status reporting	task breakdown dependency analysis project scheduling earned value analysis status collection recognizing problems
25	Metrics and Process Improvement (spring only)	process improvement ISO9000 Six Sigma software metrics process metrics	good metrics metrics gaming metrics balancing rational metrics use	Capability Maturity Model	continuous improvement Best Practice Benchmarking

Last updated: July 2012