UIUC CS 427 Study Guide

Random Miscellaneous Quiz

Can you name the UIUC CS 427 Study Guide?

Quiz not verified by Sporcle

 plays        
How to Play
Software for SCM
know who made changes ... etc 
produce right version of executable 
bug reporting 
Resolving a bug
done 
this isn't real 
nope, not doing it 
farther down the road 
post it note it 
multiple 
its a feature? 
Test
checks the quality of the product (speeds, timings) 
checks the end result / quantity of the tests (completion) 
unit tests for example, doesn't require humans 
human run tests 
how well a customer can use a product, similar to non-programmer tests 
Quick test to ensure that system at least runs after you make a change 
Ensure that a specific module is not broken after you make a change, one click execution 
Ensure that existing code doesn't get worse as you make other improvements 
Debugging
situation that gives the wrong result 
mistake in the code 
debugging activity - where you watch the execution of the program with print statements, single stepping debuggers, etc. 
debugging activity - find fault by going back to first failure 
debugging activity - list all bug possibilites, and examine each one. Requires system knowledge. 
preconditions or postconditions used to make sure that code executed correctly, postconditions often reside in unit tests 
Component-Based SE
COTS 
royalties, training, support and enhancement, domain analysis, increased documentation, reuse repository 
components + pattern 
build software that helps build applications in the problem domain 
components, frameworks, domain-specific software architectures, product-line architectures 
Design Patterns
set of recurring arrangements of elements, documenting expertise, describe something that doesn't fall into standard categories (algorithm, data structures) 
GoF 
creational, structural, or behavioral 
behavioral, define a one-to-many dependency between objects so that when one object chanes state, all its dependents are notified and updated automatically 
behavioral, define a language and grammar for object to understand, example excel cell equations 
creational, method that creates objects without having to specify the class 
creational, creates many class objects all at once that logically go together, provide interface for individual factory methods 
structural, convert the interface of a class into another interface the client expects, makes adaptee act like it has the target interface 
structural, make abstract component class, can tree objects and groups of objects the same, composite can enumerate components, component knows its container 
behavioral, define an algorithm that a specific subclasses can redefine parts without changing the algorithm (example, sorting) 
creational, class has only named instances, global access to them (examples, tetris pieces) 
Relooper
refactor tool that provides analysis on whether parellel refactorings can be done and performs them if they can 
check loops over all elements, loop iterations have no conflicting memory accesses, loops do not contain blocking IO 
Waterfall life cycle
1 
2 
3 
4 
5 
6 
7 
XP Process
1 
2 
3 
4 
5 
Documentation
magic number of max ideas you can present at once 
use appriopriate vocabulary 
abstract, requirements, architecture, detailed design, user manual, installation 
designers need guidance, if we try we'll get close, organizations need a starndard procedure, standard of comparison, projects can be reviewed 
produce the documents we would have if we had done things the ideal way 
Actor
encapsulated state + behavior + independent control + mailbox, concurrent, no data races, asynchronous message passing 
XP practices
customer involved weekly in development along with your developers 
user stories, tasks, time -> becomes a plan 
interative products as opposed to large final product 
frequent testing by customer 
two people, one computer 
design based off of tests first, before implementing 
design improvements 
everyone owns everything 
frequent attempts for 
40-hour week 
Code Smells
too much of the same 
can't think of whole thing at once, often extracting a loop body 
more a couple dozen methods 
introduce parameter object, if lots of similarly called functions 
long list of method calls, ex a().b().c() .... 
code wishes it were in another class 
might make a subclass for each case 
no methods excpet for getting and setting, conflicts with parameter object a bit 
instance field is only used during part of the lifetime of an object 
class is a subclass of another when they have some conflicting methods etc, really should create a superclass that both should inherit from 
adding a feature or class requires lots of changes to many parts of the program or hierarchy 
JPF Operations
 
 
 
Reverse Engineering
risk factor 
risk factor 
risk factor 
risk factor 
risk factor 
quick glance through code 
redesign some of the code to make it clearer 
Software metrics
number of references outside of module 
number of references within a module 
SLOC 
number of independent paths through the procedure 
1 / (# inputs + # outputs + # globals + # modules called + # modules calling) 
instability = efferent coupling / (afferent coupling + efferent coupling) 
WMC 
NOC 
Concurrency
ACID 

Friend Scores


  Player Best Score Plays Last Played
You You haven't played this game yet.

You Might Also Like...

Extras

Created Dec 10, 2009ReportNominate
Tags:427, CS 427, guide, study, Study Guide, uiuc