IT Fundamentals on Software Engineering Learning Paths

Computer Architecture

Mon, 01 Jan 0001 00:00:00 +0000

The Von Neumann Model#

All modern computers follow this architecture: a processor fetches instructions from memory, decodes them, executes them, and stores results.

flowchart LR
 subgraph CPU["CPU"]
 CU["Control Unit"]
 ALU["ALU"]
 REG["Registers"]
 Cache["Cache"]
 end
 
 CPU <-->|"Bus"| RAM["RAM (Memory)"]
 CPU <-->|"Bus"| IO["I/O (Disk, Network, Display)"]

CPU (Central Processing Unit)#

Component	Role	Speed
Registers	Tiny storage inside CPU	1 cycle
L1 Cache	Per-core cache (32-64KB)	~4 cycles
L2 Cache	Per-core (256KB-1MB)	~12 cycles
L3 Cache	Shared across cores (8-64MB)	~40 cycles
RAM	Main memory (8-128GB)	~200 cycles
SSD	Persistent storage	~100,000 cycles
HDD	Spinning disk	~10,000,000 cycles

The Instruction Cycle#

flowchart LR
 F["Fetch"] --> D["Decode"]
 D --> E["Execute"]
 E --> S["Store"]
 S --> F

Fetch — read next instruction from memory (pointed to by Program Counter)
Decode — interpret what the instruction means
Execute — perform the operation (ALU for math, load/store for memory)
Store — write result to register or memory

Modern CPUs execute billions of cycles per second (GHz = billion cycles/sec).

Operating Systems

Mon, 01 Jan 0001 00:00:00 +0000

What is an Operating System?#

An OS is the software layer between hardware and applications. It manages resources (CPU, memory, disk, I/O) and provides abstractions so programs don’t need to interact with hardware directly.

flowchart TD
 Apps["Applications (browser, editor, server)"]
 Apps --> OS["Operating System"]
 OS --> HW["Hardware (CPU, RAM, Disk, Network)"]

Core Responsibilities#

Function	What It Does
Process management	Create, schedule, and terminate processes
Memory management	Allocate RAM, virtual memory, paging
File system	Organize and access persistent data
I/O management	Interface with devices (disk, network, display)
Security	User permissions, process isolation

Process Management#

What is a Process?#

A process is a running program — it has its own memory space, file descriptors, and execution state.

File Systems

Mon, 01 Jan 0001 00:00:00 +0000

What is a File System?#

A file system organizes data on storage devices into a hierarchy of files and directories. It manages how data is stored, retrieved, and updated on disk.

flowchart TD
 Root["/"]
 Root --> etc["/etc (config)"]
 Root --> home["/home (users)"]
 Root --> var["/var (variable data)"]
 Root --> usr["/usr (programs)"]
 Root --> tmp["/tmp (temporary)"]
 
 home --> alice["/home/alice"]
 var --> log["/var/log"]

Linux Directory Structure#

Path	Purpose
`/`	Root — everything starts here
`/bin`	Essential binaries (ls, cp, cat)
`/etc`	System configuration files
`/home`	User home directories
`/var`	Variable data (logs, databases, mail)
`/tmp`	Temporary files (cleared on reboot)
`/usr`	User programs and libraries
`/opt`	Optional/third-party software
`/proc`	Virtual filesystem — process info
`/dev`	Device files (disks, terminals)
`/mnt`, `/media`	Mount points for external storage

File System Types#

FS	OS	Features	Use Case
ext4	Linux	Journaling, mature, reliable	Default Linux FS
XFS	Linux	High performance, large files	Enterprise, databases
Btrfs	Linux	Snapshots, compression, RAID	Advanced Linux
NTFS	Windows	ACLs, encryption, journaling	Windows default
APFS	macOS	Snapshots, encryption, SSD-optimized	macOS/iOS
FAT32	Cross-platform	Simple, universal	USB drives, boot partitions
ZFS	Linux/BSD	Checksums, snapshots, RAID-Z	Storage servers

Key Concepts#

Inodes#

Every file has an inode — metadata about the file (NOT the filename):

Linux Basics

Mon, 01 Jan 0001 00:00:00 +0000

Why Linux?#

Linux runs ~96% of cloud servers, all Android phones, most IoT devices, and the world’s top supercomputers. For software engineers, Linux fluency is non-negotiable.

Essential Commands#

pwd # print working directory
ls -la # list all files with details
cd /path/to/dir # change directory
cd ~ # go to home directory
cd - # go to previous directory

mkdir -p path/to/dir # create directories (with parents)
touch file.txt # create empty file
cp -r source/ dest/ # copy (recursive)
mv old new # move/rename
rm -r directory/ # remove (recursive)

Viewing Files#

cat file.txt # print entire file
less file.txt # paginated viewer (q to quit)
head -20 file.txt # first 20 lines
tail -20 file.txt # last 20 lines
tail -f /var/log/app.log # follow (live updates)
wc -l file.txt # count lines

Searching#

find . -name "*.py" # find files by name
grep -r "pattern" dir/ # search file contents
which command # find command location
locate filename # fast search (uses index)

Users and Permissions#

User Management#

whoami # current user
id # user ID, groups
sudo command # run as root
su - username # switch user

File Permissions#

-rwxr-xr-- 1 alice devs 4096 Jan 1 12:00 script.sh
 │││ │││ │││
 │││ │││ └── Others: read only
 │││ └──── Group: read + execute
 └────── Owner: read + write + execute

chmod 755 script.sh # rwxr-xr-x
chmod 644 file.txt # rw-r--r--
chown alice:devs file # change owner:group

Package Management#

Distro Family	Tool	Commands
Debian/Ubuntu	apt	`apt update`, `apt install pkg`, `apt remove pkg`
RHEL/CentOS/Amazon	yum/dnf	`yum install pkg`, `dnf update`
Alpine	apk	`apk add pkg`, `apk del pkg`

# Debian/Ubuntu
sudo apt update # refresh package index
sudo apt install nginx # install
sudo apt remove nginx # remove
sudo apt upgrade # upgrade all packages

# RHEL/Amazon Linux
sudo yum install nginx
sudo yum update

Service Management (systemd)#

# Service control
systemctl start nginx # start service
systemctl stop nginx # stop service
systemctl restart nginx # restart
systemctl status nginx # check status
systemctl enable nginx # start on boot
systemctl disable nginx # don't start on boot

# View logs
journalctl -u nginx # logs for a service
journalctl -u nginx --since today
journalctl -f # follow all logs

Process Management#

ps aux # all processes
ps aux | grep nginx # find specific process
top # real-time process monitor
htop # better process monitor

kill PID # graceful stop (SIGTERM)
kill -9 PID # force kill (SIGKILL)
pkill -f "pattern" # kill by name pattern

Networking Commands#

ip addr show # show IP addresses
ip route show # show routing table
ss -tlnp # listening TCP ports
curl -v http://localhost # HTTP request
ping host # test connectivity
dig domain.com # DNS lookup

Environment Variables#

echo $PATH # view variable
export MY_VAR="value" # set for current session
env # list all env vars

# Persistent (add to ~/.bashrc or ~/.profile)
echo 'export MY_VAR="value"' >> ~/.bashrc
source ~/.bashrc # reload

SSH (Secure Shell)#

# Connect to remote server
ssh user@hostname
ssh -i ~/.ssh/key.pem user@host # with private key

# Copy files
scp file.txt user@host:/path/ # local → remote
scp user@host:/path/file.txt . # remote → local

# SSH key generation
ssh-keygen -t ed25519 -C "email@example.com"
# Public key → ~/.ssh/id_ed25519.pub (share this)
# Private key → ~/.ssh/id_ed25519 (keep secret, chmod 600)

Key Takeaways#

Learn the core commands — ls, cd, grep, find, chmod, ps, systemctl
Everything is a file in Linux — config, devices, processes
systemd manages services — systemctl and journalctl are essential
SSH is how you access remote servers — use key-based auth, never passwords
Package managers vary by distro — apt (Debian), yum/dnf (RHEL), apk (Alpine)
Environment variables configure applications — export for the session, .bashrc for persistence

Virtualization and Containers

Mon, 01 Jan 0001 00:00:00 +0000

The Problem: “Works on My Machine”#

Applications depend on specific OS versions, libraries, and configurations. Virtualization and containers solve this by packaging the environment with the application.

Virtualization (Virtual Machines)#

A hypervisor creates virtual hardware — each VM runs its own complete OS:

flowchart TD
 subgraph Physical["Physical Server"]
 HV["Hypervisor"]
 subgraph VM1["VM 1"]
 OS1["Guest OS (Ubuntu)"]
 App1["App A"]
 end
 subgraph VM2["VM 2"]
 OS2["Guest OS (RHEL)"]
 App2["App B"]
 end
 end

Hypervisor Types#

Type	Description	Examples
Type 1 (bare-metal)	Runs directly on hardware	VMware ESXi, KVM, Xen, Hyper-V
Type 2 (hosted)	Runs on top of a host OS	VirtualBox, VMware Workstation

VM Characteristics#

Aspect	Value
Isolation	Full (separate kernel)
Boot time	Minutes
Size	Gigabytes (full OS)
Overhead	High (duplicate OS per VM)
Use case	Different OS requirements, strong isolation

Containers#

Containers share the host kernel but isolate the application’s filesystem, processes, and network:

Security Fundamentals

Mon, 01 Jan 0001 00:00:00 +0000

The CIA Triad#

All security aims to protect three properties:

flowchart TD
 C["Confidentiality<br/>(only authorized access)"]
 I["Integrity<br/>(data not tampered with)"]
 A["Availability<br/>(accessible when needed)"]

Property	Threat	Protection
Confidentiality	Data breach, eavesdropping	Encryption, access control
Integrity	Tampering, corruption	Hashing, digital signatures
Availability	DDoS, hardware failure	Redundancy, backups

Encryption#

Symmetric Encryption#

Same key encrypts and decrypts — fast, used for bulk data:

Algorithm	Key Size	Use Case
AES-256	256 bits	Data at rest, TLS data transfer
ChaCha20	256 bits	Mobile, TLS alternative

Asymmetric Encryption#

Key pair (public + private) — slower, used for key exchange and signatures:

Authentication and Authorization

Mon, 01 Jan 0001 00:00:00 +0000

AuthN vs AuthZ#

Concept	Question	Example
Authentication (AuthN)	Who are you?	Login with username/password
Authorization (AuthZ)	What can you do?	Can this user delete records?

Authentication always comes first — you must know WHO before deciding WHAT they can access.

Authentication Methods#

Method	How It Works	Security	Use Case
Password	User provides secret string	Low (phishing, reuse)	Legacy, with MFA
MFA	Password + second factor	High	All production systems
API Key	Static token in header	Medium	Service-to-service (simple)
OAuth 2.0 + OIDC	Token-based delegation	High	Web apps, SSO
mTLS	Both sides present certificates	Very high	Service mesh, zero-trust
SSH Keys	Public/private key pair	High	Server access

Multi-Factor Authentication (MFA)#

Combines two or more factors:

Version Control: Git Concepts

Mon, 01 Jan 0001 00:00:00 +0000

What is Version Control?#

Version control tracks changes to files over time, enabling collaboration, history, and rollback. Git is the industry standard — used by virtually every software team.

Git’s Data Model#

Git stores snapshots, not diffs. Each commit is a complete snapshot of all tracked files:

flowchart LR
 C1["Commit A<br/>(snapshot)"] --> C2["Commit B<br/>(snapshot)"]
 C2 --> C3["Commit C<br/>(snapshot)"]
 C3 --> C4["Commit D<br/>(snapshot)"]

Key Objects#

Object	Contains
Blob	File content (any version)
Tree	Directory listing (blobs + subtrees)
Commit	Tree pointer + parent + author + message
Tag	Named pointer to a commit

The Three Areas#

flowchart LR
 WD["Working Directory<br/>(your files)"] -->|"git add"| SA["Staging Area<br/>(index)"]
 SA -->|"git commit"| Repo["Repository<br/>(.git/)"]
 Repo -->|"git checkout"| WD

Area	Purpose
Working Directory	Files you see and edit
Staging Area (Index)	Changes selected for next commit
Repository (.git/)	Complete history of all commits

Branching#

Branches are lightweight pointers to commits — creating a branch is instant:

Software Development Lifecycle

Mon, 01 Jan 0001 00:00:00 +0000

What is the SDLC?#

The Software Development Lifecycle is the process of planning, creating, testing, deploying, and maintaining software. Different methodologies organize these phases differently, but the activities are universal.

SDLC Phases#

flowchart LR
 Plan["Plan"] --> Design["Design"]
 Design --> Build["Build"]
 Build --> Test["Test"]
 Test --> Deploy["Deploy"]
 Deploy --> Operate["Operate"]
 Operate --> Plan

Phase	Activities	Outputs
Plan	Requirements, prioritization, estimation	User stories, backlog
Design	Architecture, API contracts, data models	Design docs, ADRs
Build	Write code, unit tests, code review	Working software
Test	Integration tests, QA, UAT	Test reports, bug fixes
Deploy	Release to production	Running service
Operate	Monitor, maintain, support	Metrics, incident responses

Methodologies#

Waterfall#

Sequential phases — each completes before the next begins:

Hardware

Mon, 01 Jan 0001 00:00:00 +0000

Overview#

Understanding computer hardware is the foundation of IT literacy. Every piece of software ultimately runs on physical components — processors, memory, storage, and interconnects. Knowing how these parts work, interact, and fail gives you a mental model for performance tuning, troubleshooting, and system design.

The Central Processing Unit (CPU)#

The CPU executes instructions. It’s the brain of the computer, but a very specific kind of brain — one that does billions of simple operations per second.

Assembling a Computer

Mon, 01 Jan 0001 00:00:00 +0000

Overview#

Building a computer from components is one of the most practical IT skills. It demystifies the hardware, teaches you how everything connects, and gives you the ability to diagnose failures at the physical level. This section covers the full process from planning to first boot and troubleshooting.

Planning the Build#

Compatibility Checklist#

Before purchasing components, verify compatibility:

flowchart TD
 CPU["1. Choose CPU"] --> MB["2. Motherboard<br/>(matching socket + chipset)"]
 MB --> RAM["3. RAM<br/>(DDR4 or DDR5, match MB spec)"]
 MB --> CASE["4. Case<br/>(ATX, mATX, ITX — match MB)"]
 MB --> STORAGE["5. Storage<br/>(M.2 slots? SATA ports?)"]
 CPU --> COOLER["6. CPU Cooler<br/>(socket compatibility, TDP)"]
 CPU --> PSU["7. PSU<br/>(wattage for CPU + GPU + rest)"]
 MB --> GPU["8. GPU<br/>(PCIe slot, case clearance, PSU connectors)"]

Key Compatibility Points#

Component	Must Match
CPU ↔ Motherboard	Socket type (LGA 1700, AM5, etc.)
RAM ↔ Motherboard	DDR generation, speed support, number of slots
Motherboard ↔ Case	Form factor (ATX, Micro-ATX, Mini-ITX)
GPU ↔ Case	Physical length clearance
GPU ↔ PSU	Power connectors (8-pin, 12VHPWR) and wattage
CPU Cooler ↔ Case	Height clearance (tower coolers) or radiator mount points (AIO)
CPU Cooler ↔ CPU	Socket mounting bracket included

Tools Required#

Tool	Purpose
Phillips #2 screwdriver	90% of all PC screws
Phillips #1 screwdriver	M.2 screws, small standoffs
Anti-static wrist strap	Prevent ESD damage (or touch case metal frequently)
Cable ties / velcro straps	Cable management
Flashlight / headlamp	See inside the case
Thermal paste	Usually pre-applied on cooler; have backup
Magnetic screw tray	Don’t lose screws

Step-by-Step Assembly#

Step 1: Prepare the Workspace#

Work on a large, clean, non-carpeted surface (table, desk)
Ground yourself: wear an anti-static strap clipped to the case, or touch bare metal frequently
Keep components in anti-static bags until ready to install
Read the motherboard manual — it’s the most important document

Step 2: Install the CPU#

Intel (LGA — Land Grid Array):

Linux Administration

Mon, 01 Jan 0001 00:00:00 +0000

Going Deeper with Linux#

The Linux Basics section introduced essential commands and concepts. This section dives deeper into the structures and tools that make Linux administration possible: the filesystem hierarchy, permission model, process control, systemd, and power-user commands.

The Filesystem Hierarchy#

Linux organises everything into a single tree rooted at /. There are no drive letters — devices, processes, and configuration are all mounted into this tree.

Standard Directories#

Directory	Purpose	Examples
`/`	Root of the entire filesystem	Everything branches from here
`/etc`	System-wide configuration files	`/etc/nginx/nginx.conf`, `/etc/hosts`, `/etc/passwd`
`/var`	Variable data (changes at runtime)	`/var/log/`, `/var/lib/docker/`, `/var/mail/`
`/home`	User home directories	`/home/alice/`, `/home/bob/`
`/usr`	User system resources (programs, libraries)	`/usr/bin/`, `/usr/lib/`, `/usr/share/`
`/tmp`	Temporary files (cleared on reboot)	Scratch space for any process
`/bin`	Essential command binaries	`ls`, `cp`, `cat` (often symlinked to `/usr/bin`)
`/sbin`	System administration binaries	`fdisk`, `iptables`, `systemctl`
`/opt`	Optional/third-party software	`/opt/datadog-agent/`, `/opt/terraform/`
`/dev`	Device files	`/dev/sda` (disk), `/dev/null`, `/dev/random`
`/proc`	Virtual filesystem — running processes	`/proc/cpuinfo`, `/proc/meminfo`, `/proc/1/status`
`/sys`	Virtual filesystem — kernel/hardware info	`/sys/class/net/`, `/sys/block/`
`/mnt`, `/media`	Mount points for external filesystems	USB drives, network shares
`/root`	Home directory for the root user	Not under `/home` — root is special

Key Principles#

Everything is a file — devices (/dev/sda), processes (/proc/PID), and even kernel parameters (/sys/) are exposed as files
Configuration is text — almost all config lives in /etc as plain-text files you can read, edit, and version-control
Logs accumulate in /var/log — syslog, auth.log, kern.log, application logs
/tmp is ephemeral — never store anything important there; it’s wiped on reboot and often mounted as tmpfs (RAM)

# See disk usage per top-level directory
du -sh /* 2>/dev/null | sort -rh | head -15

# Find the largest files in /var/log
find /var/log -type f -exec du -h {} + | sort -rh | head -10

# Check what's mounted where
df -hT

File Permissions In Depth#

The Permission Model#

Every file and directory has three sets of permissions for three entities:

IT Fundamentals on Software Engineering Learning Paths

Computer Architecture

The Von Neumann Model#

CPU (Central Processing Unit)#

The Instruction Cycle#

Operating Systems

What is an Operating System?#

Core Responsibilities#

Process Management#

What is a Process?#

File Systems

What is a File System?#

Linux Directory Structure#

File System Types#

Key Concepts#

Inodes#

Linux Basics

Why Linux?#

Essential Commands#

Navigation and Files#

Viewing Files#

Searching#

Users and Permissions#

User Management#

File Permissions#

Package Management#

Service Management (systemd)#

Process Management#

Networking Commands#

Environment Variables#

SSH (Secure Shell)#

Key Takeaways#

Virtualization and Containers

The Problem: “Works on My Machine”#

Virtualization (Virtual Machines)#

Hypervisor Types#

VM Characteristics#

Containers#

Security Fundamentals

The CIA Triad#

Encryption#

Symmetric Encryption#

Asymmetric Encryption#

Authentication and Authorization

AuthN vs AuthZ#

Authentication Methods#

Multi-Factor Authentication (MFA)#

Version Control: Git Concepts

What is Version Control?#

Git’s Data Model#

Key Objects#

The Three Areas#

Branching#

Software Development Lifecycle

What is the SDLC?#

SDLC Phases#

Methodologies#

Waterfall#

Hardware

Overview#

The Central Processing Unit (CPU)#

Assembling a Computer

Overview#

Planning the Build#

Compatibility Checklist#

Key Compatibility Points#

Tools Required#

Step-by-Step Assembly#

Step 1: Prepare the Workspace#

Step 2: Install the CPU#

Linux Administration

Going Deeper with Linux#

The Filesystem Hierarchy#

Standard Directories#

Key Principles#

File Permissions In Depth#

The Permission Model#