SOFTWARE ENGINEERING UNIT 1

 

BY DR. AJAY KUMAR PATHAK

MJ–11 (TH): SOFTWARE ENGINEERING

F.Y.U.G.P FOR B. Sc. IT SEM 5

SOFTWARE CRISIS:- The term "software crisis" refers to the numerous challenges and difficulties faced by the software industry during the 1960s and 1970s. It became clear that old methods of developing software couldn't keep up with the growing complexity and demands of new projects. In our digital era, the software crisis is a prominent challenge. It's a situation where software systems frequently fail to meet necessary standards or performance metrics within expected timeframes and budgets. This crisis impacts the development and maintenance of software, leading to projects that are often over budget, delayed, and below quality expectations. The software crisis refers to the difficulty of writing efficient programs on time due to increasing complexity and demand. Software engineering aims to minimize this through systematic approaches.

DEFINITION:- “The term software crisis refers to the set of problems faced during the development and maintenance of computer software, particularly during the early years of software engineering ”

CAUSES OF SOFTWARE CRISIS:-

Complexity Overload: :- Software systems' increasing measure and functionality led to exponential complexity, making management and maintenance challenging.

Lack of Formalization::-Early software engineering lacked standardized processes, resulting in unstable and error-prone software development.

Changing Requirements:- Evolving requirements due to user needs or market shifts led to scope  project delays.

Insufficient Quality Assurance:-Inadequate testing caused software releases with bugs, weaknesses, and reliability issues.

Limited Reusability:-Ineffective code and component reuse across projects led to redundancy and wasted resources.

Poor Project Management:- Inefficient practices like communication gaps and unrealistic timelines caused missed deadlines and budget overruns.

Rapid Technological Advancements:- Fast-paced technology made maintaining and updating legacy systems challenging, requiring constant adaptation.

SOLUTION OF SOFTWARE CRISIS:-

Structured Methodologies:- The adoption of structured methodologies, like Waterfall and later Agile, brought systematic approaches to software development. These methodologies emphasized planning, iterative development, and continuous user feedback.

Formal Software Development:-The introduction of formal methods, including mathematical modeling and specification languages, enhanced software reliability by enabling difficult verification and validation of software designs.

Requirements Engineering:- Emphasis on thorough requirements gathering and analysis helped manage changing requirements effectively and ensuring software alignment with user needs.

Quality Assurance and Testing:- Robust testing and quality assurance practices, such as unit testing, integration testing, and automated testing, improved software reliability and minimized the occurrence of bugs and weaknesses.

Code Reusability:- The development of modular programming and component-based development allowed for greater code reusability across projects, boosting productivity and reducing redundancy.

SOFTWARE ENGINEERING PROCESSES:- The software engineering process consists of the set of activities required to conceive, design, implement, test, deploy and maintain a software system. It includes the entire lifecycle from conception to retirement of a software product. At a high level, it transforms various inputs like requirements, designs, code and test objects into outputs like executable, documentation and deployed systems. The software development process provides a systematic and quantifiable approach to build and operate software systems in order to achieve efficiency, reliability, and cost-effectiveness. It applies engineering principles to software development with the aim of producing high-quality systems that meet stakeholder needs. The process utilizes various methods, tools, standards and practices to aid development activities. Overall, the software engineering process represents all the technical and managerial activities performed by software professionals as part of software evolution across its total lifetime.

EVENTS OF A SOFTWARE PROCESS?:-

There are.

Requirements analysis;- This activity focuses on understanding the problem to be solved, analyzing, modeling, specifying, validating and managing requirements from different stakeholders. Both functional and non-functional requirements are considered.

Software project management:- This activity deals with planning, monitoring and controlling the software project to meet objectives regarding scope, cost, time, resources, quality, risk and communication.

Software architectural design:- This activity decomposes the system into major software components and defines their responsibilities, interfaces and interactions. Key aspects include identifying architectural patterns and creating high-level and low-level design models.

Detailed software design:-  This activity elaborates the software architecture and components into a detailed design model representing classes, data structures, interfaces, algorithms and other low-level specifics. Coding guidelines may also be developed.

Software implementation:-  This activity transforms the software design into executable code and associated data structures. Coding standards and guidelines are followed to implement components which realize the specified requirements.

Software testing:- This activity involves verifying software quality against documented requirements. Different testing levels include unit testing, integration testing, system testing, regression testing and user acceptance testing.

Software quality management:- This activity defines quality goals, standards and procedures to be followed by software engineers, Reviews, testing and metrics are used to ensure quality conformance.

Software deployment:- This activity installs the software system in the target production environment and makes it operational for use by end users.

Software maintenance:-  This activity manages modifications, enhancements and corrections to software after it is deployed. Includes bug fixes, updates, performance improvements and retirement.

EXAMPLES OF SOFTWARE PROCESSES:-

1.      Waterfall Model

2.      Incremental Model

3.      Iterative Model

4.      Agile Model

5.      V-Model (Validation and Verification)

6.      Spiral Model

7.      Big Bang Model

8.      RAD (Rapid Application Development)

9.      Scrum Model ( a subset of Agile)

CONVENTIONAL ENGINEERING PROCESSES OR TRADITIONAL OR SEQUENTIAL ENGINEERING:-

Conventional Engineering Processes, also known as traditional or sequential engineering, refer to a systematic approach to engineering where each stage of the product development cycle is carried out separately and sequentially. In this process, the stages include research, design, manufacturing, testing, and production. Each stage must be completed fully before the next one begins, and the flow of information is linear, going only in one direction. Errors or changes can only be addressed at the end of the process, which can lead to underestimation of costs and delays due to the need for reevaluation and corrections after a stage is completed. This approach is highly based on experimental knowledge, science, and mathematics, and it usually applies to building physical products like cars, machines, hardware, and buildings. The conventional process tends to have higher construction and development costs and focuses mainly on known and tested principles to meet product requirements.

An easy example of a conventional engineering process would be designing and manufacturing a car: First, engineers research and design the car; then, manufacturing starts only after the design is finalized. Later stages like quality control, distribution, and sales follow strictly in sequence without overlap or iteration during earlier phases. In the engineering design process can be cyclical and iterative, allowing for more flexibility and repeated modification during development to improve the product based on testing and feedback.

SIMILARITY AND DIFFERENCES FROM CONVENTIONAL ENGINEERING PROCESSES :-

SIMILARITY BETWEEN SOFTWARE ENGINEERING PROCESSES AND CONVENTIONAL ENGINEERING PROCESSES:-

Aspect	Software Engineering Processes	Conventional Engineering Processes	Example
Automation	Both become automated over time to improve efficiency	Both become automated after some stages	Automated code testing vs. automated machinery in manufacturing
Impact	Both aim to improve daily life and solve practical problems	Both make everyday life better through engineering products	Software improving communication; cars improving transport
Knowledge Depth	Require deep domain knowledge and technical expertise	Require deep scientific and experimental knowledge	Software developers know coding; mechanical engineers know materials and physics
Structure and Timing	Have structured processes with defined stages and fixed working times	Have structured, sequential stages and fixed working times	Software lifecycle phases; construction stages in building
Use of Science and Math	Employment computer science, discrete math, and logical reasoning	Employment science, mathematics, experiential data	Algorithms in software; physics in bridges
Quality Focus	Emphasize quality, correctness, and maintainability	Emphasize quality, durability, and safety	Software testing; structural integrity tests
Documentation and Standards	Use standards, frameworks, and documentation	Use physical engineering standards, building codes	Coding standards; construction codes
Iterations	Can involve iterations and refinements throughout development	Typically sequential with less iteration until final review	Agile software updates; bridge inspected after construction

 

DIFFERENCES FROM SOFTWARE ENGINEERING PROCESSES AND CONVENTIONAL ENGINEERING PROCESSES:-

S. No	Feature	Software Engineering Processes	Conventional Engineering Processes
1	Domain Focus	Computer science, programming, information technology	Science, mathematics, experimental knowledge
2	Product Nature	Intangible (software, applications)	Tangible (cars, machines, buildings, hardware)
3	Design Requirements	Can change during development (flexible)	Typically well-defined or fixed
4	Development Cost	Generally low initial construction cost	High construction and development cost
5	Application of Principles	Can include new/untested elements	Usually applies tested, known principles
6	Development Effort	Focus on building new designs and features	Focus on modifying existing designs
7	Weight	Quality, modularity, maintainability	Mass production, physical robustness
8	Complexity	Complex logic and algorithms	Complex physical properties and materials
9	Methodology	Agile, iterative, adaptive methodologies	Traditional, sequential, plan-driven approaches
10	Process Flow	Often iterative, allows for ongoing changes	Sequential and linear, stage completion before moving on
11	Cost Dynamics	Less expensive to begin, higher maintenance cost	High start-up but potentially lower maintenance
12	Standards and Frameworks	Uses software-specific standards and coding frameworks	Uses engineering standards, building codes, regulations
13	Final Product	Delivered as software, can be distributed electronically	Physical product produced and assembled

QUALITY ATTRIBUTES:-

Software Quality is a term used to measure the degree of excellence of software. Software Quality attributes are extremely important while designing a software application. There is a misconception that if the software application is bug-free then the quality of the software is high. However, a bug-free product is just one of the Software Quality Attributes. The quality of the software also depends on the user requirements, satisfaction, clearer design, usability, etc.

LIST OF SOFTWARE QUALITY ATTRIBUTES:-

1)      Reliability:- It is defined as software’s ability to operate reliably under normal and highest loads, including availability, recoverability and fault tolerance.

2)      Maintainability:- Ease with which software updates and upgrades can be implemented through its design.

3)      Usability:- How easy it is for users to interact with an application, including its UI/UX (User Interface and UX stands for User Experience ) design and accessibility features.

4)      Portability of software:- Its ability to be moved between different environments and platforms with relative ease.

5)      Correctness:- Correctness measures how closely software meets its specifications and meets user expectations.

6)      Efficiency:- It is defined as software’s effectiveness in terms of resource use, speed and memory management.

7)      Security:- Protection against unauthorities access or data breaches through encryption and authentication measures.

8)      Testability:- How easily the software can be tested and automated to detect bugs.

9)      Flexibility:- Capacity of the software to adapt quickly to changing technologies and satisfy user demands.

10)  Compatibility:- Software’s capacity to run across different systems, browsers and devices.

11)  Supportability: How easily issues in the software can be identified and rectified.

12)  Reusability: Reusing software components across applications to reduce costs and effort.

HOW SOFTWARE ENGINEERING CHANGES BY SOFTWARE DEVELOPMENT LIFE CYCLE (SDLC) MODELS: WATER FALL MODEL, PROTOTYPE MODEL, SPIRAL MODEL, EVOLUTIONARY DEVELOPMENT MODELS, ITERATIVE ENHANCEMENT MODELS.

ANSWER:- Software Engineering changes significantly depending on the Software Development Life Cycle (SDLC) model used, each impacting the approach to project phases such as requirement analysis, design, development, testing, and deployment. Here's a detailed explanation of how software engineering adapts in each major SDLC model.

SDLC MODEL:-

ü  This is a linear and sequential model where software development flows downward through distinct phases.

ü  Each phase (requirements, design, implementation, testing, deployment) must be completed fully before moving on.

ü  Changes after a phase is completed are difficult and costly.

ü  Suitable for projects with well-defined, stable requirements.

ü  Emphasizes thorough documentation and upfront planning.

ü  Example: Developing software for regulatory environments where predictability and compliance are critical such as embedded systems in aviation.

PROTOTYPE MODEL :-

ü  Focuses on creating an early prototype or mock-up of the software to gather user feedback.

ü  Allows users to interact with the prototype and suggest refinements before full development.

ü  Supports requirement clarification and early risk reduction.

ü  Changes are embraced as feedback is incorporated iteratively.

ü  Useful for projects with unclear or evolving requirements.

Example: Designing a new user interface where user experience is uncertain, requiring iterative enhancements.

SPIRAL MODEL:-

ü  Combines iterative development with risk analysis at every cycle.

ü  Development progresses through repeated spirals, each comprising planning, risk assessment, engineering, and evaluation.

ü  Emphasizes managing risks early and continuously.

ü  Flexible to changes and ideal for large, complex, or high-risk projects.

Example: Developing a complex financial software system with changing regulations and high security requirements.

EVOLUTIONARY DEVELOPMENT MODEL:-

ü  Software is developed and delivered in increments, with each increment adding more functionality.

ü  Allows partial implementation early, with later expansions.

ü  Supports evolving requirements through repeated cycles.

ü  Promotes continuous customer feedback and adaptation.

Example: Building a web application where features are rolled out progressively based on user needs.

ITERATIVE ENHANCEMENT MODEL:-

ü  Starts with a basic operational version of the software.

ü  Iteratively improves and enhances the software with additional features over multiple cycles.

ü  Supports refining design and functionality based on testing and user feedback after initial deployment.

ü  Balances quick delivery with ongoing improvements.

Example: Upgrading an existing ERP system by releasing enhancements regularly while the core system stays operational.

EVOLUTIONARY DEVELOPMENT MODELS:-

The evolutionary software process model divides development into incremental phases like mini waterfall cycles. At the end of each cycle, the users get access to the product to try and provide feedback. This feedback is then used to plan the next phase so that the software evolves over time to meet user expectations.  Unlike traditional models, where the final product is delivered after a long development period, the evolutionary model breaks down work into smaller, arranged pieces. Each pieces is developed and delivered individually, so there are multiple incremental releases. With this approach, you can speed up the development process and have continuous customer involvement.

EVOLUTIONARY MODEL: STEP-BY-STEP PROCESS:-

1. Rough Requirements Specification:- The development process begins with gathering initial requirements. Instead of defining every small detail, only the core functionalities and major goals are identified. Since user needs may change over time, this stage is kept flexible to accommodate future modifications.

2. Identify the Core and Other Parts to be Developed Incrementally:- After outlining the basic requirements, the next step is to determine which features are essential for the first version and which features can be developed later. The core functionality is selected as the foundation of the software, and then the additional features are planned for incremental releases.

3. Develop the Core Part Using an Iterative Waterfall Model:- The core part of the software is developed using a structured approach similar to the waterfall model. This is where stages like design, coding, and testing are followed in sequence.

4. Collect Customer Feedback and Modify Requirements:- Once the initial version is ready, it is shared with customers for feedback. Their inputs is used to refine existing functionalities and may also introduce new requirements. Based on this feedback, the development process goes back to the core part development before proceeding further to the next iteration.

5. Develop the Next Identified Features Using an Iterative Waterfall Model:- With updated requirements in place, the next set of features is developed following the same iterative approach. This cycle of feedback and improvement continues until the software meets all user needs.

6. Maintenance:- After the product is fully developed and deployed maintenance is established as an ongoing process. This includes fixing bugs, optimizing performance, and updating features to keep the software relevant and functioning over time.

APPLICATION OF EVOLUTIONARY MODEL:-

1. When Requirements Change Rapidly:- The evolutionary model in software engineering is perfect for projects where user needs or market demands can change in no time. It allows the software to adapt continuously and the final product to meet the latest requirements and stay relevant.

 2. Exploratory Projects:- For projects with unclear problems or those requiring creative solutions, the model works well for exploration. Developers can try different approaches in the early stages and adjust the project direction based on early feedback and testing.

3. High-Risk Projects:- In projects that face high uncertainty or risk, the evolutionary model helps identify and address risks early on. Undertaking the most uncertain aspects early reduces the chances of major project failures down the line.

4. Customer-Centric Applications:- The evolutionary model performs well when a project needs close collaboration with customers or end-users. Regular feedback from users helps the product evolve in line with their preferences.

5. Technology Integration Projects:- In projects that involve new or unfamiliar technologies, the evolutionary model allows for a gradual and controlled approach. This helps developers better understand the technology's impact and reduces the risks of integration failures.

6. Fast-Moving Industries:- The evolutionary model offers the flexibility needed to stay ahead for industries like technology and media, where trends and technologies change quickly. It helps teams rapidly adapt to new technologies or market shifts, keeping the product relevant.

ITERATIVE ENHANCEMENT MODELS OR  INCREMENTAL MODEL:-

The iterative model is a type of software development life cycle model that focuses on an initial, basic implementation that gradually adds more complexity and a broader feature set until the final system is complete.

In the Iterative model, iterative process starts with a simple implementation of a small set of the software requirements and iteratively enhances the evolving versions until the complete system is implemented and ready to be deployed.

An iterative life cycle model does not attempt to start with a full specification of requirements. Instead, development begins by specifying and implementing just part of the software, which is then reviewed to identify further requirements. This process is then repeated, producing a new version of the software at the end of each iteration of the model.

ITERATIVE MODEL  DESIGN:-

Iterative process starts with a simple implementation of a subset of the software requirements and iteratively enhances the evolving versions until the full system is implemented. At each iteration, design modifications are made and new functional capabilities are added. The basic idea behind this method is to develop a system through repeated cycles (iterative) and in smaller portions at a time (incremental).

The following illustration is a representation of the Iterative and Incremental model:-

Iterative and Incremental development is a combination of both iterative design or iterative method and incremental build model for development. "During software development, more than one iteration of the software development cycle may be in progress at the same time." This process may be described as an "evolutionary acquisition" or "incremental build" approach."

ITERATIVE MODEL  ADVANTAGES:-

1)      Some working functionality can be developed quickly and early in the life cycle.

2)      Parallel development can be planned.

3)      Progress can be measured.

4)      Less costly to change the scope/requirements.

5)      Testing and debugging during smaller iteration is easy.

6)      Risks are identified and resolved during iteration; and each iteration is an easily managed milestone.

7)      Easier to manage risk - High risk part is done first.

8)      With every increment, operational product is delivered.

ITERATIVE MODEL  DISADVANTAGES

1)      More resources may be required.

2)      More management attention is required.

3)      System architecture or design issues may arise because not all requirements are gathered in the beginning of the entire life cycle.

4)      Defining increments may require definition of the complete system.

5)      Not suitable for smaller projects.

6)      Management complexity is more.

7)      End of project may not be known which is a risk.

8)      Highly skilled resources are required for risk analysis.

9)      Projects progress is highly dependent upon the risk analysis phase.

UNIT 1 COMPLETED