Computing Fundamentals
Computing fundamentals covers the foundational concepts underlying all computer systems: binary representation, logic gates, processor operation, memory, storage, operating systems, and networking. It provides the mental model for understanding how software instructions become physical actions.
itComputer fundamentals | OpenSkills.info
Course pathWalk it in order
Look it upDip in anytime
Go furtherLeaves this page
Don't Panic
Don't Panic -- Computing Fundamentals
Right then. You have in front of you a two-minute tour of how a computer actually works, written for people with better things to do. It is not a textbook and will not make you memorize a datasheet. It hands you a map of the machine so that the next time something misbehaves, you know which layer is lying to you.
The problem this set of pages solves: a computer is several quiet subsystems pretending to be one gadget. Before you got here, the usual introduction was either a wall of acronyms, CPU, DRAM, API, DNS, TCP, stacked until the eyes glaze, or a brochure that shows you pictures of keyboards. This course skips both.
Three ideas carry the whole thing.
First, the machine is layered. Hardware supplies resources, software supplies instructions, and the operating system, the software managing processors, memory, files, devices and the network, is the referee in the middle. Once you see that a program, stored instructions, is not a process, the running copy that holds state and consumes resources, a lot of confusing behavior starts to look like coordination instead of chaos.
Second, data has no innocent meaning. Bits are of themselves silent. A byte is just a run of zeroes and ones until a format or character encoding, the mapping from stored units to characters, gives it meaning. The same eight bits can be a number, a letter, a pixel or part of an instruction. Stare at a file long enough and it stays stubbornly meaningless until you say what it is.
Third, the machine is not uniform. Main memory, the RAM, forgets everything when the power goes, while storage does not. Underneath it all sits the page cache, a slice of main memory that holds file chunks, which is why a write may not reach the disk for a while and a read may not touch the disk at all. These gaps are where 'it should just work' goes to die.
The genuinely surprising thing: your tidy slogan 'I saved it, so it is safe' is backwards. Writing bytes is a request, not a receipt, and memory does not empty the instant power leaves, which has consequences for trust most people only discover far too late.
Start with the introductory page for the calm version of the map, then the slides and cheatsheet as your glossary. When you are ready for the gritty underside, the field notes carry the judgment the intro was too polite to mention, and the timeline covers how all of this got built in a few loud decades.
Where this skill leads
Relevant careers
See how this topic contributes to broader role-level skill maps.
Sources
- https://nvlpubs.nist.gov/nistpubs/SpecialPublications/NIST.SP.800-223.pdf
Supports
- Computers include CPUs, memory, disk space, and network interfaces
- A software stack includes an operating system, compilers, and libraries
- Workload requirements determine relevant storage and network constraints
- https://csrc.nist.gov/glossary/term/byte
Supports
- A byte is a sequence of eight bits
- Byte values can be treated as integers from zero through 255
- https://csrc.nist.gov/glossary/term/os
Supports
- An operating system manages hardware resources and provides common program services
- Operating-system functions include scheduling, input and output, and data management
- Applications use the operating system for interface and file-management operations
- https://csrc.nist.gov/pubs/ir/7298/r3/final
Supports
- Standard terminology for security, authentication, authorization, and system concepts
- The need to interpret technical terms in their defined source context
- https://csrc.nist.gov/glossary/term/backup
Supports
- A backup is a copy of files and programs made to support recovery
- Backup has a recovery purpose distinct from active working data
- https://pubs.opengroup.org/onlinepubs/9799919799/basedefs/V1_chap01.html
Supports
- POSIX defines a standard operating-system interface and environment
- The environment includes a command interpreter and common utilities
- https://pubs.opengroup.org/onlinepubs/9799919799/basedefs/V1_chap03.html
Supports
- Formal definitions of file system, pathname, parent directory, and file permissions
- Process and parent-process terminology
- A pathname identifies a file
- https://pubs.opengroup.org/onlinepubs/9799919799/basedefs/V1_chap04.html
Supports
- Files are organized through a hierarchy containing directories
- Absolute and relative pathnames use different starting locations
- File-system access can pass through a memory cache
- https://pubs.opengroup.org/onlinepubs/9799919799/utilities/V3_chap02.html
Supports
- A shell is a command language interpreter
- A shell reads, tokenizes, parses, and executes commands
- https://pubs.opengroup.org/onlinepubs/9799919799/functions/fork.html
Supports
- A process has an identifier and can create a child process
- A new process receives defined process state and resource references
- https://www.rfc-editor.org/info/rfc1122/
Supports
- Internet communication uses application, transport, Internet, and link layers
- Hosts implement layered protocols for interoperability
- Network layers provide distinct responsibilities useful for fault isolation
- https://www.rfc-editor.org/rfc/rfc9293.html
Supports
- TCP provides reliable, ordered byte-stream service
- TCP carries byte streams in segments inside IP datagrams
- Sequence numbers, checksums, and retransmission contribute to reliability
- Ports identify application services and multiplex flows
- https://www.rfc-editor.org/info/rfc1035/
Supports
- DNS provides name-server access over Internet transports
- DNS queries and responses can be carried with UDP or TCP
- Name resolution is distinct from packet routing and application execution
- https://www.cisa.gov/secure-our-world
Supports
- Recognize and report phishing
- Use strong passwords and a password manager
- Turn on multifactor authentication
- Install software updates promptly
- https://support.apple.com/en-ae/guide/platform-support/supc3f7e97bc/web
Supports
- Systematic troubleshooting narrows symptoms across hardware, operating-system, connectivity, application, and service layers
- Isolation tests help distinguish possible root causes
- Lower-effort observations and tests should precede disruptive changes
- https://www.cisa.gov/resources-tools/training/how-protect-data-stored-your-devices
Supports
- Backup copies reduce the risk of permanent data loss
- Connected backup media can be deleted or corrupted by ransomware
- Backup and restoration guidance applies across major operating systems
- https://openstax.org/books/introduction-computer-science/pages/1-1-computer-science
Supports
- A broad computer-hardware model of processor, memory, network, and storage
- Software provides algorithms and instructions that operate on data
- Computing has technical limits related to computability and required resources
- https://openstax.org/books/introduction-computer-science/pages/5-1-computer-systems-organization
Supports
- Programs move from storage into memory for execution
- The CPU fetches, decodes, and executes instructions
- Registers, cache, memory, storage, buses, and input-output devices have distinct roles
- https://openstax.org/books/introduction-computer-science/pages/6-2-fundamental-os-concepts
Supports
- Applications request operating-system services through interfaces
- Operating systems manage processes, memory, files, devices, and input-output
- Device drivers expose hardware functions through software interfaces
- https://developer.mozilla.org/en-US/docs/Learn_web_development/Howto/Web_mechanics/How_does_the_Internet_work
Supports
- Switches connect devices on local networks
- Routers forward messages between networks
- Domain names provide human-readable names associated with network destinations
- The Web is a service built on Internet infrastructure
- https://developer.mozilla.org/en-US/docs/Web/HTTP/Guides/MIME_types
Supports
- A media type indicates the nature and format of bytes
- A file-name suffix can suggest a type but is not guaranteed to be correct
- Content can be examined for format markers when explicit type information is absent
- https://www.nand2tetris.org/
Supports
- The materials build a general-purpose computer and software hierarchy from first principles
- The course provides lectures, projects, and tools for practical progression
- https://ocw.mit.edu/courses/6-033-computer-system-engineering-spring-2018/
Supports
- Advanced study includes modularity, client-server design, operating systems, performance, and networks
- The course also covers naming, security, privacy, fault tolerance, and recovery
- https://thunk.org/tytso/blog/2009/03/12/delayed-allocation-and-the-zero-length-file-problem/
Supports
- write() returning does not guarantee data reached disk
- Delayed allocation and a short commit interval mask the gap between a write and stability
- Durability of critical data requires an explicit flush such as fsync()
- https://manybutfinite.com/post/page-cache-the-affair-between-memory-and-files/
Supports
- All regular file I/O happens through the page cache
- A write copies bytes to the page cache and marks the page dirty; disk I/O happens later
- A cached read may not touch the disk at all, so timings vary run to run
- https://jhalderm.com/pub/papers/coldboot-cacm09.pdf
Supports
- DRAM retains its contents for several seconds after power loss
- Assuming memory is wiped on power-off is incorrect
- In-memory state that is not persisted is genuinely gone on power loss
- https://www.joelonsoftware.com/2003/10/08/the-absolute-minimum-every-software-developer-absolutely-positively-must-know-about-unicode-and-character-sets-no-excuses/
Supports
- There is no such thing as plain text; bytes need an encoding to become characters
- Assuming ASCII silently corrupts non-English text into mojibake
- The encoding must be known wherever text crosses a boundary
- https://en.wikipedia.org/wiki/Turing_machine
Supports
- The 1936 Turing machine founding milestone
- https://en.wikipedia.org/wiki/A_Symbolic_Analysis_of_Relay_and_Switching_Circuits
Supports
- The 1937 Shannon switching-circuits milestone
- https://en.wikipedia.org/wiki/ENIAC
Supports
- The 1945 ENIAC milestone
- https://en.wikipedia.org/wiki/Transistor
Supports
- The 1947 transistor milestone
- https://en.wikipedia.org/wiki/UNIVAC_I
Supports
- The 1951 UNIVAC I milestone
- https://en.wikipedia.org/wiki/IBM_350
Supports
- The 1956 magnetic-disk drive milestone
- https://en.wikipedia.org/wiki/Fortran
Supports
- The 1957 FORTRAN milestone
- https://en.wikipedia.org/wiki/Integrated_circuit
Supports
- The 1958 integrated-circuit milestone
- https://en.wikipedia.org/wiki/IBM_System/360
Supports
- The 1964 IBM System/360 milestone
- https://en.wikipedia.org/wiki/ARPANET
Supports
- The 1969 ARPANET first-link milestone
- https://en.wikipedia.org/wiki/Intel_4004
Supports
- The 1971 Intel 4004 milestone
- https://en.wikipedia.org/wiki/Altair_8800
Supports
- The 1975 Altair 8800 milestone
- https://en.wikipedia.org/wiki/Apple_II
Supports
- The 1977 Apple II milestone
- https://en.wikipedia.org/wiki/IBM_Personal_Computer
Supports
- The 1981 IBM PC milestone
- https://en.wikipedia.org/wiki/Internet_protocol_suite
Supports
- The 1983 TCP/IP adoption milestone
- https://en.wikipedia.org/wiki/Tim_Berners-Lee
Supports
- The 1989 web proposal milestone
- https://en.wikipedia.org/wiki/History_of_the_World_Wide_Web
Supports
- The 1990 first web server and browser milestone
- https://en.wikipedia.org/wiki/WorldWideWeb
Supports
- The 1991 web made public milestone
