1. Software Engineering Chapter 3 CPSC 110 - Pascal Brent M. Dingle Texas A&M University

2. Software Engineering  Robustness of a program  Iterative Enhancement  Testing and Debugging – types of errors  Software Life Cycle

3. Robustness  In general a robust program is a program that does not fail due to unexpected or unlikely input.  In general a robust program will consider all forms and types of input – including input that is entered incorrectly by the user.  It will guarantee that any assumptions it had to make about the input are indeed true.  How this is accomplished is dependant on the programmer, the problem and ‘other’ things.

4. Iterative Enhancement  Iterative Enhancement is the process of first designing a simple program and then adding features and refinements as deemed necessary.

5. Testing and Debugging  This is perhaps THE most important part of programming.  If a program is NOT tested how do you know it was actually programmed correctly?  Even the best algorithms must be explained to the computer correctly.

6. Testing  Testing a program means running it and trying to find errors in it.  It is best to use as many forms of testing as possible.  It is best to have as many people as possible test the program – and the program’s writers are NOT very good testers because they already know what the program is supposed to do.

7. Debugging  Debugging is the removing of errors (bugs) from a program.  There are several ‘types’ of errors you will find: syntax errors runtime errors logical errors

8. Syntax Errors  Syntax errors are violations of the syntax (grammar) rules of the programming language.  These are the ONLY type of errors that the compiler will detect.

9. Runtime Errors  Runtime errors occur when the program is running.  Most runtime errors involve numeric calculations.  For example: Because a computer is finite you can increment a number too far – this results in an overflow error. In old video games you could ‘flip’ the score back to zero. Other runtime errors are: division by zero taking the square root of a negative number etc.  Do NOT confuse these with logical errors !  Some say runtime errors are caused by logical errors – but it is more often a failure in robustness.

10. Logical Errors  Logical errors are mistakes in the algorithm itself.  This means that the program compiles AND runs, but produces an incorrect result.  You will NOT receive any error from the computer concerning these types of errors.  Often these errors involve using less than ( ) or something similar.  But every now and then, they are caused by simply using an incorrect algorithm entirely.

11. Software Life Cycle – in general  There are several different descriptions of the software life cycle found throughout computer science.  For this class we will use the one presented in the book.  If you would like to see others, do some research on it. =)

12. Software Life Cycle – 6 Phases  Analysis and task specification.  Design of the software.  Implementation (coding).  Testing.  Maintenance and evolution of the system.  Obsolescence.

13. Analysis Phase  During this phase, many questions are answered in particular the question: WHAT must the software do?  Here it must be determined what the software is expected to do by the person paying for the development and by the expected users.  Usually specifications are set in this phase – or rather the software’s requirements.

14. Design Phase  This phase answers the question: HOW must the software do (whatever)? and the (whatever) was determined in the Analysis phase.  In this phase algorithms will be selected or created as needed.  The (program and data) structure of the software should also be determined here.

15. Implementation (coding) Phase  Once the algorithms are determined, they will be coded (programmed into the computer).  Sometimes (often) this phase will lead back to the design phase as unforeseen problems in the design are encountered.

16. Testing Phase  Testing is often broken down into small pieces so that each part of a piece of software is tested at first.  Once each small part is tested then larger parts are tested and eventually the final product will be tested (all this is theoretical of course =)  Testing is sometimes incorporated into the Design and/or the Implementation Phase and you will bounce back and forth as debugging takes place.

17. Maintenance Phase  This phase begins immediately after the program is ‘released’ for use.  Inevitably more bugs are found as time goes on and more needs will arise, so the software will need to be maintained – to fix previously unknown bugs, to modify the code to meet new needs, to fix new bugs introduced by the maintenance process itself and so on.

18. Obsolescence Phase  This phase is entered when a piece of software is seen to no longer have any value.  This does not always mean the software is removed completely from use.  It means that the maintenance phase will no longer occur and that using an obsolete piece of software is ‘at your own risk.’  This phase often occurs when a company changes operating systems or computer systems or when technology simply advances beyond the software and better software is available.

19. End Software Engineering