Computer Science 121 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 be able to read and answer questions about system described in these formats. You should be able to present your answers in these forms.

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.

Lecture	Subject	Concepts	Issues	Representations	Techniques
1	Intro	characteristics of s/w (vs h/w) criticality of methodology	challenges of building s/w challenges of legacy s/w why we ship bad s/w
2	S/W Management	configuration management change control version control standard build environment	change control trade-offs problems of reproducability version control goals build automation goals	baseline model promotion model makefiles	dependencies, implicit rules variables, includes and conditionals base releases and branches keyword use locking
3	Quality Quality Assurance	dimensions of quality Q/A roles & activities engr Q/A activities process assurance	testing vs Q/A costs of defects defect amplification efficacy of Q/A techniques		post mortems statistical Q/A
4	S/W Process Models	s/w definition s/w planning s/w construction s/w deployment work products	value of check-lists choosing the right model managing concurrency safe phase overlap planned iteration	waterfall model incremental model spiral model
5	Agility & XP	agile philosophy Agile Aliance Principles eXtreme Programming	failings of formal process Big Requirements Up Front? when to choose which? how much process?
6	Teams, Structure, Dynamics	leadership training mentoring	individual productivity pair programming work partitioning global s/w development		Pair Programming improving productivity
7	Requirements	criticality of requirements costs of early mistakes stake holder types of requirements	user vs technical requirements clarity consistency testability traceability		reqts elicitation reqts validation reqts prioritization
8	Use Cases	role scenario use case	good user classifications use case vs specification	use case diagrams user story cards	user characterization task analysis scenario development
9	System Models (behavior)	UML behavioral requirements	why a graphical language why a standard language requirements vs specifications	activity digrms interaction digrms swim-lane digrms state digrms
10	System Models (structure)	system views class associations class dependencies		class digrms package digrms object digrms component digrm deployment digrm
11	System Models (analytical & prototypes)	hierarchies of models descriptive vs analytical models queueing models markov models discrete event simulation	reasons to model reasons to prototype agile modeling principles model life span		mathematical models U/I prototypes mechanism prototypes proof-of-concept
12	U/I Design	Content model Navigation model	principles of UI design web UIs vs GUIs principles of CLI design	web site mapping	usability testing Relationship Analysis Navigation Analysis UI design process
13	Architecture (what)	hierarchies of design architecture (vs design) modularity information hiding cohesion complexity/simplicity elegance	criticality of architecture scope of architecture elements of good design appropriate abstraction criticality of interfaces interface stability mechanism/policy separation
14	Architecture (how)	extensibility portability design patterns architectural patterns	anticipating change designing for change solving hard problems anti-architectural forces		domain object analysis top-down design bottom-up design evaluating an architecture
15	Component Design	component component specification classes packages macros & inlines	reasons to define classes class design principles reasons to define routines routine design principles appropriate macro use packaging principles	pseudo-code tabular designs	developing routine design classes in non-OO languages
16	Maintainability	elements of maintainability elements of readability elements of coding style style tools	naming conventions comment types when/how to comment coding standards	module layout indentation styles commenting styles javadoc
17	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 fail mode enumeration error prioritization error detection error containment error testing error handling techniques
18	Test Cases and Testability	test case black-box testing white-box testing code coverage static complexity	characteristics of a good test elements of testability designing for testability black-box vs white-box 100% code coverage?	test specifications	specfication-based testing equivalence partitioning boundary value analysis structural testing (othogonal array testing)
19	Integration Strategy Testing Methodology	integration orders incremental integration continuous integration unit testing regression testing test harnesses	architecture & integration development & integration testing & integration daily builds & smoke tests program vs routine testing in-vivo vs in-vitro testing	test case	test driven development test harnesses
20	Design/Code 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
21	Bugs & Debugging	back-traces bug tracking system bug report life cycle priority and severity	minimal failure cases good bug reports hypothesis confirmation similar bugs psychological issues	core dumps stack traces execution traces diagnostic instrumentation bug reports	bug triage scientific debugging method forensic analysis correct bug fixing root-cause analysis
22	System Testing Performance	system testing alpha testing beta testing Pareto principle	unit vs system testing testing and bug discovery ship criteria performance principles	bug arrival rates call counting event tracing profiling	scenario-based testing load/stress testing interoperability testing load generation
23	Estimation & Risk	size estimates work estimates Constructive Cost Model types of risk	estimation principles productivity estimation planning w/poor info causes of technical risk	estimate confidence risk assessment risk management plan	size estimation risk identification risk mitigation risk monitoring
24	Scheduling and Tracking	task dependencies critical path resource dependencies critical resource	SMART milestones time vs. staffing work vs. progress quantifying progress	PERT Charts Gantt charts PNR effort/time curve	task breakdown dependency analysis project scheduling earned value analysis
25	Project Management	project management functions of management management skills	project warning signs features/quality/schedule causes of schedule slippage dealing w/schedule slippage adding more resources	status reporting	status collection recognizing problems
26	Process Improvement	process improvement ISO9000 Six Sigma software metrics process metrics	CMM levels good metrics metrics gaming metrics balancing rational metrics use	Capability Maturity Model	Best Practice Benchmarking Root Cause Analysis

Last updated: April 20, 2007