DEV Community: Charles Otugeh

Building API with Gin framework

Charles Otugeh — Mon, 22 Jun 2026 09:43:16 +0000

Building API with Gin Framework

Gin is one of the Golang framework. Procedure for create the framework.
on command line:
$ mkdir [directory name]* this the name of my backend repo.
$ cd to the directory
go mod init [directory]
add the following code into file main.go
...
package main // use pacage called main

import (
"net/http"
"github.com/gin-gonic/gin"
)

// Sample of items represents in the database model
// Item starts with uppercase so it is visible to other functions.
type Item struct {
ID string json:"id"
Name string json:"name" binding:"required"
Price double json:"price" binding:"required"
}

// In-memory data store
var items = []Item{
{ID: "1", Name: "Mechanical Keyboard", Price: 99.99},
{ID: "2", Name: "Wireless Mouse", Price: 49.99},
}

// Initialize the default Gin router with Logger and Recovery middleware
func main() {

router := gin.Default()

// Define routes retrieve(GET) and upload(POST)
router.GET("/items", getItems)
router.POST("/items", createItem)

// Start the server on port 8080
router.Run(":8080")

}

// GET handler to fetch all items
func getItems(c *gin.Context) {
c.JSON(http.StatusOK, items)
}

// POST handler to add a new item with validation
func createItem(c *gin.Context) {
var newItem Item

// Bind JSON request body to newItem struct and validate
if err := c.ShouldBindJSON(&newItem); err != nil {
    c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
    return
}

items = append(items, newItem)
c.JSON(http.StatusCreated, newItem)

}
NB: This is just the part of the Framework it not all the files.

Evolution of NFT

Charles Otugeh — Sat, 20 Jun 2026 23:09:52 +0000

Understanding the Evolution of Non-Fungible Tokens (NFTs)

Non-Fungible Tokens (NFTs) are unique digital assets that use blockchain technology to verify ownership and authenticity. Unlike cryptocurrencies such as Bitcoin, which are interchangeable and have equal value, NFTs are distinct and cannot be exchanged on a one-to-one basis. They act as secure digital certificates of ownership for various assets, including digital art, music, collectibles, virtual real estate, and gaming items.

Today, NFTs are recognized as one of the most significant innovations in the blockchain ecosystem. However, their development did not happen overnight. The evolution of NFTs can be traced through four distinct stages.

1. The Precursor Stage (2012–2013)

The foundation of NFTs was laid between 2012 and 2013 through the concept of Colored Coins on the Bitcoin blockchain. Colored Coins were small fractions of Bitcoin that could be "colored" or marked with metadata to represent ownership of real-world or digital assets.

Although the term NFT did not yet exist, Colored Coins introduced the idea that blockchain technology could be used to track and transfer ownership of unique assets rather than just currency. This innovation sparked interest in tokenizing property, stocks, digital collectibles, and other assets.

While limited by Bitcoin's functionality, Colored Coins established the fundamental principles that would later shape NFTs.

2. The Quantum Stage (2014)

The next major milestone occurred in 2014 when digital artist Kevin McCoy and technologist Anil Dash introduced Quantum, widely regarded as the first NFT.

Created during a hackathon, Quantum was a digital artwork stored on a blockchain and linked to a unique ownership record. This project demonstrated that blockchain technology could be used not only for financial transactions but also for proving ownership and authenticity of digital creations.

Quantum represented a breakthrough because it solved a long-standing problem in the digital world: how to establish verifiable ownership of digital content.

3. The Expansion Stage (2015–2017)

Following the success of Quantum, developers began experimenting with more advanced blockchain platforms capable of supporting programmable digital assets.

The launch of Ethereum introduced smart contracts, enabling developers to create unique tokens with customized rules and functionality. During this period, projects such as Rare Pepes and CryptoPunks gained popularity and showcased the growing potential of blockchain-based collectibles.

In 2017, the ERC-721 token standard was introduced on Ethereum, providing a standardized framework for creating non-fungible tokens. This development significantly accelerated NFT adoption by making NFT creation and trading more accessible.

The same year saw the rise of CryptoKitties, a blockchain-based game that allowed users to buy, breed, and trade digital cats. The project became one of the first mainstream NFT applications and demonstrated the commercial viability of NFTs.

4. The Mainstream Adoption Stage (2018–Present)

Since 2018, NFTs have expanded beyond collectibles into various industries, including art, gaming, entertainment, sports, education, and intellectual property management.

The emergence of NFT marketplaces such as OpenSea made it easier for creators to mint, sell, and trade NFTs globally. High-profile NFT sales attracted attention from artists, celebrities, brands, and investors, further accelerating adoption.

Today, NFTs are used for:

Digital art ownership
Music royalties
Gaming assets
Event tickets
Virtual real estate
Identity verification
Intellectual property protection

Despite challenges such as market volatility and environmental concerns, NFTs continue to evolve as blockchain technology matures.

The Future of NFTs

The future of NFTs extends beyond digital artwork and collectibles. Emerging applications include decentralized identity systems, supply chain verification, educational credentials, and tokenized real-world assets.

As blockchain infrastructure improves and adoption grows, NFTs are expected to play an increasingly important role in establishing trust, ownership, and transparency in digital environments.

What began as an experimental concept built on Colored Coins has evolved into a global technology that is reshaping how people create, own, and exchange digital assets.
During the hackathon organized by Zone01 Kisumu, my team chose to work on a project called Afyachain thay apply NFT to decentralized and secure patients' data.

Kisumu Lightning Developer Bootcamp

Charles Otugeh — Sat, 20 Jun 2026 22:16:26 +0000

Building for Solar Energy Producers: My Experience at the Bitcoin Kisumu Lightning Bootcamp

Technology becomes truly meaningful when it solves a real problem. That was the biggest lesson I took away from the Bitcoin Kisumu Lightning Bootcamp, organized by Bitrust, where I had the opportunity to collaborate with a team of six talented individuals to build a Bitcoin-powered solution for small-scale solar energy producers.

The bootcamp was more than a technical training program. It was a space where developers, innovators, and Bitcoin enthusiasts came together to explore how Bitcoin and the Lightning Network can create practical solutions for communities that are often underserved by traditional financial systems.

The Challenge We Chose to Solve
Many small-scale solar energy producers play a critical role in expanding access to clean and affordable energy. However, despite their contribution, they often face challenges such as delayed payments, limited access to financial services, and inefficient payment systems.

Our team wanted to explore how Bitcoin and the Lightning Network could help address these challenges.

The idea was simple: create a platform that enables solar energy producers to receive fast, low-cost payments through Bitcoin while maintaining transparency and reducing dependency on traditional financial infrastructure.

Why Bitcoin and the Lightning Network?
Traditional payment systems can be slow, expensive, and sometimes inaccessible, especially for small businesses operating in underserved regions.

Bitcoin's Lightning Network offers several advantages:

Near-instant transactions.
Minimal transaction costs.
Borderless payments.
Greater financial accessibility.
Improved payment efficiency for microtransactions.
For solar producers who may receive frequent small payments, these characteristics make the Lightning Network particularly attractive.

Building Together
One of the most rewarding parts of the bootcamp was working alongside five other team members with diverse skills and perspectives.

As a team, we combined our strengths in:

Software development.
Product design.
Research and validation.
User experience.
Bitcoin and Lightning integration.
Presentation and communication.
The collaborative environment pushed us to think critically about both the technical and social aspects of the solution we were building.

It reminded me that innovation is rarely an individual effort. Great products emerge when people with different backgrounds work together toward a shared goal.

Learning Beyond Code
The Bitcoin Kisumu Lightning Bootcamp, facilitated by Bitrust, gave me a deeper appreciation for Bitcoin's potential beyond investment and speculation.

Throughout the experience, I gained valuable insights into:

Lightning Network architecture.
Bitcoin payment flows.
Financial inclusion use cases.
Building applications for real-world adoption.
Designing technology for underserved communities.
More importantly, I learned that successful solutions begin with understanding people and their challenges before writing a single line of code.

Key Takeaways
The experience reinforced several important lessons:

Solve Real Problems
Technology has the greatest impact when it addresses genuine community needs.
Financial Inclusion Matters
Millions of people still face barriers to accessing financial services. Bitcoin offers new opportunities to bridge that gap.
Collaboration Accelerates Innovation
Working with a team exposes you to new perspectives and often leads to better solutions.
Bitcoin Has Practical Applications
Beyond being a store of value, Bitcoin and the Lightning Network can power real-world payment systems to reduce the cost to consumers by a reasonable percentage.
Continuous Learning Is Essential
Every project presents an opportunity to learn new technologies, challenge assumptions, and improve problem-solving skills.

Looking Ahead
Participating in the Bitcoin Kisumu Lightning Bootcamp was an inspiring experience that challenged me to think differently about technology, finance, and impact.

I am grateful to Bitrust for creating a platform where developers can learn, build, and experiment with Bitcoin technologies while tackling meaningful challenges in their communities.

As we continue refining our solution for small-scale solar producers, I am excited about the possibilities that Bitcoin and the Lightning Network present for creating more inclusive and efficient financial systems.

The future of technology is not just about building software. It is about building solutions that empower people, strengthen communities, and create opportunities where they are needed most.

Go Web Dev: How Proactive Communication Saves "Ghost" Projects

Charles Otugeh — Fri, 15 May 2026 13:50:19 +0000

The Power of Collaboration
Collaboration is the ultimate hack to overcome your weaknesses as a programmer. No matter how much time you spend reading documentation or writing isolated code, nothing accelerates your growth faster than working with a team. In Go web development, where concurrency, architecture, and performance matter immensely, bouncing ideas off others is the fastest way to level up.However, team collaboration is not automatic. It requires constant maintenance.The Day the Team Went Silent We recently kicked off a new Go web development project. We held our very first stand-up meeting to align on the architecture, and initial API endpoints integration. The energy was high, and everyone seemed ready to build.By the following morning, the reality of remote work set in.The team channel was completely silent. There were no new pull requests, no commits to the main repository, and zero public activity from some members. It felt like a "ghost project."It is easy to assume the worst when a team goes silent. You might think people are stuck, procrastinating, or confused about the requirements. Instead of waiting around for things to fail, I decided to take action.The Short Ask That Changed Everything I reached out to the team chat with a casual, non-judgmental check-in:"Hey team! Let's do a quick sync. Can everyone drop a screenshot or a brief note on what you've been working on so far?"The response was instant. It turned out that my colleague had not been idle at all. They were working locally on a complex continuous integration and deployment pipeline. Within minutes of my message, they replied with an updated workflow file, pushed their active local branch to Gitea, and asked for feedback.
The Gitea Actions workflow my colleague pushed from his branch models.

My Biggest Takeaway Sometimes "inactivity" isn't a lack of work it is simply a lack of communication.Programmers often get trapped in their own heads, trying to perfect a feature or fix a bug before showing it to the world. A simple, proactive check-in breaks that friction. It instantly aligns the team, exposes great work early, and unblocks momentum before time is wasted.Don't wait for the next formal meeting. If your project feels quiet, be the one to spark the conversation.

Gemma 4

Charles Otugeh — Tue, 12 May 2026 13:17:54 +0000

This is a submission for the Gemma 4 Challenge: Write About Gemma 4

Google recently unveiled advance AI agent called Gemma 4. This a multimodal and can give information in several languages, hence it is called multilingual. Gemma 4 can process text, video audio and images across one 140 languages. In addition Gemma 4 exhibits high performing rate, optimizing intelligence. the following parameters are exhibited by Gemma 4: Mixture of Expert which is for strong reasoning this enable a strong functionality and complex performance and supporting AI root-use-protocol. Lastly, Gemma 4 can work multiple hardware.

Advantage of Gemma 4 for developers and industries

It offers Effective @B and $B available for device using edge and mobile.
26B offers higher efficiency while 31B for large-scale and sophisticated performance. Deployment for Gemma 4 depends on Ollama, llamacpp, vLLm and Unsloth.
NVIDIA and TPU
API which is accessed gemini Google AI Studio.

ASCII-Art Web

Charles Otugeh — Wed, 22 Apr 2026 15:23:06 +0000

Over the past two weeks, I have made great progress in Go. I implemented a small program that accepts user input and displays ASCII art on a webpage. What I learned from this project is that it can be embedded on the web to display blurred images.
The interesting part was implementing a mapping server to GET static files from the static directory:

fs := http.FileServer(http.Dir("static"))

This line handles the GET requests by mapping CSS to the Go backend. It is implemented at the top of main.go, followed by this line:

http.Handle("/static/", http.StripPrefix("/static/", fs))

I enjoy using HTML and CSS to create nice-looking webpages.

follow the link to get the whole code: https://github.com/ckotugeh/ascii-art-webs

Golang vs JavaScript

Charles Otugeh — Sat, 21 Mar 2026 16:08:34 +0000

Golang Experience in Comparison to JavaScript: A Practical Perspective
In the modern software landscape, developers often find themselves choosing between multiple programming languages depending on the problem they want to solve. Two popular choices Golang (Go) and JavaScript (JS) offer very different development experiences. While both are powerful in their own right, they differ significantly in philosophy, performance, ecosystem, and use cases. This article explores what it feels like to work with Golang compared to JavaScript from a practical, developer-focused perspective.

Language Philosophy and Design

Golang was designed with simplicity, performance, and concurrency in mind. Its syntax is minimalistic, avoiding unnecessary abstractions and enforcing a strict structure. The language encourages clarity over cleverness, making codebases easier to read and maintain.
JavaScript, on the other hand, is highly flexible and dynamic. Originally built for the browser, it has evolved into a multi-paradigm language supporting functional, object-oriented, and event-driven programming. This flexibility is powerful, but can also lead to inconsistency across projects.
Experience takeaway:
Go feels disciplined and predictable.
JavaScript feels expressive but sometimes chaotic.

Performance and Efficiency

Performance is one of Golang’s strongest advantages. Being a compiled language, Go produces fast, efficient binaries that run close to system-level performance. It is particularly well-suited for back-end systems, APIs, and microservices.
JavaScript, being interpreted (or JIT-compiled), is generally slower in raw execution. However, modern engines like V8 have significantly improved its speed. Still, for CPU-intensive tasks, it lags behind Go.
Experience takeaway:
Go excels in performance-critical applications.
JavaScript is “fast enough” for most web use cases.

Concurrency and Scalability

Concurrency in Go is a standout feature. With goroutines and channels, developers can easily write concurrent programs without dealing with complex thread management. This makes Go highly effective for scalable backend services.
JavaScript uses a single-threaded event loop with asynchronous patterns like callbacks, promises, and async/await. While powerful, handling concurrency can become complex, especially in large applications.
Experience takeaway:
Go makes concurrency simple and natural.
JavaScript requires more careful handling of async logic.

Tooling and Developer Experience

Golang comes with built-in tooling that works seamlessly; formatting, testing, dependency management, and compilation are all standardized. This reduces setup time and eliminates “tool fatigue.”
JavaScript has a vast ecosystem with countless tools, frameworks, and libraries. While this provides flexibility, it also leads to fragmentation. Developers often spend time choosing and configuring tools rather than building features.
Experience takeaway:
Go offers a smooth, consistent development workflow.
JavaScript offers choice—but at the cost of complexity.

Ecosystem and Use Cases

JavaScript dominates frontend development and is essential for building interactive web applications. With Node.js, it also powers backend systems, making it a full-stack language.
Golang is primarily used for backend services, cloud infrastructure, and DevOps tools. It shines in building APIs, distributed systems, and high-performance servers.
Experience takeaway:
JavaScript is unavoidable for web interfaces.
Go is ideal for backend performance and reliability.

Learning Curve

Golang is relatively easy to learn due to its small syntax and strict rules. Developers can become productive quickly.
JavaScript has a steeper learning curve—not because of syntax, but due to its quirks, asynchronous behavior, and evolving ecosystem.
Experience takeaway:
Go is beginner-friendly and straightforward.
JavaScript requires deeper understanding over time.

Conclusion

Choosing between Golang and JavaScript is less about which language is better and more about which is better suited to your needs.
If you want simplicity, performance, and strong concurrency Go is an excellent choice.
If you need flexibility, rich ecosystems, and frontend capabilities JavaScript is indispensable.
Many modern systems even use both: JavaScript for the frontend and Go for the backend. Understanding the strengths of each allows developers to build more efficient, scalable, and maintainable applications.
In the end, the best developers aren’t loyal to one language thLearning Curve
Golang is relatively easy to learn due to its small syntax and strict rules. Developers can become productive quickly.
JavaScript has a steeper learning curve not because of syntax, but due to its quirks, asynchronous behavior, and evolving ecosystem.
Experience takeaway
Go is beginner-friendly and straightforward.
JavaScript requires deeper understanding over time.They're fluent in choosing the right tool for the job.

By Charles Otugeh
Penetration tester,Software Developer apprentice at Zone01 Kisumu
kotugeh@gmail.com
+254704433824