DEV Community: Fakorede Abiola

Variables in GO

Fakorede Abiola — Sat, 11 Apr 2020 10:12:45 +0000

Introduction

GO stores a variable inside a computer memory. A variable occupies some space on the memory depending on the variables type. Variables are only created after you run your program so they only become alive at the runtime not the compile-time. GO only knows the type at compile-time.

A variable stores a value with a type because GO is a strongly typed language. This is why we can't store an integer variable inside a variable which has a string type.

Variable Name allows us access the variable.

Variable Type GO is a statically typed programming language. In GO, every variable has a type. It is called static type since we can't change the type of a variable once we declare it.

Since a Variable should have a type, its only important to talk about the basic data types.

Basic Data Types

int - An int type represents numbers without a fractional part. It can be negative, zero, or positive numbers . It ranges from -128 to 127. These are called integer literals. GO has several built-in integer types for storing signed and unsigned numbers with varying sizes.

float64 - A float type are used to store numbers with a fractional part ex -2.5, 0.5, 1.5. These are called float literals.

bool - The bool type can only represent two values, true and false. These are called boolean values and are pre-declared constants.

string - The string type is used for representing human readable text data. An example string literal is "hello world!". A string can contain english and non-english characters.

How to Declare a Variable

In GO, we need to declare a variable before we can use it unlike in a dynamic language where we can assign a value to a variable even before declaring it. This is important and necessary for the compile-time safety.

Example

var speed int

The var keyword which is short for variable starts the variable declaration. It simply tells GO to declare a variable.

After the var keyword, we need to give a unique name to the variable. Here, speed is the name of this variable. A variable name can also be referred to as an identifier. It helps us understand which variable we are referring to.

int is the type of this variable. In GO, every variable has a type. This is because GO is a strongly-typed programming language. This helps the compiler find bugs in our program even before we run it. A variable type determines what type of value we can store in it and where we can use it.

Naming Rules

A name should only start with a letter or an underscore character. When the name starts with an uppercase letter, that name becomes exported so that other packages can use it.
A name can contain uppercase letters.
A name can have unicode letters. This works because GO can understand unicode letters.
A name cannot contain reserved keywords.

Zero Values

Now if we try to print this variable to the console, we get 0. This is because a variable gets initialized to a zero value when its declared without an initial value.

var speed int
fmt.Println(speed) // 0

Every GO type has a zero value. An empty variable gets a zero value depending on its type.

var speed int
var temperature float64
var off bool
var name string

fmt.Println(speed) // 0
fmt.Println(temperature) // 0
fmt.Println(off) // false
fmt.Printf("%q\n", name) // ""

Declaring Multiple Variables

By using a multiple declaration, we can declare multiple variables at once in the same declaration statement.

var (
   speed int
   temperature float64
   off bool
   name string
)

This is exactly the same as the previous declaration. Its purpose is to improve readability. Its better to use this style when you intend to group a few related variables together.

We can also declare multiple variables that have the same times like so:

var speed, velocity int

We don't have to define the types of each variable if their types are the same.

Type Inference

We can declare variables without specifying its type. This is because GO uses what is called Type Inference which means that GO can figure out the type of the variable automatically.

var age = 10
fmt.Printf("Variable has a type %T\n", age) // int

Short Declaration

In GO, we don't even need to use the var keyword. Just the name of the variable and its value is enough. In this case, we use the Short Declaration Syntax using the := operator like so:

isSafe := true
fmt.Printf("Variable has a type %T\n", isSafe) // bool

Multiple Short Declaration

We can declare and initialize multiple variables using short declaration.

month, day := "April", 11
fmt.Println(month, day) // April 11

Here "Fab is assigned to name and 22 is assigned to age. The first variable gets the first value and the second variable gets the second value.

Redeclaration

Redeclaration allows us to use existing variables in multiple short declaration variables i.e. declaring new variables while assigning values to existing variables.

var firstname string
firstname, lastname := "Nikola", "Tesla"

fmt.Println(firstname, lastname)

One of the variables must be a new variable or the redeclaration won't work.

When to Use Declaration vs When to Use Short Declaration

Use normal declaration:

If you don't know the initial value
When you want to group variables together

Use short declaration:

If you know the initial value
To keep the code concise
For redeclaration

Blank Identifier

What happens when we don't use declared variables? A variable declared in every block scope should be used or there will be an error.

func main() {
   var name string // ERROR: name declared and not used
}

Running this program will cause a compile-time error because the variable name was declared but not used.

The Blank Identifier( _ ) can be used to prevent unused variable error. It is like a black hole which consumes the variable.

func main() {
   var name string
   _ = name
}

Conclusion

Variables are a very important concept of any programming language. Therefore, it is important to understand the work-arounds around them. In this article, the following concepts were introduced:

Variable Declaration
Zero Values
Declaring Multiple Variables
Type Inference
Short Variable Declaration
Multiple Short Declaration
Redeclaration
Blank Identifiers

A link has also been provided to the GO Playground to demonstrate everything we have learnt in this lecture. Thanks for reading and any feedback would be much appreciated. 👋🏼

The Classic Hello World Program in GO

Fakorede Abiola — Thu, 09 Apr 2020 13:50:34 +0000

Introduction

To write your first code in any programming language, it has become a norm to start with a simple hello world program. In this post, I will be showing how to write a program in GO and explain all the parts of the program. Lets begin!👍🏼

Hello World

The first step is creating a helloworld folder in your $GOPATH. To learn more about how to do this, view my previous article here.

In the main.go file, write the following piece of code:

package main

import "fmt"

func main() {
   fmt.Println("Hello World!")
}

Explanation

package main should always be first statement in a GO program. This creates an executable GO program. Every GO file can only belong to a single package.
main represents the name of the package which this file belongs to.
import: The import keyword is used to import reusable pieces of code from other packages to use in our program.
import fmt: This line imports the fmt package. fmt is a package that ships with the GO standard library and is used for formatted I/O.
func main is an entry point to this program. It is a special function which tells GO where to start execution. In all executable programs, almost everything will be run under this function.
func represents a function. A function contains a block of code that can be executed when the function is called. It is used for reusable code.
fmt.Println: This line prints "Hello World" to the terminal when the program is run. Println is a method of the fmt package that writes to the standard output.

Running the Program

There are two(2) tools available to run a GO program.

go build: this command compiles the GO program and we can then run afterwards. First we compile the program using:

$ go build

It seems as though nothing happened but in the background, this compiles the GO code to machine code. We need to use the ls command to see the executable file. And then we run it by typing ./helloworld.

This way of running GO programs is best suited for deployment.

go run: this command both compiles and run the GO program.

$ go run main.go

This is the most suitable for prototyping i.e. when developing

Conclusion

That is all when trying to write and run your first program in GO. With this, we should be able to:

understand the basic parts of a GO program.
what statements like the package main and import clause does.
how to print to the console.
how to run a GO program.

What the $GOPATH is about

Fakorede Abiola — Thu, 09 Apr 2020 13:50:34 +0000

Introduction

I just recently started learning the GO programming language. While I have realized that keeping notes of what I am learning along the way is crucial to the learning process, I also decided to as well share some of my notes in the form of short articles revolving around everything I have learnt.

I almost skipped knowing what the $GOPATH is about all together as it wasn't discussed properly in the first resource I tried learning GO with. But from what I have gathered, I realize it is important to understand what the $GOPATH is and understand how it works.

What is $GOPATH?

I'll be answering this in a bullet point format to make it easier to digest. Here are some of the points I gathered:

The $GOPATH is an environment variable. It shows a location to a physical directory on a machine which has GO set up.
The $GOPATH directory is automatically created under the users folder when the Visual Studio Code GO extension is installed so we do not need to create it.
By default, GO assumes that the folder $GOPATH shows is in your users folder. So we do not need to set it.
To know what your $GOPATH is, use the command below in your terminal:

$ go env GOPATH

It is usually in the form Users/{user}/go

The directory $GOPATH points to is also referred to as a Workspace. It also shows GO tools where it can find GO source code files and other related stuffs like compiled packages, executable binaries and so on. By convention, every GO project uses this folder.
Inside this directory are three folders: bin, pkg, and src. The src folder contains GO source-code files and this is where we keep our GO projects.
When we download a GO project, it is stored under the $GOPATH.
An executable GO program needs its own directory which we create under the $GOPATH/src folder. For example:

$GOPATH/src/helloworld/main.go

If you have a GitHub account, it is better to put your project in a github.com folder under the src directory i.e.

$GOPATH/src/github.com/{your-username}/helloworld/main.go

Since we will be creating our projects under the $GOPATH/src folder, to open up the folder in VS Code using the terminal, if you're on MAC or have git bash installed on Windows, type:

$ code ~/go/src

Conclusion

Looking back, I realize how vital understanding what the $GOPATH is as a GO developer and how important its concept is in developing GO programs and packages. It is in fact a convention in the GO community and I would definitely urge anyone new to the language to endeavour to understand what it is.

Is Node.js really Single Threaded? Here is what I think...

Fakorede Abiola — Sat, 19 Oct 2019 07:32:14 +0000

This is a very popular question in the node.js ecosystem. One that has been asked over and over again. And while many believe node.js really is single-threaded, in my opinion, i believe to really answer this question we will have to take a dive into the internals of node.js.

To really understand this article, I assume the reader understands how Node.js uses the Event Loop to handle the asynchronous code we write as many performance concerns about Node.js eventually boils down to how the Event Loop behaves.

Building Blocks Of Node.js

Node.js is a runtime environment for executing JavaScript code outside of a browser. Node.js internally has a collection of dependencies it uses to execute the JavaScript code we write.

The most important of these dependencies are the V8 project and the libuv project.

The V8 project is an open source JavaScript engine created by Google to execute JavaScript code in the browser.

The Libuv project is a C++ open source project that gives Node.js access to the Operating systems' underlying file system, networking and as well handles some aspects of concurrency.

When we start up a node program on our computer, node automatically creates one thread and executes all of our code in that single thread. Inside that thread, we have the event loop which we can think of as a structure that determines what the thread should be doing at any given instance. Every node program has exactly one event loop which is at the core of the program.

Is Node Single Threaded?

Before i go in deeper, i have to make two points absolutely clear

The Node Event Loop itself is Single Threaded
Some of the functions included in the Node standard library are not Single Threaded. Which means some of the functions included in Node run outside of our event loop and outside that single thread. So, simply declaring that Node is single-threaded is not absolutely true.

In this article, we are going to look at a couple of examples of that by writing and executing some codes at the command line.

In your code editor, create a new file and name it threads.js

Require the pbkdf2 function from the crypto module

We will run the function and benchmark how long it takes to run on our individual computers. We are not concerned here how the function runs.

const crypto = require('crypto')

const start = Date.now()
crypto.pbkdf2('a', 'b', 100000, 512, 'sha512', () => {
      console.log('1:', Date.now() - start)
})

Now lets see how long it takes the program to run. In your terminal, run

node threads.js

For me, it takes aprox. 1600 milliseconds. Now lets duplicate the function and run:

const crypto = require('crypto')

const start = Date.now()
crypto.pbkdf2('a', 'b', 100000, 512, 'sha512', () => {
      console.log('1:', Date.now() - start)
})

crypto.pbkdf2('a', 'b', 100000, 512, 'sha512', () => {
      console.log('2:', Date.now() - start)
})

I have to make it clear that both functions will be invoked at approx the same time. With that in mind, lets run the program again

node threads.js

We will notice that the times we are having now is above what we had before.

Now, to really understand the significance of the results we had above, i will use the diagram below

The above is a diagram of the results we would have expected to see if node were truely single-threaded.

If Node really was single-threaded, this is what we would have expected.

But in reality, this is what really happened:

The pbkdf2 functions took approximately 2seconds to run. Clearly, this tells us something happened that went against the single-thread set up of Node because if we were running on only one single thread, we would have seen the first function call complete and then the second one execute.

What really happened?

The way the pbkdf2() function in the node crypto module works is that it has both the JavaScript and the C++ implementation. But behind the scenes it delegates all the work to be done to the C++ side which contains refernces to the Libuv library which gives Node.js access to the underlying Operating System.

For some standard library function calls, the Node's C++ side and libuv decides to do expensive operations outside of the event loop entirely. Instead they make use of what is called a Threadpool.

The Threadpool is a series of four threads that can be used for running computation intensive tasks such as the pbkdf2() function. By default, libuv created four threads in this threadpool. That means that in addition to the thread used for the event loop, there are four other threads that can be used to handle expensive operations that occur in our applications which some functions in the Node standard library make use of.

Conclusion

While the Event Loop in Node.js is single-threaded, It isn't entirely true that Node.js is single-threaded because there are some other threads available in the libuv Threadpool which Node.js uses in doing computational intensive tasks.

DEV Community: Fakorede Abiola

Variables in GO

Introduction

Basic Data Types

How to Declare a Variable

Zero Values

Declaring Multiple Variables

Type Inference

Short Declaration

Multiple Short Declaration

Redeclaration

When to Use Declaration vs When to Use Short Declaration

Blank Identifier

Conclusion

Other Articles 📖

Code Samples - https://github.com/Fakorede/Learning-Golang

GO Playground - https://play.golang.org/p/bF3u5v-Er39

The Classic Hello World Program in GO

Introduction

Hello World

Explanation

Running the Program

Conclusion

Other Articles 📖

Code Samples - https://github.com/Fakorede/Learning-Golang

What the $GOPATH is about

Introduction

What is $GOPATH?

Conclusion

Other Articles 📖

Code Samples - https://github.com/Fakorede/Learning-Golang

Is Node.js really Single Threaded? Here is what I think...

Building Blocks Of Node.js

Is Node Single Threaded?

What really happened?

Conclusion