System Design & Analysis
Multiple Choice Questions

The process of studying a system to identify its components and requirements

The process of coding a system

The process of testing a system

The process of deploying a system

Analysis studies requirements, design creates solutions

Design studies requirements, analysis creates solutions

Both study requirements

Both create solutions

A collection of interrelated components working together

A single component

A programming language

A type of hardware

Closed has no interaction with environment, open interacts

Open has no interaction with environment, closed interacts

Both interact with environment

Neither interacts with environment

To determine if a project is viable and worth pursuing

To write code for the system

To test the system

To deploy the system

Technical, Economic, Operational, Schedule

Technical, Financial, Social, Legal

Technical, Economic, Social, Time

Technical, Financial, Operational, Legal

Software Development Life Cycle

System Design Life Cycle

Software Design Life Cycle

System Development Life Cycle

Planning, Analysis, Design, Implementation, Testing, Maintenance

Design, Code, Test, Deploy

Plan, Execute, Monitor, Close

Analyze, Design, Build, Test

A linear sequential model where each phase must be completed before moving to the next

An iterative model with cycles

A model with concurrent phases

A model with random phases

An iterative approach with flexible requirements

A rigid sequential approach

A model without planning

A model with no testing

Agile is iterative, Waterfall is sequential

Waterfall is iterative, Agile is sequential

Both are sequential

Both are iterative

To update and fix the system after deployment

To design the system

To test the system

To plan the system

The process of discovering, analyzing, documenting, and managing requirements

The process of coding the system

The process of testing the system

The process of deploying the system

Functional describes what the system should do, non-functional describes how it should do it

Non-functional describes what the system should do, functional describes how it should do it

Both describe what the system should do

Both describe how the system should do it

Clear, Complete, Consistent, Testable, Feasible

Vague, Incomplete, Inconsistent

Complex, Long, Detailed

Simple, Short, Basic

A description of how users interact with the system

A code module

A test case

A deployment plan

To ensure requirements are correct and complete

To write code for the requirements

To test the requirements

To deploy the requirements

User requirements are from user perspective, system requirements are from developer perspective

System requirements are from user perspective, user requirements are from developer perspective

Both are from user perspective

Both are from developer perspective

The process of creating a blueprint for a system

The process of coding the system

The process of testing the system

The process of deploying the system

High-level shows overall architecture, detailed shows implementation specifics

Detailed shows overall architecture, high-level shows implementation specifics

Both show overall architecture

Both show implementation specifics

Dividing a system into smaller, manageable modules

Creating a single large module

Designing without modules

Designing with random modules

To provide reusable solutions to common design problems

To write code

To test code

To deploy code

Coupling is about module inter-dependency, cohesion is about intra-module focus

Cohesion is about module inter-dependency, coupling is about intra-module focus

Both are about inter-dependency

Both are about intra-module focus

Modules should be focused and have minimal dependencies

Modules should be complex and have many dependencies

Modules should be unrelated

Modules should be identical

Unified Modeling Language

Universal Modeling Language

Unified Modeling Logic

Universal Modeling Logic

To visualize and document system designs

To write code

To test code

To deploy code

A diagram showing classes and their relationships

A diagram showing system processes

A diagram showing user interactions

A diagram showing system components

A diagram showing interactions between users and the system

A diagram showing class relationships

A diagram showing system architecture

A diagram showing deployment

Aggregation is a weak relationship, composition is strong

Composition is a weak relationship, aggregation is strong

Both are weak relationships

Both are strong relationships

A diagram showing the sequence of interactions between objects

A diagram showing class relationships

A diagram showing system architecture

A diagram showing deployment

The overall structure of a system

The code of a system

The testing of a system

The deployment of a system

A system where clients request services from servers

A system with no servers

A system with only servers

A system with only clients

2-tier has client and server, 3-tier adds business logic layer

3-tier has client and server, 2-tier adds business logic layer

Both have two tiers

Both have three tiers

An architecture with small, independently deployable services

A large monolithic architecture

An architecture with no services

An architecture with one service

Monolithic is one large application, microservices are small independent services

Microservices is one large application, monolithic are small independent services

Both are monolithic

Both are microservices

To design systems as collections of services

To design systems as single applications

To design systems without services

To design systems with only hardware

The process of creating a database structure

The process of writing queries

The process of testing databases

The process of deploying databases

Logical is independent of DBMS, physical is implementation-specific

Physical is independent of DBMS, logical is implementation-specific

Both are independent of DBMS

Both are implementation-specific

Organizing data to reduce redundancy and improve integrity

Adding redundant data

Deleting data

Creating complex data structures

1NF, 2NF, 3NF, BCNF, 4NF, 5NF

1NF, 2NF, 3NF

1NF, 2NF, 3NF, 4NF

1NF, 2NF, 3NF, BCNF

A diagram showing entities and their relationships

A diagram showing user interactions

A diagram showing system architecture

A diagram showing deployment

To uniquely identify each record in a table

To identify foreign keys

To delete records

To update records

UI is about interface appearance, UX is about user experience

UX is about interface appearance, UI is about user experience

Both are about appearance

Both are about experience

To create an intuitive and user-friendly interface

To make interfaces complex

To reduce usability

To ignore user needs

Simplicity, Consistency, Feedback, Accessibility

Complexity, Inconsistency, No Feedback

Randomness, Chaos, Confusion

Difficulty, Unclear Navigation

To create a low-fidelity layout of the interface

To create a high-fidelity prototype

To write code for the interface

To test the interface

To understand user needs and behaviors

To ignore user needs

To make assumptions about users

To avoid user testing

Usability tests design, UAT tests if system meets business needs

UAT tests design, usability tests business needs

Both test design

Both test business needs

The process of evaluating a system to find defects

The process of writing code

The process of designing the system

The process of deploying the system

Verification checks if we built the system right, validation checks if we built the right system

Validation checks if we built the system right, verification checks if we built the right system

Both check if we built the system right

Both check if we built the right system

Unit Testing, Integration Testing, System Testing, Acceptance Testing

Unit Testing, System Testing

Integration Testing, System Testing

Unit Testing, Integration Testing

Black-box tests without knowing internal structure, white-box tests with knowledge of internal structure

White-box tests without knowing internal structure, black-box tests with knowledge of internal structure

Both test without knowing internal structure

Both test with knowledge of internal structure

To ensure changes haven't broken existing functionality

To test new features

To test performance

To test security

Processes to ensure the system meets quality standards

Testing the system once

Ignoring quality issues

Deploying without testing

The process of planning, organizing, and managing resources

The process of writing code

The process of testing the system

The process of deploying the system

A document that formally authorizes a project

A document that contains code

A document that contains test cases

A document that contains deployment plans

PM manages the project, SA studies requirements and designs solutions

SA manages the project, PM studies requirements

Both manage the project

Both study requirements

To identify and mitigate potential problems

To ignore risks

To create risks

To avoid planning

To visualize project schedule and progress

To write code

To test systems

To deploy systems

To manage changes to the system in a controlled manner

To prevent all changes

To make random changes

To ignore change requests

The process of deploying and installing the system

The process of designing the system

The process of testing the system

The process of planning the system

Direct replaces old system immediately, phased replaces gradually

Phased replaces old system immediately, direct replaces gradually

Both replace immediately

Both replace gradually

To ensure users can effectively use the system

To make users avoid the system

To confuse users

To ignore user needs

To provide information about the system for users and developers

To hide system information

To confuse users

To avoid maintenance

User docs are for end-users, technical docs are for developers

Technical docs are for end-users, user docs are for developers

Both are for end-users

Both are for developers

To migrate data and processes from old system to new system

To delete old system data

To create data

To ignore old system

The process of updating and fixing the system after deployment

The process of designing the system

The process of testing the system

The process of planning the system

Corrective, Adaptive, Perfective, Preventive

Corrective, Adaptive, Perfective

Corrective, Adaptive

Corrective, Preventive

Fixing bugs and errors

Adding new features

Adapting to new environments

Preventing future issues

Adapting the system to new environments

Fixing bugs

Adding new features

Preventing issues

Perfective improves performance, preventive prevents future issues

Preventive improves performance, perfective prevents future issues

Both improve performance

Both prevent future issues

To move the system to new hardware or platform

To delete the system

To create a new system

To ignore the system

Using remote servers for computing and storage

Using local servers

Using personal computers

Using mobile devices

IaaS provides infrastructure, PaaS provides platform, SaaS provides software

PaaS provides infrastructure, IaaS provides platform, SaaS provides software

SaaS provides infrastructure, IaaS provides platform, PaaS provides software

All provide the same service

Network of interconnected devices with sensors and software

A single device

A type of software

A type of hardware

To create intelligent and adaptive systems

To make systems less intelligent

To remove automation

To make systems static

A distributed ledger technology

A centralized database

A type of cloud service

A type of hardware

To integrate development and operations for faster delivery

To separate development and operations

To ignore deployment

To slow down delivery

The process of creating a conceptual representation of data

The process of writing code

The process of testing data

The process of deploying data

Conceptual is high-level, logical is detailed, physical is implementation-specific

Physical is high-level, logical is detailed, conceptual is implementation-specific

Logical is high-level, conceptual is detailed

All are the same

To visualize the relationships between data entities

To write code

To test systems

To deploy systems

Weak entity depends on another entity, strong entity can exist independently

Strong entity depends on another entity, weak entity can exist independently

Both are independent

Both are dependent

To store metadata about the database

To store actual data

To delete data

To update data

Data model is the structure, data diagram is the visual representation

Data diagram is the structure, data model is the visual representation

Both are structures

Both are visual representations

The process of designing security measures into the system

The process of ignoring security

The process of adding security after deployment

The process of removing security

Authentication verifies identity, authorization grants permissions

Authorization verifies identity, authentication grants permissions

Both verify identity

Both grant permissions

Users should have minimal necessary permissions

Users should have all permissions

Users should have no permissions

Users should have random permissions

To protect data from unauthorized access

To make data readable

To delete data

To corrupt data

Policy defines rules, mechanism implements them

Mechanism defines rules, policy implements them

Both define rules

Both implement rules

To monitor and control network traffic

To allow all traffic

To block all traffic

To delete traffic

The process of connecting different systems to work together

The process of creating isolated systems

The process of deleting systems

The process of testing systems

Horizontal integrates across systems, vertical integrates within a system

Vertical integrates across systems, horizontal integrates within a system

Both integrate across systems

Both integrate within a system

To allow communication between different systems

To prevent communication between systems

To delete systems

To create isolated systems

Synchronous waits for response, asynchronous doesn't

Asynchronous waits for response, synchronous doesn't

Both wait for response

Neither waits for response

To facilitate communication between systems

To block communication between systems

To delete communication

To create isolated systems

SOA is service-oriented, microservices are independent services

Microservices are service-oriented, SOA are independent services

Both are the same

Neither is service-oriented

To study and analyze system requirements and design solutions

To write code

To test systems

To deploy systems

A model where development and testing phases are paired

A model with no testing

A model with random phases

A model with only development

To gather feedback and refine requirements

To deploy the system

To test the system

To write code

To evaluate and improve the design

To ignore design issues

To complicate the design

To hide design problems

A diagram showing the states of an object

A diagram showing class relationships

A diagram showing system architecture

A diagram showing deployment

To provide reusable architectural solutions

To write code

To test systems

To deploy systems

A key that references a primary key in another table

A key that uniquely identifies a record

A key that is used for indexing

A key that is used for sorting

To compare two versions and choose the better one

To ignore user preferences

To make random changes

To remove features

Functional tests features, non-functional tests performance and security

Non-functional tests features, functional tests performance

Both test features

Both test performance

To schedule and track project tasks

To ignore deadlines

To delay tasks

To cancel tasks

To test the system in a limited environment

To deploy to all users immediately

To ignore testing

To cancel deployment

To protect data from loss

To delete data

To corrupt data

To ignore data

To process data near the source

To process data in the cloud

To delete data

To ignore data

To reduce data redundancy and improve integrity

To increase data redundancy

To delete data

To corrupt data

To identify security vulnerabilities

To delete security

To ignore security

To remove security

To combine data from different sources

To separate data

To delete data

To corrupt data

To determine if the project should proceed

To ignore project viability

To cancel the project

To delay the project

To identify and fix defects

To write code

To design the system

To plan the system

To determine which requirements are most important

To ignore requirements

To make all requirements equal

To delete requirements

To ensure the design meets requirements

To ignore design issues

To complicate design

To hide design problems

A diagram showing the physical deployment of system components

A diagram showing class relationships

A diagram showing user interactions

A diagram showing system processes

To assess if the architecture meets requirements

To ignore architecture

To complicate architecture

To hide architecture issues

To speed up data retrieval

To slow down data retrieval

To delete data

To corrupt data

To adapt the interface to different screen sizes

To ignore screen sizes

To use only one size

To complicate layouts