DEV Community: Ashomondi

THE INTERNET

Ashomondi — Tue, 17 Mar 2026 11:32:29 +0000

The Internet: How Messages Travel in a Digital World

You’ve probably never thought about it, but every time you browse a website, send a message, or watch a video online, tiny digital “travelers” are racing across the globe to make it happen. Let’s take a journey to understand how the internet really works—not as code or protocols, but as a living, moving system.

The Internet Is a Digital Highway

Imagine the world as a massive city, with roads connecting every house, office, and shop. These roads are the internet’s networks, connecting computers, phones, servers, and smart devices.

When you click a link or open an app, it’s like sending a delivery truck onto these highways. The truck carries information—your request for a website, a video, or a message—to its destination.

Addresses and Names: Finding Your Way

Every device in this city has an address—called an IP address. Without it, your delivery truck would never know where to go.

Humans, however, don’t remember numbers well. That’s why we use domain names like youtube.com or wikipedia.org. A DNS server acts like a GPS or map service—it converts the name into the numerical address your digital truck needs.

Packets: Tiny Travelers on the Road

Data doesn’t travel as one big load; it’s broken into packets, like hundreds of tiny drones each carrying a piece of your message.

1.Each packet knows:
2.Where it’s coming from
3.Where it’s going
4.Its place in the overall message

These packets may take different routes, zooming through various routers and networks, but they all arrive at your device and reassemble into the complete page, message, or video.

4.** Security: Sealed and Locked**

Some deliveries need to be secure, like a bank transaction or private email. That’s where encryption (HTTPS/TLS) comes in. It’s as if each packet is placed in a sealed, locked box. Only your device and the server holding the key can open it.

Without this, anyone along the highway could read your messages.

Servers: Warehouses of the Digital World

Websites live in servers, which are like massive warehouses storing all the content you might request. When your delivery truck reaches a server, it picks up the items (HTML, images, scripts) and heads back to your device.

Some servers are far away, even across oceans. To speed things up, companies use CDNs (Content Delivery Networks)—mini-warehouses spread worldwide—so your data doesn’t have to travel too far.

A Living, Breathing System

The internet isn’t static. It adapts and moves constantly:

1.Routers find the fastest path for packets.
2.Networks reroute traffic when there’s congestion or outages.
3.Edge servers and caching make popular content instantly available.

It’s like a city where every street, intersection, and delivery truck is constantly adjusting to keep traffic flowing.

7.** Why Understanding It Matters**

Even if you’re not a programmer, knowing how the internet works can help you:

1.Understand why pages sometimes load slowly
2.Protect your data with strong security practices
3.Appreciate the incredible infrastructure behind your favorite apps and websites

The next time you hit Enter, think about all the hidden roads, travelers, and warehouses working in perfect harmony—just to bring a single web page to your screen.

✅ Key Takeaways (In Simple Words)

1.The internet is a global network of networks.
2.Names (domain names) are translated into numbers (IP addresses).
3.Data travels in small packets, often taking different routes.
4.Servers store the content you request, while CDNs make it faster.
5.Encryption keeps your data safe on the journey.

INTERNATIONAL WOMEN'S DAY (IWD)

Ashomondi — Tue, 10 Mar 2026 14:10:10 +0000

Celebrating International Women's Day (IWD) at Zone01 Kisumu 2026: Give to Gain

This year at Zone01 KIsumu, international women's day was not just a celebration but also it was an interactive session focused on learning and sharing of knowledge.Under the theme of:Give to Gain we decided to do something different from our previous years.
We brought together young minds,tech mentors for a day full of innovation,creativity and fun.

Hands-on Technovation for Young Learners

We invited girls from: Sinyolo ,Lions high and St.Paul schools to dive into the world of technology.Using App-inventor they learned how to build a simple app of their choice and experienced firsthand how technology can help solve real-world problems.

It was amazing to see their curiosity and creativity throughout the project. From building their apps to testing them, the room was full of energy and excitement.

Learning form experts and guests

The invited guests made the day even more interactive and inspiring. We were delighted to have representatives from the Directorate of ICT Kisumu, including Audrine Papetua (ICT Officer, CGK) and Rozanne Achieng (RMS Support Engineer), who shared their journeys in the tech industry.

We also held a panel discussion moderated by Vallary Odinga. The panelists included our mentors Bella Oyucho and Anne Okingo, who made the session engaging and insightful.

In addition, we had special guests like Maxi Daniels, a poet and author, and Winnie Wenger Walcott, a digital creator, who shared their inspiring journeys.

Give to Gain: The Heart of the Event

The theme Give to Gain truly came alive through mentorship, shared knowledge, and collaboration. By investing time and skills in young learners, we not only empowered them but also strengthened our community.

International Women’s Day at Zone01 Kisumu showed that empowering others benefits everyone. Every app created, every idea shared, and every lesson taught reminded us that knowledge grows when it is shared.

BUILDING A TEXT AUTO-CORRECTION TOOL IN GO(go-reloaded)

Ashomondi — Fri, 27 Feb 2026 08:26:01 +0000

Go-reloaded
In this project i built a small Go tool that reads a text file and automatically applies to a set of editing rules such as :
1.converting words to uppercase/lowercase/capitalized form
2.converting hexadecimal and binary numbers to decimal
3.fixing punctuation spacing
4.fixing quotes 'like this'
5.converting a → an before vowels or h
This project works like auto-correct it corrects a sentence and puts every letter in order and also punctuation.

This program takes two arguments:

an input file name (that contains raw text) 2.an output file name where the corrected output will be written example: a)sample.txt this is where the input/ raw text will be b) result.txt this where the corrected output will be displayed. You can use this "go run . sample.txt. result.txt"

GO-RELOADED PROJECT (article)

Ashomondi — Tue, 17 Feb 2026 12:46:02 +0000

Go-reloaded is a small text editing and auto-correct tool written in Go.
The program reads text files from an input file, applies a set of formatting and correction rules, then writes the corrected version into an output file e.g : sample.txt -this is where the inputs are written

result.txt - this where the the corrected version in the sample.txt file is being displayed

What this project does and what is learnt in it

Reading and writing files in Go using os.ReadFile This opens the file, reads the content in it then returns it as a slice of bytes
Working with strings
Converting numbers (binary and hexadecimal)
Applying text transformation like uppercase, lowercase and capitalize
Fixing punctuation and grammar rules automatically This helps to place every punctuation in order the way it should like quotes after the .

HOW THE PROGRAM WORKS
The program receives two command line:

The input file name (sample.txt)
The output file name (result.txt) How to run it use: go run . sample.txt result.txt Easy to run and also implement

STEPS THE PROGRAM FOLLOWS:

Check if the user provided exactly two command lines
Read the input file content using os.ReadFile
Apply multiple text transformation one after another
Write the final corrected text to the output file/ result using os.WriteFile
Prints "Done" if everything worked successfully.

INPUT AND OUTPUT FILES
-Sample.txt (or input.txt) contains the raw text with special tags like (up), (cap), (low, 8), (hex), (bin)
-Result.txt (output.txt) contains the corrected text after the program finishes processing
This makes it easy to run.

THE TEXT TRANSFORMATION RULES
The project supports multiple corrections and formation rules
a) Uppercase version
Whenever the program find (up) it changes the word before it to uppercase
sample.txt
go (up)
result.txt
GO
b) Lowercase version
Whenever the program finds (low) it changes the word before to lowercase(small letter)
sample.txt
GO (low)
result.txt
go
c) Capitalize version
The programs runs and when it finds (cap) anywhere in the sentence it changes the word before to cap
sample.txt
go (cap)
result.txt
Go
Only the first letter of the word will change.
This program is being implemented through
func Tocap(text string) string
func Tolower(text string) string
func Toupper(text string) string
all of the 3 are done using the above function

Uppercase, Lowercase and Capitalize for N words.
The program also supports tags like

up 2
low 4
cap 3

This means : apply the function to the previous N word.
input
my life (cap, 2) is good.
output
My Life is good.
The program removes the word in the bracket after converting correctly.

My life is very good (up, 2)
output
My life is VERY GOOD

MY LIFE IS (low, 3) good.
my life is good.
The difference between up and cap is that up capitalize the whole word while cap only the first letter of the word.

You implemented using this function:
TolowerN
ToupperN
TocapN

These functions:

Detect the keyword like (up)
Read the number in the next word like (3)
Loop backwards and update the previous N words
Remove the formatting tags from the final output

Hexadecimal conversion (hex)
When (hex) appears, the word before it is treated as a hexadecimal number and converted to decimal.

Example:
1E (hex)
output
30

It is being handled by this function:
func Hexadecimal(text string) string
strconv.ParseInt(word, 16, 64)
uses a string convert

Binary conversion (bin)
When (bin) appears, the word before it is treated as a binary and it is converted to decimal.

Example:
10(bin)
output
2
This is the function used:
func Binary(text string) string
strconv.ParseInt(word, 2, 64)

FIXING PUNCTUATION
One important part of the project is puntuation formatting.
The rules include:
a) punctuation like . , ! ? : ; must be attached to the previous word
b) there should be a space after punctuation (when needed)
c) special groups like ... or !? must stay together
d) quotes ' ' must not contain extra spaces inside

This is implemented using this function
func Punctuation(text string) string
This function uses many Strings.ReplaceAll() calls to remove wrong space and fix punctuation.
It is easy to implement and understand.

FIXING "a" to "an"
The final grammar rule is :

Replace "a" with "an" when the next word starts with a) a vowel (a,e,i,o,u) b) or the letter h Example: a untold story output an untold story

Used this function:
func FixAtoAn(text string) string

WHY I USED string.Fields()
In most cases i used :
word := strings.Fields(text)

This is important because:

splits the text into words
removes extra spaces automatically
makes it easier to scan word by word and detect tags like (up) After converting the strings it joins it using strings.Join(words, " ")

PROGRAM FLOW(pipeline style)
In main.go i applied the function pipeline:
text = Toupper(text)
text = Tolower(text)
text = Tocap(text)
text = Hexadecimal(text)
text = Binary(text)
text = TolowerN(text)
text = ToupperN(text)
text = TitleN(text)
text = Punctuation(text)
text = FixAtoAn(text)
This makes the program easy to read because every function focuses on one task

What i learnt from this project:
This project helped me learn how to:

Work with command-line arguments using "os.Args"
Convert strings into numbers strconv 3.Manipulate words using loops and string functions
Build a program using a step by step transformation approach.

CONCLUSION
Go-reloaded is a simple but powerful text formatting tool that automatically edits text using special tags like (up), (hex) and also correct punctuation and grammar.
The project improved my understanding of:

File handling in Go
string processing
building algorithms for real text problems It also taught me how to write code that is readable by separating each rule into its own function

CHALLENGES FACED DURING THIS PROJECT
The challenges i faced was time management, submitting the project on time was quite difficult.
Writing the whole code for the first time was challenging i had to redo it over and over again to get it right with the proper out put.

Got a question or suggestion? Drop a comment, i would love to hear your thoughts.