DEV Community: Tyclone81

ASCII-Art Experiment to Production-Grade: Building a Live Web Platform for INKA LittUp

Tyclone81 — Thu, 23 Jul 2026 09:30:59 +0000

From my time at Zone01 Kisumu, one thing has become evident, "Every project builds the next". It is a gradual process which makes the learning experience worthwhile. The knowledge I built during the Ascii-art-Web assignment was the exact foundation that made building a real, working site almost effortless.

Throughout the ASCII-Art project, I thought of this idea for my production-grade project at Zone01 Kisumu. Building a mobile-responsive web platform for INKA LittUp, a full-service electrical outfit, to showcase their portfolio and convert site visitors to potential clients.

*The Mindset Shift: From In-Memory String Math to Asset Delivery
*
For INKA LittUp, the engineering challenge completely shifted. I wasn't parsing characters anymore, as in Ascii-Art-Web, I needed to serve static visual assets fast, enforce strict HTTP route boundaries, and ensure zero false 200 OK responses.

*Fixing Catch-All Routing in Go
*
An important lesson from the Ascii-Art project was defensive error handling. In Go, http.HandleFunc("/", ...) acts as a catch-all prefix match. If a user requests /some-random-url, Go’s default behavior will serve index.html with a 200 OK status code instead of a 404 Not Found.
For INKA LittUp, I had to enforce strict route checking;

_package main

import (
"fmt"
"log"
"net/http"
)

func main() {
fmt.Println("Server starting on http://localhost:8080")

// 1. Serve static assets cleanly (CSS, cover photos, gallery images)
// /static/styles.css maps directly and safely to ./static/styles.css
fs := http.FileServer(http.Dir("./static"))
http.Handle("/static/", http.StripPrefix("/static/", fs))

// 2. Strict root handler guard
http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
    if r.URL.Path != "/" {
        http.NotFound(w, r) // Properly return 404 for bad paths
        return
    }
    http.ServeFile(w, r, "index.html")
})

// 3. Start listener with crash-logging
err := http.ListenAndServe(":8080", nil)
if err != nil {
    log.Fatal("Server failed to start:", err)
}

}
_

*Pragmatic Architecture: Value Over Complexity
*
Developing production-grade platforms showed me that great engineering is not about designing complex stack but about maximizing utility while keeping maintenance low. I customized the platform to use already existing APIs as follows:

For the contact form, I used Formspree API Integration to ensure zero database overhead and instant email alerts.
For direct messaging, WhatsApp Deep Link(wa.me) which ensures instant mobile contact on a platform clients already use.

*The Mobile Reality Check
*
During testing on mobile devices, I ran into this issue where the hero image was cropping awkwardly on narrower screens. Instead of throwing heavy JavaScript at the problem, adjusting the CSS container behavior fixed it cleanly:

/* Clean mobile background containment /
.hero {
background-size: contain;
background-color: #121212; / Dark background fill for extra space */
}

*Shipping to Production: Continuous Delivery on Render
*
For this particular platform, I turned the deployment mindset into a continuous delivery pipeline as follows:

Version Control: Modular layout tracked cleanly in Git (Tyclone81/LittUp).
Automated Deployments: Connected the GitHub repository directly to Render.
Zero-Touch Releases: Every git push origin main automatically triggers a fresh build and redeploy.

*What’s Next?
*
Moving from terminal utilities to production web deployments showed me how fast you can grow when you build continuously. I'm taking these learning directly into my next production implementations!

Live Platform: https://inkalittup.onrender.com/

GitHub Repository: Tyclone81/LittUp

How did you make the jump from your early utility projects to your first live production site? Let’s chat in the comments.

golang #webdev #beginners #buildfromhere #devops

From the Terminal to Browser: Building a Web-Based ASCII Art Generator

Tyclone81 — Thu, 23 Jul 2026 07:27:11 +0000

In my last post, I pulled back the curtain on version control. Knowing how to safely track and commit files is half the test, building software that people can actually interact with is the real test.
This project ensured I took a step up the stack. The project required me to transform a terminal-based ASCII-Art logic into a fully functional web application. This is a completely new challenge from the previous one and as usual, I was locked and ready to walk these waters.

*The Core Architecture: Serving HTTP
*
First, the web application has to constantly listen for incoming user requests, process payload data and serve responses back without crashing. GO's net/http package handles this.
_package main
import (
"fmt"
"net/http"
)
func main() {
http.HandleFunc("/", home)
http.HandleFunc("/ascii-art", artHandler)

log.Println("Server running smoothly at http://localhost:8080")
log.Fatal(http.ListenAndServe(":8080", nil))

I learnt the hard way that if a single request causes a runtime panic, the web server crashes for everyone. I had to be more cautious in handling error as a result.

*The Rendering Engine: Processing the Font File
*
This is the heart of the application. The server accepts an input string from a web form, maps each character to a corresponding visual block in a given banner text file and structures it into a graphic ASCII typography.

The logic works as follows:
File I/O: _os.ReadFile _ reads the chosen font file e.g standard, shadow or thinkertoy.
Splitting the Font: the raw banner file is then split by newline characters into a massive string slice,8 lines tall.
Mathematical Mapping: To find the starting line of any character block, its position is calculated based on its ASCII decimal value.
_startLine := int(char-32)*9 + 1
_

*Shipping the Code: Containerization with Docker
*
The program works perfectly on my local machine. However, I have learnt that local success means nothing it it does not run identically in production or on a grading server.
Therefore, I had to learn the Dockerization concept. The concept ensures that my application would run seamlessly in any given environment. It entailed packing the GO binary, the font banner files and HTML templates into a single lightweight image.
_# --- Stage 1: Build & Test Environment ---

FROM golang:1.22-alpine AS builder

Metadata to track build stages for garbage collection

LABEL stage=ascii-art-web-builder

WORKDIR /src

Copy all source files and assets needed for building and testing

COPY main.go ascii.go main_test.go go.mod ./
COPY banners/ ./banners/
COPY templates/ ./templates/

Run the automated safety test script inside the container; If any test block fails, the Docker build stops immediately

RUN go test -v

Build the optimized, statically linked Go binary

RUN CGO_ENABLED=0 GOOS=linux go build -a -installsuffix cgo -o ascii-art-web-server main.go ascii.go

--- Stage 2: Final Runtime Environment ---

FROM alpine:3.19

Apply metadata directly from your updated documentation

LABEL app="ascii-art-generator"
LABEL version="1.0"
LABEL description="Dockerfike for my ASCII Art Generator Web Application with Asset Auditing and In-Memory Caching."

Security: Run as a non-root user

RUN adduser -D -u 10001 appuser
USER appuser

WORKDIR /app

Copy binary from the builder stage

COPY --from=builder /src/ascii-art-web-server .

Copy assets and layout folders exactly as specified in the directory structure

COPY banners/ ./banners/
COPY templates/ ./templates/

Document the port exposed by your Main Controller

EXPOSE 8080

Execute the application

CMD ["./ascii-art-web-server"]
_

The Breakthrough

Building this web generator made everything I have learned the past month unfold before me. The strict formatting logic in go-reloaded through to the structural progress in Git. I have literally gone full circle really. From observing how tools work in the lab, to actively participating in building web platforms.

Now more than ever, I am convinced I will ultimately hack it. Through this exercise, I already have an idea in mind that I would like to implement. Stay tuned for my next post where I put the web skills into a production grade implementation.

go #beginners #webdev #buildfromhere

Getting into the Git: Unlocking the Version Control

Tyclone81 — Thu, 02 Jul 2026 13:44:22 +0000

Just like any house requires a foundation or any chemical reaction requires individual elements, I realized coding requires an elaborate understanding of the version control system. My Git project was intentionally designed as a progressive journey into the world of version control and collaboration. Initially I could type commands in my terminal without necessarily being sure what they do, I quickly discovered this was not sustainable. I now have to unlearn, learn and relearn if I am to stand any chance in this field.

The project laid down the basics of what I need, starting from git init, a command to create a git repository to git push, one to send my project to the repository. I moved from ground up, git clone, a command to pull down project templates into my terminal, the staging cycle where my code moves between states. The three states of Git have become an integral part of my journey as everything coding is done here. The working directory comprises my active code files, the staging area, git add . & git commit -m and the repository, _git push _.

I hit this puzzle that required me to stage once but commit twice, and that's how I learnt git add -p , a command that allows me to commit sections of my file separately. Moving through the project taught me this deep web of commands that would become integral in group collaboration such as git switch -c, git log, git push origin (branch name), etc.

At the end of the project, my git skills progressed from frantic guesswork to deliberate, structural control. Indeed, git is not just a list of terminal prompts to memorize, it is a logical environment built to protect my work. Another week, another reason to look forward for more.

Science v Syntax: The Rude Awakening.

Tyclone81 — Sun, 28 Jun 2026 20:03:40 +0000

Passing the selection pool at Zone01 Kisumu was just the gate. Four weeks into my official journey to software development and I have been hit by a rude awakening! The case sensitivity of Go has already signaled me not to shade my laboratory skin off yet. The attention to detail shall come in handy. Miss a comma, brace, or even an exclamation mark and the program throws in syntax errors.
My introduction to this reality was go-reloaded, a command-line text parsing tool. The assignment sounded simple: take a raw text file, manipulate the strings, fix punctuation spacing, and convert the binary or hexadecimal strings to numbers.
The chemist in me figured I would logic my way through it in an hour. Instead, I immediately hit a wall trying to format punctuation marks (., ,, !). They need to close up to the word before them, but maintain a space after them. My clueless loops resulted in constant runtime crashes;
panic: runtime error: index out of range.

With assistance from a few of my peers(I had to sample ideas from a few to establish my base), I was able to break the execution into two phases. First I split the text string into a slice of individual words and characters. I then used Go's built in standard package, strconv , to look ahead and convert specific flags (like hex _and _bin to decimal), while cleaning up the slice indexes.

The feeling of being able to run my first program albeit with enormous help from my peers was so much fulfilling. Much like the feeling I used to get when I got a breakthrough on a particular research, never gets old really.
The biggest lesson I learned wasn't actually about Go syntax. It was learning that error messages are not a sign of personal failure. In science, an unexpected result is just data. In coding, a red error screen is exactly the same thing, it is just an input telling you exactly where your logic diverged from reality. Each day is a learning day.

Beginners #Golang #Zone01Kisumu

From the lab to the loop; Starting Again!

Tyclone81 — Sun, 28 Jun 2026 13:18:45 +0000

Start of the year this year I felt like I was completely trapped in this endless loop of self doubt. Fast forward 6 months into the year, I am completely locked in at Zone01 Kisumu as an aspiring software Developer.
Why jump ship from science to tech? That is the question I find myself facing from almost everyone around me right now. To me, the answer is straightforward: the world is evolving, and I want to be at the center of it all. It is the oldest rule in the jungle, the rule of natural selection. Either adapt, or get eliminated.
During my time in the science fraternity, I noticed a pattern. Most of the hiccups, bottlenecks, and major problems we faced were ultimately solved by technology, whether it was built internally or outsourced. I saw a massive opportunity right there. Instead of just relying on the tools, I wanted to learn how to build them.
So, I took the first step into the unknown. I decided to start over. Time will surely tell whether it was the right step or not, but I had to try.

Getting selected into Zone01 Kisumu however, had me questioning my decision to start again. Calling the selection process intense would be an understatement. Our perseverance and mental limits were seriously tested. "Where do you go now if you fail" is the question that could not leave my head, I guess I would never know now.
To anyone out there who is standing on the edge, wanting to make a fresh start, whether it is in your career, your family, or your employment: take that leap of faith. The unknown is terrifying, but staying stuck is worse, you got this!

beginners #golang #Zone01Kisumu