Principles of Software Engg.

Only available on StudyMode
  • Topic: Agile software development, Waterfall model, Software development process
  • Pages : 9 (2671 words )
  • Download(s) : 723
  • Published : August 16, 2011
Open Document
Text Preview
University of Ballarat

ITECH6501 Principles of Software Engineering

Name: Abdulhadi Zawi (30088958)

Individual Assignment - 20 marks – refer to Course Description for weighting

Semester 2011/05 Report Due Date: Refer to course description

In this first assignment, TWO software development methodologies will be examined using the first four laws given in the prescribed text.

Glass’ law
Requirement deficiencies are the prime source of project failures. (LI)

Boehm’s first law
Errors are most frequent during the requirements and design activities and are the more expensive the later they are removed. (L2)

Boehm’s second law
Prototyping (significantly) reduces requirement and design errors, especially for user interfaces. (L3)

Davis’ law
The value of a model depends on the view taken, but none is best for all purposes. (L4)

The first software development methodology will be the Waterfall Model, the second software methodology will be one of either Agile Methodology or the Rational Unified Process (RUP or UP).

For both the software development methodologies do the following:

1. Describe each law in your own words. Illustrate with a practical example. [2 + 2 = 4 marks]

Waterfall Model:

Glass’ law: Requirements are the basic and fundamental source of input to the Waterfall Model. Requirement deficiencies in the beginning of the project will lead to a low quality design of the software and that low quality of the design will lead to a low quality software product at the end. If a crucial requirement is not captured in requirements gathering phase or a wrong requirement is captured then it leads to customer dissatisfaction, and eventually the project will fail.

Boehm’s first law:
The requirements gathering phase in Waterfall Model is more prone to errors and most of the times major errors in the end product are originated from the requirements and analysis phases of the software development life cycle. This is because of the customer are most of the times non technical and they can not describe their requirements in very well formed manner. Also, the requirements gathering teams are not familiar with the domain customer is working in, so there is a huge chance of misunderstanding the requirements or missing out some crucial ones. If some error occurs in the requirements gathering phase it will lead to a wrong design and that wrong design will lead to a product with deficiencies. If we need to remove those errors after completing all the waterfall phases then we need to capture the requirements again, change the whole product design based on the new requirements, develop the software and test it again. It will definitely increase the cost of developing those requirements with a lot of rework, as compared to if they were captured correctly at the first place.

Boehm’s second law:
Prototyping is a good method of removing some errors at the very early stage of software development. With a prototype a customer can easily visualize what will be the final product and the developers also get the requirements clarified by the customers. The prototypes are the GUIs with none or very limited functionality to help customers tell if some critical aspect of the end system is missing. They also help the developers in designing robust software in the early stages of the development cycle. As an example if a user thinks that he will select from the dropdown list the names of the cities or the developer thinks that the user will enter the city name in the text box, it can be clarified easily with the help of a simple prototype.

Davis’ law:
Models are designed to have a better understanding of the existing systems, and for...
tracking img