DEV Community: Neel Modi

Variables in Depth

Neel Modi — Wed, 25 Nov 2020 07:19:29 +0000

In the previous blogs, we have covered enough topics to get you the introductory knowledge about How to code in Go. It is now time that we dive deep into specific topics and understand the in and out's.

In this blog, we will go through how to declare variables, assign values to variables, and then how to do both of them at the same time. Then we will discuss about the differences between the styles and when should you use which one.

Style 1 : Using var Keyword

The first and foremost way we will cover is using the var keyword. We have use this method in our previous introductory blogs.

We declare a variable using the following syntax:

var <name> <type>

Here, we first write the keyword var followed by the name of the variable and then the type we want to use. For example, we want to declare a variable called title of type string. It will look like this:

var title string

This way, we do declare the variable title but we don't assign a value to it at this moment. It is initialized or assigned it's default or zero-value which is empty string. You can verify this by printing the value of title using the fmt.Println method.

Style 2 : Using var Keyword but also Assigning a Value.

Adding to our style 1, we can further simplify the process by declaring and assigning the value at the same time. We do so in the following way:

var title string = "Spaces or Tabs"

We will not discuss about Spaces vs Tabs here but do comment your preference in the comment section.

In style 2, we are declaring the variable as we did in style 1 but we also added = <value> after it. This way, we can declare a variable and assign value to it immediately. Now, let's move onto style 3.

Style 3 : Using the short-declaration Operator.

The third style in which we can declare and assign an initial value to our variable is using the short-declaration operator.
We do it in the following way:

title := "Spaces or Tabs"

Those who have experience in python may recognize it as the walrus operator.

In this style, Go itself inferences the type of our variable by looking at the value assigned on the right hand side.

You might think like "Shouldn't we use style 3 all the time."

We do use it most of the time but there are scenarios where we have to use either style 1 or style 2.

Differences and When to Use.

Let's first discuss about the differences this styles comes with.
There are no differences in style 1 and style 2 but if you are aware of any, please share it for others in the comment section.

The main difference style 3 has with style 1 and style 2 is that we are not telling Go the type we want to use with the variable. Now, since Go itself is attaching the type to our variable, there are some limitations. In blog #3 Primitive Data Types in Go, we discussed about the different types of int present in Go. We have uint. Within uint, we have uint8, uint16, uint32 and uint64. Same goes for int, floats, and complex numbers.

When we define a variable like age := 18, Go initializes the variable age with value 18 of type int.

When we run the program, we see that our variable age is of type int.

Now, the problem arises when we want to declare the variable with different type of integer other than int like int8 or uint8. In this scenario, we use style 1 or style 2.

When to use which style.

Short-declaration operator can be used only inside a function body.
To define global variables or declare variables out of function blocks, we use the style 1 or style 2.
When we want to attach a specific type like uint8 or uint32, we use the style 1 or style 2.

With that said, we will wrap up our post here.
More on scope of go code will be discussed in the later blogs.

Make sure to follow me on DEV or Twitter if you like the content. It will help in increasing the reach of blogs to a wider audience.

Zero Values and Complex Data Types In Golang

Neel Modi — Sat, 21 Nov 2020 10:29:44 +0000

In the last blog, we talked about the Primitive Data Types of Golang. If you haven’t read it yet, first go read that blog. In that blog, in the end, we talked that we will learn about zero values and how we will optimize our code. So that’s the topic of this blog.

Our code from the last blog.

In the photo above, you can see that initially, when we are declaring the variables, we are not assigning the values at the time of declaring the variables.

Now, let’s look at what will be the output if we print the value of our variables before assigning values to them.

We print the values of the variables before assigning any values to the variables using the Println method from the package fmt.

If you have followed the guide, you may get an output similar to this.

In the terminal, you may notice that we are only seeing two zeros. But in reality, we are looking at two zeros and two empty strings "" . A question may arise in your mind that if we haven’t assigned any value to those variables, how can it decide on its own the values of the variables.

This is because whenever we declare a variable without assigning values to it, the Go language does that for us by automatically assigning Zero Values or Default Values. Each variable is given a default value as per its type.

Default values corresponding to their types are given below:

false for booleans, 0 for numeric types, "" for strings, and nil for pointers, functions, interfaces, slices, channels, and maps.

Now let’s move forward towards optimizing our code. In this blog, we will look at one of the Complex Data types present in Go. We will be talking about type Struct.

A struct in Go is similar to classes if you are coming from OOP paradigm languages like C++, Java, Python, etc.

What it basically does is it encapsulates different types which we use to describe a particular thing and form a single entity that can represent all the features of that particular thing.

For example, in our code above, we are declaring and assigning values to different variables only to describe a student. What we can do is define a student of type Struct and populate it with all the features we want the student to have. Let’s understand it more clearly by writing the code and then understanding what we have written.

After optimizing our code, it will look something like this.

Note that in the code above, we are not declaring a struct with keyword var, instead, we are using another keyword present in Golang called type. The keyword type is used when we want to define our own type apart from those present in the language.

Here, we are defining a type student of type struct. Confusing right. Let’s frame the sentence more clearly. We are declaring a variable of type student whose underlying type is a struct which allows us to store different data types inside it. It will get more clear as we move further ahead in the course.

Since now we can define structs in Golang, I want you to create a solution for the following problem.

Problem #2: We Define A Car With The Following Characteristics.

No. of tires.

Driving fuel. (i.e. Petrol, Diesel, Electric, etc.)

Capacity. (2-seater, 4-seater, etc.)

Company Name

Car Name

— — — — — — — — — — — — — — — — — — — — — — — — — — — — — — —

Try to solve the above problem and let me know your answers in the response section.

In the next blog, we will look at more complex data types.

Primitive Data Types in Golang

Neel Modi — Sat, 21 Nov 2020 10:23:59 +0000

Deep Dive into Golang’s Primitive Data Types and How To Use Them.

In the last blog, we discussed how to print text in the console. For that, we used string as the underlying type for our input variable. Now, in this blog, we will work on different types, actually different primitive data types provided by Go. Later, we will cover complex data types.

So, what are primitive data types?

Think of primitive data types as atoms. Atoms are the smallest particles in the universe which cannot be further broken. (Though we can use the latest technology to break them but we will leave it for the physicists.) Like atoms, primitive data types also cannot be further broken down. And like atoms, on combining them, we can form complex data types but more on that later.

Primitive data types in Golang

In golang, we have int, float, byte, string, rune & bool(boolean if you are coming from other programming languages).

1) Int

Int is one of the numeric types which represents a set of integers. There are various kinds of integer types associated with int. We have uint or unsigned integers, complex numbers, and int itself. Along with them are the different sets of numbers that they contain. For example, int8 contains all the 8-bit integers from -128 to +127, int16 contains all the 32-bit integers from -32768 to 32767.

By default, when we write int, the bits associated with it depends on the architecture of your computer. It can be either 32 or 64 bits.

2) Floats

Floats are also numeric types. They represent the decimal numbers. We have some special formatting on the floats which are known as verbs. Verbs are used to set the precision of the floating-point numbers. We will cover verbs when we will work on a problem where we have to calculate the GPA of a student.

In general, verbs are not only associated with floats. Verbs are the different formatting styles that we can apply when using the Printf method from package fmt.

3) String

A string type represents a series of string values or characters if you may. String type is usually used when we want to name things out or to write sentences. There are various needs that strings can satisfy but in layman’s terms, they are used for writing characters as we write words and sentences.

4) Boolean

When the outcome of our input can either be true or false, we use Boolean.

We have discussed the primitive data types, let’s look at them in action.

We always declare the variable in this way. (At least for now)

Var {Keyword} followed by the variable name followed by Data Type.

Problem #1: We want to populate the information of a student.

We would like to have his name, his age, his address, and his GPA for the last sem. Let name = Sam, age = 19, address = Encino, California and GPA = 3.9 {You can populate the data of your own choice.}

First, try it on your own and see if you can do this, I know you will. But here’s my take on it.

Okay, so this is how I would do it.

Note: This exercise is just for the shake of getting started with Go. We will discuss how to write it in a more approachable way in upcoming blogs.

So that’s it for this blog, in the next blog, we will further optimize our code and learn about Zero Values.

Learn Golang by Solving Real-World Problems

Neel Modi — Sat, 21 Nov 2020 09:55:26 +0000

Roadmap To Mastering the Language

Since you are already sold on learning "Go" after reading countless articles on the internet, we will cut it down directly to how you will learn it. In this series of blogs, we will learn anything new by solving real-world problems via programming and down the line, will focus on its applications.

We will start our journey by learning the keywords and syntax in Go. Later, we will move on to conditionals and statements, functions, methods, structs, maps, and many more features of the Go programming language. We will also cover how to read the go standard library because believe me it is confusing and time-consuming to just get the gist of what it wants to convey when you are a beginner.

Following is the roadmap of what we will be doing under various categories.

Note: This roadmap may change further down the line but everything which is shown in the photo will be covered. The only thing that may change will be the sequence or new things which I think should be added.

Now, before we start anything, I want to make sure you have set up your Go development environment. If not, now is the right time. Follow this link if you haven't already.

In your src directory create a directory for example called youngling in which we will store all the codes for beginner level concepts and projects.

Problem #0: The Good Ol’ Hello World

In this introductory blog, we will look at how to define variables, and how to print out some text back to the user.

Step 1) Declaring the package name

The first thing in every Go program that we do is defining the package name. We will define the package name as **package main **here.

Every Go program starts by defining the package name

Step 2) Importing the required packages

After we have defined the package name, we will always write the package imports that we will use in our program. Think of packages as pre-written codes to perform a specific action. In our case, we have to print out a text to the user and for that, we will import a package called “fmt” which stands for format. More on that later.

We always enclose the package name which we are importing inside double-quotes. The red squiggly shown above is because we have imported the fmt package but haven’t used it yet.

Step 3) Main function block

Now, since we have imported the fmt package, we will now move on to write the main logic behind solving the problem. The main driving code of our problem is always written between the main function. Think of it as the entry point of our code which runs as soon as we first compile our program.

The syntax to declare the main function is shown in the above picture.

Now, we will work on writing the logic which will solve our problem, but remember that we will have to write it between the main function block otherwise it won’t run and will result in an error.

Step 4) Declaring the variable

There are various ways to declare a variable in go but we will focus right now on only one. More on that later. We will create a variable named **input **which will store the text which we want to print out to the user.

We define a variable by writing the keyword *var **followed by the **variable name **and the **type **we want our variable to be. *(A keyword is a text which has a special meaning attached to it and cannot be used by us in our code. Golang has 25 keywords which we will discuss further down the line.)

In this example, we will use string as the type of input. Follow this link to see the various types Golang offers us. We will cover each type and will also define our own types later on.

Step 5) Assigning value to our input

In Golang, we cannot leave unused variables, meaning we have to use every variable we define in our code. To use a variable, we have to do two things, first declare and assign values to it, and secondly perform some actions on it. We will now assign value to our variable input and print it out to the user. I am assigning the value “Hello World” here but you can write anything you want but between the double-quotes.

Assigning value Hello World to the variable input.

Step 6) Printing the value

Now, since we have assigned the value to our variable, “Hello World” in my case, we will try to print it. For this, we will use a method called Println from the package fmt.

We use the Println method as shown above. First, we type the package name from which we are using the method, followed by a . (dot) and the method name. While writing the code, you can repeat this in your head, “From package fmt, I am using the Println method”.

Note: All the methods are called only by placing parenthesis in the end and passing inside the variable we want to carry operations on.

(input)

Now save the file as main.go. See here, we have an extension of .go with our filename. All go programs are saved as .go

Step 7) Run the program

We have written all the code required to print out the text to the user. Now to run the code, we have to first compile it into the byte code which will tell our computer to do the intended operations. For that open your terminal inside the code directory and run the following command.

go run <filename>.go 

For example: 

go run 01.go

You should see the results in your terminal.

So that’s it for this blog. We have covered the extreme basics of how we start writing our code. We will learn more about packages, methods, and the different ways of declaring and assigning variables in the later blogs. Till then, adios.

Setting Up Dev Environment for Golang

Neel Modi — Thu, 19 Nov 2020 06:43:58 +0000

In this post, we will be setting up our development environment for writing go-code. Now, first thing that should be clear is having a good development environment as it brings up your "A-game" when writing good quality codes. The better your environment, the less work you have to do, and the better the code quality. Do Less, Do Better.

Assuming you have no prior experience in installing Go, we will first start by installing Go in Windows and then in Ubuntu(can be applied to any other distro). For Mac, I have no experience in installing Go in Mac, so sorry folks but you have to work on yourself and then join us later when setting up VSCode.

For Windows

First of all, head over to golang.org and click on "Download Go" button. You will be redirected to a new page. Now click on the .msi installer under the Microsoft Windows box, the installer will be downloaded. Once, the installer is downloaded, open it and install Go. (Just do next, next, next!). Once Go is installed, you can verify it by opening your Command Prompt and enter

go version

Next step is creating a workspace folder.

On your PC, create a folder which will be used to store Go Projects. Mine is in Local Disk C. You can see the path.

C:\workspace\go

Now create three directories in here by the name bin, pkg, src. The src folder is the one which we will for our projects initially before learning about Go Mod.

After creating a workspace folder, we have to add it to the GOPATH. To do this, first search for environment variables in your search window. (Search Window can be open by pressing Win+S).
Click on edit environment variables for your account.

Now, under user variables, i.e. the first dialog box, if no GOPATH variable is there, then create a new one by clicking on New. Then under variable name, write GOPATH and under variable value, copy the path of your workspace folder.

Mine looks something like this:

That's it, you have successfully installed Go in your Windows PC. You can now jump directly to the VSCode part of the post.

For Ubuntu

Firstly, we will download the tar ball of Latest Go version. At the writing of this post, the latest Go Version is 1.15.something something. You can check the latest version by going to the official golang website golang.org. Click on Download Go and check the latest version. You can download it from there, or you can follow the way I am showing. The reason is that those who are running Ubuntu on WSL (like me), for them downloading and then moving the Go Tar file is kind of a boring work.

In your terminal, write the following term.

wget -c https://dl.google.com/go/<insert your version here>.linux-amd64.tar.gz -O - | sudo tar -xz -C /usr/local

The above step will download the tar file, will extract it and place the resultant directory under /usr/local/.

Now, we have to set the GOPATH. In your .profile file, located in your root, place the following line at the end of the file.

export PATH=$PATH:/usr/local/go/bin

By default, the GOPATH is set us $HOME/go. Therefore, in your HOME directory, you have to create a directory named go. You can do this by copying and pasting the following text.

mkdir ~/go

Now create three directories in here by the name bin, pkg, src. The src folder is the one which we will for our projects initially before learning about Go Mod.

Now, source your .profile file or just restart your terminal.
Verify your installation by writing

go version

in your terminal.

Setting Up VSCode

I use VSCode as my code editor but feel free to use any other code editor of your choice. If you are using VSCode, then follow the steps.

Install VScode on your PC.
Download the official go-extension.
Once, the extension is installed, a pop-up will be shown to download some additional tools. Make sure you click on Install All.
Next step is setting up an advanced Linter. Open your settings.json file by pressing CTRL + , and on top right, click on the file icon.
Copy the following text in the end of the file.

"go.lintTool":"golangci-lint",
"go.lintFlags": [
  "--fast"
]

Make sure you format this document otherwise it may break your VSCode.

So that's it for this post, we will start working on learning Go by solving real world problems from the next post. It is already publish on Medium prior to writing this post. You can check out those posts also.

These are the friend links:

You can contact me on twitter @neel229 ✌