Fundamentals of Software Engineering

Software is composed of three elements: instructions (computer programs), data structures, and documents that describe operation and use.
Software goes beyond just program code; it encompasses the entire system needed to operate correctly.
Documentation includes system documentation (describing the system structure), user documentation (explaining how to use it), and user information such as websites for downloading updates.
IEEE defines software as a collection of programs, procedures, rules, documentation, and data, aimed at serving a particular purpose.
Engineering involves applying scientific and practical knowledge to invent, design, build, maintain, and improve frameworks, processes, and products. It focuses on finding cost-effective solutions.

Software engineering is an engineering branch focused on developing software using scientific principles, methods, and procedures. The goal is reliable, efficient software.
Software engineering involves applying sound engineering principles to create reliable and efficient software for real machines (Fritz Bauer).
Software engineering is the practical application of scientific knowledge for designing and building computer programs. It includes needed documentation for development, operation, and maintenance (Boehm).
Software engineering is a process that analyzes user requirements and designs, builds, and tests software to meet those requirements.

Modularity: Divide the software into smaller, reusable components for easier development and testing.
Abstraction: Hide component intricacies and expose only essential functionalities to other parts of the software.
Reusability: Create components that are used in multiple projects, saving time and resources .
Maintenance: Continuously update and improve to fix bugs, add features, and address security vulnerabilities.

Testing: Verifying software meets requirements and is free of errors.
Design Patterns: Using existing solutions for recurring problems.
Agile Methodologies: Incremental development focused on customer satisfaction, rapid delivery, and flexibility.
Continuous Integration & Deployment: Integrating and deploying code changes into the production environment continuously.

Changes in Requirements: Software must adapt to evolving business needs and environment with documented processes.
Large and Complex Software: Complex software becomes more manageable through software engineering methods.
Scalability and Adaptability: Handling increasing demands with efficient processes that help maintain existing systems versus re-creating new ones.

Cost: Producing software at a reasonable price.
Schedule: Creating software in a reasonable timeframe.
Quality: Building software with high quality.
Accepted industry practices: Developing using good quality control, adherence to standards and efficiently.

Improved Quality: Following established principles leads to fewer errors and increased reliability.
Increased Productivity: Modern tools streamline development enabling faster projects.
Maintainability: Well-designed software is more adaptable for updates and changes.
Reduced Costs: Early problem identification can minimize future fixes.

Customer Satisfaction: Involving customers throughout builds trust and satisfaction.
Team Collaboration: Agile methodologies enhance collaboration within teams.
Better Scalability: Designed for scalability to handle increasing user numbers and transactions.
Better Security: Following SDLC with security testing reduces risk.

Legacy Systems: Maintaining older systems can be time-consuming, especially when avoiding cost overruns, or keeping essential operations running.
Heterogeneity: Managing many types of devices and systems across networks in distributed systems is complex.
Delivery Speed: Balancing fast delivery with software quality in demanding, evolving markets is tricky.
Trust: Achieving user trust in software systems is essential in increasingly intertwined software systems.
Risk Issues: Safety-critical systems can face severe consequences for errors, requiring robust and tested software for safety.

Purpose: System software (operating systems) or application software (word processors, games).
Platform: Native software (for specific operating systems) or cross-platform (for multiple systems).
Deployment: Installed (on user devices) or cloud-based (remote servers).
License: Proprietary or open-source.
Development Models: Traditional (waterfall) or agile.
Size: Small-scale (single user) or large-scale (enterprises).
User Interface: Graphical (GUI) or command-line (CLI).

Usability: How easy the software is to use and learn.
Efficiency: How well it performs the required tasks and uses resources efficiently.
Correctness: How well the software meets its requirements without errors.
Reliability: How dependable the software is and its stability over time.
Functionality: If all intended operations are available and functional.
Security and Safety: Protection from attacks and safety concerns.
Portability: How easily it can be moved to other platforms or devices.
Interoperability: How easily it can work with other systems.
Reusability: How easily its components can be reused.
Adaptability: How easily changed to adapt to changing user needs.
Modularity: The ease of separating into smaller components.
Maintainability: The simplicity of fixing bugs, adding features, or updating the software.
Flexibility and Scalability.

Confidentiality: respecting the privacy of clients.
Competence: knowing one's skill limits and not underestimating a project's complexity.
Intellectual property: understanding legal rights about ownership of ideas and work produced.
Computer misuse: not harming other systems or individuals using technical skills (to cause malicious harm).
Code of ethics principles: guiding professional behavior for engineers, educators, managers, and trainees.