Understand the problem.
t’s occasionally diffi cult to admit, but utmost of us suffer
. from hubris when we ’re presented with a problem. We hear for a many second
and also suppose, Oh yeah, I understand, let’s progeny on with working this thing. Unfortunately, understanding is n’t always that easy. It’s worth spending a little tim
answering a many simple question
• Who has a stake in the result to the problem? That is, who are th
. stakeholders
• What are the unknowns? What data, functions, and features are neede
. to duly break the problem
• Can the problem be compartmented? Is it possible to represent lowe
problems that may be easier to understand
• Can the problem be represented graphically? Can an analysis model b
created
Plan the result. Now you understand the problem (or so you suppose), and yo
. ca n’t stay to begin rendering. Before you do, decelerate down just a bit and do a littl
. desig
• Have you seen analogous problems before? Are there patterns that are recognizable in a implicit result? Is there being software that implement
the data, functions, and features that are needed
. • Has a analogous problem been answered? If so, are rudiments of the resul
. applicable
• Can subproblems be defi ned? If so, are results readily apparent for th
. subproblems
• Can you represent a result in a manner that leads to effective perpetration? Can a design model be created
Carry out the plan. The design you ’ve created serves as a road chart for the system you want to make. There may be unanticipated divergences, and it’s possible tha
. you ’ll discover an indeed better route as you go, but the “ plan” will allow you t
. do without getting lost
.ot??e?t?sneu?e?r?d?esesdo without getting lost.
• Does the result conform to the plan? Is source law traceable to the design model?
• Is each element part of the result provably correct? Has the design
and law been reviewed, or better, have correctness attestations been applied
. to the algorithm?
uote
“ There’s a grain
of discovery in the
result of any
problem.”
George Polya
The most important
element of problem
understanding is
listening.
pre22126_ch02_014-028. indd 20re22126_ch02_014-028. indd2013/12/ 13 610 PM3/12/13 610 PM
CHAPTER 2 SOFTWARE ENGINEERING 21
Examine the result. You ca n’t be sure that your result is perfect, but you can
. be sure that you ’ve designed a suffi cient number of tests to uncover as numerous
crimes as possible.
• Is it possible to test each element part of the result? Has a reasonable
testing strategy been enforced?
• Does the result produce results that conform to the data, functions, and
. features that are needed? Has the software been validated against all
stakeholder conditions?
It should n’t surprise you that important of this approach is common sense. In fact,
. it’s reasonable to state that a firm approach to software engineering
will noway lead you amiss.
2.3.2 General Principles
The wordbook defi nes the word principle as “ an important beginning law or
supposition needed in a system of study.” Throughout this book we ’ll bandy principles at numerous different situations of abstraction. Some concentrate on software
engineering as a whole, others consider a specifi c general frame exertion
. (e.g., communication), and still others concentrate on software engineering conduct (e.g.,
. architectural design) or specialized tasks (e.g., write a operation script). Anyhow
of their position of focus, principles help you establish a mind- set for solid software
. engineering practice. They’re important for that reason.
David Hooker (Hoo96) has proposed seven principles that concentrate on software engineering practice as a whole. They’re reproduced in the following paragraphs 5
The First Principle The Reason It All Exists he Reason It All Exists
A software system exists for one reason to give value to its druggies. All
opinions should be made with this in mind. Before specifying a system demand, before noting a piece of system functionality, before determining
. the tackle platforms or development processes, ask yourself questions similar
. as “ Does this add real value to the system?” If the answer is no, do n’t do it. All
other principles support this bone.
The Alternate Principle KISS ( Keep It Simple, Stupid!) ISS ( Keep It Simple, Stupid!)
. Software design isn’t a erratic process. There are numerous factors to consider in any design trouble. All design should be as simple as possible, but no
. simpler. This facilitates having a more fluently understood and fluently maintained
system. This isn’t to say that features, indeed internal features, should be discarded in the name of simplicity. Indeed, the further elegant designs are generally
. the more simple bones. Simple also doesn’t mean “ quick and dirty.” In fact, it
.5 Reproduced with authorization of the author (Hoo96). Hooker defi nes patterns for these principles at http//c2.com/cgi/wiki?SevenPrinciplesOfSoftwareDevelopment.
Before beginning a
software design, be
. sure the software has
a business purpose
and that druggies perceive
value in it.
uote
“ There’s a
certain majesty in
simplicity which is
far over all the
quaintness of wit.”
Alexander Pope
(1688 – 1744)
pre22126_ch02_014-028. indd 21re22126_ch02_014-028. indd2113/12/ 13 610 PM3/12/13 610 PM
22 CHAPTER 2 SOFTWARE ENGINEERING
frequently takes a lot of study and work over multiple duplications to simplify. The
lucre is software that’s further justifiable and less error-prone.
The Third Principle Maintain the Vision aintain the Vision
A clear vision is essential to the success of a software design. Without one, a
. design nearly continually ends up being “ of two (or further) minds” about itself.
Without abstract integrity, a system threatens to come a patchwork of inharmonious designs, held together by the wrong kind of screws… Compromising the
. software systems must endure far longer. To do this successfully, these systems must be ready to acclimatize to these and other changes. Systems that do this
