10 Important Points of Software Development

Thursday, May 31, 2001
By keiji
Software Engineering Methodology is strongly needed to improve software development process. It provides a framework and a way of thinking to develop software.
Here is the ten most important points of software development.
I have listed here the ten points of software engineering discipline most important to creating high quality software and to managing the development process well. These are based on my research in software engineering. I believe we should keep these in mind as software engineers.

1. Computer Ethics
First of all, what is our responsibility as software engineers? What is a professional software engineer? Software developers have to have guidelines as professionals. These should provide standard for people personally or on an organizational level. There are two major guidelines provided by distinguished organizations. They are:
Please recognize that every person has a different concept and view of software development, therefore, there could be things that you don't agree with above codes. However, it is important for a company to have an explicit policy so that all employees can work from a common foundation.

2. Individual Variation
The productivity of skilled, experienced developers is more than ten times higher than inexperienced developers in every aspect of development. The "Chief Programmer" development method is recommended for fast and solid development. It is similar to a surgical team or an owner-chef. The person who has enough ability to do the task should have full responsibility of decision making power for the task.
I believe in two facts:

  1. Programming is both an art and a science, thus requires innate ability as well as concentrated study.
  2. Mastering a programming language is as hard as mastering a foreign language. Only with continuous effort can one gain the ability to use the language freely.

We should appreciate a person who has strong skills and ability in both design and programming.

3. Software Development Process Lifecycle
An incremental, iterative, and evolutional process is recommended.

Software Development Process

Problems of the traditional Waterfall Model are as follows

  1. It is based on the impossible assumption that each phase can be done 100% before the next phase.
    It also usually inhibits going back to a previous phase.
  2. It throws risks to the end of the project.
    Process of testing and fixing problems later in the project cost much more than fixing problems earlier.

Waterfall Model

Risks in Waterfall Model

It's too late to fix risks later in the project.
The Spiral Model is an improved process.

Risks in Spiral Model

It is much better than the Waterfall Model in keeping the course of development direction, but still has some risks.

The Agile/XP Model's short process could be much better than the above models, regarding risk avoidance.

Risks in Agile/XP Model

Even though the Agile/XP Model seems to be keeping up the requirement direction, it is always important to understand a long-range real goal of the system, which can take a longer period of time in development and contemplation. I believe something between the Spiral Model and Agile Model, depending on the project, will be the best choice.

Please note that even though this Agile/XP Model's short incremental/iteration could reduce the risks, it is valid only if it comes with other disciplines described here. There is no excuse for not having design and documentation.

4. Project Management
It is obvious that a typical Waterfall Model has flaws; especially that of throwing risks to the end of the project. The most important purpose of process management is to find risks as early as possible, and manage them well. The most important points to consider in process management are as follows:
  • Risk Management: Be aware of potential risks. Create a list of top 10 risks every week and assign a risk officer to be in charge of notifying team members of risks.
  • Change Control: If you are not controlling the changes, you are not controlling the project. Use software which can manage change control, such as source control, software defect tracking software.
  • Defect-cost graph: The later a problem is found, the more it costs.
  • Cone of uncertainty: The uncertainty of estimation is high at the beginning of a project; it becomes lower at the later phase of the project. If we can decrease the uncertainty in the early phase, the risk can be reduced.

5. Documentation
Regardless of the project size, we should create a document. Following documents might be useful for most projects:
  • A project charter
  • Requirement, including UI design
  • System Design, Business Analysis
  • Well refactored code, Unit Tests Suite
  • Test Plan, Test Case Design, Test Cases

6. Quality Assurance (QA) and Configuration Management (CM)
Quality assurance and Configuration Management are activities constantly done throughout the development process. A QA should be well integrated into the process. Some key topics in QA:
  1. Understanding "verification" and "validation" is important.
    According to the IEEE Definition:
    1. Validation: "Confirmation by examination and provisions of objective evidence that the particular requirements for a specific intended use are fulfilled."
    2. Verification: "Confirmation by examination and provisions of objective evidence that specified requirements have been fulfilled."
  2. Regression testing is an important way to make sure the overall system works OK when some parts of the system are changed. (Regression testing should be automated as it is often needed to run many times.)

7. Human-Computer Interaction / Usability Engineering
Easy-to-use is does not necessarily mean easy-to-implement. Knowledge of the Human Factor, Psychology, Cognitive Science, and Behavioral science could be a great help in understanding the user's point of view. To accomplish high usability:
  1. Design user interface at a requirement analysis phase. Developing a prototype is helpful.
  2. Design and implementation need to have strong cooperation between them because implementing complex components to increase usability requires strong programming skills.

8. Requirement Analysis / Software Design
Prototyping is a good tool to clarify requirements and to communicate with a customer. "Use Case" and "Scenario-driven" design must be introduced in systems development. Visual Design / User Interface Design should be a part of this phase.

Design has two aspects:
  1. Design process: use/reuse design pattern.
  2. Design representation: Unified Modeling Language (UML) is now a standard modeling language. Any kind of visual presentation of the system design helps people understand the overall architecture and systems' behavior.

9. Software Construction / Testing
Some important points about software implementation:

  1. Programming is an art. We should admit that to acquire a high skill in programming takes a long time. The difference in productivity and quality of programs is more than ten fold between a novice and an expert in programming. Train and develop programming skills.
  2. Programmers should follow such software development management practices as change management, coding standards, and documentation.
  3. A strong and well-designed class library is a key to the success of a high quality software.
  4. Refactoring is an important skill for all programmers.
  5. Design unit tests before coding and write unit tests at the same time as coding functions.
  6. An interface between subsystems is important for the systems' future. All systems must have a programmable interface to be controlled by other systems.
  7. Applications must output log files to track processing status. The log files must contain information of not only error status, but also normal processing status, for future analysis.

Writing a test case is also important when designing and coding.

  1. A unit test is the most important method of testing.
  2. Write a test when designing.
  3. Write a test when coding.

Actually, testing should be done before and at the time of implementation. A programmer should write unit tests and code simultaneously. Without a unit test, how can you guarantee your code? So, all features/functions should have self-testing codes.

10. Deployment
This includes the user's manual, training, and installing.
  1. The user's manual can be incorporated as part of a design document.
  2. Creating a setup program and testing installation could take longer than expected. Prepare early.
  3. Automate deployment: Try to create a mechanism to deploy a system automatically. You can reuse it, and it reduces the risk of human error.

  • Brooks, JR., Frederick P. the Mythical Man-Month. Addison-Wesley, 1995, ISBN:0201835959
  • McConnel, Steve. Software Project Survival Guide. Microsoft Press, 1997. ISBN:1572316217
  • Royce, Walker. Software Project Management: A Unified Framework. Addison Wesley, 1998, ISBN:0201309580
  • Beck, Kent. Extreme Programming explained: Embrace Change. Addison-Wesley, 2000. ISBN:0201616416
  • Hunt, Andrew. Thomas, David. The Pragmatic Programmer. Addison-Wesley, 2000. ISBN:020161622X
  • Fowler, Martin. Refactoring: Improving the Design of Existing Code. Addison-Wesley, 2000. ISBN:0201485672