Pankaj Jalote. Pages PDF · Software Requirements Analysis and Specification. Pankaj Jalote. Pages PDF · Planning a Software Project. Pankaj. [EPUB] Pankaj Jalote Software Engineering Narosa Publishing House File Type Pdf Executing any software project requires skills in two key. software engineering by pankaj jalote pdf download - a concise introduction to pankaj jalote pdf free download of illinois at urbana champaign, and has.
|Language:||English, Spanish, Hindi|
|ePub File Size:||18.65 MB|
|PDF File Size:||13.24 MB|
|Distribution:||Free* [*Regsitration Required]|
TEXTS IN COMPUTER SCIENCE Editors David Gries Fred B. Schneider An Integrated Approach to Software Engineering Third Edition Pankaj Jalote Indian. An integrated approach to Software Engineering by Pankaj Jalote,. Narosha Publishing houre. 3. Software Engineering by Sommerville, Pearson Education. 4 . This book covers software project management concepts. the Jalote book despite its comprehensiveness in the scope. text book on software project management should have.
Theexplanations are supported by examples, and the key learnings are summarizedin the end for the reader. With 2months as the completion time, the productivity of the student will be lines of code LOC per person-month. Preface viiTeaching Support and Supplemental ResourcesThough the book is self-contained, some teaching support and supplementalresources are available through a website. By improvement, we mean that the capability of the processto produce quality goods at low cost is improved. In other words, the process model provides generic guidelines for developing asuitable process for a project. These three constituent processes focus on the projects and the productsand can be considered as comprising the product engineering processes, as theirmain objective is to produce the desired product.
Pages Software Processes. Software Requirements Analysis and Specification. Planning a Software Project. Function-Oriented Design. Object-Oriented Design. Detailed Design. Back Matter Pages It therefore focuses on activities directly related to productionof the software, for example, design, coding, and testing.
Themanagement process is often decided based on the development process.
In other words, the process model provides generic guidelines for developing asuitable process for a project. Due to the importance of the development process, various models havebeen proposed. In this section we will discuss some of the major models. In this model, a project be-gins with feasibility analysis.
Upon successfully demonstrating the feasibility ofa project, the requirements analysis and project planning begins. The designstarts after the requirements analysis is complete, and coding begins after thedesign is complete. Once the programming is completed, the code is integratedand testing is done. Upon successful completion of testing, the system is in-stalled. After this, the regular operation and maintenance of the system takesplace.
The model is shown in Figure 2. The basic idea behind the phases is separation of concerns—each phasedeals with a distinct and separate set of concerns.
By doing this, the large andcomplex task of building the software is broken into smaller tasks which, bythemselves, are still quite complex of specifying requirements, doing design,etc. Separating the concerns and focusing on a select few in a phase gives abetter handle to the engineers and managers in dealing with the complexity ofthe problem. A good plan is based onthe requirements of the system and should be done before later phases begin.
However, in practice, detailed requirements are not necessary for planning. Consequently, planning usually overlaps with the requirements analysis, and aplan is ready before the later phases begin. This plan is an additional input toall the later phases. Linear ordering of activities has some important consequences. The waterfall model. That is, when the ac-tivities of a phase are completed, there should be some product that is producedby that phase.
The outputs of the earlier phases are often called work productsand are usually in the form of documents like the requirements document or Software Processesdesign document. For the coding phase, the output is the code. Though the setof documents that should be produced in a project is dependent on how theprocess is implemented, the following documents generally form a reasonableset that should be produced in each project: One of the main advantages of the waterfall model is its simplicity.
It is concep-tually straightforward and divides the large task of building a software systeminto a series of cleanly divided phases, each phase dealing with a separate logi-cal concern. It is also easy to administer in a contractual setup—as each phaseis completed and its work product produced, some amount of money is givenby the customer to the developing organization. The waterfall model, although widely used, has some strong limitations.
Some of the key limitations are: It assumes that the requirements of a system can be frozen i. This is possible for systems designed to automate an existing manual system.
Hence, having unchanging requirements is unrealistic for such projects. A large project might take a few years to complete. This is clearly not desirable for such expensive software systems. This entails heavy risks, as the user does not know until the very end what they are getting.
Furthermore, if the project runs out of money in the middle, then there will be no software. It is a document-driven process that requires formal documents at the end of each phase. Despite these limitations, the waterfall model has been the most widely usedprocess model.
It is well suited for routine types of projects where the require-ments are well understood. The basic idea here is that instead of freezingthe requirements before any design or coding can proceed, a throwaway proto-type is built to help understand the requirements. This prototype is developedbased on the currently known requirements. Development of the prototype ob-viously undergoes design, coding, and testing, but each of these phases is notdone very formally or thoroughly.
By using this prototype, the client can get anactual feel of the system, which can enable the client to better understand therequirements of the desired system. This results in more stable requirementsthat change less frequently. Prototyping is an attractive idea for complicated and large systems forwhich there is no manual process or existing system to help determine therequirements. This might be needed for novel systems, where it isnot clear that constraints can be met or that algorithms can be developed toimplement the requirements.
In both situations, the risks associated with theprojects are being reduced through the use of prototyping. The process modelof the prototyping approach is shown in Figure 2.
A development process using throwaway prototyping typically proceeds asfollows .
At this stage, there is a reasonable understanding of the system and its needsand which needs are unclear or likely to change. After the prototype has beendeveloped, the end users and clients are given an opportunity to use and ex-plore the prototype. Based on their experience, they provide feedback to the Software Processes Figure 2.
The prototyping model. For prototyping for the purposes of requirement analysis to be feasible, itscost must be kept low. Consequently, only those features are included in theprototype that will have a valuable return from the user experience.
Excep-tion handling, recovery, and conformance to some standards and formats aretypically not included in prototypes. In prototyping, as the prototype is to bediscarded, there is no point in implementing those parts of the requirementsthat are already well understood.
Hence, the focus of the development is toinclude those features that are not properly understood. Because the prototype is to be thrown away, only minimal documenta-tion needs to be produced during prototyping. Another important cost-cutting measure is to reduce testing. Because testing consumes a major part of development expenditure during reg-ular software development, this has a considerable impact in reducing costs.
Byusing these types of cost-cutting methods, it is possible to keep the cost of theprototype to less than a few percent of the total development cost. First, the experienceof developing the prototype will reduce the cost of the actual software develop-ment. Second, as requirements will be more stable now due to the feedback fromthe prototype, there will be fewer changes in the requirements.
Consequentlythe costs incurred due to changes in the requirements will be substantially re-duced. It is also an excellent technique for reducing sometypes of risks associated with a project.
The basic idea is that the software should bedeveloped in increments, each increment adding some functional capability tothe system until the full system is implemented.
The iterative enhancement model  is an example of this approach. This subset is one that contains some of the key aspectsof the problem that are easy to understand and implement and which forma useful and usable system.
Each step consists of removing the next task from the list, designing theimplementation for the selected task, coding and testing the implementation,performing an analysis of the partial system obtained after this step, and updat-ing the list as a result of the analysis. These three phases are called the designphase, implementation phase, and analysis phase. The iterative enhancement model is shown in Figure2. The iterative enhancement model.
The project control list guides the iteration steps and keeps track of alltasks that must be done. Based on the analysis, one of the tasks in the listcan include redesign of defective components or redesign of the entire system. However, redesign of the system will generally occur only in the initial steps. In the later steps, the design would have stabilized and there is less chanceof redesign. Each entry in the list is a task that should be performed in onestep of the iterative enhancement process and should be simple enough to becompletely understood.
Selecting tasks in this manner will minimize the chancesof error and reduce the redesign work. The design and implementation phasesof each step can be performed in a top-down manner or by using some othertechnique. For example, asthe requirements for future iterations are not known, the design of a systemmay not be too robust. Another common approach for iterative development is to do the require-ments and the architecture design in a standard waterfall or prototyping ap-proach, but deliver the software iteratively.
We can view this approach ashaving one iteration delivering the requirements and the architecture plan, andthen further iterations delivering the software in increments. At the start ofeach delivery iteration, which requirements will be implemented in this releaseare decided, and then the design is enhanced and code developed to implementthe requirements. The iteration ends with delivery of a working software system Selecting of requirements for an iterationis done primarily based on the value the requirement provides to the end usersand how critical they are for supporting other requirements.
This approach isshown in Figure 2. Iterative delivery approach. The advantage of this approach is that as the requirements are mostlyknown upfront, an overall view of the system is available and a proper archi-tecture can be designed which can remain relatively stable.
With this, hopefullyrework in development iterations will diminish. At the same time, the value tothe end customer is delivered iteratively so it does not have the all-or-nothingrisk. Also, since the delivery is being done incrementally, and planning andexecution of each iteration is done separately, feedback from an iteration canbe incorporated in the next iteration. Even new requirements that may get un-covered can also be incorporated.
There are a few key reasons for its increasingpopularity. In the current business scenario, it is preferableto see returns continuously of the investment made. The iterative model per-mits this—after each iteration some working software is delivered, and the riskto the client is therefore limited. Iterative process allows this. Third, eachiteration provides a working system for feedback, which helps in developingstable requirements for the next iteration.
Below we will describe some other Software Processesprocess models, all of them using some iterative approach. We will discuss these topics in a later chapter. RUP proposes that development of software be divided into cycles, eachcycle delivering a fully working system.
Generally, each cycle is executed as aseparate project whose goal is to deliver some additional capability to an exist-ing system built by the previous cycle.
Hence, for a project, the process for acycle forms the overall process. Each cycle itself is broken into four consecutivephases: The purposeof the inception phase is to establish the goals and scope of the project, andcompletion of this phase is the lifecycle objectives milestone.
In the elaboration phase, the architecture of the system is designed, basedon the detailed requirements analysis. The completion of this phase is the life-cycle architecture milestone. In addition, a high-level projectplan for the project has been prepared showing the remaining phases and iter-ations in those, and the current perception of risks. By the end of this phase, In the construction phase, the software is built and tested. This phase resultsin the software product to be delivered, along with associated user and othermanuals, and successfully completing this phase results in the initial operationalcapability milestone being achieved.
Thisis a complex task which can require additional testing, conversion of old datafor this software to work, training of personnel, etc. The successful executionof this phase results in achieving the milestone product release. The RUP model.
Generally, it is expected that the construction phase willbe broken into multiple iterations, each iteration producing a working systemwhich can be used for feedback, evaluation, beta-testing, etc. Though itera-tions in construction are done often and it is clear what an iteration in thisphase delivers, iterations may be done meaningfully in other phases as well.
RUP has carefully chosen the phase names so as not to confuse them withthe engineering tasks that are to be done in the project, as in RUP the en-gineering tasks and phases are separate. Software Processesbe performed in a phase to achieve its milestones.
These sub-processes correspond to the tasks of performing requirements analysis, doingdesign, implementing the design, testing, project management, etc. Some of thesubprocesses are shown in Table 2. In waterfall or waterfall-based iterative model , a phase withina process was linked to a particular task performed by some process like re-quirements, design, etc. In RUP these tasks are separated from the stages,and it allows, for example, during construction, execution of the requirementsprocess.
That is, it allows some part of the requirement activity be done evenin construction, something the waterfall did not allow. Similarly, the model hasthe development process active in elaboration, which allows a project to builda prototype during the elaboration phase to help its requirements activity, ifneeded. However, most of the implementation does happen in the constructionphase.
However, a general pattern is indicated in Table 2. Table 2. Mgmt Low Low High High That is, a new iteration commences before the system producedby the current iteration is released, and hence development of a new releasehappens in parallel with the development of the current release. By starting aniteration before the previous iteration has completed, it is possible to reducethe average delivery time for iterations.
However, to support parallel execution,each iteration has to be structured properly and teams have to be organizedsuitably. The timeboxing model proposes an approach for these [60, 59]. This is in contrast to regular iterative approaches where the functionalityis selected and then the time to deliver is determined.
Timeboxing changesthe perspective of development and makes the schedule a nonnegotiable and ahigh-priority commitment. However, two particularly dominant trends are clearly discernible: And the object-oriented approach is considered by many one of the best hopes for solving some of the problems faced by software developers. In this second edition, these two trends are clearly highlighted. Aseparate chapter has been included entited "Software Processes.
Object-orientation figures in many chapters. Overall, if one wants to develop software using the paradigm of object -orientation, aB aspects of development that require different handling are discussed. Most of the other chapters have also been enhanced in various ways. In particular, the chapters on requirements specification and testing have been considerably enhanced.