MOD 3: Overview of the System Architecture

System Architecture

: The structural design, behavior, and conceptual views of a computing system, showing how hardware components, software modules, and networks interact to satisfy technical and business requirements.

Von Neumann Architecture

: The classic design framework for electronic digital computers consisting of a central processing unit (CPU) containing a control unit and arithmetic/logic unit (ALU), a memory unit, mass storage, and input/output mechanisms. Its defining trait is that data and programs share the same memory space.

Bus (System Bus)

: The physical, shared communication pathway that transfers data, address pointers, and control signals between the CPU, memory, and peripheral devices.

Cache Memory

: High-speed, volatile static RAM (SRAM) positioned directly inside or next to the CPU. It stores copies of frequently accessed main memory data to reduce the latency of the memory access bottleneck.

Cache Coherence

: A critical synchronization problem and solution in multi-core processors, ensuring that all individual CPU cores reading from shared memory spaces see the exact same data value at any given moment.

OSI 7-Layer Model

: A conceptual framework developed by the ISO that standardizes network communication into seven distinct structural layers:

• Physical

• Data Link

• Network

• Transport

• Session

• Presentation

• Application

OSI 7-Layer Models:Physical

Physical

: Raw bit transmission over hardware.

Data Link

: Node-to-node data transfer and framing (e.g., Ethernet, MAC addresses).

Network

: Routing data packets across paths and networks (e.g., IP, ICMP).

Transport

: End-to-end reliable data packet transfer and flow control (e.g., TCP, UDP).

Session

: Managing, maintaining, and terminating connection sessions between apps.

Presentation

: Data translation, encryption, and compression formatting.

Application

: Direct interaction with network services and software (e.g., HTTP, FTP, DNS).

TCP/IP Protocol Stack

: The practical, four-layer foundational networking model used on the internet, consisting of the Network Interface, Internet (IP), Transport (TCP/UDP), and Application layers.

TCP (Transmission Control Protocol)

: A connection-oriented, reliable transport mechanism utilizing a 3-way handshake to guarantee in-order delivery.

UDP (User Datagram Protocol)

: A connectionless, lightweight, "best-effort" transport mechanism prioritizing speed over data validation.

IP Address (IPv4 vs. IPv6)

: Numerical labels assigned to connected devices. IPv4 uses a limited 32-bit format (e.g., 192.168.1.1), while IPv6 leverages a massive 128-bit hexadecimal format to avoid address exhaustion.

Subnet Mask

: A bitmask used to split an IP address logically into a network identifier portion and a host identifier portion to manage local routing efficiency.

DNS (Domain Name System)

: The internet's phonebook system that maps human-readable domain names (like example.com) into computer-routable IP addresses.

Middleware

: Software that sits logically between an operating system and the applications running on it, functioning as a hidden translation layer to enable communication and data management in distributed applications.

RPC (Remote Procedure Call)

: A protocol that allows a computer program to trigger a subroutine or procedure to execute on another computer across a network without the developer writing explicit network routing code.

SOA (Service-Oriented Architecture)

: An architectural style where software applications are designed as a collection of modular, discrete, discoverable services that communicate with each other over a network via standard protocols.

MSA (Microservices Architecture)

: A modern variant of SOA where a monolithic application is broken down into a collection of completely independent, tiny, single-purpose services that run their own unique processes and talk to each other via lightweight APIs (like HTTP REST).

Cloud Computing Models (SPI)

: The three fundamental service abstractions of cloud infrastructure:

• IaaS

• PaaS

• SaaS

IaaS (Infrastructure as a Service)

: Provides raw compute, storage, and networking hardware virtually (e.g., AWS EC2).

PaaS (Platform as a Service)

: Provides a pre-configured execution runtime environment and tools, letting developers focus solely on code without managing underlying OS systems (e.g., Heroku).

SaaS (Software as a Service)

: Delivers complete, end-user software applications accessible straight over a web browser (e.g., Google Workspace).

Virtualization

: The core technology enabling cloud computing, using a piece of software called a Hypervisor to partition single physical hardware units into multiple distinct, isolated Virtual Machines (VMs).

Kernel

: The core, central component of an operating system that has complete control over everything in the system. It acts as the bridge between applications and the actual data processing performed at the hardware level.

System Call

: The programmatic interface through which a running application requests a service or privileged resource directly from the operating system's kernel (e.g., file creation, hardware access).

Context Switching

: The process of storing the state (context) of a running CPU process or thread so that it can be paused and another process can be resumed later. This is what allows for multitasking, but it introduces minor computational overhead.

Interrupt

: A signal sent to the processor by hardware or software indicating an event that requires immediate attention. The CPU pauses its current activities to execute an Interrupt Service Routine (ISR).

Thrashing

: A destructive state in virtual memory systems where the processor spends more time swapping pages in and out of disk storage than it does executing actual application instructions.

Garbage Collection

: An automatic memory management feature built into modern language runtimes (like Java or .NET) that looks for blocks of memory that are no longer referenced by the application and safely reclaims them.

Grid Computing

: A distributed computing architecture that coordinates and links geographically dispersed computer resources (often across different organizations) to solve a single, massive scientific or mathematical problem.

Edge Computing

: A distributed computing paradigm that brings data storage and processing closer to the location where it is needed (the "edge" of the network, near sensors or users) to improve response times and save network bandwidth.

IoT Architecture (Internet of Things)

: A multi-tiered structural network of physical objects ("things") embedded with sensors, software, and electronics that collect and exchange data. It is typically tested via its three layers: Perception (sensors), Network (data transmission), and Application (data usage).

Embedded System

: A dedicated, single-purpose computer system designed to perform a specific, fixed function within a larger mechanical or electrical system (e.g., automotive anti-lock brakes, smart thermostats). They are highly constrained by power, memory, and processing limits.

RTOS (Real-Time Operating System)

: A specialized operating system intended for serving real-time applications that process data as it comes in, typically without buffer delays. The defining trait is determinism (guaranteeing that a critical task completes within a strict, predictable time window).