SD 1.1

Software Engineering Overview





Course InformationCourse Title: CS1890/CS2890 – Software DesignInstructor: Dr. Carlos MatosDepartment: Computer ScienceContent adapted from: Pfleeger and Atlee (2010)


Overview of Software EngineeringSoftware engineering is a discipline encompassing the systematic design, development, testing, and maintenance of software applications. It combines principles from computer science, project management, and engineering practices to create reliable, efficient, and effective software products that meet specified requirements.

Key Roles in Software Engineering

  • Customer: The entity—be it an individual or organization—that invests in the software system's development. They articulate their needs and provide feedback throughout the development process. Customers include stakeholders who may have differing priorities and expectations from the project.

  • Developer: The organization or individual responsible for building the software system. Developers may specialize in various aspects of the software lifecycle, such as front-end or back-end development or may take on roles such as full-stack developers who cover all facets of the software. Developers work collaboratively in teams, often employing agile methodologies to ensure timely delivery.

  • User: The individuals or groups that will operate the software system upon its release. Understanding user needs and experiences is crucial in designing user-friendly applications. This involves understanding their workflows, pain points, and how they interact with technology.


Relationships:Customers sponsor the development of the software, providing necessary resources, while developers engineer the product based on user feedback and requirements. The goal is to create a product that users find useful and engaging, ensuring their needs are at the forefront of the development process.


Engineering Approach to Building a SystemPre-Programming Steps:

  1. Requirement Analysis and Definition: Gathering and specifying requirements through interviews, surveys, and studies to ensure clarity about what users want. This includes not just functional requirements (what the software should do) but also non-functional requirements (how the software should perform).

  2. System Design: Crafting an architecture that includes the software's interface with both users and other systems, focusing on how components will interact and function together. This phase involves creating wireframes and user interface designs to visualize the end product.

Programming Steps:

  1. Program Design: Creating detailed algorithms and structures to guide coding, including flowcharts and pseudocode. This step helps to break down the complexity and serves as a roadmap for developers.

  2. Writing the Programs: Translating design documents into code using programming languages. Developers often collaborate using version control systems to manage changes and ensure code quality.

Testing Stages:

  1. Unit Testing: Assessing individual components for correctness, often using automated testing tools. Each part of the software should meet its design specifications before moving forward.

  2. Integration Testing: Ensuring that components work together as intended, identifying any interfaces issues between components.

  3. System Testing: Validating the complete system's overall functionality against requirements, ensuring the software behaves as expected in a production-like environment.

Post-Programming:

  1. System Delivery: Finalizing the product for release to customers and users, which may include deploying on a production server and ensuring all documentation is complete.

  2. Maintenance: Addressing bugs, updates, and enhancements based on user feedback and evolving requirements. Continuous monitoring and iteration are essential as technology and user needs change.


Members of the Development TeamRoles Include:

  • Requirement Analysts: Tasked with documenting precise requirements identified through discussions with customers. They work to facilitate communication between stakeholders and the development team.

  • Designers: Responsible for architecting the system's structure and functionality, focusing on user experience and interface issues.

  • Programmers: Skilled professionals who implement the designs through coding efforts, often collaborating in coding teams.

  • Testers: Play a crucial role in finding and reporting defects in the system before release, utilizing various testing strategies and tools.

  • Trainers: Provide essential training to users, educating them on how to effectively use the software system, ensuring successful adoption of the technology.

  • Maintenance Team: In charge of fixing defects and making iterative improvements as required.

  • Librarians: Manage and archive all documents related to software development projects, ensuring that knowledge is retained and accessible for future projects.

  • Configuration Management Team: Ensure that all changes made to the software maintain traceability and organization among various project artifacts, crucial for compliance and rollback capabilities.


Success and Challenges in Software EngineeringAchievements:

  • Enhanced efficiency in various sectors through technological advancements (e.g., office applications, communication tools).

  • Supported progress in crucial areas such as healthcare, where software aids in diagnosis and treatment, and agriculture, through improved resource management and predictive analytics.

Issues with Software:

  • Software systems often encounter problems that can lead to significant errors, faults, and potential failures impacting users' trust and safety.


Examples of Software FailureCase Studies:

  • IRS Automated Tax Processing: A project that escalated from an initial budget of $103 million to $193 million due to various developmental challenges, leading to significant lost interests and additional overtime costs.

  • Therac-25 Incident: A critical failure where malfunctioning software tragically caused fatalities during medical procedures, highlighting the dire consequences of poor software reliability.

  • Reliability Constraints: Many safety-critical systems, such as those in aviation and healthcare, were scrapped due to the immense risks presented by software failures; the target reliability for these systems is often set to a benchmark of 10^-9 failures per hour.


Defining Good SoftwareQuality Considerations:

  • Product Quality:

    • Correctness: Adherence to the specified requirements, ensuring all functionality is implemented correctly.

    • Reliability: Ability to perform under specified conditions without failure, crucial for user trust.

    • Efficiency: Optimal use of resources (time, memory), which can impact performance and cost.

    • Usability: Ease of use for end-users, focusing on intuitive interfaces and accessibility.

    • Maintainability: Ease with which the software can be modified post-delivery, impacting long-term sustainability.

    • Reusability: The extent to which components can be used in other projects, promoting efficiency and reducing redundancy.

  • Process Quality: Highlights the significance of development and maintenance processes, focusing on modeling for fault detection and fault tolerance strategies.

  • Contextual Quality: Measures the business value of the software in terms of Return on Investment (ROI) and overall impact on organizational goals, emphasizing alignment with strategic objectives.


The Software Engineering ProcessProblem Solving in Software Engineering:

  • Complexity: Managing the inherent complexities of software products requires both thorough analysis (to simplify problems) and synthesis (to integrate components into a cohesive system).

Processes Involved:

  • Methods/Techniques: Formal methodologies employed to achieve technical or operational goals independent of the tools used in execution. These can range from traditional Waterfall models to modern Agile approaches.

  • Tools: Automated environments and software utilities designed to enhance productivity and streamline tasks. Tools may include Integrated Development Environments (IDEs), version control systems, and testing frameworks.

  • Procedures: Established protocols that combine tools and techniques for linear or iterative product development, ensuring consistency and quality across projects.

  • Paradigms: Various philosophies directing software development practices, such as Object-Oriented, Procedural, and Agile methodologies, each with its own strengths and suitability depending on the project context.


Positioning of Software EngineeringRelationship to Other Fields:

  • Computer Science: Focuses on theoretical foundations, hardware, algorithms, compilers, and programming languages.

  • Software Engineering: Applies computer science principles to create software as problem-solving instruments, emphasizing practicality, user needs, and iterative development, bridging gaps between theory and real-world applications.