Gurucharan94

Restart A Service Fabric Application Replica using PowerShell

2020-06-10T00:00:00+00:00

Here is a PowerShell script to restart replicas where specific applications / services are deployed to.

Connect-ServiceFabricCluster -ConnectionEndpoint <domain-without-https.com:19000> `
-KeepAliveIntervalInSec 10 -AzureActiveDirectory -ServerCertThumbprint <thumbprint>

$nodes = Get-ServiceFabricNode

For ($i = 0; $i -lt $nodes.Count; $i++) {

    $result =  Get-ServiceFabricDeployedReplica -NodeName $nodes[$i].NodeName -ApplicationName fabric:<appName> `
                | Where-Object ServiceName -eq fabric:<serviceName> | Select-Object -Property ReplicaId, Partitionid

    For ($j = 0; $j -lt $result.Count; $j++) {
        Write-Host $nodes[$i].NodeName $result[$j].Partitionid $result[$j].ReplicaId
        Restart-ServiceFabricReplica -NodeName  $nodes[$i].NodeName -PartitionId $result[$j].Partitionid -ReplicaOrInstanceId $result[$j].ReplicaId
    }
}

A Collection of Public Speaking Tips for Developers

2020-05-27T00:00:00+00:00

This blog post is a collection of public speaking tips for developers. The tips include how to respond to a CFP (Call for Papers), how to structure your talk, how to design your slides, preparing good demos and how to deal with anxiety and prepare for failure.

Tips to get your talk accepted

Conferences, Local Meetups, User Group events all have a call for papers (CFP). Writing a good proposal is paramount to getting accepted. A convincing abstract, professional head-shot, and an impressive bio will surely improve your chances of getting through. Below are some tips that I found useful.

Writing a good proposal

On crafting a story arc and slide design

On Abstracts, Practicing, Tech Checks and Preparing for Failure

If you are only going to pick one link from here, then pick this speaking guide from Zach Holman
Here is a 4 hour paid Pluralsight course on Speaking Fundamentals by Scott Hanselman & Rob Conery
Here is a collection of speaker tips from twitter

How to migrate data between two Cosmos DB instances using PowerShell

2020-05-16T00:00:00+00:00

I have previously written about Cosmos DB utility tools that you cannot miss. Cosmos DB Data Migrator is the one I use most if I have to move data around across multiple instances of CosmosDB. Here is a simple script I wrote to migrate data from the source database to a target instance of Azure Cosmos DB.

$cosmosCollections = @(
  "collection1",
  "collection2",
  "yetanothercollection",
  "ThisIsTheLastOneIPromise"
  );

### Settings for Prod
$sourceConnectionString = "AccountEndpoint=<sourceendpoint>;AccountKey=<sourcekey>;Database=<sourcedatabase>"
$targetConnectionString = "AccountEndpoint=<targetendpoint>;AccountKey=<targetkey>;Database=<targetdatabase>"

$timestamp = Get-Date -Format "MM-dd-yyyy-HH-mm-ss"

foreach ($collection in $cosmosCollections)
{
  Write-Host "Starting Migration of $collection"
  $file = "./migration-$timestamp-$collection.log"
  Start-Process -Wait -NoNewWindow -RedirectStandardOutput $file -FilePath "\path\to\executable\dt.exe" `
                -ArgumentList "/ProgressUpdateInterval:00:00:05 /s:DocumentDB /s.Collection:$collection /s.ConnectionString:$sourceConnectionString /s.InternalFields /t:DocumentDBBulk /t.DisableIdGeneration /t.Collection:$collection /t.ConnectionString:$targetConnectionString"

  Write-Host "End Migration of $collection"
}

You can save this script in your computer. Once you execute this file, you will see logs that shows you how many records were migrated

Transferred: 0; Failed: 0; Elapsed Time: 00:00:00
Transferred: 250; Failed: 0; Elapsed Time: 00:00:04.8250522
Transferred: 650; Failed: 0; Elapsed Time: 00:00:09.8259306
Transferred: 1050; Failed: 0; Elapsed Time: 00:00:14.8389670
Transferred: 1450; Failed: 0; Elapsed Time: 00:00:19.8393121
Transferred: 1800; Failed: 0; Elapsed Time: 00:00:24.8405494
Transferred: 2200; Failed: 0; Elapsed Time: 00:00:29.8413284
Transferred: 2600; Failed: 0; Elapsed Time: 00:00:34.8423809
Transferred: 3000; Failed: 0; Elapsed Time: 00:00:39.8551647

There is no value in keeping this hidden on a folder in my hard drive, is there ? So, I made it public. I am pretty sure that I will do an internet search for this later 😎. Hopefully, you will find this useful as well.

What you need to know about blogging as a developer

2020-05-13T00:00:00+00:00

In this blog post, I write about why I set-up my blog (yes, very meta) using GitHub pages on my own domain. I write about cross-posting, SEO optimization, my blogging schedule and ultimately figuring out why I blog.

1. Choosing a Blogging Platform

The biggest question I had when I started was where should I blog ? Medium ? Dev.to ? Or on my own website ?

The internet is a digital real estate and you have the chance to own your piece of land of the digital estate by choosing to blog on a domain you own. If you are blogging on a 3rd party medium, it means you have decided to rent. You are trading convenience for control and ownership. You are giving away your words to a 3rd party company. A company that can

Change its terms and conditions that you surely carefully read
Erroneously suspend/ban your profile
Be hacked (I’m looking at you WordPress)
Paywall your content or
Simply go out of business.

All your words, wasted. Your permalinks, gone.. With your own blog, you have control. Your domain, your words, your permalinks, your theme.

1.1 Setting up a blog on GitHub Pages

If I have convinced you about setting up your own blog, the next question is what are the options available ? While there are many blogging platforms, I like using GitHub Pages to host my blog and I have my reasons.

It is FREE.
I can set it up very quickly.
I understand git and GitHub (to an extent 😂)
Plenty of themes available on GitHub for me to choose from.
I can customize the themes to my liking while still respecting the license terms.
I can host it on my domain if I have one (you should have one!!).

If you want to set up a blog using GitHub pages, you have to

Choose a Jekyll Theme. I use the minimal mistake theme.. It comes with a full-text search, disqus integration for comments, pagination, tags, categories, atom feed and everything I needed.
Fork the source repository and rename it to username.github.io
You will have a basic empty blog available with HTTPS at https://username.github.io.

But isn’t GitHub pages a third-party platform ? No. It merely provides free hosting for blogs powered by the open-source Jekyll blogging software. If GitHub goes out of business (I don’t see that happening), I can simply move to a different host or spin up a server on the cloud that can host a Jekyll site. Then, I make some changes to the DNS records and my blog is available again. No broken URL’s. All of this is possible because my blog and it’s contents are exportable and portable.

Owning my content does not mean rolling out a custom blogging engine. Believe me, I tried. It’s not worth it.

2. Improving Viewership by Cross-Posting

While I blog on my domain, I can still cross-post on popular websites. Medium let’s me import my blog posts. Dev.to can import from my RSS Feed. When I cross-post on other platforms, there is a special rel=canonical thing in the post, that says this post was originally posted on some other domain and so cross-posting does not cost me search engine points. I realized that I made up the term when writing this. Search Engine Points.

By cross-posting content, I get the best of both worlds. I own my content and can still improve my viewership.

3. SEO Optimization

The next thing I do is optimize my posts for search engines and social media sharing. What I mean by that is not stuffing keywords in my blog but rather adding the right metadata for my blog posts so that social media creates a good preview for it. My Jekyll theme did most of the work for me.

I might have customized it a bit and you can see how many meta tags I have in the <head> section. If this is new to you, an internet search on SEO will help you.

<title>Title of the post</title>
<meta name="description" content="">
<meta name="robots" content="follow,index">
<link rel="icon" type="image/png" href="/assets/images/logo.png">
<meta property="og:type" content="article">
<meta property="og:locale" content="en_US">
<meta property="og:site_name" content="Gurucharan94">
<meta property="og:title" content="">
<meta property="og:url" content="">
<meta property="og:description" content="">
<meta property="og:image" content="">
<meta name="twitter:site" content="@gurucharan94">
<meta name="twitter:title" content="">
<meta name="twitter:description" content="">
<meta name="twitter:url" content="">  
<meta name="twitter:card" content="summary_large_image">
<meta name="twitter:image" content="">
<meta property="article:published_time" content="">
<link rel="canonical" href="">
  <script type="application/ld+json">
    {
      "@context": "https://schema.org",
      "@type": "Person",
      "name": "Gurucharan Subramani",
      "alternateName":"Gurucharan94",
      "url": "https://www.gurucharan.in",
      "sameAs": ["https://www.linkedin.com/in/gurucharan94","https://twitter.com/gurucharan94","https://github.com/gurucharan94"]
    }
  </script>

I spend more time making a good cover image for my blog than actually writing my blog posts. So I decided to fix it once and for all with GitHub Actions.

4. Schedule and Consistency

When I started a year ago, I decided I want to write at least one blog post every month and see if I can consistently do it for a year. For the most part, I was successful. This year I wanted to write at least two every month. And then I see myself writing every week. I wanted to start small, be consistent and take it from there. To start with a goal of I will write every week would have surely set me up for failure.

Off late, I have realized that I should publish on a schedule. Not 2 blog posts on the first of the month because I’ve already written them and then nothing for 45 days. I want to have a few blog posts written upfront but published later on a schedule. Every alternate Wednesday or something like that. To do that, I will future date my blog posts and use GitHub actions to publish when the time comes.

5. But… I have nothing to blog about

I’ve been there. I felt that I have nothing interesting to blog about. What if I am wrong ? I am no expert. What if nobody reads it ?

The answer to all this comes down to why I wanted to blog. My blog is a collection of my notes, bookmarks, ideas, solutions and thoughts made public. It is a love letter to my future self. I write so that I can later do an internet search of my words. I am not trying to “influence” you. I am not attempting to sell you anything. I am trying to write things down because I can’t remember everything. And I let you know about my writing in the hope that you find something interesting on my blog. If something was interesting to me, there is a good chance someone else will find it interesting as well. Once the Why I Blog was clear to me, I’m no longer looking for that perfect blog post. I’m writing more frequently. I am not trying to position myself as the expert. I am merely an “experienced beginner”. Aren’t we all?

Side by Side install of multiple versions of NodeJS and NPM with NVM on Windows 10

2020-05-03T00:00:00+00:00

I already have NodeJS installed on my machine. But I start working on a different project and that sometimes requires a higher or lower version of NodeJS. So, I wanted to see if I can have multiple versions of NodeJS installed side-by-side. This blog post shows you how to install and manage multiple versions of NodeJS, Node Package Manager (NPM) using Node Version Manager (NVM) on Windows 10.

I found a nice project on Github that helps me install and manage multiple version of NodeJS on a windows machine.According to the project, this is the npm/Microsoft/Google recommended Node.js version manager for Windows.

Installation of NVM for Windows

Head over to the release page to download the latest version of NVM.

Before you extract and install NVM, make sure that you remove any previous installations of NodeJS.Also ensure to delete any existing NodeJS installation directories "C:\Program Files\nodejs" that might remain.
You should also delete the existing npm install location "C:\Users\<user>\AppData\Roaming\npm", so that the nvm install location will be correctly used instead.

Then extract the files and run the setup. Next, Next, Next, I accept the terms and finish. Once the installation is complete, you can open PowerShell as administrator and run nvm to check if everything is installed correctly.

Install Node, NPM using NVM

Now, the next thing to do is install the required versions of NodeJS and see how to switch between them.

nvm list available shows you a list of available node downloads
nvm install <version> downloads and installs said version
nvm use <version> activates specified version of node. You can then type node -v to confirm the installation. npm -v tells you what version of NPM you have.

You can install another version of Node on your machine side by side with existing install by invoking nvm install <version> and switch to the newer version using nvm use <version>.

Global utilities like gulp will have to be installed separately for each installed version of Node.

I also needed to install yarn and I did that using the npm i -g yarn command.

Common Issues

Now that the installations are completed, here are some known issues that you have to keep in mind when using NVM for Windows.

As of writing, only official Windows terminals are supported (CMD and PowerShell).
NVM is an installer and so Windows requires elevated administrative privileges to perform specific functions like running nvm use.
You have to uninstall previous versions of Node before installing NVM for Windows.

This blog post showed you how to use NVM Windows to manage your node versions side by side on Windows and a few of the issues that you need to keep in mind when using NVM.

Auto Generate Open Graph Cover Images for your blogs posts with GitHub Actions

2020-05-01T00:00:00+00:00

I spend more time making a social media preview image for my blog than actually writing my blog posts. And more often than not, I end up with a preview image that I am fully convinced about. And then I decide to spend more time on this on my next blog post to get a better preview and round and round it goes. Talk about #bikeshedding.

In this blog post, I show you how to auto-generate a simple, consistent preview image using GitHub Actions for your Jekyll powered blog hosted on GitHub pages.

What are GitHub Actions

GitHub Actions help you automate your software development workflows. You can write individual tasks, called actions, and combine them to create a custom workflow.

Workflows are custom processes that usually helps to build, test, package, release, or deploy any code. Here we use an existing action in the marketplace to auto-generate open graph images for my blog posts.

You can find this action in the marketplace

Creating the workflow with GitHub Actions

To create a new workflow, I created a new main.yml file (the name of the file does not matter) under .github/workflows folder, and pasted the contents below.

name: "Generate OG Images"
on: pull_request

jobs:
  generate_og_job:
    runs-on: ubuntu-latest
    name: Generate OG Images
    steps:
      - name: Checkout
        uses: actions/checkout@v1
      - name: Generate Image
        uses: BoyWithSilverWings/generate-og-image@1.0.3
        env:
          GITHUB_TOKEN: $
          GITHUB_CONTEXT: $
        with:
          path: assets/images/
          commitMsg: Auto Generated OG image
          fontColor : "#00695c"

In the next step, I add the below contents to the front matter of the markdown file that contains the blog post.

ogImage:
  title: "**Auto Generate OG image with GitHub Actions**"
  subtitle: "www.gurucharan.in | @gurucharan94"
  filename: "auto-generate-og-image-no-subtitle-updated-font-size-120-bold-text-green-font"
  fontSize: "120%"

How does this work?

GitHub automatically triggers the workflow on every Pull Request (PR) as specified in the main.yml file.
It checks if there are any markdown files that are changed as part of the PR and then reads the appropriate settings. File specific settings specified in the front matter of the YAML file takes precedence over the repository level settings specified in main.yml (with section).
A preview image is then created and the pull request is updated by adding this new jpeg file and a preview is available as a comment in the PR page.
If you are not happy with the image and want to generate a new one with different settings, please ensure that you provide a new file name. There seems to be a problem overwriting files. Not a show stopper by any means.

You should look at the docs for details about the different configuration options.

Take a look at this pull request for a demo with multiple configuration options.

The GitHub action merely generates a nice image for you. You need the appropriate meta tags in the <head> section of your HTML page if you need the preview to show up when you hit share on social media. If you are reading this from your laptop or computer, you can (should) hit F12 right now to open up the developer tools and browse the code for this page.

With preview image generation automated, I’m hoping I will spend time more time ACTUALLY blogging.

How to Invite Guest Users in Azure Active Directory using Azure Logic Apps

2020-04-27T00:00:00+00:00

You can invite guest users on your tenant using the Azure Active Directory B2B collaboration. This blog post shows you how to invite guest users using Azure Logic Apps by invoking the /invitation endpoint from the Microsoft Graph API.

Azure Logic Apps is a cloud service that helps you schedule, automate, and orchestrate tasks, business processes, and workflows when you need to integrate apps, data, systems, and services across enterprises or organizations.

Microsoft Graph Endpoint for Invitations

From the Graph Endpoint docs, you can send a HTTP POST request to https://graph.microsoft.com/v1.0/invitations to invite a guest user to the organization.

The request body looks like the below json.

{
    "inviteRedirectUrl": "https://myapplication.com",
    "invitedUserDisplayName": "Gurucharan",
    "invitedUserEmailAddress": "youremail.com",
    "invitedUserMessageInfo": {
        "customizedMessageBody": "Custom invitation message 👍👍👍"
    },
    "sendInvitationMessage": true
}

You also need to send a Bearer token in your header. To obtain a bearer token, you have to register an application in the Active Directory. You can follow the below steps to do so.

Registering an Application in the Active Directory

You need to register an application in the Azure Active Directory as an “Azure AD only single-tenant” app so that this app is available only for users in this directory.
Ensure the registered app has the User.Invite.All permission configured under Application permission and consent is also provided.
Then take note of the registered application’s
- ApplicationID
- TenantID or DirectoryID
- Password / Secret Key

Now that we have the app registration part completed, we can create a logic app where we will invite a guest user.

Azure Logic App Configuration

Create a new logic app in Azure and once it is created, use the designer to create a workflow that looks like below and click save.

The logic app makes a call to the rest endpoint every hour and obtains a bearer token using the Client Credentials flow. The OAuth 2.0 client credentials grant flow permits a web service (confidential client) to use its own credentials, instead of impersonating a user, to authenticate when calling another web service. You can read more about this method of obtaining a Bearer token here.

It then uses the token to invite a guest user to the organization by making a HTTP POST call to the specified endpoint with the mentioned payload.

Invoke the Logic App

If you manually invoke the logic app, you will see that the run is successful and you would have also received an email invite to the organization. The custom message and the emojis are all there. Cool 😎😎😎.

Once you click on “Get Started” button, you will be guided to the invitation redemption steps and then be redirected to the application URL that was specified in inviteRedirectUrl in the request body. After you have everything working, you can disable the logic app (or not).

Closing Remarks

I have previously written about inviting guest users using Powershell. The disadvantage with the PowerShell approach (and the Azure Portal approach) is that it requires me to log in and sends the invite as me. It would say Gurucharan has invited you to da da da. And I don’t want that.

With Logic Apps, you can easily invite application users as the application itself. Very useful in situations where this process needs to be fully automated. These are simple HTTP calls and so you can also do this as part of your core applications or have an Azure Function invite users as well. If Azure Functions excite you, take a look at the Microsoft Graph bindings for Azure Functions.

Let’s Go - Part 2 : Basic Concepts of the Go Programming Language

2020-04-15T00:00:00+00:00

This is part 2 of a multi-part series of blog posts on learning Go.

This blog post covers the basic concepts of the GO language and covers Packages, DataTypes, Constants, Variables and Functions.

Package

Every Go program is made up of packages. Programs start running in package main.
The code sample below imports the fmt and math/rand packages into a parenthesized, “factored” import statement.
By convention, the package name is the same as the last element of the import path. For instance, the math/rand package comprises files that begin with the statement package rand.
In Go, a name is exported if it begins with a capital letter. From the math package, pi is not exported but PI is.

package main

import (
  "fmt"
  "math/rand"
)

func main() {
  fmt.Println(math.pi) // Throws Error as pi is not exported
  
  fmt.Println(math.Pi) // Works Fine

}

Data Types

The following are Go’s basic data types.

bool

string

int  int8  int16  int32  int64
uint uint8 uint16 uint32 uint64 uintptr

byte // alias for uint8

float32 float64

complex64 complex128

Variables

The var statement declares variables and the data type is specified after the name.
The var may be “factored” into blocks, as with import statements.
Inside a function, the := short assignment statement can be used in place of a var declaration with implicit type. Outside a function, := construct is not available.

Variables declared without an explicit initial value are given their zero value.

The zero value is

0 for numeric types,
false for the boolean type, and
”” (the empty string) for strings.

package main

var (
  ToBe   bool // Set to it's zero value
  MaxInt uint64     = 1<<64 - 1
  z      complex128 = cmplx.Sqrt(-5 + 12i)
)

var a,b int // Set to their zero value

func main() {
  i:= 20
  fmt.Println(i, a, b, ToBe, z, MaxInt)
}

Constants

Constants are declared but with the const keyword. They can also be “factored” into blocks, as with import statements.
Constants can be character, string, boolean, or numeric values.
Constants cannot be declared using the := syntax.

package main

import "fmt"

const(
  x = "Hello"
)

func main() {
  var integer1 int = 52
  integer1 = 30

  const Pi = 3.14
  Pi = 1.22 // This fails as you cannot reassign a value to a constant
  
  fmt.Println(Pi);
  fmt.Println(x);
  fmt.Println(integer1);
}

Functions

A function can take zero or more arguments and that the type comes after the argument name.
When two or more consecutive named function parameters share a type, you can omit the type from all but the last.
A function can return any number of results.

package main

import "fmt"

func add(x int, y int) int { // type comes after the argument
  return x + y
}

func subtract(x , y int) int { // the type of x is omitted
  return x - y
}

func divide(x , y int) (int, int) { // the function returns multiple results
  return x /y , x%y
}

func main() {
  fmt.Println(add(42, 13))
  fmt.Println(subtract(42, 13))
  fmt.Println(divide(42, 13))
}

In this blog post we looked at some of the basics concepts of the GO programming language such as Packages, DataTypes, Constants, Variables and Functions. In the next one, we will look at more concepts of the language such as

Conditionals
Loops
Switches and
Defers

Let’s Go - Part 3 : Basic Concepts of the Go Programming Language (Contd.)

2020-04-15T00:00:00+00:00

This is part 3 of a multi-part series of blog posts on learning Go.

In this post, we will understand how to control the flow of code with if conditionals, for loops, switches and defers.

Loops in Go

Go has only one looping construct, the for loop. The basic for loop has three components separated by semicolons.
- the init statement: executed before the first iteration
- the condition expression: evaluated before every iteration and loop exits once this is false
- the post statement: executed at the end of every iteration
The init and post statements are optional. When they are omitted, go’s for loop becomes a while loop.
There are no parentheses surrounding the three components of the for statement and the braces { } are always required.

package main

import "fmt"

func main() {
  
  for i := 0; i < 10; i++ {
    fmt.Println(i) // Prints 0,1, 2 up to 9
  }
  
  sum := 1
  for sum < 1000 {
    sum += sum
    fmt.Println(sum) // Prints 2,4,8,16,32,64,128... 1024
  }
}

If

The if statement need not be surrounded by parentheses ( ) but the braces { } are required.
The else part is optional and can also contain an if statement.
The if can start with a short statement to execute before the condition. The variables inside the short statement are also available inside any of the else blocks.

package main

import (
  "fmt"
)

func oddoreven(x int) {

  // A simple if else statement
  if x%2 == 0 {
    fmt.Println("Even")
  } else {
    fmt.Println("Odd")
  }
}

func oddoreven2(x int) string {

  if y:=x%2; y == 0 { // y:=x%2 is the short statement before the condition
    return fmt.Sprintf("%d is even \n" , y) // y is available here
  } else {
    return fmt.Sprintf("%d is odd \n", y) // y is also available here
  }
}

func main() {
  
  oddoreven(33)

  fmt.Println(
    oddoreven2(1),
    oddoreven2(10),
  )

}

Switch

A switch statement is a shorter way to write a sequence of if-else statements.
It evaluates cases from top to bottom, runs the first case whose value is equal to the condition expression and stops thereby not running the following cases . In effect, the break statement that is used in certain other languages is not needed.

package main

import (
  "fmt"
  "runtime"
)

func main() {

  switch os := runtime.GOOS; os {
  case "darwin":
    fmt.Println("OS X.")
  case "linux":
    fmt.Println("Linux.")
  default:
    fmt.Printf("%s.\n", os)
  }
}

Defer

A defer statement defers the execution of a function until the surrounding function returns with 3 simple rules
1. A deferred function’s arguments are evaluated when the defer statement is evaluated.
2. Deferred function calls are executed in Last In First Out order after the surrounding function returns.
3. Deferred functions may read and assign to the returning function’s named return values.

You can read more about defer and additional concepts like panic and recover from this blog post

In this post, we looked at how to control the flow of code with if conditionals, for loops, switches and defers. In the next post, we will look at more data types available in the Go language such as

Structs
Arrays
Slices and
Maps.

Let’s Go - Part 1 : Getting Started with the Go Programming Language

2020-04-12T00:00:00+00:00

This is part 1 of a multi-part series of blog posts on learning Go.

In this blog post, we looked at what is the Go programming languages, installing the Go binaries and running a simple “Hello World” program in Go.

The Go Programming Language

An internet search on Go will lead you the official documentation on Go that states

Go is expressive, concise, clean, and efficient. Its concurrency mechanisms make it easy to write programs that get the most out of multicore and networked machines, while its novel type system enables flexible and modular program construction. Go compiles quickly to machine code yet has the convenience of garbage collection and the power of run-time reflection. It’s a fast, statically typed, compiled language that feels like a dynamically typed, interpreted language.

It looks like Go’s strongest features are

Concurrency
Smaller Footprint
Run-time Reflection
Garbage Collection

There may be a lot to unpack here. I will not be doing that here because I don’t need these features now. I want to install Go successfully and get to “Hello, World !”. Let’s do that now and leave the advance bits for later.

If you want to use an online playground to practice Go, you can do so at the Go playground

Installation of Go

You can download Go from the downloads page. I have a Windows 10 machine and will download the Go binaries for windows. The installation was fairly simple. Next, Next, Accept the terms and conditions that I carefully spent 5 hours reading 🤣 and Finish. I see that Go is installed in C:\Go.

Next, I open a PowerShell window and type ‘go’ and see the below output. Go is installed successfully. As of writing, I have the 1.14.2 version of Go installed.

Go is a tool for managing Go source code.

Usage:

        go <command> [arguments]

The commands are:

        bug         start a bug report
        build       compile packages and dependencies
        clean       remove object files and cached files
        doc         show documentation for package or symbol
        env         print Go environment information
        fix         update packages to use new APIs
        fmt         gofmt (reformat) package sources
        generate    generate Go files by processing source
        get         add dependencies to current module and install them
        install     compile and install packages and dependencies
        list        list packages or modules
        mod         module maintenance
        run         compile and run Go program
        test        test packages
        tool        run specified go tool
        version     print Go version
        vet         report likely mistakes in packages

Use "go help <command>" for more information about a command.

Additional help topics:

        buildmode   build modes
        c           calling between Go and C
        cache       build and test caching
        environment environment variables
        filetype    file types
        go.mod      the go.mod file
        gopath      GOPATH environment variable
        gopath-get  legacy GOPATH go get
        goproxy     module proxy protocol
        importpath  import path syntax
        modules     modules, module versions, and more
        module-get  module-aware go get
        module-auth module authentication using go.sum
        module-private module configuration for non-public modules
        packages    package lists and patterns
        testflag    testing flags
        testfunc    testing functions

Use "go help <topic>" for more information about that topic.

Hello World in Go

I fired up VS Code and pasted the “Hello World” program from the docs.

package main

import "fmt"

func main() {
  fmt.Printf("hello, world\n")
}

You can build it with the Go tool by running go build <filename>.go. This creates a <filename>.exe in the same folder from where the command was run. Running <filename>.exe prints hello world on the console. For more details on the build command in Go, run go help build.

In this blog post, we looked at what is the Go programming languages, installing the Go binaries and running a simple “Hello World” program in Go. But I don’t really know what is happening in the program. In the next part, we will hopefully get to know more about the important concepts of the language and perhaps words like package, import and others will make more sense then.