|
|
| Book details / order |
| BEGINNING SOFTWARE ENGINEERING |
Beginning software engineering demystifies the software engineering methodologies and techniques that professional developers use to design and build robust, efficient and consistently reliable software. free of jargon and assuming no previous programming, development, or management experience, this accessible guide explains important concepts and techniques that can be applied to any programming language. each chapter ends with exercises that let you test your understanding and help you elaborate on the chapter's main concepts. everything you need to understand waterfall, sashimi, agile, rad, scrum, kanban, extreme programming and many other development models is inside!
contents : -
introduction
part i: software engineering step-by-step
chapter 1: software engineering from 20,000 feet
requirements gathering
high-level design
low-level design
development
testing
deployment
maintenance
wrap-up
everything all at once
chapter 2: before the beginning
document management
historical documents
e-mail
code
code documentation
application documentation
chapter 3: project management
executive support
project management
pert charts
critical path methods
gantt charts
scheduling software
predicting times
get experience
break unknown tasks into simpler pieces
look for similarities
expect the unexpected
track progress
risk management
chapter 4: requirement gathering
requirements defined
clear
unambiguous
consistent
prioritized
verifiable
words to avoid
requirement categories
audience-oriented requirements
business requirements
user requirements
functional requirements
nonfunctional requirements
implementation requirements
furps
furps+
common requirements
gathering requirements
listen to customers (and users)
use the five ws (and one h)
who
what
when
where
why
how
study users
refining requirements
copy existing systems
clairvoyance
brainstorm
recording requirements
uml
user stories
use cases
prototypes
requirements specification
validation and verification
changing requirements
chapter 5: high level design
the big picture
what to specify
security
hardware
user interface
internal interfaces
external interfaces
architecture
monolithic
client/server
component-based
service-oriented
data-centric
event-driven
rule-based
distributed
mix and match
reports
other outputs
database
audit trails
user access
database maintenance
configuration data
data flows and states
training
uml
structure diagrams
behavior diagrams
activity diagrams
use case diagram
state machine diagram
interaction diagrams
sequence diagram
communication diagram
timing diagram
interaction overview diagram
chapter 6: low level design
oo design
identifying classes
building inheritance hierarchies
refinement
generalization
hierarchy warning signs
object composition
database design
relational databases
first normal form
second normal form
third normal form
higher levels of normalization
chapter 7: development
use the right tools
hardware
network
development environment
source code control
profilers
static analysis tools
testing tools
source code formatters
refactoring tools
training
selecting algorithms
effective
efficient
predictable
simple
prepackaged
top-down design
programming tips and tricks
be alert
write for people, not the computer
comment first
write self-documenting code
keep it small
stay focused
avoid side effects
validate results
practice offensive programming
use exceptions
write exception handers first
don't repeat code
defer optimization
chapter 8: testing
testing goals
reasons bugs never die
diminishing returns
deadlines
consequences
it's too soon
usefulness
obsolescence
it's not a bug
it never ends
it's better than nothing
fixing bugs is dangerous
which bugs to fix
levels of testing
unit testing
integration testing
automated testing
component interface testing
system testing
acceptance testing
other testing categories
testing techniques
exhaustive testing
black-box testing
white-box testing
gray-box testing
testing habits
test and debug when alert
test your own code
have someone else test your code
fix your own bugs
think before you change
don't believe in magic
see what changed
fix bugs, not symptoms
test your tests
how to fix a bug
estimating number of bugs
tracking bugs found
the lincoln index
chapter 9: deployment
scope
the plan
cutover
staged deployment
gradual cutover
incremental deployment
parallel testing
deployment tasks
deployment mistakes
chapter 10: metrics
wrap party
defect analysis
kinds of bugs
discoverer
severity
time created
age at fix
task type
ishikawa diagrams
software metrics
qualities of good attributes and metrics
using metrics
process metrics
project metrics
things to measure
size normalization
function point normalization
count function point metrics
multiply by complexity factors
calculate complexity adjustment value
calculate adjusted fp
chapter 11: maintenance
maintenance costs
task categories
perfective tasks
feature improvements
new features
the second system effect
adaptive tasks
corrective tasks
preventive tasks
clarification
code reuse
improved flexibility
bug swarms
bad programming practices
individual bugs
not invented here
task execution
part ii: process models
chapter 12: predictive models
model approaches
prerequisites
predictive and adaptive
success and failure indicators
advantages and disadvantages
waterfall
waterfall with feedback
sashimi
incremental waterfall
v-model
systems development life cycle
chapter 13: iterative models
iterative versus predictive
iterative versus incremental
prototypes
types of prototypes
pros and cons
spiral
clarifications
pros and cons
unified process
pros and cons
rational unified process
cleanroom
chapter 14: rad
rad principles
james martin rad
agile
self-organizing teams
agile techniques
communication
incremental development
focus on quality
xp
xp roles
xp values
xp practices
have a customer on site
play the planning game
use standup meetings
make frequent small releases
use intuitive metaphors
keep designs simple
defer optimization
refactor when necessary
give everyone ownership of the code
use coding standards
promote generalization
use pair programming
test constantly
integrate continuously
work sustainably
use test-driven and test-first development
scrum
scrum roles
scrum sprints
planning poker
burndown
velocity
lean
lean principles
crystal
crystal clear
crystal yellow
crystal orange
feature-driven development
fdd roles
fdd phases
develop a model
build a feature list
plan by feature
design by feature
build by feature
fdd iteration milestones
agile unified process
disciplined agile delivery
dad principles
dad roles
dad phases
dynamic systems development method
dsdm phases
dsdm principles
dsdm roles
kanban
kanban principles
kanban practices
kanban board
summary
appendix: solutions to exercises
glossary
index.
Author : Rod stephens
Publication : Wrox
Isbn : 9788126555376
Store book number : 107
NRS 960.00
|
 |
|
|
|
|
|
|
|
| |
|
|
