Page 24 - DCAP305_PRINCIPLES_OF_SOFTWARE_ENGINEERING
P. 24

Principles of Software Engineering



                   Notes            •  System  and  software  design:  The  systems  design  process  partitions  the  requirements  to
                                      either hardware or software systems. It establishes overall system structural design.
                                      Software design involves representing the software system functions in a form- that may
                                      be transformed into one or more executable programs.

                                    •  Implementation and unit testing: during this stage, the software design is realized as a set
                                      of programs or program units. Unit testing involves verifying that each unit meets its
                                      specification.
                                    •  Integration and system testing: The individual program units or programs are integrated
                                      and tested as a complete system to ensure that the software requirements have been met.
                                      After testing, the software system is delivered to the customer.
                                    •  Operation  and  maintenance:  Normally  (although  not  necessarily)  this  is  the  longest  life
                                      cycle  phase. The  system  is  installed  and put into practical use. Maintenance involves
                                      correcting errors which were not discovered in earlier stages of the life cycle, improving the
                                      implementation of system units and enhancing the system’s services as new requirements
                                      are discovered.
                                 Actually, these stages extend beyond and feed information to each other. During design,
                                 problems with requirements are identified; during coding, design problems are found and so
                                 on. The software process is not a simple linear model but involves a sequence of iterations of
                                 the development activities.

                                 During the final life cycle phase (operation and maintenance) the software is put into use. Errors
                                 and omissions in the original software requirements are discovered. Program and design errors
                                 emerge and the need for new functionality is identified. Modifications become necessary for
                                 the software to remain useful.
                                   (1)  Evolutionary Development

                                       This moves towards interleaves the performance of specification, growth and validation.
                                      An initial system is quickly developed from very abstract specifications. This is then refined
                                      with customer input to produce a system which satisfies the customer’s needs. The system
                                      may then be delivered. Alternatively, it may be re-implemented using a more structured
                                      approach to produce a more robust and maintainable system.

                                   (2)  Formal Transformation
                                       This  approach  is  based  on  producing  a  formal  mathematical  system  specification  and
                                      transforming this  specification, using  mathematical methods,  to a  program.  These
                                      transformation are correctness preserving. This means that you can be sure that the
                                      developed program meets its specification.

                                   (3)  System assembly From Reusable Components
                                       This technique assumes that parts of the system already exist. The system development
                                      process focuses on integrating these parts rather than developing them from scratch.
                                 The first two of these approaches, namely the waterfall approach and evolutionary development,
                                 are now widely used for practical systems development. Some systems have been built using
                                 correctness-preserving transformations but this is still an experimental.

                                 1.11 Role of Management in Software Development


                                 The management of software development is heavily dependent on four factors: People, Product,
                                 Process, and Project. Order of dependency is as shown in Figure. 1.11.




        18                                LOVELY PROFESSIONAL UNIVERSITY
   19   20   21   22   23   24   25   26   27   28   29