Creating Software Programs
Creating software
programs is part science and art.
There are two aspects to software development:
-
Processes for developing software.
-
Management of the effort.
This section will also deal with debugging and delivering software programs.
Development Process
There are many aspects to software development. Historically, one approach has called for a multi-part process including:
 |
Concept Definition - describing the type of program that is desired and the resources (money, people, time) to create it. |
|
Requirements Analysis - Identifying the functional, performance, and interface characteristics of a program to be developed. |
|
Design - describe how the program will work in terms of the requirements that have been specified. Design is typically a top-down activity that starts with a broader view of a program and narrows it to very detailed functions. |
|
Implementation - creating the code based on the design. |
|
Testing - testing the program to make sure all requirements are satisfied. |
|
Delivery - creating user manuals, media, and training to bring the program to end users. |
|
Maintenance - providing updates to the program over time. |
Developers, in order to meet local software development needs, often modify this approach based on:
|
The nature of the program to be developed (how large, who will use it, anticipated value). |
|
The people who will create it (number of people, their abilities, and availability). |
This takes us back to the point that software development is part science and art. There are many tools and techniques for defining the nature and cost of software development. But in many cases, experience and hard work is critical to software development and an educated (experiential) guess is often more right than wrong.
There are a number of techniques or strategies that are used in developing software programs that are worth mentioning:
|
Rapid Prototyping - creating "very" preliminary versions of programs in the early stages (e.g., concept definition) to better understand what the final product looks like or how it might work. Prototypes are usually disposed of prior to implementation. |
|
Iterative Development - the development cycle is repeated (requirements through the testing phases) until a final product is refined. In each successive cycle, the phases take much less time to complete. |
|
Cross-Platform Development - developing software that will run on two or more different platforms (e.g., Microsoft Windows and Macintosh). |
Project Management
Key to the success of any software development project is management. Management is responsible for the allocation of resources (people, tools) based on money and time to develop a project.
Project management does not necessarily mean that the manager is intimately familiar with technologies to develop software. However, they should have a good understanding of the development process and the nature of the technologies involved.
Documentation
Documentation is a critical part of any software development process. Any software development project should include a significant set of documentation to record requirements, preserve design notes, and document testing.
Configuration Management
Configuration management is the process of tracking code and documentation. This effort is critical in maintaining and tracking versions of software in large development efforts or in the maintenance phase.
Quality Assurance
Critical to any software development project is the ability to ensure that a good (or great) product will be created. Quality assurance is responsible for making sure that:
|
Everything is documented. |
|
Everything is accounted for. |
|
Every phase is completed to satisfaction. |
Although these sound like project management functions, these are also independent functions that are undertaken to ensure success for a project.
Quality assurance is not the same as testing. Quality assurance ensures that a product meets a desired standard, that is, it works and is complete. This is called product acceptance. Testing is used to make sure every function and process works per specification, a job performed by the developer.
Debugging Software
Debugging is the process of finding and correcting errors in a program. There are a number of techniques to accomplish this including examining how the program is running (is it giving us the answer expected), or using built-in tools in the programming environment to troubleshoot problems.
Program Behavior Debugging
Examine the behavior of the program. Is it doing what is expected? If not, find out why and fix it. For example, a series of actions may be expected. By knowing the sequence, you can determine if it is not working properly.
Some programming systems, such as Visual Basic, allow you to step through a program to see how things happen. In some cases, programs do not execute the instructions in the sequence we expect. This is very true in event-driven systems, where different things such as user input or other system functions can cause events we did not anticipate. These events have to be accounted for in debugging the program.
Generally speaking, there are three types of errors that occur when developing computer programs:
-
Syntax Errors - these are usually created when the program is written and include problems such as misspelling keywords (e.g., "Dom fname as string" where "Dom" should be "Dim"). Depending on the sophistication of the development environment (e.g., Visual Basic), these errors are often identified by the environment. On the other hand, editor-based programming (e.g., writing JavaScript) does not readily indicate syntax errors until the program is running.
-
System Errors - these errors happen because files are missing, hardware devices fail (or are not present), or supporting software modules are not present. These errors are caused by a failure of the program to check for the existence of needed components (e.g. files), incomplete setup programs, or deletion or changes in supporting software modules after the software has been installed.
-
Operational or Process Errors - these are errors that happen because the program is not doing what it is supposed or expected to be doing-even though there are no other errors (e.g., syntax errors). These errors include mistakes in complex mathematics equations, errors in logic (using an "AND" instead of "OR"), or misunderstanding the original requirements of the program. These errors often require complex testing that goes back to the original requirements to ensure thoroughness.
Error Trapping
Most programming systems will halt or generate an error message if illegal actions occur such as exceeding the value range of an integer or dividing by 0. These error messages can be used to find the problem and make corrections. Typically, an error window will appear telling you where the error occurred.
Some systems, such as Visual Basic, provide a "debug" window, which allows you to check the status of variables in the program. This often provides valuable clues as to where problems are.
Program-based Error Handling
Many software environments, such as Visual Basic, allow you to use statements that tell the program what to do if an error is encountered during program execution. Some examples of this include:
|
ON ERROR RESUME NEXT - if an error is encountered, skip the error and continue processing with the next instruction. This can be risky because the program could be unstable affecting other instructions. |
|
ON ERROR GOTO <LABEL> - if an error is encountered, jump to the position in the code where the label is located. This is often used to terminate the current activity and notify the user that an error has been found, even suggesting how to fix the problem. |
Error trapping is valuable in creating programs that are user-friendly.
Delivering Applications
Finally, when you have designed, coded, and tested your application - it is time to deliver it! There are number of delivery options, depending on what kind of programming environment you have selected.
Compiling
Many software programs can be compiled to machine language for faster execution. Compilers for languages such as Visual Basic, C++, and Assembly language will actually optimize the final code to run efficiently. Generally speaking, compilers are operating system specific. You can run the program only on the system it is compiled for or compatible with.
Some programming systems (e.g., Visual Basic) will allow you to run the program in interpretive mode prior to compiling to support faster testing. Interpretive programs are often slower but may be smaller in size (although they depend on the presence of an interpreter program for execution).
Although most compilers create an executable file (it has an ".exe" extension), other supporting files such as dynamic link libraries and control files may need to be shipped with the application in order for it to run.
Web Delivery
JavaScript and VBScript are interpreted programs. The code is commonly stored in the hypertext markup language (HTML) document that is downloaded to the browser (there are also server tools for executing scripts prior to downloading). The code is read when the document is loaded and then processed. The interpreter to run the program is actually part of the browser.
One of the more frustrating aspects of web delivery is browser (and server) compatibility. Currently, VBScript runs only on Microsoft Explorer browsers and servers whereas JavaScript runs on Netscape and Microsoft browser and server products.
Document Macro (Office Applications)
Macros are similar to interpreted software programs in that they are not compiled to machine language. Macros are usually stored as part of a document. They are then executed when an interpreter run from within the parent program needs them. The parent program (e.g., word processor or spreadsheet) contains or can access the interpreter program when the macro is needed.
Macro programming for Microsoft Office actually shares a common macro language called Visual Basic for Applications (VBA) that looks, functions, and is even implemented like Visual Basic (the programming environment).