Golang Interview question

 Rest Api

You can think of an API as a mediator between the users or clients and the resources or web services they want to get. It’s also a way for an organization to share resources and information while maintaining security, control, and authentication—determining who gets access to what. 

What are microservices?

Microservices - also known as the microservice architecture - is an architectural style that structures an application as a collection of services that are

• Highly maintainable and testable

• Loosely coupled

• Independently deployable

• Organized around business capabilities

• Owned by a small team

Http vs Grpc

HTTP API requests are sent as text and can be read and created by humans.

gRPC messages are encoded with Protobuf by default. While Protobuf is efficient to send and receive, its binary format isn't human readable. Protobuf requires the message's interface description specified in the .proto file to properly deserialize. Additional tooling is required to analyze Protobuf payloads on the wire and to compose requests by hand.

gRPC

gRPC can use protocol buffer for data serialization. This makes payloads faster, smaller and simpler.

Just like REST, gRPC can be used cross-language which means that if you have written a web service in Golang, a Java written application can still use that web service, which makes gRPC web services very scalable.

Data serialization is the process of converting data objects present in complex data structures into a byte stream for storage, transfer and distribution purposes on physical devices. ... XML, JSON , BSON, YAML , MessagePack, and protobuf are some commonly used data serialization formats.

Module

A module is a collection of Go packages stored in a file tree with a go.mod file at its root

Package

A package is nothing but a directory with some code files, which exposes different variables (features) from a single point of reference. Let me explain, what that means.

Imagine you have more than a thousand functions that you need constantly while working on any project. Some of these functions have common behavior. For example, toUpperCase and toLowerCase function transforms case of a string, so you write them in a single file (probably case.go). There are other functions which do some other operations on string data type, so you write them in a separate file.

Since you have many files which do something with string data type, so you created a directory named string and put all string related files into it. Finally, you put all of these directories in one parent directory which will be your package. The whole package structure looks like below.

 

Goroutine

Goroutines are functions or methods that run concurrently with other functions or methods. Goroutines can be thought of as light weight threads. The cost of creating a Goroutine is tiny when compared to a thread. 

Channel

In Go language, a channel is a medium through which a goroutine communicates with another goroutine and this communication is lock-free. Or in other words, a channel is a technique which allows to let one goroutine to send data to another goroutine. By default channel is bidirectional, means the goroutines can send or receive data through the same channel as shown in the below image:

logical streaming replication, new in 9.4, sends changes at a higher level, and much more selectively.

It replicates only one database at a time. It sends only row changes and only for committed transactions, and it doesn't have to send vacuum data, index changes, etc. It can selectively send data only for some tables within a database. This makes logical replication much more bandwidth-efficient.

Operating at a higher level also means that you can do transactions on the replica databases. You can create temporary and unlogged tables. Even normal tables, if you want. You can use foreign data wrappers, views, create functions, whatever you like. There's no need to cancel queries if they run too long either.

 physical streaming replication changes are sent at nearly disk block level, like "at offset 14 of disk page 18 of relation 12311, wrote tuple with hex value 0x2342beef1222....".

Physical replication sends everything: the contents of every database in the PostgreSQL install, all tables in every database. It sends index entries, it sends the whole new table data when you VACUUM FULL, it sends data for transactions that rolled back, etc. So it generates a lot of "noise" and sends a lot of excess data. It also requires the replica to be completely identical, so you cannot do anything that'd require a transaction, like creating temp or unlogged tables. Querying the replica delays replication, so long queries on the replica need to be cancelled.

Kafka

 Kafka is a distributed streaming platform that is used publish and subscribe to streams of records.

Apache Kafka is a community distributed event streaming platform capable of handling trillions of events a day.

Rpc vs TCP

Remote procedure calls can run over TCP/IP and UDP/IP services.

Rest Vs Rpc

REST will use HTTP methods such as GET , POST , PUT , DELETE , OPTIONS and, hopefully. RPC, however, would not do that. Most use only GET and POST , with GET being used to fetch information and POST being used for everything else.

Docker

Docker enables us to create, deploy, and manage lightweight, stand-alone packages that contain everything that is needed to run an application. To be specific, it contains code, libraries, runtime, system settings, and dependencies. Each such packages are called containers. Each container is deployed with its own CPU, network resources, memory, and everything without having to depend upon any individual external kernel and operating system.

Benefits of using Docker

• Enables consistent environment
• Easy to use and maintain
• Efficient use of the system resources
• Increase in the rate of software delivery
• Increases operational efficiency
• Increases developer productivity
• Docker Architecture

 

 Interface

the interface is a custom type that is used to specify a set of one or more method signatures and the interface is abstract, so you are not allowed to create an instance of the interface. But you are allowed to create a variable of an interface type and this variable can be assigned with a concrete type value that has the methods the interface requires. Or in other words, the interface is a collection of methods as well as it is a custom type.

JWT

// JWTs, or  JSON Web Tokens allow you to transmit 

information from a client to the server in a stateless,

 but secure way.

//The JWT standard uses either a secret, using the HMAC

 algorithm, or a public/private key pair using RSA or 

ECDSA.

//These are heavily used within Single-Page Applications 

(SPAs) as a means of secure communications as they allow

 us to do two key things

//[1] Authentication - The most commonly used practice

. Once a user logs in to your application, or authenticates

 in some manner,

//every request that is then sent from the client on behalf

 of the user will contain the JWT.

//[2] Information Exchange - The second use for JWTs is to

 securely transmit information between different systems.

These JWTs

//can be signed using public/private key pairs so you can

 verify each system in this transaction in a secure manner 

and JWTs

//contain an anti-tamper mechanism as they are signed based

 off the header and the payload.

//we can use a JWT that has been signed with a secure key 

that both our client and server will have knowledge off.

//When our client goes to hit our server API, it will 

include this JWT as part of the request.

// CREATING SIMPLE REST API

//DOES NOT STORE PASSWORD IN JWT BECAUSE IT IS SHOWING 

PUBLICLY