Abhinav P Y / Personal Website

Future Blog Post

2199-01-01T00:00:00-08:00

This post will show up by default. To disable scheduling of future posts, edit config.yml and set future: false.

Daily Blog Post 29th June 2022

2022-06-29T00:00:00-07:00

Knowledge Transfer of Digital AI product (Highest Priority) (4 hours)

Finish at least 4 videos from the KT Sessoins take by Vinay (Suggested by Yashas Manjunath).

Finish the Introductory Numerify PDF (1 Hour)

Finish as many topics as possible on the Numerify PDF.

Spring MVC (Finish a project from the Udemy Course) (2 hours)

Java Spring course - Finish one full course with project

LeetCode - Solve 10 Problems (2 hours)

Finish problems and write solutions here on Github.

Finish one sheet of vocab for GRE (High Priority) (1 hour)

Finish a sheet and write down the meanings of all words learnt.

Learn Web Design (Finish HTML and/or CSS Section 1)

Finish a module of FreeCodeCamp HTML or CSS. Or maybe even React.js.

Daily Blog Post 2 May 2022

2022-05-02T00:00:00-07:00

Chapter 2 - William Stallings COA

Finished Reading the chapter - spent 1.5 hours.

Chapter 2 - DDIA

Finished reading the first section of the chapter - spent 1 hour.

Day 2 of 100DaysOfCode for JavaScript and NodeJS - JWT Implementation in JavaScript

Spent about 2.5 hours trying to implement JWT in JavaScript.

ReactJS - Day 2 of 100DaysOfCode

Went through the first component. Spent about 0.5 hours on this.

Daily Blog Post 1 May 2022

2022-05-01T00:00:00-07:00

ReactJS - Started Day 1 of 100DaysOfCode of ReactJS

Studied about react components. hen it comes to React it is all about components. You can think of components as independent chunks of user interfaces. Components can be as small as one HTML element or you can be a rebel, and jam your entire facebook clone in one component. At the end of the day, a lot of it depends on your needs and wants. In reality though you will probably avoid the one component route because it defeats the purpose of using React.

You see the benefit of component is you can build a bunch of independent isolated, and most importantly reusable user interfaces that you can run and piece together just like lego blocks.

And as a result, build even super complex apps without going insane.

While your app can have as many components as you’d like, it will always have atleast one called root component.

We already glossed over it a bit, but just to reiterate the major benefits of using components and essentially, react, develop your next app or phone, you can build independent pieces of user interfaces, meaning changing logic, or layout in one component will not break your OLAP once component is ready to go, you can reuse it all throughout your app.

But component code is still stored in one place.

So if you ever need to make some changes, you don’t have to run around like a headless chicken, simply locate the component, apply the changes, and all the instances will be automatically updated.

And of course, let’s also not forget about speed.

You see behind the scenes, React is using something called virtual DOM, where only the component that needs to be updated, is affected.

And what’s really cool, it’s done without rerendering the whole app, which in turn, of course, increases the speed of your final product.

And as a result the user experience as well.

Before we go, let’s look at a typical example of React that everyone uses to show React Components in Action. And that is no other than our beloved Twitter.

So as we are looking at the screen, on the left hand side of the homescreen we see various React Components. So you will see a bunch of words, however you probably notice that each link has pretty much the same structure, where there is some kind of icon and associated text.

So essentially what we could do is set this up as one component. And what that means is we will just set up a structure, and everywhere where we would want to use it, we will just need to pass in the data.

And by data of course I mean, the specific icon that is going to be rendered. And then of course the text.

And as a result, what that also means that I can reuse that component, all throughout my application, however I would like.

But if I would want to make some changes, for example if I would want to add something here, I can change it in one place, and then all the instances will be automatically updated. so that would be a links example.

And you can probably already guess, the same, for example, would work with a post. Because when we are looking at the post, what do we have, we have some kind of picture, we have the name, of course, we have the text, we have all the retweet options, as well as likes and comments, but the only thing that is changing is the data. So the person who is posting and how many likes, and that sort of thing. The point that I am trying to make is that as you are looking at the application, you can see a bunch of places where we can set up a react component, and then use all the awesome benefits the components provide.

Before we go futher, let’s cover the main goals of this course, and honestly there is only one: By the end of the course I should be comfortable with React. Now what that means is you can do two things. First, you are aware of external resources. And more importantly, you’re comfortable with using them. When you’d want to learn something new. Essentially you know where to find useful info. And second, you are comfortable applying theory to practice by building your own project using React.

While the Core API of react is essentially quite small, since it is by far the most popular framework out there, the ecosystem surrounding react is as vast as you can imagine. What that means is that essentially, there will always be something new to learn about React.

That’s why I would suggest adopting a student mindset instead, where you are always open to expanding your React knowledge. In my experience, the best way to learn and get comfortable with language and framework is by building a bunch of projects. So that is exactly what we will do during this course, we’ll start small, our first project will be somewhat silly, but slowly and surely, we will expand on our knowledge. And by the end of the course, you will be comfortable building your own complex React apps.

Structure

Dev Environment
Tutorial
Projects
Redux

Course Requirements

HTML
CSS
JavaScript (ES6)
Coding Addict - JavaScript Nuggets

The more javascript you know the easier it is going to become. Because at the end of the day React is just javascript. So if you are familiar with things like spread operator, ro functions, destructuring etc. you will be in good shape.

Dev Environment

Node
Browser = Chrome
VSCode
React Developer Tools

CSS - 100DaysOfCode Day - 1

Box Model - Extrinsic and Intrinsic Sizing.
Content Sizing
The area of the box model
A useful analogy
Debugging the box model
Controlling the box model
Resources

Content Sizing - Extrinsic sizing, Intrinsic sizing.

The areas of the box model - margin box, border box, padding box, content box.

The border box surrounds the padding box and its space is occupied by the border value. The border box is the bounds of your box and the border edge is the limit of what you can visually see. The border property is used to visually frame an element.

The final area, the margin box, is the space around your box, defined by the margin rule on your box. Properties such as outline and box-shadow occupy this space too because they are painted on top, so they don’t affect the size of our box. You could have an outline-width of 200px on our box and everything inside and including the border box would be exactly the same size.

Every browser applies a user agent stylesheet to HTML documents. The CSS used varies between each browser, but they provide sensible defaults to make content easier to read. They define how elements should look and behave if there’s no CSS defined. It is in the user agent styles where a box’s default display is set, too. For example, if we are in a normal flow, a <div> element’s default display value is block, a <li> has a default display value of list-item, and a has a default display value of inline.

An inline element has block margin, but other elements won’t respect it. Use inline-block, and those elements will respect the block margin, while the element maintains most of the same behaviors it had as an inline element. A block item will, by default, fill the available inline space, whereas a inline and inline-block elements will only be as large as their content.

Alongside an understanding of how user agent styles affect each box, you also need to understand box-sizing, which tells our box how to calculate its box size. By default, all elements have the following user agent style: box-sizing: content-box;.

Having content-box as the value of box-sizing means that when you set dimensions, such as a width and height, they will be applied to the content box. If you then set padding and border, these values will be added to the content box’s size.

OAuth 2.0

YouTube Link: https://youtu.be/Aj143QiiQPY

API Kong

Wrote slides : https://docs.google.com/presentation/d/1WVtuhszW1a7pJk109EFxMZWOGhMQyUvIsMSl0yP9vUU/edit?usp=sharing

Computer Organization and Architecture

Read Chapter - 1 of William Stallings COA Book.

Dynamic Programming - 100DaysOfCode - Day 1

https://leetcode.com/tag/dynamic-programming/discuss/662866/DP-for-Beginners-Problems-or-Patterns-or-Sample-Solutions

The above problem list will be followed:

Problem for Day - 1 : Longest Increasing Subsequence Variant : Longest Increasing Subsequence: https://leetcode.com/problems/longest-increasing-subsequence/

Sample Solution for LIS:

  int lengthOfLIS(vector<int>& nums) {
    int n = nums.size();
  
    vector<int>LIS(n+1, 1);
    for(int i = 0; i < n; i++) {
      for(int j = 0; j < i; j++) {
        if(nums[i] > nums[j]) {
          LIS[i] = max(LIS[i], 1 + LIS[j]);
        }
      }
    }
  
    int ans = 0;
    for(i = 0; i < n; i++) {
      ans = max(ans, LIS[i]);
    }
    return ans;
  }

RESTful API Golang 18 April 2022

2022-04-18T00:00:00-07:00

package main

import(
	"encoding/json"
	"fmt"
	"io/ioutil"
	"log"
	"net/http"
	"github.com/gorilla/mux"
)

type event struct {
	ID string `json: "ID"`
	Title string `json: "Title"`
	Description string `json: "Description"`
}

type allEvents []event

var events = allEvents{
	event{ID : "1", Title: "Title1", Description: "Desc1"},
	event{ID : "2", Title: "Title2", Description: "Desc2"},
}

func homePage(w http.ResponseWriter, r *http.Request) {
	fmt.Fprintf(w, "Welcome to the homepage!!!")
	fmt.Println("Endpoint Hit: homePage")
}

func returnAllEvents(w http.ResponseWriter, r *http.Request) {
	fmt.Fprintf(w, "The events are as follows: ")
	json.NewEncoder(w).Encode(events)
	fmt.Println("Endpoint Hit: returnAllEvents")
}

func getSingleEvent(w http.ResponseWriter, r *http.Request) {
	eventID := mux.Vars(r)["id"]

	for _, singleEvent := range events {
		if singleEvent.ID == eventID {
			fmt.Fprintf(w, "Successfully found required event: ")
			json.NewEncoder(w).Encode(singleEvent)
		}
	}
	fmt.Println("Endpoint Hit: getSingleEvent")
}

func createSingleEvent(w http.ResponseWriter, r *http.Request) {
	var newEvent event
	reqBody, _ := ioutil.ReadAll(r.Body)

	json.Unmarshal(reqBody, &newEvent)
	events = append(events, newEvent)
	
	fmt.Fprintf(w, "The newly entered data is as follows: ")
	json.NewEncoder(w).Encode(newEvent)
}

func deleteSingleEvent(w http.ResponseWriter, r *http.Request) {
	eventID := mux.Vars(r)["id"]
	for i, singleEvent := range events {
		if singleEvent.ID == eventID {
			events = append(events[:i], events[i+1:]...)
			fmt.Fprintf(w, "The event with ID %v has been deleted successfully", eventID)
		}
	}
}

func updateSingleEvent(w http.ResponseWriter, r *http.Request) {
	eventID := mux.Vars(r)["id"]
	var updatedEvent event

	reqBody, _ := ioutil.ReadAll(r.Body)
	
	json.Unmarshal(reqBody, &updatedEvent)

	for i, singleEvent := range events {
		if singleEvent.ID == eventID {
			singleEvent.Title = updatedEvent.Title
			singleEvent.Description = updatedEvent.Description
			events = append(events[:i], singleEvent)
			fmt.Fprintf(w, "Successfully updated event %v", eventID)
		}
	}
	fmt.Println("Endpoint Hit: updateSingleEvent")
}

func main() {
	router := mux.NewRouter().StrictSlash(true)
	router.HandleFunc("/", homePage).Methods("GET")
	router.HandleFunc("/events", returnAllEvents).Methods("GET")
	router.HandleFunc("/event/{id}", getSingleEvent).Methods("GET")
	router.HandleFunc("/event", createSingleEvent).Methods("POST")
	router.HandleFunc("/event/{id}", deleteSingleEvent).Methods("DELETE")
	router.HandleFunc("/event/{id}", updateSingleEvent).Methods("PATCH")
	log.Fatal(http.ListenAndServe(":8080", router))
}

Twitter API Golang.

2022-04-12T00:00:00-07:00

Using the Twitter API to get tweets

This post will talk through the steps on how to create your own Twitter bot in Go! We will be making use of go-twitter which is a Go client library for the Twitter API. Big thanks to the developers over there for making an easy to use library.

Prerequisites

Twitter developer account
Valid Golang installation
Basic programming knowledge

Creating a Twitter API key

If you haven’t already got a developer account on Twitter you will need to sign up. The steps to do this are documented here.

Once you have an approved developer account head over to the dashboard and create a new Project.

Take note of your API key, API key secret, access token, access token secret as we will need these in a few moments time.

Go….code!

Open the twitter-bot directory in your favourite editor and create a file named main.go.

Firstly we will focus on authenticating with twitter. We are going to store the keys in environment variables. It’s not a good idea to have sensitive information stored in our code as when it reaches our source control (Github, Gitlab, etc) it may be visible to others.

Head over to the developer dashboard page where you should see the project you just created. On the left hand side click the name of your project under Projects & Apps. Navigate to the Keys and tokens page which is where we grab the API keys from.

We need four values CONSUMER_KEY, CONSUMER_SECRET, ACCESS_TOKEN and ACCESS_TOKEN_SECRET. These can all be found on the Keys and tokens page. Once you have the values populate the export commands with the right values.

export CONSUMER_KEY=<API_KEY_VALUE>
export CONSUMER_SECRET=<API_KEY_SECRET_VALUE>
export ACCESS_TOKEN=<ACCESS_TOKEN_VALUE>
export ACCESS_TOKEN_SECRET=<ACCESS_TOKEN_SECRET_VALUE>

Once we have exported the environment variables we need to read them in via our Go code. The following code will do that and it will be the method we use when the code is complete

package main
import (
	"fmt"
	"os"
)

type Credentials struct {
	ConsumerKey       string
	ConsumerSecret    string
	AccessToken       string
	AccessTokenSecret string
}

func main() {
	creds := Credentials{
		ConsumerKey:       os.Getenv("CONSUMER_KEY"),
		ConsumerSecret:    os.Getenv("CONSUMER_SECRET"),
		AccessToken:       os.Getenv("ACCESS_TOKEN"),
		AccessTokenSecret: os.Getenv("ACCESS_TOKEN_SECRET"),
	}

	 fmt.Printf("%+v\n",creds)
}

This bit of the code can be divided into three sections

Imports This is where we import other packages that we make use of in our code. It’s only a short list at the moment but we will be adding a few by the time we have completed the Twitter bot! Struct We define a struct to store the keys that we need to use for authenticating with Twitter. main function This function is slightly special in that it is the entrypoint and will be called automatically when we run our program. For now we are just going to prove that we can read in our environment variables.

Copy the code snippet into main.go and run it using the following command

go run main.go

This should output something similar to this

{randomvalue1 randomvalue2 randomvalue3 randomvalue4}

In your case each of the values should be referring to the keys from twitter.

Authenticating with Twitter

Now that we have exported our environment variables and are able to read them in we are ready to authenticate with Twitter.

func getClient(creds *Credentials) (*twitter.Client, error) {

	// These values are the API key and API key secret
	config := oauth1.NewConfig(creds.ConsumerKey, creds.ConsumerSecret)
	// These values are the consumer access token and consumer access token secret
	token := oauth1.NewToken(creds.AccessToken, creds.AccessTokenSecret)
	httpClient := config.Client(oauth1.NoContext, token)
	client := twitter.NewClient(httpClient)

	verify := &twitter.AccountVerifyParams{
		SkipStatus:   twitter.Bool(true),
		IncludeEmail: twitter.Bool(true),
	}
	user, _, err := client.Accounts.VerifyCredentials(verify)
	if err != nil {
		fmt.Println(err)
		return nil, err
	}
	// print out the Twitter handle of the account we have used to authenticate with 
	fmt.Println("Successfully authenticated using the following account : ", user.ScreenName)
	return client, nil
}

We can now call this function from within our main function. Replace this line(we don’t need to log the credentials out anymore)

fmt.Printf("%+v\n",creds)

with

client, err := getClient(&creds)
if err != nil {
    fmt.Println(err)
    os.Exit(1)
}

Search tweets

As I have mentioned previously the go-twitter client library makes it nice and easy to talk to the Twitter API in Go! Let’s create our next function where we make use of the search functionality

func searchTweets(client *twitter.Client) error {

	search, _, err := client.Search.Tweets(&twitter.SearchTweetParams{
		Query: "bonjour",
	})

	if err != nil {
		fmt.Println(err)
		return err
	}
	fmt.Println("search : ", search)
	return nil
}

Add the following line to our main() function (at the bottom)

searchTweets(client)

and then run the code with go run main.go

Your terminal window will turn into what looks like a wall of text that doesn’t make a lot of sense. This code works but there’s definitely room for improvement! All of the tweets that were returned were in French (Not surprising given the search parameter) and the big wall of text is not very readable. Let’s make some improvements to the searchTweets() function.

Improving our search function

I’m not sure about you but unfortunately I’m unable to speak French so the first change we’ll make is to add a language to the search parameters. We do this by adding the following parameter for English Lang: “en”,. This will bring back tweets where Twitter has detected the language to be English. Let’s change our search parameter to become the following

search, _, err := client.Search.Tweets(&twitter.SearchTweetParams{
    Query: "bonjour",
    Lang:  "en",
})

The second change is to parse the interesting bits of each tweet into a struct so we can ignore the bits we don’t care about and more clearly see the bits we do care about! Let’s try and keep things anonymous by only grabbing the tweet likes, retweets and the tweet itself. To do this let’s create another struct but this time it will hold tweet data instead of credentials

type TweetData struct {
	Tweet         string
	LikeCount    int
	RetweetCount int
}

When we use the client to search tweets we get a twitter.Search object back which has an array of tweets and metadata. To grab out the values we want to keep we will loop over the array of tweets creating a struct to hold the data. We will print each struct so it makes it more readable than the previous wall of text!

New and improved…

func searchTweets(client *twitter.Client) error {
	search, _, err := client.Search.Tweets(&twitter.SearchTweetParams{
		Query: "bonjour",
		Lang:  "en",
	})

	if err != nil {
		fmt.Println(err)
		return err
	}

	for _, v := range search.Statuses {
		tweet := TweetData{
			Tweet:        v.Text,
			LikeCount:    v.FavoriteCount,
			RetweetCount: v.RetweetCount,
		}
		fmt.Printf("%+v\n", tweet)
	}
	return nil
}

Replace the existing searchTweets() with the above snippet of code. Feel free to add/remove/change the SearchTweetParams to something you find more interesting. You could change the query parameter to something else (maybe “Formula 1”). You could also add on some additional parameters to the query.

At the moment this is a pretty simple use case but hopefully it gives you a foundation to build on. We could go on and build up an array of tweets and do some kind of processing on them. We could send tweets via the client when a certain condition is true.

TLDR

If you just want to skip ahead to the completed code snippet or want to use the completed snippet for reference, here it is. If you come straight here don’t forget to make sure you have your API keys setup.

package main

import (
	"fmt"
	"os"

	"github.com/dghubble/go-twitter/twitter"
	"github.com/dghubble/oauth1"
)

type Credentials struct {
	ConsumerKey       string
	ConsumerSecret    string
	AccessToken       string
	AccessTokenSecret string
}

type TweetData struct {
	Tweet        string
	LikeCount    int
	RetweetCount int
}

func main() {
	creds := Credentials{
		ConsumerKey:       os.Getenv("CONSUMER_KEY"),
		ConsumerSecret:    os.Getenv("CONSUMER_SECRET"),
		AccessToken:       os.Getenv("ACCESS_TOKEN"),
		AccessTokenSecret: os.Getenv("ACCESS_TOKEN_SECRET"),
	}

	client, err := getClient(&creds)
	if err != nil {
		fmt.Println(err)
		os.Exit(1)
	}
	searchTweets(client)
}

func getClient(creds *Credentials) (*twitter.Client, error) {

	// These values are the API key and API key secret
	config := oauth1.NewConfig(creds.ConsumerKey, creds.ConsumerSecret)
	// These values are the consumer access token and consumer access token secret
	token := oauth1.NewToken(creds.AccessToken, creds.AccessTokenSecret)
	httpClient := config.Client(oauth1.NoContext, token)
	client := twitter.NewClient(httpClient)

	verify := &twitter.AccountVerifyParams{
		SkipStatus:   twitter.Bool(true),
		IncludeEmail: twitter.Bool(true),
	}
	user, _, err := client.Accounts.VerifyCredentials(verify)
	if err != nil {
		fmt.Println(err)
		return nil, err
	}
	// print out the Twitter handle of the account we have used to authenticate with
	fmt.Println("Successfully authenticated using the following account : ", user.ScreenName)
	return client, nil
}

func searchTweets(client *twitter.Client) error {
	search, _, err := client.Search.Tweets(&twitter.SearchTweetParams{
		Query: "Formula 1",
		Lang:  "en",
	})

	if err != nil {
		fmt.Println(err)
		return err
	}

	for _, v := range search.Statuses {
		tweet := TweetData{
			Tweet:        v.Text,
			LikeCount:    v.FavoriteCount,
			RetweetCount: v.RetweetCount,
		}
		fmt.Printf("%+v\n", tweet)
	}
	return nil
}

Golang Prep April 8th 2022

2022-04-08T00:00:00-07:00

Golang Interview Questions

All these questions and content were sourced from InterviewBit.com

Golang or most popularly known as Go is one of the youngest programming languages that was released in the year 2012 at Google by developers Robert Griesemer, Rob Pike and Ken Thompson. It is said that Golang was born out of frustration with the demerits of the existing programming languages.

Go is a high level, open-source programming language that was mainly developed keeping in mind the efficiency of code without compromising on the simplicity and faster compilation time to help develop software applications at a faster pace. Companies like Google, Apple, Uber are using Golang due to its proven ability of less learning time, faster code development, improved runtime efficiency, reduced bugs, concurrency, garbage collection strategies and so on.

1. What is Golang?

Go is a high level, general-purpose programming language that is very strongly and statically typed by providing support for garbage collection and concurrent programming.
In Go, the programs are built by using packages that help in managing the dependencies efficiently. It also uses a compile-link model for generating executable binaries from the source code. Go is a simple language with elegant and easy to understand syntax structures. It has a built-in collection of powerful standard libraries that helps developers in solving problems without the need for third party packages. Go has first-class support for Concurrency having the ability to use multi-core processor architectures to the advantage of the developer and utilize memory efficiently. This helps the applications scale in a simpler way.

2. Why should one learn Golang? What are the advantages of Golang over other languages?

Go language follows the principle of maximum effect with minimum efforts. Every feature and syntax of Go was developed to ease the life of programmers. Following are the advantages of Go Language:

Simple and Understandable: Go is very simple to learn and understand. There are no unnecessary features included. Every single line of the Go code is very easily readable and thereby easily understandable irrespective of the size of the codebase. Go was developed by keeping simplicity, maintainability and readability in mind.
Standard Powerful Library: Go supports all standard libraries and packages that help in writing code easily and efficiently.
Support for concurrency: Go provides very good support for concurrency using Go Routines or channels. They take advantage of efficient memory management strategies and multi-core processor architecture for implementing concurrency.
Static Type Checking: Go is a very strong and statically typed programming language. Statically typed means every variable has types assigned to it. The data type cannot be changed once created and strongly typed means that there are rules and restrictions while performing type conversion. This ensures that the code is type-safe and all type conversions are handled efficiently. This is done for reducing the chances of errors at runtime.
Easy to install Binaries: Go provides support for generating binaries for the applications with all required dependencies. These binaries help to install tools or applications written in Go very easily without the need for a Go compiler or package managers or runtimes.
Good Testing Support: Go has good support for writing unit test cases along with our code. There are libraries that support checking code coverage and generating code documentation.

3. What are Golang Packages?

Go Packages (in short pkg) are nothing but directories in the Go workspace that contains Go source files or other Go packages themselves. Every single piece of code starting from variables to functions are written in the source files are in turn stored in a linked package. Every source file should belong to a package.

The package is declared at the top of the Go source file as package

The packages can be imported to our source file by writing: import

An example of the Go package is fmt. This is a standard Go Package that has formatting and printing functionalities such as Println().

4. Is Golang case sensitive or insensitive?

Go is a case-sensitive language.

5. What are Golang pointers?

Go Pointers are those variables that hold the address of any variables. Due to this, they are called special variables. Pointers support two operators:

* operator: This operator is called a dereferencing operator and is used for accessing the value in the address stored by the pointer.
& operator: This operator is called the address operator and is used for returning the address of the variable stored in the pointer.

Pointers are used for the following purposes:

Allowing function to directly mutate value passed to it. That is achieving pass by reference functionality.
For increasing the performance in the edge cases in the presence of a large data structure. Using pointers help to copy large data efficiently.
Helps in signifying the lack of values. For instance, while unmarshalling JSON data into a struct, it is useful to know if the key is present or absent then the key is present with 0 value.

6. What do you understand by Golang string literals?

String literals are those variables storing string constants that can be a single character or that can be obtained as a result of the concatenation of a sequence of characters. Go provides two types of string literals. They are:

Raw string literals: Here, the values are uninterrupted character sequences between backquotes. For example: interviewbit
Interpreted string literals: Here, the character sequences are enclosed in double quotes. The value may or may not have new lines. For example: “Interviewbit Website”

7. What is the syntax used for the loop in Golang? Explain.

Go language follows the below syntax for implementing for loop.

for [condition |  ( init; condition; increment ) | Range]  
{  
   statement(s);  
   //more statements
}  

The for loop works as follows:

The init steps gets executed first. This is executed only once at the beginning of the loop. This is done for declaring and initializing the loop control variables. This field is optional as long as we have initialized the loop control variables before. If we are not doing anything here, the semicolon needs to be present.
The condition is then evaluated. If the condition is satisfied, the loop body is executed.
- If the condition is not satisfied, the control flow goes to the next statement after the for loop.
- If the condition is satisfied and the loop body is executed, then the control goes back to the increment statement which updated the loop control variables. The condition is evaluated again and the process repeats until the condition becomes false.
If the Range is mentioned, then the loop is executed for each item in that Range.

package main

import "fmt"

func main() {
    // For loop to print numbers from 1 to 5
    for j := 1; j <= 5; j++ {
        fmt.Println(j)
    }
}

8. What do you understand by the scope of the variables in Go?

The variable scope is defined as the part of the program where the variable can be accessed. Every variable is statically scoped (meaning a variable scope can be identified at compile time) in Go which means that the scope is declared at the time of compilation itself. There are two scopes in Go, they are:

Local Variables: These are declared inside a function or a block and is accessible only within these entities.
Global Variables: These are declared outside function or block and is accessible by the whole source file.

9. What do you understand by Go routines in Golang?

A goroutine is nothing but a function in Golang that usually runs concurrently or parallelly with other functions. They can be imagined as a lightweight thread that has independent execution and can run concurrently with other routines. Goroutines are entirely managed by Go Runtime. Goroutines help Golang achieve concurrency.

In Golang, the main function of the main package is considered the main goroutine. It is the starting point of all other goroutines. These goroutines have the power to start their goroutines. Once the execution of the main goroutine is complete, it means that the program has been completed.
We can start a goroutine by just specifying the go keyword before the method call. The method will now be called and run as a goroutine. Consider an example below:

package main
import (
    "fmt"
    "time"
)
func main() {
    go sampleRoutine()
    fmt.Println("Started Main")
    time.Sleep(1 * time.Second)
    fmt.Println("Finished Main")
}

func sampleRoutine() {
    fmt.Println("Inside Sample Goroutine")
}

In this code, we see that the sampleRoutine() function is called by specifying the keyword go before it. When a function is called a goroutine, the call will be returned immediately to the next line of the program statement which is why “Started Main” would be printed first and the goroutine will be scheduled and run concurrently in the background. The sleep statement ensures that the goroutine is scheduled before the completion of the main goroutine. The output of this code would be:

Started Main
Inside Sample Goroutine
Finished Main

10. Is it possible to return multiple values from a function in Go?

Yes. Multiple values can be returned in Golang by sending comma-separated values with the return statement and by assigning it to multiple variables in a single statement as shown in the example below:

package main
import (
	"fmt"
)

func reverseValues(a,b string)(string, string){
    return b,a    //notice how multiple values are returned
}

func main(){
    val1,val2:= reverseValues("interview","bit")    // notice how multiple values are assigned
    fmt.Println(val1, val2)
}

In the above example, we have a function reverseValues which simply returns the inputs in reverse order. In the main goroutine, we call the reverseValues function and the values are assigned to values val1 and val2 in one statement. The output of the code would be:

bit interview

11. Is it possible to declare variables of different types in a single line of code in Golang?

Yes, this can be achieved by writing as shown below:

var a,b,c= 9, 7.1, "interviewbit"

Here, we are assigning values of a type Integer number, Floating-Point number and string to the three variables in a single line of code.

12. What is “slice” in Go?

Slice in Go is a lightweight data structure of variable length sequence for storing homogeneous data. It is more convenient, powerful and flexible than an array in Go. Slice has 3 components:

Pointer: This is used for pointing to the first element of the array accessible via slice. The element doesn’t need to be the first element of the array.
Length: This is used for representing the total elements count present in the slice.
Capacity: This represents the capacity up to which the slice can expand.

For example: Consider an array of name arr having the values “This”,“is”, “a”,“Go”,“interview”,“question”.

package main
 
import "fmt"
 
func main() {
 
    // Creating an array
    arr := [6]string{"This","is", "a","Go","interview","question"}
 
    // Print array
    fmt.Println("Original Array:", arr)
 
    // Create a slice
    slicedArr := arr[1:4]
 
    // Display slice
    fmt.Println("Sliced Array:", slicedArr)
 
    // Length of slice calculated using len()
    fmt.Println("Length of the slice: %d", len(slicedArr))
 
    // Capacity of slice calculated using cap()
    fmt.Println("Capacity of the slice: %d", cap(slicedArr))
}
Here, we are trying to slice the array to get only the first 3 words starting from the word at the first index from the original array. Then we are finding the length of the slice and the capacity of the slice. The output of the above code would be:

Original Array: [This is a Go interview question ]
Sliced Array: [is a Go]
Length of the slice: 3
The capacity of the slice: 5

Here, we are trying to slice the array to get only the first 3 words starting from the word at the first index from the original array. Then we are finding the length of the slice and the capacity of the slice. The output of the above code would be:

Original Array: [This is a Go interview question ]
Sliced Array: [is a Go]
Length of the slice: 3
The capacity of the slice: 5

13. What are Go Interfaces?

Go interfaces are those that have a defined set of method signatures. It is a custom type who can take values that has these methods implementation. The interfaces are abstract which is why we cannot create its instance. But we can create a variable of type interface and that variable can then be assigned to a concrete value that has methods required by the interface. Due to these reasons, an interface can act as two things:

Collection of method signatures.
Custom types They are created using the type keyword followed by the name needed for the interface and finally followed by the keyword interface. The syntax goes as follows:

type name_of_interface interface {
	// Method Signatures
}

Consider an example of creating an interface of the name “golangInterfaceDemo” having two methods demo_func1() and demo_func2(). The interface will be defined as:

// Create an interface
type golangInterfaceDemo interface{
    // Methods
    demo_func1() int
    demo_func2() float64
}

Interface also promotes abstraction. In Golang, we can use interfaces for creating common abstractions which can be used by multiple types by defining method declarations that are compatible with the interface. Conside the following example:

package main
 
import "fmt"
 
// "Triangle" data type
type Triangle struct {
	base, height float32
}
 
// "Square" data type
type Square struct {
	length float32
}
 
// "Rectangle" data type
type Rectangle struct {
	length, breadth float32
}
 
// To calculate area of triangle
func (triangle Triangle) Area() float32 {
	return 0.5 * triangle.base * triangle.height
}
 
// To calculate area of square
func (square Square) Area() float32 {
	return square.length * square.length
}
 
// To calculate area of rectangle
func (rect Rectangle) Area() float32 {
	return rect.length * rect.breadth
}
 
// Area interface for achieving abstraction
type Area interface {
	Area() float32
}
 
func main() {
	// Declare and assign values to varaibles
	triangleObject := Triangle{base: 20, height: 10}
	squareobject := Square{length: 25}
	rectObject := Rectangle{length: 15, breadth: 20}
 
	// Define a variable of type interface
	var shapeObject Area
 
	// Assign to "Triangle" type variable to the Area interface
	shapeObject = triangleObject
	fmt.Println("Triangle Area = ", shapeObject.Area())
 
	// Assign to "Square" type variable to the Area interface
	shapeObject = squareobject
	fmt.Println("Square Area = ", shapeObject.Area())
 
	// Assign to "Rectangle" type variable to the Area interface
	shapeObject = rectObject
	fmt.Println("Rectangle Area = ", shapeObject.Area())
}

In the above example, we have created 3 types for the shapes triangle, square and rectangle. We have also defined 3 Area() functions that calculate the area of the shapes based on the input object type passed. We have also defined an interface named Area and we have defined the method signature Area() within it. In the main function, we are creating the objects, assigning each object to the interface and calculating the area by calling the method declared in the interface. Here, we need not know specifically about the function that needs to be called. The interface method will take care of this considering the object type. This is called abstraction. The output of the above code will be:

Triangle Area =  100
Square Area =  625
Rectangle Area =  300

14. Why is Golang fast compared to other languages?

Golang is faster than other programming languages because of its simple and efficient memory management and concurrency model. The compilation process to machine code is very fast and efficient. Additionally, the dependencies are linked to a single binary file thereby putting off dependencies on servers.

15. How can we check if the Go map contains a key?

A map, in general, is a collection of elements grouped in key-value pairs. One key refers to one value. Maps provide faster access in terms of O(1) complexity to the values if the key is known.

![Key to Value Mapping] (https://d3n0h9tb65y8q.cloudfront.net/public_assets/assets/000/001/748/original/How_can_we_check_if_the_Go_map_contains_a_key.png?1637335439)

Daily Blog Post 6 April 2022

2022-04-06T00:00:00-07:00

GRE Verbal:

Completed Advanced Reading Comprehension 4. Scored 14/20. Could have scored slightly better. Took a lot of time - 1hr19min which has to be reduced.
Completed Advanced Sentence Equivalence 5. Hence finishing the section of Advanced Sentence Equivalence. Scored 12/20. Not a very good score. Will have to start revising all SE Questions to revise word meanings.

GRE Quant:

Completed Advanced Sequences Practice.
Completed Basic Geometry and Triangles Advanced Practice.

Golang Practice from exercism.org

Url link: https://exercism.org/tracks/go/exercises/lasagna

About Comments

In go, comments play an important role in documenting code. They are used by the godoc command, which extracts these comments to create documentation about Go packages. A documentation comment should be a complete sentence that starts with the name of the thing being described and ends with a period.

Comments should precede packages as well as export identifiers, for example exported functions, methods, package variables, constants and structs, which you will learn more about in the next exercises. A package level variable can look like this:

var TemperatureCelsius float64

Package Comments

Package comments should be written directly before a package clause (package x) and begin with Package x … like this:

//Package Kelvin provides tools to convert
// temperatures to and from kelvin
package kelvin

Function Comments

A function comment should be written directly before the function declaration. It should be a full sentence that starts with a function name. For example, an exported comment for the function Calculate should take the form Calculate … It should also explain what arguments the function takes, what it does with them, and what its return values mean, ending in a period.

// CelsiusFreezingTemp returns an integer value equal to the temperature at which water freezes in degree celsius
func CelsiusFreezingTemp() int {
  return 0
}

Go comments exercise - Weather Forecast

Instructions:

Being hired by a big weather forecast company, your job is to maintain their codebase. Scrolling through their code, you find it hard to follow what the code is actually doing. Good thing you know just the right thing to do.

Step 1: Document Package Weather

Write a package comment for package weather that describes its contents. The package comment should introduce the package and provide information relevant to the package as a whole.

Step 2: Document the Current Condition Variable

Write a comment for the package variable CurrentCondition

This should tell any user of the package what information the variable stores, and what they can do with it.

Step 3: Document the currentLocation variable

Just like the previous step, write a comment for currentLocation.

Step 4: Document the Forecast() function

Write a function comment for Forecast(). Your comments must describe what the function does, but not how it does it.

func TestComments(t *testing.T) {
	filename := "weather_forecast.go"

	fs := token.NewFileSet()
	f, err := parser.ParseFile(fs, filename, nil, parser.ParseComments)
	if err != nil {
		t.Fatal(err)
	}

	wantedComments := 4
	got := len(f.Comments)
	if got != wantedComments {
		t.Errorf("Incorrect number of comments: got %d, want %d", got, wantedComments)
	}

	testPackageComment(t, f)

	ast.Inspect(f, func(node ast.Node) bool {
		switch n := node.(type) {
		case *ast.GenDecl:
			if n.Lparen.IsValid() {
				for _, v := range n.Specs {
					testBlockIdentifierComment(t, v.(*ast.ValueSpec))
				}
			} else {
				testIdentifierComment(t, n)
			}
		case *ast.FuncDecl:
			testFunctionComment(t, n)
		}
		return true
	})
}

Numbers in Go

About Numbers

Go contains basic numeric types that can represent sets of either integer or floating point values.

This concept will concentrate on two number types:

Daily Blog Post 5 April 2022

2022-04-05T00:00:00-07:00

Reading Comprehension - GREEdge

Finished Advanced Reading Comprehension Exercise 3. Scored 12/20. Need to perform better. Again, questions were confusing. Made one or two errors that could have been avoidable.

GRE Quant

Watch https://www.youtube.com/watch?v=K7B0ckmrviM&ab_channel=Crackverbal to gain confidence to solve Venn Diagram questions in GRE Quant.
Rule of thumb to differentiate when to use Venn Diagrams and Tables.

Golang Tutorials

About Basics Go is a statically typed, compiled programming language. Go is syntactically similar to C. The language is often referred to as Golang because of its previous domain name golang.org, but the proper name is Go. The Basics concept will introduce three major language features: packages, functions and variables. Packages: Go applications are organized in packages. A package is a collection of source files located in the same directory. All source files in a directory must share the same package name. It is conventional for the package name to be the last directory in the import path. For example the files in the “math/rand” package begin with the statement package rand. When a package is imported, only entities (functions, types, variables, and constants) whose names start with a capital letter can be used/accessed. The recommended style of naming in Go is that identifiers will be named using camelCase, except for those meant to be accessible across packages which should be PascalCase.

package lasagna

Variables: Go is statically types, which means all variables must have a defined type at compile time. Variables can be defined by explicitly specifying a type:

var explicit int

You can also use an initializer, and the compiler will assign the variable type to match the type of the initializer:

implicit := 10

Once declared variables can be assigned value using the = operator. Once declared a variable’s type can never be changed. count := 1 //Initial value count = 2 //update new value count = false //This throws a compiler error due to assigning a ‘non’ int-type

Constants: Constants hold a piece of data just like variables, but their value cannot change during the execution of the program. Constants are defined using the const keyboard and can be numbers, characters, strings or booleans: const Age = 12

Functions: Go functions accept zero or more parameters. Parameters must be explicitly typed, there is no type inference. Values are returned from the function using the return keyword. A function is invoked by specifying the function name and passing arguments for each of the function’s parameters. Note that Go supports two types of comments. Single line comments are preceded by // and multiple line comments are inserted between /* and */

package greeting
// Hello is a public function
func hello(name string) string {
  return hi(name)
}

// hi is a private function
func hi(name string) string {
  return "hi" + name;
}

Gopher’s Gorgeous Lasagna Instructions:

Define the expected oven time in minutes: Define OvenTime constant with how many minutes the Lasagna should be in the oven. According to the cooking book, the expected oven time in minutes is 40.
```
OvenTime
```
Calculate the remaining oven time in minutes: Define the RemainingOvenTime() function that takes the actual minutes the Lasagna has been in the oven as a parameter and returns how many minutes the lasagna still has to remain in the oven, based on the expected oven time in minutes from the previous task.
```
func RemainingOvenTime(actual int) int {
  //TODO
}
RemainingOvenTime(30)
```
Calculate the preparation time in minutes: Define the PreparationTime function that takes the number of layers you added to the lasagna as a parameter and returns how many minutes you spent preparing the lasagna, assuming each layer takes you 2 minutes to prepare.
```
func PreparationTime(numberOfLayers int) int {
  // TODO
}
PreparationTime(2)
```
Calculate the elapsed working time in minutes: Define the ElapsedTime function that takes two parameters: the first parameter is the number of layers you added to the Lasagna, the second parameter is the number of minutes the lasagna has been in the oven. The function should return how many minutes in total you have worked on cooking the lasagna, which is the sum of the preparation time in minutes, and the time in minutes the lasagna has spent in the oven at the moment.
```
func ElapsedTime(numberOfLayers, actualMinutesInOven int) int {
  // TODO
}
ElapsedTime(3, 20)
```

Daily Blog Post 4 April 2022

2022-04-04T00:00:00-07:00

Reading Comprehension - GREEdge

Finished Advanced Reading Comprehension Exercise 2. Scored 11/20. Need to do better. Questions were ambigious and confusing with similiar meaning options.
Revised Essential RC Practice 1.
Revised Essential RC Practice 2.

CLRS - Dynamic Programming

DP, Like Divide and Conquer solves problems by combining solutions to subproblems.
Divide and Conquer Algorithms partition the problem into disjoint subproblems, solve the subproblems recursively, and then combine their solutions to solve the original problem.
In contrast, DP applies when subproblems overlap-that is, when subproblems share subsubproblems. In this context a divide and conquer algorithm does more work than necessary, repeatedly solving the common subsubproblems.
A dynamic programming algorithm solves each subsubproblem just once and then saves its answer in a table, thereby avoiding the work of recomputing the answer each time it solves each subsubproblem.
We typically apply DP to optimization problems. Such problems can have many solutions. Each solution has a value, and we wish to find a solution with the optimal (minimum or maximum) value.
We call such a solution an optimal solution to the problem as opposed to the optimal solution to the problem.
When developing a dynamic-programming algorithm, we follow a sequence of four steps:
1. Characterize the structure of an optimal solution.
2. Recursively define the value of an optimal solution.
3. Compute the value of an optimal solution, typically in a bottom-up fashion.
4. Construct an optimal solution from computed information.
  Rod Cutting
  
  The rod cutting problem is as follows given a rod of length n and a table of prices for lengths of rods. Determine the maximum revenue obtainable by cutting up the rod and selling the pieces.

We can cut a rod of length n in 2^(n-1) ways, since we have an independent option of cutting or not cutting, at distance i inches from the left end. If an optimal solution cuts a rod into k pieces, for some 1<=k<=n, then an optimal decomposition n = i1 + i2 + i3 + i4 + … + ik of the rod into pieces of lengths i1, i2, i3, i4, i5, …, ik provides maximum corresponding revenue rn = pi1 + pi2 + pi3 + … + pik.

More generally, we can frame the values of rn from n >= 1 in terms of optimal revenues from shorter rods: rn = max(pn, r1 + rn-1, r2 + rn-2, …. , rn-1 + r1).

The first argument, pn, corresponds to making no cuts at all and selling the rod of length n as it is.
The other n-1 arguments to max correspond to the maximum revenue obtained by making an initial cut of the rod into two pieces of size i and n - i, for each i.
Since we don’t know ahead of time which value of i optimizes revenue, we have to consider all possible values of i and pick the one that maximizes revenue.
We also have the option of picking no i at all if we can obtain more revenue by selling the rod uncut.
Note that to solve the original problem of size n, we solve smaller problems of the same type, but of smaller sizes. Once we make the first cut, we may consider the two pieces as independent instances of the rod-cutting problem. The overall optimal solution incorporates optimal solutions to the two related subproblems, maximizing revenue from each of those two pieces.
We say that the rod cutting problem exhibits optimal substructure: optimal solutions to a problem incorporate optimal solutions to related subproblems, which we may solve independently.

GeeksForGeeks Practice - Arrays and Dynamic Programming

Solved about 8-10 problems.

Abhinav P Y / Personal Website

Future Blog Post

Daily Blog Post 29th June 2022

Knowledge Transfer of Digital AI product (Highest Priority) (4 hours)

Finish the Introductory Numerify PDF (1 Hour)

Spring MVC (Finish a project from the Udemy Course) (2 hours)

LeetCode - Solve 10 Problems (2 hours)

Finish one sheet of vocab for GRE (High Priority) (1 hour)

Learn Web Design (Finish HTML and/or CSS Section 1)

Daily Blog Post 2 May 2022

Chapter 2 - William Stallings COA

Chapter 2 - DDIA

Day 2 of 100DaysOfCode for JavaScript and NodeJS - JWT Implementation in JavaScript

ReactJS - Day 2 of 100DaysOfCode

Daily Blog Post 1 May 2022

ReactJS - Started Day 1 of 100DaysOfCode of ReactJS

CSS - 100DaysOfCode Day - 1

OAuth 2.0

API Kong

Computer Organization and Architecture

Dynamic Programming - 100DaysOfCode - Day 1

RESTful API Golang 18 April 2022

Twitter API Golang.

Using the Twitter API to get tweets

Prerequisites

Creating a Twitter API key

Go….code!

Authenticating with Twitter

Search tweets

Improving our search function

TLDR

Golang Prep April 8th 2022

Golang Interview Questions

1. What is Golang?

2. Why should one learn Golang? What are the advantages of Golang over other languages?

3. What are Golang Packages?

4. Is Golang case sensitive or insensitive?

5. What are Golang pointers?

6. What do you understand by Golang string literals?

7. What is the syntax used for the loop in Golang? Explain.

8. What do you understand by the scope of the variables in Go?

9. What do you understand by Go routines in Golang?

10. Is it possible to return multiple values from a function in Go?

11. Is it possible to declare variables of different types in a single line of code in Golang?

12. What is “slice” in Go?

13. What are Go Interfaces?

14. Why is Golang fast compared to other languages?

15. How can we check if the Go map contains a key?

Daily Blog Post 6 April 2022

GRE Verbal:

GRE Quant:

Golang Practice from exercism.org

About Comments

Package Comments

Function Comments

Go comments exercise - Weather Forecast

Numbers in Go

Daily Blog Post 5 April 2022

Reading Comprehension - GREEdge

GRE Quant

Golang Tutorials

Daily Blog Post 4 April 2022

Reading Comprehension - GREEdge

CLRS - Dynamic Programming

Rod Cutting

GeeksForGeeks Practice - Arrays and Dynamic Programming

Quant - GREedge