1. What is Systems Analysis and Design?
Definition (SAD)
Systems analysis and design (SAD) is the process of:
- Examining a business problem
- Determining what system will address the problem
- Designing that system
| Part | Focus |
|---|---|
| Systems Analysis | Study the current system, identify problems / inefficiencies |
| Systems Design | Create a solution: design a system that meets the business requirements |
Goal: build effective and efficient systems that solve business problems.
Example — the house analogy (slide 4). Building software is like building a house:
flowchart LR A["Family's idea of a house<br/>(business need)"] <--> B["Architect's blueprints<br/>(analysis & design)"] B <--> C["Construction site<br/>(implementation)"] C <--> D["Finished house<br/>(delivered system)"]
Why a formal process?
- Failures occur too often.
- Creating systems is not intuitive.
- Projects are late, over budget, or delivered with fewer features than planned.
2. The Systems Analyst
Definition (Systems Analyst)
A person responsible for analyzing and designing systems to meet organizational needs.
Key responsibilities
- Problem-solving — find problems in the existing system or ways to improve the organization.
- Communication — bridge between users, developers and management.
- Documentation — clear specifications and requirements for the new system.
- Facilitating change — smooth implementation and adoption.
⚠ The main goal is not a perfect system — it is to create value for the organization (usually: increase profits). Many systems failed and were abandoned because analysts built a “perfect” system without understanding how it fits the organization’s goals, current business processes and other information systems.
Skills
| Skill | Meaning |
|---|---|
| Technical | Understand relevant technologies and design techniques |
| Business | Understand and align with business objectives |
| Analytical | Break down complex systems |
| Communication | Talk to technical and non-technical audiences |
| Interpersonal | Leadership and management |
| Ethics | Deal fairly, protect confidential information |
Roles
| Role | Focus | Example |
|---|---|---|
| Systems Analyst | Makes sure the IS meets requirements and works correctly | Identifies what features a new application needs |
| Business Analyst | Understands business problems, improves business processes | Finds ways to reduce customer waiting time |
| Infrastructure Analyst | Technical infrastructure (servers, networks, hardware) | Ensures servers can support the new application |
| Change Management Analyst | Helps employees adapt to new systems | Trains employees on new software |
| Project Manager | Finish on time and within budget | Assigns tasks, monitors deadlines, controls costs |
3. Systems Development Life Cycle (SDLC)
Definition (SDLC process)
- Consists of four phases: Planning → Analysis → Design → Implementation.
- Each phase = a series of steps; each phase produces documented deliverables.
- Phases can run sequentially, incrementally, iteratively, or in another pattern.
- SDLC is gradual refinement: each phase uses the previous phase’s deliverables as input and adds detail.
flowchart LR P[Planning<br/>WHY build it?] --> A[Analysis<br/>WHO / WHAT / WHERE / WHEN?] A --> D[Design<br/>HOW to build it?] D --> I[Implementation<br/>Build, install, support] I -.-> P
3.1 Planning Phase
Questions: Why build this system? What value does it provide? How long will it take?
| Step | Activities |
|---|---|
| 1. Project initiation | Develop/receive a system request; conduct a feasibility analysis |
| 2. Project management | Develop the work plan; staff the project; monitor & control |
3.2 Analysis Phase
Questions: Who will use it? What should it do? Where and when will it be used?
- Develop an analysis strategy — model the current (as-is) system, formulate the new (to-be) system.
- Gather requirements — develop a system concept; create a business model of business data and business processes.
- Develop a system proposal — initial deliverable describing which business requirements the system must meet.
3.3 Design Phase
Question: How should we build it?
- Design strategy (in-house, outsource, …)
- Architecture design (hardware, software, network) + interface design (UI, reports, forms)
- Database and file specifications
- Program design — what programs to write and what each one does
- Architecture design + interface design + database/file specs + program design = system specification, handed to the programmers.
- At the end of design, feasibility and project plan are re-examined; the sponsor/approval committee decides to continue or terminate.
3.4 Implementation Phase
- Construct — write code and test it (bugs are very costly → testing is one of the most critical steps).
- Install — train the users.
- Support — maintenance.
⚠ Don’t confuse the phase questions: Planning = why, Analysis = who/what/where/when, Design = how.
4. SDLC Methodologies
Definition (Methodology)
A formalized approach to implementing the SDLC: it defines the steps to follow and the deliverables of each phase.
Categories by focus
| Category | Core of the system concept |
|---|---|
| Process-oriented | Process models |
| Data-centered | Data models |
| Object-oriented | Balances both — process + data in one model |
Classes of methodologies
flowchart TD M[Methodologies] --> S[Structured Design] M --> R[Rapid Application Development] M --> AG[Agile Development] S --> W[Waterfall] S --> PA[Parallel] R --> PH[Phased] R --> PR[Prototyping] R --> TP[Throwaway Prototyping] AG --> SC[SCRUM]
4.1 Structured Design
Waterfall
Phases strictly in sequence: Planning → Analysis → Design → Implementation. Deliverables are long (often hundreds of pages) and must be approved by the sponsor before moving on.
| Advantages | Disadvantages |
|---|---|
| Requirements defined early | Design must be fully specified before programming |
| Minimal changes later | Very rigid; long time before delivery |
| Costly changes if requirements are missed | |
| Poor at handling a changing business environment |
Parallel Development
General design first → system split into subprojects designed and implemented in parallel → integrated at the end.
| Advantage | Disadvantages |
|---|---|
| Faster delivery than waterfall | Dependencies between subprojects (a design decision in one affects another) |
| Integration can be difficult |
4.2 Rapid Application Development (RAD)
Goal: quickly deliver parts of the system to get early user feedback.
- Strengths: faster development, higher user involvement, better requirement refinement.
- Risks: user expectations can grow uncontrollably; less detailed documentation.
| Methodology | How it works | + | − |
|---|---|---|---|
| Phased | Analysis identifies overall requirements; system delivered in sequential versions — core features first, then improvements | First version delivered quickly; users see progress early | Users initially work with an incomplete system |
| Prototyping | Analysis, design, implementation done concurrently and repeatedly; prototype shown to users and improved from feedback | Users clarify needs quickly | Many changes → messy design over time |
| Throwaway Prototyping | Quick prototype built only to gather feedback/understand requirements, then discarded; real system built from the insights | Reduces risk by clarifying requirements | Longer delivery than evolutionary prototyping |
⚠ Prototyping evolves the prototype into the final system; throwaway prototyping throws it away.
4.3 Agile Development
Short development cycles, flexibility, frequent delivery of working software, continuous customer–developer collaboration.
- Core values: working software, collaboration, responding to change.
- Strengths: adapts quickly to changing requirements; continuous improvement.
- Criticisms: hard to scale to large systems; limited documentation.
SCRUM
- Work done in 30-day sprints, with progress reviewed after each.
- Self-organized teams (they make decisions themselves).
- Strengths: fast feedback, high transparency, flexible planning.
- Challenges: scaling to large systems; requires disciplined teams.
4.4 Which Methodology to Use?
| Ability to develop systems… | Waterfall | Parallel | Phased | Prototyping | Throwaway | XP | SCRUM |
|---|---|---|---|---|---|---|---|
| With unclear user requirements | Poor | Poor | Good | Excellent | Excellent | Excellent | Excellent |
| With unfamiliar technology | Poor | Poor | Good | Poor | Excellent | Good | Good |
| That are complex | Good | Good | Good | Poor | Excellent | Good | Good |
| That are reliable | Good | Good | Good | Poor | Excellent | Excellent | Excellent |
| With a short time schedule | Poor | Good | Excellent | Excellent | Good | Excellent | Excellent |
| With schedule visibility | Poor | Poor | Excellent | Excellent | Good | Excellent | Excellent |
Worked example. A bank wants a new system, but users can’t clearly describe what they need and the team has never used the target technology.
- Unclear requirements → rule out Waterfall/Parallel (Poor).
- Unfamiliar technology → Prototyping is Poor.
- Throwaway prototyping is Excellent on both → best fit.
⚠ Prototyping is Poor for complex or reliable systems (design gets messy) — a classic exam trap.
5. Object-Oriented Systems: Basic Characteristics
5.1 Classes & Objects
- Class: template for objects.
- Object (instance): an instantiation of a class.
- Attributes: information describing the class.
- State: the object’s attribute values and relationships at a point in time.
5.2 Methods & Messages
- Methods: the behavior of a class.
- Messages: information sent to an object to trigger a method (like a procedure call).
5.3 Encapsulation & Information Hiding
- Encapsulation: combining process and data in one unit.
- Information hiding: the internal functionality is hidden; only the interface is visible.
5.4 Inheritance
General classes (superclasses) are created; subclasses inherit their data and methods.
5.5 Polymorphism & Dynamic Binding
- Polymorphism: the same message is interpreted differently by different classes.
- Dynamic binding: the object’s type isn’t determined until run time (vs. static binding — decided at compile time).
Worked example.
classDiagram class Person { -name -address +insert() } class Patient { -insuranceCarrier +insert() } class Doctor { -specialty +insert() } Person <|-- Patient Person <|-- Doctor
PatientandDoctorinheritnameandaddressfromPerson.- Sending the same message
insert()to a Patient or a Doctor runs different code → polymorphism. - Which
insert()runs is decided only when the actual object is known at run time → dynamic binding. - The caller only sends the message; it doesn’t know how
insert()works → information hiding.
6. Object-Oriented Systems Analysis & Design (OOSAD)
OOSAD balances data and process, using UML and the Unified Process. Three characteristics:
6.1 Use-Case Driven
- Use cases define system behavior: how users interact with the system to perform an activity (place an order, make a reservation, search…).
- Used to identify and communicate requirements to developers.
- Each use case focuses on one business process.
6.2 Architecture Centric
The architecture is described through three views:
| View | Focus | Example |
|---|---|---|
| Functional (external) | User’s perspective — what users can do | Interface, user actions |
| Static (structural) | Classes, attributes, methods, relationships | Customer with placeOrder(), updateProfile() |
| Dynamic (behavioral) | Messages between classes and resulting behavior | Sequence diagram |
6.3 Iterative & Incremental
Continuous testing and refinement; the analyst understands the system better with each iteration.
6.4 Benefits
- Break a complex system into smaller, manageable modules.
- Work on modules individually.
7. The Unified Process (UP)
Definition
A methodology that defines when and how to use UML techniques in OOAD. Two dimensions:
- Phases — stages of development (Inception, Elaboration, Construction, Transition).
- Workflows — activities performed in each phase (requirements, design, coding, testing…).
Phases and workflows overlap: every workflow can be active in every phase, with varying intensity.
7.1 Phases
| UP phase | ≈ SDLC | Focus |
|---|---|---|
| Inception | Planning | Feasibility analyses; business modeling & requirements |
| Elaboration | Analysis + Design | Heavy analysis & design |
| Construction | Implementation | Programming |
| Transition | (Installation) | Testing & deployment |
Feasibility analyses in Inception
- Technical — do we have the capability to build it?
- Economic — will it provide business value?
- Organizational — will the organization use it?
7.2 Workflows
| Engineering workflows | Supporting workflows |
|---|---|
| Business modeling, Requirements, Analysis, Design, Implementation, Testing, Deployment | Project management, Configuration & change management, Environment |
flowchart LR I[Inception] --> E[Elaboration] --> C[Construction] --> T[Transition] subgraph Peak workflows I -.- BM[Business modeling<br/>Requirements] E -.- AD[Analysis<br/>Design] C -.- IM[Implementation] T -.- TD[Testing<br/>Deployment] end
8. Unified Modeling Language (UML)
Definition
A standard language to visualize, design and document systems — the blueprint of a software system. It gives developers a common vocabulary of OO terms and diagramming techniques, and is used from analysis → design → implementation.
Why UML? Communicate clearly in teams, model complex systems visually, avoid confusion before coding, bridge business and technical understanding.
UML 2.5 has 15 diagrams in 2 groups:
8.1 Structure Diagrams
Show how the system is built — data and static relationships.
| Diagram | Used to… | Primary phase |
|---|---|---|
| Class | Relationships between classes | Analysis, Design |
| Object | Relationships between actual objects (instances) | Analysis, Design |
| Package | Group UML elements into higher-level constructs | Analysis, Design, Implementation |
| Deployment | Physical architecture; software components on hardware | Physical Design, Implementation |
| Component | Physical relationships among software components | Physical Design, Implementation |
| Composite Structure | Internal structure of a class | Analysis, Design |
| Profile | Develop extensions to UML itself | None |
8.2 Behavior Diagrams
Show how the system behaves — dynamic relationships among objects.
| Diagram | Used to… | Primary phase |
|---|---|---|
| Activity | Business workflows, flow of a use case, or detailed method design | Analysis, Design |
| Sequence | Object behavior in a use case — time ordering | Analysis, Design |
| Communication | Object behavior in a use case — communication among objects | Analysis, Design |
| Interaction Overview | Overview of flow of control of a process | Analysis, Design |
| Timing | Interaction among objects and their state changes along a time axis | Analysis, Design |
| Behavioral State Machine | Behavior of one class | Analysis, Design |
| Protocol State Machine | Dependencies among the interfaces of a class | Analysis, Design |
| Use-Case | Business requirements; interaction between system and environment | Analysis |
⚠ The use-case diagram is a behavior diagram, not a structure diagram. Class/object diagrams are structural.