Unit-1
Introduction
Software engineering works with a variety of software production methods. It accompanies software product development using well-defined scientific principles, methods and processes. The result of software engineering is an efficient and reliable software product.
The term software engineering is coined with the addition ‘software + engineering’. Software is more than just program code. The program is a usable code, which serves a specific calculation purpose. Software is considered a collection of effective editing code, compatible libraries and texts. Software, when required for a specific purpose, is called product software.
According to IEEE: Software Engineering is the systematic approach to the development, operation, maintenance and retirement of the software.
According to Bohem: “Software Engineering is the application of science and mathematics by which capabilities of computer equipment are made useful to man through computer programs, procedures and related documentations.”
Software Engineering is based on the following disciplines:
● Computer Science
● Management Science
● Economics
● Communication Skills
● Engineering approach to problem solving
Software Engineering is a branch of engineering that uses well-defined scientific principles, techniques and procedures to develop software products. A successful and reliable software product is the result of software engineering.
Key takeaway:
There are three components of the software:
Program: A computer program is a set of instructions that instructs a computer about how to perform certain tasks.
Documentation: Design documents, comprehensive code statements, and other sources of product knowledge.
Operating Procedures: An organization's compilation of step-by-step instructions to assist personnel in performing complex routine operations.
● Off the shelf Components: Software that is already available and can be purchased from a third party.
● Full Experience Components: Existing previous projects that are similar to the software to be developed for the current project have already been completed, and team members have extensive experience.
● Partial Experience components: Existing Past projects that are similar to the software that will be developed for the current project but need significant changes.
● New Components: Computer modules that must be designed specifically for the needs of the current project by the software team.
It refers to how well the program performs in comparison to its intended function. The following functions are required:
● Functionality: Refers to the degree of performance of the software against its intended purpose. A collection of characteristics that relate to software's ability to sustain its level of performance under specified conditions for a specified period of time.
The following functions are required:
● Suitability
● Security
● Accuracy
● Interoperability
● Reliability: Refers to the ability of software to perform a required function under given conditions for a specified period.
Required functions are:
● Maturity
● Recoverability
● Usability: Refers the degree to which software is easy to use. It describes the ease with which the program can be used. the amount of time or effort it takes to learn how to use the app.
The following functions are required:
● Operability
● Understandability
● Learnability
● Efficiency: Refers to the ability of software to use system resources in the most effective and efficient manner.
The following functions are required:
● In Resource
● In Time
● Maintainability: Refers to the ease with which a software system can be modified to add capabilities, improve system performance, or correct errors.
The following functions are required:
● Testability
● Stability
● Changability
● Portability: Refers to the ease with which software developers can transfer software from one platform to another, without (or with minimum) changes Robustness: it is the ability of a software to handle unexpected errors and faults with ease.
The following functions are required:
● Adaptability
● Installability
● Replaceability
● Size and cost: Software's sophistication and expectations are increasing on a daily basis. Software is becoming more costly and complex.
● Quality: The quality of software products must be high.
● Delayed Delivery: The development of software takes longer than anticipated, resulting in increased costs.
● Many software programs collapsed during the late 1960s.
● A lot of apps went over budget. The result was faulty software that was costly to maintain.
● Maintaining larger software was difficult and costly.
● Many pieces of software are unable to meet the ever-increasing demands of customers.
● As the hardware capability of a software project grew, the complexity of the project increased as well.
● When opposed to the ability to produce new applications, demand for new software grew faster.
Most of the above problems result in a 'Software Crisis.'
The Solution
The problem was solved by turning a disorganized coding effort into a software engineering discipline. These innovation models aided businesses in streamlining processes and delivering applications that met consumer needs.
● Software engineering principles were widely used in the late 1970s.
● In the 1980s, the software engineering process was automated, and CASE (Computer-Aided Software Engineering) grew in popularity.
● In the 1990s, there was a greater focus on the 'management' aspects of programs, such as ISO 9001 quality standards and processes.
The word software refers to a set of computer programs, procedures, and supporting documents (flowcharts, instructions, and so on) that explain the program and how it should be used.
A software process is a set of activities and their results that result in a software product. These tasks are often carried out by software engineers. These are the four main process operations that all software systems have in common.
These are the activities:
2. Software Development: Designing, scripting, logging, checking, and bug fixing are all part of this process.
3. Software Validation: This method involves evaluating software products to ensure that they fulfill both market and end-user requirements.
4. Software Evolution: It is the method of first designing software and then upgrading it on a regular basis for different purposes.
Key takeaway:
Similarity
● Both are gradually being automated.
● Both need a thorough understanding of their respective fields.
● Unlike doctors, both have set work hours much of the time.
● Both are attempting to improve the environment in some way.
Differences
● Software engineers earn a lot of money right out of the gate.
● Engineers with a traditional background have more opportunities in the government sector.
● Software engineers have a greater chance of settling in another country.
● Software Engineers work in an office environment, while traditional engineers are more physically involved.
Software Quality Attributes include attributes like availability, interoperability, correctness, reliability, learnability, robustness, maintainability, readability, extensibility, testability, effectiveness, and portability that help Software Testing professionals measure the performance of a software product.
High Software Quality Attributes scores enable software architects to ensure that a software application can work according to the client's requirements.
Availability: This property indicates whether or not an application will complete the tasks it has been given. Certain principles related to software protection, performance, integrity, reliability, dependability, and confidentiality are also included in availability. Furthermore, top-notch availability means that a software-driven system can correct any operating faults so that service interrupt times are kept to a minimum.
Interoperability: To complete these tasks, software-driven systems may be required to communicate and function in concert. The capacity of two systems to share information through specific interfaces is referred to as interoperability.
Performance: This characteristic refers to a software-driven system's ability to adhere to time constraints. It implies that Software Testing engineers must check whether the device reacts to different events within given time limits from a testing standpoint. Clock events, process interruptions, notifications, and requests from various users, among other things, are examples of these events.
Testability: Software testability refers to how well a software-driven framework enables Software Testing practitioners to perform tests according to predefined requirements. This criterion also considers how easy it is for Software Quality Assurance engineers to create test standards for a system and its various components. Engineers can evaluate a system's testability using a variety of techniques, including encapsulation, interfaces, patterns, low coupling, and more.
Security: This attribute assesses a system's ability to detect and prevent malicious or unwanted acts that could endanger the system. The attribute takes on significance because protection refers to a system's ability to protect data and information from unauthorized access. Authorization and authentication techniques, network attack prevention, data encryption, and other threats are all part of security. It is important for Software Testing practitioners to perform updated security tests on systems on a regular basis.
Usability: Every software-driven system is made to be simple to use in order to complete specific tasks. Usability is an attribute that describes how easy it is for users to complete tasks on a system, as well as the level of user support offered by the system. KISS is the most well-known property theory. Computer Quality Assurance engineers must also monitor software to see if it supports various forms of accessibility controls for people with disabilities. Usability has a long history of influencing a software application or package's commercial success.
Functional: The adherence of a software-driven system to real requirements and specifications is determined by this attribute. Most Software Testing practitioners consider this feature to be critical and a top requirement of a modern application, and would therefore recommend performing tests that evaluate the desired functionality of a device early in the Software Testing process.
Key takeaway:
● SDLC is a process used by software industry to design develop and test high quality software.
● SDLC is a framework defining tasks performed at each step in the software development process.
Fig 1: Software Development Life Cycle
● SDLC process is divided into following stages
● Requirement gathering and analysis: In this stage the team members get detailed and precise requirements. This helps the company to calculate the risks involved and finalize the necessary timeline to finish the work and also to give quality assurance.
● Feasibility study: The next step is to define and document the software needs. This stage is completed with the help of SRS (Software Requirement Specification). It involves everything which should be designed and developed during the project life cycle.
● Design: In this stage, the system and software design documents are prepared as per the SRS document. This helps to define overall system architecture.
● Coding: In this stage, the developers start building systems by writing codes using chosen programming language.
● Testing: This phase includes the debugging process. All the flaws are detected here, documented and passed back to the developer to fix. This continues till all the flaws are removed.
● Deployment: When the program is finalized and has no issues, then it is ready to be launched for the end users
Software Development Life Cycle Models
● Waterfall Model
● Prototyping Model
● Evolutionary Model
● Spiral Model
● Iterative Enhancement Models
Waterfall Model
● It is a simplest model, which states that the phases are organized in a linear order.
● The model was originally proposed by Royce.
● The various phases in this model are
● Feasibility Study – The main aim of the feasibility study activity is to determine whether it would be financially and technically feasible to develop the product. The feasibility study activity involves the analysis of the problem and collection of all relevant information relating to the product such as the different data items which would be input to the system, the processing required to be carried out on these data, the output data required to be produced by the system as well as various constraints on the behavior of the system.
● Requirement Analysis – The aim of the requirement analysis is to understand the exact requirements of the customer and to document them properly. The requirement analysis activity is begun by collecting all relevant data regarding the product to be developed from the users of the product and from the customer through interviews and discussions. During this activity, the user requirements are systematically organized into a software requirement specification (SRS) document. The important components of this document are the functional requirements, the nonfunctional requirements, and the goals of implementation. The SRS document is written in end-user terminology. This makes the SRS document understandable by the customer. After all, it is important that the SRS document be reviewed and approved by the customer.
● Design – This phase is concerned with
● Identifying software components like functions, data streams and data stores.
● Specifying software structure.
● Maintaining a record of design decisions and providing.
● There are two categories of Design:
■ Architectural Design – It involves
● Identifying the software components.
● Decoupling and decomposing the software component into modules and conceptual data structures.
● Specifying the interconnection between the various blueprints for the implementation phase
■ Detailed Design – It is concerned with details of the implementation procedures to process the algorithms, data structures and interaction between the modules and data structures. The various activities that this phase includes are
● Adaptation of existing code.
● Modification of existing algorithms.
● Design of data representation and
● Packaging of the software product.
This process is highly influenced by the programming language under which the implementation would be carried out. This stage is different from implementation.
● Implementation – It involves the translation of the design specifications into source code. It also involves activities like debugging, documentation and unit testing of the source code. In this stage various styles of programming can be followed like built-in and user defined data types, secure type checking, flexible scope rules, exception handling, concurrency control etc.
● Testing – It involves two kinds of activities
● Integration Testing – It involves testing of integrating various modules and testing their overall performance due to their integration.
● Acceptance Testing – It involves planning and execution of various types of tests in order to demonstrate that the implemented software system satisfies the requirements stated in the requirements document.
● Maintenance – In this phase the activities include
● Corrective Maintenance – Correcting errors that were not discovered during the product development phase.
● Perfective Maintenance – Improving the implementation of the system, and enhancing the functionalities of the system according to customer’s requirements.
● Adaptive Maintenance – Adaptation of software to new processing environments.
Fig 2: Classical waterfall model
Advantages of Waterfall model
● All phases are clearly defined.
● One of the most systematic methods for software development.
● Being oldest, this is one of the time-tested models.
● It is simple and easy to use.
Disadvantages of Waterfall Model
● Real Projects rarely follow sequential models.
● It is often difficult for the customer to state all requirements explicitly.
● Poor model for complex and object-oriented projects.
● Poor model for long and ongoing projects.
● High amount of risk and uncertainty.
● Poor model where requirements are at a moderate to high risk of changing.
● This model is suited to automate the existing manual system for which all requirements are known before the design starts. But for new system, having such unchanging requirements is not possible.
Prototyping Model
Fig 3: Prototyping model of software development
● Often, a customer defines a set of general objectives for software, but does not identify detailed input, processing, or output requirements. In other cases, the developer may be unsure of the efficiency of an algorithm, the adaptability of an operating system, or the form that human-machine interaction should take. In these and many other situations, a prototyping paradigm may offer the best approach.
● The various phases of this model are
● Listen to Customer: - This is the starting step, where the developer and customer together
■ Define the overall objectives for the software,
■ Identify the known requirements and
■ The analyst then outlines those factors and requirements that are not visible normally but are mandatory from a development point of view.
● Build prototype: - After the identification of the problem a quick design is done which will cause the software to show the output that the customer wants. This quick design leads to the development of a prototype (a temporary working model).
● Customer test drives the prototype: - The customer runs and checks the prototype for its perfection. The prototype is evaluated by the customer and further improvements are made to the prototype unless the customer is satisfied.
● All the stages are repeated until the customer gets satisfied. When the final prototype is fully accepted by the customer then final development processes like proper coding for attaining maintainability, proper documentation, testing for robustness etc. are carried out. And finally the software is delivered to the customer.
Advantages
● It serves as the mechanism for identifying the requirements.
● The developer uses the existing program fragment means it helps to generate the software quickly.
● Continuous developer – Consumer communication is available.
Disadvantages
● Customer considers the prototype as an original working version of the software.
● Developer makes implementation compromises in order to get the prototype working quickly.
● This model is time consuming.
Evolutionary Model
SDLC Evolutionary model builds the required product in several successive versions and hence is also known as successive version model or incremental model
● In this model the requirement is broken down into different functional units
● These functional units are known as modules
● The functionality improvements are done in these modules until the desired system is realized
● Each successive version is capable of performing more functions than the previous versions
Release of different evolutionary versions in SDLC:
Fig 4: Evolutionary development of a software product
● Each of the version will be released with some new functionalities added to the older one
● Here B will have more functionality than A, but will exhibit less capability than C
● As the system is viewed to be developed in incremental way so it is also termed as incremental model of development
Advantages:
● In this model the user gets a chance to experiment partially developed system
● It reduces the error because the core modules get tested thoroughly
Disadvantages:
● Sometimes it becomes hard to divide the problem into several versions that would be acceptable to the customer which can be incrementally implemented and delivered.
Fig 5: Evolutionary model of software development
Types of project for which it is suitable:
● The evolutionary model is basically useful for very large products.
● Rather than waiting for the full product, the customer prefers to receive the product in increments so that he can start using them.
Spiral Model
● Evolutionary software process model that couples the iterative nature of prototyping with the controlled and systematic aspects of the linear sequential model.
● It provides the potential for rapid development of incremental versions of the software.
● Using the spiral model, software is developed in a series of incremental releases. During early iterations, the incremental release might be a paper model or prototype. During later iterations, increasingly more complete versions of the engineered system are produced.
● A spiral model is divided into a number of framework activities, also called task regions.
● There are six task regions.
● Customer communication—tasks required to establish effective communication between developer and customer.
● Planning—tasks required to define resources, timelines, and other project related information.
● Risk analysis—tasks required to assess both technical and management risks.
● Engineering—tasks required to build one or more representations of the application.
● Construction and release—tasks required to construct, test, install, and provide user support (e.g., documentation and training).
● Customer evaluation—tasks required to obtain customer feedback based on evaluation of the software representations created during the engineering stage and implemented during the installation stage.
Fig 6: Spiral model of software development
Advantages:
● It is a realistic approach for development of large scale systems.
● High amount of risk analysis.
● Good for large and mission-critical projects.
● Software is produced early in the software life cycle.
Disadvantages:
● It is not widely used.
● It may be difficult to convince customers (particularly in contract situations) that the evolutionary approach is controllable.
● It demands considerable risk assessment expertise and relies on this expertise for success. If a major risk is not uncovered and managed, problems will undoubtedly occur.
● Can be a costly model to use.
● Risk analysis requires highly specific expertise.
● Project’s success is highly dependent on the risk analysis phase.
● Doesn’t work well for smaller projects.
Iterative Enhancement Models
The iterative enhancement model, also known as the incremental model, incorporates the functionality of the waterfall model in an iterative manner. The waterfall model completes each step of software development, while the incremental model has phases that are similar to the linear sequential model and prototyping is iterative.
The project is divided into small subsets known as increments, which are introduced one at a time during the implementation process. This model has many stages, each of which generates an increment. These increments are defined at the start of the development phase, and each increment goes through the entire process from collecting specifications to delivering the product.
The basic concept behind this model is to begin with specifications and iteratively improve them before the final software is implemented. In addition, similar to prototyping, the increment generates input from the consumer by defining the software's specifications. This method is advantageous since it simplifies the software development process because smaller steps are simpler to incorporate than the entire framework.
Each stage of the incremental model introduces a new feature to the product before moving on to the next. The first increment is commonly referred to as a core product, and it is used by the consumer to conduct a thorough assessment. As a result of this procedure, a schedule for the next increment is established.
This strategy specifies how the product will be modified (features or functions) in order to meet consumer needs. The iteration process continues until the program is fully developed, which involves delivering increments to the customer.
The increments lead to implementations, which are evaluated in order to monitor the product's development.
Fig 7: Iterative enhancement model
Advantages:
● Avoids the issues that arise as a result of the software's risk-based approach.
● With refinement, one's understanding grows.
● Until adding features to applications, performs a cost-benefit analysis.
● With each iteration, the successful solution grows incrementally.
● There isn't a lot of ambiguity involved.
● Since only a small portion of the program is implemented at a time, early feedback is provided.
Disadvantages:
● This necessitates management and professional preparation.
● Whether there is a time limit on the project timeline or when the customers are unable to accept the staggered deliverables, it becomes invalid.
Key takeaway:
References:
2. Pankaj Jalote, Software Engineering, Wiley
3. Rajib Mall, Fundamentals of Software Engineering, PHI Publication.
4. https://www.geeksforgeeks.org/software-processes-in-software-engineering
