ASP.NET - Query - Asked By on 02-Aug-11 03:03 AM

Can anyone tell me software development life cycle?
Ravi S replied to on 02-Aug-11 03:04 AM

The software development life cycle (SDLC) is the entire process of formal, logical steps taken to develop a software, the SDLC is basically the part of process in which coding/programming is applied to the problem being solved by the existing or planned application. product. Within the broader context of

The phases of SDLC can vary somewhat but generally include the following:

  • conceptualization;
  • and cost/benefits analysis;
  • detailed specification of the software requirements;
  • software design;
  • programming;
  • user and technical training; and
  • maintenance.

There are many methodologies or models that can be used to guide the software development lifecycle either as a core model to the SDLC or as a complementary method. These include:

  • rapid application development (RAD) (;
  • the linear or waterfall model (which was the original SDLC method);
  • joint application development (JAD);
  • the iterative model;
  • the v-model;
  • the prototyping model;
  • the fountain model;
  • the spiral model;
  • build and fix; and
  • synchronize-and-stabilize.
Ravi S replied to on 02-Aug-11 03:05 AM

Software Development Life Cycle – WATERFALL

Software Development Life Cycle - Waterfall Model

The waterfall model is a sequential design process comprised of several steps, each of which must be completed before the next starts.
  1. System/Information Engineering and Modeling
    Requirements are established for each component in the system, and the team decides which requirements will be fullfilled by the software. This is necessary when the application must interact with other resources. Once the ideal system is designed according to the requirements, work proceeds to the next step.
  2. Software Requirement Analysis
    Software Requirement Analysis is also known as a feasibility study. The development team analyzes the customers’ requirements, looking at the need for possible software automation.Then, the development team creates a document that holds specific recommendations for the customer’s system. This document includes details like personnel assignments, costs of the system, project schedule and target dates.
  3. System Analysis and Design
    Here, the process and the application’s structure are defined. If client/server technology is to be used, this step will specify elements like number of tiers required for the package architecture, and the database design. Then, the development team will create a software development model. This is a crucial step; any fault in the design phase could be very expensive to fix later.
  4. Code Generation
    In this phase, the actual application code is created. using high level programming languages like C, C++, Pascal and Java. The programming language is chosen according to the type of application, as well as the application requirements.
  5. Testing
    Several different testing methods are available to reveal errors and defects that were created during the previous phases.
  6. Maintenance
    Maintenance is performed after the application is delivered to the customer. Changes can occur due to changing customer requirements or new, unexpected input into the system. The application should be designed to accommodate changes that could be happen after development is complete.

refer the links also
Jitendra Faye replied to on 02-Aug-11 03:05 AM
Follow this link-
Reena Jain replied to on 02-Aug-11 03:09 AM

oftware development consisted of a programmer writing code to solve a problem or automate a procedure. Nowadays, systems are so big and complex that teams of architects, analysts, programmers, testers and users must work together to create the millions of lines of custom-written code that drive our enterprises.
To manage this, a number of system development life cycle (SDLC) models have been created: waterfall, fountain, spiral, build and fix, rapid prototyping, incremental, and synchronize and stabilize.

The oldest of these, and the best known, is the waterfall: a sequence of stages in which the output of each stage becomes the input for the next. These stages can be characterized and divided up in different ways, including the following:

  • Project planning, feasibility study: Establishes a high-level view of the intended project and determines its goals.
  • Systems analysis, requirements definition: Refines project goals into defined functions and operation of the intended application. Analyzes end-user information needs.
  • Systems design: Describes desired features and operations in detail, including screen layouts, business rules, process diagrams, pseudocode and other documentation.
  • Implementation: The real code is written here.
  • Integration and testing: Brings all the pieces together into a special testing environment, then checks for errors, bugs and interoperability.
  • Acceptance, installation, deployment: The final stage of initial development, where the software is put into production and runs actual business.
  • Maintenance: What happens during the rest of the software's life: changes, correction, additions, moves to a different computing platform and more. This, the least glamorous and perhaps most important step of all, goes on seemingly forever.
for more information check this
Anoop S replied to on 02-Aug-11 03:13 AM
When a Software Company undertakes a project right from the collection of Requirements gathering, designing, architecture, developing, testing, maintenance there are  different processes which the company carries out in different models,  This is called SDLC(Software Development Life Cycle)

SDLC is the process of developing information systems through investigation, analysis, design, implementation and maintenance. SDLC is also known as information systems development or application development. SDLC is a systems approach to problem solving and is made up of several phases, each comprised of multiple steps:
  • The software concept - identifies and defines a need for the new system
  • A requirements analysis - analyzes the information needs of the  end users
  • The architectural design - creates a blueprint for the design with the necessary specifications for the hardware software, people and data resources
  • Coding and debugging - creates and programs the final system
  • System testing - evaluates the system's actual functionality in relation to expected or intended functionality.

SDLC (Software Development Life Cycle) is the process of developing software through business needs, analysis, design, implementation and maintenance. Software has to go through various phases before it is born which are as follows:

(i)Generating a Concept – A concept comes from the users of the software. For example, a Pizza Hut may need software to sell pizza.

An Indian store may need software to sell its newly arrived movies or grocery. The owner of the company feels that he needs software that would help him in tracking his expenses and income as well as enhance the selling process. This is how the concept is generated. The owner will specifically tell the software company what kind of software he would need. In other words, he will specify his requirements.

(ii) Requirements analysis – After the owner (user) knows his requirements, then it is given to a software team (company) who will analyze the requirement and prepare requirement document that will explain every functionality that are needed by the owner. The requirement document will be the main document for developers, testers and database administrators. In other words, this is the main document that will be referred by everyone. After the requirement documents, other detailed documents many be needed. For example, the architectural design which is a blueprint for the design with the necessary specifications for the hardware, software, people and data resources.

(iii) Development: After the detailed requirement documents (some companies have design documents instead of requirement documents), the developers start writing their code (program) for their modules. On the other hand, the testers in the QA (Quality Assurance) Department start writing Test Plans (one module=1 test plan), test cases and get ready for testing.

(iv) Testing: Once the code (programs) are ready, they are compiled together and to make a build. This build is now tested by the software testers (QA Testers)

(v) Production: After testing, the application (software) goes into production (meaning, it will be handed over to the owner).

(vi) End: And one day, the owner will have say bye to the software either because the business grows and this software does not meet the demand or for some reason, the he does not need the software. That’s the end of it.

dipa ahuja replied to on 02-Aug-11 03:52 AM

SDLC is a mythology in which covers all aspects of

·      operations

·      It consists of

·      Requirements Management.

·      System Analysis.

·      Design

·      Coding

·      Testing

·      Support and Maintenance.

·     Post Audit.


Golu sharma replied to on 02-Aug-11 06:34 AM

Traditional approach or Software Development Life cycle:

VTLGlobal manages the process from conception to completion. Under this approach our software development outsourcing team is responsible for the whole development life cycle. Depending on the requirements we follow different models of Software development Life Cycle (SDLC), but the most common is waterfall method. We divide project in different stages and output of each stage becomes the input for another. We keep the process simple and make sure at no time we move away from the targeted goals.

The common stages:

1). Project planning, feasibility study: In this phase our Software development strategy making team establishes a high-level view of the intended project and determines its goals.

2). Requirement definition: Refines project goals into defined functions and operation of the intended application.

3). System analysis: Analyze end-user information needs.

4). Systems design: VTL's software development team describes desired features and operations in detail, including screen layouts, business rules, process diagrams, pseudo-code and other documentation.

5). Implementation/development: The real code is written here.

6). Integration and testing: Our team brings all the pieces together into a special environment, then checks for errors, bugs and interoperability.

7). Acceptance, installation, deployment: This is the final stage of initial development. Our team puts the software into production and runs actual business.

8). Maintenance i.e. "What happens during the rest of the software's life": changes, correction, additions, move to a different computing platform or say and more. This, the least glamorous and perhaps most important step of all, goes on seemingly forever.
Golu sharma replied to on 02-Aug-11 06:35 AM
1. Planning – Everything starts with a concept. It could be a concept of someone, or everyone. However, there are those that do not start out with a concept but with a question, “What do you want?” they ask thousands of people in a certain community or age group to know what they want and decide to create an answer. But it all goes back to planning and conceptualization. It is also essential for developers to know that this stage deals a lot with upper management so if you are not the owner of the software development company; you have to deal with them a lot in this stage.

2. Design – Once planning and arguing with the manager or the owner about the plan and somehow convincing them, it is time to design or create a rough plan regarding the software. Developers will work together and decide the initial specifics of the software to be created. They will decide what platform or programming language to use, which will take care the coding of a certain part of the software and even the time frame.

This could be conducted by a project manager along with the developers. The workflow about the project is also laid out. Some will also treat this stage as planning for the back-end operations in developing the software. It is not only important that developers should have a solid plan; they should at least know that something will help them achieve to finish the program faster.

3. Implementation – The first two stages are quite common in all SDLC models. However, things change starting on this stage. When the design and all the things that you need have been laid out, it is time to work on the plan. Some developers, especially those that follow the standard plan of developing software will work on the plan and present them for approval.

However, there are those that follow the iterative plan in SDLC. Iterative SDLC is something revolutionary compared to traditional stages in developing software. Instead of finishing everything and presenting them to the general users or testers, Iterative SDLC will develop the software slowly and each change should be presented to the intended users are at least in a focus group when they are about to be implemented in public. Implementation in some SDLC models is a combination of implementation and testing to a focus group.

4. Testing – This could mean two things depending on an SDLC model. The first type of testing is the actual testing by users. This is usually done in models wherein implementation does not go with pre-testing with users. On the other hand, there are also testing that uses professionals in the field. This testing is aimed in cleaning the software of all the bugs altogether. For software that are set for public release, the software is first tested by other developers who were not in charge in creating the software.

They will weed out the bugs and suggest fixes if every they find one. Once this stage is completed, it is time to test the software not just to the developers but to actual users. Some have been bold enough to offer the software openly to the public but best practices will suggest that you have to invite limited number of people before actually offering the software as a open beta version.

That way, the software and even the hardware that backs up the operation is actually tested. A gradual increase in the number of users will test the power of the server. Some servers, even though created to withstand heat and continuous data processing, could not just handle the pressure when thousands of users all over the world starts to creep in the server.

5. Acceptance – When the software is released to be used by a certain company, acceptance means the software is implemented as an added tool or could be replacing another software that has been found too wanting after years of use. On the other hand, when the software is implemented to the public a new software could be an added software for use. It is difficult to change public software but they are not closing their ears to new software. So developers will always have a fighting chance in the market as long as they implement good software for public use.

6. Maintenance – When the software is implemented, it does not mean that the software is good as it is. All SDLC models include maintenance since there are absolutely no way that a software will be working perfectly. Someone has to stay in the present software to take a look and ensure the program works perfectly. When the software is implemented in public.

Software companies either set up a call center or an e-mail service to address the concerns of the consumer. As we have indicated in previous chapters, Maintenance is quiet an easy task as long as the right food and product is serve in an expected time frame. However, it is always a challenge when something goes wrong. The whole team might not be there to help the developer so addressing a major concern could never be answered.

Golu sharma replied to on 02-Aug-11 06:36 AM
The follwing are the phases of SDLC.
1. Definition of the problem - Identifying the requirement
2. User Requirement Study - Interview, JAD( Joint 
Application Development), Survey Method.
Outcome - Functional Specifications Document - High Level
3. Discussion and GAP Analysis - Submitting our level of 
understanding to the user and conduct suitable GAP analysis 
in understanding requirements.
Outcome - Detailed FS, Prototype, Use Cases, Flow charts, 
Logical Data Model and Process Model.
4. Feasibility Study and Cost Benefit Analysis
5. Sign-off and establish a protocol for Change Request.
6. Design - Functional and System Design
Outcome - Dataflow and process flow design with the 
suggested Design Methodology.
7. Development - Coding/programming the application.
8. Testing - Functional Testing (Black Box and White Box), 
Code Testing and User Acceptance Testing (Concurrent 
Testing (if multiple users are involved) and Regression 
Outcome - Test Documents with error reporting at every 
9. Quality Management - Software quality team will check 
the system against established standards
Outcome - Certification
10. Implementation
11. Maintenance
Irfan Khan replied to on 04-Aug-11 01:58 AM

There are several different ways to divide the work that takes place in the development of an application. The work breakdown in general comprises the project's life cycle. If you asked five SEs to describe the life cycle of a typical computer application, you would get five overlapping but different answers.

You should remember from systems analysis that a sequential project life cycle (SPLC) starts when a software product is conceived and ends when the product is no longer in use. Phases in a SPLC include:


      problem definition


      requirements analysis

      conceptual design


      code/unit test


      installation and checkout

      operations and maintenance


These SPLC phases are more appropriate to business than to military/government applications because, in the government, the first four phases (initiation' definition, feasibility, and functional requirements definition) are usually completed by a different organization than that of the implementers. Government projects are subject to congressional review, approval, and budgeting. So, a government project requiring congressional appropriation is usually defined as beginning at the conceptual design phase and ending with deployment of the system with operational status according to Department of Defense standard #2167a [DOD, 1985]. In contrast, business IS are typically initiated by a user department requesting that a system be built by an MIS department. The need for an IS is typically motivated by some business situation: a change in the method of business, in the legal environment, in the staffing/support environment, or in a strategic goal such as improving market competitiveness.

We call these SPLC phases a 'Waterfall' approach to applications because the output of each phase feeds into the next phase, while phases are modified via feedback produced during the verification and validation processes. Phases in the waterfall definition are defined as discrete even though, in practice, the information is obtained in a nonlinear manner and the phase beginnings and endings are difficult to distinguish. To identify discrete beginnings and endings, most companies use the completion of the major product (i.e., program or document) produced during each phase as signaling the phase end. So, completion of a feasibility report, for instance, identifies the end of the feasibility analysis phase. In the following subsections, each phase of the project life cycle (SPLC) is defined, with the main activities and documents identified.

INITIATION. Project initiation is the period of time during which the need for an application is identified and the problem is sufficiently defined to assemble a team to begin problem evaluation. The people and organizations affected by the application, that is, the stakeholders, are identified. Participants from each stakeholder organization for the development team are solicited. The outcome of initiation is a memo or formal document requesting automation support and defining the problem and participants.

FEASIBILITY. Feasibility is the analysis of risks, costs and benefits relating to economics, technology, and user organizations. The problem to be automated is analyzed in sufficient detail to ensure that all aspects of feasibility are evaluated. Economic feasibility analysis elaborates costs of special hardware, software, personnel, office space, and so forth for each implementation alternative.

In technical feasibility analysis, alternatives for hardware, software, and general design approach are determined to be available, appropriate, and functional. The benefits and risks of alternatives are identified.

Organizational feasibility is an analysis of both the developing and using organizatiop.s' readiness for the application. Particular emphasis is placed on skills and training needed in both groups to ensure successful development and use of the application. The decision whether or not to use consultants and the type of role they would play during development is made during organizational feasibility analysis. Organizational decisions include effectiveness of the organization structure and definition of roles of individual jobs in the organization as they will be with the new application. The feasibility report summarizes

      the problem

      the economic, technical and organizational feasibility

      risks and contingency plans related to the application

      preferred concept for the software product and an explanation of its superiority to alternative concepts

      training needs and tentative schedules

      estimates of project staffing by phase and level of expertise

After feasibility is established, the Software Development Life Cycle (SDLC), a subcycle of the SPLC, begins. This subcycle typically includes phases for analysis, conceptual design, design, implementation, testing, and installation and checkout. SDLC end is signaled by delivery of an operational application.

ANALYSIS. The analysis phase has many synonyms: Functional Analysis, Requirements Definition, and Software Requirements Analysis. All of these names represent the time during which the business requirements for a software product are defined and documented. Analysis activities define

1.      Functional requirements-"what" the system is supposed to do. The format of the functional requirements definitions depends on the methodology followed during the analysis phase.

2.      Performance requirements-terminal, message, or network response time, input/output volumes, process timing requirements (e.g., reports must be available by 10 A.M.).

3.      Interface(s) requirements-what data come from and go to other using applications and organizations. The definition includes timing, media, and format of exchanged data.

4.      Design requirements-information learned during analysis that may impact design activities. Examples of design requirements are data storage, hardware, testing constraints, conversion requirements, and humanmachine interaction requirements (e.g., the application must use pull-down menus).

5.      Development standards-the form, format, timing, and general contents of documentation to be produced during the development. Development standards include rules about allowable graphical representations, documentation, tools, techniques, and aids such as computer-aided software engineering (CASE) tools, or project management scheduling software. Format information includes the content of a data dictionary/repository for design objects, project report contents, and other standards to be followed by the project team when reporting project accomplishments, problems, status and design.

6.      The plan for application development is refined.

Analysis documentation summarizes the current method of work, details the proposed system, and how it meets the needs of the required functions. Requirements from the work activities are described in graphics, text, tables, structured English, or some other representation form prescribed by the methodology being used.

CONCEPTUAL DESIGN. Once the proposed logical system is understood and agreed to by the user, conceptual design begins. Other names for conceptual design activity include preliminary design, logical design, external design, or software requirements specifications. The major activity of conceptual design is the detailed functional definition of all external elements of the application, including screens, reports, data entry messages, and/or forms. Both contents and layout are included at this level. In addition, the logical data model is transformed into a logical database schema and user views. If distribution or decentralization of the database is anticipated' the analysis and decision are made during conceptual design. The outputs of conceptual design include the detailed definition of the external items described above, plus the normalized and optimized logical database schema.

Not all organizations treat conceptual design separately. Outputs of conceptual design may be in a conceptual design document or might be part of the functional requirements document developed during analysis. Depending on the project manager's personal taste and experience, the conceptual design might be partially completed during logical design and fully completed during physical design. In this text, the two phases, design and conceptual design, are treated as one.

DESIGN. Design maps "what" the system is supposed to do into "how" the system will do it in a particular hardware/software configuration. The other terms used to describe design activities include detailed design, physical design, internal design, and/or product design.

During the design phase, the software engineering team creates, documents, and verifies:

1.      Software architecture-identifies and defines programs, modules, functions, rules, objects, and their relationships. The exact nature of the software architecture depends on the methodology followed during the design phase.

2.      Software components and modules-defines detailed contents and functions of software components, including, but not limited to, inputs, outputs, screens, reports, data, files, constraints, and processes.

3.      Interfaces-details contents, timing, responsibilities, and design of data exchanged with other applications or organizations.

4.      Testing-defines the strategy, responsibilities, and timing for each type of testing to be performed.

5.      Data-physically maps "what" to "how" for data. In database terms, this is the definition of the physical layout of data on the devices used, and of the requirements, timing, and responsibility for distribution, replication, and/or duplication of data.

SUBSYSTEM/PROGRAM DESIGN. Subsystem and/or program designs are sometimes treated as subphases of the design phase. Whether they are separate phases or not, the software engineering team creates, documents, and verifies the following:

1.      Application control structure-defines how each program/module is activated and where it returns upon completion.

2.      Data structure and physical implementation scheme-defines physical data layouts with device mapping and data access methods to be used. In a database environment, this activity may include definition of a centralized library of data definitions, calling routines, and buffer definitions for use with a particular DBMS.

3.      Sizing-defines any programs and buffers which are expected to be memory-resident for on-line and/or real-time processes.

4.      Key algorithms-specifies mathematically correct notation to allow independent verification of formula accuracy.

5.      Program component (routine with approximately 100 source procedure instructions) identifies, names, and lists assumptions of program component design and usage. Assumptions include expectations of, for instance, resident routines and/or data, other routines/modules to be called in the course of processing this module, size of queues, buffers, and so on required for processing.

CODE AND UNIT TEST. During coding, the low-level program elements of the software product are created from design documentation and debugged. Unit testing is the verification that the program does what it is supposed to do and nothing

more. In systems using reusable code, the code is customized for the current application, and checked to ensure that it works accurately in the current environment.

TEST. During testing-sometimes called Computer Software Component (CSC) Integration and Testingll-the components of a software product are evaluated for correctness of integrated processing. Quality assurance testing may be conducted in the testing phase or may be treated as a separate activity. During quality assurance tests, the software product (i.e., software or documentation) is evaluated by a nonmember of the project team to determine whether or not the analysis requirements are satisfied.

IMPLEMENTATION. Also called Installation and Checkout, implementation is that period of time during which a software product is integrated into its operational environment and is phased into production use. Implementation includes the completion of data conversion, installation, and training.

At this point in the project life cycle, the software development cycle ends, and the maintenance phase begins.  Maintenance and operations continue until the project is retired.

OPERATIONS AND MAINTENANCE. Operations and maintenance is the period in the software life cycle during which a software product is employed in its operational environment, monitored for satisfactory performance, and modified as necessary. Three types of maintenance are

1.      Perfective-to improve the performance of the application (e.g., make all table indexes binary to minimize translations, change an algorithm to make the software run faster, and so on.)

2.      Corrective-to remove software defects (i.e., to fix bugs)

3.      Adaptive-to incorporate any changes in the business or related laws in the system (e.g., changes for new IRS rules)

Each type of maintenance requires a minianalysis and mini-design to determine social, technical, and functional aspects of the change. The current operational versions of software and documentation must be managed to allow identification of errors and to ensure that the correct copy of software is run. One aspect of change management specifically addresses

configuration management of application programs in support of maintenance activities.

RETIREMENT. Retirement is the period of time in the software life cycle during which support for a software product is terminated. Usually, the functions performed by the product are transferred to a successor system. Another name for this activity is phaseout.