Developing Overview

Modern software typically consists of a series of components that interact with each other to perform the tasks that are required to implement the application. Development involves creating these components by writing source code in one of the many languages that are available. This code defines the fundamental individual actions that the computer will carry out to achieve the end result that is specified in the design of the application. These actions may be as simple as adding numbers together, setting values of the objects inside the components, or executing different parts of the code based on a comparison of the values of variables that are defined in the code. It may also involve more complex mathematical calculations within the code, and the application of logic operations to generate the required results. Other activities that development involves include debugging the code to locate and fix errors; tracking work using formal methodologies; working with shared code repositories; and participating in design, planning, feedback, and code review meetings.

This document describes developing tasks in the context of the lifecycle of creating software. It will help you to understand what development responsibilities include, the broad goals, and the processes carried out. Figure 1 shows an overview of the typical lifecycle for developing software.

Figure 1. The software development lifecycle

The process of creating software encompasses a wide range of tasks; from the original design through to final deployment and customer acceptance. The primary job during development is to translate the original design into working code using tools such as Microsoft Visual Studio and languages such as Visual Basic, C#, and JavaScript. However, it typically includes some involvement throughout the whole software development lifecycle - especially when working alone or in a very small team (in which case you’ll be often be doing a combination development, testing, and architecting tasks). The following sections describe the primary tasks of development within the software lifecycle.

Review Customer Input and the Goals of the Project

The first task in the creation of a software application is to capture information and generate the high-level design based on the customer's requirements. As the high-level design is translated into more specific and more technically focused documentation, technical implementation input is required to provide feedback about the capabilities of the hardware and the practical implementation of the design. This can help to avoid surprises later, and ensures that the final design for the software is capable of being implemented in a reasonable time and on the available hardware and infrastructure.

Write Code for Components

This is the core activity of development, and the activity that drives the whole software creation process. The person creating the code will use a specification or list of requirements that describe what a component or section of the application must do, the results it must generate, and the way that it will communicate with other parts of the application. This specification may be in one of many different forms such as models written in a standard modeling language, descriptions of functionality, or just diagrams on a whiteboard.

During development, the functions of the chosen programming language are used to create source code files containing the required series of instructions that the computer will execute. Basically, this code will take in a set of input values, perform some processing with these values, and output the results. It may make use of other components and functions within the software to achieve this, and may also make use of libraries of code and functions that were written by the team or obtained from third party suppliers. The development tools and environments used, such as Microsoft Visual Studio (shown in Figure 2), can help to make writing code easier by suggesting the names of objects and variables, checking the syntax to ensure it will compile successfully, and indicating errors.

Figure 2. Microsoft Visual Studio 2010 development environment

Code Review with Team Members

For any section of code that developers write, there is rarely only a single correct solution. The skills of a developer are in using the features and capabilities of code languages to construct code that performs the required task, and there may be many different ways to achieve this. Different developers may use subtly different approaches and different combinations of code instructions.

A review of the code by peers and managers performs two vital tasks. Firstly, it brings together the views and opinions of several developers who may offer alternative approaches, point out unnoticed errors, or suggest improvements to the code. This helps to optimize code efficiency and performance. Secondly, it helps to broaden the knowledge of all of the team members by sharing expertise, which improves the performance of the entire team over time.

Compile and Test the Code

Depending on the code language used, development involves compiling the source code to convert it into a form that the computer can execute. Usually the development tools and environments will perform this task. A team member (typically the initial creator, then testers) then runs the code to ensure that it works as it should. If the team uses a Test Driven Design (TDD) approach, a team member will previously have written unit tests that can be executed to ensure that the code performs correctly and generates the required results.

Compiling, running, and testing the code is an iterative process that takes place as the code is created. Typically the basic minimum code is created first to test the concept, ensure that it compiles and runs, and then code is progressively added or updated to maximize the performance and efficiency while confirming that it generates the correct results.

Check-in and Update the Code Repository

Most medium and large projects use a team information and code repository system such as Team Foundation Server (TFS) to store code, documents, and information about the project. The developer checks in the code he or she created so that it is part of the overall project and can be compiled into the complete solution during the regular builds. Typically these builds take place daily, and the test team works with the new build each day to confirm that existing reported faults have been resolved, and to locate any new faults.

The repository will usually include work items and reports. The developer updates work items relevant to the code created, marks the work items for faults that have been resolved, and adds other information relevant to the task that will be useful to other team members, including the test team, and the documentation team. The team can run reports based on these work items to monitor progress on the project and discover any ongoing issues. Figure 3 shows Microsoft Visual Studio Team Foundation Server.

Figure 3, Microsoft Team Foundation Server code and work item reporting

Implement Changes and Debug and Fix Errors

If the testing results in faults being reported in the code, a developer must go back and find the cause of these faults, then change the code to resolve them. Debugging is the task of locating the source of errors, which may be caused anywhere in the code and only be surfaced at the point discovered during testing. Debugging is sometimes thought of as a "black art" because it requires experience as well as a logical approach, especially if the fault only appears intermittently or is hard to reproduce.

However, modern tools and development environments such as Visual Studio include features that allow team members to step through the code looking at the values in the variables, and watching how they change. This makes locating faults a much easier and a more logical process. Other features and tools that provide a list of the code procedures that are executing, and the way that the computer processor is handling them, help the team to locate errors. In addition, the team may add instrumentation (such as code to write events to log files) that will monitor the code as it runs and help to locate faults.

It is also common during acceptance testing for the customer to request changes to features of the application in order to fine tune the software exactly to their requirements. The developer will implement these changes, usually based on a review of requirements and a detailed study of the impact that these changes may have on the rest of the software. A good original design that correctly separates the responsibilities of each component will make it easier to implement changes without affecting other parts of the application.

The software development lifecycle is an iterative process, and so many of the tasks described are repeated as development proceeds. For example, during development the team may create several part-completed versions of the software or components and then improve or change them based on test results and customer feedback.

Working as Part of a Team

Some developers work alone or in small groups, while others work in large organized teams. As an individual or in a small team, the developer may be responsible for all of the tasks in the development lifecycle; including design, testing, deployment, and maintenance. In large teams there are usually separate groups responsible for design, testing, deployment, and maintenance; and so the developer will focus more on the core task of writing code.

Larger teams usually operate in a structured way in order to manage and monitor the development lifecycle and the development process. There are many different approaches to managing software development in a team, including the traditional design-driven cycle based on preplanned tasks that follow one another (the "waterfall" approach) and the more feedback-oriented approach where planning runs in parallel with development tasks based on regular customer input (the "agile" approach). Figure 4 shows these two main approaches to software development.

Figure 4. Comparison of "waterfall" and "agile" development processes

Irrespective of the development approach used, good communication between members of the team members and the project managers is essential. While many teams are located in a single place, it is increasingly common for teams to include members geographically located elsewhere, and meetings will use phone and video conferencing facilities. Regular scheduled meetings attended by all the members of the team, including developers, software designers (architects), testers, and project management are used to discuss progress, to plan activities, and to receive feedback from other team members and customers. This ensures that developers are well informed about the inevitable evolution of the software design, and can act on the regular feedback that may affect the implementation of the software.

Summary

Working on software development is an interesting if challenging job that can be hugely rewarding. It requires a logical mind and a structured approach, and involves many tasks not directly related to just learning code languages. There is always something new to learn, some new requirement that requires research, and some new technology to experiment with. The rewards are in seeing the final software application working, and knowing that you had a part to play in achieving this. It is software that is shaping our modern world and, as a software creator, you can influence the future.