Software Engineering 5 - Tatiana Summary

Question 1

Shortly explain the Software process model: waterfall model

Answer 1

Description:
The Waterfall Model follows a linear, sequential approach to software development, where each phase (e.g., requirements gathering, design, implementation, testing, and maintenance) must be completed before the next phase begins.
Key Characteristics:
Rigid and structured approach.
No overlapping or revisiting previous phases.
Best suited for projects with well-defined requirements.
Example:
Development of government systems or safety-critical applications with stable, predefined requirements.

Question 2

Shortly explain the Software process model: incremental development

Answer 2

Description:
Incremental Development involves building a system in small, manageable increments or modules. Each increment adds functionality to the system and goes through the phases of development. The system grows with each iteration until the full product is delivered.
Key Characteristics:
Combines iterative development with gradual feature delivery.
Allows feedback after each increment.
Lower risk compared to a single large delivery.
Example:
Building an e-commerce platform where the shopping cart is developed and delivered first, followed by a payment gateway in a later increment.

Question 3

Shortly explain the Software process model: reuse-oriented development

Answer 3

Description:
Reuse-Oriented Development focuses on building software systems by reusing existing components (e.g., libraries, frameworks, or pre-built modules) rather than developing from scratch.
Key Characteristics:
Reduces development time and costs by leveraging reusable components.
Includes activities such as component selection, customization, and integration.
Suitable for systems where pre-existing modules can be integrated seamlessly.
Example:
A web application built using pre-existing authentication libraries, UI frameworks, and payment API modules.

Question 4

Shortly explain the Software process model: agile model

Answer 4

Description:
The Agile Model emphasizes iterative and incremental development, with a focus on flexibility, collaboration, and delivering working software in small cycles. Agile prioritizes customer collaboration, adaptability to change, and continuous improvement.
Key Characteristics:
Short development cycles (sprints).
Regular stakeholder feedback.
Self-organizing, cross-functional teams.
Welcomes changing requirements even late in development.
Example:
A mobile app where new features and updates are continuously released based on user feedback, improving the product over time.

Question 5

Choose one software process model that best fits each scenario (Or combination of models). Briefly explain your solution:

A medical device manufacturer is developing a heart-rate monitor with embedded software. The software must be certified to meet healthcare safety standards (e.g., FDA regulations). Any bug could have serious real-world consequences.

Answer 5

Medical Device Heart-Rate Monitor Software: Waterfall Model with Incremental Development to meet safety standards and support gradual testing.

Solution: A Waterfall Model with incremental testing phases is ideal due to the need for certification and safety-critical requirements.

Justification:
The Waterfall Model provides structured, well-documented phases (requirements, design, implementation, and validation) necessary for regulatory approval (e.g., FDA certification).
However, Incremental Development can be combined to break the system into smaller functional modules (e.g., signal processing, user interface) that are validated incrementally.
This ensures the overall system meets safety requirements without overwhelming complexity.

Example: The initial increment may focus on monitoring and displaying heart rate, followed by adding alarms for abnormal readings.

Question 6

Choose one software process model that best fits each scenario (Or combination of models). Briefly explain your solution:

A mid-sized game studio aims to build a proprietary graphics engine for next-generation consoles, focusing on photorealistic rendering. The engine must integrate with various platforms and hardware and be licensed to other studios for revenue.

Answer 6

Graphics Engine for Next-Gen Consoles: Incremental Development with Reuse-Oriented Development for modular development and hardware integration.

Solution: Incremental Development is suited for gradually building engine modules (e.g., rendering, physics, shaders), while Reuse-Oriented Development is appropriate for integrating hardware libraries and existing APIs.

Justification:
The project is highly complex and involves many independent sub-systems that can be developed incrementally and integrated over time.
Reuse-Oriented Development saves time by leveraging pre-existing hardware drivers and platform APIs rather than building everything from scratch.
Incremental releases also allow testing the engine across multiple platforms early in development.

Example: The team may first implement a rendering core that works on PC and consoles, followed by integrating real-time ray tracing support.

Question 7

Choose one software process model that best fits each scenario (Or combination of models). Briefly explain your solution:

A new start-up wants to make a highly realistic simulation game depicting the work of a car mechanic. The developers plan to expand their game based on releases of new DLCs.

Answer 7

Simulation Game for a Car Mechanic: Agile Model for flexibility and DLC-based expansion.

Solution: The Agile Model is ideal due to the focus on an evolving game and future expansions (DLCs).

Justification:
Agile allows the team to release a core version of the game early and expand iteratively based on user feedback and changing trends.
Frequent releases (sprints) allow developers to deliver working gameplay features while collaborating with stakeholders to refine mechanics (e.g., customizing cars, adding tools).
Agile supports DLC expansions by iterating on existing content and adding new features.

Example: In the first release, the game may support basic repairs, while later sprints introduce engine rebuilds, performance tuning, and additional vehicles.

Question 8

Choose one software process model that best fits each scenario (Or combination of models). Briefly explain your solution:

A team of data scientists is building a research tool to analyze medical images using machine learning. They expect new algorithmic breakthroughs and changes in data-processing pipelines to occur frequently, especially as new research is published.

Answer 8

Medical Image Analysis Tool: Agile Model for rapid iteration and adaptation to new research findings.

Solution: The Agile Model is most suitable due to the frequent changes in algorithms and data pipelines.

Justification:
Machine learning research evolves rapidly, requiring the team to adapt to breakthroughs and new research findings.
Agile supports frequent experimentation, prototyping, and adjustments, allowing the tool to remain state-of-the-art.
Collaboration with researchers ensures that algorithm improvements can be tested and integrated quickly during each sprint.

Example: The team may first implement a baseline neural network model for image classification and iteratively improve it with new algorithms as research progresses.

Question 9

Explain: Requirements Engineering (RE)

Answer 9

Requirements Engineering (RE) is the process of defining, documenting, and maintaining the requirements for a software system.

Question 10

Explain: User Requirements

Answer 10

User Requirements describe what the users expect the system to do, typically in a natural language format. These are high-level goals or functions the system should support.

Question 11

System Requirements

Answer 11

System Requirements specify the detailed and precise functionality and constraints of the software system. These are usually documented in a formal or technical way and are divided into functional and non-functional requirements.

Question 12

Functional Requirements

Answer 12

Functional Requirements: Describe what the system should do.

Question 13

Non-Functional Requirements

Answer 13

Non-Functional Requirements: Describe how the system performs tasks (e.g., performance, security).

Question 14

Validation

Answer 14

Validation in software engineering ensures that the system meets the user’s needs and requirements. It answers the question: “Are we building the right system?”

Question 15

Domain Requirements

Answer 15

Domain Requirements are requirements that arise from the specific domain or context in which the system operates.

Question 16

User Story

Answer 16

User Story is a simple, informal description of a feature from the perspective of an end-user. It follows a common structure:

Structure:
“As a [type of user], I want [some goal] so that [reason/benefit].”

Question 17

Multiplayer online fantasy game, in a setting of medieval Europe. Give examples of requirements that might be imposed on such a project. Make 3 User requirements:

Answer 17

User requirements:

1) Players should feel immersed in a realistic medieval European setting with detailed landscapes, buildings and characters.

2) Players should be able to create and customize their characters easily.

3) Players should be able to communicate with each other in-game.

4) Players should be able to participate in real-time combats

Question 18

Multiplayer online fantasy game, in a setting of medieval Europe. Give examples of requirements that might be imposed on such a project. Make 3 System requirements:

Answer 18

System requirements:

1) The system must use client-server architecture to ensure real-time multiplayer functionality.

2) The system must run on Windows and macOS

3)The system must support at least 100 000 concurrent players without performance degradation.

Question 19

Multiplayer online fantasy game, in a setting of medieval Europe. Give examples of requirements that might be imposed on such a project. Make 3 Functional requirements:

Answer 19

Functional requirements:

1) The system must allow users to select hairstyles, armor, and colors for their characters during character creation.

2) The chat system must support real-time text communication and store logs.

3) The system must allow players to perform parries, blocks, and dodges using keyboard and mouse or controller inputs.

4) The system must allow players to create accounts, log in securely, reset passwords, and manage personal details.

Question 20

Multiplayer online fantasy game, in a setting of medieval Europe. Give examples of requirements that might be imposed on such a project. Make 3 Non-functional requirements:

Answer 20

Non-functional requirements:

1) The system must ensure that combat interactions (e.g., attacks, skill usage) occur within 150 milliseconds of player input under standard internet conditions (ping 50 ms or less).

2) The map for each city with 3 districts must load within 2 seconds

3) The backend servers must process and respond to user actions (e.g., login, combat interactions) in under 500 milliseconds during peak loads.

Question 21

Multiplayer online fantasy game, in a setting of medieval Europe. Give examples of requirements that might be imposed on such a project. Make 3 Domain requirements (Note that these often overlap with functional requirements):

Answer 21

Domain requirements (Note that these often overlap with functional requirements):

1) The game world is structured around five kingdoms, and each kingdom’s history is told through a main quest containing 10 interconnected sub-quests.

2) The game must feature combat mechanics based on medieval knightly traditions, including sword fighting, jousting, and shield defences

3) Each city must include distinct districts, such as a market square, residential area, and castle grounds, to reflect medieval urban planning.

Question 22

Multiplayer online fantasy game, in a setting of medieval Europe. Give examples of requirements that might be imposed on such a project. Make 3 User stories:

Answer 22

User stories

1) As a mage, I want to learn new spells by taking magical trials to gain more powerful abilities for combat.

2) As a player, I want to customize my character’s appearance, including clothing, hairstyles, and accessories, so that I can express my individuality.

3) As a player, I want to participate in server-wide world events

Question 23

Model-View-Controller (MVC) - What are some scenarios where the Model-View-Controller (MVC) pattern would be appropriate?
Mention 5

Answer 23

Web Applications
Mobile Applications
Desktop GUI Applications
Games with Complex UI Components
SaaS Platforms (Software as a Service)

Question 24

Why is the MVC pattern approriate for developing Web Applications?

Answer 24

The model represents the business logic (e.g., retrieving products from the database), the view handles the UI (e.g., HTML pages), and the controller manages user input (e.g., handling form submissions).
Multiple views can be generated for different devices (desktop, mobile) while reusing the same model and controller logic.

Question 25

Why is the MVC pattern approriate for developing Mobile Applications?

Answer 25

In mobile apps, separating the UI (View) from data handling (Model) and input events (Controller) makes it easier to adapt the UI for different screen sizes and orientations.
Improves testability—you can test the model and controller logic separately from the view.

Question 26

Why is the MVC pattern approriate for developing Desktop GUI Applications?
Ex A media player

Answer 26

GUI-based apps usually have a visual component (the player interface) that must update frequently based on internal states (play, pause, etc.).
The controller handles user actions (play, pause, skip), the view updates the screen, and the model keeps track of media files, playlists, and playback states.

Question 27

Why is the MVC pattern approriate for developing Games with Complex UI Components?
Ex A role-playing game (RPG) with a UI that shows the player’s inventory, health, and quest progress.

Answer 27

The model represents the game state (player stats, items, quests), the view displays the stats in real-time, and the controller processes user actions (selecting items, moving characters).
By using MVC, the game logic remains separate from UI rendering, making it easier to update the interface or logic independently.

Question 28

Why is the MVC pattern approriate for developing SaaS Platforms (Software as a Service)?
Ex A document editing platform that saves user changes in real-time.

Answer 28

MVC ensures that the model (document data) is updated consistently while the view (UI displaying the document) shows changes immediately.
The controller processes user inputs (typing, formatting actions) and updates the model, which triggers updates to the view.

Question 29

Explain Layered Architecture

Answer 29

A Layered Architecture is a software design pattern that organizes the system into a set of distinct layers or tiers, each with a specific responsibility. These layers interact with each other sequentially (one layer only communicates with the adjacent layers), promoting separation of concerns and making the system easier to understand, maintain, and scale.

Question 30

What are the key layers in layered architecture?

Answer 30

Presentation Layer (UI Layer)
Business Logic Layer (Application Layer)
Data Access Layer (Persistence Layer)
Database Layer

Question 31

Explain the Presentation Layer (UI Layer) in layered architecture

Answer 31

Handles the user interface and displays information to the user.

Receive input from users and send requests to the business layer.
Render data received from the business or service layer into a format that the user can interact with (e.g., web pages, mobile app screens).

Question 32

Explain the Business Logic Layer (Application Layer) in layered architecture

Answer 32

Implements the core functionality of the application (i.e., the “business rules”).

Processes data sent from the presentation layer.
Makes decisions, performs calculations, and enforces rules.
Coordinates interactions between the presentation layer and the data layer.

Question 33

Explain the Data Access Layer (Persistence Layer) in layered architecture

Answer 33

Responsible for managing access to the data (database or file storage).

Retrieve, store, update, and delete data from the underlying database.

Question 34

Explain the Database Layer in layered architecture

Answer 34

Contains the actual physical or logical data storage systems.

Question 35

Is MVC a Layered Architecture?

Answer 35

Yes, MVC is a form of layered architecture, but it is UI-centric and designed specifically to separate concerns related to user interaction. It differs from traditional layered architectures by focusing on how the user interface components (View and Controller) interact with the underlying data and logic (Model) in an event-driven manner, rather than following a strict hierarchical flow.

Question 36

explain Client-Server Architecture

Answer 36

Client-Server Architecture is a network architecture where the system is divided into two main components:

1. Client: The device or application that requests services (e.g., a web browser or mobile app).
2. Server: The centralized machine or service that provides services (e.g., database, application logic, or files).

The client sends a request to the server, which processes the request and sends back a response. This architecture enables distributed communication between different devices and applications.

Question 37

what are the key Components of Client-Server Architecture

Answer 37

Client and Server

Question 38

Explain the component client in Client-Server Architecture

Answer 38

Client:
A user-facing application or device (e.g., web browser, mobile app) that requests data or services.
Responsible for:
Sending requests to the server (e.g., “fetch my account balance”).
Presenting the response from the server to the user (e.g., displaying the balance).

Question 39

Explain the component server in Client-Server Architecture

Answer 39

Server:
A system or service that responds to client requests.
Responsible for:
Receiving and processing client requests.
Performing actions such as querying databases, performing calculations, or returning requested files.
Sending responses back to the client.

Question 40

give 3 examples of Client-Server Systems:

Answer 40

Web Applications:
The client is the browser (Chrome, Firefox, etc.), and the server is a web server (e.g., Nginx, Apache) or application server (e.g., Django, Node.js).

Email Systems:
The client is an email client (e.g., Gmail, Outlook).
The server is an email server that handles incoming and outgoing emails.

Database Access:
The client is a SQL client (e.g., pgAdmin, MySQL Workbench).
The server is the database server (e.g., MySQL, PostgreSQL).

Question 41

explain Pipe and Filter Architecture

Answer 41

The Pipe and Filter architecture is a software design pattern where a system is composed of a sequence of filters (processing units) connected by pipes (data streams). The architecture is commonly used for systems where data needs to be transformed through multiple processing stages in a structured, modular way.

Question 42

The 2 key comcepts of Pipe and Filter Architecture is filters and pipes.
explain filters:

Answer 42

A filter is a processing unit that performs a specific, independent operation on the input data and produces output.
Filters do not store any internal state between processing steps.
Examples of operations performed by filters: transforming, formatting, validating, encrypting, or aggregating data.

Question 43

The 2 key comcepts of Pipe and Filter Architecture is filters and pipes.
explain pipes:

Answer 43

A pipe is a communication channel that connects two filters.
Pipes transfer the output of one filter as the input to the next filter.
Pipes enable streaming of data, allowing one filter to pass its output to the next in real time.

Question 44

when can pipe and filter architecture be used?

Answer 44

Data Processing Pipelines: Systems that process and transform data in stages (e.g., ETL systems, streaming platforms).

Text and File Processing: Systems that perform tasks like reading, filtering, transforming, and outputting text or files (e.g., log processors).

Compilers: Systems that translate source code into machine code through multiple stages.

Media Processing: Applications that perform tasks like encoding, decoding, and rendering video or audio files.

Question 45

explain 4+1 View Model

Answer 45

The 4+1 View Model is a framework for describing the architecture of a software system using five different views to address different concerns of stakeholders. It improves communication, analysis, and understanding of complex systems by breaking down their structure into multiple perspectives

Question 46

mentions the 5 perspesctives in 4+1 View Model

Answer 46

Logical View (What the system does)
Development View (How the system is built)
Process View (How the system behaves dynamically)
Physical View (Where the system is deployed)
Scenarios (Use Cases or +1 View)

Question 47

explain the Logical View in 4+1 View Model

Answer 47

Logical View (What the system does)
Focus: Describes the functional aspects of the system and how the system is organized into classes, components, and relationships.
Audience: Software designers and developers.
Artifacts: Class diagrams, entity-relationship diagrams (ERD), and sequence diagrams.
Purpose:
To capture the system’s behavior in terms of concepts and objects.
It focuses on meeting the functional requirements.

Question 48

explain the Development View in 4+1 View Model

Answer 48

Development View (How the system is built)

Focus: Describes the static organization of the software in terms of modules, components, and subsystems.
Audience: Developers and software engineers responsible for implementation.
Artifacts: Component diagrams, package diagrams, version control structures.
Purpose:
To show how the system is divided for development.
It addresses maintainability, reusability, and work allocation.

Question 49

explain the Process View in 4+1 View Model

Answer 49

Process View (How the system behaves dynamically)

Focus: Describes the system’s runtime behavior, including processes, threads, and communication between them.
Audience: System architects and performance engineers.
Artifacts: Sequence diagrams, activity diagrams, and communication diagrams.
Purpose:
To capture concurrency, synchronization, performance, and scalability requirements.
Helps model system interactions at runtime.

Question 50

explain the Physical View in 4+1 View Model

Answer 50

Physical View (Where the system is deployed)

Focus: Describes the deployment and hardware topology of the system.
Audience: System administrators, IT teams, and network engineers.
Artifacts: Deployment diagrams, network topology diagrams, and server configurations.
Purpose:
To capture the physical distribution of software components.
Helps with scalability, fault tolerance, and physical resource planning.

Question 51

explain the Scenarios in 4+1 View Model

Answer 51

Scenarios (Use Cases or +1 View)

Focus: Describes use cases or user scenarios to show how the system behaves across the different views.
Audience: All stakeholders (developers, architects, testers, business analysts, etc.).
Artifacts: Use-case diagrams, sequence diagrams, and textual descriptions of use cases.
Purpose:
To validate the architecture and ensure that all views work together cohesively.
The scenarios ensure that the system meets the functional and non-functional requirements.

Question 52

Consider a distributed e-commerce system. Which architectural pattern(s) would you recommend and why?

Answer 52

For the distributed e-commerce system:

Primary Patterns:
- Client-Server Architecture: For handling client-server interactions.
- Layered Architecture: To structure the internal backend services.
- 4+1 View Model: For documenting and validating the system architecture.

Secondary Patterns:
- Pipe and Filter: Only if you need log or analytics pipelines.
- MVC: Only for the frontend presentation layer (e.g., web UI).

Question 53

Propose a client-server architecture for a car rental application. Identify the clients.

Answer 53

Clients (Frontend Applications)
The clients are the interfaces that users interact with. The car rental application can have multiple types of clients:
Web Application: Accessed via web browsers by customers to browse available cars, make reservations, and view bookings.
Mobile Application: Accessed via mobile devices for quick car reservations and GPS-enabled rental tracking.
Admin Interface: Used by rental staff to manage cars, approve reservations, and update rental status.

Question 54

Propose a client-server architecture for a car rental application. Identify the servers.

Answer 54

Servers (Backend Services)
The servers process client requests and store/manage the data.
Application Server:
Handles client requests, such as booking requests, car availability queries, and customer authentication.
Implements business logic (e.g., validating reservations, calculating rental fees).
Database Server:
Stores data related to cars, bookings, customers, and payments.
Supports querying for available cars and updating the status of reservations.
Authentication Server:
Handles user login, registration, and session management.
Payment Gateway Integration:
Manages secure payment processing for rentals via third-party services (e.g., PayPal, Stripe).

Question 55

Propose a client-server architecture for a car rental application. Identify the network’s role.

Answer 55

Network Role
The network facilitates communication between the clients and the servers:
Internet or Private Network:
The web and mobile applications communicate with the backend over the internet using secure HTTPS requests.
Intranet (for Rental Branches):
For internal operations (e.g., branch offices accessing the system), requests may go through a private intranet for enhanced security.
Load Balancer:
Distributes incoming requests from clients to multiple instances of the application server to prevent server overload and ensure high availability.
Firewall and Security Layers:
Protects the servers from unauthorized access and network threats.

Question 56

For a real-time weather monitoring system, suggest an appropriate architectural pattern. Justify your choice based on system requirements.

Answer 56

Client-Server Architecture
This pattern is the best fit for a real-time weather monitoring system where:

Clients: Users (via web/mobile apps) who view real-time weather updates.
Server: Collects weather data from sensors and external APIs, processes it, and sends updates to the clients.

Question 57

Identify a real-world system you are familiar with (e.g., banking app, social media platform). Describe its architecture using the 4+1 view model.

Answer 57

Using the 4+1 View Model, the online banking system is described from multiple perspectives:

Logical View: Functional decomposition (e.g., services for accounts, transactions).
Development View: Structure of the codebase and modules.
Process View: Dynamic workflows for operations like login and transfers.
Physical View: Deployment details across servers and databases.
Scenarios (+1): Use cases like logging in and transferring funds to validate the architecture.

Question 58

Explain how architectural views like logical, process, development, and physical views can be applied to the design of a smart home system.

Answer 58

The 4+1 View Model provides a comprehensive description of the smart home system:

The Logical View shows the core components (like device management and automation).
The Process View shows the dynamic behavior during user interactions and sensor triggers.
The Development View focuses on how the codebase is organized.
The Physical View describes the deployment of cloud services, IoT devices, and the home network.
The Scenarios (+1) validate that the architecture supports real-world use cases (like turning on devices and sending notifications).

Question 59

(SOLID) Provide an example of a violation of single responsibility principle and how you would refactor it to comply.

Answer 59

Imagine a UserManager class in an application that is responsible for handling both user data management and sending notifications.

The UserManager class has two responsibilitie

Refactored Code (Compliant with SRP):
Separate Concerns into Two Classes
UserManager will handle only user-related operations (e.g., saving user data).
A new NotificationService class will handle all notification-related tasks.

Question 60

Development Testing:
Explain very short:
1. Unit Testing
2. Component Testing
3. System Testing

Answer 60

1. Unit Testing: Tests individual components.
2. Component Testing: Tests integrated groups of units.
3. System Testing: Tests the whole system’s behaviour.

Question 61

Explain release testing

Answer 61

Release testing is the process of testing a software system in its final, deployable form before it is released to end-users.

Question 62

User Testing
Explain very short:
1. Alpha Testing
2. Beta Testing
3. Acceptance Testing

Answer 62

1. Alpha Testing: Developers test with users in-house.
2. Beta Testing: Users test in their environment.
3. Acceptance Testing: Customers validate readiness for deployment.

Question 63

You are provided with a calculator application. It supports the following operations:

addition
subtraction
multiplication
division (handles divide-by-zero errors)
power (exponential calculation)
Write detailed test cases, including inputs, expected outputs, and test types (e.g., unit tests, edge cases).

Answer 63

Unit testing example
Test name: Addition of positive numbers
Input: add(3, 5)
Expected output: 8

Test name: division by zero
Input: divide(10, 0)
Expected output: Error: Cannot divide by zero

System testing
Test name: chain operations
Input: add(multiply(2, 3), divide(10, 2))
Expected output: 11

Performance testing example:
Test name: high-volume Computation
Input: perform power(2, 100000)
Expected outcome: Should compute the result without crashing within a reasonable time.