Critical Elements of the Programming Phase of a Custom Software Development Project
In the previous issues of Info Point, we discussed the following aspects of building a custom software solution:
- Hiring a software consultant.
- Ensuring a successful requirements capture process.
- Developing a system specification.
- Making a change to the system specification.
Why invest in custom software? Because your business requirements can’t be met with an off-the-shelf package. When developing a custom software application, the programming phase, when the actual code is created, is probably the most familiar part of a software development project. What specifically happens during this part of the project? Your consultants:
- Use the software and hardware identified during the design phase to develop code.
- Follow the standards, conventions, and style they identified in the system specification.
- Develop a system prototype for your review.
- Create modules that produce the features you need.
- Meet with you throughout this phase to get input into the system.
This method of creating a software application ensures that you have no surprises when your end product is delivered.
Two major components of the programming process are prototypes and modules. A system prototype or pilot system allows you to see the screens, navigation, and features of your system. Each group of related screens that automates a business function is considered a software module.
The System Prototype
The system prototype gives you an opportunity to provide feedback, which your consultants will incorporate as they continue to program. The first demonstration of the prototype might be a series of screens. The screens may not have any functionality behind them, but you and your consultants can review the screens to make sure the features, flow, and design of the screens reflect your business processes accurately.
After you approve a group of screens, the next time you see the system there may be some functionality behind the screens. This programming/feedback process is iterative, allowing you frequent opportunities to make sure the application is effective in addressing your business issues.
The prototype consists of a series of software modules. Each module should be identified during the design phase of the software project and should represent a specific feature or set of related features.
Once the software modules work individually, they must be integrated to make sure they work with each other. The integration begins before all the modules are complete so parts of the system can be tested as the various features are created. This sort of testing allows for discovery of errors early and therefore helps keep costs and schedules in check. As the modules are integrated, your custom software takes shape, and you can anticipate how your software application will help fulfill your business requirements.
Programming with modules guarantees an efficient application in a number of ways.
- Ensures Consistency. A module can be programmed so it can be re-used. This ensures that a feature looks and works the same way throughout the application. There is nothing quite as frustrating as learning how to use a particular feature only to discover that elsewhere in the system, the same feature functions differently. Programming in modules helps avoid this problem.
- Simplifies Training. Re-usable modules can also save on training costs and time. Once an employee learns how to use a particular feature, they can be assured whenever they use that feature in your custom software application, it will work the same way throughout the application.
- Enables Programming Once, Using Twice (or more). If a module can be re-used throughout the system, the module only has to be programmed once. A module used more than once saves on programming time and therefore keeps the cost of the application down.
- Facilitates Change. Modules make changes easier. You may find you need to make a change before the system has been completed. Any change will impact the cost and schedule of a software development project, increasing both. However, if custom software is programmed in modules, the impact may be minimized. If a change affects a single module, that module can be changed without requiring changes to other modules in the system. Or if a change requires addition or removal of a feature, if the feature is described by a single module, the module can be added or removed without affecting the rest of the system.
Three Advantages of Custom Software
Following this iterative, modular approach to custom software development, your final product should be an application that automates your business needs and provides the following advantages:
- You don’t have change the way you do business to fit pre-packaged software.
- As your business grows, you may find you need to make changes to your application to accommodate new customers, products, or business rules. Modular programming simplifies change.
- A custom built, modular system helps your business be flexible so it can meet future demands and opportunities.
The programming phase of a software development project can be exciting because you:
- See what your custom software will look like.
- Visualize how the functionality behind each feature matches your business objectives.
- Work with the developers to make sure the system meets your business goals.
- Envision how the application will make your current work processes more efficient.
Custom software can be the key to ensuring your business remains competitive.