Forem: Mohammad Aziz

How to Use Unpublished Go Modules in Your Local Projects?

Mohammad Aziz — Thu, 13 May 2021 02:07:50 +0000

Context

While developing any go applications you might come into a situation where you need to use a module that is not yet ready to publish. The module might be living on your local machine and you wanted to get the taste of it using with other projects before shipping it. In this post, we will discuss what approach you can take to import a module that is still in development and before publishing it to the package registry.

We will write a simple project which takes a string and returns a boolean whether the string is valid IP address or not. The functionality is not that important but the important part is how we integrate it into another project while still making changes to the project.

Projects Layout

To keep things simple, I have created two projects which live side by side. The wip-module project is the unpublished one and the tester-module is the one in which will import the unpublished wip-module project. You can find the folder structure on Github.

WIP Project

The wip-module is a simple go module that holds the implementation of checking whether the IP is valid or not. Let's look into the file:

wip-module/ipchecker.go

package ipchecker

import (
    "net"
)

func IsValidIP(host string) bool {
    if ip := net.ParseIP(host); ip != nil {
        return true
    }

    return false
}

This module does not have the main package which means it was intended to be used as a library in other projects.

Tester Project

This is the project which will import the ipchecker package. Here is how it looks:

tester-module/main.go

package main

import (
    "fmt"

    ipchecker "github.com/iAziz786/wipmodule"
)

func main() {
    fmt.Println("valid IP = ", ipchecker.IsValidIP("127.0.0.1"))
    fmt.Println("valid IP = ", ipchecker.IsValidIP("invalid-ip"))
}

// Output:
// valid IP =  true
// valid IP =  false

As you can see it's using the ipchecker package from the github.com/iAziz786/wipmodule module. At this point, if you run the tester-module program you will see an error related to the package. Let's glue them together!

Using Unpublished Modules

Before we do anything let's look at the go.mod file of the tester-module.

tester-module/go.mod

module github.com/iAziz786/testermodule

go 1.16

require github.com/iAziz786/wipmodule v0.0.0-unpublished

Since the module is not published we gave it a version (v0.0.0-unpublished) that does not exist yet but to make things work correctly.

The next step is to replace the import behaviour for the wipmodule. We can do this by telling the go compiler to replace the import for github.com/iAziz786/wipmodule with the local path of the module. Since they are siblings, I can use relative path dot (..) notation.

go mod edit -replace=github.com/iAziz786/wipmodule@v0.0.0-published=../wip-module
go get -d github.com/iAziz786/wipmodule@v0.0.0-published

This will add a replacement in the go.mod of the tester-module.

tester-module/go.mod

module github.com/iAziz786/testermodule

go 1.16

require github.com/iAziz786/wipmodule v0.0.0-unpublished

replace github.com/iAziz786/wipmodule v0.0.0-unpublished => ../wip-module

Can you notice a replace directive at the end of the file? It adds the logic to tell go get to use the implementation which is one level up in the wip-module.

Now if you will run the program in the tester-module you will see this output:

$ cd tester-module
$ go run .

# Output
valid IP =  true
valid IP =  false

Note: Make sure to remove the replace directive from go.mod of the tester module before you commit your changes, otherwise go get will break in non-local environment.

Conclusion

We have used the golang's module replace directive to use the local go module which is not a published module to import it into the other projects.

Reference

https://golang.org/doc/modules/managing-dependencies#unpublished

https://golang.org/ref/mod#go-mod-file-replace

How to Work with Arbitrary JSON in Go?

Mohammad Aziz — Wed, 30 Dec 2020 15:24:22 +0000

Abstract

Mostly, when you are working with data you know the schema in which you will receive that data, but there come times when you don't know exactly what will be the structure you will end up receiving. We talk about how you can handle JSON data which are arbitrary in Go.

JSON with a Fixed Structure

When you receive JSON for which you already know the structure, it is pretty easy to work with. You create a struct and unmarshal the bytes to that struct and the JSON package will take care of the rest. Suppose you receive information about today's dinner in JSON and everyday dinner has the following structure.

type Dinner struct {
    MainCourse   string  `json:"main_course"`
    Beverage     string  `json:"beverage"`
    HasDessert   bool    `json:"has_dessert"`
}

And you receive the following JSON value:

food := []byte(`
{
  "main_course": "Biryani",
  "beverage": "Coca Cola",
  "has_dessert": true
}
`)

You just need to create a variable which can hold the value from JSON.

var dinner Dinner

Eventually, decode the values to the dinner variable like this:

json.Unmarshal(food, &dinner)

Now, you can access those values through the fields on the struct. Lucky you, you have dessert for today 😋.

dinner.MainCourse   // Biryani
dinner.HasDessert   // true

JSON That You Are Not Aware

Let's diverge our mind from food to shopping list :). Now assume every weekend you go to purchase some grocery and the items in the list keep changing each week. If you have to represent that into a struct, you got no luck!

Like almost everything in Go where so much randomness is evolved, you have to use interfaces. More particularly an empty interface. You can represent your shopping list like this:

var shoppingList interface{}

Because an empty interface can satisfy any type you can use that to do Unmarshaling.

listJSON := []byte(`
{
  "food": {
    "ketchup": "1pc",
    "noodles": "1pc",
    "rice": "2Kg"
  },
  "utensils": {
    "knives": 2,
    "forks": 3
  }
}
`)

json.Unmarshal(listJSON, &shoppingList)

At this point shoppingList looks like this:

shoppingList = map[string]interface{
    "food": map[string]interface{
        "ketchup": "1pc",
        "noodles": "1pc",
        "rice": "2Kg"
    },
    "utensils": map[string]interface{
        "knives": 2,
        "forks": 3
    }
}

To access the data, you can make a type assertion to map[string]interface{}.

list := shoppingList.(map[string]interface{})

After that, you can access the values like a regular map. But for the values that are nested, you need to do a type assertion again.

utensils := list["utensils"].(map[string]interface{})

utensils["forks"] // 3

Conclusion

You can handle arbitrary JSON with the help of interfaces. You just need to pass an empty interface to the Unmarshal function and the JSON data. After a type assertion, you are good to use the arbitrary fields and their values.

How to Use Embedding to Write Cleaner Code in Go?

Mohammad Aziz — Thu, 17 Dec 2020 19:13:09 +0000

Abstract

Go is cleaner because it doesn't support many of the features that tradition OO languages support. Less is more. Inheritance is one of those features but Go has a different style which can fulfil the necessity of inheritance. It's called Embedding.

Table of content

What is embedding
How to create embedding
Embedding In Interface
Embedding In Struct
Conclusion
Reference

What is embedding

You can "borrow" the functionality of a struct or interface into an another struct and interface respectively is called embedding. You can not embed an interface into a struct or vice versa.

How to create embedding

To create an embedding you need to put a different struct or interface into a different one without naming the field.

type Morning struct {
  breakfast bool
}

type Routine struct {
  Morning // ⬅️ no field name makes it embedded 
}

type Director interface {
  Direct()
}

type Producer interface {
  Produce()
}

type Creator interface {
  Director
  Producer
}

Embedding In Interface

Interface when embedded is the union of all the methods present in all of the interfaces combined. If method Eat() is present on an interface and Sleep() on another then embedding them into an interface with Repeat() method will have all, Eat(), Sleep(), and Repeat() methods.

Embedding In Struct

Embedding in a struct is where you can see the real power of Go. Not only the fields that defined type has but also the methods you can access them directly. How cool is that! Let's continue with our Routine struct.

type Morning struct {
  breakfast bool
}

func (m Morning) hasBreakfast() bool {
  return m.breakfast
}

type Routine struct {
  Morning
}

r := Routine{}

r.hasBreakfast() // false

You also the embedded type will be a field name on the struct. For example, you can have:

type DailySports struct {
  Jog            // field name Jog
  *Swim          // field name Swim
  sports.Cycling // field name Cycling
  *sports.Tennis // field name Tennis
}

func (d DailySports) enrolledBySwimming() bool {
  return d.Swim.Speed
}

But you cannot have conflict while embedding. This makes sense otherwise you won't know which one to pick.

struct {
  *Swim         // ⛔ Now allowed
  *sports.Swim  // ⛔ Not allowed
}

You can do all the things you can with the promoted fields but you can not use the field name present in the defined type while constructing the struct.

type Morning struct {
  breakfast bool
}

type Routine struct {
  Morning
}

r := Routine{breakfast: true} // ⛔ Not allowed

Conclusion

You can use embedding to use any defined type to used inside a struct and borrow all the functionality it has. You need to check that the names don't clash otherwise you are good to go.

Reference

How to Handle Missing Fields From A Struct in Go?

Mohammad Aziz — Thu, 10 Dec 2020 10:20:14 +0000

Suppose you have a variable of the type of the struct mentioned below which you wanted to Unmarshal.

type Building struct {
    WindowCount int `json:"window_count"`
    Doors       int `json:"doors"`
}

In case the data is coming from an unreliable source, you can never be sure that the value you will receive will always have the correct format. You have to be cautious when working around data like this. If you are new in Go you might be wondering what will happen you Unmarshal and incorrect value?

Compiler Loves Zero Values

If you unmarshal the code into a variable you will get the zero value for the fields WindowCount, and Doors. Which in some case can lead to bug because you might have different logic for missing case.

var b Building
json.Unmarshal([]byte(""), &b)
fmt.Printf("%+v\n", b)
// Output:
// {WindowCount:0 Doors:0}

Pointer To Rescue 🦸

If you have worked with pointers in languages like C, C++ you might have some opinion. You either like it or you hate it. Most people fall into the latter group. Working with pointers in Golang is fun because things are declarative comparatively.

If you set the field type to a pointer of that type it will be nil in case the field is missing

type Building struct {
    WindowCount *int `json:"window_count"`
    Doors       *int `json:"doors"`
}

Unmarshalling it has the following effect:

var b Building
json.Unmarshal([]byte(`{"window_count": 2}`), &b)
fmt.Printf("%+v\n", b)
// Output:
// {WindowCount:0xc000016170 Doors:<nil>}

The WindowCount holds the pointer to an integer which holds the value 2. Whereas since doors is missing from the JSON string it will set to nil thanks to the zero value of pointers. You can now write your logic in case of the absence of that value.

Conclusion

Since the field of a struct is part of the contract of the struct it can't go missing entirely instead you need to handle it little differently. The most preferable way is to convert the type to a pointer of the same type and when in some case the value is missing it will be set to the zero value, which is nil.

How to Auto Reload Golang Applications?

Mohammad Aziz — Mon, 30 Nov 2020 17:02:02 +0000

You wanted to develop quick, you wanted to develop fast and there is
nothing more tedious for a developer than doing the same thing again
and again.

I really HATE doing repetitive work.

Foundation (a server)

I have been exploring Go, you might be aware since my previous post was
written for itself. You can spin up a simple Go server with the following
code.

package main

import "net/http"

func handler(w http.ResponseWriter, r *http.Request) {
  fmt.Fprintln(w, "hello")
}

func main() {
  http.HandleFunc("/echo", handler)

  http.ListenAndServe(":3000", nil)
}

The above code creates a simple server which listens on port 3000 and if
you hit http://localhost:3000/echo you will receive "hello" as a message.

To run the go server we should run the command below

go run .

I call this the "tedious code". I don't care about it but I care what it
does for me, it runs my application.

I want changes, right now!

Now, if you do any changes to the code you have run the "tedious code" again, and again, and again...

You get it 🙄

If you are a lazy developer you must be thinking what is the
the better way to do it?

Your computer can help you will that for sure.

Firstly, you need to install Node.js.

I know, you must be thinking about how Node.js can help you to reload your Go code?
Just bear with me and you will know how.

Once Node.js is installed on your system you will be able to run the
command below.

npm install -g nodemon

It will install a package called nodemon in your system and you will be
able to run it from the command line.

Command to Auto Reload

Now you can start you Go application with the command mentioned below.

nodemon --exec go run . --ext go

Let's break it down.

It will watch for any files with .go extension in the current directory and if
any change in the go files it will execute the go run . command again.

Summary

By using nodemon you can reload your any application, not just Go, by providing the command
to run in the --exec command and specifying which extensions to watch and
if there is any change in the provided extensions, nodemon will execute the command specified in the --exec again.

How to get most starred repositories on GitHub?

Mohammad Aziz — Mon, 16 Nov 2020 18:16:13 +0000

It's not that easy to find most starred repositories on GitHub by your own. So here I created this video which will show you the trick on how to do it.

Give this post ❤️ if the video was helpful to you :)

How many pods you're running in your production environment?

Mohammad Aziz — Thu, 28 May 2020 10:03:06 +0000

Assuming you are using some kind of containerization (like Docker) to deploy your production code on Kubernetes, I'm curious to know how many pods are you currently running in your production environment and how do you manage them?

Merge two Sorted Linked List in Go

Mohammad Aziz — Wed, 27 May 2020 18:12:45 +0000

A linked list is a linear way to structure the data so that any arbitrary number of data we can store. That means it's flexible on the memory limitation as compare to arrays.

What do I mean by linear?

A linear data structure is where I can go to only one other element from the current one.

One supposes you already have two linked lists and they are already sorted how do you merge it effectively? What I mean by being effective is how can you swap the node in memory of a list without having to manage an extra dummy node?

Show me some code

Let go through each method one by one.

The first two are simple. The Print is to help print all the values in the linked list and Push will add value at the tail of the linked list.

The Output is 3 5 7 11

As promised since both linked lists are sorted then the expected output is very simple to guess.

`var result *Node = nil`

The result value is what we will be returning to the caller. At the start, there isn't any result so that's why keeping it nil.

`moveNode(dest Node, source Node)`

The dest and source are pointers to a struct pointer. The value of dest will be a nil value because of lastPtrRef = &((*lastPtrRef).next). In this function what happening is, we're setting the last value to the next node of the sorted list while doing that we're also updating the result variable. We're also clearing the value which should be removed from the top of the sorted list.

Reference

https://www.geeksforgeeks.org/merge-two-sorted-linked-lists/

Finding total lines of code in your project

Mohammad Aziz — Sat, 11 Apr 2020 17:05:29 +0000

You may be a new joiner to your organization or someone who is already working in a firm for many years. One day you're sitting on your chair and suddenly one thought came into your mind.

How many lines of code are in my project? 🤔

One challenge could be that you might be relying on external packages, preferably open-sourced, or some code coverage folder might be already present from the last time you have run your test. You can delete them, fair point but then you have to create the coverage or install all of the dependencies again. Only if there is a way adhere my .gitignore rules then the world could have been a little more perfect.

Turns out, there is a way out 💡

Entering `git`, like always!

git ls-files | xargs cat | wc -l

Running this command will give you the total number of lines in your project.

There are two parts in this process, well, as you can see there are three parts but you can think the last two commands as singular. The last two commands are there basically to count the number of lines only. The first command is a kind of interesting one which lists all the files that currently present in your repository and excludes the one who is ignored in your .gitignore file. So there you have it.

You can also tweak git ls-files command to check the lines for specific extensions.

Image Courtesy

Does an object passed from a function is by reference or by value in JavaScript?

Mohammad Aziz — Sun, 24 Nov 2019 19:32:24 +0000

Lying on my bed, I started pondering one question in my mind. Whether the object passed by a function call is passed by reference or passed by value in the context of the function body?

How to evaluate this?

It was confusing at first that how should I test this? Because of once a function returns something, its body is done executing, so there wasn't any mechanism to check what happens to the object if we change it outside of the function body; whether will it be changed into the function as well?

Enters Generators

A generator function is a kind of function whose execution of the body can pause and can resume from the same spot from which It was paused before. So I created one simple generator function which I'll be using as the base to evaluate my theory.

function* generator() {
  const me = {name: 'Aziz', age: 23};
  rv = yield me;
  console.log(me, rv);
}

Can you see the difference? It's the * over there ☝️. Now let's run this function.

let gen = generator();

Calling the above function doesn't mean that the body will start executing from the same. When we run a generator function, it returns a generator object which has a property called next, when we call this method, that is when the body of the generator function starts executing.

let myself = gen.next();

The result of calling next property is an object that is returned which has this type.

{value: any, done: boolean}

Changing object's value

Now, I've got the passed object me to the variable myself. Let's try to change its value.

myself.value.name = "Mohammad Aziz";

One fascinating thing about the generators is that you can also pass value from outside to the stopped position of the generator. This is done by calling the same next method and by passing the parameter you want to transfer to the generator body.

gen.next(myself.value);

// logs -> {name: "Mohammad Aziz", age: 23} {name: "Mohammad Aziz", age: 23}

Conclusion

This concludes that when we pass any object from a function, then it is passed by reference.

Debugging (Also) The Standard Library In Python

Mohammad Aziz — Sat, 27 Jul 2019 07:23:01 +0000

We all have to debug our application very often in order to fix a bug, learn something new, or to understand the flow of our code, etc.

Have you ever tried to debug your code in Python and more specifically in VS Code?

If you have then you will find that the VS Code is not letting you get into the standard library packages. I wanted to know what is happening under the hood of those files so get a better understanding of why my code is not working as expected.

I was trying to create_connection with the socket library. Every time when my file ran I was getting this error.

Not quite helpful for me. I wanted to put my breakpoint to where it was throwing the error. Now the question was how to do this?

There are two steps for it:

Add a configuration file if you don't have any.
Add justMyCode to false. 🎉

1. Add the configuration file

It is very simple to do.

Just go to the Debug tab
Click on the No Configurations option
Select Add Configuration...

After that just to select any one of the prompted options, Python File was in my case but VS Code also supports frameworks like Django, Flask, and Pyramid etc.

Once this has been done you will see and .vscode folder and in that folder, there will be a file named launch.json.

2. Adding Magical Words 😄

Now the time comes to add those magical words which will make you able to debug the files other than you code.

In launch.json, select the one configuration and add justMyCode: false. THAT'S IT!

The VS Code will now allow you to roam around the code of the standard library and you can find the exact reason why your code is not working as expected.

In my case, the problem was that you don't prepend https:// when you are passing host and port to socket.create_connection.

Footnotes

Follow me on Twitter

Cover Image: Chris Ried on Unplash

How to render different components based on the selected option?

Mohammad Aziz — Mon, 15 Apr 2019 10:13:26 +0000

I want to create a page where I have more than 30 different select options. Whenever I select one of the options based on the currently selected option, a different set of React components renders below.

As I have said, there are more than 30 different select options. Well, it is not necessary that for each option the combination of components will be different. There can be a one-to-many relationship between a component and the option under which the component is rendered.

There are many ways to do this, but I wanted to gather some ideas before I implement one. What approach should I take to create this kind of a page?

Forem: Mohammad Aziz

How to Use Unpublished Go Modules in Your Local Projects?

Context

Projects Layout

WIP Project

Tester Project

Using Unpublished Modules

Conclusion

Reference

How to Work with Arbitrary JSON in Go?

Abstract

JSON with a Fixed Structure

JSON That You Are Not Aware

Conclusion

How to Use Embedding to Write Cleaner Code in Go?

Abstract

Table of content

What is embedding

How to create embedding

Embedding In Interface

Embedding In Struct

Conclusion

Reference

How to Handle Missing Fields From A Struct in Go?

Compiler Loves Zero Values

Pointer To Rescue 🦸

Conclusion

How to Auto Reload Golang Applications?

Foundation (a server)

I want changes, right now!

Command to Auto Reload

Summary

How to get most starred repositories on GitHub?

How many pods you're running in your production environment?

Merge two Sorted Linked List in Go

What do I mean by linear?

Show me some code

The Output is 3 5 7 11

var result *Node = nil

moveNode(dest **Node, source **Node)

Reference

Finding total lines of code in your project

How many lines of code are in my project? 🤔

Entering git, like always!

Does an object passed from a function is by reference or by value in JavaScript?

How to evaluate this?

Enters Generators

Changing object's value

Conclusion

Debugging (Also) The Standard Library In Python

1. Add the configuration file

2. Adding Magical Words 😄

Footnotes

How to render different components based on the selected option?

`var result *Node = nil`

`moveNode(dest Node, source Node)`

Entering `git`, like always!