You switch on your phone.
The screen comes
alive.You open an app.
You take a photograph.
You connect to Wi-Fi.
You receive a notification.
You save a document.
You install an application.
You plug in a USB device.
You put your computer to sleep.
All of this feels simple because you interact with a graphical interface rather than directly controlling the processor, memory, storage, display hardware, network hardware, and other components yourself.
Something is coordinating those resources underneath.
That something is the operating system.
Windows, Android, Linux, macOS, ChromeOS, iOS, and other operating-system families provide different environments, but they solve a common class of problems:
How do you turn computing hardware into a usable, manageable, secure environment in which people and applications can actually do useful work?
Understanding that question takes you deeper into computing.
It also explains many things you encounter every day:
- why an application needs permission;
- why an update matters;
- why two devices with similar hardware can behave differently;
- why an app can run without directly controlling every piece of hardware;
- why restarting a device can solve certain problems;
- why background processes consume battery or memory;
- why storage and memory are different;
- why drivers matter;
- why security features operate at the operating-system level;
- and why the operating system is one of the most important pieces of software on your device.
WHAT IS AN OPERATING SYSTEM?
An operating system, commonly called an OS, is system software that manages computing resources and provides services that applications and users depend on.
Microsoft describes an operating system as software that manages apps, hardware, files, and security.
A useful mental model is:
YOU
↓
APPLICATIONS
↓
OPERATING SYSTEM
↓
HARDWARE
You normally do not tell the processor:
“Move these exact bytes from this memory address to that hardware register.”
Instead, you tell an application what you want to accomplish.
The application requests services from the operating system.
The operating system coordinates access to the underlying hardware.
The hardware performs the physical computation.
So:
USER
↓
APP
↓
OS
↓
HARDWARE
↓
RESULT
This is simplified, but it gives you the right starting point.
YOUR PHONE IS NOT JUST “ANDROID”
When you say:
“I have an Android phone.”
you are describing a device and its software ecosystem, but Android itself is a layered system.
The Android Open Source Project documents an architecture that includes:
- apps;
- Android framework APIs;
- system services;
- Android Runtime;
- hardware abstraction layers;
- native libraries and daemons;
- the Linux kernel;
- physical hardware.
A simplified model looks like this:
ANDROID APPS
↓
ANDROID FRAMEWORK / APIs
↓
SYSTEM SERVICES
↓
ANDROID RUNTIME + NATIVE COMPONENTS
↓
HARDWARE ABSTRACTION
↓
LINUX KERNEL
↓
DEVICE HARDWARE
That is why saying “Android is just an app environment” misses what is happening underneath.
Android is an operating-system platform and software stack.
THE KERNEL: THE CORE OF THE OPERATING SYSTEM
One term you will encounter repeatedly is:
kernel
The kernel is the central component that interacts closely with the hardware and provides fundamental operating-system functions.
The Android documentation describes the kernel as the central part of the operating system that communicates with the underlying hardware.
Linux is an example of a kernel.
The Linux kernel itself provides core facilities such as:
- process management;
- memory management;
- hardware interaction;
- networking;
- multitasking;
- and other low-level system functions.
The Linux Kernel project describes Linux as a Unix-like operating-system kernel supporting multitasking, virtual memory, memory management, networking, and many processor architectures.
This distinction is important:
Linux is the kernel; a Linux distribution is a complete operating system built around the kernel and additional software.
That is why Ubuntu, Fedora, Debian, Arch Linux, and other distributions can provide different complete environments while using the Linux kernel.
WHAT DOES THE OPERATING SYSTEM ACTUALLY DO?
An operating system performs many jobs simultaneously.
At a high level, think about these responsibilities:
PROCESS MANAGEMENT
MEMORY MANAGEMENT
FILE & STORAGE MANAGEMENT
DEVICE MANAGEMENT
NETWORKING
SECURITY
USER INTERFACE
APPLICATION SERVICES
POWER MANAGEMENT
SYSTEM MONITORING
Let's examine them.
1. PROCESS MANAGEMENT
When you open an application, the computer needs to execute its instructions.
But you may have many applications running at the same time.
You might have:
- a browser;
- a music player;
- messaging;
- an email application;
- a document editor;
- background synchronization;
- security services;
- system services.
The processor cannot simply give every program unlimited control.
The operating system manages the execution of processes and determines how computing resources are shared.
A simplified model is:
APP A ──┐
APP B ──┤
APP C ──┼──> OPERATING SYSTEM ──> CPU
APP D ──┤
SYSTEM ─┘
The operating system helps coordinate these competing workloads.
This is one reason multitasking is possible.
2. MEMORY MANAGEMENT
Applications need memory to work.
But memory is limited.
The operating system therefore manages how memory is allocated and used.
Imagine opening:
- a browser;
- a video editor;
- a spreadsheet;
- a game;
- and several other applications.
Each application needs working memory.
The operating system manages the memory environment so that applications can operate without simply overwriting one another's working areas.
This also contributes to security.
An application should not ordinarily be able to freely inspect or modify another application's private memory.
That separation is an important part of modern operating-system design.
3. FILE AND STORAGE MANAGEMENT
Your storage device contains enormous amounts of information compared with what you are actively using at any one moment.
The operating system provides mechanisms for organizing that information.
You see:
Documents
Pictures
Videos
Downloads
Music
Applications
Projects
Underneath, the storage system contains data structures and metadata that allow the operating system to locate and manage files.
The operating system can handle operations such as:
- creating files;
- reading files;
- writing files;
- deleting files;
- renaming files;
- organizing directories;
- managing permissions;
- tracking storage usage.
When you tap Save, an enormous amount of complexity is hidden behind that single action.
4. DEVICE MANAGEMENT
Your computer may contain or connect to:
- keyboard;
- mouse;
- display;
- camera;
- microphone;
- speakers;
- printer;
- storage devices;
- USB devices;
- Wi-Fi hardware;
- Bluetooth hardware;
- sensors;
- graphics processors;
- touchscreens.
Applications generally do not need to know every electrical detail of each device.
The operating system and associated software provide standardized ways for applications to interact with hardware.
This is one reason drivers and hardware abstraction matter.
The application can request:
“Capture an image.”
instead of needing to understand every hardware-specific instruction required by the camera sensor.
Android's architecture explicitly uses a Hardware Abstraction Layer (HAL) to provide standardized interfaces between higher-level software and hardware-specific implementations.
5. NETWORKING
Your operating system also participates in communication.
When an application accesses the Internet, the operating system helps provide the networking capabilities that allow data to move between the application and the network hardware.
The broader process may involve:
APPLICATION
↓
NETWORK API
↓
OPERATING SYSTEM
↓
NETWORK STACK
↓
NETWORK HARDWARE
↓
NETWORK
↓
INTERNET
This is where Category 2 connects directly to Category 3.
Computing provides the machine and software environment.
Networking explains how machines communicate.
The categories are separate because the knowledge is different, but they work together constantly.
6. SECURITY
The operating system is also part of your security boundary.
It can help control:
- application permissions;
- access to files;
- user accounts;
- processes;
- device resources;
- system updates;
- authentication;
- isolation;
- encryption-related functions;
- and security policies.
Android, for example, uses application sandboxing, app permissions, app signing, secure inter-process communication, and Linux-kernel security mechanisms as part of its platform security architecture.
This explains why an application may ask:
“Allow this app to access your camera?”
The application is not supposed to have unrestricted access to everything on your device.
The operating system can act as a gatekeeper.
7. POWER MANAGEMENT
Power management becomes especially important on smartphones and laptops.
The operating system can coordinate things such as:
- sleep;
- wake;
- processor power states;
- background activity;
- display behavior;
- battery usage;
- device activity.
Windows, for example, uses operating-system power-management facilities to place systems into lower-power states and resume them when needed.
This is why battery life is not determined only by the battery itself.
Software behavior matters too.
A poorly behaved application that repeatedly performs background work can consume resources even when you are not actively using it.
8. THE USER INTERFACE
The operating system provides much of the environment through which you interact with the computer.
That may include:
- desktop;
- taskbar;
- settings;
- notifications;
- file manager;
- application launcher;
- windows;
- menus;
- touch interaction;
- accessibility tools;
- system dialogs.
But the user interface is not the entire operating system.
This is an important distinction.
The graphical interface is what you see.
The operating system is doing much more underneath.
9. SYSTEM SERVICES
Modern operating systems contain background components that provide functionality to applications and other system components.
On Android, for example, system services provide functionality exposed through the Android framework and interact with lower-level components and hardware.
You may never see many of these services directly.
Yet they may be involved when you:
- request your location;
- connect to a network;
- play audio;
- access a camera;
- receive a notification;
- synchronize data;
- authenticate;
- use Bluetooth;
- or interact with a sensor.
A modern operating system is therefore better understood as a collection of coordinated system capabilities than as simply a graphical screen.
WHY APPS DON'T DIRECTLY CONTROL EVERYTHING
Imagine installing a calculator app.
Should that app be allowed to:
- rewrite the operating system?
- inspect every file?
- access your microphone without permission?
- control every other application?
- modify hardware settings freely?
- read another app's private data?
Clearly, that would create enormous security and reliability problems.
The operating system provides boundaries.
A simplified model is:
USER
↓
APPLICATION
↓
OS SERVICES / APIs
↓
SECURITY CHECK
↓
KERNEL
↓
HARDWARE
The exact architecture varies between operating systems, but the principle is powerful:
Applications request capabilities; the operating system controls how those capabilities are provided.
WHY APPS NEED APIS
Applications need ways to communicate with the operating system.
That is where APIs, or Application Programming Interfaces, become important.
An API provides a defined way for software to request functionality.
For example, an application might need to:
- open a file;
- display something;
- access a camera;
- obtain location information;
- communicate over a network;
- create a notification;
- access a database;
- use a cryptographic service.
Instead of implementing everything from scratch, the application can use APIs provided by the operating system or other software layers.
This creates another useful model:
APP
↓
API
↓
OS SERVICE
↓
KERNEL
↓
HARDWARE
The API becomes a bridge between software components.
This concept becomes even more important when you start programming.
OPERATING SYSTEMS CREATE ABSTRACTIONS
One of the most important ideas in computer science is abstraction.
The operating system hides unnecessary complexity behind simpler interfaces.
For example, you might see:
“Save file.”
You don't need to know:
- which physical storage cells are used;
- how the storage controller communicates;
- how blocks are allocated;
- how the filesystem records metadata;
- how the hardware handles electrical signals.
The operating system provides a higher-level abstraction.
Likewise, an application can request network communication without needing to manually control every electrical signal travelling through a network interface.
This is how complex systems remain usable.
THE OPERATING SYSTEM IS A TRANSLATION LAYER
You can think of the operating system as a bridge between different worlds.
HUMAN INTENTION
↓
APPLICATION
↓
OPERATING SYSTEM
↓
HARDWARE
↓
PHYSICAL COMPUTATION
The user thinks in terms of:
“Open my photo.”
The application thinks in terms of:
“Request this image resource.”
The operating system coordinates:
“Read the required data from storage.”
The hardware performs:
“Retrieve the physical data.”
You see:
Your photo appears.
The operating system helps make that entire chain possible.
WINDOWS, LINUX, AND ANDROID ARE NOT THE SAME THING
It is tempting to think that every operating system is simply a different version of the same product.
They share fundamental responsibilities, but their architectures, ecosystems, interfaces, licensing models, hardware targets, and implementation details can differ significantly.
WINDOWS
Windows is Microsoft's operating-system family for personal computers and other computing environments.
Microsoft's current Windows documentation describes operating-system responsibilities around hardware, applications, files, security, and system behavior.
It is widely used for:
- desktop computing;
- business;
- education;
- gaming;
- professional software;
- development;
- enterprise environments.
LINUX
Linux is a kernel used in a huge range of computing environments.
The complete system you install is typically a Linux distribution that combines the kernel with additional software.
Linux distributions can target:
- desktops;
- servers;
- cloud infrastructure;
- embedded systems;
- networking;
- development;
- scientific computing;
- specialized appliances.
The Linux kernel supports multitasking, virtual memory, memory management, networking, and multiple processor architectures.
ANDROID
Android is designed around mobile and other device environments.
The Android Open Source Project supports a wide range of hardware and device categories, and its architecture includes applications, framework components, runtime, hardware abstraction, native components, and the Linux kernel.
Android therefore demonstrates an important idea:
An operating system is not necessarily tied to a traditional desktop computer.
THE OPERATING SYSTEM IS PART OF THE PRODUCT
When you buy a smartphone, laptop, tablet, server, or other computing device, you are not buying hardware alone.
You are interacting with an entire stack.
For example:
PHYSICAL HARDWARE
↓
FIRMWARE
↓
KERNEL
↓
OPERATING SYSTEM
↓
SYSTEM SERVICES
↓
APPLICATIONS
↓
USER
The boundaries differ between platforms, but the layered idea is useful.
This is why two devices with similar processors, memory, and storage can provide noticeably different experiences.
The software stack matters.
UPDATES ARE NOT JUST ABOUT NEW FEATURES
When your operating system asks you to install an update, it may contain:
- bug fixes;
- security fixes;
- performance improvements;
- compatibility changes;
- driver changes;
- new functionality;
- system-component updates;
- changes required by newer applications.
This is why operating-system maintenance matters.
A device that is physically capable of running software may still become problematic if its operating system or important components are no longer maintained.
Android's current documentation, for example, describes continuing kernel branches, compatibility requirements, testing, and security maintenance across supported Android releases.
The lesson is broader:
Computing capability is not only about what hardware you own. It is also about whether the software stack supporting that hardware remains usable and maintained.
WHY OLD DEVICES SOMETIMES STILL WORK WELL
A device does not automatically become useless because a newer model exists.
If:
- the hardware still meets your needs;
- the operating system remains usable;
- applications remain compatible;
- security support is adequate for your use case;
- storage and battery are manageable;
- and performance is sufficient,
then the device may still be useful.
This is particularly important when you have limited resources.
Instead of asking:
“Is this the newest device?”
ask:
“Can this device reliably perform the work I need?”
That is a much better computing question.
OPERATING SYSTEMS AND LIMITED HARDWARE
Not every computing environment has abundant resources.
Some devices have:
- small amounts of RAM;
- limited storage;
- modest processors;
- low-power hardware;
- limited battery capacity.
Operating systems therefore make design trade-offs.
Android's documentation even describes mechanisms such as modular kernel components that can reduce kernel image size and runtime memory consumption, with particular relevance to resource-constrained devices such as Android Go devices.
This matters if you develop software.
A program that works beautifully on a high-end computer may perform poorly on a low-end phone.
Good software engineering therefore includes understanding the environment in which the software will run.
OPERATING SYSTEMS AND VIRTUALIZATION
Modern operating systems also participate in virtualization.
Virtualization allows computing resources to be separated into environments that can operate with varying degrees of isolation.
A simplified model is:
PHYSICAL SERVER
↓
HYPERVISOR
↓
VIRTUAL MACHINE
↓
GUEST OPERATING SYSTEM
↓
APPLICATION
This concept becomes important in:
- cloud computing;
- servers;
- development;
- testing;
- cybersecurity;
- enterprise computing;
- containerized environments.
You do not need to master virtualization yet.
The important point is that the operating-system concept extends beyond the physical laptop or smartphone sitting in front of you.
THE OPERATING SYSTEM CONNECTS COMPUTING TO THE CLOUD
When you use a cloud application, you may be interacting with multiple operating-system environments.
Your device has an operating system.
The remote server has an operating system or another managed runtime environment.
Between them are networks, protocols, security systems, application services, databases, and infrastructure.
For example:
YOUR PHONE
↓
ANDROID
↓
NETWORK
↓
INTERNET
↓
CLOUD INFRASTRUCTURE
↓
SERVER / COMPUTE
↓
APPLICATION
↓
DATABASE / STORAGE
This is why Category 2 connects naturally to:
- Category 3 — Networks;
- Category 5 — Web;
- Category 6 — Software;
- Category 7 — Cloud;
- Category 8 — AI;
- Category 10 — Cybersecurity;
- Category 12 — Programming.
The categories are separate knowledge domains, but real systems combine them.
THE OPERATING SYSTEM IS ALSO A SECURITY BOUNDARY
Consider what would happen if every application had unrestricted access to your computer.
One malicious application could potentially:
- read private files;
- interfere with other applications;
- capture sensitive information;
- modify system components;
- abuse hardware;
- consume resources;
- or persist in ways the user cannot easily control.
Modern operating systems therefore use concepts such as:
- privilege;
- permissions;
- user accounts;
- process isolation;
- application sandboxing;
- secure boot mechanisms;
- code signing;
- access controls;
- security updates.
Android's security architecture explicitly uses application sandboxing and permissions to isolate applications and limit their access to system resources.
This is why operating-system knowledge belongs near the foundation of cybersecurity knowledge.
WHAT HAPPENS WHEN YOU OPEN AN APP?
Let's put everything together.
Suppose you tap a photo-editing application.
A simplified sequence is:
1. YOU TAP THE APP
↓
2. OS RECEIVES INPUT
↓
3. OS LOCATES / LAUNCHES APP
↓
4. PROCESS IS CREATED
↓
5. APP CODE IS LOADED
↓
6. MEMORY IS ALLOCATED
↓
7. OS PROVIDES REQUIRED SERVICES
↓
8. APP ACCESSES HARDWARE THROUGH SYSTEM INTERFACES
↓
9. CPU EXECUTES INSTRUCTIONS
↓
10. GPU / DISPLAY SYSTEM RENDERS OUTPUT
↓
11. YOU INTERACT WITH THE RESULT
You experience:
Tap → App opens.
The operating system experiences:
Input → process → memory → permissions → services → hardware → output.
That difference is exactly why understanding operating systems is useful.
WHAT HAPPENS WHEN AN APP CRASHES?
A crash can have many causes.
For example:
- application bugs;
- incompatible software;
- insufficient resources;
- corrupted files;
- operating-system bugs;
- driver problems;
- hardware problems;
- permissions;
- dependency failures;
- unexpected input.
The operating system may detect that a process has stopped functioning correctly.
It may terminate the process, report an error, preserve diagnostic information, or allow the user to restart the application.
This is another reason the operating system matters:
It provides an environment in which applications can fail without necessarily bringing down the entire machine.
Modern systems are designed with varying degrees of isolation and recovery.
WHY RESTARTING SOMETIMES HELPS
“Turn it off and on again” sounds simplistic.
But there is a technical reason it can work.
Restarting a system can clear or reset:
- processes;
- temporary memory state;
- certain resource locks;
- background services;
- temporary system conditions;
- hardware initialization state.
It does not magically repair every problem.
But it can return the operating system to a cleaner starting state.
That is why restarting is a legitimate troubleshooting step rather than mere superstition.
OPERATING SYSTEM VS APPLICATION
These are often confused.
Operating system
Provides the underlying environment and system services.
Examples include:
- Windows;
- Android;
- Linux-based systems;
- macOS;
- iOS;
- ChromeOS.
Application
Performs a particular user-facing task.
Examples include:
- browser;
- word processor;
- image editor;
- calculator;
- messaging application;
- video editor;
- accounting software.
Think:
OPERATING SYSTEM
↓
provides the environment
↓
APPLICATION
↓
provides a specific function
↓
USER
A browser is not the operating system.
A word processor is not the operating system.
A social-media app is not the operating system.
They run within an operating-system environment.
WHY THIS MATTERS WHEN YOU CHOOSE SOFTWARE
Suppose you find an application that looks perfect.
Before installing it, you may need to know:
- Which operating systems does it support?
- Which OS versions?
- What hardware does it require?
- Does it require Internet access?
- Does it need special permissions?
- Does it support your processor architecture?
- Is it still maintained?
- What data does it access?
- Does it depend on services that may disappear?
- Can you export your data?
These questions are much more useful than simply asking:
“Does the app look good?”
Software exists inside an ecosystem.
WHY THIS MATTERS WHEN YOU BUILD SOFTWARE
If you are developing software, the operating system becomes part of your technical environment.
You may need to understand:
- processes;
- memory;
- files;
- permissions;
- networking;
- environment variables;
- services;
- system APIs;
- hardware;
- logs;
- processes;
- terminals;
- package managers;
- system dependencies.
This is why programming becomes easier when you understand some computer science fundamentals.
Code does not execute in a vacuum.
It runs somewhere.
That “somewhere” has an architecture.
THE OPERATING SYSTEM IS AN ABSTRACTION MACHINE
The deeper lesson is not simply:
“Android uses Linux.”
or:
“Windows manages hardware.”
The deeper lesson is:
Operating systems create abstractions that allow humans and applications to work with complex computing machinery without controlling every physical detail directly.
Consider what is hidden from you when you open a document.
You do not need to know:
- the exact memory addresses;
- storage-sector layout;
- CPU instructions;
- electrical signals;
- device-controller commands;
- cache behavior;
- hardware interrupts;
- scheduling decisions.
You interact with:
Open → Edit → Save
The operating system helps transform that high-level intention into a sequence of lower-level operations.
That is one of the great achievements of computer science.
A COMPUTING STACK YOU SHOULD REMEMBER
Put the major pieces together:
YOU
↓
APPLICATIONS
↓
OS APIs
↓
SYSTEM SERVICES
↓
KERNEL
↓
DRIVERS / HARDWARE INTERFACES
↓
HARDWARE
↓
CPU • MEMORY • STORAGE • DEVICES
And when the application needs the Internet:
APPLICATION
↓
OPERATING SYSTEM
↓
NETWORK STACK
↓
NETWORK HARDWARE
↓
LOCAL NETWORK
↓
INTERNET
↓
REMOTE SYSTEM
When the application needs persistent information:
APPLICATION
↓
OPERATING SYSTEM
↓
FILE SYSTEM / STORAGE SERVICES
↓
STORAGE DEVICE
When the application needs camera input:
APPLICATION
↓
OS API / SERVICE
↓
HARDWARE INTERFACE
↓
CAMERA HARDWARE
These patterns will appear repeatedly throughout computing.
WHAT YOU SHOULD NOW LOOK FOR ON YOUR OWN DEVICE
Open your device settings.
Look for information such as:
- operating-system version;
- security-update status;
- storage;
- memory;
- installed applications;
- application permissions;
- battery usage;
- network settings;
- accessibility features;
- system services;
- developer options where available.
Don't change settings simply for the sake of experimenting.
Instead, observe.
Ask:
What does the operating system know about this device?
What resources are applications allowed to use?
Which applications are running?
Which applications use the most battery or storage?
When was the last security update?
You are beginning to see the operating system as a system rather than just an interface.
A SMALL OPERATING-SYSTEM INVESTIGATION
Choose one application on your phone or computer.
Investigate:
1. What operating system does it run on?
2. What permissions does it request?
3. What files does it create?
4. Does it require Internet connectivity?
5. Does it run background processes?
6. What happens if you revoke a permission?
7. What happens if you force-stop it?
8. What happens after restarting the device?
9. Does the application require a particular OS version?
10. What happens when the OS receives an update?
You are turning everyday device use into practical computer-science observation.
OPERATING SYSTEMS AND THE INTERNET MONEY LENS
Understanding operating systems may not immediately look like an income skill.
But foundational computing knowledge compounds.
If you understand operating systems, you become better positioned to:
- troubleshoot computers;
- support users;
- administer systems;
- develop software;
- configure servers;
- work with cloud infrastructure;
- understand cybersecurity;
- build applications;
- automate tasks;
- support businesses;
- evaluate technology;
- teach computing;
- create technical content;
- and build digital products.
A deeper technical foundation can therefore increase the number of problems you are capable of solving.
The economic progression looks like:
COMPUTING KNOWLEDGE
↓
TECHNICAL SKILL
↓
PROBLEM-SOLVING CAPABILITY
↓
USEFUL RESULT
↓
SERVICE / PRODUCT / WORK
↓
VALUE
↓
INCOME / SAVINGS / ASSET
You don't need to monetize every piece of knowledge immediately.
Sometimes the economic value comes from what that knowledge enables you to do later.
OPERATING SYSTEMS ARE PART OF THE DIGITAL FOUNDATION
You have now moved one layer deeper into the computer.
You already have the foundation of:
Bits and digital representation
↓
Computer hardware and architecture
↓
Computing processes
↓
Operating systems
The next layers lead naturally toward:
- programming;
- software;
- databases;
- networking;
- cloud;
- cybersecurity;
- AI;
- distributed systems.
This is why Computer Science is not simply “learning to code.”
Programming is important, but computer science gives you a broader way to understand computation itself.
THE BIGGER PICTURE
Your phone may look like a single object.
It isn't.
It is a layered computing system.
PHYSICAL HARDWARE
↓
FIRMWARE
↓
KERNEL
↓
OPERATING SYSTEM
↓
SYSTEM SERVICES
↓
APPLICATIONS
↓
INTERNET SERVICES
↓
DIGITAL INFORMATION
↓
HUMAN PURPOSE
When you take a photograph, send a message, edit a video, make a payment, use an AI application, or publish something online, you are operating at the top of a deep technological stack.
You don't need to understand every layer before you can use the device.
But the more layers you understand, the more intelligently you can:
- choose technology;
- troubleshoot problems;
- build software;
- protect your systems;
- evaluate products;
- learn advanced computing;
- and solve technical problems.
That is the real value of computer science foundations.
The operating system is the bridge between the machine underneath and the software and human activities above it.
Once you understand that bridge, your computer stops looking like a collection of applications.
It starts looking like a computing system.
READ. USE. SOLVE.
Image: Facebook
No comments:
Post a Comment