Forem: Kervie Sazon

Git & GitHub Notes - Part 3: Undoing Changes & Forking

Kervie Sazon — Thu, 12 Mar 2026 14:19:04 +0000

Undoing Changes

git reset
This command allows you to move the HEAD (current commit pointer) to a previous commit.

`git log`

Before undoing commits, it’s useful to see the commit history.

Example Output:

commit d00cb3c91f942a4aa10c3d14e2428344e670e9d5 (HEAD -> testing-lang)
Author: Kervie Jay <166139157+kervieszn14@users.noreply.github.com>
Date:   Fri Mar 6 09:23:19 2026 +0800

    Update README.md

commit 896d60f6a6f5f695da06349bed40f530bf083413
Author: Kervie Jay <166139157+kervieszn14@users.noreply.github.com>
Date:   Fri Mar 6 09:21:59 2026 +0800

    README.md

commit 389969f59a98fe3496660f59a301f8ded48a74fb
Author: Kervie Jay <166139157+kervieszn14@users.noreply.github.com>
Date:   Fri Mar 6 09:20:26 2026 +0800

Each commit has a unique commit hash which can be used to reset to a specific commit.

`git reset HEAD~1`

This command moves the repository one commit back.

Meaning:

HEAD - current commit
~1 - one commit before the current commit

This removes the latest commit but keeps the changes in working directory so you can edit them again.

`git reset <hash>`

Used to reset a specific commit using its commit hash.

Example

git reset d00cb3c91f942a4aa10c3d14e2428344e670e9d5

This moves the project back to that commit.
Use git log to find the commit hash.

`git reset --hard <hash>`

This command resets the repository completely to a previous commit.

Example

git reset d00cb3c91f942a4aa10c3d14e2428344e670e9d5

Important:

This will:

Remove commits after the selected commit
Delete changes in the working directory

Forking a Repository

Forking is a feature on GitHub that allows you to create a copy of someone else's repository under your own GitHub account.

After forking, you can clone your fork to your local machine.

Example:

git clone https://github.com/yourusername/project-name.git

Then you can make changes and commit them normally.

Example workflow:

git add .
git commit -m "Improve documentation"
git push

This pushes the changes to your forked repository.

Creating a Pull Request

After editing your fork, you can submit your changes back to the original project using a Pull Request (PR).

A Pull Request allows the original repository owner to:

Review your changes
Discuss improvements
Merge your contribution

Steps:

Push changes to your fork
Go to your forked repository on GitHub
Click Compare & Pull Request
Add a description
Submit the Pull Request

Command	Purpose
`git log`	View commit history
`git reset`	Move to a previous commit
`git reset HEAD~1`.	Undo the last commit
`git reset <hash>`	Reset to a specific commit
`git reset --hard <hash>`	Reset and Delete Changes

Today, I learned how to undo commits in Git using commands like git reset and git reset --hard. I also practiced viewing commit history with git log to identify which commit to revert to. In addition, I learned how forking works on GitHub and how it allows developers to contribute to projects they don’t own. Finally, I understood the workflow of editing a forked repository and submitting contributions through a Pull Request.

Git & GitHub Learning Notes

Kervie Sazon — Mon, 09 Mar 2026 15:16:00 +0000

Part 1: Fresh Start
Part 2: Branching
Part 3: Undoing Changes & Forking

Git & GitHub Notes - Part 2: Branching

Kervie Sazon — Mon, 09 Mar 2026 15:10:59 +0000

Today I continued learning Git and GitHub, focusing on branching and collaboration commands.

Branch

A branch in Git is a separate line of development. It allows you to work on new features, fixes, or experiments without affecting the main project.

Most repositories have a default branch called:
main

Developers usually create new branches to:

Add new features
Fix bugs
Test ideas safely

Commands encountered:

`git branch`

The git branch command is used to view or manage branches.
View all branches

git branch

Example Output:

* main 
  feature-testing

The * indicates the current branch you are working on.

Create new branch

git branch feature-testing

This creates the branch but does not switch to it yet.

`git checkout`

git checkout is used to switch between branches.

`git checkout -b <branch_name>`

This command creates a new branch and switches to it at the same time.

Command

git checkout -b feature-testing

This is equivalent to running:

git branch feature-testing
git checkout feature-testing

`git diff`

git diff shows the difference between file changes.

This helps developers review what has changed before committing or merging.

`git commit -am`

This command is a shortcut that:

Stages tracked files
Creates a commit

Command

git commit -am "Update test feature"

Important notes:

Works only for already tracked files
New files still require git add

Example:

git add newfile.go
git commit -m "Add new file"

`git merge`

git merge combines changes from one branch into another.

Example workflow

Switch to the branch you want to merge into:

git checkout main

Merge another branch:

git merge feature-testing

This brings the changes from feature-testing into main.

`git pull`

git pull updates your local repository with the latest changes from GitHub.

Command

git pull

It basically does two things:

Fetch updates from the remote repository
Merge them into your local branch

`git branch -d`

This command deletes a branch after it has been merged.

Command

git branch -d feature-login

This helps keep the repository clean by removing branches that are no longer needed.

Example Branch Workflow

A common workflow when adding a new feature:

git checkout -b feature-navbar
git add .
git commit -m "Add navbar feature"
git push

After finishing the feature:

git checkout main
git merge feature-navbar
git branch -d feature-navbar

In summary, I learned how branching works in Git and how it helps developers work on features without affecting the main branch. I practiced creating and switching branches using commands like git branch and git checkout -b. I also learned how to review changes with git diff, combine branches using git merge, and update my local repository with git pull. These commands helped me understand a basic workflow for developing features and managing code changes more efficiently using Git.

Git & GitHub Learning Notes - Fresh Start

Kervie Sazon — Fri, 06 Mar 2026 15:16:00 +0000

Today I studied the basics of Git and GitHub. These are essential tools for developers to track code changes and collaborate with others. I’m writing these notes so I can quickly remember the workflow when I use them again.

1. What is Git?

Git is a version control system that helps developers:

Track changes in code
Revert to previous versions
Work on projects collaboratively

Instead of saving multiple copies of files, Git keeps a history of changes.

2. What is GitHub?

GitHub is a cloud platform that hosts Git repositories online. It allows developers to:

Store code remotely
Collaborate with teams
Share projects publicly

Think of it as Git + cloud storage + collaboration tools.

3. Cloning a Repository

Cloning means downloading an existing repository from GitHub to your local machine.

Command

git clone <repository-url>

Example

git clone https://github.com/username/project-name.git

After cloning, a folder with the project will be created on your computer.

4. The Basic Git Workflow

The typical Git workflow looks like this:

Edit files
   ↓
git add
   ↓
git commit
   ↓
git push

5. `git add` Command

The git add command moves changes into the staging area.

The staging area is where you prepare files before committing them.

Add a specific file

git add index.html

Add all changes

git add .

6. `git commit` Command

A commit saves a snapshot of the staged changes into Git history.

Command

git commit -m "your message"

Example

git commit -m "Add index.html page"

Tips for commit messages

Good commit messages are:

Short
Clear
Descriptive

Examples:

Add login page
Fix navigation bug
Update README

7. `git push` Command

git push uploads your commits to GitHub.

Command

git push

If it's your first push:

git push --set-upstream origin main

After that, you can simply run:

git push

8. SSH Key

An SSH key allows you to connect to GitHub securely without typing your username and password every time.

It works like a secure authentication key between your computer and GitHub.

Generate SSH key

ssh-keygen -t ed25519 -C "your_email@example.com"

View your public key

cat ~/.ssh/id_ed25519.pub

Copy the key and add it to GitHub under:

Settings → SSH and GPG Keys

9. Useful Git Commands

Check repository status

git status

See commit history

git log

Check remote repository

git remote -v

10. My Simple Daily Git Workflow

When working on a project, I will usually do:

git add .
git commit -m "describe what I changed"
git push

Key Takeaways 🧠

git clone → download a repository
git add → stage files
git commit → save changes locally
git push → upload changes to GitHub
SSH key → secure authentication without passwords

Learning Git and GitHub felt confusing at first, but understanding the basic workflow (add → commit → push) makes it much easier. I’ll keep practicing these commands while working on small projects.

Next topics I want to learn:

Branching
Pull requests
Merging
Git collaboration workflows

Go Learning Notes - Part 8: Concurrency & Goroutines

Kervie Sazon — Thu, 05 Mar 2026 15:00:20 +0000

Today I explored Concurrency in Go using Goroutines and learned how Go can perform tasks in the background while the program continues executing. In my conference booking application, I implemented a goroutine to simulate sending a ticket confirmation email without blocking the main program.

Concurrency in Go

Concurrency allows a program to run multiple tasks independently. Go provides a simple way to achieve this using goroutines, which are lightweight threads managed by the Go runtime.

Instead of waiting for a task to finish, Go can run it in the background.

Goroutines with the `go` keyword

A goroutine is created by adding the go keyword before a function call.

In my program, I run the sendTicket function as a goroutine:

wg.Add(1)
go sendTicket(userTicket, fName, lName, email)

This allows the program to continue running other code while the ticket is being "sent".

Simulating Work with `time.Sleep`

Inside the sendTicket function, I simulate a delay to represent sending an email.

time.Sleep(10 * time.second)

This pauses the goroutines for 10 seconds.

Formatting Strings with `fmt,Sprintf`

I also used fmt.Sprintf to format a string without immediately printing it.

ticket := fmt.Sprintf("%v tickets for %v %v \n", userTickets, fName, lName)

Unlike fmt.Printf, fmt.Sprintf returns the formatted string, which can then be stored in a variable or used later.

Synchronizing Goroutines with `WaitGroup`

When using goroutines, the program might finish before the goroutines complete.
To prevent this, Go provides the WaitGroup from the sync package.

var wg = sync.WaitGroup{}

A WaitGroup helps the main program wait for all goroutines to finish before exiting.

`Add()`

Add() tells the WaitGroup how many goroutines to wait for.

wg.add(1)

This means the program expects one goroutine to finish.

`Done()`

Inside the goroutine, Done() signals that the task is completed.

wg.Done()

In my program, this is called at the of the sendTicket function.

`Wait()`

Wait() block the program until all goroutines have called Done()

wg.wait()

This ensures the main program does not exit until the background task is finished.

Example: Sending Tickets Concurrently

My sendTicket function runs in the background and simulates sending a confirmation email.

func sendTicket(userTickets uint, fName string, lName string, email string) {
    time.Sleep(10 * time.Second)

    ticket := fmt.Sprintf("%v tickets for %v %v \n", userTickets, fName, lName)

    fmt.Println("############")
    fmt.Printf("Sending ticket: \n %v to email address %v \n", ticket, email)
    fmt.Println("############")

    wg.Done()
}

This demonstrates how goroutines allow long-running tasks to execute without blocking the main application flow.

In summary, I learned how Go uses goroutines to run functions concurrently using the go keyword. I also learned how to simulate background tasks using time.Sleep and format strings using fmt.Sprintf. Another key concept I discovered was synchronizing goroutines using WaitGroup from the sync package. Using Add(), Done(), and Wait() ensures that goroutines complete their execution before the program exits.

Go Learning Notes - Part 7: Struct

Kervie Sazon — Wed, 04 Mar 2026 14:06:08 +0000

Today I learned about Structs in Go and encountered the type keyword, which allows us to create custom data types. This lesson helped me improve my booking app by replacing maps with a more structured and type-safe approach.

Struct

A struct is a composite data type that groups together variables under a single name. It helps organize related data into one logical unit.

In my booking app, instead of using a map[string]string, I created a custom struct:

type UserData struct {
    firstName        string
    lastName         string
    email            string
    numberOfTickets  uint
}

Here, UserData is a custom type created using the type keyword.

The `type` Keyword

The type keyword in Go allows us to define our own data types.

type UserData struct {
    ...
}

This means:

I created a new type called UserData
It has fields like firstName, lastName, email, and numberOfTickets
It behaves like a blueprint for user booking information

This makes the program cleaner and more structured.

Creating a `struct` Instance

Inside my bookTicket() function, I create a new struct instance like this:

userData := UserData{
    firstName:        fName,
    lastName:         lName,
    email:            email,
    numberOfTickets:  userTickets,
}

Then I store it in a slice:

bookings = append(bookings, userData)

Now instead a slice of maps, I use:

bookings = make([]UserData, 0)

This is much more readable and type-safe.

Accessing Struct Fields

To get all first names, I loop through the slice and access struct fields using dot(.) notation:

for _, booking := range bookings {
    firstNames = append(firstNames, booking.firstName)
}

Unlike maps, struct fields are accessed using . instead of ["key"].

In summary, I learned how to use structs in Go to group related data into a single, organized unit. I understood that the type keyword allows me to create custom data types like UserData, which act as blueprints for structured information. I also learned how to create struct instances and access their fields using dot notation.

Go Learning Notes - Part 6: Maps & Type Conversion (strconv)

Kervie Sazon — Mon, 02 Mar 2026 14:16:03 +0000

Today I learned about Maps in Go and how to properly handle type conversion using the strconv package.

Maps in Go

I improved my booking app by replacing simple slices with maps to store structured user data.

Instead of storing only names like this:

bookings := []string{}

I now use a slice of maps:

bookings := make([]maps[string]string, 0)

Each user booking is stored as a map:

userData := make([]map[string]string)
userData["firstName"] = fName
userData["lastName"] = lName
userData["email"] = email

This makes the data more organized, easier to access and more scalable for real-world applications.

Now I can easily access specific values like:

bookings["firsName"]

Type Conversion in Go (`strconv`)

In my app, userTickets is a uint, but maps store values as string.
So I needed to convert the number into a string before storing it.

Solution: strconv.FormatUint()

userData["numberOfTickets"] = strconv.FormatUint(uint64(userTickeets), 10)

What’s happening here?

uint64(userTickets) - Convert uint to uint64
10 - Base 10 (decimal)
Returns a string

Now the ticket number can safely be stored inside the map.

For Better Understanding

Slice of Maps Declaration

var (
    bookings = make([]map[string]string, 0)
)

Creating and Storing User Data in a Map

func bookTicket(userTickets uint, fName string, lName string, email string) {
    RemainingTickets = RemainingTickets - userTickets

    // create a map for a user
    userData := make(map[string]string)
    userData["firstName"] = fName
    userData["lastName"] = lName
    userData["email"] = email
    userData["numberOfTickets"] = strconv.FormatUint(uint64(userTickets), 10)

    bookings = append(bookings, userData)
}

Accessing Map Values Inside a Loop

func getFNames() []string {
    firstNames := []string{}
    for _, booking := range bookings {
        firstNames = append(firstNames, booking["firstName"])
    }
    return firstNames
}

Import for Type Conversion

import "strconv"

This lesson made my booking application more structured and closer to real-world development.
Using maps helped me understand how Go handles data organization, and learning strconv improved my understanding of Go’s strict type system.

In summary, I learned how to use maps in Go to store structured user data more efficiently by creating a slice of map[string]string. I understood how to access specific values from a map while looping through the slice, such as retrieving all first names. I also learned that Go is strongly typed and requires explicit type conversion when working with different data types. Using strconv.FormatUint() helped me convert a uint value into a string so it can be stored properly inside a map.

Go Learning Notes - Part 5: Packages, Exported Functions & Variables, & Scope

Kervie Sazon — Sun, 01 Mar 2026 15:49:56 +0000

Today I focused on organizing Go programs using packages, exporting functions and variables, and understanding different levels of variable scope. I improved my Conference Booking App by moving input validation logic into a separate package called helper.

Here's what I do:

Packages in Go

A package is a way to organize Go code into reusable modules.

In my app:

import (
    "fmt"
    "strings"
    "booking-app/helper"
)

fmt and strings are standard Go packages
helper is a custom package I created
Packages allow me to separate concerns, like moving input validation out of main()

My Go module is defined as:

module booking-app

go 1.26.0

This ensures the project is recognized as a Go module and allows me to import packages like helper.

Exported Functions & Variables

In Go, functions or variables are exported if their name starts with a capital letter.

Example from the helper package:

isValidName, isValidEmail, isValidTicketNumber := helper.ValidateUserInput(fName, lName, email, userTickets, RemainingTickets)

ValidateUserInput is exported because it starts with a capital letter
I can call it from main even though it’s in another package

The helper package looks like this:

package helper

import "strings"

func ValidateUserInput(fName string, lName string, email string, userTickets uint, remainingTickets uint) (bool, bool, bool) {
    isValidName := len(fName) >= 2 && len(lName) >= 2
    isValidEmail := strings.Contains(email, "@")
    isValidTicketNumber := userTickets > 0 && userTickets <= remainingTickets
    return isValidName, isValidEmail, isValidTicketNumber
}

Variables can also be exported:

var RemainingTickets uint = 50

RemainingTickets is accessible across functions because it starts with a capital letter
Exporting variables allows sharing state safely between packages (but should be done carefully)

Levels of Scope in Go

There are three main types of variable scope:

Local Scope – Variables declared inside a function, only accessible in that function:

var fName string

Package Scope – Variables declared at the package level (outside any function) are accessible to all functions in the package:

var bookings = []string{}

Global / Exported Scope – Variables or functions that start with a capital letter are accessible from other packages:

var RemainingTickets uint = 50
helper.ValidateUserInput(...)

Understanding scope helps control where variables are accessible and avoid accidental misuse.

How I Applied This Today

Moved input validation logic to helper.ValidateUserInput() → cleaner main()
Exported the function and variable so main can use them
Learned how to structure Go programs into packages for better readability and maintainability
Practiced using local, package, and global scope effectively in a real program

In summary, I learned how to organize Go programs using packages, which allows me to separate logic into reusable modules. I practiced exporting functions and variables so they can be accessed from other packages, like moving my input validation into a helper package. I also learned about the three levels of variable scope: local (inside functions), package (accessible within a package), and global/exported (accessible across packages).

Linux Fundamentals - Part 16: Connecting from Mac to Ubuntu VirtualBox using SSH

Kervie Sazon — Thu, 26 Feb 2026 15:44:59 +0000

Today, I practiced connecting from my Mac to my Ubuntu VirtualBox using SSH. I also tested basic file and directory operations to see how commands from Mac reflect in Ubuntu.

Steps I followed:

1. Configure VirtualBox Network

Open VirtualBox, Select Ubuntu VM, Settings, Network
Change network adapter from NAT to Bridged Adapter
Selected Mac Wi-Fi interface and saved changes

2. Install SSH Server on Ubuntu
Update package list:

sudo apt update

Install OpenSSH server, started and enabling the service:

sudo apt install openssh-server
sudo systemctl start ssh
sudo systemctl enable ssh

3. Verify SSH service status

sudo systemctl status ssh

Check if running.

4. Ensure firewall allows SSH

sudo ufw allow ssh
sudo ufw status

This step is important to make sure the firewall doesn’t block incoming SSH connections.

5. Connect from Mac using Terminal
Get the IP Address first from ubuntu setup:

ip a

Mine is 192.168.100.153

In Mac Terminal:

ssh kerviejay@192.168.100.153

I entered my Ubuntu password and successfully accessed my Ubuntu machine remotely!

Today, I have learned that SSH allows me to connect from Mac to Ubuntu VM and run commands remotely. Using a Bridged Adapter gives the VM its own IP on the same network. I learned to check my username (whoami), current directory (pwd), and list files (ls) from SSH. Creating and removing directories and files from Mac reflects directly in Ubuntu. Ensuring the firewall allows SSH is crucial for successful connections. Making a file with a message confirms SSH connectivity, which makes practicing Linux more interesting.

Go Learning Notes - Part 4: Functions, Input Validation & Encapsulating Logic

Kervie Sazon — Wed, 25 Feb 2026 16:41:33 +0000

Today was a step forward in my Go journey. Instead of writing everything inside main(), I refactored my Conference Booking App by separating logic into functions, validating user input properly, and organizing my code structure.

Here's what I learned:

Encapsulating Logic with Functions

I broke my program into smaller, focused functions:

greetUser() - Displays conference details
getUserInput() - Collects user input
validateUserInput() - Validates the input
bookTicket() - Handles ticket booking logic
getFNames() - Extracts first names from bookings

Example:

func bookTicket(userTickets uint, fName string, lName string, email string) {
    remainingTickets = remainingTickets - userTickets
    bookings = append(bookings, fName+" "+lName)
}

What I Realized:

Functions make main() cleaner
Code becomes reusable
Logic is easier to test and understand
Each function has a single responsibility

Validating User Input

I created a validation function that returns multiple boolean values:

func validateUserInput(fName string, lName string, email string, userTickets uint) (bool, bool, bool)

Inside it:

isValidName := len(fName) >= 2 && len(lName) >= 2
isValidEmail := strings.Contains(email, "@")
isValidTicketNumber := userTickets > 0 && userTickets <= remainingTickets

What I Learned:

Functions can return multiple values in Go
Boolean expressions control decision-making
Validation prevents bad input

Using Global Variables Carefully

I defined shared data outside main():

var conferenceName = "Go Conference"
const conferenceTickets = 50
var remainingTickets uint = 50
var bookings = []string{}

This allowed multiple functions to access shared state.

Clean Main Function

Now my main() function is much cleaner:

fName, lName, email, userTickets := getUserInput()
isValidName, isValidEmail, isValidTicketNumber := validateUserInput(...)

Instead of being crowded with logic, main() now:

Gets input
Validates input
Books tickets if valid
Displays first names
Stops when tickets are sold out

This separation made the flow much easier to read.

Extracting First Names

I also created:

func getFNames() []string

Which:

Loops through the bookings slice
Uses strings.Fields() to split names
Returns only first names

In summary, I learned how to encapsulate logic into separate functions to make my Go program cleaner and more organized. I created dedicated functions for greeting users, collecting input, validating data, booking tickets, and extracting first names. I also learned how to return multiple boolean values from a function to validate user input properly. Structuring my code this way made main() easier to read and improved the overall flow of the program. This lesson helped me understand the importance of modular and maintainable code in real-world development.

Go Learning Notes - Part 3: If, Else If, Else Statements

Kervie Sazon — Tue, 24 Feb 2026 14:18:40 +0000

Today I improved my Go Conference Booking App by adding conditional logic and better loop control. Instead of allowing any booking, I now validate user input using if, else if, and else statements.

Here’s what I learned:

Boolean Expressions in Go

In Go, conditions inside if statements must evaluate to a boolean (true or false).

Example from my program:

if userTickets < remainingTickets

This expression returns:

true - booking is allowed
false - booking is denied

Comparison operators I used:
< less than
== equal to
> greater than

If Statement (Main Booking Logic)

if userTickets < remainingTickets {
    remainingTickets = remainingTickets - userTickets
    bookings = append(bookings, fName+" "+lName)
}

What This Does:

Checks if enough tickets are available
Deducts tickets
Saves the booking
Displays confirmation

This made my app smarter and prevented overbooking.

Else If Statement

else if userTickets == remainingTickets {
    // do something else
}

This condition handles the case where:

The user books exactly the remaining tickets It allows handling a special edge case separately.

Else Statement (Invalid Booking)

else {
    fmt.Printf("We only have %v tickets, so you can't book %v tickets.\n", remainingTickets, userTickets)
}

This runs when:

The user tries to book more tickets than available

Now my program protects against invalid input.

Infinite Loop with Condition-Based Exit

The booking system runs inside:

for {

This creates an infinite loop.

But I added a stopping condition:

if remainingTickets == 0 {
    fmt.Println("Our Conference is fully booked. Come back next year!")
    break
}

`break` Statement

The break keyword:

Immediately exits the loop
Stops the program once tickets are sold out

Without break, the loop would continue forever.

Today I learned how to use boolean expressions and if, else if, and else statements to control the flow of a Go program. I practiced validating user input and handling different booking scenarios to prevent overbooking. I also learned how to use break to stop an infinite loop when tickets are sold out. Combining conditionals with loops and slices made my program smarter and more dynamic.

Linux Fundamentals - Part 15: Server Review (Uptime & Load)

Kervie Sazon — Mon, 23 Feb 2026 14:44:18 +0000

One of the fastest ways to review a server’s condition is with a single command:

uptime

The `uptime` Command

The uptime command gives a information of a Linux system’s current state — all in one line.

Example Output

21:36  up 48 mins, 2 users, load averages: 1.63 1.67 1.65

This output tells:

Part of Output	Meaning
Current Time	Local server time when the command was run
Up time	How long the server has been running since last reboot
Users count	Number of logged-in users
Load averages	System load over 1, 5, and 15 minutes

This is often the first command engineers run after SSH-ing into a server.

Breaking Down the Output

Example output:

21:36  up 48 mins, 2 users, load averages: 1.63 1.67 1.65

21:36 - current system time.
up 48mins - The server has been running for 48 mins.
2 users - 2 active logged in session.
load average: 1.63 1.67 1.65
These are the load averages for:

Last 1 minute
Last 5 minutes
Last 15 minutes

Uptime Options
uptime -p - show only the running time of the system.
Example output:

up 58 minutes

uptime -s - shows the date/time since when the system has been running.
Example output:

2026-02-23 10:27:58

uptime -h - shows help and exit.
uptime -V - shows information and exit.

Load Average

Load Average represents how much work the system is doing.

Specifically it measures:

Processes currently using the CPU.
Processes waiting for CPU.
Processes in uninterruptible sleep (often waiting for disk I/O).

The three values represents:

Value	Represents
First	Average load over 1 minute
Second	Average load over 5 minutes
Third	Average load over 15 minutes

What does Load Average Actually Mean?

Load average is not CPU percentage.
Instead, it shows how many processes are demanding CPU resources.
Interpretation Rule:

Load = 0; means System is idle.
Load = Number of CPU cores; means Fully utilized.
Load > CPU cores; means Overloaded (processes waiting)

Example Scenarios

Single-Core System

Load > 1.0 = Overloaded

4-Core System

Load = 4.0 = Fully Utilized
Load = 6.0 = Overloaded (2 processes waiting)

To check CPU Cores:

nproc

lscpu

CPU count matters. Load numbers alone mean nothing without context.

Interpreting Load in Practice

Load Example	Interpretation
`0.50, 0.40, 0.30`	Light load
`4.00, 3.50, 2.00` (4 cores)	Fully utilized but stable
`10.00` (4 cores)	Severe overload

A rising 1 minute load but stable 15 minutes load?

Probably a temporary spike.

High load but low CPU usage?

Likely I/O bottleneck (disk, network, database lock).

This is where real troubleshooting begins.

Why This Matters for Platform Engineers

Checking uptime helps with:

Monitoring server health
Detecting performance bottlenecks
Identifying overload conditions
Capacity planning
Incident response diagnostics

When someone says:

"The server is slow."

First step is often:

uptime

It gives immediate situational awareness.

Today I learned how to use the uptime command to quickly check a Linux server’s health and status. I now understand how to interpret load average values and compare them properly against the number of CPU cores. I also learned that load average measures CPU demand, not CPU percentage, and can indicate overload or I/O bottlenecks. This lesson strengthened my foundation in server monitoring, which is essential for becoming a Platform Engineer.

Forem: Kervie Sazon

Git & GitHub Notes - Part 3: Undoing Changes & Forking

Undoing Changes

git log

git reset HEAD~1

git reset <hash>

git reset --hard <hash>

Forking a Repository

Creating a Pull Request

Git & GitHub Learning Notes

Git & GitHub Notes - Part 2: Branching

Branch

Commands encountered:

git branch

git checkout

git checkout -b <branch_name>

git diff

git commit -am

git merge

git pull

git branch -d

Example Branch Workflow

Git & GitHub Learning Notes - Fresh Start

1. What is Git?

2. What is GitHub?

3. Cloning a Repository

Command

Example

4. The Basic Git Workflow

5. git add Command

Add a specific file

Add all changes

6. git commit Command

Command

Example

Tips for commit messages

7. git push Command

Command

8. SSH Key

Generate SSH key

View your public key

9. Useful Git Commands

Check repository status

See commit history

Check remote repository

10. My Simple Daily Git Workflow

Key Takeaways 🧠

Go Learning Notes - Part 8: Concurrency & Goroutines

Concurrency in Go

Goroutines with the go keyword

Simulating Work with time.Sleep

Formatting Strings with fmt,Sprintf

Synchronizing Goroutines with WaitGroup

Add()

Done()

Wait()

Example: Sending Tickets Concurrently

Go Learning Notes - Part 7: Struct

Struct

The type Keyword

Creating a struct Instance

Accessing Struct Fields

Go Learning Notes - Part 6: Maps & Type Conversion (strconv)

Maps in Go

Type Conversion in Go (strconv)

For Better Understanding

Go Learning Notes - Part 5: Packages, Exported Functions & Variables, & Scope

Packages in Go

Exported Functions & Variables

Levels of Scope in Go

How I Applied This Today

Linux Fundamentals - Part 16: Connecting from Mac to Ubuntu VirtualBox using SSH

Go Learning Notes - Part 4: Functions, Input Validation & Encapsulating Logic

Encapsulating Logic with Functions

Validating User Input

Using Global Variables Carefully

Clean Main Function

Extracting First Names

Go Learning Notes - Part 3: If, Else If, Else Statements

Boolean Expressions in Go

`git log`

`git reset HEAD~1`

`git reset <hash>`

`git reset --hard <hash>`

`git branch`

`git checkout`

`git checkout -b <branch_name>`

`git diff`

`git commit -am`

`git merge`

`git pull`

`git branch -d`

5. `git add` Command

6. `git commit` Command

7. `git push` Command

Goroutines with the `go` keyword

Simulating Work with `time.Sleep`

Formatting Strings with `fmt,Sprintf`

Synchronizing Goroutines with `WaitGroup`

`Add()`

`Done()`

`Wait()`

The `type` Keyword

Creating a `struct` Instance

Type Conversion in Go (`strconv`)

`break` Statement

The `uptime` Command