DEV Community: Chibueze felix

New Go Tools You Should Know: Level Up Your Development!

Chibueze felix — Fri, 13 Jun 2025 08:42:07 +0000

Hey Gophers! 👋 Ever feel like your Go toolkit could use a refresh? Today, we’re spotlighting five new (or newly updated) tools that can seriously upgrade your workflow—whether you’re building AI apps, squeezing out performance, or diving into embedded systems. Let’s jump in!

1️⃣ redis/go-redis v9.10.0 (Vector Sets)

What it is: The popular Redis client for Go, now with experimental vector set support.
Why it’s cool: Unlock AI/ML superpowers in Redis! Store and query vector embeddings (think: semantic search, recommendation engines) without leaving your Go app.
Simple use case:

// Store & query vectors  
client.Do(ctx, "VSET", "user_embeddings", "id123", []float32{0.1, 0.8, -0.2})  
result := client.Do(ctx, "VSEARCH", "user_embeddings", "K=5", "VECTOR", queryVector)

2️⃣ gorse-io/goat

What it is: A Go assembly transpiler that converts C code to Go assembly.
Why it’s cool: Turbocharge performance-critical code by leveraging C’s optimizations (like SIMD instructions) in Go.
Simple use case:

goat -i optimized.c -o optimized_amd64.s # Transpile C to Go assembly

Then call it from Go:

// Go wrapper  
func FastMatrixMul(a, b []float64) []float64 { ... }

Ideal for: Math-heavy workloads (e.g., data processing) 🚀

3️⃣ hybridgroup/tinygo-tkey

What it is: A library for programming the Tillitis TKey-1 (open-source USB security key) using TinyGo.
Why it’s cool: Build ultra-secure embedded apps with Go—think hardware-backed auth or cryptographic tools.
Simple use case:

import "github.com/hybridgroup/tinygo-tkey"  
func main() {  
    tkey.BlueLEDOn()  // Control hardware directly!  
    // Sign data with the key’s secure enclave  
    signature := tkey.Sign([]byte("LOCK"))  
}

Great for: DIY security keys or hardware-bound secrets 🔒

4️⃣ BrownNPC/Raylib-Go-Wasm

What it is: Raylib bindings for Go + WebAssembly.
Why it’s cool: Build 2D games or visualizations in Go and run them in the browser.
Simple use case:

import rl "github.com/BrownNPC/Raylib-Go-Wasm/raylib"  
func main() {  
    rl.InitWindow(800, 600, "Go in Browser!")  
    for !rl.WindowShouldClose() {  
        rl.DrawText("Hello, WASM!", 100, 100, 20, rl.Black)  
    }  
}

Build: Web-based games, interactive demos, or data viz 🎮

5️⃣ asdf-vm/asdf

What it is: A multi-language version manager (not Go-specific, but a lifesaver for Gophers).
Why it’s cool: Switch between Go versions (or Node/Python/Ruby) per-project with one command.
Simple use case:

asdf plugin-add golang  
asdf install golang 1.22.1  
asdf local golang 1.22.1  # Sets version for current project

No more: go version conflicts across projects! ✨

Wrapping Up

These tools open doors to new domains (AI, embedded, gaming), boost performance, and simplify workflows. Try one in your next project:

Store vectors with go-redis/v9 → GitHub

Optimize C code with goat → GitHub

Hack hardware with tinygo-tkey → GitHub

Build WASM games with Raylib-Go-Wasm → GitHub

Manage versions with asdf → GitHub

Go explore—and level up your 2024 code! 🚀

Cover image via GopherCon. Tools sourced from Go Weekly.

What’s your favorite new tool? Share below! 👇

Get Better at Golang with these hacks..!!!!!

Chibueze felix — Mon, 07 Apr 2025 09:41:33 +0000

Matty

Mar 28 '25

Boost Your Golang Development Efficiency with These Tools

#webdev #programming #devops

Comments 7

3 min read

Understanding Operating System concepts

Chibueze felix — Sun, 30 Mar 2025 20:41:58 +0000

Hello Felix what do you understand by "MUTEX"?

Yes, that was the question that was thrown at me on one of those interview days I had in the past, and it got me stuttering🤔.
I honestly responded that I had not idea what that is😒. And yes, honesty is good however, every software engineer is expected to know some basic concepts; especially those that are core to the system on which most software runs - An Operating system.

The operating system is the core software of every device, it is the parent software on which other software runs; that is the most basic definition I could get for an operating system.

Being the core of every other operations that happens on a system(system here can be a server, a phone, a Payment terminal etc), it is expected that data is stored, processed and easily accessible in the best ways possible. However, for this efficiency to be achieved by any software engineer it is expected that one understands some basic concepts related to the operating system(OS).

A good understanding of these concepts will make you a better engineer and this will be evident in what data types you utilise and in one's algorithms to access or process such data efficiently.

In this article we will provide clarity to a few operating system concepts these include:

Stacks
Heaps
Threads
Mutex
Scheduling

Please note that these are just a few OS concepts and We can not exhaust all in one article as it is intended to be as short and possible to clarify these handpicked topics 😄. Lets get to it.

Stacks

A stack is a last-in, first-out (LIFO) data structure that plays a key role in operating systems. Think of it like a stack of plates—adding or removing items only happens at the top. In programming, the call stack keeps track of function calls, storing return addresses and local variables. When you call a function, the OS pushes a new frame onto the stack; when the function returns, that frame gets popped off. Exceeding the allocated stack memory—often due to infinite recursion—results in a stack overflow. Stacks provide fast and predictable memory allocation, making them essential for function execution.

Heaps

Heaps are used by OS memory managers for dynamic memory allocation. Unlike stacks, heaps allow flexible allocation and deallocation, though at the cost of efficiency. When a program calls malloc() or new, memory is allocated from the heap. Over time, repeated allocation and deallocation can lead to fragmentation, making memory usage less efficient. To combat this, modern OSes use strategies like buddy allocation and slab allocation. A common issue with heap memory is memory leaks—when allocated memory isn’t freed, it slowly consumes system resources, potentially leading to performance degradation or crashes.

Threads

A thread is the smallest unit of execution that an OS scheduler manages. If a process is a running program, threads are independent execution paths within that process. Since threads share the same memory space but have separate execution stacks, they enable concurrent execution without the overhead of creating new processes. OSes support kernel threads (managed by the OS) and user threads (managed by libraries like pthreads). Multithreading is crucial for taking advantage of modern multicore processors, improving responsiveness and parallelism. Since thread context switching is lighter than process switching, threads are an efficient way to handle multiple tasks concurrently.

Mutex

A mutex (short for mutual exclusion) is a synchronisation mechanism that ensures only one thread accesses a shared resource at a time. Think of it like a bathroom key—only one person can hold it at a time, and others have to wait. Mutexes prevent race conditions, where multiple threads modifying shared data simultaneously can lead to unpredictable results. However, they need to be used carefully—improper usage can lead to deadlocks (where threads are stuck waiting for each other) or priority inversion (where a low-priority thread holds up a high-priority one). Thoughtful mutex design is key to writing thread-safe concurrent programs.

Scheduling

Scheduling determines how the OS assigns CPU time to threads. The goal is to balance performance, fairness, and responsiveness. Common scheduling strategies include round-robin (giving each thread a fixed time slice), priority-based (favoring higher-priority tasks), and multilevel feedback queues (dynamically adjusting priorities based on behavior). Real-time operating systems take scheduling further by guaranteeing response times for critical tasks. Every time the OS switches from one thread to another, a context switch occurs, which involves saving and restoring CPU state. Efficient scheduling is essential for ensuring smooth system performance and optimal resource utilisation.

These concepts provide basic insights into data types and the operations used in basically all Operating systems, feel free to research more on other concepts related to the OS such as Security, Memory management, Concurrency,Interrupt, Kernel.🚀🚀🚀.

Thanks for your time !!!🚀🚀🚀

Embed Google Ads in Flutter Using Native Ads

Chibueze felix — Sun, 29 Sep 2024 01:46:36 +0000

While implementing this feature on an app I found the following links useful, hence i thought I should share here. You may seek some examples , however I also added a link to small application provided by the team which you can customize you to your niche idea:

Get Started here:

All About Native Ads,

Native set up for Android and iOS:

Example App:

Flutter Package

Thanks for your time.

Happy Hacking !!.

Managing dependencies like a pro in Android with version catalogs

Chibueze felix — Wed, 18 Sep 2024 01:37:44 +0000

While building multi-modular android applications it can be a painful task to manage dependencies especially when one have to maintain project one inherited...haha, in this post we will see better ways of setting up our dependencies so they can be managed better form one single file even in large projects.
In this article we will cover the following:

What is version catalog
Steps How to Migrate to version catalog **

What is version catalog

**
Before now, how you add dependencies to your project in a modern android application it painfully like so:

// .....
//other codes.....
dependencies {

    implementation("androidx.core:core-ktx:1.10.1")
    implementation("androidx.lifecycle:lifecycle-runtime-ktx:2.6.1")
    implementation("androidx.activity:activity-compose:1.7.0")
    implementation(platform("androidx.compose:compose-bom:2023.08.00"))
    implementation("androidx.compose.ui:ui")
    implementation("androidx.compose.ui:ui-graphics")
    implementation("androidx.compose.ui:ui-tooling-preview")
    implementation("androidx.compose.material3:material3")
    testImplementation("junit:junit:4.13.2")
    androidTestImplementation("androidx.test.ext:junit:1.1.5")
    androidTestImplementation("androidx.test.espresso:espresso-core:3.5.1")
    androidTestImplementation(platform("androidx.compose:compose-bom:2023.08.00"))
    androidTestImplementation("androidx.compose.ui:ui-test-junit4")
    debugImplementation("androidx.compose.ui:ui-tooling")
    debugImplementation("androidx.compose.ui:ui-test-manifest")
}

Hold on a second! imagine for a moment, you have to do this for every build.gradle file for every module in a multi modular project say with about 20 modules; Welcome back, yes many survived it,I did, however its time consuming especially when you face managing compatibility and versions between modules. This is where version catalogs becomes a hero for saving your development time as well as future managements and dependencies upgrade, isn't that great? just have one place to look for all application dependencies.

According to google developers,

Gradle version catalogs enable you to add and maintain dependencies and plugins in a scalable way. Using Gradle version catalogs makes managing dependencies and plugins easier when you have multiple modules. Instead of hardcoding dependency names and versions in individual build files and updating each entry whenever you need to upgrade a dependency, you can create a central version catalog of dependencies that various modules can reference in a type-safe way with Android Studio assistance.

So basically , a version catalog file is a TOML file that is used to manage dependencies in modern android development.

The TOML file consists of 4 major sections:
the [versions] section is used to declare versions which can be referenced by dependencies
the [libraries] section is used to declare the aliases to coordinates
the [bundles] section is used to declare dependency bundles
the [plugins] section is used to declare plugins

Steps How to Migrate to version catalog

For brevity, there for about six simple steps to migrate and enjoy the benefits of version catalogs:

Create a version catalog file: In the root project gradle folder create the libs.versions.toml Add these sections to it:

[versions]

[libraries]

[plugins]

Each sections hold version numbers, gradle libraries and plugins respectively.

Add the new entry to the file

Next we will add implementation("androidx.core:core-ktx:1.10.1") to the newly created file, by first adding the version number then the library in the respective sections:

[versions]
ktx-version ="1.10.1"

[libraries]
androidx-ktx = { group = "androidx.core", name = "core-ktx", version.ref = "ktx-version" }
[plugins]
....

Sync the Android project
Once the previous step is done rightly you may sync gradle to update the new settings of your project.
Replace the previous string declaration with the catalog type-safe accessor:
Do the previous steps 2 and 3 for every new dependency you add to the libs.versions.toml file.
Add the plugins to the plugins block :
Just like the previous steps you would need to. add the version of th e plugin in the versions section but this time the dependency goes to the plugin section of the file, like so:

[versions]
ktx-version ="1.10.1"
androidGradlePlugin = "7.4.1"
//....
[plugins]
android-application = { id = "com.android.application", version.ref = "androidGradlePlugin" }

Referencing the catalog : In your build.gradle file (app) you can refer to the plugins with alias ,and libraries with implementation , see below for examples:

// Top-level build.gradle.kts
plugins {
   alias(libs.plugins.android.application) apply false

}

// module build.gradle.kts
plugins {
   alias(libs.plugins.android.application)

}

dependencies {
   implementation(libs.androidx.ktx)

}

Now you may go ahead and add more dependencies for all modules, as much as you want. Each module will reference same libs.versions.toml file so no issues with incompatible versions or wrong version

Pro Tip

Use alias for plugins in the version catalog aand id for plugins not in the version catalog.
If you are using Gradle version below 8.1 you need to annotate the plugins{} block with @Suppress("DSL_SCOPE_VIOLATION") when using version catalogs.

Well done, you have read this far !! Do well to share....

Managing Flutter Versions with fvm. Let's Talk FVM 🚀

Chibueze felix — Wed, 11 Sep 2024 05:03:35 +0000

Suffice it to say ,nearly every flutter developer like myself has had one point or another work with projects with different flutter versions based on when such projects were first compiled or created or even by subsequent builds/updates. If one happens to work on such projects from the-same computer, there is need for you to manage the versions of flutter for which you are running thoe projects, especially if there dependencies that depends on specific version flutter fvm package is here to save the day. In this are article we will shortly explain:

What fvm is
How to install fvm
How to set fvm setup
How to use fvm
How to switch flutter channels

So, you've been diving deep into Flutter development, crafting beautiful UIs, and bringing your app ideas to life. But let me ask you this: have you ever found yourself in a sticky situation where one project needs Flutter 2.5, another needs 3.0, and your latest experiment demands the bleeding edge version? If you're nodding your head (or even if you're not), let me introduce you to your new best friend: Flutter Version Management, or FVM for short!

What's FVM and Why Should You Care?

FVM is a simple cli to manage Flutter SDK versions per project. It support channels, releases and local cache for fast switching between versions.

FVM is like having a magical Flutter toolbox that lets you switch between different Flutter versions faster than you can say "hot reload." It's a game-changer for developers like us who juggle multiple projects or just love to experiment with the latest Flutter features without breaking our stable apps.

Getting Started with FVM

Install FVM First things first, let's get FVM on your machine. Open up your terminal and type:

   dart pub global activate fvm

Just like that, you've taken your first step into a larger world!

Use FVM in Your Project Navigate to your Flutter project directory and run:

   fvm use <version>

Replace <version> with the Flutter version you want. For example:

   fvm use 3.10.0

FVM will download and set up this version for your project. Magic, right?

Switch Between Versions
Working on an older project? No problem! Just use the same command with a different version. FVM makes it as easy as changing your socks (and much more exciting).
List Available Versions
Feeling adventurous? Check out what versions are available:

   fvm list

It's like a buffet of Flutter goodness!

Pro Tips for FVM Mastery

Use FVM in Your CI/CD Pipeline: Ensure consistent builds across your team and CI environment. It's like giving everyone the same LEGO set to build with!
Try Flutter Beta Channels: Want to live on the edge? Use FVM to experiment with beta releases without affecting your stable setup.
Project-Specific Settings: Create a .fvmrc file in your project root to specify the Flutter version. It's like leaving a note for your future self (and your teammates).

Wrapping Up

FVM is more than just a tool; it's your ticket to a smoother, more flexible Flutter development experience. It's like having a time machine for your Flutter SDK – you can jump back and forth between versions without breaking a sweat.

Remember, the goal isn't just to manage versions; it's to give you the freedom to create, experiment, and build amazing things with Flutter. So go ahead, give FVM a spin, and watch your Flutter workflow transform!

Happy coding, and may your widgets always align perfectly! 🎉📱💙

How to to attach a function to a struct in Golang

Chibueze felix — Sun, 04 Aug 2024 21:25:28 +0000

If you are coming from other languages such as php, C# , Dart etc you would be familiar with creating methods for classes. Usually these methods implement one action for that class. In such OOP languages you create such methods in the class scope such as :

class ClassName{
....
 function functionName(){
  // perform action
}
}

In go you first create a struct then you can attach receivers to perform specific actions for the struct. For instance we have as model User to which we want it to have a method that returns the user's full name we have that as shown below:

type myUser struct{
 FirstName string
LastName string
PostalCode string
DateOfBirth time.Time
}

Above we just created a User type with the various attributes such as FirstName, LastName .... , we want to have a method that perform some special action for the 'myUser' type in this case just return the full name form the stated attributes FirstName,LastName.

We can go n a create a receiver function fullname that returns a string.

func (user *myUser) fullname() (string, string){
   return user.FirstName ,user.LastName
}

How can we use this? we could test this directly in the main function just to see how it works:

func main() {

    user := myUser{
        FirstName: "Felix",
        LastName:  "chi",
    }
    fmt.Println(user.fullname())

}

Hence we have successfully created a receiver method for our myUser struct. The full code will loke like so:

package main

import (
    "fmt"
    "time"
)

type myUser struct {
    FirstName   string
    LastName    string
    PostalCode  string
    DateOfBirth time.Time
}

func (user *myUser) fullname() (string, string) {
    return user.FirstName, user.LastName
}

func main() {

    user := myUser{
        FirstName: "Felix",
        LastName:  "chi",
    }
    fmt.Println(user.fullname())

}

So whats next? go ahead and paste code on https://go.dev/play/ to see how it truly works. See in your on my next post...!!!!

How to add Firebase CLI to your Flutter Project- Fast Steps

Chibueze felix — Wed, 09 Aug 2023 18:21:51 +0000

First of all a quick disclaimer this will be quick and short as well directly targeted at macOS users.
What motivated me to do this because I needed a TLDR version of doing this and it took time and various tabs to achieve. So this might help and save you some time

Create and app on firebase enter your name of choice.

Add firebase to your PATH like so:
on your terminal enter nano ~/zshrc
add this to the list export PATH="$PATH":"$HOME/.pub-cache/bin" quit and save

Install firebase tool with command
on your terminal enter curl -sL firebase.tools | upgrade=true bash

Enter password(if any)
Login to firebase
on your terminal enter firebase login this open your browser and ask for access to your firebase account.

Activate firebase on your app. On the directory of your flutter project.
on your terminal enter flutter configure
This configures all requirement onto your app. Confirm installation with firebase --version

Add flutter_core package to you app.

Thats it. Short right?? Now you can use most firebase services such as Firebase app distribution, realtime database etc.

Connect with me on linkedIn and twitter 😋

Convert Widget (a view) to image in flutter

Chibueze felix — Sat, 22 Jul 2023 16:29:49 +0000

I get this question a lot if I am also a flutter developer and most recruiters ask me if I have equal proficiency in both, and most of the time my response to this is yes I do have equal proficiency in both and I am on the journey of adding more technologies to my stack as it relates to mobile application development.

To the subject how do you convert and widget to an image programmatically? Yes, many would go for the screenshot package in pub.dev. However, I am a great advocate of having lighter applications, and I love taking full control of what a feature does even if I am using a plugin, package or library. Now the aforementioned package is awesome and allows you to take screenshots and save them as an image, how about you want to convert your widget to another file format asides from PNG or JPEG?

Here I am going to show you how to convert your widget to any file format you wish and perhaps be able to share it in that format, provide you can save it to the device you work with.

Now flutter is a rendering framework, that mostly works on a rendering engine. See here for more, And we can utilize the rendering service to do so much provided we can render such a view.

Firstly, let's mention an important setup on the view you want to convert and I must mention that you can convert whatsoever, remember everything is a widget in flutter. Oh boy! show me some code already :)

Import required services into your widget

import 'dart:io';
 import 'dart:ui' as ui; 
import package:flutter/foundation.dart';
 import 'package:flutter/material.dart';
 import 'package:flutter/rendering.dart';

Create a Global key and create a nullable file(where we can save the file)

GlobalKey _yourGlobalKey = GlobalKey();
File? widgetFilePath;

Wrap the widget you want to convert with the RepaintBoundary

RepaintBoundary(
key: _globalKey,
child: Container()

Replace the container widget with any other of your choice

Create the capture function that captures the wrapped widget through _yourGlobalkey you created.

Future<ui.Image> captureWidgetImage() async {
RenderRepaintBoundary boundary =_globalKey.currentContext!.findRenderObject() as RenderRepaintBoundary;
final image = await boundary.toImage(pixelRatio: 1.0);

return image;
}

Now we have the set-up complete and create the function how can we call the captureWidgetImage function.

Now we can actually just capture the widget but what can we do with it ? how about we save the image :)

Future<void> saveImageAsPng() async {

/// TODO Check File write permission
/// you can change the format here to pdf,jpeg etc

//1 widgetFilePath = File(appDocDirectory.path + '/capturedWidget.png');

//2
if(mounted){

//3 ui.Image image = await captureImage();

//4 ByteData? byteData = await image.toByteData(format: ui.ImageByteFormat.png);
//5 if (byteData != null) {

//6 final buffer = byteData.buffer.asUint8List();

//7 await widgetFilePath?.writeAsBytes(buffer);
}

}

Using the save saveImageAsPng and captureWidgetImage
You can use these functions by calling saveImageAsPng() in say a button click when you do this
i. A widgetFilePath file u created initially is then initialised and assigned a path and a name.
ii. In #2 You check if the widget is still in the tree and not disposed you initialise ui.Image and call the captureImage in #3 Remember it returns an image.

iii. since better work on images as bytes data in #4 we convert the to bytes with toByteData and format it into png format
iv. In #5 we check we actually have an image and then in #6 we convert these bytes to a usable list asUint8List and write the parts of this list to the file we created initially.

Thats it....!
Where to go next!!!!
You can share images and save them in your gallery or show users in a pop, a very good use case is to show or share qr images, show or share receipts etc.

Here is a GitHub gist of more code 👨‍💻

Thanks for reading this far, until next time, you reach out to me on linkedin, happy hacking👨‍💻 !!!