Computer Science | System fundamentals

Welcome to System Fundamentals! (Topic 1)

Hello future computer scientists! This chapter, System Fundamentals, is where we lay the foundation for everything else in the course. Don’t worry if the name sounds a bit abstract. We’re simply going to explore what a "system" is, what pieces it’s made of, how those pieces talk to each other, and why understanding this is essential before we dive into hardware, networking, or programming.

Think of this chapter as taking apart a complex machine—like your phone or a self-driving car—and identifying all the roles and relationships involved. Let's get started!

---

1. Defining a System and its Core Components

In Computer Science, the word system is used all the time. But what does it really mean?

What is a System?

A system is a collection of interacting or interdependent components working together to achieve a common goal.

Analogy: Think of a soccer team. Each player (component) has a specific role (defender, striker, goalie), but they all interact and depend on each other to achieve the common goal: winning the match. If one component fails (e.g., the goalie is sick), the entire system is affected.

The Three Pillars: Hardware, Software, and Data

Any IT system, no matter how simple or complex, relies on three fundamental components:

• Hardware: The physical components you can touch (e.g., CPU, screen, keyboard, mouse, network cables).
• Software: The non-physical sets of instructions and programs that tell the hardware what to do (e.g., the Operating System, Google Chrome, Photoshop).
• Data: The raw facts and figures that the system processes (e.g., a student ID number, a photo file, a temperature reading).

Key Takeaway: These three pillars are inseparable. Hardware is useless without software instructions, and software has nothing to work with without data.

---

2. System Boundaries and Subsystems

When dealing with complex systems, we need a way to break them down into smaller, manageable chunks. This is where boundaries and subsystems come in.

Subsystems: Breaking Down Complexity

A subsystem is a system that is part of a larger system. Large IT projects are usually broken down into smaller, defined subsystems to make development easier.

Example: A university registration system might have subsystems like:

• The Student Records subsystem (handles personal data).
• The Course Enrollment subsystem (handles scheduling and availability).
• The Billing and Finance subsystem (handles tuition payments).

Boundaries

The system boundary defines the limit of the system—it specifies which components are inside the system and which are outside (part of the environment).

Understanding the boundary is vital because the system only has control over the elements within its boundary. Everything outside (like the user, external servers, or the electricity supply) is considered part of the environment and acts as an input or output source.

Interaction and Feedback

Systems generally follow a cycle:

1. Input: Data is taken from the environment (e.g., you type your password).
2. Processing: The data is manipulated according to instructions (e.g., the OS checks if the password is correct).
3. Output: The processed information is sent back to the environment (e.g., the screen shows "Login Successful").
4. Storage: Data is saved for later use.

Often, systems include feedback, where the output or stored data is used to modify future inputs or processes. Example: A thermostat measures room temperature (output) and adjusts the boiler (input) if the temperature is too low.

---

3. Software Fundamentals: System vs. Application

Software is often categorized based on its purpose. There are two major types you must know: System Software and Application Software.

a) System Software

System software is designed to operate the computer hardware and provide a platform for application software to run. It manages resources and ensures the computer runs efficiently.

The most important piece of system software is the Operating System (OS) (e.g., Windows, macOS, Linux, iOS).

Key Functions of an Operating System:

• User Interface Management: Provides the GUI (Graphical User Interface) or command line, allowing you to interact with the machine.
• Memory Management: Decides where programs and data are stored in RAM, and ensures programs don't interfere with each other.
• Peripheral Management: Handles communication between the CPU and input/output devices (like printers or cameras) using special software called device drivers.
• Security and Access Control: Handles logins, passwords, and user permissions.

Utility Software is also part of system software. This includes programs that perform maintenance tasks, like defragmentation tools, file compression utilities (e.g., WinZip), and antivirus software.

b) Application Software

Application software (or "apps") is designed to perform specific tasks for the user. These cannot run without the underlying system software (the OS).

Examples: Word processors, spreadsheets, web browsers, video games, email clients, and music players.

Don't worry if this seems tricky at first: Just remember that System Software runs the *computer*, while Application Software runs the *user tasks*. You need an OS (System) to run Microsoft Word (Application).

---

4. Data Representation and Measurement Units

All information handled by a computer must be represented using binary (a base-2 number system).

The Basics: Bits and Bytes

• Bit (b): The smallest unit of data, representing a single binary digit (0 or 1). Think of it as a single electrical switch being OFF (0) or ON (1).
• Byte (B): A collection of 8 bits. This is the fundamental unit used to store a single character (like the letter 'A' or the number '5').

Measuring Data Size

Because data sets are enormous, we use standardized prefixes (based on powers of 2, specifically 1024) to measure capacity:

Unit	Abbreviation	Size (approx.)
Kilobyte	KB	\(2^{10}\) bytes (1,024 bytes)
Megabyte	MB	\(2^{20}\) bytes (about 1 million bytes)
Gigabyte	GB	\(2^{30}\) bytes (about 1 billion bytes)
Terabyte	TB	\(2^{40}\) bytes (about 1 trillion bytes)
Petabyte	PB	\(2^{50}\) bytes (really, really big!)

Memory Aid: If you ever forget the order of the units, remember the phrase: Kids Make Great Tacos (Kilo, Mega, Giga, Tera).

Did you know? Due to slight confusion between the computer science standard (base 2, using 1024) and the scientific standard (base 10, using 1000), organizations sometimes use units like Kibibyte (KiB), Mebibyte (MiB), etc., to specifically indicate the base-2 system, although KB, MB, and GB are still commonly accepted abbreviations in IT.

---

5. System Reliability, Integrity, and Usability

A key aspect of system fundamentals is evaluating how well a system performs its job. We often measure this using three criteria: reliability, integrity, and usability.

a) Reliability

Reliability is the measure of how consistently a system performs its intended function without failure. A reliable system is dependable.

Sources of unreliability:

• Hardware failures: A hard drive crashes or a component overheats.
• Software bugs: Errors in the code that cause the program to crash or produce incorrect results.
• Human error: An administrator accidentally deletes a crucial file or inputs incorrect data.

To improve reliability, designers use techniques like:

• Redundancy: Having multiple backup components (like two hard drives mirrored) ready to take over if one fails.
• Error Checking: Implementing checks in the software to catch incorrect data input.

b) Data Integrity

Data Integrity refers to the validity, accuracy, and consistency of data throughout its life cycle. If data is stored, processed, and retrieved without alteration, it has high integrity.

Poor integrity happens if data is corrupted (e.g., during transmission) or if inaccurate data is entered into the system.

c) Usability

Usability refers to how easy and efficient a system is for the user to operate. If a system is difficult to learn, frustrating to use, or poorly designed, users will make mistakes, reducing overall system performance and increasing the chance of errors.

Good usability often involves:

• Clear, intuitive User Interfaces (UIs).
• Consistency in design and navigation.
• Providing accessibility features (e.g., large text, voice commands) for users with different needs.

---

6. The Social and Ethical Context (Stakeholders)

System Fundamentals isn't just about technical components; it’s about people too! IB Computer Science emphasizes the context in which systems operate.

Identifying Stakeholders

A stakeholder is any individual or group that has an interest in, or is affected by, the development or operation of a system.

It is crucial to identify all stakeholders because their needs and perspectives often conflict.

Example: Developing a new school timetable system.

• Users: Teachers, Students (want simplicity, access to their own data).
• Owners: School Board (want cost-effectiveness, high security).
• Developers: Programmers (want clear specifications, efficient code).
• Regulators: Government (want compliance with privacy laws, like GDPR).

Failure to meet the needs of all key stakeholders is a common reason why IT projects fail!

Social and Ethical Implications

System design often involves moral choices. Always consider:

• Privacy: How is user data collected, stored, and protected? (A major ethical and legal concern).
• Copyright: Does the software or data infringe on intellectual property rights?
• Digital Divide: Does the system exclude certain populations (e.g., people without internet access or older devices)?