DEV Community: Gospel Lekia

New article alert

Gospel Lekia — Mon, 09 Feb 2026 13:52:46 +0000

The Software Engineers' Role in the AI Era

Gospel Lekia ・ Feb 9

The Software Engineers' Role in the AI Era

Gospel Lekia — Mon, 09 Feb 2026 06:16:49 +0000

Artificial Intelligence is no longer a future idea. It’s already here. From chatbots and recommendation systems to code assistants and self-driving cars, AI is becoming part of everyday software. This shift has naturally raised questions, especially among software engineers: Will AI replace us? What is our role now?

The short answer is simple: software engineers are more important than ever, just in a different way. So, there is nothing to really worry about.

From Writing Code to Solving Problems

In the past, a large part of a software engineer’s job was writing code line by line. Today, AI tools can help generate code, fix bugs, and suggest improvements. This doesn’t make engineers less useful; it changes the focus of their work.

Modern software engineers spend more time understanding problems, designing systems, and making decisions. AI can write code, but it cannot fully understand business needs, user behaviour, or real-world constraints. Engineers bridge that gap. One of the things engineers need to understand is the first principles of how things work.

Building and Shaping AI Systems

AI systems don’t build themselves. Software engineers design the infrastructure that AI runs on, integrate AI models into applications, and ensure everything works reliably at scale. They decide how data flows, how models are deployed, and how systems stay secure and fast.

Without solid engineering, even the smartest AI model is useless.

Responsible and Ethical Development

Humans are better at making judgments.
AI can have serious consequences—biased decisions, privacy issues, and unintended harm. Software engineers play a key role in preventing this. They choose how data is collected, how models are used, and what safeguards are in place.

In the AI era, engineers are not just builders; they are guardians. They help ensure AI is fair, transparent, and safe for users.
It is in the place of the engineers to ensure compliance, governance and security checks are in place even for vibe-coded software or AI-generated code. Speaking of checklist here is a good one you can use production-ready web-api checklist.

Working With AI, Not Against It

The best engineers don’t compete with AI. They collaborate with it. AI tools can speed up development, reduce repetitive work, and help engineers focus on creative and complex tasks.

Knowing how to use AI effectively is becoming a core engineering skill, just like knowing a programming language or a framework.

Continuous Learning Is Now Essential

Technology has always changed, but AI is accelerating that change. Software engineers must keep learning about AI basics, data, system design, and new tools. The goal isn’t to become a machine learning expert overnight, but to understand enough to make smart decisions.
Also, LLMs are not as good yet. The knowledge on which they relied comes from the public and engineers. We need to continually feed it the right techniques and knowledge to improve the system.

Those who adapt will thrive.

Conclusion

The AI era is not the end of software engineering. It’s an evolution. Software engineers are shifting from pure coders to problem solvers, system designers, and ethical decision-makers. AI is a powerful tool, but it still needs human judgment, creativity, and responsibility.

In the end, AI doesn’t replace software engineers. It raises the bar—and creates new opportunities for those ready to grow.

What other ways do you think engineers can improve and thrive? Leave your response in the comments.

A Beginner-friendly Approach to Developing a REST API with Go, Gin and MSQL

Gospel Lekia — Wed, 21 Feb 2024 18:17:24 +0000

Mastering Go is an effort worth sticking to. It is challenging when you attempt to learn everything in a day. The beginner-friend tutorial series is an honest effort to teach key concepts in bitwise and practical ways. This is the continuation and second part of this tutorial. See the first part here: A Beginner-friendly Approach to Developing a REST API with Go and Gin.

What We are building on

Here is our current code and structure:

|- go.mod
|- go.sum
|- main.go
|- readme.md

main.go/

1 package main
2
3 import (
4   "github.com/gin-gonic/gin"
5   "net/http"
6 )
7
8 // book struct represents data about a book record.
9 type book struct {
10  ID     string  `json:"id"`
11  Title  string  `json:"title"`
12  Author string  `json:"author"`
13  Price  float64 `json:"price"`
14 }
15
16 // books slice to seed record to book store.
17 var books = []book{
18  {ID: "1", Title: "A Day in the Life of Abed Salama", 
19 Author: "Nathan Thrall", Price: 56.99},
20  {ID: "2", Title: "King: A life", Author: "Jonathan 
21 Eig", Price: 56.99},
22  {ID: "3", Title: "Where we go from here", Author: 
23 "Bernie Sanders", Price: 17.99},
24  {ID: "4", Title: "Buiding a dream server", Author: 
25 "Yiga ue", Price: 39.99},
26  {ID: "5", Title: "Clean Code ", Author: "Robert C 
27 Martin", Price: 39.99},
28 }
29
30 // getBooks responds with the list of all books as json
31 func getBooks(c *gin.Context) {
32  c.IndentedJSON(http.StatusOK, books)
33 }
34
35 func main() {
36  router := gin.Default()
37  router.GET("/books", getBooks)
38  router.GET("/books/:id", getBook)
39  router.POST("/books", postBook)
40  router.Run("localhost:8080")
41 }
42
43 func getBook(c *gin.Context) {
44  id := c.Param("id")
45  for _, book := range books {
46      if book.ID == id {
47          c.IndentedJSON(http.StatusOK, book)
48          return
49      }
50  }
51  c.IndentedJSON(http.StatusNotFound, gin.H{"message": 
52 "book not found"})
53 }
54
55 func postBook(c *gin.Context) {
56  var newBook book
57
58  if err := c.BindJSON(&newBook); err != nil {
59      return
60  }
61
62  books = append(books, newBook)
63  c.IndentedJSON(http.StatusCreated, newBook)
64 }
65

Here is a linear structure where everything is in the main.go file. let's add structure bit by bit as we go along the tutorial.

Restructuring

To focus on learning, we will not do so much with the application's structure. However, we will add a little structure to the application.

Create a new models directory in the root and add a file name book.go to it.

mkdir models 
touch models/book.go

|- go.mod
|- go.sum
|- main.go
|- readme.md
|- models /
   |- book.go

Move the book struct code block into the book.go file and update the name of the 'book' struct to 'Book' (this makes it visible to other packages and we can import it into other packages). Add the code package models at the top of the book.go. The file should have the code:

package models

// book struct represents data about a book record.
type Book struct {
    ID     string  `json:"id"`
    Title  string  `json:"title"`
    Author string  `json:"author"`
    Price  float64 `json:"price"`
}

Update the two book struct references in the main.go file; the books and
postBook function as shown below.

// books slice to seed record to book store.
var books = []models.Book{ // 📌 Update reference
    {ID: "1", Title: "A Day in the Life of Abed Salama", Author: "Nathan Thrall", Price: 56.99},
    {ID: "2", Title: "King: A life", Author: "Jonathan Eig", Price: 56.99},
    {ID: "3", Title: "Where we go from here", Author: "Bernie Sanders", Price: 17.99},
    {ID: "4", Title: "Buiding a dream server", Author: "Yiga ue", Price: 39.99},
    {ID: "5", Title: "Clean Code ", Author: "Robert C Martin", Price: 39.99},
}

func postBook(c *gin.Context) {
    var newBook models.Book // 📌 Update reference

    if err := c.BindJSON(&newBook); err != nil {
        return
    }

    books = append(books, newBook)
    c.IndentedJSON(http.StatusCreated, newBook)
}

Database Setup

Set up a database to hold our book records. The database will replace our in-memory slice store.
From the terminal/command prompt, create a new directory database and add a bookstore.sql file. The instructions for setting up the bookstore database are shown in the SQL file.

mkdir database
touch database/bookstore.sql

Let's move the books collection into this file as a SQL CREATE command:

-- connect on CLI: mysql -u dbuser -p
-- Enter password:
-- mysql> CREATE DATABASE bookstore;
-- mysql> USE bookstore;
-- mysql> SOURCE /path to/bookstore.sql;
-- mysql> exit (closes connection);

DROP TABLE IF EXISTS book;
CREATE TABLE book (
  id         INT AUTO_INCREMENT NOT NULL,
  title      VARCHAR(128) NOT NULL,
  author     VARCHAR(255) NOT NULL,
  price      DECIMAL(5,2) NOT NULL,
  PRIMARY KEY (`id`)
);

INSERT INTO book
  (title, author, price)
VALUES
  ("A Day in the Life of Abed Salama", "Nathan Thrall", 90.18),
    ("King: A life", "Jonathan Eig", 56.99),
    ("Where we go from here", "Bernie Sanders", 23.99),
    ("Buiding a dream server", "Yiga ue", 39.99),
    ("Clean Code ", "Robert C Martin", 49.99);

Database connection

We need to create a connection to our database programmatically.
Two major dependencies are needed to do that, github.com/joho/godotenv and github.com/go-sql-driver/mysql.

Create a .env file in the root of the application.
Add the database connection variables into the .env file as shown.

DBUSER=root
DBPASS=password # replace with your password
DBHOST=localhost
DBNAME=bookstore # can be any name of your choice

In the database directory create a new file name dbconn.go. Add the following code in the dbconn.go file.

1 package database
2
3 import (
4   "database/sql"
5   "fmt"
6   "log"
7   "os"
8   "github.com/joho/godotenv"
9
10  "github.com/go-sql-driver/mysql"
11 )
12
13 func DBConnect() {
14  err := godotenv.Load()
15
16  if err != nil {
17      log.Fatalf("Some error occured. Err: %s", err)
18  }
19
20  config := mysql.Config{
21    User: os.Getenv("DBUSER"),
22    Passwd: os.Getenv("DBPASS"),
23    Net: "tcp",
24    Addr: os.Getenv("DBHOST"),
25    DBName: os.Getenv("DBNAME"),
26  }
27
28  db, err := sql.Open("mysql", config.FormatDSN())
29  if err != nil {
30    log.Fatal(err)
31  }
32  err = db.Ping()
33  if err != nil {
34    log.Fatal(err)
35  }
36
37  fmt.Println("DB connection successful")
38 }

On the CLI run the command to import all dependencies.

go get .

On line 14: godotenv.Load() provided by github.com/joho/godotenv dependency retrieves the values of our .env file.
On lines 20 - 26, use the MySQL package struct Config to collect the connection properties from the .env.
On line 28, open the SQL connection passing the driver and the connection string which is in this format "username:password@(127.0.0.1:3306)/dbname". The config.FormatDSN() formats the config struct into the connection string behind the scene so we don't have to do it manually. Note, there are other drivers aside from MySQL.
On line 32, test the connection is successful with db.Ping().
For a start, if there is any error we end execution with a call to log.Fatal("") and print the error to the console.

Finally, in the main.go file there is a call to the database.DBConnect() function just below line 35 in the main() function to temporarily test that the connection setup worked. Don't forget to import the "github.com/yigaue/bookstore/database" package.
Run:

go run .

It would help if you got "DB connection successful" response.
Your main function should look like this now.

func main() {
    database.DBConnect()
    router := gin.Default()
    router.GET("/books", getBooks)
    router.GET("/books/:id", getBook)
    router.POST("/books", postBook)
    router.Run("localhost:8080")
}

Good job if you got here so far.

Update the code to use the database

After the endpoints and database setup, let's update the code to use the database instead of the in-memory slice store.

There are currently three functions in the main.go file we need to update.

getBooks function
getBook function
postBook function

We'll add one more, a deleteBook function.

getBooks function
Below is the updated code for the getBooks function.

23 // getBooks responds with the list of all books as JSON
24 func getBooks(c *gin.Context) {
25  // var db *sql.DB
26  db := database.DBConnect()
27  var books []models.Book
28
29  rows, err := db.Query("SELECT * FROM book")
30  if err != nil {
31      fmt.Errorf("getBooks: %v", err)
32  }
33
34  defer rows.Close()
35  for rows.Next() {
36      var book models.Book
37      if err := rows.Scan(&book.ID, &book.Author, 
38 &book.Title, &book.Price); err != nil {
39          fmt.Errorf("getBooks: %v", err)
40      }
41
42      books = append(books, book)
43  }
44
45  if err := rows.Err(); err != nil {
46      fmt.Errorf("getBooks: %v", err)
47  }
48  c.IndentedJSON(http.StatusOK, books)
49 }

Much has not changed from the previous code except the addition of the SQL query to fetch the books and minor updates.
First, connect to the database on line 26,
DBConnect() is the function that connects to our DB in the database package

A slice of type Book is declared on line 27 imported from the models' package.

Line 29 - 32 we query the database for all books and check for any error.

Line 34, rows.Close() prevents further enumeration of the fetched rows.

In lines 35 - 43: loop through the rows fetched from the database with rows.Next(). rows.Next() returns true if there is a next row and false if none making it possible to use a for loop on it. Each row is scanned into our book struct with the column of the database copied into the appropriate struct property.
Line 42: append each book struct created from the row columns into the books slice defined on line 27.
Then we return a Json of the books slice.
fmt.Errorf is an error formatter handy to log where an error occurred.

Test the implementation with curl. First, run the go code.

go run .

Then open a new terminal and run

curl localhost:8080/books

getBook function
This function fetches a single row using the given ID of the book.

50 func getBook(c *gin.Context) {
51  db := database.DBConnect()
52  id := c.Param("id")
53  var book models.Book
54
55  row := db.QueryRow("SELECT * FROM book WHERE id = ?", id)
56  err := row.Scan(&book.ID, &book.Author, &book.Title,  
   &book.Price)
57
58  if err == sql.ErrNoRows {
59      c.IndentedJSON(http.StatusNotFound, 
   gin.H{"message": "book not found"})
60  }
61
62  if err != nil {
63      fmt.Errorf("book ID, %d: %v", id, err)
64  }
65
66  c.IndentedJSON(http.StatusOK, book)
67 }

Again, connect to the database.
On line 51 we get the id of the book.

On line 55: use db.QueryRow to get a single row. Note it’s different from db.Query method which returns multiple rows.

row.Scan method copies the columns of the row to the appropriate book struct fields.

Sql.ErrNoRows is returned by row.Scan method when no result is returned by db.QueryRow method.

On lines 62 - 64, we check for any error.

Finally, return the book as JSON.

Test the implementation with curl. First, run the go code:

go run .

Then open a new terminal and run

curl localhost:8080/books/1

postBook function
Let's update the postBook function.

69 func postBook(c *gin.Context) {
70  db := database.DBConnect()
71  var newBook models.Book
72  if err := c.BindJSON(&newBook); err != nil {
73      return
74  }
75  row, err := db.Exec("INSERT INTO book (title, author, price) VALUES (?, ?, ?)", newBook.Title, newBook.Author, newBook.Price)
76  if err != nil {
77      fmt.Errorf("postBook %v", err)
78  }
79
80  id, err := row.LastInsertId()
81
82  if err != nil {
83      fmt.Errorf("error getting lastID: %v", err)
84  }
85
86  newBook.ID = strconv.Itoa(int(id))
87
88  c.IndentedJSON(http.StatusCreated, newBook)
89 }

First, connect to the database.

Line 72, we get the request body JSON, bind it to the book struct fields and check for error at the same time.

Lines 75 -78: execute the INSERT SQL query to add the book to the database table.

Line 80, we get the ID of the recently inserted row and then assign this ID to the book struct ID field.
The int64 ID returned from row.LastInsertedId() is converted to a string on line 86 using strconv.Itoa (int to ASCII).
Note strconv.Itoa() takes an int type so the ID is first converted from int64 to int.
On line 88, return the book JSON with the status code of 201(http.StatusCreated
)

Test the implementation by running:

go run .

Then open another terminal tab and run

curl http://localhost:8080/books \
    --include \
    --header "Content-Type: application/json" \
    --request "POST" \
    --data '{"title": "Things fall apart", "author": "Chinua Achebe", "price": 30.90}'

deleteBook function
The deleteBook function was not part of the first tutorial.

91 func deleteBook(c *gin.Context) {
92  db := database.DBConnect()
93  id := c.Param("id")
94  _, err := db.Exec("DELETE FROM book WHERE id = ?", id)
95
96  if err != nil {
97      fmt.Errorf("deleteBook %v", err)
98  }
100 c.IndentedJSON(http.StatusOK, "Book deleted successfully")
101 }

In this code, connect to the database, get the ID of the book to be deleted, and then execute the DELETE SQL query. Finally, a response is returned. This function can be improved to check for errors if the book is not found and others.

Conclusion

This tutorial focused on interacting with our database using Go's built-in packages and the gin framework for routing, reducing the distraction of learning the intended core concepts.
In the next tutorial, we'll add more functionality and JWT authentication. I hope you enjoyed coding along. Do well to leave questions and feedback in the comment section.

See the complete code on Github. Feel free to contribute or open an issue.

Why I Built a Vscode Extension

Gospel Lekia — Fri, 12 Jan 2024 00:40:11 +0000

A couple of times, we spend time tweaking VScode themes. It could be fun but sometimes tiring and time-consuming. I have travelled this road many times but went a little over the board this time, and why would I do that?

The need for a suitable theme

I have enjoyed using wonderful themes, from Material Theme to Monokai. I always wanted to change something in every theme, especially the colours to resonate with me and the comfort of my eyes.

A little adventure wouldn't hurt

During the close of the year, 2023 I decided to do something a little different from my usual development. I considered doing some design tasks, colour combinations and colour effects. It was nice to put it into practice. So boom, I built and published my Vscode theme extension.

The need to give back to the community

The tech community has always been awesome in open-source and sacrificial endeavours. Almost everyone has it in mind to give back to this wonderful community of love.

Final note

I enjoyed designing the theme. Some other time I will write about the process.
Thanks for reading and I hope you enjoyed this episode 🙂. To install on Vscode, search for Dukana.
Or check the marketplace.
Be kind to support my endeavours.

A One-Pager to Understanding Pointers in Go (expanded)

Gospel Lekia — Tue, 02 Jan 2024 00:48:14 +0000

Scared of pointers let’s end the fear once and for all.

Pointers are a powerful feature in programming languages that allow you to work with memory addresses directly. In the Go programming language, pointers work similarly to other C-style languages, but with some differences in syntax and behaviour.

To understand pointers, you'll need to clearly understand the following:

variable
value
type

Let's define them in one statement: topic := "go programming".
The variable is topic, the value is "go programming" and the type is a string. There is one more thing that is not obvious on the list and that's the memory address of the variable. Every variable has an address in memory and that's where pointers come in.

A variable does not only hold a value but also has an address. This is a hot fact to keep in mind. Consider it like a house. It has an address and can contain a person assuming one person per house.
Say Mr John Doe's house address is 100 ABC Street, Omo Island, Dukana. It means if we get to the above address we'll find Mr John.

Type is important in Go just like other languages. Every value in Go is of a type. For instance, 4, 9, and 5 can be called integer types, 5.0, and 4.4 float64 types, "welcome", and "tomorrow" string types and more. If a variable holds a value of a type then that variable is of that type.

age := 30
Variable, age here is an integer type since it holds an integer value.
There is also a pointer type just like every other type mentioned above.
Every variable has a location in memory (more like an address).
Let's say the address of a variable, b in memory is 0xc000012028 (yes, memory addresses look like this). We can assign the value to another variable like so u := 0xc000012028 (note, this is an illustration). In this case u is a pointer (to b).

Exercise:

Mention the variable types in the examples.

name := "John Doe" // name is string type
age := 30 // age is integer type
height := 1.7 // height is float64 type
pToName := &name // ptoName is a pointer type; '&name' is the memory address of name

What is a Pointer in Go?

A pointer holds the memory address of a value or from the angle of a variable, a pointer is a variable that holds the memory address of another variable.

A pointer is represented by the * symbol followed by the type of variable it points to. For example, the following code declares a pointer to an integer variable:

var p *int

In Go you declare a variable like this var age int but if age is a pointer you will declare it like this instead var age *int. This is not the same as dereferencing (defined below).

Here, p is a pointer to an integer variable. It's important to note that p is currently a nil pointer, meaning it doesn't point to any valid memory address as it's just a declaration.

Creating a Pointer

To create a pointer to a variable, you use the & operator followed by the variable's name. For example, the following code declares an integer variable x and creates a pointer p that points to it:

x := 42
p := &x // p points to x

Here, p points to the memory address of x, which is the address where the value 42 is stored.

Dereferencing a Pointer

There is a relationship between pointers and values.
Given an address, we can get the value at the location and vice-versa.

To access the value at the memory address, you use the * operator followed by the pointer variable name. This operation is called dereferencing the pointer. For example, the following code dereferences the pointer p and assigns the value 100 to the variable it points to:

*p = 100
// We're setting x to 100 through p.
// Now, if we print the value of x, it will be 100:
// x was initially 42 (defined above).

fmt.Println(x) // Output: 100

Note that you can only dereference a non-nil pointer. If you try to dereference a nil pointer, your program will crash with a runtime error.

Two Ways to Use the `*` Symbol

To clear a common confusion around *, it's good to know we can use it in two different ways.

To indicate that a variable is a pointer in variable declaration.
To deference a pointer variable.

The syntax examples in the first case: var age *int, var name *string. The * is followed by the type.
In the second case, the * is followed by a variable like so: *name, *age.

Passing Pointers to Functions

Normally, when a variable is passed to a function it's passed as a copy.
Modifying the variable in the function does not modify the one outside the function.
But if we want to modify the variable outside the function within the function we can pass it as reference using a pointer.

One common use of pointers is to pass a variable to a function by reference, allowing the function to modify the variable directly. To do this in Go, you simply pass the pointer to the function. For example, the following code declares a function that takes a pointer to an integer variable and increments its value:

func increment(p *int) {
    *p++
}

To call this function and increment the value of x defined earlier, you pass the pointer to x as an argument:

increment(&x)
fmt.Println(x) // Output: 101

Here, increment(&x) takes a pointer to x, which dereferences it and increments the value it points to.

Further Example

package main

import "fmt"

func main() {
    age := 8      // declare a variable and assign a value to it.
    printAge(age) // we pass a copy of the variable to the function.
    // OUTPUT:
    // AGE in function: 10
    // memory location in function: 0xc000012040

    fmt.Println("AGE in global:", age)
    fmt.Println("memory location of age in global:", &age)
    // OUTPUT:
    // AGE in global: 8
    // memory location of age in global: 0xc000012028

    printAgePointerParameter(&age)
    fmt.Println("AGE in global after pointer function:", age)
    // OUTPUT:
    // memory location in pointer function: 0xc000012028
    // value in memory location in pointer function: 8
    // age in pointer function after reasignment: 20
    // AGE in global after pointer function: 20 (the original variable is affected after it's changed in the pointer function)

}

func printAge(age int) {
    age = 10 // reasign a value to the variable
    fmt.Println("AGE in function:", age)
    fmt.Println("memory location in function:", &age)
}

func printAgePointerParameter(age *int) { // function takes a pointer type of int
    fmt.Println("memory location in pointer function:", age)
    fmt.Println("value in memory location in pointer function:", *age) // we deference the pointer and print it.
    *age = 20 // we deference the variable and reasign a new value to it. This also affects the original variable.

    fmt.Println("age in pointer function after reasignment:", *age)
}

Run code in playground

Benefits of pointers

Dynamic Memory Allocation: Pointers are often used to allocate and manage memory dynamically in Go programs. This allows you to allocate memory for data structures at runtime, rather than relying on compile-time allocation. For example, you can use pointers to create linked lists, trees, and other dynamic data structures.

Sharing Data between Functions: Pointers can be used to share data between functions and avoid creating copies of large data structures. By passing a pointer to a function, you can allow the function to modify the original data structure directly, rather than creating a new copy of it.
Performance Optimization: Pointers can be used to optimize performance in certain situations, such as when working with large data sets or in high-performance computing applications. By working directly with memory addresses, you can avoid unnecessary memory copies and improve the efficiency of your program.
Interfacing with C Libraries: Go programs can interface with C libraries using pointers, which are a common feature in C programming. This allows you to take advantage of existing C libraries and leverage their functionality in your Go programs.

Conclusion

Pointers are a powerful tool in the Go programming language that allows you to work with memory addresses directly. They can be used to pass variables by 'reference' to functions, modify values directly, and work with complex data structures. However, it’s important to use pointers with care and avoid common pitfalls such as dereferencing nil pointers or using dangling pointers that point to invalid memory addresses.

Here is my personal Github gist(note) that inspires this article. Feel free to leave comments. https://gist.github.com/Yigaue/d0a0128a86914ef718ed48457d003031

Other Useful Resources

Go Curated learning resources
Go Address Operators (Go doc)
Pointer Types Operators (Go doc)
Pointers to a struct (Playground)
Pointers (playground)

A Beginner-friendly Approach to Developing a REST API with Go and Gin

Gospel Lekia — Sun, 24 Dec 2023 22:16:00 +0000

We learn to learn again (until we come to an "Aha!" moment if we're lucky enough). Let's get to the heart of it.

Definitons

Go is a statically typed, compiled high-level programming language designed at Google. It's a modern programming language well-positioned for the evolving technology needs.

Gin is a web framework written in Go that simplifies building web applications.

Fully functional REST APIs can be developed with Go native packages. However, there are tools created to increase efficiency and reduce development time, and very likely you will be working more with frameworks.

Prerequisite

Basic understanding of REST
Introductory knowledge of Go
Introductory knowledge of Gin (optional)

Tools

A computer, laptop or anything similar.
Go install and set up. Installation instruction
Any code editor or IDE of choice e.g. Vscode
A command terminal, cmd or PowerShell (windows)
Curl or any API client e.g Postman
Git for version control (optional)
A repository to store your code (optional)

In this tutorial:

Design API endpoints
Setup project structure
Create the data store
Write the corresponding endpoint handlers:
- Handler to return all books
- Handler to add a new book to the data store
- Handler to return a specific book
Associate Handles to Request Endpoints
Conclusion

What We will be building

A simple bookstore service where books can be added and retrieved.

Design API endpoints

API design typically starts with writing out the endpoints. We'll have endpoints to:

Retrieve all books in the store:
Retrieve a particular book from the store using the book Id
Add a book to the store.

`/books`

GET - return a list of all books as JSON.
POST - add a new book resource from a JSON request.

`/books/:id`

GET - retrieve a book by using the ID, returned as JSON.

For simplicity, there are things we did not consider in designing these API endpoints.
In this tutorial, we'll not consider API versioning, middleware, authentication, database etc. Those will be coming in future tutorials as a continuation of this.

Set up Project Structure

Using any editor of choice create a directory to hold your project, and name the directory bookstore.
Or from your terminal:

cd ~
mkdir bookstore
cd bookstore

Every programming language has a way of managing packages and dependencies. In Go, dependency is managed using Go module.

So let's create a module to manage/track dependencies similar to npm init using our terminal.

go mod init github.com/yigaue/bookstore
go: creating new go.mod: module github.com/yigaue/bookstore

You can use any path of your choice. It's perfectly fine. However, it's common to see developers append the project name to their GitHub username like above, in that way, it's easy to publish their code as a package and reuse it in other code.
Without using Github we can simply do:

go mod init project/bookstore
go: creating new go.mod: module project/bookstore

You can see that a file, go.mod is created. Quickly view the content with or open from the editor:

cat go.mod

This file contains the module path: the import path prefix for all packages within the module.

Create Data Store

For simplicity, we'll store our data in memory. A typical API will store data in a database. For this, we'll use struct and slice. Do not worry if slice and struct are not familiar, you can read more about them.
The data in memory is not persistent, which means the data is lost every time we stop and start our local server.

Create a main.go file in the project directory.

touch main.go

Add the following code to the main.go file.

package main

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

// book struct defines a book similar to an object
type book struct {
    ID     string  `json:"id"`
    Title  string  `json:"title"`
    Author string  `json:"author"`
    Price  float64 `json:"price"`
}


var books = []book {
    {ID: "1", Title: "A Day in the Life of Abed Salama", Author: "Nathan Thrall", Price: 56.99},
    {ID: "2", Title: "King: A life", Author: "Jonathan Eig", Price: 56.99},
    {ID: "3", Title: "Where we go from here", Author: "Ken Wiwa", Price: 17.99},
    {ID: "4", Title: "Buiding a dream server", Author: "Lekia Yiga", Price: 39.99},
    {ID: "5", Title: "Clean Code ", Author: "Robert C Martin", Price: 39.99},
}

Explanation: The first line is our package declaration. package main is required for an executable standalone program. A package is similar to a namespace. Run the command to fetch all dependencies in the import.

go get .

All dependencies in the import statement will be fetched and a sum.go file will be created to lock our dependencies, similar to package-lock.json.

Below the package declaration is the import of needed dependencies.
The book struct defines the structure of a book like a book object. When a book is created it follows the blueprint of the book struct. A book will have a title, author, ISBN, and price amongst others. Note that we have added a struct tag like json:"title". This will ensure that the JSON key returned is formatted as specified and does not use the struct keys like "Title".

Beneath the book definition is the book store: a slice of books. Five books have been added to the collection as samples. A slice in Go is similar to an array but more flexible. We can easily manipulate the slice, adding and removing items.

Write the Corresponding Endpoint Handlers

What we want to do here is map the request path to the appropriate handler(a portion of code that executes the logic associated with that request path).

Handler to return all books

GET: /books - call the getBooks handler when a user visits the /books endpoint. Add the function below to the existing code. The function takes the gin.Context as a parameter. Recall the gin package is imported at the beginning of this file.

  func getBooks(c *gin.Context) {
     c.IndentedJSON(http.StatusOK, books)
  }

IndentedJSON serializes the book struct to JSON and the response is returned to the client. The response code http.StatusOk is the first parameter of IndentedJSON, a constant with a value of 200.

Handler to add a new book to the data store

When a post request is made to /books/ we want to add a new book. Let's implement the handler to handle this logic.

Add the following function to the existing code.

  func postBook(c *gin.Context) {
    var newBook book

    if err := c.BindJSON(&newBook); err != nil {
        return
    }

    books = append(books, newBook)
    c.IndentedJSON(http.StatusCreated, newBook)
  }

The postBook function takes a gin.Context parameter. A newBook variable is declared in the function which is of type book with underlining type as struct (declared above). The request body JSON is bound to the newBook variable with BindJSON(.... If an error occurs, we exit. append(books, newBook) appends the newBook variable to the existing books slice(data store). Finally, c.IndentedJSON(http.StatusCreated, newBook) returns the resulting book JSON to the client making the request.

Handler to return a specific book

/books/:id endpoint GET method retrieves a book. The handler function is thus:

  func getBook(c *gin.Context) {
    id := c.Param("id")
    for _, book := range books {
        if book.ID == id {
            c.IndentedJSON(http.StatusOK, book)
            return
        }
    }
    c.IndentedJSON(http.StatusNotFound, gin.H{"message": 
 "book not found"})
 }

Let's go through what the function is doing.

gin.Context is passed as a parameter to the getBook function. c.Param("id") retrieves the URL path variable, "id". We loop over the book structs in the slice to find a struct whose ID field matches the id parameter from the URL path. If there is a match we serialize the matching book struct to JSON using c.IndentedJSON... and return it with an http.statusOk response. If there is no match StatusNotFound response is returned.

Associate Handles to Request Endpoints

Now that the Handlers and the endpoint are defined, Let's map the Handlers to the request endpoints.

create a function name main like so.

func main() {
    router := gin.Default()
    router.GET("/books", getBooks)
    router.GET("/books/:id", getBook)
    router.POST("/books", postBook)
    router.Run("localhost:8080")
}

In the main function we initialize a gin router using gin.Default(), then associate individual endpoints to the corresponding Handlers we already defined.

Format your code nicely using go fmt from the terminal.
Start the server and run the code with the command:

go run .

You should see a result similar to GIN-debug] Listening and serving HTTP on localhost:8080 in your terminal.
Open a new terminal and run the command:

curl http://localhost:8080/books

Or use Postman or any API client of choice.

Result:

Do the same for the other endpoints.

curl http://localhost:8080/books/2

Result:

curl http://localhost:8080/books \
    --include \
    --header "Content-Type: application/json" \
    --request "POST" \
    --data '{"id": "6", "title": "Things fall apart","author": "Chinua Achebe", "price": 30.90}'

Result:

After adding a book you can verify with the /books endpoint that the new book was added.

Conclusion

In this tutorial, we were able to show a simple implementation of REST API using the Gin framework. Certain considerations were not taken in the implementation. You may have noticed that our data store (Book slice) can hold many non-unique records. That's to say we can have books with the same IDs.
In the coming tutorial, we'll swap our in-memory store with an actual database.

You can find the full code here on GitHub.
Feel free to create an issue or raise a pull request if you find an issue.

3D book: Open and close pages

Gospel Lekia — Mon, 20 Jun 2022 00:13:30 +0000

Making Sense of Computer Programming/ Web Development

Gospel Lekia — Sat, 09 Nov 2019 15:12:33 +0000

Programming/Web development can be tedious. Most time there is a strong feeling of throwing everything away and turning your back on it. But that is not all. One thing that constantly comes to mind is ‘How do I make sense of this’? It becomes discomfort, especially in a fast-paced industry. And then there is a second thought that this is just all you’ve got left and you need to make the most out of it. . . But how?
This article is the first of the series "Making Sense of Computer Programming/ Web Development".
More articles in this series will be posted regularly. We’ll talk about those peculiar, silent questions in the heart of many developers, especially those who think more about a fulfilling life. If you’ve found yourself here, then you’re not alone.
Some programmers/developers came into programming with no background in computer science or its related field. Ya, many are ‘self-taught’. This is not bad in itself as the industry is open to contributions from anyone who can make a difference.
Now, the question is where do I start if I am interested in programming or web development? How do I make sense of web development/programming?
You should understand that when we speak of web development, we are pointing to three key things.

The computer
The computer language
The computer User

These three things should be properly defined and understood and how they relate.
Let’s consider them one after the other.

Computers:

Computers affect every part of our lives: from medicine, travel, finance, engineering, socialization, travel, communication, you name it. The list goes on. Such great influence is one that perhaps we didn’t see coming. And what's more, its web spins even deeper into the twenty-first century.
considering these, as a web developer/programmer what does a computer mean to you, and how does it affect you?
Also, how do you as a developer use the computer to affect people and society?
Everyone interacts with a computer differently; the banker, the statistician, the engineer, and you as a developer/programmer. So as a developer, you must understand how you interact with the computer. This is the first thing to understand because everything you do surrounds the computer. The computer is the centre — the computer language, the computer code, and the computer user all point to one thing — the computer.
As a developer, first understand the basics of the computer (computer science), not necessarily the whole thing but the basics. The basics of anything are the foundation of it, no matter how simple it may seem, don’t ignore it. Time spent learning the basics may seem a waste, but that is not the case. In any big building, more time is spent on the foundation than any other part, and the foundation is less visible and admired. You may be tempted to jump to higher things: the seemingly trending things, but don’t. The basics are mostly things that cut across all computer languages and no matter the trends or changes they remain. In this way, you can keep pace with the constant changes in technology without getting blown away. Those who make an impact are those who simply understand the basics very well.
You may have to start with data structure and advance a step at a time. Studying selected topics relevant to your work and career is important.
Thanks for reading. You can share your thoughts and suggestions in the comments.

This post was originally posted at https://medium.com/@Lekia/making-sense-of-computer-programming-web-development-c0741dc04ef5

5 THINGS I WISH I KNEW YEARS AGO AS A DEVELOPER IN SECURING MY DREAM JOB

Gospel Lekia — Mon, 22 Apr 2019 12:15:19 +0000

Hello developer, I am glad you found this article. I wrote this with you in mind, and it is meant to guard you on this path. Why bear much burden when there is help?

Life is a lot easier when there are those on whose shoulders you can climb. Here I will be sharing briefly with you some truths that will boost your velocity whether as a beginner, intermediate or you’ve been around a while.
Becoming a developer is challenging and yet exciting. You’ve to love the job, or I should say calling. It is something you can’t do casually. It requires a consistent and conscientious effort. Discipline, dedication and diligence are not in words but in doing. Nobody pays to hear you talk as a developer, rather you are paid to do it. So, sharpening your skills is a top priority.

‘Okay, enough intro let’s get to it’!!! You are right we’re getting there. I will list them out and we'll begin.

Get a corner in the room
Work your corner before inviting guest
Keep up the standard
Who says your dream Job is impossible?
Don’t reinvent the wheels, Leverage platforms

Get a Corner in the Room

Joining the world of developers may sound exciting. You may have excitedly proclaimed ‘I am a developer’, only to discover your excitement just died the next minute on peeping in. You don’t have to be discouraged, we all felt that way too.
There are millions of developers around the world and you’re just +1. This should not scare you. You are unique in the million. The community needs you. The number of developers is not important as it is that you get a corner. Look for a niche and fit yourself. This is a place where you have passion for and wish to pour your life, as life is not long enough for any of us. Choose a language and start with it till you are proficient enough. Don’t be carried away by the trends and all the buzz. Just pick a tool and master it. I mean one tool. This leads us to the next point.

Work your corner before inviting Guests

This is important. Some young developers are so out to impress. This shouldn’t be your trade. You could waste precious hours if you do not plan your route as a developer. There are myriads of information available to you, but you don’t need all of them. you need to be selective where you quench your thirst. How many hours can you invest to build your skills? Information is good, but skills are what people are paying for. You have to invest time and get rid of distractions. Get to know the fundamentals, and stop jumping on resources.
Don’t start by going for the jobs. Work on your skills enough. You can do some tasks and projects along the way but keep that big company out of it.

Keep Up the Standard

You are not done yet but you are close. After building your skills and choosing your tools, it is time to go a little out. Now you’re ready to add more loads. I call this keeping up the standard. Maintaining your relevance as a developer is challenging too. This is because technology is fast evolving and there are innovations and practices almost every day. It is not easy to keep up with the trends, but you can if you have worked on your foundation adequately.
Do research for what skills and requirements are needed to land your dream job. Add these to your cart and gradually work on them. When you’re ready attack with full force.

Who says your dream job is Impossible

There are big names that scare you. It should not. It is a dream for you, so it was for others who work there currently. A man should not think of harvesting if he has not planted. But if he has observed planting season let him wait for harvest.
Now, it is time to aim for the stars while you upgrade your skill on the side. Think of yourself as a unique developer, there are no two you on earth so what you have to offer is in you till you let it out.
You may be asking how do I reach my employer for my dream job. Well, there are several ways around it. Few are searching, getting to their website, subscribing to their newsletter, Setting up a job alert and using social media: You have to follow that company till you find a gateway. Some of these companies float opportunities on their career platform. All you need to do is prepare and be available when the trumpet calls. This takes me to the last point.

Don’t Reinvent the Wheels, Leverage on Platforms

As a developer, you have many platforms that can help you find what you want. You can get it on a platter of gold. The problem is making your way through the ocean of information.

DEV Community: Gospel Lekia

New article alert

The Software Engineers' Role in the AI Era

Gospel Lekia ・ Feb 9

The Software Engineers' Role in the AI Era

From Writing Code to Solving Problems

Building and Shaping AI Systems

Responsible and Ethical Development

Working With AI, Not Against It

Continuous Learning Is Now Essential

Conclusion

A Beginner-friendly Approach to Developing a REST API with Go, Gin and MSQL

What We are building on

Restructuring

Database Setup

Database connection

Update the code to use the database

Conclusion

Why I Built a Vscode Extension

The need for a suitable theme

A little adventure wouldn't hurt

The need to give back to the community

Final note

A One-Pager to Understanding Pointers in Go (expanded)

Exercise:

What is a Pointer in Go?

Creating a Pointer

Dereferencing a Pointer

Two Ways to Use the * Symbol

Passing Pointers to Functions

Further Example

Benefits of pointers

Conclusion

Other Useful Resources

A Beginner-friendly Approach to Developing a REST API with Go and Gin

Definitons

Prerequisite

Tools

In this tutorial:

What We will be building

Design API endpoints

/books

/books/:id

Set up Project Structure

Create Data Store

Write the Corresponding Endpoint Handlers

Handler to return all books

Handler to add a new book to the data store

Handler to return a specific book

Associate Handles to Request Endpoints

Conclusion

3D book: Open and close pages

Making Sense of Computer Programming/ Web Development

Computers:

5 THINGS I WISH I KNEW YEARS AGO AS A DEVELOPER IN SECURING MY DREAM JOB

Get a Corner in the Room

Work your corner before inviting Guests

Keep Up the Standard

Who says your dream job is Impossible

Don’t Reinvent the Wheels, Leverage on Platforms

Two Ways to Use the `*` Symbol

`/books`

`/books/:id`