Software Engineering Notes

Software and Software Engineering

Quick Look at Software and Software Engineering

What is Software?

Software is a product developed and maintained by software professionals. It includes:

  • Programs that run on various computer systems.

  • Content displayed when programs execute.

  • Documentation in both physical and digital forms.

What is Software Engineering?

Software Engineering is the systematic approach to developing high-quality software. It consists of:

  • Process – A structured approach to software development.

  • Methods – Techniques and best practices for efficient development.

  • Tools – Software and utilities that assist in development.

Who Uses Software?

  • Software Engineers – Develop and maintain software.

  • General Public – Uses software directly (e.g., applications, websites) or indirectly (e.g., embedded systems in devices).

Importance of Software & Software Engineering

  • Software is essential in business, culture, and daily life.

  • Software engineering ensures that complex systems are built efficiently and with high quality.

Steps in Software Development

  • Software is developed using an agile and adaptable approach to ensure quality and user satisfaction.

Work Products in Software Engineering

  • For Engineers: Programs, data, and other software components.

  • For Users: Information that improves their experience and productivity.

Ensuring Software Quality

  • Applying relevant software engineering principles ensures correctness, efficiency, and reliability.

1. The Nature of Software

  • Today, software acts both as a product and the vehicle for delivering a product.

  • As a product, it powers hardware by enabling computing capabilities.

  • As a vehicle, it delivers functionality such as system control, communication, and software creation.

Software as a Product

  • Software transforms and manages information:

    • Handles everything from binary data to multimedia.

    • Supports tasks like producing, acquiring, modifying, displaying, and transmitting data.

    • Used in devices ranging from personal gadgets to large network systems.

Software as a Delivery Vehicle

  • Software supports core computing operations:

    • Operating systems manage hardware and resources.

    • Networking software enables communication between systems.

    • Development tools assist in building new software.

Information – The Key Output

  • Software helps turn data into meaningful information:

    • Personal: e.g., converting bank data into financial reports.

    • Business: helps organizations gain a competitive edge.

    • Global: connects users to the world via the Internet.

Evolution of Software

  • The role of the Computer Software has undergone significant changes over the last half century.

  • Software has evolved due to:

    • Improvements in hardware, memory, I/O, and computing architecture.

    • Shift from individual programming to team-based development.

  • Despite the growth, development has become more complex and demanding.

  • The fundamental challenges in software development remain the same.

Fundamental Challenges in Software Development

  • Key unresolved issues in the field:

    • Why is software development so time-consuming?

    • Why are costs still high?

    • Why do bugs still appear after testing?

    • Why is maintenance so time and cost demanding?

    • Why is it hard to measure progress during development?

  • These, and many other questions, continue to challenge software engineers, making software engineering critical discipline for managing complexity, cost, and quality in modern systems.

2. Software Application Domains

  • Software is categorized into seven major domains.

  • Each domain presents unique challenges and demands specific development approaches.

1. System Software

  • Supports and manages other programs and system resources.

  • Examples: Operating systems, compilers, text editors, device drivers.

  • Deals with multitasking, process control, resource sharing, and complex hardware interactions.

2. Application Software

  • Designed for specific business or technical tasks.

  • Examples: Financial systems, point-of-sale terminals, and real-time business control software.

  • Helps automate operations and support business decision-making.

3. Engineering & Scientific Software

  • Traditionally focused on numerical computation in science and engineering.

  • Now supports real-time systems and simulations (e.g., CAD tools, automated manufacturing).

  • Combines technical accuracy with real-time control features.

4. Embedded Software

  • Embedded within hardware products to manage internal functions.

  • Examples: Microwave controls, car systems (fuel injection, braking, dashboards).

  • Delivers precision, automation, and control inside physical devices.

5. Product-Line Software

  • Designed for mass use across specific domains.

  • Examples: Word processors, spreadsheet tools, personal finance applications.

  • Focuses on reusability, reliability, and market adaptability.

6. Web Applications (Web Apps)

  • Ranges from basic websites to complex, cloud-integrated systems.

  • Evolved from simple hypertext pages to dynamic, real-time platforms.

  • Enable interactive content, collaboration, and online services.

7. AI Software

  • Uses non-numeric algorithms to simulate human intelligence.

  • Applications include robotics, neural networks, expert systems, image/voice recognition.

  • Aims to solve complex, decision-based problems.

Growth & Challenges in Software Development

  • Software engineers worldwide are involved in projects that either develop new systems or enhance existing applications

  • As technology advances, new challenges arise:

    • Open-World Computing: Develop adaptable software to ensure seamless communication across mobile devices, PCs, and enterprise systems.

    • Net Sourcing: The web is evolving into a computing engine, not just a content provider. Engineers must design scalable and user-friendly applications for global markets.

    • Open-Source Development: Open-source software allows developers worldwide to contribute to system applications. The challenge lies in coordinating contributions, ensuring code clarity and version control.

  • To tackle these challenges, software engineers must adopt agile and flexible development processes that can keep pace with technological advancements and changing business needs.

3. Legacy Software

  • Legacy software refers to older computer programs that have been in use for many years.

  • These systems were developed decades ago and have been continuously modified to meet new business requirements and evolving computing environments.

  • Despite their age, many legacy systems remain critical to business operations and cannot simply be replaced.

Key Characteristics of Legacy Software

  • Longevity: In use for many years.

  • Business Criticality: Supports core business processes and cannot be easily discarded.

  • Frequent Modifications: Continuously updated to meet changing needs.

  • Poor Quality Issues: Some legacy systems suffer from:

    • Complex and outdated design

    • Difficult-to-understand code

    • Lack of documentation and test records

    • Hard to integrate with modern systems

When Do Legacy Systems Need Changes?

  • Many legacy systems continue to function reliably.

  • If a system meets user needs and operates without failure, there is no immediate need to modify it.

  • However, changes may be required in the following situations:

    • Adaptation: The software needs to be modified for new computing environments or technologies.

    • Enhancement: New business requirements necessitate additional features.

    • Interoperability: The system must be extended to work with newer software or databases.

    • Re-architecture: The system needs to be restructured to function within modern networked environments.

  • When a legacy system requires significant updates, software reengineering is necessary.

Role of Software Reengineering

  • Reengineering is needed when major updates are required.

  • It involves:

    • Restructuring old code

    • Improving maintainability

    • Making the system compatible with modern technology

  • Goal: Extend the life of legacy systems while maintaining reliability and enhancing performance.

4. The Unique Nature of Web Apps

  • Web applications (Web Apps) have evolved from simple linked hypertext files(1990s) to advanced computing tools integrated with databases and business logic.

  • Unlike traditional software, they run over the Internet or intranets and present unique development challenges.

1. Network Intensiveness

  • Web Apps operate over networks like the Internet or intranet.

  • They support global access, allowing users to interact with the app from any location.

  • Development Challenge: Managing network latency, data exchange, and real-time connectivity across devices and regions.

2. Concurrency

  • Web Apps are designed to handle multiple users simultaneously.

  • Common in social media, e-commerce, and online learning platforms.

  • Development Challenge: Ensuring consistent performance without data conflicts or slowdowns due to high user activity.

3. Unpredictable Load

  • User traffic may vary greatly — from hundreds to millions in a short time.

  • Example: Online ticket booking or e-commerce sales.

  • Development Challenge: Must implement scalable architectures (e.g., cloud infrastructure, load balancing).

4. Performance

  • Users expect quick load times and smooth interactions.

  • Slow Web Apps can result in user drop-offs and negative impressions.

  • Development Challenge: Optimize server response times, client-side scripting, and use techniques like caching and lazy loading.

5. Availability

  • Web Apps need to be accessible 24/7 across global time zones.

  • Downtime can affect user trust and business operations.

  • Development Challenge: Ensure fault tolerance, redundancy, and planned maintenance with minimal disruption.

6. Data-Driven

  • Most Web Apps use databases to store and manage content and user data.

  • Content includes text, images, videos, and transaction records.

  • Development Challenge: Ensure efficient database queries, indexing, and real-time data synchronization.

7. Content Sensitivity

  • The value of a Web App depends on the quality, accuracy, and presentation of its content.

  • Poor or outdated content can drive users away.

  • Development Challenge: Implement content management systems (CMS) and update workflows for timely changes.

8. Continuous Evolution

  • Web Apps are updated frequently and iteratively.

  • New features, bug fixes, and UI changes are deployed regularly.

  • Development Challenge: Adopt agile and DevOps practices to manage fast release cycles with minimal bugs.

9. Immediacy

  • Web Apps often have short development timelines.

  • Used in startups and dynamic business environments where speed is critical.

  • Development Challenge: Maintain quality and testing standards despite the pressure of quick releases.

10. Security

  • Being Internet-accessible makes Web Apps vulnerable to cyber threats.

  • Risks include hacking, phishing, data breaches, and injection attacks.

  • Development Challenge: Use strong encryption, secure authentication, firewalls, and regular vulnerability testing.

11. Aesthetics

  • Visual appeal and user interface (UI) design impact user engagement.

  • Good design improves usability, retention, and trust.

  • Development Challenge: Combine UI/UX best practices, responsive design, and accessibility standards for all users.

5. Software Engineering

  • Fritz Bauer’s Definition: “software engineering is the application of sound engineering principles to develop reliable and efficient software in an economical manner.”

  • IEEE Definition: “A systematic, disciplined, and quantifiable approach to software development, operation, and maintenance.”

  • Although the definitions emphasize discipline, they must also allow adaptability to meet varying team structures, project scales, and changing requirements.

  • Software engineering is essential for developing reliable, efficient, and maintainable software that meets the needs of individuals, businesses, and governments.

  • As software systems become more complex and embedded in various domains, proper design and management are crucial.

Importance of Software Engineering

  • Helps in building reliable, efficient, and maintainable software.

  • Supports the growing integration of software in business, government, health, finance, and other domains.

  • As systems grow complex, engineering ensures proper design and control to minimize risk and error.

  • High-quality engineering is essential to prevent failures, especially in critical areas like healthcare, banking, and transportation.

Software engineering follows a layered approach:

  • Tools

  • Methods

  • Process

  • A quality focus

a. Quality Focus

  • Quality is at the core of all software engineering activities.

  • Poor-quality software can lead to major financial and operational risks.

  • Ensures customer satisfaction, user trust, and system stability.

  • Adopt Total Quality Management (TQM), Six Sigma, and other quality improvement methodologies.

b. Process Layer

  • Acts as a framework guiding software project execution.

  • Defines project lifecycle stages, from requirements to maintenance.

  • Facilitates:

    • Project planning and management

    • Quality assurance

    • Change control

  • Helps standardize practices and ensure consistency and compliance.

c. Methods

  • Represent technical approaches used during development.

  • Include core activities:

    • Communication with stakeholders

    • Requirement gathering and analysis

    • Design modeling and prototyping

    • Coding and implementation

    • Testing and debugging

    • Deployment and maintenance

  • These methods provide a disciplined approach to build reliable solutions.

d. Tools

  • Tools offer automation or semi-automation for software engineering tasks.

  • Examples: Code editors, testing tools, version control systems, modeling tools.

  • When integrated, they form Computer-Aided Software Engineering (CASE) systems.

  • CASE supports:

    • Design consistency

    • Documentation

    • Versioning

    • Team collaboration

  • Improves efficiency, accuracy, and collaboration throughout the lifecycle.

6. The Software Process

1. Introduction to Software Process

  • A software process is a structured set of activities, actions, and tasks involved in software development.

  • Its goal is to ensure timely delivery of high-quality software that meets the expectations of stakeholders.

  • It is not rigid, but adaptable, enabling teams to choose suitable methods depending on project type, size, and complexity.

  • The process balances discipline with flexibility for efficient and successful software delivery.

  • It consists of framework activities that define the core development tasks and umbrella activities that support and manage the overall process.

2. Framework Activities

Framework activities are the core tasks that form the foundation of any software development process:

a. Communication

  • Involves early interaction with stakeholders to gather and understand requirements.

  • Establishes clear expectations and prevents miscommunication.

  • Poor communication can lead to incorrect or unusable software.

b. Planning

  • Provides a detailed roadmap of project activities.

  • Involves task breakdown, time estimation, resource allocation, and risk analysis.

  • Effective planning aids progress tracking and minimizes delays.

c. Modeling

  • Helps visualize the structure and functionality of the system.

  • Includes:

    • Requirement Modeling – defines what the system should do.

    • Design Modeling – defines how the system will perform its functions.

  • Aids in identifying components, interactions, and potential issues before development begins.

d. Construction

  • The actual coding and testing phase.

  • Involves writing source code based on design and conducting thorough testing.

  • Ensures the system works as intended and adheres to requirements.

e. Deployment

  • The software is released for real-world use.

  • May include phased or full deployment, depending on the project.

  • User feedback is collected to guide further enhancements and bug fixes.

These five activities are universal and apply to both small programs and large-scale systems, although their details may vary.

3. Umbrella Activities

Umbrella activities support and monitor the core framework tasks. They span the entire development lifecycle.

a. Software Project Tracking and Control

  • Monitors progress to ensure timely completion.

  • Detects delays early and triggers corrective actions.

b. Risk Management

  • Identifies potential threats to the project (e.g., cost overruns, scope creep).

  • Prepares mitigation strategies to reduce the impact of these risks.

c. Software Quality Assurance

  • Maintains high quality through systematic testing and reviews.

  • Ensures compliance with standards and reduces the risk of defects.

d. Technical Reviews

  • Scheduled evaluations of requirements, design, and code.

  • Helps catch errors early, saving time and cost later in the development process.

e. Measurement

  • Collects and analyzes data to evaluate performance and improve processes.

  • Metrics such as productivity, defect rates, and delivery times are commonly used.

f. Software Configuration Management

  • Manages changes in the software during development.

  • Tracks versions, controls updates, and ensures stability across releases.

g. Reusability Management

  • Promotes the use of existing components or modules.

  • Reduces development effort, cost, and time.

h. Work Product Preparation and Production

  • Involves creating supporting documentation such as:

    • Requirement documents

    • Design reports

    • User guides

    • Technical manuals

  • Ensures maintainability and knowledge transfer.

4. Process Adaptability

The software process must be tailored to match the unique needs of each project. Two main categories of process models include:

a. Prescriptive Process Models

  • Offer a structured, step-by-step development approach.

  • Suitable for large-scale or critical projects (e.g., defense, banking).

  • Examples: Waterfall Model, V-Model.

  • Pros: High control and predictability.

  • Cons: Inflexibility; slow to adapt to changes.

b. Agile Process Models

  • Focus on flexibility, collaboration, and quick iterations.

  • Suitable for dynamic environments like web development or startups.

  • Examples: Scrum, Kanban, XP (Extreme Programming).

  • Pros: Fast feedback, adaptability, stakeholder involvement.

  • Cons: May be less predictable for long-term planning.

A good software process should offer structure where needed but remain flexible enough to adjust to project demands, team capabilities, and evolving requirements.

7. Software Engineering Practice

  • Software engineering practice involves the application of systematic, structured, and logical methods to develop software that is reliable, efficient, and maintainable.

  • It is grounded in common-sense problem-solving principles and aligns with the five framework activities of software engineering:

    • Communication

    • Planning

    • Modeling

    • Construction

    • Deployment

  • One of the foundational inspirations behind software engineering practice is George Polya’s four-step approach to problem-solving, introduced in his book How to Solve It (1945).

a. Understand the Problem (Corresponds to: Communication & Requirement Analysis)

  • Before attempting to solve a problem, it is essential to develop a deep and precise understanding of it.

  • This involves interacting with stakeholders, gathering requirements, and analyzing the scope.

  • Key Questions:

    • Who are the stakeholders involved?

    • What data, functions, and features are needed?

    • Can the problem be decomposed into manageable parts?

    • Is it possible to create models (like DFDs or UML) to visualize the problem?

A clear understanding prevents rework and ensures that the final solution meets real-world needs.

b. Plan a Solution (Corresponds to: Modeling & Software Design)

  • Once the problem is well understood, the next step is to design a solution strategically.

  • Emphasis is placed on reusability, modularization, and design modeling.

  • Key Questions:

    • Have similar problems been solved before? Can we reuse that knowledge?

    • Can we use or adapt reusable components?

    • Can the solution be divided into subproblems?

    • Can we develop a design model (e.g., class diagrams, architecture diagrams) to guide development?

A solid plan leads to a maintainable and scalable solution.

c. Carry Out the Plan (Corresponds to: Code Generation)

  • The actual development/coding phase where the planned solution is implemented.

  • The code should follow the design model to ensure consistency and traceability.

  • Developers must regularly verify if the code behaves as expected.

  • Key Actions:

    • Ensure that the code matches the design accurately.

    • Implement modules in a structured and traceable manner.

    • Perform unit tests during development.

Implementation should be clean, maintainable, and adhere to coding standards.

d. Examine the Result (Corresponds to: Testing & Quality Assurance)

  • After implementation, it is essential to test the software rigorously to ensure quality.

  • Verifies whether the software meets functional and non-functional requirements.

  • Key Questions:

    • Can each component be tested independently and together?

    • Does the software meet user and stakeholder expectations?

    • Have all errors and defects been identified and resolved?

Testing ensures software reliability, correctness, and readiness for deployment.

Step Activity Focus Objective

  • Understand the Problem

    • Communication & Analysis

    • Gather clear, complete requirements

  • Plan a Solution

    • Modeling & Design

    • Create a structured, modular design

  • Carry Out the Plan

    • Code Generation

    • Write code that aligns with the design

  • Examine the Result

    • Testing & Quality Assurance

    • Validate the software against requirements

8. General Principles

  • A principle is a fundamental rule or guideline that shapes behavior and decision-making.

  • In software engineering, principles are applied at every stage — from broad project practices to specific technical details.

  • These principles serve as the foundation for building reliable, maintainable, and high-quality software systems.

  • In 1996, David Hooker outlined seven key principles that define good software engineering practice.

  • These principles are timeless and apply across all types of software projects.

a. The First Principle: The Reason It All Exists

  • A software system should exist only to provide value to its users.

  • Every decision — whether about features, requirements, or tools — must be justified by user benefit.

  • If something does not add value, it should not be part of the system.

  • This principle acts as the foundation for all others, keeping the user’s needs at the core.
    *