Characteristics of software

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


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?


“ There’s a grain

of discovery in the

result of any


George Polya

The most important

element of problem

understanding is


pre22126_ch02_014-028. indd 20re22126_ch02_014-028. indd2013/12/ 13 610 PM3/12/13 610 PM


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//

Before beginning a

software design, be

. sure the software has

a business purpose

and that druggies perceive

value in it.


“ 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


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


Leave A Reply

Your email address will not be published.