Software Engineering (CS 561)

Study Guide for Final Exam

The final exam format will be similar and of similar length to past exams.

There will be 10 T/F questions worth 20 points and there will be 80 points of 
short/long answer questions

If you score better on this exam than you did on one or both of the previous 
exams, the final exam score will replace the worse of the two previous exam 
scores.

Topics covered in class included:

Software engineering basics
Object orientation
Development with reusable technology
Developing requirements
Modeling with classes
Design patterns
Usability and UI's
Models of SW behavior and interactions
Software Architecture/Design principles

***Basics***
What is SW eng? (Aug. 26 Notes)
Types of SW
Stakeholders
SW Attributes
	Usability
	Efficiency
	Reliability
	Maintainability
	Reusability
Types of projects
	Evolutionary
	New or greenfield
	Framework based
What to do when creating SW (SW Life Cycle)
	Requirements and specification
	Design
	Modeling
	Programming
	QA
	Deployment
	Maintenance

***Object orientation***
Procedural and data abstraction
Classes and objects
Instance variables
Attributes and associations
Polymorphism
Inheritance
Abstract classes and methods
Overriding
Dynamic binding
Interfaces

Simple metrics for program quality (apply to coupling)
	See Sept. 11 Notes

	Inheritance hierarchy depth
	# of overridden methods per class
	Lines of code per method
	# of Public instance variables per class
	# methods per class
	% of lines with comments
	uncommented lines of code
	# of lines of code

Software reuse
	Different kinds of reuse
	Frameworks - reusable subsystems
	Client server architecture
	Properties of clients and servers
	
Requirements
	Domain analysis - background info (Sept 13 Notes)
	Requirements gathering
		Scope
		Functional
		Quality
		Platform
		Process requirements

        *** Be able to complete a written use case diagram ***

	See Sept 27 notes
	Use cases

	See Sept. 16, Sept. 18, Oct. 4 & 7 notes
	Interviewing
		how to get requirements from clients/users
	Requirements documentation
	Software Process Models
		Know the difference between Waterfall, Spiral, and Agile Models	

UML
	See Sept 4, Sept 6, Oct. 9 and 11 notes

	*** On the exam ***
	*** You will have to draw UML diagrams including associations ***

	Class diagrams
		Associations
		Multiplicities
			Directionality
		Generalization
		Aggregation
		Composition
		Attributes
		Methods
		Interfaces

	Be able to describe each of the following model types:
		exploratory domain model
		system domain model
		system model
		See Oct. 11 Notes

Design Patterns
	See Oct 14 - 16 notes

	Abstraction occurrence
	Singleton
	General Hierarchy
	Player-role
	Observer
	Delegation
	Adapter
	Facade
	Immutable
	Read-Only Interface
	Factory

	You should know how to draw UML class diagrams for the Delegation,
        Immutable, General Hierarchy, Observer, and Read-Only Interface
        design patterns.

	You should be able to answer T/F questions about the other patterns.

UI design
	Understand user centered design
	Be able to understand and recall usability principles
	Be able to evaluate user interfaces
		Examples include consistency, 
	Be able to draw paper prototypes
	Recognize and recall UI components such as
		Text boxes
		Modal dialogs
		Radio buttons
		Checkboxes
		etc.

Modeling behaviors and interactions
	***There will be questions on sequence and communication diagrams***

	State Diagrams - understand these
	Activity Diagrams - understand these
	Sequence Diagrams - be able to understand and draw these
		See notes from Sept. 23 and Oct. 30.
	Communication Diagrams - be able to understand and draw these
		See notes from Nov. 1.
	You should be able to compare sequence diagrams to communication
	diagrams.

Architecture/Design
	***There will be a question on cohesion and coupling***

	Design principles
	   11 Design principles were presented in the notes from Nov. 6
	   You should be able to recall at least 4 of these

	Cohesion
	   Be able to recall the different types of cohesion
		-Functional
		-Layer
		-Communicational
		-Sequential
		-Procedural
		-Temporal
		-Utility
	Coupling
	   Be able to recall the different types of coupling
		-Content
		-Common
		-Control
		-Stamp
		-Data
		-Routine Call
		-Type use
		-Inclusion/import
		-External

	Defensive Design
		Use design by contract
		Preconditions - true beforehand
		Postconditions - true afterwards
		Invariants - don't change while code is running

	Know steps for Model Development (See Nov. 15 notes)

	Be able to recognize parts of component diagrams

		See Nov. 15 notes
		Lollipop symbol
		---( *---- refers to interface that must be implemented

		Electrical Socket symbol - refers to a SW component

		+----------------+
                |   _            |
		| -| |           |
                | -|_| Component |
		+----------------+

		- - - > Symbol refers to modular dependency

	Be able to recognize the different kinds of component designs
	See Nov. 20 Notes and slides link for Dec. 2

		Multi-Layer
		Client-Server
		Broker
		Transaction Processing
		Pipe-and-Filter
		Model-View-Controller
		
Metrics
   See Sept. 11 notes for simple metrics
   See Nov. 18 notes for more complex metrics

   ***Be able to work a problem, if you are given a code segment and formulas***
   ***Know the basic differences between these***

   Halstead Complexity - measures "logical" complexity (how long a program is
	and how short it could be
   Cyclomatic Complexity - measures structural complexity (how complex in terms
	of control flow)
   Henry-Kaufera Complexity - measures structural complexity between modules
	(how complex in terms of information flowing between modules)