*Why Software Engineering?

*Why Software Engineering?Software development is hard !Important to distinguish easy systems (one developer, one user, experimental use only) from hard systems (multiple developers, multiple users, products)Experience with easy systems is misleadingOne person techniques do not scale upAnalogy with bridge building:Over a stream = easy, one person jobOver River Ganga ? (the techniques do not scale)

*Engineering approach to develop software.Building Construction Analogy.Systematic collection of past experience:techniques, methodologies,guidelines.

*Why Study Software Engineering? (1)To acquire skills to develop large programs. Exponential growth in complexity and difficulty level with size.The ad hoc approach breaks down when size of software increases.

*Why Study Software Engineering? (2)Ability to solve complex programming problems: How to break large projects into smaller and manageable parts?Learn techniques of: specification, design, interface development, testing, project management, etc.

*Why Study Software Engineering? (3)To acquire skills to be a better programmer: Higher Productivity Better Quality Programs

*Programs versus Software ProductsUsually small in sizeAuthor himself is sole userSingle developerLacks proper user interfaceLacks proper documentationAd hoc development. LargeLarge number of usersTeam of developersWell-designed interfaceWell documented & user-manual preparedSystematic development

*The problem is complexityMany sources, but size is key:UNIX contains 4 million lines of codeWindows 2000 contains 108 lines of code

Software engineering is about managing this complexity.

*Software Engineering PracticeHeavy use of past experience:Past experience is systematically arranged.Theoretical basis and quantitative techniques provided.Many are just thumb rules.Pragmatic approach to cost-effectiveness

* What is software engineering?Software engineering is an engineering discipline which is concerned with all aspects of software production

Software engineers should adopt a systematic and organised approach to their work use appropriate tools and techniques depending on the problem to be solved, the development constraints and the resources available

*The IEEE Standard Glossary of Software Engineering terminology(IEE83) defines software engineering as: The systematic approach to the development, operation, maintenance, and retirement of software, where software is defined as : Computer programs, procedures, rules, and possibly associated documentation and data pertaining to the operation of a computer system.

*Software CrisisSoftware products:fail to meet user requirements.frequently crash.expensive.difficult to alter, debug, and enhance.often delivered late.use resources non-optimally.

Software Crisis (cont.)YearHw costSw costRelative Cost of Hardware and Software19601999

Factors Contributing to the Software CrisisLarger problems, Lack of adequate training in software engineering,Increasing skill shortage, Low productivity improvements.

*Symptom of Software Crisisabout US$250 billion spent per year in the US on application developmentof this, about US$140 billion wasted due to the projects getting abandoned or reworked; this in turn because of not following best practices and standardsRef: Standish Group, 1996

*Symptom of Software Crisis10% of client/server apps are abandoned or restarted from scratch 20% of apps are significantly altered to avoid disaster40% of apps are delivered significantly late Source: 3 year study of 70 large c/s apps 30 European firms. Compuware (12/95)

Software Productis a product designated for delivery to the usersource codesobject codesplansreportsmanualsdocumentstest suitesprototypesdatatest results

*Emergence of Software EngineeringEarly Computer Programming (1950s):Programs were being written in assembly language. Programs were limited to about a few hundreds of lines of assembly code.

*Early Computer Programming (50s)Every programmer developed his own style of writing programs:according to his intuition (exploratory programming).

*High-level languages such as FORTRAN, ALGOL, and COBOL were introduced:This reduced software development efforts greatly. High-Level Language Programming (Early 60s)

*Software development style was still exploratory. Typical program sizes were limited to a few thousands of lines of source code.High-Level Language Programming (Early 60s)

*Control Flow-Based Design (late 60s)Size and complexity of programs increased further:exploratory programming style proved to be insufficient. Programmers found:very difficult to write cost-effective and correct programs.

*Control Flow-Based Design (late 60s)Programmers found:programs written by others very difficult to understand and maintain. To cope up with this problem, experienced programmers advised: ``Pay particular attention to the design of the program's control structure.'

*Control Flow-Based Design (late 60s) A program's control structure indicates: the sequence in which the program's instructions are executed.To help design programs having good control structure:flow charting technique was developed.

*Control Flow-Based Design (late 60s) Using flow charting technique: one can represent and design a program's control structure. Usually one understands a program:by mentally simulating the program's execution sequence.

*Control Flow-Based Design (Late 60s)A program having a messy flow chart representation: difficult to understand and debug.

*Control Flow-Based Design (Late 60s)It was found:GO TO statements makes control structure of a program messyGO TO statements alter the flow of control arbitrarily. The need to restrict use of GO TO statements was recognized.

*Control Flow-Based Design (Late 60s)

Many programmers had extensively used assembly languages. JUMP instructions are frequently used for program branching in assembly languages, programmers considered use of GO TO statements inevitable.

*Control Flow-Based Design (Late 60s)

Soon it was conclusively proved:only three programming constructs are sufficient to express any programming logic:sequence (e.g. a=0;b=5;)selection (e.g.if(c=true) k=5 else m=5;)iteration (e.g. while(k>0) k=j-k;)

*Control-flow Based Design (Late 60s)Everyone accepted:it is possible to solve any programming problem without using GO TO statements.This formed the basis of Structured Programming methodology.

*Structured ProgrammingA program is called structured when it uses only the following types of constructs:sequence, selection, iteration

*Structured programsUnstructured control flows are avoided. Consist of a neat set of modules.Use single-entry, single-exit program constructs.

*However, violations to this feature are permitted:due to practical considerations such as:premature loop exit to support exception handling.Structured programs

*Structured programsStructured programs are:Easier to read and understand, easier to maintain, require less effort and time for development.

*Structured Programming Research experience shows: programmers commit less number of errors while using structured if-then-else and do-while statements compared to test-and-branch constructs.

*Data Structure-Oriented Design (Early 70s)Soon it was discovered:it is important to pay more attention to the design of data structures of a program than to the design of its control structure.

*Data Structure-Oriented Design (Early 70s)Techniques which emphasize designing the data structure: derive program structure from it:are called data structure-oriented design techniques.

*Data Flow-Oriented Design (Late 70s) Data flow-oriented techniques advocate: the data items input to a system must first be identified, processing required on the data items to produce the required outputs should be determined.

*Data Flow-Oriented Design (Late 70s)Data flow technique identifies:different processing stations (functions) in a system the items (data) that flow between processing stations.

*Data Flow-Oriented Design (Late 70s)Data flow technique is a generic technique:can be used to model the working of any systemnot just software systems. A major advantage of the data flow technique is its simplicity.

*Data Flow Model of a Car Assembly Unit FitEnginePaint and Test FitWheels FitDoorsChassis Store Door Store Wheel StoreEngine StoreCarPartly Assembled CarAssembled CarChassis with Engine

*Object-Oriented Design (80s)Object-oriented technique:an intuitively appealing design approach: natural objects (such as employees, pay-roll-register, etc.) occurring in a problem are first identified.

*Object-Oriented Design (80s)Relationships among objects:such as composition, reference, and inheritance are determined. Each object essentially acts as a data hiding (or data abstraction) entity.

*Object-Oriented Design (80s)Object-Oriented Techniques have gained wide acceptance:SimplicityReuse possibilitiesLower development time and costMore robust codeEasy maintenance

*Evolution of Design TechniquesObject-OrientedAd hocData flow-basedData structure-basedControl flow-based

*What is the difference between software engineering and system engineering?Software engineering is part of System engineeringSystem engineering is concerned with all aspects of computer-based systems development including hardware, software and process engineeringSystem engineers are involved in system specification, architectural design, integration and deployment

*Computer Systems EngineeringComputer systems engineering: encompasses software engineering.

Many products require development of software as well as specific hardware to run it: a coffee vending machine, a mobile communication product, etc.

*Computer Systems EngineeringThe high-level problem:deciding which tasks are to be solved by software which ones by hardware.

*Computer Systems Engineering (CONT.) Often, hardware and software are developed together:Hardware simulator is used during software development.Integration of hardware and software.Final system testing

*Computer Systems Engineering (CONT.)Feasibility StudyRequirements Analysis and SpecificationHardware Software PartitioningHardware DevelopmentSoftware DevelopmentIntegration and TestingProject Management

*What is CASE ? (Computer-Aided Software Engineering)Upper-CASETools to support the early process activities of requirements and designLower-CASETools to support later activities such as programming, debugging and testingSoftware systems which are intended to provide automated support for software process activities, such as requirements analysis, system modelling, debugging and testing

*What are the key challenges facing software engineering?Software engineering in the 21st century faces three key challenges:Legacy systemsOld, valuable systems must be maintained and updatedHeterogeneitySystems are distributed and include a mix of hardware and softwareDeliveryThere is increasing pressure for faster delivery of software

*Evolution of Other Software Engineering Techniqueslife cycle models, specification techniques, project management techniques, testing techniques, debugging techniques, quality assurance techniques, software measurement techniques, CASE tools, etc.

*Differences Between the Exploratory Style and Modern Software Development PracticesUse of Life Cycle Models Software is developed through several well-defined stages: requirements analysis and specification,design, coding, testing, etc.

*Differences Between the Exploratory Style and Modern Software Development PracticesEmphasis has shifted from error correction to error prevention. Modern practices emphasize:detection of errors as close to their point of introduction as possible.

*Differences Between the Exploratory Style and Modern Software Development Practices (CONT.)In exploratory style, errors are detected only during testing,Now, focus is on detecting as many errors as possible in each phase of development.

*Differences Between the Exploratory Style and Modern Software Development Practices (CONT.)In exploratory style, coding is synonymous with program development. Now, coding is considered only a small part of program development effort.

*Differences Between the Exploratory Style and Modern Software Development Practices (CONT.)A lot of effort and attention is now being paid to: requirements specification. Also, now there is a distinct design phase:standard design techniques are being used.

*Differences Between the Exploratory Style and Modern Software Development Practices (CONT.)During all stages of development process:Periodic reviews are being carried out Software testing has become systematic:standard testing techniques are available.

*Differences Between the Exploratory Style and Modern Software Development Practices (CONT.)There is better visibility of design and code: visibility means production of good quality, consistent and standard documents.In the past, very little attention was being given to producing good quality and consistent documents. We will see later that increased visibility makes software project management easier.

*Differences between the exploratory style and modern software development practices (CONT.)Because of good documentation:fault diagnosis and maintenance are smoother now.Several metrics are being used: help in software project management, quality assurance, etc.

*Differences between the exploratory style and modern software development practices (CONT.)Projects are being thoroughly planned: estimation, scheduling, monitoring mechanisms. Use of CASE tools.

*Why Model Life Cycle ?A written description:forms a common understanding of activities among the software developers.helps in identifying inconsistencies, redundancies, and omissions in the development process. Helps in tailoring a process model for specific projects.

*Why Model Life Cycle ?Processes are tailored for special projects.A documented process model helps to identify where the tailoring is to occur.

*Life Cycle Model (CONT.)The development team must identify a suitable life cycle model:and then adhere to it.Primary advantage of adhering to a life cycle model:helps development of software in a systematic and disciplined manner.

*Life Cycle Model (CONT.)When a software product is being developed by a team: there must be a precise understanding among team members as to when to do what, otherwise it would lead to chaos and project failure.

*Life Cycle Model (CONT.) A software project will never succeed if: one engineer starts writing code,another concentrates on writing the test document first, yet another engineer first defines the file structureanother defines the I/O for his portion first.

*Life Cycle Model (CONT.)A life cycle model:defines entry and exit criteria for every phase. A phase is considered to be complete:only when all its exit criteria are satisfied.

*Life Cycle Model (CONT.)The phase exit criteria for the software requirements specification phase: Software Requirements Specification (SRS) document is complete, reviewed, and approved by the customer. A phase can start: only if its phase-entry criteria have been satisfied.

*Life Cycle Model (CONT.)It becomes easier for software project managers:to monitor the progress of the project.

*Life Cycle Model (CONT.)When a life cycle model is adhered to, the project manager can at any time fairly accurately tell, at which stage (e.g., design, code, test, etc. ) of the project is. Otherwise, it becomes very difficult to track the progress of the project the project manager would have to depend on the guesses of the team members.

*

A software process is a series of predictable steps - a road map or a framework that helps to create a timely, high-quality product or system.

Software Process

*Software Process Models

Software process models define a distinct set of activities, actions, tasks, milestones, and work products that are required to engineer high-quality software.These process models are not perfect, but they do provide a roadmap for software engineering work.

*Life Cycle Model (CONT.)Many life cycle models have been proposed. We will confine our attention to a few important and commonly used models. classical waterfall modeliterative waterfall, evolutionary, prototyping, and spiral model

*Code & Fix Model It is a two phase model first phase is to write the code and next phase is to fix it as per clients requirements.

*

Classical Waterfall Model This process model is sequence of different phases. Each phase of the process model has well defined entry and exit criteria which needs to be well documented

*Iterative Waterfall Model

*Iterative waterfall model contd.Iterative waterfall model suggests feedback paths in the classical waterfall model from every phase to its preceding phases.to allow for the correction of the errors committed during a phase that are detected in later phases.After detecting the error in later phases, it would be necessary not only to rework the design, but also to appropriately redo the coding and the system testing, thus incurring higher cost

*V-Shaped Model

*V-Shaped Model Contd..Like waterfall model, V-shaped model is also sequential path of execution of process. Here more emphasis is given in Testing.The testing methods are developed early in the life cycle before each phases go for implementation.High level design phase focuses on system architecture and design.Low-level design phase focuses on actual software component design.Implementation phase concerned about all coding.

*DrawbacksVery rigid like the waterfall model.Not very flexible, difficult and expensive to adjust to change.No early prototype is produced.

*Prototyping Model

*The prototyping model contd.The prototyping model suggests that before carrying out the development of the actual software, a working prototype of the system should be build.

A prototype is a toy implementation of the system. It exhibits limited functional capabilities, low reliability, and inefficient performance compared to the actual software.

*Rapid Application Development (RAD) Model

*RAD continuedRAD is an incremental software process modelemphasizes a short development cycle e.g., 60 to 90 days.It is a high-speed adaptation of the waterfall model, in which rapid development is achieved by using component based construction approach.

*Drawbacks of RADRAD model is not for large projects, because it requires sufficient humane resources to create right number of RAD team.In case the developers and customers are lacking in commitment to the rapid-fire activity, RAD projects will fail.Improper modeling may lead to poor component building which is problematic.

*Spiral Model

*Spiral model starts at the center of the spiral and work in clockwise direction. Each traversal of the spiral typically results in a deliverable. The main emphasis is given in risk analysis. Different types of risks:cost overruns, change in requirements, loss of intelligent project personnel, unavailability of necessary hardware At the end of each loop of the spiral, the customers evaluate the tasks, risk analysis is performed. If the risks are too high then the project is terminated.

*Commercial off-the shelf (COTS) ModelCommercial off-the shelf (COTS) software component, developed by vendors who offer them as products, can be used when software is to be built.It is evolutionary in nature, demanding an iterative approach to the creation of the software.It leads to software reuse,Reusability provides software engineers with a number of measurable benefits like reduction in development cycle time, reduction in project cost etc.

*Unified Process Model

*Contd..The Unified Process Model is a use-case driven, architecture-centric, iterative and incremental.In its early stage only it includes the five different views of the software the use-case model, the design model, the implementation model, and the deployment model.At times it uses executable architectural baseline which is not a thrown away prototype, instead the baseline is substantiate during the later phases.It is a framework for object oriented software engineering using UML (Unified Modeling Language).UML only provides the necessary technology to support object-oriented software engineering practice.

*The Agile ViewAn agile philosophy for software engineering stresses four key issues:Individuals and interactions over processes and toolsWorking software over comprehensive documentationCustomer collaboration over contract negotiationResponding to change over following a plan

*Agile process models are:Extreme Programming (XP)Adaptive Software Development (ASD)Dynamic System Development Method (DSDM)ScrumCrystalFeature Driven Development (FDD)

*Extreme Programming (XP)

*XP Contd..In the first phase, the customers write out the story cards that they wish to be included in the first release.The customer assigns a value (i.e. a priority) to the stories and an agreement of the content of the small release is made.XP design rigorously follows the KIS (keep it simple) principle.

*XP Contd..After preliminary design work is done, XP team develop a series of unit tests.A key concept during the coding activity is pair programming.XP acceptance tests, also called customer tests, are specified by the customer and focus on overall system features and functionality that are visible and reviewable by the customer.

*XP Contd..XP encourages the use of CRC (Class- Responsibility Collaborator) cards as an effective mechanism for thinking about the software in an object-oriented context.XP recommends the immediate creation of an operational prototype, known as spike solution, for a difficult design problem. XP encourages refectoring a construction technique that is also a design technique.

*VOSDM Vision Oriented Software Development Model

Visualization Phase

Implementation Phase

Actualization Phase

*VOSDM Phases Visualization PhaseThe primary objective is to visualize the system adequately. In this phase the students write the mission statements which include the visualization of the software.

*Implementation PhaseIn the Implementation Phase the mission statements are converted into code. In this phase vigorous coding, testing and integration are done to achieve the goal at the earliest.

*Actualization PhaseHere we are giving a shape to the system from the development into production, making it available to the end user. The activities of this phase include beta testing of the system to validate it and making the system acquainted with the end users and maintainers.

*VisualizationImplementationActualizationCoding, Testing & Integration simultaneouslyDesignTest casesSystem TestingFast ReleasePictorial RepresentationReleasepair-programming

**********************************************************