Talk:Software development process/Archive

This is an archive of material deleted during the merge of Software development process with Software development life cycle and Software development cycle. It (likely) needs to be moved elsewhere; if sufficient time passes without such a move, this article can be safely deleted. --David.alex.lamb 13:34, 23 February 2006 (UTC)

programming paradigms
Some paradigms for programming software: --David.alex.lamb 00:31, 23 February 2006 (UTC)
 * Procedural programming
 * Structured programming
 * Imperative programming
 * Declarative programming
 * Functional programming
 * Literate programming
 * Object oriented programming
 * Aspect oriented programming
 * Concurrent programming
 * Component-oriented programming
 * Interactive programming

Material from Software development life cycle; might go in main article or somewhere else. --David.alex.lamb 21:25, 23 February 2006 (UTC)

End-User Development (EUD)
In this model, software is developed and maintained by the end users themselves. Businesses rarely have controls over software developed with this model, and it is often developed without a formal framework.


 * Errors from faulty design and implementation
 * Problems with business users leaving and incomplete knowledge transfer
 * Inconsistant firm wide tools and techniques
 * Unknown dependencies, both upstream and downstream

Material from Software development cycle, to be merged with Waterfall model. --David.alex.lamb 13:54, 23 February 2006 (UTC)

Introduction
The software development cycle is a software project management theory saying that software is developed in five phases. Each phase is dependent upon completion of the previous one, though during subsequent phases alterations to previous phases can and should be made at the earliest point possible. The rationale for using the software development cycle for software project management is often compared to constructing different building types.

The Doghouse Approach:
When you build a doghouse, the needs are pretty basic and easy to understand. The risk for failure is low, and the cost is low. In the worst situation, your dog would have a poorly built doghouse with maybe a leaky roof and unevenly spaced walls. Since the doghouse is so simple, there is little or no maintenance requirements. It would be considered overkill to carefully draw up blueprints for a doghouse, but having blueprints or any plan at all would be better then not having them. This approach can be applied to software development for the very small projects which take little time, effort and money to build.

The House Approach:
If you decide to build your own house, it would be foolish to just start building somewhere without any plan at all. A proper foundation needs to be located and laid, an architect needs to be hired to draw the blue prints, electritions and plumbers need to be found, laborers to build the house, suppliers for materials, building inspectors, finding a good construction manager, setting a timeline and goals, staying within budget, etc. The intricacies of a house are much greater then a doghouse. Unless you are filthy rich, the cost of failure in building a house would be very bad. While a dog might tolerate a leaky roof or uneven walls, your family wouldn't and neither would the future home-buyer. Much like building a house, mid-sized software development projects have the same level of risks involved. You need to take in many more considerations

The Multi-Story Office Building Approach:
Much like building a house, but the cost and risks for failure are much greater. The Project Manager needs to keep close track of many different pieces of a project to make sure that things are running seamlessly. A delay of a shipment of steel or concrete could push back the timeline for the entire project, and at the worst, cause a breach of contract with the client. Large software development projects put heavy emphasis in the five phase development cycle and use experienced project managers (hopefully).

Development Cycle
1. Requirements and Specifications

2. Design

3. Development

4. Implementation

5. Maintenance

1. Requirements analysis Phase
This phase involves the three pillars of successful software project development: Time,Budget, Specifications. This is the step where a client/user, software systems designer and software project manager would create the initial design document, determine the objectives, set the mission/vision, estimate the required budget for the project (or submit a bid), and set a timeline for development. This is also where the method for payment of the project is determined (payment per milestone or on project completion), and contracts are signed.

2. Design phase
This could also be called the "planning phase" where the foundation of the software details and functionality is specified in a design document. This is where you'd also take into consideration technical considerations about the differing methods of implementation. The importance on the attention to detail and thoroughness cannot be over-emphasised for this step. A software project will become exponentially more difficult to develop and manage if the planning is poorly implemented.

Many books compare this crucial step to getting the blue prints to a building construction project.

3. Developing and unit testing phase
During the developing and unit testing phase separate components are constructed and tested according to the design document. Programmers write the code, artists create the artwork and design, database admins create the database structure, etc. This phase takes the longest amount of time, and most prone to causing delays, setbacks, or complete project failure. The time this phase will take is the time you expect it to take, multiplied by three.

4. Integration and system testing
The entire application is implemented as a solution (installed) and tested. This can be something as simple as installing software on one machine, or as complicated as installing software on many machines and configuring them to work together. Integration and system testing involve putting the separate components together and developing & testing the entire system until it is operational.

5. Maintenance
The last phase involves maintaining, upgrading and expanding the system after it has been released. This includes providing a website, user manual, drivers etc. When it is determined that the software needs to be updated, the software developers will return to the first step and start working the development cycle again.