Software Engineering

Introduction to Software Engineering :    
                      

 Computers are becoming a key element in our daily lives. Slowly and surely they are taking over many of the functions that affect our lives critically. They are now controlling all forms of monetary transactions, manufacturing, transportation, communication, defence systems, process control systems, and so on. In the near future, they will be found in our homes, controlling all forms of appliances. Left to themselves, they are harmless pieces of hardware. Load the right kind of software, they can take you to the moon, both literally and figuratively. It is the software that gives life to them.When they are going to play such a crucial role, one small flaw either in the hardware or the software can lead to catastrophic consequences. The sad part is, while there are well defined processes based on theoretical foundations to ensure the reliability of the hardware, same thing can not be said about software.

 There is no theory for software devlopment as yet. But at the same time, it is mandatory that software always behaves in a predictable manner, even in unforeseen circumstances. Hence there is a need to control its development through a well defined and systematic process. The old fashioned 'code & test' approach will not do any more. It may be good enough for 'toy' problems, but in real life, software is expected to solve enormously complex problems. Some of the aspects of real life software projects are:

 

	Team effort: Any large development effort requires the services of a team of specialists. For example the team could consist of domain experts, software design experts, coding specialists, testing experts, hardware specialists, etc. Each group could concentrate on a specific aspect of the problem and design suitable solution. However no group can work in isolation. There will be constant interaction among team members.
	Methodology: Broadly there are two types of methodologies, namely, 'procedure oriented methodolgies' and 'object oriented methodologies'. Though theoretically either of them could be used in any given problem situation, one of them should be chosen in advance.
	Documentation: Clear and unambiguous documentation of the artifacts of the development process are critical for the success of the software project. Oral communication and 'back of the envelop designs' are not sufficient. For example, documentation is necessary if client signoff is required at various stages of the process. Once developed, the software lives for a long time. During its life, it has to undergo lot of changes. Without clear design specifications and well documented code, it will be impossible to make changes.
	Planning: Since the development takes place against a client's requirements it is imperative that the whole effort is well planned to meet the schedule and cost constraints.
	Quality assurance: Clients expect value for money. In addition to meeting the client's requirements, the software should also meet additional quality constraints. They could be in terms of performance, security, etc.
	Lay user: Most of the time, these software packages will be used by non-computer savvy users. Hence the software has to be highly robust.
	Software tools: Documentation is important for the success of a software project, but it is a cumbersome task and many software practitioners balk at the prospect of documentation. There are tools known as Computer Aided Software Engineering (CASE) tools which simplify the process of documentation.
	Conformance to standards: We need to follow certain standards to ensure clear and unambiguous documentation. For example, IEEE standards for requirements specifications, design, etc. Sometimes, clients may specify the standards to be used.
	Reuse: The development effort can be optimised, by reusing well-tested components. For example, mathematical libraries, graphical user interface tool kits, EJBs, etc.
	Non-developer maintenance: Software lives for a long time. The development team, may not be available to maintain the package. Some other team will have to ensure that the software continues to provide services.
	Change management: Whenever a change has to be made, it is necessary to analyse its impact on various parts of the software. Imagine modifying the value of global variable. Every function that accesses the variable will be effected. Unless care is taken to minimise the impact, the software may not behave as expected.
	Version control: Once changes are made to the software, it is important that the user gets the right version of the software. In case of failures, it should be possible to roll back to the previous versions.
	Subject to risks: Any large effort is subject to risks. The risks could be in terms of non-availability of skills, technology, inadequate resources, etc. It is necessary to constantly evaluate the risks, and put in place risk mitigation measures.

Software Quality :

The goal of any software development process is to produce high quality software. What is software quality? It has been variously defined as:

	Fitness for purpose
	Zero defects
	Conformability & dependability
	The ability of the software to meet customer's stated and implied needs

  Some of the important attributes that can be used to measure software quality are:  

	Correctness: Software should meet the customer's needs
	Robustness: Software must always behave in an expected manner, even when unexpected inputs are given
	Usability: Ease of use. A software with a graphical user interface is considered more user-friendly than one without it
	Portability: The ease with which software can be moved from one platform to another
	Efficiency: Optimal resource (memory & execution time) utilization
	Maintainability: Ease with which software can be modified
	Reliability: The probability of the software giving consistent results over a period of time
	Flexibility: Ease with which software can be adapted for use in different contexts
	Security: Prevention of unauthorised access
	Interoperabilty: The abilty of the software to integrate with existing systems
	Performance: The ability of the software to deliver the outputs with in the given constraints like time, accuracy, memory usage

 

      Correctness is the most important attribute. Every software must be correct. The other attributes may be present in varying degrees. For example, it is an expensive proposition to make a software 100% reliable and it is not required in all contexts. If the software is going to be used in life critical situations, then 100% reliability is mandatory. But, say, in a weather monitoring system, a little less reliability may be acceptable. However, the final decision lies with the client. One should keep in mind that some of the above attributes conflict with each other. For example, portability and efficiency could conflict with each other. To improve efficiency, one may resort to using system dependent features. but that will affect the portability. In the days, when DOS ruled the world, it was possible to access the internal architecture directly to improve performance. To port such a program to any other platform would require enormous changes. So in practice there will always be a tradeoff

3. What is a Process

  3.2 Process: Definition and Phases  

      A Process is a series of definable, repeatable, and measurable tasks leading to a useful result. The benefits of a well defined process are numerous.

 

	It provides visibility into a project. Visibility in turn aids timely mid-course corrections
	It helps developers to weed out faults at the point of introduction. This avoids cascading of faults into later phases
	It helps to organize workflow and outputs to maximize resource utilization
	It defines everybody's roles and responsibilities clearly.
	Individual productivity increases due to specialization and at the same time the team's productivity increases due to coordination of activities

  A good software development process should:  

	View software development as a value added business activity and not merely as a technical activity
	Ensure that every product is checked to see if value addition has indeed taken place
	Safeguard against loss of value once the product is complete
	Provide management information for in-situ control of the process

  To define such a process the following steps need to be followed:  

	Identify the phases of development and the tasks to be carried out in each phase
	Model the intra and inter phase transitions
	Use techniques to carry out the tasks
	Verify and Validate each task and the results
	Exercise process and project management skills

 

      The words 'verify' and 'validate' need some clarification. Verify means to check if the task has been executed correctly, while validate means to check if the correct task has been executed. In the context of software, the process of checking if an algorithm has been implemented correctly, is verification, while the process of checking if the result of the algorithm execution is the solution to the desired problem, is validation.

 

The generic phases that are normally used in a software development process are:

 

	Analysis: In this phase user needs are gathered and converted into software requirements. For example, if the user need is to generate the trajectory of a missile, the software requirement is to solve the governing equations. This phase should answer the question: what is to be done to meet user ne eds?
	Design: This phase answers the question: How to meet the user needs? With respect to the above example, design consists of deciding the algorithm to be used to solve the governing equations. The choice of the algorithm depends on design objectives like execution time, accuracy, etc. In this phase we determine organisation of various modules in the software system
	Construction: Coding is the main activity in this phase
	Testing: There are three categories of testing: unit testing, integration testing, and system testing. There are two types of testing: Black box testing and White box testing. Black box testing focuses on generating test cases based on requirements. White box testing focuses on generating test cases based on the internal logic of various modules
	Maintenance: Maintenance is the last stage of the software life cycle. After the product has been released, the maintenance phase keeps the software up to date with environment changes and changing user requirements. The earlier phases should be done so that the product is easily maintainable. The design phase should plan the structure in a way that can be easily altered. Similarly, the code should be in such a way that it is easily read, understood, and changed. Maintenance can only happen efficiently if the earlier phases are done properly.