Home > Articles > Software Development & Management > Management: Lifecycle, Project, Team

Ten Commandments of Successful Software Development

  • Print
  • + Share This
While not inscribed in stone tablets, these rules provide detailed suggestions on how to streamline and improve your software development organization for greater success.
Marc Hamilton is the author of Software Development: Building Reliable Systems (Prentice Hall PTR, 1999, ISBN 0-13-081246-3).
From the author of

All great organizations have a vision, a mission, and elemental guidelines for proper behavior that are infused into their people. Perhaps the oldest code of conduct is the Ten Commandments. Since the day Moses stumbled off Mount Sinai, people have applied the idea of condensing their groups' rules into 10 easy-to-remember sentences. Following the lead of Moses, we've distilled the successful software development concept into 10 commandments. If you want to be consistently successful at software development, be sure you always embrace these 10 ideals:

  1. Start development with software requirements.

  2. Honor your users and communicate with them often.

  3. Don't allow unwarranted requirements changes.

  4. Invest up front in software architecture.

  5. Don't confuse products with standards.

  6. Recognize and retain your top talent.

  7. Understand object-oriented technology.

  8. Design web-centric applications and reusable components.

  9. Plan for change.

  10. Implement and always adhere to a production acceptance process.

1: Start Development with Software Requirements

Every morning, some software developer wakes up with a great new idea for a software application, utility, or tool. Those who go off and start writing code without first considering the requirements for their program are likely doomed to failure. Invest up front in developing your software requirements, and you'll be starting down the path to successful software development. A software development organization without any requirements-management process in place will not achieve repeated development success. Here are some tips as to why and how you should develop and manage software requirements for any project, regardless of size.

For starters, if you can't define the requirements for your software system, you'll never be able to measure the success of your development effort. If you were to write a calculator program, would it be successful if it could add two numbers and produce the correct result? What about subtraction, multiplication, and division? Does the calculator need to handle floating-point numbers or just integers? How many digits of precision are needed in results? What should the calculator's behavior be if a "divide by zero" error is encountered? Should results be displayed in a textual or graphical format? How long does the result have to be saved after it's displayed? The list goes on. Even in this trivial example, requirements are extremely important to determining the success of the project.

It's very difficult to write good software requirements. Without good requirements that state precisely what a software program is suppose to accomplish, it's difficult to complete the project, much less judge the application's success. One of the main reasons that it's hard to write good software requirements has to do with the nature of human language. Spoken language is very imprecise and leaves much to be inferred by the listener or reader. Computers, by their digital nature, are very precise and not easily programmed to infer missing requirements. Therein lies a dichotomy. Think of a requirements statement as simple as "the program will add two numbers and display the results." You could raise all the same questions posed in the calculator example in the last paragraph. Even if these questions were answered, more requirements would probably be uncovered during development of the application.

If your software development team asks questions like those in the calculator example, it's probably a good sign. There is no surer road to failure of a software development project than incomplete requirements. Of course, the next steps after asking questions and developing requirements are to documenting, organizing, and tracking functions that help you do this.

Many development projects actually start with a good set of functionality requirements—input this, perform this processing, output that. Often left out, however, are performance and other environmental requirements as summarized in Table 1. How quickly does the program have to complete the required processing?

Table 1 Commonly Overlooked Performance and Environmental Requirements

Requirements

Example(s)

Processing speed

CPU speed

Memory capacity

Cache size, RAM size

Network capacity

Network interface card speed, switch/router bandwidth

Persistent storage

Online disk capacity; tape backup capacity

Internationalization support

Application deployed in multiple countries or languages

Display

Minimum monitor size and resolution; number of colors supported

Financial issues

Budget and schedule

Environmental issues

Power requirements, air conditioning, special temperature or humidity requirements


How much RAM or disk space can it use? Does the software have to support internationalization for worldwide use? What's the minimum display size required? Environment-related requirements are becoming increasingly important, especially with the advent of cross-platform development environments such as Java. Java truly provides a write-once-run-anywhere environment, ranging from smartcards to workstations to mainframes. A Java applet that looks great on a workstation's 21-inch color monitor, however, may look much different on the 4-inch screen of a monochrome personal digital assistant (PDA). Finally, don't forget budget and schedule requirements.

In gathering these requirements, the reasons for the second commandments should become very clear.

  • + Share This
  • 🔖 Save To Your Account