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

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 standard build environment gate keeping	problems of reproducability goals of version control change control trade-offs goals of build automation	baseline model promotion model	work partitioning work scheduling time management post mortems base releases and branches keyword substitution conflict management
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 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	requirement specification	reqts elicitation reqts validation reqts prioritization
5	Users, Roles, Use Cases	role scenario use case behavioral requirements	good user classifications use case vs specification	user story cards use case 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	Agile Process	agile philosophy Agile Aliance Principles eXtreme Programming	failings of formal process Big Requirements Up Front? Agile vs planned process? how much process?
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 architectural patterns	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	System Models and Modeling	UML system views descriptive vs analytical models queueing models markov models discrete event simulation	why a graphical language why a standard language reasons to model reasons to prototype agile modeling principles model life span choice of model type choice of model representation	activity digrms component digrm deployment digrm	mathematical models U/I prototypes mechanism prototypes proof-of-concept
11	Class Design	component component specification classes class associations class dependencies packages	reasons to define classes class design principles packaging principles	class digrms package digrms object digrms	OO-design class design patterns classes in non-OO languages
12	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 interaction digrms swim-lane digrms state digrms tabular designs	algorithmic design patterns developing routine design program into your language
13	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
14	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
15	U/I Design	Content Architecture	principles of UI design web UIs vs GUIs principles of CLI design	web site mapping	usability testing UI design process
16	Maintainability	elements of maintainability elements of readability elements of coding style statement layout code style as docn style tools	naming conventions comment types when/how to comment coding standards module layout indentation syles commenting styles external documentation	javadoc
17	Productivity, and Colaboration	leadership training mentoring	individual productivity pair programming global s/w development		Pair Programming eXtreme Programming improving productivity
18	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 suite test plan	specfication-based testing equivalence partitioning boundary value analysis orthogonal array testing structural testing data flow testing
19	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
20	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 bug reports	bug triage scientific debugging method forensic analysis diagnostic instrumentation correct bug fixing root-cause analysis
21	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 event tracing profiling	scenario-based testing load/stress testing interoperability testing load generation
22	Estimation & Risk	size estimates work estimates Constructive Cost Model types of risk	estimation principles productivity estimation planning w/poor info causes of technical risk size vs productivity size and activities	estimate confidence risk assessment risk management plan	size estimation risk identification risk mitigation risk monitoring
23	Scheduling Tracking Management	task dependencies critical path resource dependencies critical resource project management	SMART milestones time vs. staffing work vs. progress quantifying progress project warning signs features/quality/schedule causes of schedule slippage dealing w/schedule slippage adding more resources communication vs proj size	PERT Charts Gantt charts PNR effort/time curve status reporting	task breakdown dependency analysis project scheduling earned value analysis status collection recognizing problems
24	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: Aug 21, 2007