David Hooker $[$Hoo$96]$ has proposed seven principles that focus on

software engineering practice as a whole. They are reproduced in the

following paragraphs:$10$

The First Principle: The Reason It All Exists

A software system exists for one reason: to provide value to its users. All

decisions should be made with this in mind. Before specifying a system

requirement, before noting a piece of system functionality, before determining

the hardware platforms or development processes, ask yourself questions

such as: $$Does this add real value to the system?$$ If the answer is no$,$ don$$t

do it$.$ All other principles support this one.

The Second Principle: KISS $($Keep It Simple, Stupid!$)$

There are many factors to consider in any design effort. All design should

be as simple as possible, but no simpler. This facilitates having a more

easily understood and easily maintained system. This is not to say that

features should be discarded in the name of simplicity. Indeed, the more

elegant designs are usually the simpler ones. Simple does not mean $$quick

and dirty.$$ It often takes a lot of thought and work over multiple iterations to

simplify the design. The payoff is software that is more maintainable and less

error$-$prone.

The Third Principle: Maintain the Vision

A clear vision is essential to the success of a software project. Without

conceptual integrity, a system threatens to become a patchwork of

incompatible designs, held together by the wrong kind of screws $...$

Compromising the architectural vision of a software system weakens and

will eventually break even the well$-$designed systems. Having an empowered

architect who can hold the vision and enforce compliance helps ensure a

very successful software project.

The Fourth Principle: What You Produce, Others Will

Consume

Page $15$

Always specify, design, document, and implement knowing someone else

will have to understand what you are doing. The audience for any product

of software development is potentially large. Specify with an eye to the

users. Design, keeping the implementers in mind. Code with concern for

those that must maintain and extend the system. Someone may have to debug

the code you write, and that makes them a user of your code. Making their job

easier adds value to the system.

The Fifth Principle: Be Open to the Future

In today$$s computing environments, where specifications change on a

moment$$s notice and hardware platforms are obsolete just a few months old,

software lifetimes are typically measured in months instead of years.

However, true $$industrial$-$strength$$ software systems must endure far longer.

To do this, systems must be ready to adapt to these and other changes.

Systems that do this successfully have been designed this way from the start.

Never design yourself into a corner. Always ask $$what if$,$ and prepare for

all possible answers by creating systems that solve the general problem, not

just the specific one$\mathrm{.}11$

The Sixth Principle: Plan Ahead for Reuse

Reuse saves time and effort$\mathrm{.}12$ Achieving a high level of reuse is arguably

the hardest goal to accomplish in developing a software system. The reuse of

code and designs has been proclaimed as a major benefit of using object$-$

oriented technologies. However, the return on this investment is not

automatic. Planning ahead for reuse reduces the cost and increases the

value of both the reusable components and the systems into which they are

incorporated.

The Seventh Principle: Think!

This last principle is probably the most overlooked. Placing clear,

complete thought before action almost always produces better results.

When you think about something, you are more likely to do it right. You also

gain knowledge about how to do it right again. If you do think about

something and still do it wrong, it becomes a valuable experience. A side

effect of thinking is learning to recognize when you don$$t know something, at

Page $16$

which point you can research the answer. When clear thought has gone into a

system, value comes out. Applying the first six principles requires intense

thought, for which the potential rewards are enormous.

If every software engineer and every software team simply followed

Hooker$$s seven principles, many of the difficulties we experience in building

complex computer$-$based systems would be eliminated.

$1\mathrm{.}5$ H