Tasks: 0's and 1's that transform data

Foundations of Practical System Design

System Design Course for Junior Engineers

Kay Ashaolu

Lesson Overview

• Goal is to understand how tasks (instructions) manipulate and transform raw data into meaningful outputs.
• We'll explore how binary instructions (0's and 1's) guide computers to perform computations, turning static data into something useful.

What is a Task?

• A task is a defined unit of work that the computer performs.
• It takes certain inputs and produces outputs by following a set of instructions.
• In essence, a task encapsulates a small piece of logic or computation.

Tasks as 0's and 1's

• At the lowest level, tasks to the CPU are represented as binary digits (0's and 1's).
• Just like storage, the instructions themselves are stored in memory as sequences of bits.
• These bits tell the CPU what operation to perform next.

Distinguishing Storage from Tasks

• Both storage and tasks are stored as binary, but how we interpret them differs.
• Storage: Represents information (e.g., numbers, text, images).
• Tasks: Represents actions to be performed on data (e.g., add two numbers, move values in memory).

The Essence of Programming

• Programming is about writing instructions that the CPU will execute.
• High-level languages (like Python, Java, C++) provide human-readable syntax.
• These programs are eventually translated into binary machine instructions the CPU can understand.

Functions as Tasks

• In many programming languages, a function represents a well-defined task.
• A function takes input parameters, processes them, and returns a result.
• Internally, the function’s logic is compiled or interpreted into instructions (0's and 1's).

Inputs, Outputs, and Processing

• A task (or function) often looks like:
  function(input) -> output
• Input data flows into the task, the task’s instructions transform it, and the output emerges.
• This transformation is the core of what makes raw data meaningful.

How Tasks Execute

• Tasks are "called" or "invoked" by other parts of the program.
• When you call a function, the CPU fetches the function’s instructions from memory.
• It then executes these instructions step by step, manipulating data accordingly.

The CPU’s Role

• The CPU is the hardware that understands and runs these binary instructions.
• It carries out fundamental operations: arithmetic, logic, data movement, control flow.
• Each executed instruction brings the system closer to completing the intended task.

Data Transformation in Action

• Consider a simple task: add two numbers.
• Input: two integers (data)
• Instructions: perform addition
• Output: a single integer (new data)
• Behind the scenes: binary instructions guide the CPU through each step.

Relationship with Data Structures

• Tasks do not work in isolation; they interact with Storage, which are 0's and 1's organized in one or more data structures.
• Tasks process Storage for a particular purpose.
• Combined, they form building blocks of systems: storage (what we have) + tasks (what we do with it).

Composition of Complex Tasks

• Complex functionality is built by combining smaller tasks.
• Example: Processing a file, filtering data, sorting it, and summarizing results involve multiple tasks.
• Each task is another set of binary instructions, orchestrated to achieve the larger goal.

Real-World Analogy

• Think of a recipe (tasks) and ingredients (storage).
• The recipe (task) tells you how to combine and transform the ingredients.
• The end result (output) is a prepared dish (meaningful data).

Clarity and Structure

• Well-defined tasks improve maintainability and scalability.
• Clear task boundaries, or modularity help you understand and reason about code.
• This leads to designing building blocks that are easier to extend, debug, and optimize.

Next Steps

• Tasks are instructions represented by 0’s and 1’s, telling computers what actions to perform on data.
• Understanding tasks helps you see how raw data is transformed into meaningful output.
• Next, we will explore how multiple tasks and data structures fit together in building blocks that are used in larger system designs.