Unit 1

Emerging Software Engineering Practices

• Aspect oriented software development, agile methods, security engineering,
client/server s/w engineering, software engineering aspects of programming
language, cleanroom software engineering: approach, functional specification,
design & testing.
• Component-based software engineering: software component and its element,
component models- concept & principle, COTS myths, CBSE process, domain
engineering, component based development, classifying and retrieving
components, and economics of CBSE.
• Engineering web application: web based applications and their attributes, web
engineering process , framework for web engineering , formulating, analysing
web-based systems, design and testing for web based applications.
Emerging Software Engineering Practices
Modern software systems are large, distributed, and security-critical.
Traditional software engineering methods are not flexible enough to handle frequent changes, large user bases,
and growing security threats.
Emerging software engineering practices introduce new techniques that focus on:
• flexibility to manage changing requirements
• modularity to control complexity
• built-in security
• faster and continuous software delivery
These practices help in developing reliable, scalable, and maintainable software systems for today’s dynamic
environment.

Why needed?
Traditional engineering struggles with:
1. Frequent requirement changes
2. Security challenges
3. Distributed & large scale systems
Aspect-Oriented Software Development (AOSD) Problem: In large software systems, some
functionalities such as logging, security, and error handling are required in many modules.
These repeated functionalities are called cross-cutting concerns.

Aspect-Oriented Software Development separates these concerns from the main business logic and manages
them as independent units called aspects. This separation improves software quality and makes the system
easier to manage.

Example:
Security checks in every module → handled separately as an aspect

Benefits:
Clean and readable code
Easy maintenance
Better modularity
Agile Software Development: Agile software development is an iterative and incremental approach that
focuses on customer satisfaction and quick delivery of working software.
Instead of building the complete system at once, development is done in small cycles called iterations or
sprints, allowing frequent feedback and improvement.

Agile = Flexible + Fast + Customer-centric

Core Ideas:
• Small and frequent iterations
• Continuous customer feedback
• Working software over heavy documentation

Popular Agile Methods:

Scrum
XP (Extreme Programming)
Example:
Mobile application updated every 2 weeks
Security Engineering: Security engineering deals with protecting software systems from unauthorized
access, cyber attacks, and data breaches.
It focuses on designing software that is secure by default, not adding security at the end.
Security Engineering = Designing software that is safe from attacks

Security Goals:
• Confidentiality
• Integrity
• Availability
Example:
Online banking application
OTP
Encryption
Access control

Why is it important today?

1. Increasing cyber attacks
2. Data leakage incidents
3. Strict privacy laws
Client / Server Software Engineering: Client/Server software engineering is used in distributed systems
where responsibilities are divided between clients and servers.
The client sends a request for a service, and the server processes that request and sends back a response.
Client: Requests service
Server: Provides service

Example:
Web browser → Client
Website backend → Server

Characteristics:
• Distributed system
• Network-based communication
• Scalable architecture

Issues:
Network failure
Security risks
Performance challenges
Software Engineering Aspects of Programming Languages: Programming languages play an important
role in software engineering by helping developers build structured, reliable, and maintainable software.
Modern languages provide built-in features that support good software engineering practices.

Languages support Software Engineering by:

Modularity (classes, packages)
Reusability (libraries, frameworks)
Error and exception handling
Concurrency and parallel processing

Examples:
Java → Object-Oriented features + security
Python → Fast development and simplicity
➡ Choice of programming language directly impacts software quality
Cleanroom Software Engineering: Cleanroom software engineering is a disciplined development
approach used to produce software with very low defect rates.
Instead of finding errors through extensive testing, this method focuses on preventing defects using formal
specifications and correctness-based design.
Cleanroom = Develop software with near-zero defects

Key Idea:
Prevent bugs instead of fixing them later

Used in critical systems:

• Medical systems
• Space applications
• Banking systems
Cleanroom Approach :
The Cleanroom approach follows a structured and correctness-focused process to ensure high reliability
of software.

Steps:
• Formal specification
• Incremental development
• Statistical testing

Difference from Traditional Approach:

• No unit testing by developers
• Strong emphasis on correctness
Functional Specification: Functional specification in Cleanroom engineering defines what the system
should do, without describing how it will be implemented.
It focuses on system behaviour from the user’s perspective, which helps in reducing ambiguity and ensuring
correctness.

Functional Specification includes:

• What the system should do
• No implementation details

Example:
• ATM system functions:
 Withdraw cash
 Check balance
Cleanroom Design & Testing
Cleanroom design follows formal methods and box-structured design to ensure correctness at every
development stage.
Testing is performed separately using statistical methods that reflect real user behaviour.

Design:
• Based on formal methods
• Box-structured design

Testing:
• Statistical usage testing
• Reliability measurement
Summary:
• AOSD ne code ko clean banaya
• Agile ne process ko flexible banaya
• Security Engineering ne system ko safe banaya
• Client/Server ne system ko scalable banaya
• Programming Language aspects ne quality ensure ki
• Cleanroom ne reliability ko extreme level pe le gaya

Code → Process → Security → Architecture → Language →

Reliability
PART–2 Component Based Software
Engineering (CBSE)
Component-Based Software Engineering: Component-Based Software Engineering focuses on building
software systems by assembling pre-built and reusable components.
Instead of developing the entire system from scratch, developers integrate already tested components, which
improves reliability and reduces development time.

CBSE = Building software using pre-built components

Example- LEGO blocks:

Each block has a fixed shape and purpose, and different blocks can be combined to build different structures.
Similarly, software components can be reused and assembled to create different applications.

CBSE is widely used in large and complex software systems.

Software Component & Its Elements:
A software component is a self-contained and independent unit that performs a specific function.
It interacts with other components through a well-defined interface, without exposing internal details.

Component Characteristics:
• Reusable
• Independent
• Well-defined interface

Elements of a Component:
• Interface
• Implementation
• Documentation
Component Models – Concept & Principle: Component models define the rules and standards that
software components must follow in order to work together correctly.
They specify how components are developed, deployed, and how they interact with each other in a system.

Component Model defines:

• How components interact
• How components are deployed

Core Principles:
• Reusability
• Replaceability
• Interoperability

Examples:
JavaBeans
.NET components
COTS (Commercial Off-The-Shelf) & Myths: Commercial Off-The-Shelf (COTS) components are
ready-made software products available in the market.

They are used to reduce development time by avoiding development from scratch.

COTS = Ready-made software components

Common Myths:
• COTS is always cheap ❌
• COTS has no integration issues ❌

Reality:
• Customization is often required
• Compatibility issues may arise
CBSE Process: The Component-Based Software Engineering process focuses on building systems by
selecting and integrating reusable components instead of developing everything from scratch.

Steps in CBSE Process:

• Requirement analysis → Understand what the system must do.

• Component search → Find suitable reusable components.
• Component evaluation → Check if components meet quality and functionality requirements.
• Integration → Assemble components into a complete system.
• Testing → Verify that all components work together correctly.
Domain Engineering: Domain engineering involves identifying common requirements and features within
a specific application domain.
By analyzing similar systems, reusable components can be created, supporting faster development and
consistency.

Domain Engineering = Identifying common features in a domain

Example: E-commerce systems

• Login
• Cart
• Payment
➡ Helps in building reusable components
Component-Based Development
Component-Based Development focuses on assembling, configuring, and integrating reusable components
to build software efficiently.

Focus Areas:
• Assembly
• Configuration
• Integration

Benefits:
• Faster development
• Reduced cost
Classifying & Retrieving Components helps developers quickly find suitable reusable components from a
component repository.

Proper classification saves time and improves reuse efficiency.

Classification Methods:
• Keyword-based → Components are searched using keywords or names
• Faceted classification → Components are classified using multiple attributes

Goal:
• Quick and accurate retrieval from repository
Economics of CBSE :
The economics of CBSE focuses on the cost and benefits of using reusable components in software
development.

Advantages:
• Less development time
• Lower development cost
• Higher reliability (tested components)

Challenges:
• Licensing cost of components
• Integration and maintenance overhead
PART–3: Engineering Web Applications
Web-Based Applications: Web-based applications are software systems that run on web servers and are
accessed through web browsers. They are platform-independent and easily accessible. Due to their wide user
base, web applications must handle scalability, performance, and security issues effectively.

Web App = Software accessed via browser

Examples:
• Gmail
• Online shopping
• University portals

Attributes of Web Applications

• Network intensive : Heavily depend on internet for communication and data transfer
• Content-driven : Focus on displaying and managing dynamic content
• Continuous evolution : Regular updates and feature enhancements
• Security sensitive : Requires strong security to protect user data
Web Engineering Process: is a systematic and disciplined approach used to develop and maintain web-based
applications. It focuses on planning, designing, building, and deploying web applications in an organized way.
Since web applications are used by a large number of users and technologies change very fast, web engineering
ensures that the application is reliable, scalable, secure, and easy to maintain. It also involves continuous updates
and improvements so that the web application can adapt to new requirements and technologies over time.

Steps:
1. Communication : Understanding requirements through interaction with stakeholders
2. Planning : Defining schedule, resources, and project scope
3. Modeling : Designing system structure, data, and user interface
4. Construction : Coding and testing the web application
5. Deployment : Delivering the application to users and providing support

Framework for Web Engineering

Includes:
• Process models
• Tools
• Best practices
➡ Ensures quality & scalability
Formulating Web-Based Systems: Formulation is the first step in web engineering where the basic idea of
the web system is clearly defined. It focuses on identifying the goals of the website, who will use it, and what
type of content it will provide. This step helps in avoiding confusion later and ensures that the web application
is designed according to user needs.

Formulation includes:
• Goals
• Target users
• Content scope

Example:
College website → students + faculty
Analyzing & Design of Web-Based Systems: Analysis and design are important stages in web
engineering. During analysis, we study what the web system should contain, how users will interact with it, and
what functions it must perform. This helps in understanding user needs clearly.
In the design phase, these requirements are converted into proper layouts, page structures, navigation flow, and
user interfaces. A good design makes the web application easy to use, fast, and easy to maintain.

Analysis focuses on:

• Content analysis : Identifies what information (text, images, videos, data) will be shown.
• Interaction analysis : Defines how users interact with the system (forms, clicks, login).
• Functional analysis : Specifies what functions the system should perform.

Design types:
• Information design : Organizes content in a clear and logical manner.
• Interface design : Focuses on the look and feel of web pages.
• Navigation design : Defines how users move between pages easily.
Testing Web Applications: Testing is an essential phase in web application development to ensure the system
works correctly, safely, and efficiently. Since web applications are accessed by different users, browsers, and
devices, proper testing helps improve reliability and user satisfaction. It also ensures that the application
performs well under real-world conditions.

Types of Testing:
• Functional testing : Checks whether all features work as expected (login, forms, links).
• Usability testing : Ensures the application is easy to use and user-friendly.
• Security testing : Identifies vulnerabilities and protects data from attacks.
• Performance testing : Evaluates speed, load handling, and responsiveness.