DEV Community: Azeez Abiodun Solomon

Introducing gitresume, an open-source cli tool for building résumé with LLM support

Azeez Abiodun Solomon — Fri, 28 Nov 2025 21:51:01 +0000

One of the challenges I’ve faced in the past is keeping track of my contributions across different projects, teams, and companies. When it’s time to update my résumé during a job search, it often turns into a struggle to recall what I’ve recently accomplished.

This is why I built Gitresume, a tool that helps me:

Keep track of my contributions
Create résumés with AI assistance
Gain insights from my Git commits
Export my résumé in multiple formats

Installation

To get started, visit https://gitresume.app and follow the installation instructions.
You’ll need to install the Gitresume CLI, which is available for Windows, macOS, and Linux.

Mac OSX

 $ brew tap iamhabbeboy/homebrew-tap
 $ brew install iamhabbeboy/tap/gitresume

Linux

curl -sL https://raw.githubusercontent.com/iamhabbeboy/gitresume-cli/main/install.sh | bash

Windows

choco install gitresume --version=0.1.0

Create your first resume

To create a résumé, start the Gitresume server using the command below.
But first, verify that the installation was successful:

$ gitresume

Usage:
  gitresume [command]

Available Commands:
  ai          Test AI integration
  help        Help about any command
  init        Initialize gitresume config
  seed        Seed your commit messages
  serve       Web dashboard for managing your resumes

Flags:
  -h, --help   help for gitresume

Use "gitresume [command] --help" for more information about a command

Then start the server using

$ gitresume serve

🚀 Starting dashboard on http://localhost:4000
✨ Build your resume visually...

Next, open your browser and navigate to the dashboard URL. From there, click on Resumes.

Click Create Resume to begin

You can now start editing the form and customizing your résumé

Check out the full demo on how to create your résumé with Git activity + AI support

How to upgrade TLS version for serverless service on GCP (Google Cloud Platform)

Azeez Abiodun Solomon — Thu, 29 Sep 2022 22:44:12 +0000

For the past few days, I've been battling with the issue of upgrading the TLS version for a few cloud-run apps, the plan is to set the minimum version to v1.2 as required by slack, After a lot of trial and error, I got it fixed and I will be discussing the procedures in this blog post.

What is TLS?

TLS (Transport Layer Security) is a cryptographic protocol developed to provide communication security over a network, it is widely adopted to facilitate privacy and data over the internet network. TLS is used in securing HTTPS, which means that HTTPS(Hypertext Transfer Protocol Secure) uses TLS to ensure data integrity over the internet.
It was earlier called SSL, which was later changed to TLS in 1999.

Our current setup

We have three(3) cloud run services;

A website
A REST API endpoints
Slack bot

This procedures requires that we:

Reserve an external static IP Address
Setup Load balancer
Create certificate
Create an SSL Policy
Setup Network endpoint group
Create an A record to map the cloud run app(in our case, yours could be cloud functions, app engine, etc) domain with the IP Address reserved in step 1

Reserve an external static IP Address

An idea approach will be to reserve external static IP Addresses for each of the services, alongside with load balancer which tends to cost us more, so instead we reserve an IP address to be used for all.

Create a load balancer

Load balancing refers to an efficient approach to distributing incoming network traffic across a group of backend servers,server farm or server pool.

Setting up a load balancer allows us to configure other steps listed above.

Click on HTTPS

Make sure global load balancing (classic) is selected

Setup frontend that distribute traffic
The frontend configuration of the load balancer requires that you specified a reserved IP address, protocol type, certificate and SSL policy.This is the most important part of the load balancing as you need to carefully provides the appropriate information for all the required fields as seen in the screenshots below.

Select the IP Address you reserved earlier

Click on create policy to create if you haven’t done that before

You need to specify your TLS minimum version for the new SSL policy.

Click on backend configuration, when you're done with the frontend.

Click on create backend configuration and create new backend service or select if you already have one.

Create network endpoint group
A network endpoint group (NEG) is a configuration that specifies group of backend services, it is common used for deploying service in container.

At this point, you need to select your serverless network type, in my own case, its cloud run.

By selecting the serverless NEG type, it should list out your current app running.

Finally 🎉, You can decide to create multiple backend for multiple services depending on your setup, which should give you something related to this or just have a single backend service.

Setup A record for DNS mapping

How to check the TLS version

Install a cli tool called nmap, and run

nmap --script ssl-enum-ciphers -p 443 domainname.com

Your output should be... viola 🎉

PORT    STATE SERVICE
443/tcp open  https
| ssl-enum-ciphers: 
|   TLSv1.2: 
|     ciphers: 
|       TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256 (ecdh_x25519) - A
|       TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384 (ecdh_x25519) - A
|       TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256 (ecdh_x25519) - A
|     compressors: 
|       NULL
|     cipher preference: client
|   TLSv1.3: 
|     ciphers: 
|       TLS_AKE_WITH_AES_128_GCM_SHA256 (ecdh_x25519) - A
|       TLS_AKE_WITH_AES_256_GCM_SHA384 (ecdh_x25519) - A
|       TLS_AKE_WITH_CHACHA20_POLY1305_SHA256 (ecdh_x25519) - A
|     cipher preference: client
|_  least strength: A

Nmap done: 1 IP address (1 host up) scanned in 2.83 seconds

I'm sure you might be surprised to see TLSv1.3 by default,😉 Yes!, that's because google adds it for every certificate at the time of writing this post.

Thanks for reading ✌️

Build Web App with Go for Beginners Part II

Azeez Abiodun Solomon — Sun, 07 Jun 2020 11:51:40 +0000

... Thanks for reading the Part I, here's the continuation.

Setting up routes

We're going to setup our routes using mux package as stated here.The following routes would be created just for our app.

/: Homepage and listing todo page
/add: Add todo page
/delete/:id Delete todo action

main.go

package main

import (
    "fmt"
    "github.com/gorilla/mux"
)

func main() {
    r := mux.NewRouter()
    r.HandleFunc("/", controllers.TodoList)
    r.HandleFunc("/add", controllers.TodoAdd)
    r.HandleFunc("/delete/{id}", controllers.TodoDelete)
    http.Handle("/", r)

    fmt.Println("Server started")
    http.ListenAndServe(":3000", nil)
}

Starting the server, You would surely get errors here, but don't worry😉 it's due to the controller package not yet included in the import.

go run main.go

We could decide to create our route functions inside the main.go but for better code structure and readability, we decided to move the functions to a controller package called TodoController.go which is why we have the snippet controllers with references to their appropriate functions in TodoController.go

 controllers.Todo***

Setting up Model

For the simplicity of the app, MySQL database is used with GORM
database/connect.go

package database

import (
    "fmt"
    "log"

    "github.com/jinzhu/gorm"
    _ "github.com/jinzhu/gorm/dialects/mysql"
)

func Init() *gorm.DB {
    user := "root"
    pass := "password"
    host := "localhost"
    dbName := "todo"

    credentials := fmt.Sprintf("%s:%s@tcp(%s:3306)/%s?charset=utf8&parseTime=True&loc=Local", user, pass, host, dbName)

    db, err := gorm.Open("mysql", credentials)

    if err != nil {
        log.Fatal(err)
    }

    return db
}

Here is the structure of our table todo, the SQL version of the Gorm struct model is listed below.

id int(10)
title varchar(255)
completed tinyint(1)
created_at datetime
updated_at datetime
deleted_at datetime

models/Todo.go

package models

import (
    "github.com/jinzhu/gorm"
)

type Todo struct {
    gorm.Model
    Title     string
    Completed bool
}

Handling the logic in the controller

This package is created to handle the logic of the models and views.To render the view, Go has a pre-built package called html/template. We also have;
github.com/iamhabbeboy/todo/database and github.com/iamhabbeboy/todo/models which is the path to both our models and database packages.
controllers/TodoController.go

package controllers

import (
    "fmt"
    "html/template"
    "log"
    "net/http"

    "github.com/iamhabbeboy/todo/database"
    "github.com/iamhabbeboy/todo/models"
)


func TodoList(w http.ResponseWriter, r *http.Request) {
    view, err := template.ParseFiles("views/list.html")
    if err != nil {
        log.Fatal("Template not found ")
    }

    db := database.Init()
    var todos []models.Todo

    query := db.Find(&todos)

    defer query.Close()

    view.Execute(w, todos)
}

views/list.html

<h1>List Todo</h1>
<ul>
    {{ range .}}
        <li>{{ .Title }} <a href="/delete/{{.Model.ID}}" style="color: red">&times;</a> </li></li>
    {{end}}
</ul>

<a href="/add">Add New </a>

We would be using /add route to perform two(2) operations, which are:

GET: renders the add page
POST: Handles the form request

Which is why we have the switch statement to check the current request.

controllers/TodoController.go

...

func TodoAdd(w http.ResponseWriter, r *http.Request) {
    switch r.Method {
    case "GET":
        TodoForm(w, r)
    case "POST":
        ProcessTodoForm(w, r)
    }
}

func TodoForm(w http.ResponseWriter, r *http.Request) {
    t, err := template.ParseFiles("views/add.html")
    if err != nil {
        fmt.Println(err)
    }

    t.Execute(w, nil)
}

func ProcessTodoForm(w http.ResponseWriter, r *http.Request) {
    title := r.FormValue("title")
        if title == "" {
        http.Redirect(w, r, "/", 302)
    }
    db := database.Init()
    todo := models.Todo{
        Title:     title,
        Completed: false,
    }
    db.Create(&todo)
    http.Redirect(w, r, "/", 302)
}

views/add.html

  <form method="POST">
        <h1>Todo App</h1>
        <label>Title</label> <br/>
        <input type="text" name="title" required/>
        <br/>
        <input type="submit" value="Add+" />
    </form>

Delete Todo

In other to get todo Id from the /delete route, We have to extract GET params using mux.Vars(r) which requires you to add

import("github.com/gorilla/mux")

...
func TodoDelete(w http.ResponseWriter, r *http.Request) {
    vars := mux.Vars(r)
    id := vars["id"]
    if id == "" {
        http.Redirect(w, r, "/", 302)
    }
    db := database.Init()
    var todos []models.Todo
    db.Where("id = ?", id).Delete(&todos)
    http.Redirect(w, r, "/", 302)
}

Performing the delete action redirects the page back to the homepage that contains list of todos. This is done with http.Redirect(w, r, "/", 302) from import ("net/http").

Thanks for reading, checkout the full source code on github

Build Web App with Go for Beginners Part I

Azeez Abiodun Solomon — Fri, 29 May 2020 22:04:14 +0000

Go was designed at Google in 2007 to improve programming productivity in an era of multicore, networked machines and large code bases.The designers wanted to address criticism of other languages in use at Google, but keep their useful characteristics.

During past couple of days I have been learning Golang and I noticed some of the challenges I faced was the lack of constraints or standards, choosing external packages and much more😭. I would like to share some findings that have worked for me and also walk you through the steps by building a simple todo app.

Prerequisites

A Golang compiler installed on your Machine
An IDE or text editor
Basic understanding of Go
Basic understanding of HTML and CSS
Basic understanding of SQL (Only required to create Database 😉)

Project Layout

We would start by creating a module for our project so as to better track our packages in a file called go.mod which would makes it easier for distribution or deployment. it's more like package.json or composer.json.

 go mod init github.com/iamhabbeboy/todoapp

Next, we need to create the following folders.

You don't have to follow this structure.😊

todoapp
├──models
|   └── Todo.go
├── controllers  
|    └── TodoController.go
├── database
|     └── connect.go
├── views  
|     └── index.html
|     └── create.html
|── main.go
|── .env

Packages

The following packages would be used to better develop our project.

Gorm: Go ORM that support mysql and other databases.

go get -u github.com/jinzhu/gorm

Mux: It's handles our routes and requests.

go get -u github.com/gorilla/mux

Godotenv: Would be used to access our .env variables

go get github.com/joho/godotenv

MySQL driver: Allow connection to MySQL DB

 go get github.com/go-sql-driver/mysql

I wouldn't want you to be bored with this post so I decided to split it into two. The other part would be posted in the comment section soon.

Please do leave a comment in case you have any contributions, I would really appreciate that.😉

Thanks for reading.❤️

Advice on how to pass algorithm questions

Azeez Abiodun Solomon — Thu, 27 Jun 2019 19:35:58 +0000

I've been failing algorithm tests for interviews even after studying and practicing with hackerrank. I would love you guys to share your personal experiences and give advice and procedures to become better.

Quick guide to Vuex

Azeez Abiodun Solomon — Fri, 15 Mar 2019 21:34:06 +0000

Vuex is a package developed to manage the state of data in Vue app. In other words, Vuex manages all the data we ever needed inside our app.

Prerequisites

Basic understanding of Vue
Basic understanding of REST API

What is Vuex?

Vuex is a state management pattern + library for Vue.js applications. It serves as a centralized store for all the components in an application, with rules ensuring that the state can only be mutated in a predictable fashion.

Why should you use it?

Best practices
Single data centralization
DRY (Don't repeat yourself)
Easier to maintain and modify existing code

How?

This simple illustration would make you have a thought on Vuex.

Let's say you have an app that calls endpoints for CRUD (Create, Read, Update, Delete) Operations,Remember the conventional method is using the endpoint directly into your app with axios or fetch then you get a response and move on,

But what if we need to call the same endpoint on another page, that's where Vuex comes in, the conventional method would literally make the request twice but with Vuex; The data would be stored from the first instance in a state which can be later used several times on other views or components.

Vuex Common Terminology

Vuex contains a few terms which can be confusing; they include:

Getters
Mutation
Action
State
MapState

State: This is a JavaScript object containing a list of variables that are used to handle responses from mutation


state: {
  users: [],
  blogs: [],
}

Getters: This is used to filter data in a particular state



findBlogById: (state, getters) => (id) => {
  return state.blogs.find(blog => blog.id == id);
}

Action: This is used to make a request using axios or fetch, just like the conventional method.


axios.get('/api/blog')
.then(res => {
   commit("LOAD_BLOGS", res.data)
})

MapState: this is used in Vue computed property such that the state needed can be accessible in template/view.


computed: {
  ...mapState(['blogs']),
}

//OR 

computed: mapState(['blogs']),

<div v-if="blogs">
   <div v-for="(value, index) of blogs">
      <h1> {{value.title}} </h1>
      <p> {{value.body}} </p>
   </div>
</div>

Mutation: These are very similar to events, they allow a state to be modified by the response of the action.

//fetching blogs

LOAD_BLOGS(state, blogFromAction) {
   state.blogs = blogFromAction
}

//adding new blog

ADD_BLOG(state, payloadFromForm) {
    state.blogs.unshift(payloadFromForm);
}

But I still don't understand

In case you still don't understand, Here is a link to a simple blog that uses https://jsonplaceholder.typicode.com as endpoints.

DEV Community: Azeez Abiodun Solomon

Introducing gitresume, an open-source cli tool for building résumé with LLM support

Installation

Create your first resume

How to upgrade TLS version for serverless service on GCP (Google Cloud Platform)

What is TLS?

Our current setup

Reserve an external static IP Address

Create a load balancer

How to check the TLS version

Build Web App with Go for Beginners Part II

Setting up routes

Setting up Model

Handling the logic in the controller

Delete Todo

Build Web App with Go for Beginners Part I

Prerequisites

Project Layout

Packages

Advice on how to pass algorithm questions

Quick guide to Vuex

Prerequisites

What is Vuex?

Why should you use it?

How?

Vuex Common Terminology

But I still don't understand

Thanks ❤️