DEV Community: Riya Halbhavi

🐈‍⬛ The Definitive Guide to Git, GitHub, and Open Source Contribution

Riya Halbhavi — Tue, 30 Jun 2026 04:54:47 +0000

In the modern landscape of software development, open-source software serves as the bedrock for technological innovation, powering everything from microservices to global enterprise infrastructure.

At the core of this collaborative ecosystem lies Git, a decentralized version control system designed to track modifications, manage concurrent workflows, and safeguard code integrity.

While Git operates as the local foundational engine, platforms like GitHub provide the cloud-based social infrastructure, transforming isolated codebases into globally accessible public hubs/repositories.

Understanding how to seamlessly navigate Git operations and merge them with GitHub’s collaborative workflows is a vital competency for any developer looking to impact global software engineering ecosystems.

Engaging in open-source development is more than an act of altruistic code contribution; it is a collaborative methodology that sharpens your skills, fosters community mentoring and interaction, and drives industry standards forward. Overall, a truly rewarding experience.

🐱 Part 1: The Comprehensive Git Commands Reference

Git functions through a series of dedicated state transformations, moving code between the working directory, the staging index, the local repository head, and remote servers. Below is the comprehensive command architecture categorized by functional lifecycle phases.

🛠️ 1. Setup and Configuration

These commands establish your developer identity, globally define configuration parameters, and provide administrative system help metadata.

Command	Functional Description	Syntactical Example
`git config`	Queries or mutates global and repository-level configuration properties.	`git config --global user.name "John Doe"`
`git help`	Launches detailed system documentation or summaries for targeted sub-commands.	`git help commit`
`git version`	Outputs the active build version of the local Git binary.	`git version`

💻 2. Creating and Cloning/Copying Projects

Used at project inception to initialize structural Git metadata directories or replicate remote architectures locally.

Command	Functional Description	Syntactical Example
`git init`	Generates a hidden `.git` tracking system inside the target directory.	`git init`
`git clone`	Downloads an external project database and builds a tracked local copy on your device.	`git clone https://github.com/user/repo.git`

3. 📸 Basic Snapshotting (Working with Changes)

These commands control the primary local lifecycle: tracking file additions, staging alterations, examining state diffs, and committing logical snapshots.

Command	Functional Description	Syntactical Example
`git add`	Adds modified files or directory state to the index staging area. Adds all files to staging area.	`git add src/main.js` `git add .`
`git status`	Aggregates tracked versus untracked changes, showing state deltas.	`git status`
`git diff`	Renders line-by-line differences between working, staged, or committed states.	`git diff --staged`
`git commit`	Binds staged changes permanently to local structural graph logs, with a meaningful message detailed the changes.	`git commit -m "Refactor auth"`
`git restore`	Overwrites uncommitted modifications in the working tree from the repository index.	`git restore components/`
`git reset`	Unstages tracking entries or rolls back HEAD pointer references safely.	`git reset HEAD file.txt`
`git rm`	Purges targeted items out of physical filesystems and staging lists.	`git rm obsolete.log`
`git mv`	Executes file relocations or renames while preserving tracking history.	`git mv old.js new.js`

4. 🌴 Branching and Merging

Commands that govern parallel feature tracks, enabling multi-threaded execution streams that can be reconciled safely later.

Definitions:

🌿 Branch: Independent workspace within a repository that allows you to safely develop features, fix bugs, or experiment with changes without affecting the main project/codebase. By default, every new repository starts with a primary branch, usually named 'main'.

➜] Merging: Process of taking the changes from an isolated feature branch and integrating them back into another branch (usually main).

Depending on how much the project history has changed while you (the developer) were working, Git performs this in 2 ways:

Fast-Forward Merge: If the main branch didn't receive any new updates while you were working on your new feature, Git simply slides the pointer forward to include your new commits/changes.
Three-Way Merge: If another developer updated the main branch while you were away, the 2 branches have diverged. Git compares both branch tips against their original shared ancestor and creates a new "merge commit" to combine them.

Command	Functional Description	Syntactical Example
`git branch`	Declares new development branches/pointers, lists active targets, or deletes branches.	`git branch feature-login`
`git checkout`	Migrates working states across lines of development or updates files.	`git checkout staging`
`git switch`	An optimized modern alternative dedicated solely to branch switching safety.	`git switch -c fix-bug`
`git merge`	Combines chronological sequences from divergent tracks into the active branch.	`git merge feature-login`
`git rebase`	Re-applies local linearly ordered commits directly on top of a fresh external base.	`git rebase main`
`git stash`	Shelves working modifications onto an internal stack to allow clean context switches.	`git stash pop`
`git tag`	Affixes immutable human-readable milestones to specific cryptographic commits.	`git tag -a v1.1.0 -m "Release"`

5. 🔗 Sharing and Updating Projects (Remotes)

Bridges the local filesystem to hosted networks, providing mechanisms to publish work and synchronize shared codebases.

Command	Functional Description	Syntactical Example
`git remote`	Manages names, tracking relationships, and connection URLs for remote locations.	`git remote add origin <url>`
`git fetch`	Downloads upstream refs and historical database objects without changing active branch files.	`git fetch origin`
`git pull`	Simultaneously executes an upstream fetch and merges it into the local branch.	`git pull origin main`
`git push`	Transfers local branch changes and structural commits into a remote server repository.	`git push origin main`

6. 📊 Inspection, Comparison, and Development History Visualization

Enables historical audits, line authorship tracing, reference pointer navigation, and development history logs.

Command / Flag	Functional Description	Syntactical Example
Core History Tools
`git log`	Displays the default commit history graph chain in reverse chronological order.	`git log`
`git show`	Expands details and diff structures for individual structural hash objects.	`git show e3b1a2c`
`git blame`	Annotates each code line with its last modifying author, date, and commit hash.	`git blame index.js`
`git shortlog`	Summarizes logs by authoring group, providing convenient project metric rollups.	`git shortlog -sn`
`git reflog`	Maintains an unbroken ledger tracking local head movements—a vital data safety net.	`git reflog`
Formatting & Visuals
`git log --oneline`	Condenses each commit to a single line showing an abbreviated hash and message.	`git log --oneline`
`git log --decorate`	Explicitly prints out branch names, tags, and HEAD indicators next to their commits.	`git log --decorate`
`git log --graph`	Renders a text-based ASCII graph displaying branch mutations, topologies, and merges.	`git log --graph`
`git log --stat`	Displays file-level stats for commits, showing changed targets and line delta volumes.	`git log --stat`
`git log -p`	Generates the complete patch information (full inline code diff) for past history entries.	`git log -p`
Filtering by Scope
`git log -n <number>`	Limits the output log screen to a strict specific count of the most recent commits.	`git log -n 5` (or `git log -3`)
`git log -- <file_path>`	Isolates repository history to track only commits that modified a specific path.	`git log -- src/utils.js`
`git log -L <range>:<file>`	Traces the precise evolutionary line-range or functional history of a block over time.	`git log -L 12,24:index.js`
Filtering by Criteria
`git log --grep="keyword"`	Searches commit titles/messages to catch explicit patterns, bug IDs, or PR identifiers.	`git log --grep="Fix auth"`
`git log --author="Name"`	Filters history logs to surface updates executed by specific authors or emails.	`git log --author="Jane Doe"`
`git log --since / --until`	Scans the timeline to isolate commits processed inside explicit calendar timeframes.	`git log --since="2026-01-01" --until="2026-06-30"`
`git log --all`	Overrides default logic to force visibility into all tracking branches instead of just HEAD.	`git log --all`
Advanced Views
`git log --first-parent`	Skips side-branch commits entirely to isolate the primary trunk timeline line of delivery.	`git log --graph --oneline --first-parent`

git log

git log --oneline

git log --graph

git log --graph --decorate

git blame

7. 🩹 Patching and Rewriting History

Advanced administrative operations designed to prune, clean up, or systematically alter committed data hierarchies before publishing upstream.

Command	Functional Description	Syntactical Example
`git cherry-pick`	Extracts changes introduced by a specific upstream commit and appends them to current HEAD.	`git cherry-pick c4a7f1e`
`git revert`	Generates a new, inverse commit that safely rolls back specified changes without erasing log lineage.	`git revert b2d5f9c`
`git rebase -i`	Triggers an interactive text buffer to reorder, squash, reword, or drop past commits.	`git rebase -i HEAD~4`

8. 🔍 🐞 Debugging and Troubleshooting

Surgical tools leveraged to locate system regressions, clean residual disk assets, and assess data repository integrity.

Command	Functional Description	Syntactical Example
`git bisect`	Implements binary search algorithms across the commit graph to isolate regression origins.	`git bisect start` / `bad`
`git grep`	Rapidly parses regular expression patterns across tracked file content hierarchies.	`git grep "TODO: auth"`
`git clean`	Flushes the physical directory by permanently deleting untracked files and directories.	`git clean -fd`
`git fsck`	Audits internal object graph links, verifying connectivity, hash sanity, and object health.	`git fsck`
`git gc`	Runs garbage collection, compresses file histories, and optimizes database storage.	`git gc --prune=now`

👨‍💻 Part 2: The Open Source / GitHub Contribution Guide

🌐 Open Source describes software whose source code is released under a license that grants anyone the right to inspect, modify, distribute, and use it for any purpose.

Contributing to open-source software projects stretches beyond writing functional code; it requires adhering to a strict social and technical workflow to ensure that maintainers can easily review and accept your additions. Following a structured contribution model ensures that codebases remain clean, maintainable, and aligned with project standards.

📜 Brief History of Open Source

The open source movement grew from an intense cultural clash between corporate proprietary licensing and a hacker culture of sharing code.

🕰️ Important Milestones

The Hacker Era (1950s - 1970s): In the early days of computing, software was shared freely alongside hardware.
The Proprietary Shift (1970s - 1980s): Companies started compiling software into binary format, restricting access to the source code to protect commercial profits.
The Free Software Movement (1983): Richard Stallman launched the GNU Project and later created the Free Software Foundation (FSF). He argued software should respect four essential user freedoms (run, study, modify, and redistribute).

The Rise of Linux (1991): Linus Torvalds released the Linux Kernel as a hobby project, which became the largest collaborative operating system in the world.

The "Open Source" Term Coined (1998): The term "Open Source" was coined at a meeting in Palo Alto, California, to present software sharing in a more business-friendly, pragmatic light.

💡 Why You Should Contribute

Level Up Your Skills: Working on large codebases exposes you to collaborative workflows, advanced design patterns, testing frameworks, and lint tools.
Build a Public Portfolio: Your GitHub contribution graph serves as a public proof-of-work. Employers can see your coding style, problem-solving, and communication.

Contribution Graph

You can also earn cool achievements for doing a variety of tasks like getting pull requests merged, closing an issue, or answering questions posted by other users on forums!

Collaborative Experience: You learn standard industry practices like code reviews, pull requests, CI/CD checks, and Git version control.
Find Mentors and Network: Collaborating with maintainers and other contributors connects you with engineers worldwide.

🔎︎ Common Misconceptions / Myths

Many people are intimidated by open source, believing it's only for "genius" developers. Let's debunk the most common myths.

1️⃣ MYTH 1: "I need to be a coding genius."

Reality: Most open source contributions are small fixes, typo corrections, documentation improvements, or simple bug patches. You do not need to rewrite the entire project to help! Starting small is key, and you will eventually transition into more complex work.

2️⃣ MYTH 2: "Open source is only about writing code."

Reality: Non-code contributions are highly valued. Projects need:

📝 Documentation: Fixing typos, enhancing or rewriting guides, translating text.
🎨 Design: Creating logos, improving UI layouts, styling components, adding relevant images.
🖧 Triage: Testing issues, writing reproducing steps, tagging duplicates.
🤝 Community: Answering questions in discussions, mentoring other fellow users and contributors.

3️⃣ MYTH 3: "My code must be perfect before submitting."

Reality: Pull requests are collaborative spaces. Maintainers expect revisions and are usually happy to help you refine your work if you communicate politely.

👣 The Step-by-Step Contribution Pipeline

1. Identify and Select a Project:

Find an open-source codebase that matches your skill set. Review the project's documentation, README.md, and explicit CONTRIBUTING.md protocols to understand their code styling metrics, testing frameworks, and submission expectations.

2. Discover or Create a New Issue:

Navigate to the project's Issues tab to find bugs or feature requests.

If you discover a new bug, open a descriptive issue detailing reproduction paths, expected behavior, and your system environment criteria.
If you are working on an existing issue, review the comment history to check if another contributor is already addressing it.

3. Secure Assignment:

Before writing any code, establish who is responsible for the task to avoid fragmented, overlapping work.

Comment directly on the issue, expressing your intent to work on a solution (e.g., "I would love to look into this bug. Could you please assign this issue to me?").
Wait for a project maintainer to officially assign the issue to your profile, or utilize automated self-assignment commands (e.g., typing .take or /assign if configured by the repository's automation bots).
Crucial open-source etiquette: Avoid coding in isolation without coordination or self-assigning multiple complex tasks that you cannot finish quickly, as this can stall project progress.

4. Fork the Repository:

Since you do not have direct write access to the upstream organization's repository, click the Fork button on GitHub. This creates a duplicate, server-side copy under your personal GitHub profile, granting you full administrative writing permissions over that specific clone.

5. Clone and Track Remotes:

Download your personal fork locally to your development environment. Connect it back to the original source codebase to keep track of any upstream updates using the following commands:

git clone https://github.com/your-username/repo-name.git
cd repo-name
git remote add upstream https://github.com/original-username/repo-name.git

6. Create a New/Isolated Feature Branch:

Never write modifications directly on the main branch.
Create a distinct, descriptively named branch specifically for your changes:

git switch -c feature/issue-description-or-id

7. Code, Modify, and Test:

Implement your code fixes, style formatting updates, or documentation expansions. Verify that your additions pass all preexisting automated test frameworks and do not introduce new regressions into the project. Commit your work locally using clear and concise commit logs.

8. Synchronize with Upstream:

Open-source codebases change quickly. Before publishing your work, pull any recent developments from the main repository into your local branch to handle any merge conflicts early:

git fetch upstream
git rebase upstream/main

9. Push to Your Personal Fork:

Upload your local commits to your personal GitHub repository copy:

git push origin feature/issue-description-or-id

10. Initiate a Pull Request (PR):

Navigate back to the original organization's upstream repository page on GitHub. A banner will automatically appear prompting you to click "Compare & pull request". Choose your personal feature branch as the head comparison source against the primary main branch of the parent repository.

11. Link the Issue via Keywords:

Fill out the pull request template completely, detailing your technical implementation choices.

Pro-Tip: To automate issue closure and keep project management neat, use explicit closing keywords in the PR description linked to the target issue ID. Write phrases such as Fixes #123, Closes #123, or Resolves #123.

When GitHub maintainers merge your PR into the core branch, GitHub parses these keywords and automatically closes the referenced issue, keeping project tracking accurate and organized.

12. Review and Iterate:

Once submitted, your pull request triggers automated continuous integration (CI) pipelines to test your code. Maintainers will review your work and may request design or code adjustments. Welcome this feedback, make the requested edits locally, commit them, and push them to your fork—the pull request will update automatically. Once approved, a maintainer will merge your branch into the core codebase!

🏁 Conclusion

Moreover, I conclude this guide to open source and version control systems. Many people ask me about the process of getting started with open source, raising issues and PRs, and participation in open source events, and thus I wrote this article to answer all these questions.

Is this guide helping you in any way? Feel free to drop a comment.

Happy contributing!

Free AI Coding Extensions for VS Code with High Usage Limits

Riya Halbhavi — Tue, 23 Jun 2026 16:30:57 +0000

Coding shouldn't have to cost a fortune, especially when you are just trying to find the perfect workflow. Fortunately, a handful of incredibly powerful AI extensions for VS Code offer robust free tiers with highly generous usage limits.

Sparing you the headache of digging through the marketplace to find the right tools, I have put together a list of the most prominent free extensions available right now so you don't have to spend a single dime.

Here are the top options to turbocharge your editor:

1. Windsurf (by Codeium)

Usage Limits: Unlimited base model completions.

What is Free: Inline code autocompletions and basic chat. It also gives individual developers a generous trial or a rolling quota of their powerful "Cascade" autonomous agent (which can write multi-file features for you).

Get it on: Windsurf Marketplace.

2. Blackbox AI

Usage Limits: Completely unlimited requests on its default models.

What is Free: Full multi-task chat agents, autocomplete, and code search. It famously does not require a subscription or even a login to get started with basic features.

Premium models require a subscription, but the free default models (like Mini Max) are highly proficient.

Get it on: Blackbox AI on VS Code.

3. Gemini Code Assist

Usage Limits: A massive allowance of up to 1,000 requests per user, per day on the individual tier when connected to your personal Google account.

What is Free: Robust inline code completion, code generation directly from comments, advanced bug fixing (/fix), smart documentation generation (/doc), and contextual sidebar chat. It leverages Google's fast Flash and Pro model families.

Get it on: Gemini Code Assist on VS Code Marketplace.

Whether you want the agentic multi-file capabilities of Windsurf, the instant, no-login convenience of Blackbox AI, or the massive daily allowance of Gemini Code Assist, you can build a cutting-edge development setup entirely for free. Mixing and matching these tools lets you lean on different AI strengths without ever hitting a hard paywall.

Grab one of these extensions from the marketplace and start coding smarter today!

🌐 Complete Guide to System and Network Administration

Riya Halbhavi — Sat, 20 Jun 2026 18:10:02 +0000

In a world completely powered by technology, have you ever wondered what actually keeps our digital lives from crashing down? Enter the unsung heroes: system and network administration.

Think of an operating system like Windows or Linux as a computer's command center, orchestrating everything from the heavy-lifting CPU to the smallest plugged-in device. To keep your data safe and your machine stable, it cleverly splits its brain into two zones: a restricted "user mode" where your everyday apps play, and a highly secure, privileged "kernel mode" reserved strictly for critical system operations.

When individual computers connect to form massive global networks, the complexity skyrockets. This comprehensive guide breaks down those complex environments into simple, bite-sized concepts.

Here is a quick snapshot of what we will cover:

Host & OS Administration: This module covers how an operating system functions as the primary intermediary between a user and a computer's raw physical hardware. It explains how the system kernel manages critical computing processes, memory allocation, local storage file systems, and administrative tasks like security patching and automated scripting.
Networking Concepts, Topologies, and Protocols: This module explores how individual computer systems connect and communicate across localized or global distances. It details the structural design of network topologies, addressing rules like IPv4 and IPv6, and the standardized layer frameworks that ensure safe and efficient data transmission.

🏛️ Part 1: Operating Systems & Host Administration

🖥️ Computer Resources and Functions

Computer Motherboard

At its core, every computer system is a collection of physical machinery and digital structures working together to solve problems. To understand how an operating system manages these pieces, it helps to look at the foundational puzzle blocks of a computer. This section maps out the primary hardware and data elements the system has to control, alongside a simple breakdown of how data flows through a machine from the moment you provide an input to when it saves or displays your final results.

Computer Resources

CPU
Memory
Input / Output Devices
Files

Computer Functions

 📥 Input ───► ⚙️ Process ───► 📤 Output
                  ▲
                  │
                  ▼
              💾 Storage

⚙️ Operating Systems

Major Computer Operating Systems

💻 Definition

System software that manages computer hardware & software resources.
Intermediary between users and computer hardware.
Provides essential services for application programs.

🌟 Features

User Interface: method for users to interact with computer.
File system: method by which OS stores and organizes files.
Processes and services
Kernel: Heart of OS, runs with highest priority.
Ensures high-priority processes are taken care of first.
Manages memory, makes sure I/O devices are accessed by only 1 person at a time.

📁 Examples:

Desktop OS: Windows, macOS, Linux
Server OS: Windows Server, Unix, Red Hat Enterprise, etc.
Mobile OS: Android, iOS

🛠️ Core Functions:

Process Management
Memory Management
File System Management
Device Management
Security & Access Control

🔄 Process and CPU Management

🔄 Process Management

Process: Program / event in execution.
Process creation, scheduling, termination of processes.
Multitasking: context-switching, scheduling algorithms.
Zombie process: Parent process deleted, child process executed.

⏱️ CPU Allocation Concepts

Each process is given a "time slice" by CPU.
After an operation is complete, the kernel gives the next process CPU access for its time slice.
FIFO (First In First Out) Method: Arrive first, get served first. Once a program starts running on the CPU, it cannot be interrupted or stopped by any other program until it is completely finished with its task. This is an example of a non-preemptive scheduling rule.
Preemption (Priority-Based Selection): The operating system retains the power to forcibly interrupt and freeze a running program if a higher-priority, time-critical application suddenly cuts in line and demands immediate CPU attention.

📊 Process Time-Slice Allocation Example

P1	P2	P3	P4	P5
a	b	c	d	e
12 s	10 s	15 s	20 s	10 s

🔄 Operating System Execution Modes

Restricted / User Mode vs. Privileged / Kernel Mode

Restricted / User Mode	Privileged / Kernel mode
- Executing code has inability to directly access hardware or reference memory.	- Executing code has full access to underlying hardware.
- Must assign to system APIs to access hardware / memory.	- Can execute any CPU instruction and reference any memory address.
- Purpose is to run user-level applications and software.	- Purpose is to manage system hardware & resources.
- Crashes don't crash entire OS.	- Crashes may crash entire OS.
- Limited exception handling.	- Comprehensive exception handling.

🧠 Memory Management & Storage Mapping

🛠️ OS Memory Management Tasks

Allocates memory to processes, handles de-allocation.
Memory segmentation & paging: splits memory if there is no continuous storage space.
Ensures memory protection to prevent processes from interfering with each other.

Kinds of Memory

1. Main memory
2. Secondary memory
3. Cache memory
4. Register memory
5. Flash memory

🗲 Main Memory

Located on the motherboard of the computer.
It stores data, instructions to be executed.

Includes:

RAM (Random Access Memory)

ROM (Read-Only Memory)

💾 Secondary Memory

Physical device for the storage of data permanently.
This data can be accessed and retrieved even after the computer is turned off.

Examples:

Hard disk

Flash drive

Compact drive

⚡ Cache Memory

Kind of RAM, located on both sides of the CPU.
It stores frequently accessed data and programs, allowing the CPU to quickly retrieve this data and execute instructions when needed.

📟 Register Memory

Located in the CPU.
This stores data in registers which is currently being executed by the CPU.
It's useful for parallel processing.

📸 Flash Memory

Non-volatile storage devices which are external.

Examples:

USB Drives
DVDs
Cameras in phones
Embedded systems in microcontrollers.

🖥️ Environment Architectures: Desktop vs. Server

👤 Desktop OS

Client OS
Used by 1 person at a time.
Always connected to a network (wired / wireless).

Hardware with this OS:

Desktop computers (CPU box, keyboard, mouse, monitor)
Laptops
iMac computers
Tablet computers (iPad Pro, Microsoft Surface) with detachable keyboards.

🌐 Server OS

Installed on a more powerful computer.
Usually wired connection.
Enables usage by multiple users.

Hardware with this OS:

Traditional server hardware
Rack-mounted server hardware
Blade servers

🗄️ Server Types

💾 Kinds of Historical & Modern Operating Systems

🪟 Windows: Developed by Microsoft

Used in PCs, laptops, servers.

Architecture:

Pentium architecture
32-bit architecture

⏳ Versions Timeline

Windows 3.x (1989)
Windows 95 (PnP)
Windows 98 (Active Desktop)
Windows Millennium Ed.
Windows New Technology (desktop & servers) : workstations, server
Windows 2000 (VPNs)
Windows Vista (desktop)
Windows XP
Windows 7 (success)
Windows 8 / 8.1
Windows 10
Windows 11

🐧 Linux

Open-source, Unix-like OS kernel.
Runs on Intel & AMD-based processors.

📦 Distributions:

Ubuntu (Most popular)
Fedora
Debian
CentOS
Arch Linux (Popular among tech-savvy users who prefer a "do-it-yourself" approach to build their OS from the ground up.)
OpenSUSE Linux
Turbolinux

Ubuntu 24.04 LT

🍏 macOS

macOS Big Sur

Developed by Apple
Intel processors, proprietary hardware
Built on Darwin UNIX - distribution of BSD Linux UNIX version

📌 Versions:

Mac OS X
Mac OS 10.x : firmware - hardware - functions located in ROM (unique)

💾 MS-DOS (Microsoft Disk Operating System) & PC DOS

MS-DOS

PC DOS

Microsoft's original OS for IBM PC hardware platform
Text-based CLI
Version called PC DOS as it was customized & marketed by IBM

🌐 UNIX Operating System

Developed at AT&T, headed by Ken Thompson & Dennis Ritchie, in 1969.
Company made it open-source.

🏛️ UNIX Standards:

BSD (Berkeley Software Distribution) standard: NetBSD, FreeBSD, BSDi UNIX (paid)
SVR4 (System V Release 4) standard: free Linux ver.s, Oracle Solaris, SCO UNIX

📐 Design Standards:

Modularity: Made of separate components, each performing a specific function.
Simplicity: Small set of tools, each performing a specific function.
Composability: Tools designed to work together seamlessly by using standard I/O streams.
Extensibility: Functionalities can be extended by users
Standards:
SUS (Single UNIX Specification)
POSIX (Portable OS standards)

🌿 UNIX Distribution Family Tree

                      🐧 [UNIX Distributions]
                     /                       \
        🛠️ [Unix-Based]                     🧬 [Unix-Like]
       /   │   │   │   \                   /   │   │   │   \
    [AIX] [Sol] [IRIX] [HP-UX]          [FBSD] [NBSD] [GL] [COS] [OBSD]
      │     │     │                       │      │     │    │
   (macOS) (Deb) (Fed)                 (And)  (QNX)  (SCO) (Tru)
      │
   (Ubu)

🐚 Shell and Terminal Frameworks

A Shell is a computer program that allows the user to interact with the operating system. It's like an interface between the user and the OS, kernel.
It enables users to execute commands, run programs, and manage system resources.

How it Works:

Input prompt ───► Command ───► Execution

📋 Types of Shells:

💻 Command-line Shells

Bash (Bourne Again Shell)
sh (Bourne Shell)
csh (C Shell)
zsh
PowerShell
ksh (Korn Shell)
Fish (Friendly Interactive Shell)
Tsh (T Shell)

Bash

🖼️ GUI Shells

Windows Shell
GNOME Shell (Linux)
KDE Plasma
macOS Finder

Windows PowerShell

GNOME Shell

🌐 Remote / Network Shells

Allow users to interact with a system over a network.

Types:*

SSH (Secure Shell) - Cryptographic network protocol used to securely access and manage remote computers, typically servers, over an unsecured network.

Telnet (Outdated)

SSH

📱 Mobile & Embedded Shells

Used in mobiles and embedded systems.
ADB shell - Android

ADB Shell

📝 Line Editor vs. Text Editor

Line Editor	Text Editor
- Text is edited line by line	- Text can be edited at once
- CLI	- GUI, interactive interface
- Challenging for users with no coding skill	- Suitable for all users
- ... Simultaneous	- Can edit multiple lines simultaneously
- Minimal resource usage	- Greater resource usage
- Used for embedded systems	- Used for programming, writing, general-purpose editing
- Examples: `ed`, `ex`	- Examples: VS Code, Notepad, Sublime Text, Vim, GNU Emacs

📊 Operating System Deployment & Design Models

An operating system can be designed differently depending on who is using it and what kind of computer it runs on.

Types of OS

Here are the core types:

Batch Processing OS: The oldest type of system where the computer collects similar data jobs into a "batch" and processes them all at once later without any human interaction.
Time-Sharing OS: Allows multiple users located at different terminals to share a single central computer's processor time simultaneously. The CPU switches between users so fast that everyone feels like they have their own dedicated computer. (Examples: UNIX, IBM VM/370).
Real-Time OS (RTOS): Built for environments where timing is everything. It must receive an input and guarantee a correct output within a strict, razor-thin time limit. (Examples: Systems inside automated factory machinery, rocket guidance systems, or medical equipment).
Multiuser OS: Designed to let multiple people log in, run programs, and access the computer's resources at the exact same time. All modern server operating systems fall into this category.
Multitasking OS: Allows a single user to run and switch between multiple different applications seamlessly at the same time (like listening to music while typing a document). This is managed using two scheduling strategies:

Pre-emptive Multitasking: The operating system acts as a strict boss, forcibly pausing programs when their time slice is up or when a higher-priority app needs to use the CPU.
Non Pre-emptive (Cooperative) Multitasking: Programs are on the "honor system." A program keeps control of the CPU for as long as it wants and must voluntarily release it to let the next application run. If one app freezes, the whole computer freezes.

🗄️ Specialized Computing Environments

Mainframe Computer: Massive, highly reliable computers used by large organizations (like banks, insurance companies, and scientific institutions) to safely process huge, bulk volumes of critical data transactions.

Single-User OS: Designed to easily manage a device for exactly one person at a time with no shared network user pipelines required. (Examples: MS-DOS, early mobile devices, or simple embedded microcontrollers).

⏱️ RTOS (Real-Time Operating System) Classifications

Hard RTOS: Strict time constraints for completing tasks
Soft RTOS: timeliness is not critical, allows small errors.

Hard RTOS	Soft RTOS
- Aerospace	- Smartphones
- Defense	- Cameras
- Automotive	- PCs
- Industrial automation	- Online games
	- Email systems
	- Digital audio systems

Single-user: handles 1 user at a time
Ex: VxWorks, QNX, Windows CE

🔀 OS Type Comparison

Comparison	Time-sharing	Real-time	Multiuser	Multitasking
Functionalities	- Allows multiple users to share CPU time, batch processes	- Ensures process execution in specific time intervals	- Allows multiple users to access single system.	- Allows multiple users to perform multiple tasks at same time.
	- Processes data as it comes in.	- Switches between tasks.	- Individual sessions for each user.	- Allocates CPU time to tasks using scheduling algorithms
Scheduling	- Priority-based	- Time-slicing	- User-specific	- Pre-emptive / non-pre-emptive
Advantages	- Efficient utilization of resources	- Very reliable & predictable	- Enhances collaborative workflows	- Enhances productivity
	- Allows for remote operation	- Continuous performance, no interruptions	- Improves resource sharing among users	- Reduces CPU idle time
	- Reduces CPU idle time	- Sticks to deadlines	- Good security & system monitoring mechanisms	- Background running of processes
	- Cost-effective	- Useful in embedded systems		- Smooth multi-tasking
	- Allows multiple users to work / access
Disadvantages	- Performance may degrade with system load	- Expensive in cost to maintain & develop	- More complex	- Performance can be hindered by many tasks
	- Security vulnerabilities due to resource sharing	- Limited flexibility in non-critical applications.	- May need high-end hardware	- Debugging is complex in inter-dependent tasks
	- Requires efficient scheduling to prevent conflicts	- For strict time-slices, higher costs required	- Security risks caused only by 1 user	- Resources can cause system delays or instability
	- Overhead of context switching	- Complex debugging & testing	- Performance can degrade with too many users
Examples	- UNIX	- Hard RTOS: VxWorks, FreeRTOS	- Windows Server	- Windows 10/11
	- Linux (multi-user mode)	- Soft RTOS: Windows CE, QNX	- Linux (multi user mode)	- macOS
	- Windows Server		- Unix	- Android
				- Linux (desktop distributions)
Reliability	High	Very high	High	Moderate - high

💿 System Installation and Virtualization

💿 OS Installation Types

Clean Installation:
Performed on system with no OS installed.
OS deleted and replaced with new OS. New OS installed on a different volume.
Upgrade Installation:
Computer already has OS installed, this is simply upgrading it to a newer version.

🛠️ Installation Procedure:

1. Gathering system information
2. Running Installation program
3. Determining which OS elements to be installed
4. Copying OS files to computer (unzip files)
5. Configuring devices & drivers
6. Restarting system and finalizing configuration of devices

🖥️ VT-x / Virtualization Technology

How it Works

Guest OS ---> Base / Host OS communication

🛠️ Verification & Installation Setup:

Open Terminal
Run systeminfo.exe
Check Hyper-V requirements (Hyper-Visor)
Virtualization Enabled - Yes/No

🪟 Enabling Virtualization in Windows:

Settings --> Updates and Security --> Restart Now --> Troubleshoot --> Advanced --> UEFI Firmware Setting --> Virtualization --> Enable

📦 Oracle VirtualBox Installation Guide (On Windows)

🚀 Phase I: Base OS Setup

Install Oracle Virtual Box, Ubuntu, Windows 10 ISO file (Disk image).
New --> Name: Ubuntu, Mac OS X, 64-bit
Settings: storage --> Choose a disk file --> Windows 10 ISO file
'Start' button

🖥️ Windows Setup Screen Navigation:

Lang - 'English'
'Install Now'
Activate Windows --> 'I don't have a product key'
'Windows 10 Home' --> Next
Accept Terms & Conditions --> 'Next'
Type of installation --> 'Custom install'
Where: Partition ('New') --> Don't partition --> 'Next'$ (10-15 mins)
Keyboard --> US Keyboard
Second Keyboard --> 'Skip'
Create Account --> Get a new email address --> outlook.com email --> country, birthdate, phone no.
Accept

🔌 Phase II: USB Drive / Flash Storage Setup

🧡 Guest Host Administration (Ubuntu Linux Baseline)

Free, open-source Linux distribution
Introduced in 2004 by Canonical
Operates smoothly on low-end devices
GUI - GNOME

⌨️ Essential Terminal Commands

Command	Description
`pwd`	Displays present working directory
`sudo apt`	Installs modules
`cd ~/Destination`	Navigates to destination/folder
`ls`	Lists directories in system
`uname -a`	Displays kernel version, architecture
`lscpu`	Displays CPU architecture
`cat /proc/cpuinfo`	Displays CPU details
`nproc`	Displays no. of processors in system

🔍 Checking System Information Tasks

1. OS Version Check:

Go to Settings --> About --> Operating System
Ver: Ubuntu 24.04.1 LTS

2. Kernel Version Check:

In Terminal, run 'uname -a'
Ver --> Linux

3. CPU Information Check:

terminal --> run 'cpu-info'
Intel 13th Gen Core i5-1335U

🖥️ System Settings & Verification (Ubuntu GUI)

📺 Display

Settings --> Displays
Landscape, Res: 1920 x 1080, Refresh rate: 120.02Hz, Scale: 100%

🔊 Sound

Settings --> Sound
Output: Speakers, Input: Internal Microphone

🧠 Virtual Memory

2 GB (2048 MB)

🌐 IP Address & Network Settings

Terminal
Run 'sudo apt install net-tools'
Run 'ifconfig'

enpls0: ether 0f:bf:1b:ba:9a:1a
lo: inet 127.0.0.1 netmask 255.0.0.0
wlp1s0: inet 192.168.102.218

<global>:
inet6 2401:4900:9024:6073:2fcd:8cd0:a0e6:c5a

To check utility tool version: 'ifconfig --version' --> net-tools 2.10

💾 Hardware Information

Memory Information: Settings --> System --> Memory --> Memory: 16.0 GiB
Disk usage: 0.8 GiB (Apparent size: 0.7 GiB)
BIOS Mode Check: UEFI / Terminal --> sudo systemctl reboot --firmware-setup

🪟 Windows 10 Virtual Machine (VM) Properties

OS Version: Windows 10 Home 22H2 Build: 19045.3803
System Name: DESKTOP-EJSNR19
CPU Information: 13th Gen Intel(R) Core(TM) i5-1335U 2.50 GHz
Installed RAM: 2.00 GB
Disk Image: OS (C:) --> 112.56 GB NTFS (Healthy) Usage: 5%
IP Address Configuration: IPv6: fd00::4bd5:69ad:2303:169b --> IPv4: 10.0.2.15
Graphics Card Adapter Type: Microsoft Basic Display Adapter
Keyboard layout: QWERTY
Pointing Device: no of buttons --> Mouse
BIOS Version: SMBIOS BIOS VERSION Virtual Box

🔌 Host Hardware & Peripheral Management

🛠️ Basic I/O Device Configuration Steps

Install device drivers
Connect input/output/storage device
Turn on device

🪟 Windows Driver Deployment Lifecycle

Automatic Driver Installation (Plug and Play - PnP): Automatically detects and installs drivers when user connects device

Windows Update (Online): download & install missing/updated drivers

Settings --> Update & Security --> Windows Update

Manual Installation via Device Manager:

Win + X --> Device Manager --> Locate device
Actions available: Update/roll back to earlier version, Disable device/Uninstall driver

🐧 Ubuntu Driver Deployment Lifecycle (Terminal)

ubuntu-drivers devices (list drivers)
sudo ubuntu-drivers autoinstall

🖥️ Device Manager Properties

Devices --> Properties --> Update Driver

⌨️ Input Devices & Peripherals

Common Examples:

Keyboard (USB-enabled, PS2-enabled)

Scanner (Flatbed, Handheld, Sheetfed, Drum, Photo)

Light pen

Remote

Webcam

OCR (Optical Character Recognition)

MICR (Magnetic Ink Recognition)

Mouse
Mechanical/Scroll
Optical
Wireless/Cordless (Bluetooth/Wi-Fi/IrDA (Infrared))

Joystick/Game controller/Gamepad

Joystick

Gamepad

Touch pad/screen

Biometric Devices

⚙️ Core Device / Peripheral Drivers

Mouse Device Driver: Actions are translated into digital signals understood by OS & applications. Ensures compatibility with OS & applications
Keyboard Driver: Converts keystrokes into digital signals, enables special keys

🖨️ Printers and Imaging Technology

Printer: Peripheral device
Printer Driver: Translates digital documents into device specific instructions

🔬 Common Printing Systems

Inkjet: liquid ink sprayed

Laser: powdered toner & laser

Multi-Function: print, scan, fax, copy (All-in-one)

Dot Matrix: print head moving back & forth, strikes inky ribbon on paper

Plotter: large vector graphics, architectural blueprints, maps, eng. designs

Label: printing adhesive labels & tags, thermal/inkjet technology

Line: prints content line by line - entire line at once

Thermal-wax transfer: Uses heat to transfer ink onto coated paper

Dye Sublimation: Uses heat to transfer dye onto plastic/card/paper/fabric. Solid dye is sublimated directly into gas without passing through liquid state.

3D: Fused Deposition Modeling, SLA-Stereolithography, SLS- Selective Laser Sintering

🔌 Display Adapters & Audio Processing

🖥️ Display Adapter

Graphics adapter / Graphics card / Video card / GPU
Converts data from CPU into visual output, rendering visuals
PC-Display adapter card, pixels - horizontal & vertical
Higher resolution requires larger monitor

Resolution units:

dots per inch (dpi) - printers
pixels per inch (ppi) - monitors
DVI (Digital Visual Interface): 1920 x 1200 - High-quality visual standard for LCD displays and digital projectors, TVs. - HDMI

🎵 Sound Card

Enables system to process & output audio signals.

Types:

Integrated sound card (motherboard)
Dedicated sound card (bus slot)

🗰 Local Storage Drive Initialization & File Systems

🔀 Memory Classifications

Volatile (temporary): RAM
Non-volatile (permanent): ROM, SSD, HDDs, USBs, CD/DVDs

💾 Hardware Storage Devices / Peripherals

HDD: Bulk storage, has spinning magnetic disks

SSD: Flash memory (no moving parts)

USB: Uses flash memory

CD/DVD: Optical storage

Magnetic tape: large-scale data backup / archival storage

📥 Storage Block Allocation Mapping

Uses: OS Files, User apps, User documents, Virtual memory, Log files, Virtual machines, Database storage

🛰️ Enterprise Storage Access Methodologies

Local Storage: Internal (SSD/Hard drive), External (USB / Hard disk)
Direct-attached storage (DAS): Connected to computer without network
Network-attached storage (NAS): Device, Network-connected
Storage area network (SAN): Connects multiple storage devices to multiple servers
Technologies: Fibre channel

🛠️ Local Drive Initialization Protocol (Hard Drive / SSD Setup)

1. Connect disk - Install inside computer
2. Initialize disk - OS detects disk
3. Partitioning (volume)
4. Formatting (File systems - NTFS/FAT32 to make disk usable)
5. Assign a drive letter (ex: C:, D:) - by system

Disk capacity flags: B, KB, MB, GB, TB, PB (Petabyte)
Disk speed: RPM (Revolutions per minute)

🔌 Storage & File System Interfaces

⛓️ Hardware Connection Interfaces

SATA (Serial Advanced Technology Attachment)
SAS (Serial Attached SCSI)
SCSI (Small computer system Interface)
SATA: To connect HDDs/SSDs to computer
SAS: To connect hard drives to computer, in server / enterprise networks / systems
SCSI: Similar to SAS, predecessor, up to 6 Gb/s

📂 File System Principles

Used by OS to organize, store, retrieve, manage data on storage devices.

🛠️ Core Administrative Functions

File Organization - Into directories
File Naming
File Access Control - r, w, x (execution)
Data Integrity & Security
File Retrieval / Deletion
File Backup / Recovery
Path syntax: Ex: C:/folder/filename

🗺️ Default OS File System Matrix

Operating System	Native File System Default	External Storage Default
Windows	NTFS	USB Drives --> FAT32 / exFAT
Linux	EXT	Memory cards --> External storage
macOS	APFS (Apple File System)

📂 File System Interfaces & Structures

👥 User Navigation Platforms

GUI
CLI
API (programmatically). Ex: Windows API, POSIX API (Linux), Java File API

🌿 Directory Structure Path Formats

Linux Structure: Root / Dir / Subdir / File path
Windows Structure: C: Root \ Dir \ subdir \ File path

💾 File System Formats / Architectures

🪟 Windows Formats

FAT32 & exFAT (FAT64): File Allocation Table
NTFS: New Technology File system
ReFS: Resilient File System (large scale)
CDFS: Compact Disc File System (CD-ROMs)
UDF: Universal Disk Format (DVDs, Blu-ray)

🐧 Linux Formats

EXT: Extended File System (EXT2, EXT3, EXT4)
EXT4: Ubuntu, Fedora, Debian - upto 16TB files, 1EB volumes

🧰 Drive Mounting & Permission Architecture

🧭 Media Volume Mounting Protocols

Mounting: making storage devices accessible to the OS / mounting to folder

Command syntax: * sudo mount /device/xyz /folder

Unmounting: Removing file system, ejecting safely

Linux Command: * sudo umount /folder
Windows Action: "Safely Remove Hardware"

🔒 Linux File Access Permissions Configuration

Linux: sudo chmod 1/2/3/4/5/6/7/0

🔢 Absolute Access Settings (Octal Mode Representation)

Octal	Absolute Permissions Name
0	None
1	Execute (x)
2	Write
3	Write & Execute
4	Read
5	Read & Execute
6	Read & Write
7	All

🔣 Relative Permissions Adjustments (Symbolic Mode Representation)

Target Identity Scopes: user (u), group (g), others (o), All (a)
Operator Flag Controls:
+ adds privilege
- removes privilege
= reassigns only specified

📝 Concrete CLI File Configuration Examples

Ex: chmod 142 filepath (ugo)
Ex: sudo chmod u+x filename (user execute)
Create file: gedit filename
Compile file: gcc filename
Run file: ./a.out

👥 Host Accounts & Directory Services

🔑 User Accounts Primary Profiles

Authentication Tokens: Passwords (login / identity verification), PINs, Biometrics, multi-factor authentication (MFA)
Personal & system-related details registry: username & password, Full name, Email address, User role (Admin, Standard, Guest), Permissions & Access Rights
User Directories Engines:
Active Directory - Windows
Lightweight Directory Access Protocol - Linux

👥 Group Accounts Core Tasks

Group of user accounts sharing access permissions / rights.
simplifies permission management
Improves security & access control, security policies
Enhances efficiency in managing resources.

📊 Structural Profile Differences Matrix

Feature Check	User Account	Group Account
Definition	Represents 1 user in network	Represents collection of users
Purpose	Allows users to authenticate & access resources	Helps manage permissions for multiple users
Permissions	Assigned to single user	Assigned to multiple users
Examples	"UserName", "Riya H"	"G_Dept"
Management Complexity	Difficult when managing multiple user accounts	Easier to manage

🔒 Security Policies & Password Conventions

Consistent scheme
Character limits
Real name / cryptic Name (random characters)
Special characters (., _)
Some OSs are case-sensitive
Admins may use dictionary attacks to test password strength

🗃️ Built-in Accounts Available in Windows System:

Administrator Account
Guest Account (Deprecated)
Microsoft Account
Local Account (Offline)
Work or school Account (Managed by IT administrators)

🐧 Terminal User & Group Administration (Linux)

👤 Creating User Accounts

useradd / adduser command
sudo useradd username --> asks for full name, password, no.s, Other
sudo adduser username

🛡️ Verify and Audit Accounts

id username
cat /etc/passwd
View all user names: cut -d: -f1 /etc/passwd

👥 Creating Groups

List groups: getent group
sudo groupadd name
sudo usermod --append --groups testgroup testuser

👥 View user names excluding system users

awk -F':' '$3>=1000 {print $1}' /etc/passwd
Output baseline entries: nobody, user1, user2... etc.

🚫 Remove user account forcefully

pkill -u username
userdel -r username

🔍 Check currently logged-in users

who
w

📊 Host Health Audits & Maintenance Routine Automation

Tracking the state of system's resources, and performance.
Like CPU, memory, disk, network - over time
Continuous checking of system metrics and ensuring the system is running smoothly.

🎯 Key Administrative Purposes:

Detect issues early on
Understand system behavior (usage patterns)
Ensure system uptime & availability
Capacity planning

🐧 Linux Execution Tool Ecosystem:

top
htop
Target Zombie processes check syntax: ps aux | grep Z or top -b n1 | grep zombie

🔍 Standard `top` Shell Output Data Map

top - 15:43:06 up 4:03, 1 user, load average: 0.27, 0.43, 0.61
Tasks: 320 total, 1 running, 321 sleeping, 0 stopped, 0 zombie
%Cpu(s): 0.4 us, 0.9 sy, 0.0 ni, 98.9 id, 0.1 wa (waiting), 0.0 hi (h.interr), 0.0 si (s.interr), 0.0 st
MiB Mem: 15677.2 total, 10885.2 free, 3068.1 used, 2464.6 buff/cache
MiB Swap: 4096.0 total, 4096.0 free, 0.0 used, 12509.1 avail Mem

PID	USER	PR	NI	VIRT (Virtual mem)	RES	SHR (Shared mem)	S (Sleep)	%CPU	%MEM	TIME+	COMMAND
975	root	20	0	117284	30948	11540	S	3.7	0.2		COMMAND

🎨 Standard `htop` Interface Visual Rules

Green Color Line flag: user processes
Orange Color Line flag: cache memory parameters
Blue Color Line flag: low priority processes
Memory Bar Gauge Output: Mem[||||||........... 2.30G/15.3G]
Swap Space Bar Gauge Output: Swp[||||||........... 0K/4.00G]

🧠 Dedicated Resource Monitoring Targets

1. System Memory Verification Commands:

free (free -h) --> (h --> human-readable format)
vmstat (virtual memory statistics)
htop

            🔄 [RAM Swapping Core Cycles]
          ┌───────────────────────────────┐
          ▼                               │
 💾 [Secondary Memory] ◄───swap out─── [Main Memory RAM (Full)]

2. Local Disk Operations Verification Commands:

df (disk free) --> Ex: etwfs Size: 438K, Used: 209K, Use%: 49%
du (disk usage) --> du -sh (Summary) --> Ex: 12 G
iostat (I/O stats)
I/O Definition: maps out how fast system disk blocks execute read/write performance

3. Live Network Interface Traffic Verification Commands:

tracks incoming / outgoing data & traffic
nload
netstat -tuln (stats)
ss -tuln (stats)
Provides explicit data metrics details covering: bandwidth usage, line latency (time delay), packet loss, low bandwidth issues, data congestion bottleneck points, firewall/filter block errors, hardware connection faults.

Command: `nload`

Incoming: Total data flow rate (TTL)
Outgoing: Total data flow rate (TTL)
Audit TCP connections parameters: netstat -ant
Audit UDP connections parameters: netstat -anu

4. System Process Control Tasks:

ps
top
htop

🏎️ Performance Tuning

🛠️ Optimization Domains

CPU tuning: Adjusting process priorities, managing cores, and scheduling behaviors.
Memory tuning: Customizing cache boundaries and minimizing data paging constraints.
Disk tuning (I/O optimization): Optimizing queue sizes and block behaviors for faster reads/writes.
Network tuning: Modifying buffering schemas and network behaviors.
Essential validation diagnostics commands: netstat, ping
Primary system administration goal: Avoid dropped packets

🗄️ Backup & Recovery Procedures

🧩 Core Definitions

Backup: The process of copying and safely storing operational data assets on an alternative volume or system.
Recovery: Restoring data blocks from a saved backup destination back to their original or a designated new operating location.

🎯 Purpose / Tasks

Prevents absolute data loss resulting from runtime directory corruption, accidental deletion, or malicious attacks.
Enables robust recovery from fatal system crashes and large-scale environmental infrastructure disasters.

🔀 Standard Enterprise Backup Formats

Full file-by-file Backup: Traditional mechanism where every single operational asset is individually copied.
Incremental Backup: Captures only the absolute changes or new records created since the most recent backup operation of any type.
Differential Backup: Captures all changes made since the last Full backup, regardless of whether other intermediary backups were performed.
Binary Backup: Clones the entire targeted disk array or logical volume partition structure at a low block level.

📊 Comparison of Execution Models

Scenario A: Incremental Backup Lifespan

Monday (Full Backup Base): Saves baseline files A, B, C
Tuesday: User writes new database segment D --> Backup captures: D
Wednesday: User writes new schema script E --> Backup captures: E
Disaster Recovery Process: To restore Wednesday's state, the administrator must deploy:

Restore Sequence = Monday Full + Tuesday (D) + Wednesday (E) + Thursday (F)

Scenario B: Differential Backup Lifespan

Monday (Full Backup Base): Saves baseline files A, B, C
Tuesday: User creates asset D --> Backup captures: D
Wednesday: User creates asset E --> Backup captures accumulated changes: D + E
Thursday: User creates asset F --> Backup captures accumulated changes: D + E + F
Disaster Recovery Process: To restore Thursday's state, the administrator needs only the original baseline and the final differential file:

Restore Sequence = Monday Full Backup + Thursday Full Differential Backup

🌐 Backup Storage Deployments

Local backup: Stored on the same physical server array or attached via a local external drive.
Remote backup: Transferred to a separate physical facility or remote data center server (Significantly safer profile).
Cloud backup: Handed off directly to public/private cloud storage spaces.
Hybrid backup: Blends local on-premise appliances directly with off-site cloud storage networks.

⚙️ Administrative Configuration Checklists

Frequency: Standard operational interval definitions.
Encryption Layer Profiles: High-security transmission and rest controls (e.g., SFTP, HTTPS).

🔄 Recovery Procedures Lifespan

Identify exact datasets to be recovered.
Select the optimal clean backup target.
Perform the automated directory/volume restore.
Verify recovery integrity and validate system state.

🛡️ Security & Patch Management

🗂️ Core Security Classification Framework

                       🛡️ [Security Architecture]
                      /        /        \        \
         🟢 Network         🔵 System    🟣 App     🟡 Info
        /    │    \         /    \        /    \    /   │   \
     [FW]  [AV]  [VPN]    [AC]  [SB]   [CP] [Auth] [C] [I]  [A]

🩹 Patch Management

Definition: The programmatic workflow used to identify, acquire, test, validate, and install software updates or modifications ("patches") across system infrastructure.

🎯 Strategic System Aims

Resolves software bugs and stability glitches.
Mitigates discovered security vulnerabilities.
Improves overall system performance.
Ensures hardware/software compatibility with newly deployed enterprise technologies.
Maintains systemic long-term platform stability.

🔀 Common Software Patch Designations

Security patch: Target fixes specifically built to eliminate known system vulnerabilities.
Bug fix: Code updates deployed to resolve operational logic glitches (such as random crashes).
Feature update: Adds new tools or expands user software capabilities.
Performance patch: Speeds up system processes and optimizes memory footprints.
Cumulative patch: A consolidated bundle containing multiple historical updates, hot fixes, and security adjustments.

🤖 Automating Administrative Tasks with Scripts

Automating repetitive administration profiles across enterprise infrastructures relies primarily on Bash scripting for Linux environments and PowerShell scripting for Windows platforms.

📋 Common Automation Task Domains

User account provisioning and group access management.
File tracking, batch renaming, and data maintenance routines.
Scheduled resource checks and performance metrics tracking.
Automated software installations and system patch updates.
Log rotation, parsing, and diagnostic reporting.
Automated scheduling of batch jobs and backups.

🐧 1. Bash Script Execution (Linux Ecosystem)

Create new script file: gedit filename.sh

#!/bin/bash
# High-level script structure baseline sample entry
echo "Hello"
echo "Date:"
date # Alternative programmatic query format: $(date)

Grant execution privileges: chmod +x filename.sh
Run script: ./welcome.sh

🛠️ Handy Bash Automation Snippets

Create a folder structure: mkdir "Folder Name"
Perform safe automated updates: sudo apt update && sudo apt upgrade -y

🪟 2. PowerShell Script Execution (Windows Ecosystem)

Automated folder creation command path:

New-Item -Path "C:\Users\Name\Desktop\folder1" -ItemType Directory

Run selected script file inside environment: Press F5 key within the execution terminal wrapper interface.

🌐 Part 2: Networking Concepts, Topologies, and Protocols

📡 Networking Essentials and Components

A computer network is a system of connected devices that can communicate, share data, and share hardware or software resources. Devices can be linked wirelessly or with physical wires. In most setups, each device on the network is assigned a unique network address and a hostname to identify it.

🗺️ Network Infrastructure Hardware Components

Nodes: Any terminal or device connected directly to a network (such as PCs, laptops, or smartphones).

Router: A specialized routing device that connects your localized home or office network to the external internet.

Switch: A smart central connection point that links individual devices together within the same Local Area Network (LAN).

Hub: An older, legacy device that connects multiple devices together in a LAN. Unlike a switch, a hub does not target specific data paths; any information received is indiscriminately broadcast to every single connected device.

Modem: Short for modulator-demodulator. This hardware converts incoming analog signals from your service provider line into digital data your computer can understand, and vice versa.

Access Point: A Wireless Access Point (WAP) that broadcasts wireless signals, allowing Wi-Fi-enabled devices to connect to a physical, wired network grid.

Cables & Wireless Media: The physical transmission pathways (like fiber optic wires or radio frequencies) that data travels along.

NIC (Network Interface Card): The internal hardware component that physically allows a computer to connect to a network. They can be built directly onto the motherboard or added externally via USB or expansion slots (such as a Wi-Fi adapter card).

🔀 Network Types / Classifications

PAN (Personal Area Network): Used for localized, personal devices like pairing a phone to a headset via Bluetooth, Infrared (IrDA), or Zigbee. Usually scales up to 100 meters.

⌚ Smartwatch
             ^
             |  (Bluetooth)
  🎧 -------- 💻 -------- 📱
Headphones  Laptop   Smartphone

LAN (Local Area Network): Built across a single building, home, or office using Wi-Fi or Ethernet cables. Scales up to 2 kilometers, offering high speeds but requiring localized hardware maintenance.

🌐 Router / Switch
         /        |        \
        /         |         \
      💻         🖥️         🖨️
    Laptop     Desktop    Printer

MAN (Metropolitan Area Network): Spans across an entire city or town. It connects multiple smaller LANs together using high-speed transmission standards like FDDI, CDDI, or ATM. Scales from 5 to 50 kilometers at speeds of 10 to 100 Mbps.

     🏢 Central Building
          /       \
         /         \
   🏦 Block A     🏦 Block B

WAN (Wide Area Network): Covers vast geographical distances spanning across countries or the entire globe using leased telecom lines, dial-up, or satellite networks. The public internet is the largest example of a WAN, scaling well beyond 50 kilometers.

   🇺🇸 Office (NY)          🇬🇧 Office (London)
           \                   /
            \       ☁️        /
             ---- Internet ----
            /                  \
           /                    \
🇯🇵 Office (Tokyo)          🇦🇺 Office (Sydney)

📡 WAN Communication Channels:

Satellite <─────────────────> Base station / Ground

#### 🧪 Standard Protocol Profiles:

* **FDDI**: Fiber Distributed Data Interface
* **CDDI**: Copper Distributed Data Interface
* **ATM**: Asynchronous Transfer Mode

🔗 Structural Device Connectivity Topologies

                     🔌 [Network Switch]
                    /                   \
                   ▼                     ▼
          💻 [Target Node D1]   💻 [Target Node D2]

                        🔌 [Network Hub]
                       /    /     \    \
                      ▼    ▼       ▼    ▼
                    [D1] [D2]     [D3] [D4]

📡 Fundamentals of Data Communication Channel Engineering

Data communication relies on a structured baseline pipeline to move information from one point to another safely.

🧩 Core Infrastructure Components:

Sender: The source device that creates and transmits the data message.
Receiver: The destination device intended to receive the data message.
Message: The actual data asset, text, file, or information being sent.
Medium: The physical or wireless transmission path the message travels along.
Protocol: The standardized set of rules and communication rulebooks that both the sender and receiver must agree on to decode the message properly.

Sender (Protocol) ─────── Message / Medium ───────► Receiver (Protocol)

🗲 Primary Wired Cable Mediums

UTP (Unshielded Twisted Pair): Copper wires twisted around each other to reduce electrical interference. Very common in everyday office Ethernet networks.
STP (Shielded Twisted Pair): Similar to UTP, but wrapped in a protective foil shield to guard against heavy external magnetic or electrical interference.
Coaxial Cable: A central copper conductor surrounded by plastic and braided metal shields. Commonly used for cable TV and high-speed broadband lines.
Fiber Optic Cable: Ultra-thin strands of glass or plastic that transmit data as pulses of light. It is incredibly fast and immune to electrical interference, making it the backbone of long-distance internet grids.

📶 Primary Wireless Connectivity Methods

Wi-Fi: Uses radio waves (802.11 standards) to provide high-speed local internet access.
Bluetooth: Low-power, short-range wireless connections for personal accessories.
IR (Infrared): Line-of-sight light communication commonly found in TV remote controls.
Zigbee: A low-power mesh network protocol heavily used in smart home automated sensors.
NFC (Near Field Communication): Ultra-short range proximity connection used for tap-to-pay systems.
Satellite Communication: Long-distance microwave signals bounced off orbit stations down to ground bases.
Cellular/Mobile Networks: Carrier data grids (like 4G or 5G) distributed through cell tower regions.

🔀 Data Flow Transmission Modes

📻 1. Simplex - 1-way

Data flows strictly in one direction only. The receiver cannot talk back to the sender.

 📱 [Device 1] ───────── Unidirectional Flow Only ─────────► 📺 [Device 2] (📻 Radio)

🗣️ 2. Half-duplex - 2-way, alternate timing

Data can flow in both directions, but not at the exact same time. Devices must take turns transmitting.

 📱 [Device 1] ═════════ ⏳ Time Slice A ═════════════════► 📱 [Device 2] (📳 Walkie-Talkie)
 📱 [Device 1] ◄───────── ⏳ Time Slice B ───────────────── 📱 [Device 2]

📱 3. Full-duplex - 2-way, simultaneous

Data flows in both directions at the exact same time over concurrent transmission streams.

 📱 [Device 1] ◄═════════ 🔄 Simultaneous Streams ═════════► 📱 [Device 2] (📞 Smartphone)

🥞 Network Layer Architecture Approaches

To make sure data moves smoothly between different computer manufacturers, networks rely on layered architectures. The OSI Model provides a 7-layer theoretical framework to understand network concepts, while the TCP/IP Model condenses this into a practical 4-layer stack used by the real-world internet.

🗺️ OSI Framework / Model

OSI Layer	Protocol / Functional Scope
Application	- HTTP/HTTPS/FTP/EMAIL (User interaction) / IMAP (Internet Msg Access) - Simple Mail Transfer Protocol (SMTP)
Presentation	- Security (enc/dec)
Session	- Creating session
Transport	- TCP/UDP (User Datagram Protocol - faster, less reliable)
Network	- IP (best route)
Data	- Errors detected & corrected (Merged as Network Access in TCP/IP)
Physical	- 0/1 (bits) (Merged as Network Access in TCP/IP)

🔄 TCP/IP Framework / Model

   🧑‍💻 [Sender Node Stack]                  🧑‍ [Receiver Node Stack]
  ┌──────────────────────┐             ┌──────────────────────┐
  │  Application Layer   │             │  Application Layer   │
  └──────────┬───────────┘             └──────────▲───────────┘
             │                                    │
             ▼                                    │
  ┌──────────────────────┐             ┌──────────────────────┐
  │   Transport Layer    │             │   Transport Layer    │
  └──────────┬───────────┘             └──────────▲───────────┘
             │
             ▼                                    │
  ┌──────────────────────┐             ┌──────────────────────┐
  │    Internet Layer    │ ──(IP/ICMP)─►   Internet Layer    │
  └──────────┬───────────┘             └──────────▲───────────┘
             │                                    │
             ▼                                    │
  ┌──────────────────────┐             ┌──────────────────────┐
  │ Network Access Layer │ ───(MAC)────► Network Access Layer │
  └──────────┬───────────┘             └──────────────────────┘
             │
             ▼
   🔌 [Cables / Wireless Transmission Lines]

🌐 Network Routing and IP Address Architectures

An IP (Internet Protocol) address is a unique identifier assigned to every device on a network so routers know exactly where to send data pack assets.

IPv4 Addressing

IPv4 addresses use a 32-bit format broken down into four 8-bit numbers (octets) separated by dots. It can be viewed in dotted decimal format or computer binary code.

Decimal (Standard) Format: 120.35.62.10
Dotted Decimal to Binary Map: 01111000.00100011.00111110.00001010

Custom Port Sub-notation: To pinpoint a specific software application on a server, a port number is tacked onto the end using a colon (e.g., :54).

Example: 128.11.3.31:54
Base IP Address Binary Mapping: 10000000.00001011.00000011.00011111

📊 Standard IPv4 Class Allocation Table

IP Classes	Starting Address	Ending Address	Marking	Type Schema
Class A	`0.0.0.0`	`127.255.255.255`	8 (/8)	N.H.H.H
Class B	`128.0.0.0`	`191.255.255.255`	16 (/16)	N.N.H.H
Class C	`192.0.0.0`	`223.255.255.255`	24 (/24)	N.N.N.H
Class D	`234.0.0.0`	`239.255.255.255`	Undefined	Multicast
Class E	`240.0.0.0`	`255.255.255.255`	Undefined	Experimental

IPv6 / New Generation Addressing

Because the world ran out of unique IPv4 addresses, IPv6 was introduced. It uses a 128-bit structure written in hexadecimal blocks separated by colons, providing an almost infinite number of unique addresses.

Example: 2000:FE11:2222:83A3:0000:0000:0001:1111

🧩 IP Address Sections / Division

Every IP address is divided into 2 distinct sections:

Network Address: The common prefix identifying the specific network group the device belongs to.
Host Address: The unique sequence identifying that specific individual device within the network group.

Subnet Mask: A mathematical sequence of numbers used by systems to figure out exactly where the network section ends and where the host section begins.

Example: With an IP of 192.168.1.100 and a Subnet Mask of 255.255.255.0, the system knows: 192.168.1 is the network portion, and .100 identifies the specific machine.

✂️ Intermediate Infrastructure Routing: Gateways & Allocations

📡 Subnets & Subnet Domain Mechanics

A subnet is created by slicing a large, single broadcast network into smaller, isolated sub-networks. This improves security, helps route data traffic more efficiently, and stops network slowdowns by keeping broadcast traffic confined to smaller groups.

🚪 Network Gateways

A gateway is a specialized network node or device that serves as the mandatory entry-exit checkpoint between two completely separate networks running on different communication rules.

Gateways read network traffic, translate protocols between mismatched network frameworks, monitor packet routes, and keep internal networks safe from outside threats.

 🌐 [Local Network N1] ───► 🚪 [Gateway Core Node] ───► ☁️ [Public Internet N3]

🔄 System Working Step Lifecycle:

The gateway intercepts data leaving your local computer.
It analyzes the destination routing header.
It converts the packet data format to match the target network's protocol rulebook.
It safely forwards the translated data across the public internet boundary.

Computer ───► Gateway ───► Internet

⚖️ Gateway Deployment Trade-offs

Advantages: High levels of system security, traffic filtering, and protocol translation compatibility.
Disadvantages: High deployment costs, configuration complexity, and slight network delays caused by real-time data translation overhead.

🛠️ IP Allocation Methods: Static vs. Dynamic

🔒 Static IP - Fixed Configuration

An IP address that is manually locked into a machine's settings and never changes unless manually altered by an administrator or internet provider.

 💻 [Workstation Node] ◄══ Continuous Fixed Address ══► 🖥️ [Web Server Host]

Primary Uses: Hosting public web servers, secure corporate VPN lines, or remote access setups like security CCTV grids.

🔄 Dynamic IP - Rotated Leasing

An IP address that is automatically assigned to a device on a temporary lease by a DHCP (Dynamic Host Configuration Protocol) server. The address can change every time the machine connects to the network.

  PC <───────────> DHCP Server
  PC <───────────> Web Server

Primary Uses: Standard consumer smartphones, household smart devices, and daily office workstations.

🕸️ Network Topologies

A topology is the physical or logical arrangement layout mapping out how different nodes and computer devices link together.

🚌 1. Bus Topology

All devices connect down to a single, shared central cable called the backbone or "bus line."

             D      D      D      D
             │      │      │      │
Signal ──► ──┴──────┴──────┴──────┴──
             │      │      │      │
             D      D      D      D

💡 Note: Data travels down the wire to everyone, but only the node with the matching target address will accept the packet.

Advantages: Simple to set up in small environments, cost-effective, and uses minimal cabling.
Disadvantages: Data travels in one direction only. If the main central backbone cable breaks, the entire network crashes completely.

⭕ 2. Ring Topology

Every device links to exactly two neighbors, creating a continuous, closed circular loop path. Data moves around the ring in one or two directions using specialized tokens.

         O ─── O
       /         \
      O           O
       \         /
         O ─── O

Advantages: Orderly data flow with zero packet collisions, cheap to run, and highly performant under specific structures.
Disadvantages: Adding or moving a device requires shutting down the whole loop. If a single machine breaks down, it breaks the chain and kills the network.

⭐ 3. Star Topology

The modern standard layout where every individual node plugs directly into one smart central device, like an Ethernet switch or hub. It is heavily utilized inside offices, homes, airports, and banks.

Advantages: Extremely easy to expand and install. If one workstation cable breaks, only that single computer disconnects; the rest of the network keeps running completely fine.
Disadvantages: Completely dependent on the center machine. If the central switch or hub breaks down, the entire network goes dark.

🌿 4. Tree Topology

A hierarchical design that combines star networks together, linking them up to a central master root controller like branches on a tree.

                       🌳 [Root Node]
                      /              \
                     /                \
             🌿 [Branch 1]         🌿 [Branch 2]
             /           \         /           \
         🍃 [Leaf]   Leaf [🍃] 🍃 [Leaf]   Leaf [🍃]

Advantages: Excellent tracking and error isolation. If one leaf node branch fails, the other branches continue operating. Highly scalable.
Disadvantages: Heavily cabled and maintenance becomes very difficult as the tree structure grows larger.

🕸️ 5. Mesh Topology

A fully redundant design where every device is explicitly connected to multiple other devices on the grid, ensuring alternative routes are always available. It is heavily deployed across long-distance carrier pipelines.

                D ─────── D
               / \       / \
              /   \     /   \
             D ────*───*──── D
              \   /     \   /
               \ /       \ /
                D ─────── D

Advantages: Exceptional fault-tolerance and privacy. If one data line goes down, routers instantly send information through a different path.
Disadvantages: Massive cabling requirements and extreme installation and hardware setup costs.

🔀 6. Hybrid Topology

A custom layout created by blending two or more of the classic topologies together to match an organization's specific spatial layout needs.

               D       D
               │       │
         ──────┴───────┴──────
         │                   │
       (Hub)             (Ring Node)
      /  │  \           /           \
     D   D   D     (Ring Node) ── (Ring Node)

🛠️ Practical Network Interface Configurations & Resource Sharing

🛠️ Configuring Network Interfaces

A network interface serves as the literal bridge where a computer hooks into a network. It combines your physical NIC hardware with software driver components to manage the Physical and Data Link operations of the system.

⚙️ Mandatory IPv4 Addressing Prerequisites:

IP Address: The unique identity label for your machine on that network.
Subnet Mask: Defines the network size boundary rules.
Default Gateway: The IP address of your router (mandatory for your computer to find paths out to the internet).
DNS Servers: Domain Name System records used to translate text web names into system numbers.

🪟 Interface Connections Management in Windows

Running the shortcut command ncpa.cpl via the Win + R prompt opens the Network Connections pane instantly to manage adapters.
Command Prompt Wireless Connection Management: Administrators can audit local wireless connections using terminal queries:
netsh wlan show networks (Lists available local Wi-Fi nodes).
netsh wlan connect name="TargetName" (Triggers automated terminal network login).

🐧 Interface Connections Management in Ubuntu

Managed easily through the standard native System Network Settings GUI panel.

📂 File and Resource Sharing

Sharing resources allows companies to dramatically reduce equipment expenses, centralize backup security routines, streamline collaboration, and manage user growth effectively.

🌐 Industry File Sharing Network Protocols

SMB (Server Message Block): The default cross-platform protocol choice across Windows, Linux, and macOS systems.
NFS (Network File System): The high-speed native file-sharing standard choice across UNIX and Linux enterprise server environments.

🖨️ Printer Sharing Architecture & Protocols

Network printing requires a physical print device, a software printer representation inside the OS control panel, a print server to manage incoming document jobs, and a print queue to store pending files.

SMB Protocol: Handles standard Windows-to-Windows client print traffic pipelines.
Linux Printing Protocols:
LPD/LPR: An older, legacy line-printing protocol system.
CUPS (Common UNIX Printing System): The modern Linux system standard built on top of the HTTP-based Internet Printing Protocol (IPP).
IPP System Capabilities: Allows network print software to safely pass data via web encryption paths to check paper levels, audit ongoing job progress, or pause and cancel printing tasks remotely.

🏁 Conclusion

Ultimately, system and network administration serve as the unseen bedrock of modern digital infrastructure.

From managing low-level CPU time slices and file system architectures on individual machines to routing global traffic through complex network topologies, these foundational practices keep the modern world connected and stable.

By mastering hardware resource allocation, configuring resilient communication protocols, and executing protective measures like patch management and task automation, administrators transform raw computational power into secure, efficient, and highly dependable enterprise platforms.

🔁 What is Block-Oriented Network Simulator (BONeS)?

Riya Halbhavi — Thu, 18 Jun 2026 13:54:57 +0000

📜 In the 1990s, before many modern networking tools existed, engineers were already using a graphical software environment called Block-Oriented Network Simulator (BONeS)– for the modeling and discrete-event simulation of communication systems and computer networks.

Originally developed by COMDISCO Systems, it provided an intuitive, block-based approach to simulating complex network topologies and protocols.

🔶 Graphical / Visual-Based Approach

Instead of describing a network entirely through code, systems were built visually using interconnected functional blocks representing components such as:
• Traffic sources
• Communication channels
• Queues and buffers
• Protocol layers
• Physical network hardware

The idea was hierarchical modeling – A high-level network topology could be decomposed into smaller subsystems, and those subsystems could be further broken down into lower-level components. This allowed engineers to study complex communication systems while maintaining a clear view of the overall architecture.

🎯 Its Specialty

What makes BONeS particularly interesting is that it combined:
✓ Graphical system design
✓ Discrete-event simulation
✓ Performance analysis of communication networks

This enabled analysis of network behavior, protocol efficiency, congestion, queuing delays, and resource utilization long before cloud-scale infrastructure became commonplace.

🚀 Impact on Modern Networking Software

While BONeS itself is now largely a legacy tool, the underlying philosophy remains very relevant today.

🖥️ Modern examples include:
• Cisco Packet Tracer – graphical network construction and experimentation (Very popular)
• OMNeT++ – component-based discrete-event network simulation
• SimBricks – composable simulation for hardware-software and network co-design

💡 One lesson that still applies today:

When designing distributed systems, communication architectures, or edge networks, visual decomposition of a system into interacting components can often reveal bottlenecks and design flaws much earlier than implementation alone.

Sometimes the best way to understand a complex system is to model it as a collection of simpler building blocks.

🔎 Resources / Research Papers to check out

There isn't much publicly available information about BONeS outside those research papers, so I put together what I could find in this post.