Lecture No.

1
Principles of Software Engineering
by
Kalimullah Khan
Assistant Professor
Introduction to Software Engineering
• The term software engineering is composed of two words, software and engineering.
• Software is more than just a program code. A program is an executable code, which serves some
computational purpose.
• Software is considered to be a collection of executable programming code, associated libraries and
documentations.
• Software, when made for a specific requirement is called software product.
Introduction to Software Engineering

• Engineering on the other hand, is all about developing products, using well-defined, scientific
principles and methods.
• So, we can define software engineering as an engineering branch associated with the development
of software product using well-defined scientific principles, methods and procedures.
• The outcome of software engineering is an efficient and reliable software product.
Introduction to Software Engineering
• IEEE defines software engineering as:

• The application of a systematic, disciplined, quantifiable approach to the development, operation

and maintenance of software.
• A systematic approach to building a treehouse means to follow step-by-step instructions.
• Quantifiable means able to be measured or counted.
Introduction to Software Engineering
• We can alternatively view it as a systematic collection of past experience.
• The experience is arranged in the form of methodologies and guidelines.
• A small program can be written without using software engineering principles.
• But if one wants to develop a large software product, then software engineering principles are
absolutely necessary to achieve a good quality software cost effectively.
Introduction to Software Engineering
• Without using software engineering principles it would be difficult to develop large
programs.
• In industry it is usually needed to develop large programs to accommodate multiple
functions.
• A problem with developing such large commercial programs is that the complexity
and difficulty levels of the programs increase exponentially with their sizes.
• Software engineering helps to reduce this programming complexity.
Introduction to Software Engineering
• Software engineering principles use two important techniques to reduce problem
complexity: Abstraction and Decomposition.
• The principle of abstraction implies that a problem can be simplified by omitting
irrelevant details.
• Once the simpler problem is solved, then the omitted details can be taken into
consideration to solve the next lower level abstraction, and so on.
• Abstraction is a powerful way of reducing the complexity of the problem.
Introduction to Software Engineering
• The other approach to tackle problem complexity is decomposition.
• In this technique, a complex problem is divided into several smaller problems and then the smaller
problems are solved one by one.
• A good decomposition of a problem should minimize interactions among various components.
• If the different subcomponents are interrelated, then the different components cannot be solved
separately and the desired reduction in complexity will not be realized.
Introduction to Software Engineering
• Need of Software Engineering:
• The need of software engineering arises because of higher rate of change in user requirements and
environment on which the software is working.
• Large software - It is easier to build a wall than to a house or building, likewise, as the size of
software become large engineering has to step to give it a scientific process.
• Scalibility - in software engineering refers to the ability of a system, application, or process to
handle increased loads or to be easily expanded to manage growth.
Introduction to Software Engineering
• Cost - As hardware industry has shown its skills and huge manufacturing has lower down the price
of computer and electronic hardware. But the cost of software remains high if proper process is
not adapted.
• Dynamic Nature - If the nature of software is always changing, new enhancements need to be
done in the existing one. This is where software engineering plays a good role.
• Quality Management- Better process of software development provides better and quality
software product.
Introduction to Software Engineering
• CHARACTERESTICS OF GOOD SOFTWARE - A software product can be judged by what it offers and
how well it can be used. This software must satisfy on the following grounds:

• Operational
• Transitional
• Maintenance
Introduction to Software Engineering
• Operational - This tells us how well software works in operations. It can be measured on:
• Usability
• Efficiency
• Security
• Interoperability
• Functionality
• Dependability
Introduction to Software Engineering
• Usability - Usability is the degree to which the software can be used by specified users to achieve
specified goals with effectiveness, efficiency, and satisfaction in a specified context of use. e.g: User
interface and accessibility. A mobile app with a user-friendly interface that guides users through
the checkout process smoothly.
• Performance Efficiency - Performance efficiency relates to the software's ability to provide
appropriate performance relative to the amount of resources used under stated conditions. E.g:
respeonce time and resource utilization. A search engine that delivers results quickly, even with
millions of queries per second.
Introduction to Software Engineering
• Security - Security involves protecting the software from malicious attacks, unauthorized access,
and data breaches. e.g: Data protection and vulnerability management. A healthcare system that
ensures patient data is encrypted and accessible only to authorized personnel.
Introduction to Software Engineering
• Interoperability - Interoperability is the ability of the software to interact and operate with other
systems or products without compatibility issues. E.g: A CRM system that integrates seamlessly
with an email marketing platform and a customer support system.
Introduction to Software Engineering
• Transitional - This aspect is important when the software is moved from one platform to another:
• Portability
• Interoperability
• Reusability
• Adaptability
Introduction to Software Engineering
• Portability - It refers to the ease with which software can be transferred from one environment to
another. This includes moving the software across different hardware platforms, operating systems,
or software environments with minimal modifications. E.g: Web Applications: A web application
developed using HTML, CSS, and JavaScript is considered highly portable because it can run on any
device with a modern web browser, regardless of the operating system or hardware.
Introduction to Software Engineering
• Interoperability - It refers to the ability of different systems, software applications, or components
to work together, exchange information, and use the exchanged data effectively.
• E.g In healthcare, interoperability is crucial for ensuring that patient data can be shared across
different healthcare providers, insurance companies, and pharmacies
Introduction to Software Engineering
• Reusability - It refers to the practice of designing software components, modules, or systems in a
way that they can be used in multiple applications or in different parts of the same application.
• E.g In web development, reusable UI components like buttons, forms, and navigation menus are
often created once and reused across different pages or applications.
Introduction to Software Engineering
• Adoptability - In software engineering refers to how easily a new software system or technology
can be accepted, integrated, and effectively used by an organization or its users.
• Imagine a team using an older messaging app for daily communication. They decide to switch to a
new app like Slack. If Slack is easy to set up, has a user-friendly interface, and allows them to
import their existing contacts and chat history with minimal effort, the team will likely adopt the
new app quickly.
Introduction to Software Engineering
• Maintenance - This aspect briefs about how well a software has the capabilities to maintain itself
in the everchanging environment:
• Modularity
• Maintainability
• Flexibility
• Scalability
Introduction to Software Engineering
• Modularity - In software engineering is the practice of dividing a software system into separate,
self-contained modules or components, each responsible for a specific part of the system's
functionality.
• E.g : A calculator app is designed with separate modules for:
• Basic Arithmetic (addition, subtraction)
• Scientific Functions (trigonometry, logarithms)
• History (keeping track of previous calculations)
Introduction to Software Engineering
• Maintainability - in software engineering refers to how easily software can be updated, repaired,
or enhanced over time.
• If you have a well-organized and documented codebase for a simple to-do list app, it’s easier to:

• Fix Bugs: Quickly identify and fix issues, like a malfunctioning checkbox.
• Add Features: Easily add a new feature, like a due date reminder, without disrupting existing
functionality.
Introduction to Software Engineering
• Flexibility - In software engineering refers to the ability of a software system to adapt to new
requirements, changes, or environments with minimal modification. Flexible software can easily
accommodate updates.
• Consider an e-commerce website that initially supports only physical product sales. If the website
is designed flexibly, it can be easily extended to support digital products, such as e-books or
software downloads, by adding new modules or features without requiring a major overhaul of the
existing system.
Introduction to Software Engineering
Software Engineering and Computer Science are related fields but focus on different
aspects of computing. Here’s a brief comparison:
• Software Engineering:
• Focus: The practical application of engineering principles to software development.
It emphasizes designing, developing, testing, and maintaining software systems.
• Goals: To create reliable, efficient, and maintainable software systems that meet
user requirements.
• Practices: Involves methodologies like Agile, Scrum, and DevOps; emphasizes
project management, quality assurance, and software lifecycle management.
• Example: Developing a web application for online banking, ensuring it is secure,
user-friendly, and meets regulatory standards.
Introduction to Software Engineering
• Computer Science:
• Focus: The theoretical foundations of computation and information. It covers a broad range of
topics, including algorithms, data structures, and computational theory.
• Goals: To understand and advance the principles and techniques of computing.
• Practices: Involves research and development in areas like algorithms, machine learning, and
computer theory; less emphasis on practical software development.
• Example: Designing a new algorithm to improve the efficiency of sorting large datasets or
developing new computational models for artificial intelligence.
Introduction to Software Engineering
• System Engineering: Definition: Systems engineering is an interdisciplinary field that focuses on
designing, integrating, and managing complex systems over their lifecycle. It deals with the system as a
whole, encompassing hardware, software, processes, and interactions among these components.
• Key Areas:
• Requirements Engineering: Gathering and analyzing requirements for the entire system, including both
hardware and software.
• System Design: Defining the system architecture and how various components interact.
• Integration: Ensuring that different components and subsystems work together as intended.
• Verification and Validation: Ensuring that the system meets its requirements and performs as expected.
• Lifecycle Management: Overseeing the system through its entire lifecycle, including maintenance,
upgrades, and decommissioning.
Introduction to Software Engineering
• Example:
• Designing and implementing a satellite system where you manage not just the software but also the
hardware components, communications, and environmental factors affecting the satellite.
• Key Differences
• Scope:
• Software Engineering: Concentrates primarily on software development and its lifecycle.
• Systems Engineering: Focuses on the entire system, including hardware, software, and interactions
between components.
Software Engineering Layers

In software engineering, layers are often used to organize and manage different aspects of software systems. This layered
approach helps in separating concerns, enhancing modularity, and making the software more maintainable and scalable.
1. Presentation Layer (UI Layer)
• Purpose:
• To handle user interface and user interaction.
• To present data to the user and collect user input.
• Responsibilities:
• Rendering user interfaces (e.g., web pages, mobile screens).
• Handling user inputs (e.g., mouse clicks, keyboard input).
• Displaying data retrieved from the business logic layer.
• Examples:
• Desktop application Interfaces.
• Mobile app Interfaces
2. Application Layer (Service Layer)
• Purpose:
• To define the application's business logic and coordinate application workflows.
• To provide an abstraction between the presentation layer and the business logic layer.
• Responsibilities:
• Orchestrating application processes and operations.
• Handling use cases and application-specific logic.
• Managing interactions between the presentation layer and business logic.
• Examples:
• Application services (e.g., user authentication services).
• Business process workflows (e.g., order processing).
3. Business Logic Layer (Domain Layer)
• Purpose:
• To encapsulate the core business rules and logic of the application.
• To represent the domain model and enforce business rules.
• Responsibilities:
• Implementing business rules and domain logic.
• Managing data and business operations (e.g., calculations, validation).
• Interacting with the data access layer to persist or retrieve data.
• Examples:
• Business entities (e.g., customer, order).
• Domain services (e.g., order fulfillment, payment processing).
4. Data Access Layer (Persistence Layer)
• Purpose:
• To manage the interaction between the application and the data storage system.
• To handle data retrieval, storage, and updates.
• Responsibilities:
• Performing CRUD (Create, Read, Update, Delete) operations on data.
• Managing database connections and transactions.
• Providing an abstraction over data storage mechanisms (e.g., databases, file systems).
• Examples:
• Data access objects (DAOs).
• ORM (Object-Relational Mapping)
5. Integration Layer
• Purpose:
• To manage interactions with external systems and services.
• To handle communication between the application and other systems or APIs.
• Responsibilities:
• Handling integration with third-party services (e.g., payment gateways, external APIs).
• Managing data exchanges and communication protocols.
• Ensuring that data flows seamlessly between the application and external systems.
• Examples:
• REST (REST is an architectural style for designing networked applications) or SOAP API clients (SOAP is a protocol with its own set of rules for
message format and communication.).
• Messaging systems (software infrastructure that enables the exchange of messages between different components, applications, or systems) (e.g.,
message queues, event streams).

This layered approach helps in managing complexity and ensuring that different aspects of the application are developed, tested, and maintained
effectively.
Professional and Ethical responsibilities of SE
Engineers
1. Competence:
• Continuous Learning: Keep up with evolving technologies, tools, and best practices.
• Skill Application: Apply appropriate and tested techniques for solving problems.

2. Quality Assurance:
• Testing: Ensure software is thoroughly tested to meet quality standards.
• Documentation: Maintain clear and accurate documentation for code, design, and user manuals.
3. Code of Conduct:
• Adherence to Standards: Follow industry standards and best practices in software
development.
• Professionalism: It refers to the conduct, behavior, and qualities expected of
individuals in a professional environment.

4. Project Management:
• Time Management: Deliver work within agreed timelines.
• Scope Management: Manage and adhere to project scope, avoiding scope creep. It
refers to the gradual and often uncontrolled expansion of a project's scope beyond its
original objectives and deliverables
5. Collaboration:
• Teamwork: Work effectively within a team, valuing contributions and respecting diverse
viewpoints.
• Communication: Clearly and effectively communicate project status, requirements, and issues.

6) Responsibility for Impact:

• User-Centric Design: Focus on user needs and usability in design and implementation.
• Performance: Optimize performance to ensure the software runs efficiently.
Ethical Responsibilities
1. Confidentiality:
• Data Protection: Safeguard sensitive information and respect user privacy.
• Intellectual Property: Respect intellectual property rights and avoid unauthorized use of
proprietary software.
2. Integrity:
• Honesty: Be honest about capabilities, limitations, and progress.
• Avoid Misrepresentation: Do not misrepresent work or qualifications.
3. Security:
• Secure Design: Implement robust security measures to protect against vulnerabilities and
breaches.
• Responsible Disclosure: Report security issues responsibly and promptly.
4. Compliance:
• Legal Adherence: Follow all relevant laws and regulations, including those related to software
licensing, data protection, and accessibility.
• Ethical Standards: Adhere to ethical guidelines and standards set by professional organizations,
such as the ACM or IEEE.
5. Impact on Society:
• Social Responsibility: Consider the broader impact of software on society, including potential for
misuse.
• Accessibility: Ensure software is accessible to users with disabilities.
6. Conflict of Interest:
• Disclosure: Disclose any potential conflicts of interest to relevant parties.
• Avoid Bias: Make decisions based on merit and fairness rather than personal gain.
• By adhering to these professional and ethical responsibilities, software engineers contribute to the
development of reliable, secure, and impactful software, while maintaining trust and
professionalism in their field.
Software Crisis
• In Ian Sommerville's "Software Engineering," the term "software crisis" refers to a range of
significant challenges and problems that arise in the software development process.
• These challenges impact the reliability, cost, and effectiveness of software systems, making it
difficult to meet user expectations and manage complex projects effectively.
1. Complexity
• As software systems become more complex, it becomes increasingly difficult to manage and
understand them, leading to higher chances of errors and integration problems.

• Example: The rollout of Healthcare.gov, the U.S. government’s health insurance exchange website,
faced major issues due to its high complexity. The system was intended to handle millions of users
and integrate with various government databases.
2. Quality
• Software systems often suffer from defects and failures, which can affect their performance,
security, and reliability, resulting in subpar user experiences and potentially serious consequences.

• Example: Boeing 737 Max Crashes

• The Boeing 737 Max aircraft experienced two fatal crashes due to flaws in its Maneuvering
Characteristics Augmentation System (MCAS). The software, designed to prevent stalls, had defects
that were not adequately identified or tested. This situation highlights how critical software quality
is, especially in safety-critical systems.
3. Cost
• Definition: The costs associated with software development and maintenance often exceed initial
budgets and projections, leading to financial overruns and unanticipated expenses.

• Example: Denver International Airport Baggage Handling System

• The automated baggage handling system at Denver International Airport was originally budgeted
at $170 million but ended up costing over $560 million. The project faced delays and technical
issues, underscoring how software development can lead to significant cost overruns.
4. Productivity
• Definition: Software development processes can be inefficient, leading to delays in project delivery
and reduced productivity. This inefficiency is often due to inadequate methods or unanticipated
technical challenges.

• Example: FBI’s Virtual Case File System

• The FBI's Virtual Case File system, intended to modernize the agency's case management, was
beset by delays and inefficiencies. Despite an investment of over $100 million, the project was
canceled because it could not meet the required functionality and performance standards,
demonstrating issues with productivity in software development.
5. User Satisfaction
• Definition: Many software systems fail to meet user expectations and needs, leading to
dissatisfaction and a lack of adoption or effective use of the software.

• Example: Microsoft Windows Vista (2007)

• Windows Vista was criticized for its poor performance, high system requirements, and
compatibility issues with existing applications and hardware.
• Users faced numerous problems, which led to widespread dissatisfaction and a swift
move toward Windows 7, illustrating the impact of poor user satisfaction on software
success.
6. Development Methods
• Definition: Traditional software development methods may not be adequate to address the
challenges of modern software projects, necessitating the adoption of improved practices and
methodologies.
• Example: Airbus A380 Development

• The development of the Airbus A380 encountered significant delays and cost overruns due to
issues with integrating different software systems developed in various locations. The challenges
highlighted the need for improved development practices and coordination in managing large,
complex projects.
Conclusion

• Sommerville’s discussion of the software crisis emphasizes the need for improved practices and
methodologies to address these challenges.
• The crisis illustrates that software engineering must evolve continuously to manage complexity,
ensure quality, control costs, improve productivity, enhance user satisfaction, and adopt effective
development methods.
• By learning from past examples and applying better practices, the software industry aims to
overcome these issues and deliver more reliable and effective software solutions.
Thank You