Project Mgt Notes
Engineering
Version 0.0 14/9/2003 by Samar
- Dev.Models
- UML;
1.
History
sw engg: buildg contruct analogy approach to sw dev usg past
experience to deal
with large progs where ad hoc method breaks down
-> productivity ↑ qualtiy ↑
art (esoteric past exper) -> craft (unorg use of past exper)
-> engg (systematic use of past exper + sci basis)
2.
Life Cycle Models
SW Lifecycle/process = series of identifiable stages sw undergoes durg
life-time:
SW Lifecycle model: a descriptive + diagrammatic model of sw
lifecycle, divides lifecycle into phases, est precedence order.
a.
Classical Waterfall Model
Classical Waterfall Model :
Next phase iff previous phase complete -> pm
knows progress, not depdt on team members guesses.
- "99% complete syndrome"
- Feasibility Study : overall understandg
- aim: is proj financially worthwhile + technically feasible?
- input data, processg needed, o/p data tobe produced, constraints
- formulate + cmp difft solutn strategies (resrc requd,
cost of developmt, developmt time)
- cost/benefit analysis: which solutn best
- Requiremts, Analysis + Specificn:
SRS (Sw Requiremts Specifn) complete, reviewed + approved
by customer.
- aim: understand + documt exact requiremts of customer
- 1. requiremts gatherg + analysis (interviews, discussn);
requiremts specificn
- what inconsistencies/incompleteness/contradictns/ambiguities of
requiremts, resolve them.
- next, SRS (sw requiremts specificn) doc havg organized requiremts
made
- analysts: who do requremt, anal + spec
- Design transform requiremt spec into form suitable for
implementn in some programmg lang
- Software Architecture derived from SRS doc
Design Approaches (2):
- Traditnal approach:
- structured analysis: id all fu's tobe performed,
id data flow among fu's, decompose each fu recursively into sub-fu's, id
data flow among sub-fu's as well.
- structured design: usg DFDs (Data Flow Diagrams);
- high-level (architectural: decompose sys into modules,
represt invocatn relatnships among modules)
- low-level (detailed: module design, data
structs + algorithms for each module made) design.
- OO approach: id various objects (real-world entities) +
their relatns, eg. employees, managers;
refine obj struct
- + lower dev effort
- + lower dev time
- + better maintainability
- Implementatn/Codg + Unit Testg:
translate sw design into src code.
- each module coded + unit tested as indepdt unit, then debugged +
documented.
- Unit Testg: test if individ modules work correctly.
- end product: set of prog modules which have been individ tested
- Integrn + Sys Testg :
- Integrn: difft modules integrated in
planned manner, usu. through steps;
durg each integrn test, partially integrated sys is tested.
- Sys.Testg; ensure developed sys fu's accordg to requiremts
as spec in SRS doc.
- Maintenance: more effort than any phase;
dev. effort : maint. effort = 40:60 usu.
- Corrective Maintenance: correct errs not discovered earlier
- Perfective Maintenance: improve implementn of sys, enhance
functnalities of sys
- Adaptive Maintenance: port sw to new env/OS
Relative Phase Efforts:
* 2% req.sp
* 8% design
* * 12% coding
* * * * 18% test (max. ofall developmt phases)
* * * * * * * * * * * * 60% maintenance (max ofall phases)
Props of Waterfall model
- feasibility study < developmt phases < testg
- usu. standds on o/p ofeach phase defined;
entry + exit criteria for every phase.
- - assumes no defect introd durg any developmt activity
- - defects usu detected much later in lifecycle (eg. design defects)
- - confounds dependancy + chronology
Classical waterfall; iterative waterfall.
Classical Waterfall Model;
Feasibility Study
Req. Analysis
Design
Coding
Testing
Maintenance
b.
Iterative Waterfall Model
Analysis--| (Requiremt, analysis + spec)
/|\ Design--|
|-----|- Implementation--|
|-----|-----|--------- Testing--|
|-----|-----|------------- Installation
Iterative Waterfall Model (feedback paths added to classical
waterfall model return to phase where err introd)
- Phase Containmt of Errors: principle of detectn of errors as close
to pt of introductn as possible, pref. in same phase.
- Iterative waterfall model is by far most widely used.
- irrespective of life cycle followed, docs should
reflect classical waterfall model ≡ theorem provg in maths
c.
Prototyping Model
workg prototype / toy implementn (limited fu capabilities, low
reliability, ineffict) first built
- impossible to "get it right" first time.
- approx requiremts;
quick design, short-cuts (ineffict, inaccuate fu's),
dummy fu's; lookup not computatn
- requiremts refined based on user feedback.
- cycle continues till user approves prototype.
- + illustrate to customer
- requiremts, anal + spec phase redundant as final
workg prototype serves as an animated requiremts spec.
- design + code of prototype usu thrown away; final
code usg trad waterfall.
- + unclear user requiemts + unresolved tech issues:
refing of user requiremts + technical design issues,
prevent redesign costs
build prototype
/ \
requirmts / \
gatherg --- quk design customer eval - cust satsifd
\ / |
\ / design, implement, test, maintain
refine requmts
d.
Evolutionary Model/ Successive Versns / Incremental model
initial prod skeleton refined;
sys is broken down into several modules which canbe incrementally
implemented + delivered.
Features
- + users can experimt with partially dev'd sys
- + exact user requiremts found
- + core modules tested fully
- - oft difficult to subdivide
- useful for v. large problems
- --> evolutionary model with iteratn
used by many orgs: new functnality + modify existf functnality
Evolutionary Model with Iteration
- + traing canstart on earlier release.
- + markets canbe created for functnality never offered
- frequt releases allow dev'rs to fix unanticipated problems.
e.
Spiral Model
- proposed by Boehm in 1988
- each loop = phase of sw process;
inner loop - maybe sys. feasibility;
next loop - sys.reqmts + def;
next - sys.design, etc.
- start work usg generic model, add extra phases
- each loop split into 4 quadrants/sectors
- each iteratn ard spiral: progressively more
complete versn of sw.
- subsumes all discussed models:
single loop spiral = waterfall model;
uses evolutionary approach as each iteratn through spiral
are evolutnary levels; protypg = risk reductn
- understandg + reactg to risks durg each iteratn along
spiral
det objectives id + resolve risks
,dP""Yb,
,d" "b,
d' _ `Y,
8 8 `b
`b,_,aP P
"""" d'
,P"
a,.__,aP" dev nxt level of prod
customer eval
of prototyp
Quadrants (4)
- Objective Settg: id objectives + examine risks
(any adverse circumstance which might hamper completn of proj);
id alternatives
- Risk Assesmt + Reductn: risk reduction
- Developmt + Validatn: dev + validate next level of product
- Review + Planng: review reslts achieved so far with
the customer + plan next iteratn ard spiral.
Comparison of models:
- Iterative Waterfall model most widely used, but
good only4 well-understood problems.
- Prototype Model: good4 projects not well understood;
good4 user requiremts, technical aspects.
- Evolutnary Model: good for large problems
as canbe decomposed into set of modules that canbe incrementally
implemented.
- Spiral Model: gd for developmt of tech challengg projs
subject to difft kinds of risks.
2.
UML (Unifd Modeling Lang)
UML = lang. notatns for documtg OOAD; no methodlogy;
to standardise difft notatns
- round-trip engg: fwd (uml -> code) + reverse engg (code -> uml)
- OMT (Rumbaugh + Blaha),
Booch's method (Grady Booch), OOSE (Ivar Jacobson)
- OMG (Obj Mgt Grp) promotes UML since 1997.
- CASE tools: gen. template code from UML
- 3 views;
Static views: objs, attribs, behaviours + relatnships
Dynamic views: communicns, states + transitns, ctrl/timg
Restrictions: attrib vals + types, dyn behaviour.
Use-Case Dia
________________________________
| Class Name |
|-------------------------------|
| attrib:data_type = init_value |
| |
---------------------------------
| operation |
| operation (arg_list): result_type |
|
___________
| |\
| |_\
| |
--------------
O
/H\
/ \
_ ; ; 8 8 `b
__ ,'" "`. | | `b,_,aP P
__ ,' `. / \ ; ; """" d'
.' `. / | | | \ / ,P"
_ | | | / \ / `. .' a,.__,aP"
. o (_) `.__.' `.__.' `.___.'
Dias
- Use Case
- Class
- Collaboration
- Sequence
- Package
- State diagrams.
FS/OSS (free sw/open src sw) UML Tools
- Umbrello UML Modeller: http://uml.sourceforge.net/; can make
class/concept, sequence, collaboratn, usecase, state, activity dias;
code-uml, uml-code for java, c++, gens php, etc.
- dia: standd linux; visio clone (drawg tool, not modellg tool);
http://www.lysator.liu.se/~alla/dia/
- QuickUML http://www.excelsoftware.com/quickumllinux.html;
dachshund.
- Rational Rose
- ArgoUML: large + complete; http://argouml.org/ ; poseidon based on
argouml
- JGraph by Sun: http://www.jgraph.com/
- MagicDraw UML: must register first
- Other java: violet, umlet (60k) pasta, jase, fujaba/
- Other linux: PyUt, kuml, Dia2Code
- cpp2dia: http://cpp2dia.sourceforge.net
Project Mgt
Organizn of SPMP (Sw Proj Mgt Plan)
- Intro: Objectives; Major Fu's; Perf Issues; Mgt + Technical
Contraints
- Project Estimates: Historical Data Used;
Estimation Techniques; Effort, Resrc, Cost + Proj Duratn
- Risk Mgt Plan: Risk Analysis; Risk Identifn; Risk Estimn; Risk
Abatemt Proc
- Schedule: Work breakdown struct; Task NW Representn; PERT Chart
- Proj Resrcs: People; HW + SW; Special Resrcs
- Staff Org: Team Struct; Mgt Reportg
- Proj Trackg + Ctrl Plan
- Misc Plans: Proc Tailorg; Quality Assur; Cfg Mgt; Validn +
Verifn; Sys. Testg; Delivery, Installn, Maint.
Proj Size Estimatn Metrics:
- LOC (Lines of Code)
⊖ code reuse discouraged, logic not taken into a/c;
useless at start of proj; depdt on codg style.
- FP (Functn Pt Metric):
weighted sum of 5 empirical props:
FP Size of problem = (Nu. i/p's) * 4 {user data i/p}
+ (Nu. o/p's) * 5 (error msgs, screens, reports)
+ (Nu. inquiries) * 4 (user queries requirg actn)
+ (Nu. files) * 10 + (data struct/files)
(Nu. interfaces) * 10 (to transmit info to tape, disk, etc.)
⊕ est sw size directly from proj spec;
⊖ no a/c algo complexity
--> feature pt metric (algo considered)
References
- Mall 2002: Rajib Mall's Lectures (by Sudebkumar Prasant Pal)
http://www.facweb.iitkgp.ernet.in/~spp/softengg2002.htm (2002
Undergrad sw engg crs)
- Mall 2000: "Fundamentals of Software Engineering", by Rajib Mall,
Prentice-Hall of India, New Delhi 2000.
- Fact Guru: sw process models
http://www.site.uottawa.ca:4321/oose/processmodel.html
- http://www.cetus-links.org/oo_ooa_ood_tools.html
- http://www.zipcon.net/~swhite/docs/computers/linux/UML_Tools.html
- ascii art; alt.ascii-art faq
http://lizard.crosswinds.net/ascii-art/ascii-art_FAQ.html
- pdf notes:
http://win-www.uia.ac.be/u/sdemey/Teaching/SE1LIC/01Intro.pdf -
- large nu slides of lecture notes of Chang-Hyun Jo
http://people.aero.und.edu/~jo/
- download trial rose
http://www.rational.com/products/rose/tryit/eval.jtmpl
- Kennesaw UML
http://pigseye.kennesaw.edu/~dbraun/csis4650/A&D/UML_tutorial/
- Rational UML Quick Reference
http://www.rational.com/uml/resources/quick/index.jsp?SMSESSION=NO