Ideally, technical documentation should explain everything about your software product, ranging from internal documentation for the team to external documentation for end-users or other teams. It should contain all the details relating to software products like product designs and requirements, engineering designs, decision records, API contracts, etc.

WHY create and manage tech docs 💡

More effective team collaboration 👏

The team can collaborate better if there is a written note of everything that is currently being worked on. It could even be something that is not yet picked up for work but is finalized for development, like API Contracts, multiple feature tasks, etc. This becomes much more important in a remote job setup.

Improves tech on-call support effectiveness

Tech documentation including the playbooks for commonly faced production issues and support can improve the on-call support effectiveness. This ensures that the team knows and follows the documented SOPs for a certain set of production use cases.

Future references and decision making 👀 🧠

Consider you are working on a service, where you are expected to design and develop the service completely from scratch. There are a lot of important decisions you need to take at this point, like language choice, system architecture, end-to-end user flow, database, cache, messaging queues choices, schema design, etc.

You might have explored a lot of choices before finalizing each of these. It becomes extremely important to document these decision records with all the minute details so that they can be referred to in future if there are similar use cases. This could also be useful for any new joiner who wants to understand the system better and know why we built the system the way we built it.

This also holds true for any modifications in the existing service as well, so that the new devs can understand the trailing changes and the evolution of the service since inception instead of going through the git history, chats and emails.

How to create a tech doc 📑

To start with a team / tech documentation, you can use any preferred choice of documentation platform. I personally like using Confluence docs, but you can choose any other platform as well like git books, or even Google Docs.

You can follow the below template. Note that each point in itself is a separate doc. and the main root doc <Team Name> can have links for each of the child docs

<Team Name>

• Members

  This doc should contain information on each team member, like name, email, designation, etc.

• Onboarding Steps

  This doc should highlight all the things that are required for onboarding a new member to the team. This could include listing all the tools, and software needed to set up the codebase locally and also include access-related queries. This doc should also mention in short what the team does and what services (which will be listed below) it handles.

• Product Plans and Logs

  This doc should have links to all the PRDs created and shared by the Product from time to time.

• Service#1: <Service Name>

  • Developer Docs

    • Architecture and components

      This doc should include the HLD(high-level architecture diagrams) of the service and also list all the components used by this service, along with a short explanation, like it's DB, messaging queues, external services, etc.

    • API docs

      This doc should contain the link to Swagger/API documentation created by the developers of this service.

    • Integration

      This doc should mention all the steps that need to be followed to integrate the service into any environment. This could even include steps to request credentials like client-id/secret, etc. to get access to APIs or include additional information on the best practices to follow while integration.

  • Operational Docs

    • Deployment steps and details

      This doc should include detailed steps on how features should be deployed into production and also include pre-deployment(like re-running the previous package build to make sure we have the previous revert version) as well post-deployment steps(like monitoring and revert strategies in case of any incident).

    • Production support playbook

      This doc should mention all the steps and answers to common queries which arise on production support. This could range from customer complaints related to data sync issues or include strategies for resolving system-related issues like the most commonly occurring burst throughput latency spikes, etc.

  • Architecture Decision Records(ADRs)

    This should include links to all the ADRs documented till now. Each file inside this section should be an individual ADR in the below format.

    • ADR0001 - <ADR Title>

    • ADR0002 - <ADR Title>

  • RFCs

    This should include links to all the RFCs documented till now. Each file inside this section should be an individual RFC in the below format.

    • RFC0001 - <RFC Title>

    • RFC0002 - <RFC Title>

(Ideally, each individual ADRs / RFCs should also follow a predefined format which can be decided by your team. The idea behind this is to make the docs informative, crisp, consistent so that it is easier to review and maintain.)

Apart from the documents and sections mentioned above, you may add any other section as well based on your use case. For example: if you want to have a log of your previous tasks and the estimations, or even Action items you can add a section like Internal docs within which you can mention the details as per your requirement.

Once you create such tech documentation, it is extremely important to keep it updated as and when any change occur. If not daily, then atleast this should be updated once a week whenever change is required so that the documentation is fresh and always updated.

I hope you find this article helpful. If so, please like, comment and share this article 😃.

Let's connect 💫

• Twitter

• LinkedIn

• GitHub

You can also subscribe to my newsletter below to get an email notification on my latest posts. 💻

A little background about myself 🙋‍♂️

After graduating a couple of years back, I started working as a Software Engineer at a leading healthcare startup in India. Being passionate about startups, I always wanted to work at one of those, as I had heard many great things about work culture and the quality of work exposure that people get.

In my college days, I was mostly involved in full-stack web development and had mostly worked on PHP and MEAN(MongoDB, ExpressJs, Angular and NodeJs) stack.

The startup journey 🌟

I started my full-time job as a Software Engineer. I was working as a backend engineer in one of the most critical and core teams of the startup which dealt with the catalogue of products and their various properties.

The project that I was part of 💻

My team was responsible for all things about the product not only the static information that gets shown on the website but also its dynamic properties like its stock availability, price, discounts, etc which are calculated at each city level throughout India in real-time.

Apart from this, our project also had various algorithms and logic which dealt with showing substitutes / similar products in case the requested product was not available in a particular city in real-time.

It was a monolith project back then and was developed using Ruby on Rails, Redis and MySQL.

The first couple of months were pretty intense for me with lots of learning and understanding of the product, system and this new tech stack.

After the first six months, I was pretty comfortable working on medium-sized features and a few large-sized features with some guidance from my team members.

Coping up with the scale 🏹

Then COVID hit India by late 2019. During this time, our startup being in the healthcare e-commerce domain got unimaginable 3x boosts in growth. With this, even the product, audiences and features grew in numbers and size and existing systems started becoming overhead in terms of maintenance and scale.

We started doing optimisations in the existing code and infrastructure, like upscaling the application and database servers, optimising the code, optimising database and cache queries, etc. All these helped us to a certain extent but were still not much performant. At the same time, we also saw a few changes in the business models which could mean major changes in our services. So we had to think of a long-term solution to cope with this scale and extensibility, keeping in mind that the tech for these new business changes should be scalable and maintainable.

So we decided to split this single monolith into multiple small independent services so that they can be scaled and maintained independently. The new tech stack chosen was Java(Springboot Webflux), Redis, Kafka and MongoDB to keep in line with the newer requirements and the increasing scale.

The journey from here 💫

Being in the core and critical team of the company, I got a chance to directly work towards these things. The next six months were crazy in terms of learnings in the new tech stack again, managing multiple services and trying to cope with the rapid growth. But as difficult as it seems, it was immensely wonderful in knowing and being part of this journey.

It was during this period that I got a whole new set of experiences which I could have never got otherwise, to work from scratch on building the micro-services end to end and migrate the live traffic from monolith service to these micro-services without any business interruption.

At this point, I not only learned about product development but also about how the systems are built at scale and what it means to build a distributed system. Our team as well grew in size and I was also mentoring new joiners. I also started making proper documentation so that it's easier for the new joiners to refer to it. All this happened in a matter of just 1 year!

So by the end of 2 years into this startup where I joined as a fresher, I had worked on a monolith system, later transformed the system into microservices, migrated the live traffic to these new services, guided new joiners and also made significant tech documentation for our team.

My observations 🕵🏻‍♂️

There were a couple of things that I loved about this experience.

There was a lot of flexibility for trying out things. It does not matter if you are a fresher or a senior; if you prove that you are capable of doing what is required, then you can get great opportunities and chances to work on some amazing projects with some amazing teams.

In startups, there are fewer processes in place which enable teams to work more on the features that matter the most and deliver them in less time, which might not be possible in some big tech companies.

People are also extremely friendly and transparent in most startups, be it a fresher or most senior technical architect/lead, the people are almost always willing to help.

The pace of a startup is much faster compared to a bigger organisation. This also means you get to contribute a lot to the startup growth journey. So just after a year or two, if you had built great products, or worked with an amazing team on good projects, the work experience and work ethic you gain and exhibit helps you become a great software engineer ahead.

My learnings 💡

Apart from the experiences that I have shared above, I am also sharing a few learnings below that I got while working, which helped me grow personally and professionally.

• Initially, after spending some time on the tech stack, you get used to it and coding in itself becomes easy. As a next step, try to understand the complete product/project you are working on.

  • Try to get overall high-level knowledge of your system. Read through the Architecture docs, RFCs, and decision records designed for your system.

  • Read the product documents(PRDs, research docs, etc) to know the historical metrics of previous versions of your product and how it has evolved.

  • Be proactive in resolving queries raised by customers/other teams. This will help you to know your system better

  • Spend time understanding your service metrics, like the API latencies, throughput patterns, database latency, time-consuming database queries, etc. For this, you can start being actively involved in the service deployments/release, as the team would usually be monitoring all these metrics after any deployment.

  • Always think about optimising the system as much as you can.

• Always speak up, no one else might speak for you. Whatever you do, make sure you keep your team well-informed to avoid any confusion.

• If the potential release feature affects the team or other stakeholders, call out early to the team and the stakeholders. Never hesitate to come up with any new idea or findings, be it extremely silly or serious, it can have a huge impact sometimes. Don't wait for other folks in the team to figure it out later. Be proactive.

• There are instances where changes at one level might affect other areas too in your service, that's why unit, regression, and sanity tests are most important to do even if you are a developer. Always think about the modularization of the project/feature that you are developing. Avoid code smells! Do a thorough dev testing of your changes before raising a merge request with the team.

• If other teams are integrated with your service or actively using your services, then it is your responsibility to support and help them regarding any of the queries or problems they are facing while using your service APIs, events, etc.

• Always try to be present and actively support your team. This also helps to build credibility and trust in your team.

• Show extreme ownership in the features you are working on. Be proactive in understanding the feature, asking doubts, reaching out to stakeholders for the changes, etc. This will help you grow further as a Software Engineer and also build trust within the team.

• Take breaks! Only working all day and doing nothing else will eventually lead to burnout after some time. Make sure you take breaks in between. Play sports, go travel, trek or do something different that you like apart from work. This will help you in being more productive at work as well and also maintains your mental and physical health.

That's it from my end. Please like or comment below if you like this or if you want to share your startup experiences as well. 😃

Let's connect 💫

• Twitter

• LinkedIn

• GitHub

I am planning to write frequently on various Software Engineering topics, you can subscribe to my newsletter below so that you get an email notification on my latest post. 💻

Similar to other databases, Redis also supports transactions via which we can run multiple Redis operations in a single atomic step. By ensuring atomicity and isolation, Redis ensures that the request sent by another client will never be served in the middle of the execution of a Redis transaction.

Redis also supports an Optimistic locking mechanism via which we can guarantee that the variables used inside the transactions are not updated by any other thread or another execution context.

Redis supports these capabilities using the MULTI, EXEC , DISCARD and WATCH commands.

In the below section, we will use these commands and operate them over a few Redis key string data.

By the way, if you don't know much about Redis data structures and how we set/get the values from Redis, I would recommend checking out this article before proceeding.

Transactions

Let's consider the below example where we set two Redis keys foo and bar with values 1 and 2 respectively via our local redis-cli.

127.0.0.1:6379> SET foo 1
OK
127.0.0.1:6379> SET bar 2
OK

Now let's increment the values of both these variables by 1, but instead of executing in 2 steps, do it as a single atomic transaction.

To start a transaction, we use MULTI following the set of commands we want to run, and then finally we use EXEC if we want to execute the transaction.

127.0.0.1:6379> MULTI
OK
127.0.0.1:6379(TX)> INCR foo
QUEUED
127.0.0.1:6379(TX)> INCR bar
QUEUED
127.0.0.1:6379(TX)> EXEC
1) (integer) 2
2) (integer) 3
127.0.0.1:6379> MGET foo bar
1) "2"
2) "3"

As you might have noticed, once we run any operations inside the MULTI EXEC block, the output is stated as QUEUED. This means that the operation is not executed but is enqueued to be executed once we run EXEC.

As we run EXEC command, the operations are executed first-in-first-out (being a queue) and the results are returned in the same order.

Similarly, instead of EXEC command to execute transactions, we can use the DISCARD command to discard the operations mentioned inside the transaction block.

Errors in transaction

There could be 2 types of errors in Redis transactions

1. Errors happening before the EXEC command

   • This could occur due to a syntax error for running the command, like a wrong command name or wrong number of arguments.

2. Errors happening after the EXEC command

   • This could happen in cases where we operate against a key with the wrong value(for example: calling INCR against a key which holds a string value).

For errors happening after the EXEC command, Redis does not support the rollback of operations in case one of them fails. Even if one of the executions of the operation fails, all the other commands in the queue are still processed and are not rolled back.

Optimistic Locking on transaction attributes

Let's consider a scenario where there are 2 redis clients which are trying to increment the value foo at the same time. We can simulate this on the local system by running the redis-cli on 2 CLIs / terminal tabs.

Currently, we have the value of foo as "2" based on the commands executed in the previous sections.

In the first cli tab, run the below command

127.0.0.1:6379> MULTI
OK
127.0.0.1:6379(TX)> INCR foo
QUEUED

Now in the second cli tab, simply increment the foo value without any transaction like below

127.0.0.1:6379> INCR foo
(integer) 3

Now, if we run EXEC command on the first cli tab, it will increment the value of foo again.

127.0.0.1:6379(TX)> EXEC
1) (integer) 4
127.0.0.1:6379> GET foo
"4"

As you can see, it updates the value to 4, since the second tab already incremented it once from 2 to 3. This is known as a race condition, where multiple clients can race to update the value of the same attribute.

Redis supports optimistic locking via WATCH command. Using this command, we can ensure that the transaction is not executed if the attributes inside it have been updated by some other client.

Run the below commands in the first tab

127.0.0.1:6379> WATCH foo
OK
127.0.0.1:6379> MULTI 
OK
127.0.0.1:6379(TX)> INCR foo
QUEUED
127.0.0.1:6379(TX)> INCR bar
QUEUED

Now, again increment the value of foo from the second tab

127.0.0.1:6379> INCR foo
(integer) 5

Now, back from the first tab, try to run EXEC command. It will return the value as (nil)

127.0.0.1:6379(TX)> EXEC
(nil)

This means that none of the operations inside the transaction was executed(or we can say that the transaction was aborted) because the value of foo(which was being "watched" by the transaction) was updated by some other client.

This WATCH command can be called multiple times. Also, we can pass multiple keys to WATCH in a single command, like WATCH foo bar. All the keys mentioned in WATCH command are watched for modifications up to the moment EXEC is called.

Once EXEC is called, all keys are UNWATCHed, regardless of whether the transaction was aborted or not. Similarly, when a client connection is closed, everything gets UNWATCHed.

Since this is an Optimistic locking mechanism, the client has to retry the transactions if it fails, until there is no race condition with other clients.

I hope you find this article helpful. If so, please like, comment and share this article 😃.

Let's connect 💫

• Twitter

• LinkedIn

• GitHub

You can also subscribe to my newsletter below to get an email notification on my latest posts. 💻

Then we will see how to use terraform to create and manage the resources by taking an example of a basic local file resource.

Problem

Long back in the pre-cloud era, the total turnaround time of provisioning the infrastructure resources would range from a few days to months. Scaling the infrastructure on demand was also not quick. The things were not automated which would also lead to human errors as well.

With the advent of cloud platforms, the time to spin up infra and time to market applications significantly reduced, making it much more efficient than the traditional IT processes.

With cloud platforms, we do not have to manage actual hardware assets like the traditional IT model. The data centre and hardware assets are managed by cloud providers. These cloud providers have a management console - a nice UI via which you can provision resources. But still, there were a few problems here.

Once provisioned, systems still go through different teams and a lot of process overhead, which could again take time and also lead to human error, hence again this approach was not feasible in large organizations.

Solution 💡

The cloud providers also exposed a set of APIs via which we could automate infrastructure provisioning. This opened up a whole new world of automation.

Initially, every company was solving the same problem of writing some scripts trying to automate infra provisioning, installing required software on infra, configuration, and deploying faster and consistently by leveraging the APIs of these cloud providers. These tools eventually paved the way for IAC(Infrastructure as Code). Several IAC tools were developed later which solved the problems that everyone was facing.

Infrastructure as Code, as the name implies means writing and executing code to create, update or destroy infrastructure components. With IACs, we can manage any infrastructure components like compute instances, databases, network components, etc. by writing it in a simple human-readable high-level language.

There are various types of IACs currently present like Terraform, Ansible, AWS Cloudformation, etc.

Types of IAC tools: 🛠

Configuration management tools - These tools are commonly used to install and manage software on existing infrastructure like servers, networking devices, etc. The most commonly used tools in this category are Ansible, Chef, puppet, etc.

Sever templating tools - These tools are used to create a custom image of a VM or a container. These images already contain all the required software and dependencies on them, hence eliminating the need to install software or additional dependencies once they are deployed, hence making them immutable. This includes tools like Docker, Packer or Vagrant.

Provisioning tools - These tools allow the provisioning of infrastructure components ranging from compute resources, VMs, VPC, or even database and network components. Terraform is the most common and widely used IaC tool in this category.

Terraform 🏗

Terraform is an IAC tool which allows us to manage and destroy infrastructure.

There are other resource provisioning IAC tools like AWS Cloudformation but they allow creating resources only on AWS.

One of the best parts about terraform is that it is vendor-agnostic. We can use Terraform to provision and manage infrastructure on any major cloud provider. Terraform has provider plugins which we can use for all major cloud providers.

Another best thing about terraform is its ability to deploy infrastructure across multiple platforms including private or public cloud, on-premises or various cloud providers.

How does terraform manage infrastructure on so many different platforms?

It is achieved through the Provider!

Providers are a logical abstraction of an upstream platform API. These providers enable terraform to manage a wide range of infrastructure components on third-party platforms like AWS, GCP, Azure, etc through their APIs.

These infrastructure components could be-

• Compute instances like VMs, etc.

• Network infrastructure like DNS, etc.

• Monitoring tools like Grafana, Datadog, etc.

• Database instances like MySQL, Postgresql, MongoDB, etc.

• Version control systems like Github, bitbucket or GitLab.

There are tons of Terraform providers which are publicly available for use. It can be found at terraform registry - https://registry.terraform.io/search/providers

We will use one of the terraform providers available in this registry for creating a file on the local system. To use terraform, we need to use its language called HCL(Hashicorp configuration language)

• It is a simple declarative language by which we can define infra to be provisioned, as blocks of code.
  By declarative, it means that the code is defined in a way which declares the state we want the infra to be in(i.e. the desired state)

• All infra resources can be defined in the configuration file with the .tf extension. The syntax is quite easy and beginner friendly.

Let's create a terraform file in the local system with .tf extension. We will be using the local provider to create a local file for demonstration purposes.

Create a new project directory by name tf-local with the below content -

provider "local" {
  // attributes 
}

resource "local_file" "country" {
    filename="./country.txt"
    content="My favourite country is India"
}

This is how a resource to be created is declared in terraform. Let's dissect the above file -

• local_file is one of the resources for local provider.

  • Every object that terraforms manages is called a resource. Resources can be the compute instances, DB instances, or even on-premise or a file on local system as above.

• country is the resource name, which is a logical name given to a resource

• filename and content are the arguments of the local_file resource.

Each provider has its own set of resources and each resource has its own set of arguments. These details about the provider can be found in terraform registry itself.

For the local provider used above, you can refer -https://registry.terraform.io/providers/hashicorp/local/latest/docs

The above terraform file implies that once it is executed, it should create a file country.txt in the local system with content as My favourite country is India

In any infrastructure, there are 2 states -

1. Current state - which is the current environment state.

2. Desired state/target state - which is the environment in which we want our infrastructure to be.

The state is the blueprint of the infrastructure deployed by Terraform. Terraform can read attributes of existing infra components by configuring the source. This can be used to later configure other resources within terraform.

Terraform workflow

Terraform takes care of what is required to go from the current state to the desired state. To do this, it works in 3 phases -

1. init - In this phase, terraform initializes the project and identifies and downloads providers to be used for the target/desired environment.

2. plan - In this phase, terraform drafts the plan to get to the target state. It tells what will be the consequence of executing the changes(for example- one file will be created).

3. apply - In this phase, it makes the necessary changes required in the environment to bring it to the desired/target state.

Create resource

Let's run the terraform commands for the above phases. Go to the tf-local the directory that we created and run the below commands one by one

terraform init
terraform plan
terraform apply

Lets understand the output of each of these commands

The output of terraform init command -

It will install the latest version of local provider from the terraform registry.

You can also specify the version specifically if you want to install older ones using the below steps -

The output of terraform plan command -

As you can see, it drafts the whole plan of what it will do once you apply changes, i.e. a file country.txt will be created with the content as specified in tf file, and with default permission of 0777 .

The output of terraform apply command -

The above command creates the resource country.txt with the specified content. You can verify this by running cat country.txt from the command line.

Update and destroy resources

Let's update the file permission to 0700 of the above country.txt file using terraform code changes.

Append the file_permission attribute like shown below in the same local_file country resource in the terraform file.

resource "local_file" "country" {
        filename="./country.txt"
        content="My favourite country is India"
        file_permission="0700" # ADDED 
}

Now, let's see the change in terraform state by running the terraform plan command

As you can see it says the file_permission will be replaced from default being 0777 to the new value 0700

Let's run the terraform apply command

In the above screenshot, after running the terraform apply, we can also check the file permission for country.txt by running the command stat country.txt. It rightly signifies the permission(-rwx------) that we wanted it to be in.

In case you don't have an idea what 0700 or -rwx------ signifies, these are the notations which specify the permissions of a file. To know more about them, I would suggest you go through this (symbolic and numeric notation)

Create multiple resources

Terraform allows the creation of multiple resources within the same file by just writing a new block for each resource.

We will add one more resource random_shuffle to the existing terraform file. This resource belongs to random provider (documentation for reference)

provider "random" {
  # Configuration options
}

resource "random_shuffle" "country_shuffle" {
  input        = ["India", "Germany", "USA", "London"]
  result_count = 1
}

Now, since we are also adding a new provider, we will need to run through all the lifecycle stages, i.e. init, plan and apply

Run the below commands one by one

terraform init
terraform plan
terraform apply

terraform init - installs the newly added random provider by downloading it from registry

terraform plan - signifies that the country_shuffle will be created, and the result will be known once we run the apply command

terraform apply - applies the required changes

Once this runs, we can check the result of country_shuffle in the terraform.tfstate file created in our directory.

The tfstate file contains the current state of terraform and is updated whenever the state of the environment changes as we add or update any resource

As we can see, it randomly chose the USA value,

We can programmatically capture this output and even pass it to some other resource in our terraform file. This is explained in the below section.

Resource attribute reference

In the real world, it is bound to happen that multiple resources depend on each other. What if we want to use the output of one resource to be an input of other?

This can be done in terraform using resource attribute reference.

Let's consider the above example where we want to use the output of random_shuffle resource and provide it in the content of local_file country resource

resource "local_file" "country" {
    filename="./country.txt"
    content="My favourite country is ${random_shuffle.country_shuffle.result[0]}" # UPDATED
    file_permission="0700" 
}

We are updating the content of our local_file country resource with the value retrieved from random_shuffle (country_shuffle) resource output.

With the above changes, terraform automatically understands that the local_file country resource is dependent on the random_shuffle resource, so random_shuffle resource needs to be applied first before country resource.

This is called implicit dependency, as it is understood based on the given reference expression, without our need to tell to terraform explicitly.

Let's run terraform plan and apply after making the above changes.

As you can see above, the content was updated as we expected it to be.

Terraform also supports explicit dependency where we can provide depends_on attribute like below -

resource "local_file" "country" {   
     content = "London" 
     depends_on = [ random_shuffle.country_shuffle ] 
}

This is necessary only when a resource relies on some other resource indirectly and it does not make use of any reference expression.

Input variables

We have used arguments till now where the values are directly hard coded in terraform file. Instead of hardcoding values(which may limit reusability), we can also create the input variables in Terraform.

To assign variables, let's create new config files variables.tfwith the below content.

variable "filename" { 
    default = "/country.txt" 
}

Now to use it in our main file, we can rename the filename values to var.filename

resource "local_file" "country" {
    filename=var.filename # UPDATED
    content="My favourite country is ${random_shuffle.country_shuffle.result[0]}"
    file_permission="0700"
}

We can also provide the variable data type in our variable definition file. This is optional, but when used, it strictly enforces the type of the variable being used, like string, number, bool, etc.

Apart from the above, terraform also supports additional types like lists, maps, objects, etc. Let's see a couple of examples below

• List type:

    variable "list_demo" { 
        default = ["a","b","c"] 
        type = "list" 
    }
  

  We can access var.list_demo[0] in the main terraform file

  We can also enforce the type of values in the list; by specifying the type as list(string) for list values being string type.

• Map type:

    variable "map_demo" { 
        type = "map" 
        default = { 
            "foo" = "foo content"
            "bar" = "bar content" 
        } 
    }
  

  Now, we can access this in our main terraform file like var.map_demo["foo"]

• Object type:

    variable "object-demo" { 
        type = object({ 
                name = string 
                age = number
                country = list(string)
        })
  
        default = { 
            name = "foo" 
            age = 4 
            country = ["India", "USA", "London"] 
        } 
    }
  

By default, if we don't provide the default values of variables, then we will be prompted in an interactive way to provide values while we run terraform plan or terraform apply.

In our example, let's remove the default value for filename variable that we had defined.

variable "filename" { 
    # default = "./country.txt" # COMMENTED OUT
}

Now if we run terraform plan, we will be prompted for providing value in CLI like below-

However, if we don't want interactive mode, we can also make use of cmd flags like the below -

terraform plan -var "filename=./country.txt" [-var ....]

Apart from the above 2 options -

• We can also make use of env variables

    ➜ export TF_VAR_filename="test.txt" 
    ➜ terraform plan
  

  If we set this, then it becomes the default value unless we provide some value in the cmd flag.

• While dealing with lot of variables, we can also make use of variable definition files like below

  • Create a file with name variables.tfvars and with below content

      filename = "test2.txt"
    

  • Now we can provide the file name as a cmd flag - terraform plan -var-file variables.tfvars

    

Output variables

These variables can be used to store the value of an expression in terraform.

Let's take an example in our use case, we know country resource will generate some identifier(id) when we run apply command. To save this id, we can create an output block

output country_id { 
    value = local_file.country.id
    description = "File resource ID" # optional 
}

We can see this output variable once we perform terraform apply like below

Now you may think about where can we use this output variable. 🤔

We can use this when we want to display it on some UI or pipeline or if we want to provide the output as input to some other IaC tool like Ansible, etc.

terraform output - Prints all the output variables mentioned in terraform file.

Lifecycle rules

Terraform resources are immutable, which means we cannot update the resource once created.

When we make some updates in the terraform file and try to apply the changes, it deletes the existing resource and then creates a new resource with an updated config. In our case, the older local_file resource is deleted first and then a new file is created.

What if we want to create an updated version first and then delete the old ones? Or if we do not want the older resource to be deleted at all(for use cases like an EC2 instance, etc)? - We can use lifecycle rules.

Just add the lifecycle block in the existing local_file country resource block like below

resource "local_file" "country" {
    filename=var.filename
    content="My favourite country is ${random_shuffle.country_shuffle.result[0]}"
    file_permission="0700"
    # ADDED
    lifecycle { 
        create_before_destroy=true  # optional
    }
}

create_before_destroy - will create the new resource first and then destroy the older one

There are other lifecycle meta-attributes as well which are used vastly like prevent_destroy and ignore_changes

• prevent_destroy - this won't destroy the old resource while running apply command.

• ignore_changes - will ignore the changes made outside of terraform, and it won't sync those changes with the terraform state after the initial apply. This is useful in certain cases where the changes are made out of terraform control and we don't want to consider the changes in the terraform reconciliation phase, which will revert them unnecessarily.

Data sources

Terraform is only one of the tools which provide IAC. Infra can be created using other tools like Ansible or even via some ad-hoc scripts or manually created.

Let's say we manually create a new local file in the local directory food.txt without terraform knowing about it. We would like the terraform to know about this and use this file as a data source for the other terraform resources. This can be done via the data source.

Just manually create a food.txt file and add Pizza in this file content.

Now, add the below in the main terraform file-

data "local_file" "food" {
    filename = "./food.txt"
}

In the country resource, we can feed the content of this food.txt in our content of country resource file

Just update the content value of the country resource as below

content="My favourite country is ${random_shuffle.country_shuffle.result[0]}, and favourite food is ${data.local_file.food.content}"

Now, run the plan and apply command, and then check the test.txt file - the output will be as expected as shared below -

Other useful commands

• terraform validate - Checks if the terraform config is valid or not.

• terraform fmt - Scans the config files and formats the code into the canonical format to improve readability
  The above two commands can be run before terraform plan and is mostly used in the build or verification phases of the CI/CD lifecycle.

• terraform show - Displays the current state of resources including all attributes created by terraform for that resources

• terraform output - Prints all the output variables mentioned in terraform file.

• terraform refresh - Used to sync terraform with real-world infra.
  This is useful in case there are any changes made to a terraform resource outside its control(like a manual update). In such cases, terraform will pick it up and update the state file. This reconciliation will determine what action to take during the next applied command. Note that this command is automatically run when we run the plan and apply commands

• terraform destroy - Destroys the terraform resources mentioned in the terraform file.

That's it for this article.

🚀 I have also pushed the example code explained in this article to Github.

If you found this article helpful, please comment and share this article 😃.

Let's connect 💫

• Twitter

• LinkedIn

• GitHub

You can also subscribe to my newsletter below to get an email notification on my latest posts. 💻

In this article, I have explained the most commonly used data types in Redis with examples.

I would also recommend installing Redis on your local machine and following this article by actually executing the commands hands-on. Once you install Redis(instructions here), run redis-cli command from your CLI, this will open the command line interface of redis where you can run the commands which are mentioned below in this article.

Before starting with Redis data types, let's understand what are the keys in Redis

Keys

Keys are the primary way to access data in Redis. Almost all the Redis data structures and Redis commands operate using keys.

Usually, it is suggested to have a meaningful domain-specific key name, with a separator if required; for example: product:12 may be used for storing details about a product which has a primary id 12.

Keys are used in almost all data types of Redis like string, list, hashes, sets, etc.

We will now start with a String data type to also get acquainted with keys.

Strings

We will be exploring the below commands which are applied for string data type -

SET <key> <value>  
GET <key>
KEYS <regex pattern>
SCAN <cursor>
DEL <key> 
UNLINK <key>
EXISTS <key>

• SET <key> <value> - sets the value of the given key

  • You can also provide the expiry of this key using EX or EXAT argument.

  • By default, if the key is not present, it will create the key, else it will update the value of the key. If you want to SET the key only if the key does not already exist, then you can pass the NX argument.

• GET <key> - returns the value of the given key name. ex: GET product:12

• MGET <key> [<key>...] - returns the value of multiple keys passed in the argument

  Below is the demonstration in redis-cli :

    # Sets the value as product-12-value with expity of 2 mins
    127.0.0.1:6379> SET product:12 product-12-value EX 120 NX
    # OUTPUT
    OK
  
    127.0.0.1:6379> SET product:13 p13
    # OUTPUT
    OK
  
    127.0.0.1:6379> get product:12
    # OUTPUT
    "product-12-value"
  
    127.0.0.1:6379> GET product:12
    # OUTPUT
    "product-12-value"
  
    127.0.0.1:6379> MGET product:12 product:13
    # OUTPUT
    1) "product-12-value"
    2) "p13"
  

Redis also provides commands to retrieve all the keys in the database matching a regex pattern

• KEYS <regex pattern> - returns all the keys matching the specified pattern.

  • This command is not recommended in production applications since it's a blocking command, and it may cause performance issues in the case of large datasets.

      127.0.0.1:6379> KEYS product:*
      # OUTPUT
      1) "product:12"
      2) "product:13"
    

• SCAN <cursor> [MATCH pattern] [COUNT count]

  • This command also blocks the thread but it returns only a few keys at a time, along with a cursor. You need to call SCAN 0(0 is the cursor here) for the first time and then iteratively call the SCAN command with the updated cursor which was returned in the response.

  • When the server response has the cursor value as 0, it signifies no other keys left to iterate, so you can stop the iteration at this point.

  • The user can also specify an optional MATCH argument to retrieve based on a specified regex pattern, and a COUNT argument signifying what number of keys to be retrieved per SCAN, though this can block the thread longer if the COUNT value is too large.

To delete the key, Redis provides 2 commands

• DEL <key> - deletes the key in a blocking manner

• UNLINK <key> - deletes the key in a non-blocking way, where the memory associated with the key is reclaimed by an asynchronous process.

You can also check if the key exists or not using EXISTS <key> command.

Apart from keys and scan command, all other commands have a time complexity of O(1). Every scan command is O(1), but it can become O(N) for complete iteration.

Strings are fundamental data types in Redis and can be used to store numerical values, serialized JSON or anything that case which can be represented in binary. All the commands we saw above are used for strings.

🚨 Even if you run SET int-key 12, and then try to GET the value, it will return value 12 as a string.

127.0.0.1:6379> SET int-key 12
OK

127.0.0.1:6379> GET int-key
"12"

You can check the type of key using type <key> command. For the above key, it will return a string.

This is because it returns the string representation of the value. The different types that can be returned are: string, list, set, zset, hash and stream (We will look into these types below)

Internally, Redis stores the encoding of the values, and stores the knowledge whether it's a string, integer, floating number, etc. To check the kind of internal representation used to store the value, you need to use object encoding <key>. This command will return "int" as a value as shown below.

127.0.0.1:6379> TYPE int-key
string

127.0.0.1:6379> OBJECT ENCODING int-key
"int

For numeric values, we can also increment/decrement the value directly using the below Redis commands:

• INCR/DECR <key> - increments/decrements the key value by 1

• INCRBY/DECRBY <key> <increment value> - increments/decrements by the specified increment value

    127.0.0.1:6379> INCR int-key
    (integer) 13
  
    127.0.0.1:6379> INCR int-key
    (integer) 14
  
    127.0.0.1:6379> GET int-key
    "14"
  

Use cases of Strings:

• Caching the API response in JSON string format. for example: SET product:12 "{\"name\":\"P1\",\"price\":\"121\"}"

• Storing session cache.

Hashes

Hashes are a collection of field-value pairs, similar to hashmaps or maps in other languages like Java, Go, etc. They are mutable as well, so we can update or delete the hash and even add/update the field-value pairs.

Hashes store field values as string type, which means we can store flat string and numeric values but not embedded JSON or objects.

Similar to Key and string, we have below commands used for hashes -

• HSET <key> <field> <value> [<field> <value> ...] - sets/creates or updates the hash with given field-values stored at key

  • HSET hash-example:product:12 name p1 price 22 will create the hash with key hash-example:product:12 for the first time with given fields name and price with their values p1 and 22 respectively.

  • HSET hash-example:product:12 name p12 will update the above hash's "name" field's value to p12

• HGET <key> <field> - returns provided field's value from the given hash name

  • Example: HGET hash-example:product:12 name will return p1

• HMGET <key> <field> [<field>...] - allows retrieving multiple fields values

    127.0.0.1:6379> HSET hash-example:product:12 name p1 price 22
    (integer) 0
  
    127.0.0.1:6379> HMGET hash-example:product:12 name price
    1) "p1"
    2) "22"
  
    127.0.0.1:6379> HSET hash-example:product:12 name p2
    (integer) 0
  
    127.0.0.1:6379> HMGET hash-example:product:12 name price
    1) "p2"
    2) "22"
  

• HGETALL <key> - will retrieve all the fields with their values for provided key

    127.0.0.1:6379> HGETALL hash-example:product:12
    1) "price"
    2) "22"
    3) "name"
    4) "p2"
  

• HKEYS <key> - will only return the field names for a given hash

• HLEN <key> - returns the total length(number of fields) of hash

• HDEL <key>- deletes the hash stored at the given key

• HINCRBY <key> <field> <incr-value> - will increment the value of the field by incr-value provided in the argument.

    127.0.0.1:6379> HINCRBY hash-example:product:12 price 2
    (integer) 24
  
    127.0.0.1:6379> HMGET hash-example:product:12 name price
    1) "p2"
    2) "24"
  

• HSCAN <key> <cursor> [MATCH pattern] [COUNT count] - Similar to SCAN command we saw above in the key section, but HSCAN is for scanning hashes.

    127.0.0.1:6379> hscan hash-example:product:12 0
    1) "0"
    2) 1) "price"
       2) "24"
       3) "name"
       4) "p2"
  

Apart from HSCAN, HKEYS and HGETALL all other commands have a time complexity of O(1).

Hashes use cases:

• Caching in case the object is too large and we want to only retrieve certain fields instead of all.

• Storing User profiles, product information, etc.

List

The list is the sequence of strings, similar to Array or ArrayList in Java, Go, etc. Lists are used for storing arrays of strings, but they can also be used as a stack and queue.

Think of it as a list having a head as left(1st element)and a tail as right(last element). The beauty of this data type is that Redis provide commands to insert and remove the element from both the left and right of the list out of the box, making it ideal for stack and queue use-case implementations.

The list has below list of commands-

• LPUSH <key> <element> [<element>...] - is used to insert an element at the head of the list (left push) stored at the key. Multiple elements can also be passed.

  • LPUSH demo-list 1 2 3 will result in a list with value [3,2,1]

• LPOP <key> <count> - is used to remove the data from the head of the list (left pop). Multiple elements can also be removed at once by providing an optional count value

  • LPOP demo-list 1 will remove the 3 from the above list; updated list - [2,1]

• RPUSH <key> <element> [<element>...] - same as LPUSH, but is used to insert the element or multiple elements at the tail of the list (right push)

  • RPUSH demo-list 4 5 will add to the above list from the right; updated list - [2,1,4,5]

• RPOP <key> <count> - same as LPOP, but is used to remove the data from the tail of the list (right pop)

  • RPOP demo-list 1 will remove the 5 from the above list; updated list - [2,1,4]

• LRANGE <key> <start> <stop> - returns the elements of the list stored at the key. Start and stop are zero-based indexes, where the start 0 is the 1st element(head) and so on.

  • LRANGE demo-list 0 -1 will retrieve all elements of the list

  • LRANGE demo-list 0 -2 will retrieve all elements from the 1st element till 2nd last element of the list

127.0.0.1:6379> LPUSH demo-list 1 2 3
(integer) 3

127.0.0.1:6379> LRANGE demo-list 0 -1
1) "3"
2) "2"
3) "1"

127.0.0.1:6379> LPOP demo-list 1
1) "3"

127.0.0.1:6379> LRANGE demo-list 0 -1
1) "2"
2) "1"

127.0.0.1:6379> RPUSH demo-list 4 5
(integer) 4

127.0.0.1:6379> LRANGE demo-list 0 -1
1) "2"
2) "1"
3) "4"
4) "5"

127.0.0.1:6379> RPOP demo-list 1
1) "5"

127.0.0.1:6379> LRANGE demo-list 0 -1
1) "2"
2) "1"
3) "4"

• LLEN <key> - returns the length of the list

• LTRIM <key> <start> <stop> - trims the element and keeps only elements from the specified start index to the stop index in the list.

💫 You can use a combination of the above commands for stack and queue implementations

• For queues, use RPUSH and LPOP

• For stack, use LPUSH and LPOP

List use cases:

• Stack or queue implementations like a queue-based worker.

• Social networking sites display only the top 5 trending results, etc.

Set

Set are similar to lists, i.e. an unordered sequence of strings, but the difference is the set does not have duplicate elements, even if you try to insert the same element thousand times. Another difference is that the set does not allow insertions or deletions from the head or tail of the array, since it's not an array, it's just a set!

Redis Set also supports standard mathematical set operations like Union, Intersection and Difference 💫.

The set has below list of commands-

• SADD <key> <member> [<member>...] - Adds the member or members passed in the argument to the set stored at key

  • SADD demo-set a b - adds a and b members to the set

• SCARD <key> - returns the cardinality(total number of members) of the set. i.e. 2

• SISMEMBER <key> <member> - tells whether the given member is part of the set stored at key or not; return 0 if it is not part of the set

  • SISMEMBER demo-set bxya - returns 0 as bxya member is not present in set

• SINTER <key> [<key>...] - returns the intersection, i.e. common members between all the sets stored at the provided keys. The time complexity of this command will be O(N*M) where N is the cardinality of the smallest set and M is the total number of sets to compare with.

    127.0.0.1:6379> SADD demo-set a b
    (integer) 0
  
    127.0.0.1:6379>  SCARD demo-set
    (integer) 2
  
    127.0.0.1:6379> SISMEMBER demo-set x
    (integer) 0
  
    127.0.0.1:6379> SISMEMBER demo-set a
    (integer) 1
  
    127.0.0.1:6379> SADD demo-set1 a c d
    (integer) 0
  
    127.0.0.1:6379> SINTER demo-set demo-set1
    1) "a"
  

• SUNION <key> [<key>...] - - returns the union, i.e. all members in all the given sets stored at the provided keys

  • SUNION demo-set demo-set1 will return b, c, d, a as the output

• SDIFF <key> [<key>...] - returns the members of the set resulting from the difference between the first set and all the successive sets.

    127.0.0.1:6379> SUNION demo-set demo-set1
    1) "b"
    2) "c"
    3) "d"
    4) "a"
  
    127.0.0.1:6379> SDIFF demo-set demo-set1
    1) "b"
  

• SMEMBERS key - returns all the members of the set stored at key

    127.0.0.1:6379> SMEMBERS demo-set
    1) "b"
    2) "a"
  

• SSCAN <cursor> [MATCH pattern] [COUNT count] - Similar to SCAN and HSCAN we saw in the above sections, but SSCAN is used for scanning through sets, and is preferred over SMEMBERS for performance reasons.

• SREM <key> <member> - removes the specified member from the set

    127.0.0.1:6379> sscan demo-set 0
    1) "0"
    2) 1) "b"
       2) "a"
  
    127.0.0.1:6379> srem demo-set a
    (integer) 1
  
    127.0.0.1:6379> sscan demo-set 0
    1) "0"
    2) 1) "b"
  

Set use cases:

• Track unique website visitors based on IP, since sets have deduplication.

• The union, intersection and difference make it ideal for use cases where we want to find the commonality or combination of sets between multiple domain data which might have the same members, like for example: to find out all the customers who purchased X as well as Y book. We can have two sets purchase-order:book:X:customers and purchase-order:book:Y:customers whose values are set of customer ids, and we can simply do SINTER to find out users who bought both books.

Sorted Set

Sorted sets are similar to the sets we discussed above, with an additional property - a score is associated with each member in the set. This is a floating point number by which we can specify a sorting order of the members in a sorted set(like sort ascending by score or sort descending by score)

There can be two elements with the same score, in such cases, precedence will be given to a higher member key with a lexical value. example: a sorted set with key ab will be given higher precedence over sorted set with key name bc if both have the same score.

Sorted sets also support union and intersection commands similar to sets.

The sorted set has a similar list of commands as the set, with an additional score value.

Use case: Let's take a use case of players playing in a tennis tournament and earning some scores. We will add 4 players (player1, player2, player3 and player4) along with their total scores in the tournament

• ZADD <key> <score> <member> [<score> <member>...] - adds one more member to the sorted set along with its associated score.

    127.0.0.1:6379> zadd game:tennis NX 2 player1
    (integer) 1
  
    127.0.0.1:6379> zadd game:tennis NX 4 player2
    (integer) 1
  
    127.0.0.1:6379> zadd game:tennis NX 1 player3
    (integer) 1
  
    127.0.0.1:6379> zadd game:tennis NX 7 player4
    (integer) 1
  

• ZINCRBY <key> <increment> <member> - increments the score of the member by the values provided in the argument

    127.0.0.1:6379> zincrby game:tennis 2 player3
    "3"
  

• ZRANGE <key> <min> <max> [LIMIT offset count] [WITHSCORES]- retrieves the set members from specified min and max index. You can also pass an optional limit argument to limit the number of returned set members.
  WITHSCORES argument will also return the scores of the returned members

    127.0.0.1:6379> zrange game:tennis 0 -1 withscores
    1) "player3"
    2) "1"
    3) "player1"
    4) "2"
    5) "player2"
    6) "4"
    7) "player4"
    8) "7"
  

• ZRANGEBYSCORE <key> <min> <max> [WITHSCORES] [LIMIT offset count] - returns the members of the set in the order sorted ascending based on score. Do note here that the min and max are not zero-based indexes, instead, it starts with 1.

  • This can be used to show the leaderboards of players, for example: to show the bottom 3 players(which have the lowest score) ZRANGEBYSCORE game:tennis 1 4

      127.0.0.1:6379> ZRANGEBYSCORE game:tennis 1 4 WITHSCORES
      1) "player3"
      2) "1"
      3) "player1"
      4) "2"
      5) "player2"
      6) "4"
    

• ZSCORE <key> <member> - returns the score of the specified member

• ZREVRANGEBYSCORE <key> <min> <max> [WITHSCORES] [LIMIT offset count] - similar to ZRANGEBYSCORE mentioned above but this command will return based on descending order of the score

  • This can be used to show the tournament leaderboard, for example: to show the top 3 players(which has the highest score)

      127.0.0.1:6379> ZREVRANGEBYSCORE game:tennis +inf -inf WITHSCORES LIMIT 0 3
      1) "player4"
      2) "7"
      3) "player2"
      4) "4"
      5) "player1"
      6) "2"
    

• ZRANK <key> <member> - returns the rank of the user based on ascending order of scores. Note that rank is zero-based, which means that the member with the lowest score has rank 0.

• ZREVRANK <key> <member> - returns the rank of the user based on descending order of scores. The member with the highest score will have the lowest rank(i.e. rank 0)

  • This can be used to display the rank of individual players

• ZREMRANGEBYRANK <key> <start> <stop> - removes the members from the set with the rank range specified in the argument. For example: to retain only the top 3 players in the leaderboard and remove others, we can run -

    # Since the ZREMRANGEBYRANK will evaluate based on scores sorted in ascending order, we will want to retain only bottom 3 elements(which are actually top 3 players by rank, so we will remove from 1st element(index 0) till fourth last element(index -4), hence retaining the top 3 players)
    127.0.0.1:6379> ZREMRANGEBYRANK game:tennis 0 -4
    (integer) 1 
  
    127.0.0.1:6379> ZREVRANGEBYSCORE game:tennis +inf -inf WITHSCORES LIMIT 0 10
    1) "player4"
    2) "7"
    3) "player2"
    4) "4"
    5) "player1"
    6) "2"
  

• ZUNION <numkeys> <key> [<key>..] [AGGREGATE SUM|MIN|MAX] [WITHSCORES]

  • This performs a union on total N(numkeys) keys specified in the argument and returns the result. WITHSCORES is an optional argument by which scores will also be passed in the result.

  • Note: By default, if a key is present in two sets, the ZUNION will add the scores in both sets and return the new score. If we don't want to add up the score, we can also pass AGGREGATE function arguments like MIN or MAX

• ZINTER <numkeys> <key> [<key>..] [AGGREGATE SUM|MIN|MAX] [WITHSCORES]

• ZSCAN <cursor> [MATCH pattern] [COUNT count] - Similar to HSCAN and SSCAN mentioned above, but ZSCAN is used to scan over sorted sets.

Sorted sets use cases:

Since sorted sets have a score associated with each member and an extensive set of commands to play on this score, it makes it ideal for use cases like -

• Priority queues / task scheduling service

• Game Leaderboards

• Geo hashing

There are other Redis data structures as well like Bitmaps, Geospatial, and HyperLogLog which I will try to cover in some other article. The ones mentioned in this article are the most basic and commonly used Redis data types and data structures.

Few more facts about Redis 💡

Redis being an in-memory database leverages several efficient low-level data structures without worrying about how to persist them effectively.

Redis is single threaded hence it does not have to deal with locks and other synchronization mechanisms, making it simpler to use and think of for your system design.

Redis is known for its fast performance, although it is single-threaded. It is because Redis supports I/O multiplexing where the operating system allows a single thread to wait on multiple socket connections. Because of this, Redis still accepts a large number of requests concurrently and evaluates them one by one. This evaluation/execution phase is extremely fast because it is an in-memory data store. Applications using Redis are usually I/O heavy and I/O takes time whereas in-memory operations are extremely fast, so with I/O multiplexing, redis can support a large number of TCP connections while being extremely fast at executing the memory operations.

Redis also supports transactions and an optimistic locking mechanism. I will be making a separate article for the same. 😉

What to do after reading this article

Well, since now you know the basics of Redis data structures, you can build a small project using Java, Go, Ruby or any other language and use Redis as a data store.

Few projects ideas where you can use the above data structures -

1. Sports event

2. Product Catalog

3. Library management

Do comment down if you have more project ideas to work on.

If you found this article helpful, please comment and share this article 😃.

Let's connect 💫. You can follow me on

• Twitter

• LinkedIn

• GitHub

You can also subscribe to my newsletter below to get an email notification on my latest posts. 💻

Problem

One of the issues developers face is that the software or project they build works seamlessly on one machine but fails to work on another machine. There could be an issue with the package version mismatch used in the project or some difference in the machine architecture between two different machines. The famous dialogue "It works on my machine" comes into the picture here!

To solve this, you may think of starting a Virtual Machine locally using VirtualBox or VMWare, but the problem here is that a VM requires a new operating system on its own on top of the physical machine and requires a dedicated amount of hard disk, CPU and memory for itself. This is not much performant, as the resources would be wasted if not used by the virtual machine. 🤯

So we need something which can run on the same OS as the host machine without the overhead of installing another layer of OS or having dedicated hardware configurations.

Solution 💡

Containers solve both these problems. Instead of dividing the hardware resources for the different operating systems and VMs, containers run all the application code along with its dependencies like programming and environment runtimes in an independent environment built over the same operating system.

The container runs in isolation from its host machine, hence it can still support and have the required versions of packages for running the application seamlessly. These packages and required dependencies inside the container won't interfere with the versions of the packages or dependencies which are present in the host machine.

As a developer, we need some platform or some tool via which we can create, build and manage these containers.

This is where Docker comes into the picture🐬

Docker is one of the platforms which enables us to create, build and run the required applications inside containers.

Docker provides various constructs and commands by which we can bundle the required dependencies or packages together and run them in a container which is isolated from the host machine.

Docker has something known as images which are similar to snapshots in a VM, i.e. it contains all the instructions required to run the application inside the container.

We can run these images, which will execute those instructions inside a container. We can also say that the container is just a runtime instance of the docker image.

So in short, we need to first build these docker images and then run the images inside the container. Running the images will create the actual containers and start the application inside them as per the instructions present in the image(We will see this below with a real example).

There are a plethora of docker images which are commonly used for enterprise and personal use. Docker also maintains a registry from which we can download these images for various applications and use them. This registry is known as DockerHub.

So instead of installing some software like Redis, or Postgres on your local machine, you can simply run their images inside a container. At the same time, you can also expose and publish their ports inside the container to some port of your host machine to be able to access and use it on localhost.

You can also create your custom Docker image which could be built on top of these existing images and some additional commands as per the requirements. A Dockerfile is a document that contains all such commands a user requires to assemble an image. We will be using Dockerfile to create a custom docker image and run it in the example below.

👉 Docker images also consist of logical sub-images called "layers". Each layer stores some sub-part of the image it’s based on.

These layers are used to avoid transferring repetitive instructions which are already present and skip unnecessary build steps. For example, your image could have 5 layers, one of them being to download an "X" image from Dockerhub. Now, if you are building the same image again it should ideally not download the "X" image again from Dockerhub, instead, it will pull this existing layer itself as there is no change in that context.

Now that the basics are covered, let's learn about the commonly used docker commands with the very basic use case 🚀

Let's create a very simple Go application that prints Hello World!.

Let's build our custom docker image for this application and then start a docker container which runs that image of a simple Go application.

Create a new folder with two files- main.go and Dockerfile

// main.go
package main

import "fmt"

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

#### Dockerfile
# Download the golang 1.15 linux package from Dockerhub - https://hub.docker.com/layers/library/golang/1.15/images/sha256-eb7ebf06372b4930e0b9539b3510422c4860ec3361bb2f22b63a857990cf9efe
FROM golang:1.15

# create a build dir
RUN mkdir /build
# navigate to this build dir
WORKDIR /build

# copy the project itself
COPY . .

Now we need to create a docker image out of this Dockerfile

To do this, navigate to your projects folder from your CLI, run docker build -t main-app . command.

This command will create a docker image for your application. You can confirm whether the image is created or not by running docker images command.

Remember the image "layers" we discussed above? The image created using the above Dockerfile will have multiple layers, you can check this using docker inspect main-app command.

The docker image created has the following instructions as per the above Dockerfile

• Fetch the go1.15 package from Dockerhub

• Create a folder named build inside the container

• Navigate to this build folder inside the container

• Copy all the files from the local machine folder(which has main.go and Dockerfile) to that build folder inside the container

Now, since the image is created, we need to run this image to execute the above commands. Images can be run using docker run main-app

The above run command will create the container with the go1.15 Linux dependency and will copy the go program inside the build directory of the container.

To verify if the container is running or not, you can run docker ps -a in your CLI/terminal. This command will print container details like container id, image, status, ports, etc.

Note: You will notice that the container had initially started running but also stopped in a fraction of second. This is because all the commands provided in Dockerfile were completely executed and no process was ongoing.

So for this example, instead of simply running the container(which will exit immediately), you can start the interactive command line shell inside the container environment while running it.

To do that, run the container using docker run -it main-app /bin/bash command. This will open up an interactive bash shell inside the container. Now if you run docker ps -a in the new CLI tab, you will see the container is not stopped yet as the /bin/bash shell process is still running inside that container.

You can execute your Linux commands inside that shell just like you would do in a system with Linux/Ubuntu OS. Here you can run go run main.go command which will print Hello World! as expected. Notice that this happened inside the container you had created.

Alternatively, if you have already started the container for some other application and it's currently running, you can also run docker exec -it <container id> /bin/bash to enter into the container's CLI.

If you want to save the running container's settings and state, you can do that using docker commit command(check this for more info on this command).

You can also copy a file from the docker environment back into your local environment using docker cp <container-id>/<path to your file> <path where you want to copy locally> , for example: docker cp c7aec65deaf0:/build/main.go /Users/user1/Documents

You can stop the running container using docker stop <container-id> command.

Similarly, containers and images can be removed from your local system using

• docker rm <container-ids>

• docker rmi <image-name/>

Recap 👀

Docker commands used:

-> docker build -t main-app .
-> docker images
-> docker inspect main-app
-> docker run main-app
-> docker ps -a
-> docker run -it main-app /bin/bash
-> docker exec -it <container id> /bin/bash
-> docker commit
-> docker cp <container-id>/<file path> <local dir to store>
-> docker stop <container-id>
-> docker rm <container-ids>
-> docker rmi <image-name/>

Docker has an amazing official documentation as well ❤️

You can also check out Docker architecture at https://docs.docker.com/get-started/overview/#docker-architecture, or anything you want to know about docker at https://docs.docker.com.

If you found this article helpful, please comment and share this article 😃.

Let's connect 💫

• Twitter

• LinkedIn

• GitHub

You can also subscribe to my newsletter below to get an email notification on my latest posts. 💻

But this build command generates an executable file which is only supported for the current machine's platform and architecture on which it runs. So if you run the command from a 64-bit Mac, it will generate a macOS-based executable, which can be only run on x86_64 MacOS machines.

Let's try this out

Create a go file helloworld.go with a very basic program -

package main
import "fmt"

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

Go to the terminal and run

go build helloworld.go

This will generate the executable binary named helloworld in the same directory. To check the type of this file, run file helloworld , it will print below

➜ file helloword
helloword: Mach-O 64-bit executable x86_64

Since I build it from my Mac, it says it's a 64-bit Mac-O executable.

Where does the problem arise

We usually want to run these executables from our integration or production environments, where instances are Linux / ubuntu based, most of the time. If we have a go executable file, we don't need to have the Go installed on the system to run it, just like any executable.

If I copy this executable file from my local machine to the integration/production VMs and try to run the executable, it will throw an executable format error, as the executable file type was MacOS based but I tried to run it on Linux machines.

Solution

One approach to solve this is to copy the go program in the VM, install go and then run go build command from within that VM. But this is not usually recommended as it adds the additional overhead of installing Go and other supported packages inside the VMs whenever we spin up a new VM instance.

Another approach is to find out a way if we can build a Linux executable from our Mac itself so that we just copy that executable to our VM and run it.

Fortunately, we can. Go support cross-compilation! 🤟

Just run the below command and we have a go executable for the Linux platform

env GOOS=linux GOARCH=amd64 go build helloworld.go

• GOOS - Operating system for which we want to build this file

• GOARCH - The architecture of the OS for which we want to build this file

Once this command is succeeded, check the file type again using file command. It will show something like below

➜ file helloword
helloword: ELF 64-bit LSB executable, x86-64, version 1 (SYSV), statically linked

• ELF**(Executable and Linkable Format),** is a common standard file format for executable files.

• LSB executable stands for Linux Standard Base executable.

With this, we just built a Linux executable file from our MacOS.

We can then copy this executable to your remote VM if required using the below scp command

➜ scp helloworld <IPAdressOfYourVM>:

Now, we can just ssh into the VM and run the executable

./helloworld

Issues with packages which does not support cross-compilation

There are some packages which do not support cross-compilation, and if you are trying to build your script(which uses those packages) for a different platform, the build will fail and it will throw an error. One such package is confluent-kafka-go(still an open issue 🙈) which does not support cross-compilation.

So in such cases, we can use docker to build it inside the Linux container itself instead of cross-compiling from MacOS.

1. Create a new Dockerfile with the below content in the same directory which has the go script and go.mod file

FROM golang:1.15

# create a build dir
RUN mkdir /build
WORKDIR /build

ENV CGO_ENABLED=0

# copy module dependencies
COPY go.mod .
COPY go.sum .

# copy the project itself
COPY . .

If you also want to install some packages in this image (example: git), then add that to the above Dockerfile at line 2. Example:

FROM golang:1.15

# Install git...
RUN apt-get install git

# create a build dir
RUN mkdir /build
..
..
..

1. Generate a docker image from the above Dockerfile using the below command

docker build -t go-cli-script .

1. Run the above-created image inside a container and open a bash shell in this container with which we can interact, using the below command

docker run -it go-cli-script /bin/bash

This command will open up the bash CLI from within the Linux container. Execute the below command in this CLI to generate the Linux executable.

go build helloworld.go

After performing the above step, a new linux executable would be added in the same directory inside the container.

Now, we want to copy this executable file from the container to the host machine,

To do this, run the below docker command in your local machine terminal-

docker cp <container id>:/build/helloworld <local machine directory where you want to copy>

The container id in the above command should be of the container we created using docker run command above. You can also get the container id by running docker ps -a command.

Check the copied file’s type in the local machine using file helloworld command, it will show LSB(Linux Standard Base) executable as expected.

If you found this article helpful, please comment and share this article so that it reaches others. 😃 You can subscribe to my newsletter to get an email notification on my latest posts. 💻

Let's connect 💫. You can follow me on

• Twitter

• LinkedIn

• GitHub

I will be answering a very basic question -

If you open your browser and go to www.google.com or any other website, what happens in the background?

In a very basic sense

1. Browser (client) sends a request for this website over the internet.

2. The server (the service or machine which hosts this website) over the internet responds with the data.

This is called the request-response paradigm and this is how computers communicate with each other over a network. The above communication follows the client-server model where the browser (client) requests some resources and the server responds. The communication happens in form of chunks of data, also known as data packets (more on this below).

This data is transferred between the client and server using a series of steps and methods which follow certain protocols (rules).

Let’s go down one level deeper and try to understand the core concepts and technologies involved here.

👉 IP Address

The Internet is made up of billions of computers interconnected to each other via some network. Every resource has some identifier by which it can be uniquely identified over the internet. By resource, we mean anything which can be accessed over the internet, like websites, web applications, etc. This unique identifier is called an IP Address. IP addresses are numeric addresses in xx.xx.xx.xx format, for example, 127.0.0.1.

👉 DNS

In simple terms, DNS (Domain Name System) is the system of assigning some human-readable names to the not-so-human-readable IP addresses of the resources to access these resources(websites, etc) over the internet.

Since all internet resources are uniquely identified by IP Address, it is very difficult for a human to remember such IP addresses for the things they need. For example:

• google.com IP Address: 142.250.199.174

• facebook.com IP Address: 31.13.79.35

Too many numbers to remember!!!

That’s why we assign domain names to our web services and the DNS takes care of mapping it to the actual IP address of the host.

For example: When I type google.com in the browser, the DNS will internally check for the google.com IP Address and then forward the request to that IP Address over the internet.

👉 Data packets

The communication between the client and server happens in the form of data packets. These packets contain the actual data to be sent along with the sender and receiver details like source and destination IP Addresses and Port numbers.

IP addresses are used to know which host or computer has requested the resource (for example your router) and the request is being sent to which destination host (google’s server host), whereas ports are used to identify the application or the software service within that host/device which requested the resource (browser).

👉 A typical home setup for accessing the internet

In a typical home setup, we have one router and all our devices like mobile, laptops, etc. are connected to this router for accessing the internet. We will use this real-world example to explain how it all works.

👉 ISP

We all are exposed to the internet via some ISP (Internet Service Provider), for example, Vodafone, Airtel, or some local ISPs. These ISPs provide us with services by which we can access the internet.

If I connect my laptop to my home router and go to google.com from my laptop’s browser, the request does not directly reach Google’s server. The request first goes from the laptop to the home router. Then it goes from the home router to the ISP and then over the internet.

Local devices(phone/laptop, etc) -> Router -> ISP/s -> Internet

The ISPs also provide public IP Addresses to our local network routers, by which we are publicly identified over the internet. For the outside world/internet, all devices connected to this router will seem to have the same IP address, which is the same as the router.

But wait, if the ISP is assigning only one IP Address to my Home Router, then how multiple devices connected to my router are being uniquely identified by my router?

The answer to this question is DHCP.

👉 DHCP

Whenever any devices are connected to the router for accessing the internet, the router assigns new unique IP addresses to the devices connected to it. These IP address assignments are done using DHCP (Dynamic Host Configuration Protocol). These IP addresses are called private IP addresses, as the outside internet does not know about these IP Addresses. Internet only knows the IP address of the ISP, ISP in turn knows the IP Address of the router. So basically to trace back the request, the public internet will know about the ISP from which the request came, and the ISP will know from which specific router was the request made.

Now, when the response comes back from google.com, since the destination IP address was of the router, how does my home router know whether the response should be sent back to my laptop or mobile or computer?

And once it finds out the device( let’s say laptop), how does it know which service within that device should it be sending the response (for example browser, terminal, some gaming application, etc)?

The answer is NAT and Port numbers

👉 NAT and Ports

NAT (Network Address Translation) is the process of translating the public IP address of the router to the private IP address (which was assigned by the router to its connected devices using DHCP) and vice versa whenever the packet goes from public to private network or from private or public network.

Port numbers are used to identify the service or the application within the host (for example browser in your laptop) which made the request.

When you hit google.com from your laptop’s browser, the outgoing packet has the source IP address value as your laptop's private IP address (the one which was assigned by the router using DHCP) and the port number as the service(browser) identifier.

This request packet reaches your home router, here NAT updates the source IP address as the IP address of the router. It also masks* the source port number and then finally adds the corresponding entry in the NAT Table. When the response is received back to the home router from the internet, the NAT again checks this table to determine the exact host/device and the port/service to which the reply should be sent.

*NAT does the masking of the port number to avoid the problem which can arise if two different hosts/devices connected to the same router request a resource over the same port. As the NAT table will have a public IP address, a private IP Address and a port number entry, once the response comes back from the internet to the router, it will be unsure which host should the reply be sent to.

The clients who are requesting some resource over the internet can also specify some ephemeral port numbers instead of the default port of service which initiated the request. These ports are short-lived port numbers that clients can specify and expect a response on these ports.

This is useful if you have multiple processes running for the same service. The browser tab is the best example of this. Each new tab you open in your web browser will assign a new ephemeral port for that particular channel and this is how the router will know which specific browser tab had initiated the google.com request.

👉 Communication from ISP and above

The Internet is nothing but a large number of computers or hosts connected. So once the ISP forwards the request over the internet, the request might hop through a series of hosts before it finally reaches the server which is responsible for serving the request (in our case it is the server of google.com).

Routers have routing tables and forwarding tables which help in the data packet routing. The routing table is the data table which stores all the possible paths required to reach the destination host or router, and the forwarding table helps in actually forwarding the data packet to the next hop.

For example: If I made a request to google.com from Mumbai, India, the request might be served by some server in the USA. The request might travel from India to UAE, UAE to Austria, and Austria to the USA till it reaches the destination host which can serve the request.

Once the request reaches the server, the server will respond to the request and sends back the required data using the same technique as discussed above. The response will reach the source router (which made the request) via the same public internet and then NAT and ports will take up from there to send the response to the right host and service.

Usually, ISPs are classified into three tiers.

Tier 3 or Tier 2 ISPs are the local or national ISPs which serve some specific local areas or metropolitan regions within a country. Examples of some Tier 2 ISPs are Vodafone, Airtel, etc.

Tier 1 ISPs are the international ISPs which are responsible for connecting other lower-tier ISPs to the global internet. An example of a Tier 1 ISP is Tata Communications, etc.

These ISPs are also the ones who own the submarine cables under the oceans via which the actual internet data is transferred between nations and continents and how the whole internet works globally.

The whole world is connected not wirelessly, but via the actual submarine cables under the seas and oceans. Check this out — https://www.submarinecablemap.com. Isn’t it interesting? 🤩

👉 Other commonly used protocols over the web

There are a lot of protocols which are used in computer networking, but we will be covering the protocols which are most commonly used over the web. They are TCP, UDP and HTTP/s. Below is a basic and short explanation of these protocols. This explanation should be sufficient for starters, although you can read about them in detail later over the internet.

HTTP/s

This is used by web browsers. This protocol defines the format of the data being transferred through the web. It mentions how the communication should take place between client and server, like how the client will request the data, what will be the format of the data, and how the server should respond to the client. This is a connectionless and stateless protocol. Connectionless means that the connection is maintained only till the client receives the response from the server, and not forever. Stateless means that the state (data) involved in a particular request and response is only available during that request and response time only.

TCP

This is a connection-oriented protocol which means that the connection needs to be established between both parties (for example client and server) before actually transmitting the data. It is a reliable protocol which ensures data delivery and no data loss once the connection is created. To establish connection, TCP uses a 3-way handshake(using SYN, SYN-ACK, and ACK signals) to establish a reliable connection.

UDP

It is a connection-less protocol which means that the connection is not needed for the client and server to communicate. This also means that the data sent across between the client and server is not guaranteed for delivery as the acknowledgement flags are not present here. The upside of this protocol is that it is faster (low latency) than TCP. This protocol is used across applications where we need low latency and it is fine if the data packets are dropped. The most common applications are real-time services like gaming, video calls, etc.

Conclusion

Apart from these technologies, there are various other technologies as well which are widely used across the internet, like CDN, etc. which we will cover in some other article.

If you found this article helpful, please like, comment and share this article so that it reaches others. 😃

For more such content, please subscribe to my newsletter so that you get an email notification on my latest post. 💻

Let's connect 💫. You can follow me on

• Twitter

• LinkedIn

• GitHub

In this article, I will try to explain it in the best possible way right from the basics, differentiating it from many other similar concepts and why are they used extensively today.

Firstly, let's understand the difference between a website and a web application

A website is a collection of static web pages. Static here means that the data or information is hard-coded and do not require any inputs from a user or communications with the database. An example of a static website can be any small business website which has only services and contact us pages with content embedded in HTML itself.

Web applications, on the other hand, are dynamic websites which constantly require communicating with databases or back-end services for data or information to be presented to the end user. Examples of web applications are hashnode.com, amazon.com, etc.

A thought 💡

Do you think that massive applications such as Gmail, and Uber use a single programming language for all their development?

There are thousands of services running each second on their data centres to cope with users' demands and requests. These services may be executing various programs written in various programming languages and even running on different platforms.

Since there are more than one language and technologies used in developing one big web application, you might wonder how these different programs that are written in different languages communicate with each other.

If each language has its syntax and way of interpreting things, how do they understand what programs written in different applications wish to communicate?

Is there any standard way that all different programs can use to communicate with each other? (Just like each country have its native language, they can use English to communicate with anyone outside their country)

The answer is Yes. There is, and this is what we call a Web Service.

Web Service

Web service enables communication among different applications over the web using some standard protocol/method. Using web services, two different applications can talk to each other and exchange information.

Typically, a web service provider, who wants to provide its functionality to be used by other applications, develops a service and makes it available over the Internet. Any application can request the service from the server where it is hosted and the server responds to that request.

Two notable concepts come into the picture here — WSDL and UDDI. Putting in simple terms, WSDL(Web Services Description Language) provides information about the functionalities of any particular web service, and UDDI(Universal Description, Discovery, and Integration) is kind of a distributed directory of web services, where the server can publish their services, and clients can lookup to find any service. So, UDDI documents can have entries of multiple web services, and each web service may have its WSDL document.

The question arises again that how these applications communicate. The two important factors to think of are

• The medium through which the data or information flows from one application to another

• The format in which the information is transferred.

For example, while speaking over the telephone, the medium is the phone and the format is English or any language that both of you know.

Currently, two formats for communication between applications are universally accepted — XML and JSON.

Below is an example of the representation of students' data using JSON and XML.

Let's say there are 2 student records, each record has the student's name, email and city.

XML representation

<students>
    <student>
         <name>John</name>
         <email>john@xyz.com</email>
         <city>Boston</city>
     </student>
     <student>
         <name>Julie</name>
         <email>julie@xyz.com</email>
         <city>London</city>
     </student>
</students>

JSON representation

{
    "students": [
        {"name":"John", "email":"john@xyz.com", "city":"Boston"},
        {"name":"Julie", "email":"julie@xyz.com", "city":"London"}
    ]
}

You can see that JSON is easier to write and understand.

JSON is used on a larger scale than XML because it is lightweight and easy to understand.

Now, coming to the medium through which the data is transferred. Web services use HTTP(Hypertext Transfer Protocol) for sending requests and responses over the web.

HTTP uses a request/response technique, that is, communication or transfer of information between web server and browser is done through HTTP request and response packets.

For example, the web server is where all files related to the website are present; the browser or client sends a request for an HTML page, and the server responds with the requested page. Similarly, the browser may request some information from the server by sending an HTTP request, and the server processes the request and provides appropriate responses as an HTTP response in the format(XML or JSON) discussed above.

Now that you know the fundamental concepts of web service, let’s dig into the types of web services

Types of Web Service

Primarily, there are two types of web services-

• SOAP web services

• RESTful web services

In SOAP(Simple Object Access Protocol) based web service, all the information exchange happens over a single common format — XML. These XML-based messages have a defined structure, which is known as SOAP Message. Each of these SOAP messages consists of an Envelope, which has a header and body.

Remember that web services are used to communicate between two different applications, platforms, or browsers and servers, so these services need to have all information required for the efficient transmission of any message.

In SOAP envelope, the header provides information about the message itself and also includes routing information, and authentication information, if any. The body contains the actual data that needs to be sent.

RESTful web services communicate between applications using REST principles. REST(Representational State Transfer) is an architectural style which defines how communication happens between two different applications. And how it happens is uniform and stateless.

Two major principles of REST are uniform interface and statelessness.

A uniform interface means everything in RESTful web service is a resource. The resource can be data, information or any block of data. This means that there is no distinguished part which cannot be accessed or accessed differently, everything is accessed by a URI(Uniform Resource identifier).

Also, RESTful web services make use of HTTP methods for the exchange of information. Oh sorry, I meant the exchange of resources. 😄

For example, HTTP methods like GET, PUT, POST and DELETE can be used to request some resource specified in URI itself.

Suppose I want to get details of all student records from XYZ website, I can use GET

GET www.xyz.com/students

or if I need detail of a particular student with ID 12345

GET www.xyz.com/student/12345

Similarly -

• PUT can be used to update the existing resource details

• POST can be used to add new resources

• DELETE can be used to delete a resource.

In the above example, I can use the PUT method and specify the updated value of any detail, like the name or email of the student in my body.

Similarly, I can use the POST method to add a new student record and the DELETE method to delete a student record.

If you are building a web service or an API in a RESTful manner, you must specify the appropriate functionality and response that you want to give for any given HTTP requests received through URI.

Stateless communication means there is no previous information or data that is required to send a current request or response. Every request or response contains all the information itself and does not rely on any previous state of messages.

REST also supports caching and layered approaches. Various layers of components can be added between the client and server like a proxy server, gateways, etc.

Also, REST supports XML and JSON format, whereas SOAP only supports XML.

Because of all these principles and differences, REST is preferred over SOAP.

Conclusion

Web services are widely used today for communication and exchanging data between disparate applications or platforms. Technology is growing at a faster rate and more connectivity and seamless integration of services ensure greater experience and value for users. RESTful web services are dominant for most reasons, and REST is widely used in developing APIs and web services today.

If you found this article helpful, please like, comment and share this article so that it reaches others. 😃

For more such content, please subscribe to my newsletter so that you get an email notification on my latest post. 💻

Let's connect 💫. You can follow me on

• Twitter

• LinkedIn

• GitHub

But then eventually as I started contributing to the project, I started loving this awesome framework.

I have worked on the RoR framework for over 2 years, and here I am sharing the experience and knowledge I have gained working on production applications using RoR.

Why Ruby on Rails 💡

The biggest competitive advantage of using Ruby on Rails over other frameworks is the vast ecosystem, framework maturity and speed of product development.

On top of this, it has lots of supporting libraries, which will help you even more in your development journey.

It is known for its easy syntax and rapid programming so that you can focus on more important aspects like system designs, integrations and other engineering principles like testability and maintainability.

With all the pros above, it also comes with its challenges like slow runtime or slow performance at very high throughputs, hence it is mostly preferred by startups who are still scaling up and trying out different things and shipping features fast.

Let's start with the concepts 💫

First things first, I will start with a very common use case, upon which all further concepts will be explained. Let's consider the backend of a "product catalogue service" in an e-commerce company. This backend service deals with

• Product creation and updation

• Exposing product details to the outside world or other services within organizations via APIs

• Broadcasting the product updates asynchronously via some message-passing mechanisms.

Let’s create a new rails project using the command:

rails new catalog

Note: For demonstration purposes, I will be using MySQL database and ActiveRecord ORM for interacting with the database.

Don't know what is ORM ? - Object-relational mapping (ORM) is a mechanism that makes it easier to access and manipulate database objects without actually writing raw SQL queries.

1. MVC (Model-View-Controller)

This is the most common design pattern that many frameworks support, including Laravel, Spring MVC, Ruby on Rails, etc.

Putting it most simply, MVC is a software design pattern that divides the application into three interconnected elements, namely Model, View, and Controller. The basic idea is that each application consists of these three elements-

1. The model holds the data

2. The view makes the application look nice with clean layouts and consistent data display

3. The controller controls the flow between the Model and View, i.e. how the data flows through and out of the application.

MVC pattern allows having maintainable and segregated code, which can work wonderous in making further changes as the application scales from MVP to large-scale systems.

Use case:

Let’s take this use case where the user wants to get product information. When they click on a particular product, they are directed to the PDP(Product Details Page) of that product.

Now you may think it as simple as exposing a GET API with endpoint /products/{product_id} and when the request comes to this API, just hit the producttable in the database and get the results and show it on the web page. Well, the approach is straightforward, but with the MVC pattern, you can make these requests handling more maintainable and clean.

With rails and MySQL installed in your system, just navigate to your project folder using the terminal and run the below command -

rails generate model Product name:string

This command will create a model file named product.rb in the app/models folder and will also create a migration file in db/migrate folder, which will look like the below-

Model file (product.rb)

class Product < ApplicationRecord
end

Migration File (_create_products.rb)

class CreateProducts < ActiveRecord::Migration[5.2]
    def change
        create_table :products do |t|
            t.string :name

            t.timestamps
        end
    end
end

Now, you need to run this migration to be able to create the actual product table in the database. You can also add some more fields to this file if you need some additional attributes in the product table. After the required changes are done, run migrations using the command -

rake db:migrate

This will create the actual table in the database.

Now since you are all set with the tables and model in hand, let us create a controller.

Go to the terminal and run the below command

rails generate controller Product

This will create a product_controller.rb file inside app/controllers folder with the following content:

class ProductController < ApplicationController
end

It will also create an empty app/views/product folder, which you can use for defining views for our application. You can also use this file along with any routing mechanisms for developing full-stack web applications.

So now instead of maintaining your code in a single file or making custom secondary files and handling processing between each of them, this MVC architecture lays down a common and sleek code structure and design pattern that you need to follow for making your application code more maintainable.

One of the principles of Ruby on Rails is the ‘Fat Model, Skinny Controller’, which means making the controller as simple and atomic as possible and providing all transformation and processing logic in the model. I will be using this same principle most easily in the next few concepts.

2. Trailblazers

This is a concept that has been used widely across many organizations for designing and implementing business logic layers into comprehensive and maintainable code.

As their website quotes-

“Trailblazer’s file structure organizes by CONCEPT, and then by technology.”

They seriously mean it!

The approach of writing, dividing and structuring implementation code into concepts and practising modularity at the code level is the best thing for which you will thank yourself once the production application grows big time.

Use case:

Let’s say you have a product availability logic which determines whether any product is available in the inventory at a specified city or not.

Let us assume that availability logic requires read access to 3 to 4 tables and also requires some Redis calls to fetch related data, and at the end requires processing at the application end before giving the actual availability.

Now you want to do all these things every time someone hits Catalog interface services or APIs. So, for any requested product in any city, the catalog must provide actual availability precisely.

Implementing all of this at the Model Level or Controller Level alone is a bad practice as the logic may talk to several models and also it may scale in the future. This is where the Trailblazer concept can come into the picture.

A sample trailblazer operation file for calculating availability will look like this-

class ProductAvailability < Trailblazer::Operation
    step :read_params
    step :fetch_product_and_location_details
    step :calculate_availability
    step :persist_and_build_output

    def read_params(options)
    # logic to read the product and location id params passed
    #if params not passed, return false (this will exit the concept and return to the caller)
    end

    def fetch_product_and_location_details(options)
    # hit db/cache to fetch location and product details
    end

    def calculate_availability(options)
    # logic to calculate availability for a product-location
    end

    def persist_and_build_output(options)
    # store the availability calculated and return the response
    end
end

You must have observed a parameter named options in the above file. It is the parameter of the type map, which is common to the whole concept.

So you can assign some values to this hashmap in the first concept function and read that in the next one, and also return the values to the caller. Example: you can assign product details to options[:product] in the second function and access it in the third function, you can assign the final response to options[:result] and return, and refer to this result from the caller.

So options value can look like this:-

options = {:product: {:id:123, :name: "P1"}, :result: {:availability: "IN_STOCK"}}

Also, as specified in the first function, returning false from any of the "step" stops the current flow of concept and returns to the caller with the values added to this options variable till that time.

Apart from operations, there are other related functions that this awesome framework provides. You can explore them here- http://trailblazer.to/.

3. Active Jobs

This is a framework where you can declare async jobs and run them on any queuing services. Jobs can be used for -

• Runnin cron / daily cleanup tasks

• Sending events to a couple of services

• Running some calculations or processing some update event of a record in the model.

Active jobs run parallel and in a separate thread from the current main application thread.

Rails provide this Active Job framework where you can create a job, enqueue the jobs on certain events, specify a queue where the job should get enqueued, execute it, and many more functions.

Use case:

Let’s say that the catalog service gets the product details from another microservice through a Kafka queue, processes it and persists it in its database.

Some attributes of the product might also influence the availability of that product(like if a product is discontinued or banned), so you need to call the availability concept that we saw in the earlier example, to recalculate the availability for that product, and persist it back in the database.

This should be done parallelly so that the current application thread is not strained or blocked with additional overhead.

To do this, create a new file  app/jobs/recalculate_availability_job.rb, with job name as RecalculateAvailabilityJob. Accept product_id parameter to this job and in this job, call the availability concept which we saw in the earlier use case inside this function. Snippet added below-

class RecalculateAvailabilityJob < ApplicationJob
    def perform(p_id)
        ProductAvailability.call product_id: p_id
    end
end

Now, in your Product model, use an after-commit hook to trigger the above job whenever the product's discontinued attribute is changed.

class Product < ApplicationRecord
    after_commit :recalculate_availability

    def recalculate_availability
        if discontinued_previously_changed?
            RecalculateAvailabilityJob.perform_later id
        end
    end
end

Here, perform_later is the keyword that enqueues the job to be performed as soon as the queue gets empty.

So with the above code, whenever an attribute discontinued of any product is changed, this job gets enqueued which gets processed by a different thread and it calls the availability concept for the same product whose attribute was changed.

4. Mailers

As the name suggests, this script is used to send emails.

Use case:

You want to notify certain people about a product whenever it is banned.

Just create banned_product_mailer.rb in app/mailers/ folder as below-

class BannedProductMailer < ApplicationMailer
    def send_mail(name:, email_id:)
        attachments['banned_products.txt'] = { mime_type: 'text/plain', content: name.join("\n") }
        mail(to: email_id, subject: "Banned Products Alert: #{ENV['RAILS_ENV']}") do |format|
        body = "PFA #{result.count} banned/unbanned products"
        format.text { render plain: body }
    end
end

Now, in your Product model, use another after-commit to send an email when the banned attribute of the product model is made true.

class Product < ApplicationRecord
    after_commit :send_mail_on_banned

    def send_mail_on_banned
        mail_ids = JSON.parse(ENV['BANNED_PRODUCT_MAIL_IDS'])
        if banned_previously_changed? && banned_previous_change[1]
            BannedProductMailer.send_mail(name: name, email_id:)
        end
    end
end

5. Rake Tasks

These are the one-time scripts that you can write once and deploy, and then execute via console whenever you need to run it. These tasks are written for a specific purpose like performing data cleanup, updating some data, performing indexing of all the records, etc.

Since the developer doesn’t have access to manually update the production data, these kinds of tasks are very useful if there are any cleanups, small data anomaly fixes or some ad-hoc tasks that need to be run

For example, I developed a rake task to update any column value of a table. This had been used several times by our team for updating values for some ad-hoc requirements as well as for critical short-term data anomaly fixes.

Similarly, you can write rake tasks for your use case to provide solutions for some of the common problems.

To write a rake task, create a directory named tasks or scripts and inside this directory, create a file for a task which you need to run with .rake extension.

Sample task: hello_world.rake

desc "Print Hello world"
task :print_hello_world do
    puts "Hello World!"
end

Run this task via the terminal using the below command

rake print_hello_world

🌟 Bonus 🌟

Since you have read the article up to here, here is a small bonus.

Below are the most commonly used Ruby's in-built functions and objects that I have found most useful and have used extensively while working on the project.

1. map, split, join, flatten, etc - How to Use The Ruby Map Method (With Examples)

2. procs and lambdas - Ruby Blocks, Procs & Lambdas - The Ultimate Guide!

3. permutation

4. combination

Apart from these, there are many more functions, objects, and block patterns in Ruby, which you can explore and implement in your applications, but the above four are the ones which I have found most useful and used 80% of the time.

If you found this article helpful, please like, comment and share this article so that it reaches others. 😃

For more such content, please subscribe to my newsletter so that you get an email notification on my latest post. 💻

Let's connect 💫. You can follow me on

• Twitter

• LinkedIn

• GitHub

Most people don’t plan how to manage both front-end and back-end programming simultaneously and ultimately end up wasting a lot of time doing unwanted repetitive tasks.

The intellect is not about being able to know both sides of the technology, but it is about the way you manage your development task. It is about having a balanced and systematic approach for coordinating the frontend and backend tasks and getting rid of redundant and stressful tasks.

Design First 💡

Give me six hours to chop down a tree and I will spend the first four sharpening the axe. -Abraham Lincoln

No matter how simple or complex your application is, single or multiple pages, always design the UI and interactions, and the high-level design of your application. This applies only when you are also handling front-end tasks. If you don’t prepare a design before development, you will find yourself confused and stuck in the colours or pixels of each UI component continuously until you feel it is good, and the fact is you would not be satisfied with your UI for a very long time. This will drastically reduce your speed of programming and also stress your mind doing redundant activities.

Use tools such as Adobe XD, Figma or Sketch for designing the UI. Prototype your design to understand the interactions between various UI components.

Ask ask ask!

Developing an application for a client? Have a thorough session with them, discuss their interests, plans, any design pattern that must be followed, existing branding campaigns and brand resources they already have, like logo or colour palette.

Try to understand the end user’s needs, and design a persona for the users.

Don't start front-end programming until the design is approved by your client!

Schedule your development plan accordingly and stick to it and also have constant communication with your client at some planned milestones.

Follow the incremental approach

Suppose you want to build a library management application on the web, then divide the main application into several sub-applications. Implement those sub-applications first, develop their UI, and backend implementation, and test it completely before moving it to the next sub-application.

Let's say login and signup is the first sub-application. First make a minimal front-end, without any CSS stylings, with all necessary HTML components like forms or input tags that are required for user inputs.

Now implement middleware or back-end functionalities and test the application for inputs and responses from databases.

Finally, style your UI components completely using simply CSS or some front-end framework.

Now repeat this task for each sub-application in a bottom-up manner(also take care of integrations of these sub-tasks) until you build a complete application.

Utilise the right tools 🔧

If you are building an API, use tools like Postman for checking the HTTP request/response and methods so that you can focus on validating your API first instead of other tasks.

If you are developing front end part first, then you can use some dummy texts like ‘lorem ipsum' for filling up dummy data in place of actual data, which will be later provided by the database when you start with the back-end. (For Sublime Text, typing lorem+TAB will automatically fill up dummy data).

If you have started web development and want to get some useful tips, tools and resources, do check this article - Web Development Tips and Resources. This article also lists some tools and software which are very useful and productive.

Got bored or stuck for a long? Switch! 💫

There may be times when you are working on the front end and feeling bored or stuck somewhere for too long. In such cases, you can switch to the backend and start developing the backend part of the application. This will make sure you are not blocked or your performance is not getting affected due to boredom working on one particular tech stack. After completing the backend part, you can resume your front-end work again. You will find yourself more productive this way and will be able to complete the project faster.

Focus on code maintainability and formatting

This is a no-brainer for any developer. The code needs to be maintainable and in the proper format as per the language standards. This may not seem important initially when the application is small but when the application scales and grows in size, the features in the applications also increase and the lines of code increase at a very rapid scale.

If the code is not maintained over time, it might lead to more confusion and can be disastrous for your development journey. If the project is growing rapidly, make sure you have blocked dedicated time just for refactoring code and removing the lines of code which are not being used anymore. Also, add proper comments and test cases wherever required. This will surely help you in long run, if at all not in the beginning.

Follow proper web standards and focus on optimisations 🌟

Check if the basic things like input validation, authentication, authorization, and error handling are in place.

Make sure that the website you are building is compatible with different browsers which are common nowadays, like Chrome, Firefox, Safari, etc.

The website should also be developed with responsive design in mind so that it works and provides a consistent experience on different device sizes.

The application should be made in a way that will help in building the credibility of the website and also have good rankings in search engines. Try implementing various SEO techniques on the websites, for example: providing a readable slug for various pages, and having a valid tag for different content types like titles, headings, etc.

Optimize images which are used in websites. If the images are large enough, this can cause slowness in the website and can directly affect its rankings and usability. Use compressed images wherever possible, use SVG or WebP instead of png or jpeg, etc.

Conclusion

Managing all the things end-to-end can be overwhelming and also frustrating if it is not managed in the right manner. Hence avoiding some most common mistakes while developing web applications is a must and this article covers the steps you can follow to be better at developing web applications.

If you found this article helpful, please like, comment and share this article so that it reaches others. 😃

For more such content, please subscribe to my newsletter so that you get an email notification on my latest post. 💻

Let's connect 💫. You can follow me on

• Twitter

• LinkedIn

• GitHub

Web development has a lot to things and mastering every concept of the web would take some time. From my initial years exploring web development, I have noted various points on the related topics, which I have shared in this article. Implementing all these points and tips will help you become a great web developer. At the end of this article, I have aggregated some resources that I have been using to be productive in various phases of web development.

I have mentioned topics in a sequential order which I followed, and I suggest you can do the same.

Front-end development

Start with the basics of HTML and CSS. These are very simple and you can learn these technologies at w3schools. Try to make simple static web pages using HTML and CSS. Understand the box model, class, ids, tags, transitions, transformations and media queries in CSS.

Once you are comfortable with CSS, start with Bootstrap. It is a front-end framework with the main focus on responsive, i.e. mobile-friendly web development. This will make your development faster and improve your efficiency for both desktop and mobile-based web development.

Now, start with Javascript. Understand the DOM, DOM manipulation using Javascript. Try to go through all the core concepts of Javascript.

Now, try to make simple projects like a ToDo App, any simple browser game using Javascript or a website with some cool transitions and animations.

Back-end development

There are many technologies that you can use for back-end web development. I would suggest starting with Ruby on Rails / Node.js and MySQL. These technologies are very simple to understand and will help you in understanding the request/ response techniques in a web browser and how to interact with the database and back-end.

Node.js, Express.js and MongoDB are more popular nowadays. One of the advantages of Node.js over PHP or RoR is that Node.js uses Javascript for the back-end as well, so you don’t need to learn a new programming language as you had used Javascript for front-end development. MongoDB is a NoSQL database, which stores data in documents and collections rather than tables(which MySQL uses). So exploring both databases will help you understand the structure of both types of databases.

Make projects that have very basic database requirements like signup and login functionality, and try to perform CRUD(create, read, update, delete) operations on some data using these technologies.

HTTP Request/Response, Cookies, Sessions and AJAX

Once you are comfortable with basic front-end and back-end technologies, it’s time for you to jump to some advanced concepts on the web.

Explore server sessions, HTTP Requests and Responses, HTTP sessions and cookies. It will help you understand browsers, servers and how messages are sent from client to server and how the server processes those requests and sends responses.

Implement Ajax on your previously developed web application(that you developed with the back-end). Ajax is one of the most important concepts in web development. It will also broaden your knowledge of the request/response paradigm.

REST APIs and more

As you get a clear idea about the HTTP request/response model, you can now try to build an API in a RESTful manner. RESTful APIs are used extensively in applications because of their statelessness, and understanding these technologies can help you get more exposure to various advanced topics and also help you during job interviews.

Try to implement simple E-commerce APIs which use HTTP methods to perform CRUD(create, read, update, delete) operations on products.

Popular frameworks

Apart from trying out Laravel or Node.js, you can also try popular frontend frameworks like Angular, React, and Flutter for Web. This will help you understand concepts like stateful/stateless widgets, local storage, components, etc. React.js along with Node and Express.js is a very popular stack nowadays.

What to do after all these things?

KEEP LEARNING!

Try some latest technologies

Don’t just stick to web development, try out mobile application development, read about system designs, explore machine learning, etc. It will widen your vision across various domains.

Do internships/ research.

Expand your network.

And finally, share your knowledge with others. :)

Now, as promised, the following are some resource names that you will be requiring at various phases of web development. Make sure you save this so you don’t have to search at ten different areas and waste your time.

• IDE for web development — Brackets, Sublime

• UI Design Tools — Invision, Adobe XD

• Icons — FontAwesome, Glyphicons.

• Fonts — Google Fonts

• Colours — UIGradients, HTMLColorCodes, FlatUIColors

• Stock Photos — Unsplash, Pexels

• Illustrations — Undraw, Drawkit

• Version Control — Github

I have pushed some projects on my Github account which you can check out.

You can follow me on Twitter and LinkedIn for more such articles or if you need any guidance.

If you are looking for a job via college campus placements, companies usually start visiting colleges for hiring right from the start of the degree final year. Companies may have different requirements based on their job profile, packages, and engineering grades. I would suggest you to start planning and preparing for interviews atleast three months before the first job interview.

1. Start solving aptitude questions. As you are a fresher, the companies generally conduct aptitude tests as a first round to filter out students based on some threshold of minimum marks in these tests. You may start solving aptitude questions on websites like Indiabix, as it has almost every basic topic of aptitude covered.

2. I believe that you must have solved some basic programming questions in college theory and practical assessments and have basic knowledge of programming languages such as C, C++, Java, etc. However, if you are not much into programming but want to get into a good company as a SDE, you still have good time. Pick any one of the above language and start going through the basics like data types, loops, function definition and declarations, program flow, etc. Geeksforgeeks is the best platform according to me for getting started and knowing the basics of language. For example: if you have picked Java, you can go through https://www.geeksforgeeks.org/java/. It starts with the very basic concepts and goes all the way till advanced concepts like Multithreading, OOP using java, etc.

3. Start solving programming questions on leetcode. Start by solving easy level questions, and gradually move to medium level only when you are comfortable enough in solving easy questions. Practice daily for at least an hour so you get your basics cleared before your campus placements.

4. Thoroughly read through core topics such as OOP, databases, operating systems, and networking, and understand how various things work. Personally, I prefer GeeksforGeeks is the best website for understanding these concepts and you can get all the relevant topic related to Software Engineering there.

Data Structures and Algorithms (DSA)

After you have picked up the language you are comfortable with, start understanding various data structures and algorithms. Again, Leetcode and GeeksforGeeks are the best websites I would recommend for getting good at DSA. Leetcode also has filters based on difficulty level or topics, which you can use to get started initially.

I have provided a list of data structure and algorithms below that you must know and practice before appearing for interviews. You can filter them in leetcode and try to solve problems one data structure/algorithm at a time, starting with easy level and moving to medium level questions once you are comfortable solving easy ones.

Data structures

• Arrays (1D and 2D Arrays)

• Linked List (Single and doubly linked lists)

• Stack

• Queue(Simple, circular, priority and double-ended)

• Trees(Binary Tree, Binary Search Tree, Heap structure and Trie)

• Graphs

• Hashing

Algorithms

• Searching (Linear and Binary Search)

• Sorting (Bubble, insertion, selection, quick, merge sort, etc.)

• Recursion

• Pattern searching

• Graph Algorithms(BFS and DFS)

• Greedy approach

• Dynamic programming

• Divide and Conquer

• Backtracking

• Analysis of algorithm (Big O)

There are also many advanced data structures and algorithms, but the above listed are the most important ones that you should thoroughly understand first before moving on to advanced DSA.

Build projects

Most of you might already have worked on building projects throughout your engineering years. If you haven’t, try to build some good projects using various technologies.

Building projects does not mean making a very simple website or an application that would have built in a day or two, or any high-end project that has a thousand features in it. Just try to make something significant enough so you understand how the project development works in general and also try to explore some important concepts like MVC, APIs, etc. Learn about Git and start using git commands while making your projects.

If you have no idea what kind of projects to make, I would suggest learning technologies like Ruby on Rails or Node.js, Express.js, etc and make a web application using these technologies for starters.

I strongly believe that projects and internships are as important as learning and practicing data structures and algorithms.

Data structures and algorithms will help you in improving your problem-solving and debugging capabilities, and projects will help you gain confidence in building some real-world stuff and understanding the concepts which are commonly used in software development. Apart from that, it makes your resume look good and gives an impression that you have your hands on many technologies(not just DSA) and you are a self-starter.

If you still have no idea about any topic for projects, here are some of the simple yet significant case studies and ideas I would suggest you can work on:

• A news-based web application where admin can create and manage users and users can publish, edit or delete their news.

• Making a RESTful API of an e-commerce website that facilitates CRUD(create, read, update, delete) operations on products and comments over products.

• Developing a mobile application to manage your day to day events.

• A chat-bot or any face recognition based application.

Learn basics of System Design

Companies might also have a round where they will ask you to design some system, like movie e-ticketing system, chat application, elevator system, etc. In this round, interviewer usually want to know your approach on building these systems.

The usual steps on approaching these kinds of questions are-

1. Try to understand and note down the scope of the problem. Ask questions to clarify incase of any ambiguity.

2. Note down functional and non-functional requirements.

3. Start exploring and thinking on

   1. How end-users will interact with your system(ex: front-end UI),

   2. How frontend will interact with backend(ex: using APIs),

   3. How APIs will be designed(i.e. what will be request / response look like),

   4. How will the data be stored in DB(i.e. what will be your db schema, what tables will you create, will you have any foreign keys, indexes, etc).

For this, you should know the basics about APIs, DBMS, OOPs, ER Diagrams, etc.

There are other things to think about as well, like-

1. How will your system handle failures (ex: using resiliency, circuit breaker, etc)

2. How will your system handle scale ? (ex: increase read/write replicas of db, etc)

3. If your system includes booking or monetary transactions, how will you ensure strong consistency ? (ex: by using transactional db queries)

If you are able to go through, understand and evaluate above concepts as well in your system design interview, then it would be a great deal.

Usually in system design interviews, there are other advanced topics as well but they are mostly expected from the experienced person who has worked on scalable products.

Extra-curricular activities

Two to three months before your first interview is not the right time probably for starting to do some extracurricular activities, but if you haven’t done anything other than academics and technical profile, there are chances that the recruiter may not consider you an ideal candidate atleast as a fresher.

Companies want to hire people that are something more than just academics. If you were ever into any student or technical bodies of your college, or have been involved in any program outside college, have worked for an NGO, or have been into sports or any art, make sure you specify that in your resume as an extra-curricular activity.

If you haven't done anything yet, best way is to try to volunteer for some NGO or do some social work. You can mention this in your resume and it will help you in developing your personality and develop empathy as well :)

Build your resume

Ideally, your resume should be of one page and should highlight your education, work experiences(internships), projects, achievements, publications(if any) and extra-curricular activities.

Make your resume look professional, clean and crisp. Always have 3-4 copies of your resume handy during your interview. Also have a soft-copy in PDF and save as "RESUME_{NAME}", ex: RESUME_JOHN_DOE.pdf

Prepare the commonly asked questions in advance

There are some standard questions that will be asked in almost every company interview. Most of them are behavioural questions such as “Tell me about yourself”, "Tell me about situation where you had a tight deadline and how did you manage it", “Where do you see yourself in five years?”, “Why would you like to join this company?”, "How do you handle rejections" and so on.

Come up with the best and honest answers for such behavioral questions in advance. You don’t want to be a person who is unprepared for such frequent questions and make up a satisfactory answer during your interview.

Always remember, your first impression can affect your image that the interviewer has, so make it the best.

Also, research well about the company that you are going to apply for, and understand what they do, what technologies they use, any recent news like new funding round, etc and make a list of relevant questions about the company.

Usually, at the end of the interview, the interviewer asks whether you have any questions for them. Don’t ask obvious questions like “What does your company do?”, you should already know that. Ask something about their products and any current projects they are working on. This helps them know that you are genuinely interested in working with them.

During your interview-

• Wear proper formals clothes and shoes.

• Greet your interviewer when you enter the room.

• Always ask before you sit. (if at all it's an onsite interview ;) )

• Make yourself comfortable and sit with a straight back.

• Maintain eye contact with the interviewer and use proper body language when required.

• Speak clearly and confidently.

• Most importantly, if you don’t know an answer, don’t try to fake it. It is always better to tell the interviewer that you don’t know the answer. They may not disqualify you if you don’t answer the question but faking an answer will surely make you disqualified.

After the interview process is over, wait for the results. If you don’t get selected at a company, don’t be sad and lose hope.

“Don’t cry because it’s over, smile because it happened.” ― Dr. Seuss

Try to understand where did you lack and what mistakes did you make.

Learn from your mistakes and work on improving it for the next interview. Tons of companies visit the campus for recruiting purpose and are out there, so actively apply for jobs at good companies and keep trying until you finally get selected.

Do let me know in comments if this article helped you :)

Also, please share this article on LinkedIn or Twitter or any preferred social netwok so that it can help others who are also preparing for interviews.

You can follow me on Twitter and LinkedIn for more such articles or if you need any guidance or want to curate your resume.