Winter 2011

Master of Computer Application (MCA) Semester 3 MC0071 Software Engineering 4 Credits

(Book ID: B0808 & B0809) Assignment Set 1 (60 Marks)
Answer all Questions Each question carries TEN marks

Book ID: B0808 1. Explain the following development models: a. Serial or Linear Sequential b. Incremental Ans:

a. Serial or Linear Sequential This Model also called Classic life cycle or the Waterfall model suggests a systematic sequential approach to software development that begins at the system level and progresses through analysis, design, coding, testing, and support. The waterfall model derives its name due to the cascading effect from one phase. In this model each phase well defined starting and ending point, with identifiable deliveries to the next phase. Figure shows the linear sequential model for software engineering Modeled after a conventional engineering cycle, the linear sequential model has the following activities:

Fig: The linear sequential model

MC0071 Software Engineering

Roll No. XXXXXXXXX

System/Information Engineering and modeling: Because software is a part of a large system, work begins by establishing requirements for all system elements and then allocating some subset of these requirements to software. This system view is essential when software must interact with other element such as hardware, people and databases. System engineering and analysis encompasses requirements gathering at the system level with a small amount of top level design and analysis. Information engineering encompasses requirements gathering at the strategic business level and at the business area level. Software requirement analysis: The requirement gathering process is intensified and focused specifically on software. To understand the nature of the program to be built, the software engineer (analyst) must understand the information domain for the software, as well as required function, behavior, performance and interface. Requirements for the both system and the software are documented and reviewed with the customer. Design: Software design is actually a multistep process that focuses on four distinct attributes of a program, data structure, software architecture, interface representations, and procedural (algorithmic) detail. The design process translates requirements into a representation of the software that can be assessed for quality before coding begins. Like requirements, the design is documented and becomes part of the software configuration. Code Generation: The design must be translated into a machinereadable form. The code generation step performs this task. If design is performed in a detailed manner, code generation can be accomplished mechanistically. Testing: Once code has been generated, program testing begins. The testing process focuses on the logical internals of the software, ensuring that all statements have been tested, and on the functional externals; that is, conducting tests to uncover errors and ensure that defined input will produce actual results that agree with required results. Support: Software will undergo change after it is delivered to the customer. Change will occur because errors have been encountered, because the software must be adopted to accommodate changes in its external environments or because the customer requires functional or performance enhancements. Software maintenance re-applies each of the preceding phases to an existing program rather than a new one. Advantages: 1. Simple and a desirable approach when the requirements are clear and well understood at the beginning 2. It provides a clear cut template for analysis, design, coding, testing and support. 3. It is an enforced disciplined approach Disadvantages: 1. It is difficult for the customers to state the requirements clearly at the beginning. There is always certain degree of natural uncertainty at beginning of each project. 2. Difficult and costlier to change when the changes occur at later stages.
MC0071 Software Engineering Roll No. XXXXXXXXX

3. Customer can see the working version only at the end. Thus any changes suggested here are not only difficult to incorporate but also expensive. This may result in disaster if any undetected problems are precipitated to this stage

b. Incremental

The incremental Model is an evolution of the waterfall model, where the waterfall model is incrementally applied. The series of releases is referred to as increments, with each increment providing more functionality to the customers. After the first increment, a core product is delivered, which can already be used by the customer. Based on customer feedback, a plan is developed for the next increments, and modifications are made accordingly. This process continues, with increments being delivered until the complete product is delivered. The incremental philosophy is also used in the agile process model. Figure shows the incremental model applies linear sequences in a staggered fashion as calendar time progresses. Each linear sequence produces a deliverable increment of the software. For e.g., word processing software developed using the incremental paradigm might deliver basic file management, editing, and document production functions in the first increment; more sophisticated editing and document production capabilities in the second increment; spelling and grammar checking in the third increment; and advanced page layout capability in the fourth increment. It should be noted that the process flow for any increment could incorporate the prototyping paradigm.

Fig: The incremental model When an incremental model is used, the first increment is a core product. That is, basic requirements are addressed, but many supplementary features remain undelivered. The customer uses the core product. As a result of use and/or evaluation, a plan is developed for the next increment. The plan addresses the modification of the core product to better meet the needs of the customer and the delivery of additional features and functionality. This process is repeated
MC0071 Software Engineering Roll No. XXXXXXXXX

following the delivery of each increment, until the complete product is produced. The incremental process model is iterative in nature. The incremental model focuses on the delivery of an operational product with each increment. Incremental development is particularly useful when staffing is unavailable for a complete implementation by the business deadline that has been established for the project. Early increments can be implemented with fewer people. If the core product is well received, then additional staff can be added to implement the next increment. In addition increments can be planned to manage technical risks. For e.g.: a major system might require the availability of new hardware i.e., under development and whose delivery date is uncertain. It might be possible to plan early increments in a way that avoids the use of this hardware, thereby enabling partial functionality to be delivered to end users- without inordinate delay. Advantages 1. After every iteration any faulty piece software can be identified easily as very few changes are done after every iteration. 2. It is easier to test and debug as testing and debugging can be performed after each iteration. 3. This model does not affect anyone's business values because they provide core of the software which customer needs, which will indeed help that person to keep run his business. 4. After establishing an overall architecture, system is developed and delivered in increments. Disadvantages 1. If the requirements initially were thought to be stable but at later stages are realized to be unstable then the increments have to be withdrawn and have to be reworked. 2. Resulting cost may exceed the cost of the organization. 3. Problems may arise related to system architecture.

2. Describe the Object Interface Design. Ans: Object Interface design is concerned with specifying the detail of the object interfaces. This

means defining the types of the object attributes and the signatures and the semantics of the object operations. If an object-oriented programming language is being used for implementation, it is natural to use it to express the interface design. Designers should avoid interfaces representation information in their interface design. Rather, the representation should be hidden and object operations provided to access and update the data. If the representation is hidden, it can be changed without affecting the objects that use these attributes. This leads to a design which is inherently more maintainable. For example, an array representation of a stack may be changed to a list representation without affecting other objects, which use the stack.
MC0071 Software Engineering Roll No. XXXXXXXXX

Design evolution An important advantage of an object-oriented approach to design is that it simplifies the problem of making changes to the design. The reason for this is that object state representation does not influence the design. Changing the internal details of an object is unlikely to affect any other system objects. Furthermore, because objects are loosely coupled, it is usually straightforward to introduce new objects without significant effects on the rest of the system. To illustrate the robustness of the object-oriented approach, assume that pollution-monitoring capabilities are to be added to each weather station. This involves adding an air quality meter to compute the amount of various pollutants in the atmosphere. The pollution readings are transmitted at the same time as the weather data. To modify the design, the following changes must be made: Figure.below shows weather station and the new objects to the system. The abbreviation NO in Air quality stands for nitrous oxide.

Fig: New objects to support pollution monitoring

MC0071 Software Engineering

Roll No. XXXXXXXXX

(1) An object Air quality should be introduced as part of Weather station at the same level as Weather data. (2) An operation Transmit pollution data should be added to Weather station to send the pollution information to the central computer. The weather station control software must be modified so that pollution readings are automatically collected when the system is switched on. (3) Objects representing the types of pollution, which can be monitored, should be added. Levels of nitrous oxide, smoke and benzene can be measured. (4) A hardware control object Air quality meter should be added as a sub-object to Air quality. This has attributes representing each of the types of measurement, which can be made. The addition of pollution data collection does not affect weather data collection in any way. Data representations are encapsulated in objects so they are not affected by the additions to the design. Function oriented design A function-oriented design strategy relies on decomposing the system into a set of interacting functions with a centralized system state shared by these functions as shown in figure below. Functions may also maintain local state information but only for the duration of their execution.

Fig: A function-oriented view of design Function-oriented has been practiced informally since programming began. Programs were decomposed into subroutines, which were functional in nature. In the late 1960s and early 1970s several books were published which described top-down functional design. They specifically proposed this as a structured design strategy. These led to the development of many design methods based on functional decomposition. Function-oriented design conceals the details of an algorithm in a function but system state information is not hidden. This can cause problems because a function can change the state in a way, which other functions do not expect. Changes to a function and the way in which it uses the
MC0071 Software Engineering Roll No. XXXXXXXXX

system state may cause unanticipated changes in the behavior of other functions. A functional approach to design is therefore most likely to be successful when the amount of system state information is minimized and information sharing is explicit. Systems whose responses depend on a single stimulus or input and which are not affected by input histories are naturally functionoriented. Many transaction-processing systems and business data-processing systems fall into this class. In essence, they are concerned with record processing where the processing of one record is not dependent on any previous processing.

3. Explain the following testing strategies: a. Top-Down Testing b. Bottom-Up Testing c. Thread testing d. Stress testing Ans: a. Top-Down Testing

Top-down testing (figure) tests the high levels of a system before testing its detailed components. The program is represented as a single abstract component with sub components represented by stubs. Stubs have the same interface as the component but very limited functionality. After the top-level component has been tested, its stub components are implemented and tested in the same way. This process continues recursively until the bottom level components are implemented. The whole system may then be completely tested.

Fig: Top-Down Testing Top-down testing should be used with top-down program development so that a system component is tested as soon as it is coded. Coding and testing are a single activity with no separate component or module-testing phase. If top-down testing is used unnoticed design errors might be detected at an early stage in the testing process. As these errors are usually structural errors, early detection means that they can
MC0071 Software Engineering Roll No. XXXXXXXXX

be corrected without undue costs. Early error detection means that extensive redesign and re-implementation may be avoided. Top-down testing has the further advantage that a limited, working system is available at an early stage in the development. This is an important psychological boost to those involved in the system development. It demonstrates the feasibility of the system to management. Validation, as distinct from verification, can begin early in the testing process as a demonstrable system can be made available to users. Strict top-down testing is difficult to implement because of the requirement that program stubs, simulating lower levels of the system, must be produced. The main disadvantage of top-down testing is that test out put may be difficult to observe. In many systems, the higher levels of that system do not generate output but, to test these levels, they must be forced to do so. The tester must create an artificial environment to generate the test results.

b. Bottom-Up Testing

Bottom up testing is the converse of top down testing. It involves testing the modules at the lower levels in the hierarchy, and then working up the hierarchy of modules until the final module is tested. The advantage of bottom-up testing is the disadvantages of the top-down testing and vice versa. When using bottom-up testing (figure), test drivers must be written to exercise the lower-level components. These test drivers simulate components environment and are valuable components in their own right. If the components being tested are reusable components, the test-drivers and test data should be distributed with the component. Potential re-users can run these tests to satisfy themselves that the component behaves as expected in their environment.

Fig: Bottom-Up Testing

MC0071 Software Engineering Roll No. XXXXXXXXX

If top-down development is combined with bottom-up testing, all parts of the system must be implemented before testing can begin. Architectural faults are unlikely to be discovered until much of the system has been tested. Correction of these faults might involve the rewriting and consequent re-testing of low-level modules in the system. A strict top-down development process including testing is an impractical approach, particularly if existing software components are to be reused. Bottom-up testing of critical, low-level system components is almost always necessary. Bottom-up testing is appropriate for object-oriented systems in that individual objects may be tested using their own test drivers they are then integrated and the object collection is tested. The testing of these collections should focus on object interactions.

c. Thread testing

Thread testing is a testing strategy, which was devised for testing real-time systems. It is an event-based approach where tests are based on the events, which trigger system actions. A comparable approach may be used to test object-oriented systems as they may be modeled as event driven systems. Thread testing is a testing strategy, which may be used after processes, or objects have been individually tested and integrated in to sub-systems. The processing of each possible external event threads its way through the system processes or objects with some processing carried out at each stage. Thread testing involves identifying and executing each possible processing thread. Of course, complete thread testing may be impossible because of the number of possible input and output combinations. In such cases, the most commonly exercised threads should be identified and selected for testing.

d. Stress testing

Some classes of system are designed to handle specified load. For example, a transaction processing system may be designed to process up to 100 transactions per second; an operating system may be designed to handle up to 200 separate terminals. Tests have to be designed to ensure that the system can process its intended load. This usually involves planning a series of tests where the load is steadily increased. Stress testing continues these tests beyond the maximum design load of the system until the system fails. This type of testing has two functions:

MC0071 Software Engineering

Roll No. XXXXXXXXX

(1) It tests the failure behavior of the system. (2) It stresses the system and may cause defects to come to light, which would not normally manifest themselves. Stress testing is particularly relevant to distributed systems based on a network of processors. These systems often exhibit severe degradation when they are heavily loaded as the network becomes swamped with data, which the different processes must exchange.

Book ID: B0809 4. Describe the following Risk Reduction Models: a. Prototyping Model b. Spiral Model c. Clean Room Model Ans: a. Prototyping Model

The Prototyping Model is a systems development method (SDM) in which a prototype (an early approximation of a final system or product) is built, tested, and then reworked as necessary until an acceptable prototype is finally achieved from which the complete system or product can now be developed. This model works best in scenarios where not all of the project requirements are known in detail ahead of time. It is an iterative, trial-and-error process that takes place between the developers and the users. There are several steps in the Prototyping Model: 1. The new system requirements are defined in as much detail as possible. This usually involves interviewing a number of users representing all the departments or aspects of the existing system. 2. A preliminary design is created for the new system. 3. A first prototype of the new system is constructed from the preliminary design. This is usually a scaled-down system, and represents an approximation of the characteristics of the final product. 4. The users thoroughly evaluate the first prototype, noting its strengths and weaknesses, what needs to be added, and what should to be removed. The developer collects and analyzes the remarks from the users. 5. The first prototype is modified, based on the comments supplied by the users, and a second prototype of the new system is constructed. 6. The second prototype is evaluated in the same manner as was the first prototype.
MC0071 Software Engineering Roll No. XXXXXXXXX

7. The preceding steps are iterated as many times as necessary, until the users are satisfied that the prototype represents the final product desired. 8. The final system is constructed, based on the final prototype. The final system is thoroughly evaluated and tested. Routine maintenance is carried out on a continuing basis to prevent large-scale failures and to minimize downtime. . . .

Continued in full assignments

Remaining answers are available in the full assignments (in MS-WORD format).

For full assignments Contact us:

Prakash: 9686515230
Email: info@assignmentsclub.com / assignments.prakash@gmail.com Website: www.assignmentsclub.com

Note: Sample papers are available in Portable Document Format (.pdf) with a watermark of our Website. Full assignments will be in MS-WORD (.doc) format without any watermark... Contact us for Full assignments...

MC0071 Software Engineering

Roll No. XXXXXXXXX