Forem: Ashomondi

How I Built a To-Do App in 4 Hours at a Mini Hackathon

Ashomondi — Tue, 14 Apr 2026 00:56:58 +0000

Have you ever tried building a full app in just a few hours?
Recently, I participated in a mini hackathon organized by DevWengi, led by Clinton Odhiambo and Flovian Atieno. The challenge was simple but intense: build a functional application in just 4 hours.

It turned out to be one of the most exciting and educational experiences I’ve had so far.

The Challenge
We were tasked with building a To-Do App with these core features:

Store data locally
Edit tasks
Update tasks
Delete tasks

At first glance, it sounds simple… but doing all that within a limited time really tests your focus and problem-solving skills.

What We Built
I teamed up with Ibrahim, and together we built a mobile-friendly to-do application that met all the requirements.
Even better — it worked smoothly and did exactly what it was supposed to do.

Going Beyond the Basics
We didn’t just stop at the required features. We added:

Task filtering (Completed tasks)
Active/Pending tasks view
All tasks overview These additions made the app more practical and user-friendly.

Tech Stack
We kept things simple and focused:

HTML
CSS
JavaScript No frameworks, no backend — just pure frontend. And it still delivered!

What I Learned
This hackathon taught me:

How to build fast under pressure
The importance of planning before coding
How small features can greatly improve user experience
That you don’t always need complex tools to build something useful ** What’s Next?** This is just the beginning. I’m planning to:
Improve the UI/UX
Add more advanced features
Integrate a backend for better data handling

Check Out the Project
You can explore the full project on my GitHub, where I’ve shared a clear illustration of how the app works.

From Inspiration to Direction: My Experience at the Build From Here Conference

Ashomondi — Mon, 13 Apr 2026 14:56:19 +0000

Last Friday, I had the opportunity to attend the Build From Here Conference, and it turned out to be one of the most impactful experiences in my tech journey so far.

Stepping Into a Global Tech Space
One of the most exciting parts of the conference was meeting recruiters from different parts of the world. It wasn’t just about networking—it was about understanding what the global tech space looks like and what is expected from upcoming developers like myself.

Being part of the event also gave me a closer look at the Zone01 community. Seeing how the ecosystem works and how people grow within it made everything feel more real and achievable.

Witnessing Growth: Cohort 1 Graduation
A major highlight of the day was witnessing the graduation of Cohort 1 at Zone01 Kisumu. What made it even more inspiring was learning that some graduates are already employed.

This moment gave me something very important: clarity and confidence.

It reassured me that the path I am on is valid—and that with consistency and effort, it leads somewhere meaningful.

Breaking Barriers: From Zero to Impact
During networking sessions, I met amazing people who were curious about Zone01 Kisumu and eager to learn more about it.

But what truly stood out were the stories of Cohort 1 graduates who joined the program without any prior computer knowledge.

Today, some of them:

Are contributing to the foundation of tech communities
Are working in opportunities beyond Africa

Seeing such transformation firsthand was powerful. It reminded me that your starting point doesn’t define your destination.

Learning Beyond the Classroom

Throughout the day—during lunch, tea breaks, and panel discussions—I had the chance to engage directly with graduates and professionals.

Listening to their journeys in tech, their struggles, and their wins gave me practical insights that you don’t always get in a classroom setting.

Career Lessons That Stood Out
One of the panel sessions focused on career readiness, and it was packed with valuable advice:

Build a strong and clear CV
Be honest about what you don’t know
Stay ready and willing to learn
Put yourself out there
Share your work and journey on LinkedIn

This session changed how I view job searching. It’s not just about applying—it’s about visibility and authenticity.

A Message That Changed My Perspective
One idea that really stayed with me was:
You don’t have to be the loudest in the room to be noticed—your work can speak for you.

This completely shifted my mindset. Being impactful isn’t about noise—it’s about value.

Insights from Industry Voices
I was especially inspired by Jessicah Colaco’s talk as a woman in tech. Her message was powerful, encouraging, and a reminder that there is space for women to grow and lead in this industry.

Another quote that deeply resonated with me came from Ndinga Njeri:
“Certificates are not a competition; what matters is what you can build and demonstrate.”

This reinforced something I had been slowly realizing—skills, projects, and real-world impact matter more than just credentials.

Building Bridges, Not Focusing on Gaps
One of my biggest takeaways from the conference is this:
Instead of focusing on what we lack, we should focus on building bridges—through learning, collaboration, and creating.

In today’s tech world, certificates alone are no longer enough. What truly sets you apart is what you can build, show, and share with others.

Final Thoughts
The Build From Here Conference was more than just an event—it was a turning point.

It gave me:

Inspiration
Direction
Confidence
And a stronger sense of purpose

I’m leaving this experience more motivated than ever to keep building, keep learning, and keep showing up.

If you're on your tech journey, just know this:
Start where you are, use what you have, and keep building.

I’d love to hear your thoughts!
Have you attended a similar event or are you on your tech journey?

Feel free to leave a comment, share your experience, or drop any suggestions—let’s grow together.

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.