DEV Community: Anubhav Singhal

Microservices Architecture: What, Where & Why?

Anubhav Singhal — Mon, 22 Aug 2022 08:04:30 +0000

If you are into software development, you've probably heard about microservices. They've acquired a lot of traction in recent years, and every major corporation is creating one.

Microservices are an innovative and very unique approach to developing application systems as a collection of small services, each performing discrete and well-defined functions and being deployed independently. They are easier to understand, easier to deploy, and can be shared across different systems. This method brings high agility to an application system and provides many opportunities for DevOps and CI/CD.

In this article, you are going to learn about:

Microservices architecture of application systems
Various benefits of building microservices
Microservices development tools and technology
Common patterns for implementing microservice architectures

Different architectures of application systems

In terms of architecture, there are two sorts of application systems: the first is centralized and known as a "monolith," whereas the second has a decentralized architecture known as "microservices."

Monoliths

An application is composed of three components: a server, a client, and a database. The server processes client requests, implements business logic, collects or stores data in the database, and responds to the client. These kinds of servers are referred to as monoliths.

A monolith is a straightforward approach to building a server application. They're made up of classes and functions that let you combine all of your business logic into one running process. This is a single executable application system, where every change results in a newer version of the system. Kinda like Thanos with all infinity stones.

Monolithic systems are ideal for launching a business since they are self-sufficient, offer fast communications, and their requirements are easy to define. However, when a business grows, monolithic systems become a challenge. They have low scalability and adaptability and require extensive maintenance; even small errors at any point cause the entire system to crash in a split second. Also, they do not allow various teams to work independently and are constrained to be developed on a single technology.

Microservices

The microservice architecture is the solution to the challenges faced by monolithic systems. Rather than creating a single full-fledged server program with a dedicated data storage unit, this system consists of multiple microprograms serving unique services, thus referred to as a microservice. Kinda like a team of superheros with specific roles and abilities.

Microservices are built on specialized business capabilities. They have their own running process and can even have their own data storage unit. Different microservices can employ different programming languages, different database approaches, and be deployed independently. Different teams in the company work on specific services, and updates result in newer versions of the affected microservices rather than the entire system. And at any point of error, only the affected service will fail; the rest of the programs will work just fine.

Why microservice architecture?

More than 60% of enterprises had switched to microservices architectures by 2018. Many large corporations, such as Amazon, Netflix, Twitter, and Paypal, which began as monolithic systems, were at the forefront of this transformation. Its modular approach in application systems is widely being adopted to handle complex applications.

Let us take a quick look at some of the real-world use cases of microservices:

Refactoring Legacy Applications

In this competitive world, businesses often need to refactor their legacy codes or move to new technologies. Microservices is the preferred architecture by enterprises for rebuilding their system to change the functionality, add new features, or move to a new technology stack.

Big data, AI/ML

Applications that use technologies such as big data, artificial intelligence, machine learning, and so on need complex data pipelines for operations such as data collection, data filtering, data processing, and so on. In this scenario, a monolithic design could make the system heavy and difficult to administer; instead, a distributed system architecture with segregated pipelines is the better option.

Real-time data processing

Microservices architecture is used by streaming platforms such as Netflix and publish-subscribe pattern apps such as Twitter to provide smooth asynchronous communication and real-time data analysis to produce intelligent outputs.

Netflix was an early adopter of microservices and now has more than 500 microservices working autonomously to provide you with the best performance available.

DevOps

When DevOps and microservices are used together, they work incredibly. By adopting a single toolset that can be used for both development and operations, microservices help the DevOps team be more efficient. Project requirements, task dependencies, and problems may all be described using the same terminology and techniques.

Microservices, like anything else, have their own pros and cons. You must be aware of both of them before integrating this architecture into your system.

Benefits of using Microservices

Technical benefits for developers

You have the freedom to use different programming languages, tools, technologies, and data-storing strategies based on the requirements of your service.
Since every microservice is isolated, results in fast defect isolation too, failure in one microservices won't affect the rest of the system.
You can easily integrate or transition to new technology for a specific microservice without affecting the whole system.
Microservices are simpler to understand for new developers as compared to understanding the whole system.

Benefits for organizations

Microservices save a huge amount of time and money by making the system easy to manage and optimize.
Different teams in an organization have the freedom to work independently without colliding with other teams.
Microservices are based on distinct business capabilities, so they can be easily developed by a small team.
Since a service can be shared among different products, this saves a lot of resources for an organization.

Drawbacks of using Microservices

Testing can be a very tedious task in microservices architecture since there are a lot of services to test.
Handling the entire product might get difficult as the number of services increases.
Developer needs to design and develop a lightweight, robust and secure communication system for microservices to communicate with each other.
Internal communication between microservices increases the time taken by servers to respond to clients.

Microservices development tools and technology

As microservices architecture gained popularity, more and more tools and technologies have emerged to support this practice and improve the developer experience. Here are some of the best technologies for developing microservices:

Containerization

One of the most key traits of a microservice is that it operates independently, as autonomously as possible. To maintain their autonomy, they must be kept in an isolated environment with their own runtime environment. Containerization services such as Docker, AWS BottleRocket, and others make this feasible. Through autonomous container-based microservice architecture, you have the freedom to add, remove, scale, and replicate components as required by your business.

API Management

With an increasing group of microservices comes the challenge of establishing safe connections between them. You certainly cannot risk exposing any of your microservices to public networks. API management, using services like AWS API Gateway, Azure API Management, reduces the time required to build and manage API connections between microservices. They have various capabilities like authentication services, API monitoring, and so on, which may save developers months of time and work.

Continuous Integration, Continuous Deployment (CI/CD)

If you're adopting microservices architecture, you don't want a lengthy and costly release train where each team needs to wait their turn. You also don't want the release of one service to impact or be impacted by the release of another. You need to employ continuous integration and continuous deployment pipelines for your microservices. You can use CI/CD platforms, such as Jenkins and AWS CodePipeline, that provide easy to set up automated but high-velocity releases for your microservices.

Application Performance Monitoring (APM) tools

Your microservice is up and running after you design, implement, test, and deploy it, but you're not done yet. You must monitor system performance in order to improve user retention and rid your systems of faults and bottlenecks. Application performance monitoring solutions, such as AWS Cloudwatch, Kibana, allow you to effortlessly monitor all of your microservices, as well as increase your mean-time-to-repair (mttr) by detecting problems sooner.

Cloud providers

Managing multiple microservice can be very challenging, you need a lot of containers, API management tools, host multiple databases, CI/CDs, Application performance monitoring tools, etc. But no worry, most cloud service providers like AWS, Azure, IBM, etc. provide all of this on their platform, which eventually makes managing microservices lot simpler.

Common patterns used to build microservices

There are plenty of design patterns available for building microservices, each of them with different priorities and solving different problems. Here are some of the most popular patterns for building microservices:

Database architecture

Different services may require different data storage techniques, therefore creating a separate database for each service is a realistic solution that will improve scalability. However, running searches that connect data from several servers becomes quite complex.

Creating boundaries that ensure modularity is a smart notion. As a result, we may keep the data of a microservice private to that service, but we must make it available to other services via APIs.

API gateways

Making microservices accessible to client applications is a challenging task in itself. You don't want to expose all of the services to all sorts of customers, and some services even implement API protocols that aren't web-friendly. There are many service instances, and their location(host+port) varies dynamically.

A single access point for all clients, such as an API gateway, is a viable option in this case. This API gateway checks client requests before routing them to the appropriate microservice. It can send requests to a single server or several servers, depending on the requirements.

credits: Foundersguide

Access tokens

Consider the following scenario: you've implemented microservice architecture and implemented an API gateway as the entry point for all client requests. Requests are directed from here to various services based on their requirements, but how do you convey the requester's authenticity to the service that executes the request?

As a result, the API gateway passes an access token (e.g. JSON Web Token) along with the request, which securely identifies the requestor in each request to the services. The access token can be included in requests to other services by a service.

Log aggregation

Requests commonly span various service instances in a microservices architecture. Each service instance saves logs in a defined format to a file. Errors, warnings, information, and debug messages are all stored inside this log file. Debugging an error, on the other hand, might be time-consuming if you have to go through all of the services' log files.

As a result, having a centralized logging server that collects logs from each service instance is preferable. Different logs may be searched, analyzed, and even alarms can be created by users.

Health check APIs

Even if a service instance is unable to handle requests, it may continue to run. It might, for example, it has run out of database connections. The monitoring system should raise an alert system if this happens, and requests should not be sent to the failed service instance. So it is very crucial to identify whether a running service instance can handle a request of not.

As a result, a service's health check API endpoint, like '\health', that returns the state of the service should be included. This API endpoint handler checks a variety of things, including the status of the service instance's connections to infrastructure services, the state of the host, and application-specific logic.

You can learn more patterns for building microservices from here

Phew!

Looking back, you began with learning about various application system designs, followed by many famous microservices architecture use cases, and then, the benefits and drawbacks of adopting a microservices architecture. Furthermore, you learned about numerous microservices tools and technologies for building microservices, as well as some typical patterns for making them efficient.

Hope you found the article useful. Thanks for reading. Happy coding.

Push vs Pull API Architecture

Anubhav Singhal — Tue, 02 Aug 2022 06:05:52 +0000

The number of internet users has increased massively in the past few years, and handling this enormous amount of traffic is a big challenge for application developers. Choosing an appropriate architecture for communication between the server and clients plays a significant role in ensuring that traffic is kept at a manageable level.

In this article, you’re going to learn about the push and pull architecture of network communications, and how push architecture can limit the load on your application server, increasing performance.

Architecture of Network Communications

There are two primary approaches to network communications—push and pull.

Pull: Often referred to as polling, it’s especially common on the internet. A client, such as: a user, web browser, or application, etc. requests information and the server responds with the information requested. It’s like looking up the score of yesterday's football game: the information is static, and there's no need for frequent—or any—updates. The client requests the information, the server provides it, and the exchange is over.
Push: This is an architecture where data is pushed upstream over a connection as soon as it becomes available. One type of push-based transport is called a websocket, which is a persistent, bidirectional connection through which both the client and the server can push data. It's one of the foundations of the real-time web, and is the technology that underpins many popular chat and other real-time platforms. Other common places people encounter push-style communication is on their phones, where special offers, notifications, and score updates are often delivered directly to their devices.

It’s important to understand the difference between push and pull APIs so that you can select the right architecture for your service.

Pull API Architecture

If your client app needs to find out if there is any new information on the server side, the easiest—if not always the best—way to accomplish this is to call and ask, which is basically how pull APIs work. They are a type of network communication where the client application initiates the communication by requesting updates. The server receives the request, verifies it, processes it, and sends an appropriate response back to the client.

This whole process of polling updates usually takes hundreds of milliseconds. If there are many requests, it can slow down or even overload your server layer, resulting in a poor user experience, customer complaints, and even economic losses. Therefore, to control traffic, many companies often use rate limits to limit how often a client can ask for the same information.

While some of the drawbacks of pull architecture can be mitigated by a system that can distribute processing, even this quickly becomes a very expensive, resource-intensive option. If you need the ability to communicate frequent updates, push architecture is likely a better choice.

Push API architecture

The strongest use case for push APIs are for instances in which you have time-sensitive data that changes often, and clients need to be updated as soon as that data changes.

Push APIs allow the server to send updates to the client whenever new data becomes available, without a need for the client to explicitly request it. When the server receives new information, it pushes the data to the client application, no request needed. This makes it a more efficient communication standard for data that stays changes often.

Pull vs Push APIs

In a pull API, the client requests the information. In a push API, the server sends the information as it becomes available.
Pull architecture is request driven: the client sends the request, and the server responds accordingly. Push architecture is event driven: the server pushes data to clients as updates become available.
In a push API, the server needs to store client details to reach clients directly. With pull, the server doesn’t need to store these details, because they’re encoded in the request.
Push APIs are significantly faster than pull APIs. In a pull API, the server must receive and verify the request, then process information to form a response that’s sent to the client. In a push API, the server immediately processes information and sends it to clients as soon as it's available.

Why Push APIs?

Push APIs are widely used to minimize server load in apps with large user bases and frequent data exchanges or real-time data. Instead of users making frequent requests to stay updated with the newest information, servers instantly push data as new information is obtained. Push APIs are particularly useful for enhancing system efficiency by utilizing fewer resources, resulting in a more stable and cost-effective system.

Users receive around forty-five notifications every single day. Imagine the load that places on a system with thousands or even millions of users. Push APIs make this level of traffic much more manageable.

Push architecture also enables you to trigger parallel workflows in your application system. You can simply create a message with appropriate data for the workflow and push it to the parallel worker to process it or send it to the queue. A similar workflow can be performed using a pull architecture, but repeatedly requesting for messages to be placed in a queue can be time-consuming and difficult to implement.

Use Cases for Push APIs

Both architecture styles have use cases where they shine. Understanding these use cases will help you understand which API architecture is right for your application, and how it will affect your overall system.

Delivering System Updates

Pull APIs can be an expensive and risky choice here. Let’s say you have a thousand users, and they request updates every five minutes. If that’s the case, you’re looking at around two hundred thousand requests a day, just for updates. This puts a huge, unnecessary burden on the system. This is especially true if your system isn’t updated frequently, since most of the time, the client will request information, and receive “updated” information in which nothing has changed.

Push APIs are an excellent option here, since they can eliminate the constant update requests to the server. This reduces the server load, and creates room for other processes in your application server.

Systems With Complex Routing

If your application system requires complex routing across numerous servers, the communication architecture you choose can have a significant impact on both the system and the implementation process.

With push architecture, servers can simply push messages and client details to the queue together, making push architecture a viable option in a complex system. In a pull architecture, servers have to go through complex logic to check and pull a message out of another server and into a queue. Not only is this difficult to implement, but it’s also expensive and time-consuming.

There are many other common use cases where Push APIs are used as a standard approach.

Event triggers: A new parallel workflow is initiated with an event trigger.
Promotional marketing: Push notifications are sent to users to notify them about discounts, sales, and new offers.
Geographic location tagging: Location and other geographic data are collected by remote devices, such as your cell phone, and sent to servers using push architecture.
Notifications and reminders: Social media notifications, weather alerts, and top news articles that are sent to your device are made with push architectures.

Push APIs In Advanced Network Architectures

Push APIs are a common feature of advanced network architectures, including the following.

Event driven

Event-driven architecture is common in microservices-based systems. It utilises events to trigger communication and actions across different services.

Producers, brokers, and consumers are the three key components of this design. The publishers publish an event, which the brokers then filter and push to the consumer micro-services. This architecture uses push APIs to push events from publishers to brokers, and then from brokers to consumers, triggering appropriate services.

Pub/Sub

For asynchronous messaging, the pub/sub architecture is very popular. Pub/sub is a specific type of event-driven architecture that’s more scalable than other messaging architectures.

A publisher publishes information to a broker, and clients receive that information from the broker based on their subscriptions. Push APIs are used by the publisher to send information to the broker, who then sends the information to its subscribers.

WebSockets

WebSockets establishes a long-lived, socket-like connection between the server and the clients, enabling them to exchange data at any moment. There are no requests or responses; messages are just pushed from one end to the other, and push APIs are at the heart of the WebSockets architecture.

Conclusion

System architecture is rarely exclusively push or pull, but rather a combination of the two. All application services have different use cases, and you must choose an appropriate architecture for your expected use case to maximise your system’s potential.

Thanks for reading. Have coding.

Why Decentralised Web is a necessity?

Anubhav Singhal — Tue, 29 Jun 2021 06:28:19 +0000

When web first came into existence in 1989, it was decentralised. Anyone could publish their content on the internet, and users could access that content without any third party services. Communication was easy, secure and peer-to-peer.

However, with the introduction of web 2.0 in the early 2000s, people began to communicate through centralised services provided by several tech giants.

Centralisation with web 2.0

Current internet architecture is called to be centralised, lead by companies like Facebook, Google, Amazon, etc. Facebook, for example, now boasts 2 Billion monthly active users (more than China's whole population). Google is another good example; it answers 3.5 Billion requests per day.

The good:

These companies became massively dominant in their domain by two methods, that have also become the heart and soul of web 2.0
1.) Provide excellent services
2.) Free services for everybody

You don't have to sift through hundreds of websites to find information; instead you can utilise Google's free, fast-searching capabilities. You don't have to construct your communication channel or deal with other hassles if you want to connect and speak with others; you can do so using Facebook's services, which are also free.

The involvement of these third-party services has provided an exceptional user experience and most importantly at zero expense.

The bad:

Every internet company has its own data center, where all the user's data and their monitored interactions are stored. This infrastructural centralisation raises security concerns, by giving clear target points for hackers and fraudsters.

In early 2013, Adobe originally reported that hackers had stolen nearly 38 million encrypted customer credit card records, plus login data for an undetermined number of user accounts. In December 2018, Dubsmash suffered an attack on 162 million usernames, PBKDF2 password hashes, and other personal data, all of which was then put up for sale on the dark web market. In May 2019, Canva suffered an attack that exposed details of 137 million users.

Read more here

The Ugly:

Tech monoliths like Google and Facebook have billions of users. These users are largely unaware of what goes on behind the scenes at these companies. This Free world is a lie, users pay not with their money but with their attention. These tech giants are reaching past your wallets, spurning your money, to seize your time, which is actually your life.

Companies such as Facebook and Google dominate this user attention so massively that they are called the gatekeepers of 'information presented to users'. All major internet companies have a record of giving away user information to the government and other agencies without acquiring their consent.

The most well-known situation is the Facebook–Cambridge Analytica data scandal. We know about these companies' dark secrets thanks to whistle-blowers like Edward Snowden, Tristan Harris, and others.

Decentralised Web (D-Web)

Since the advent of BlockChain networks, like Bitcoin by Satoshi Nakamoto, and Ethereum by Vitalik Buterin, etc. A new network system is taking birth whose most powerful architectural imperative is security, a system so secure in it's root that it's also called Cryptocosm.

How does it work?

A D-Web removes centralised data hosting services, using instead a peer-to-peer infrastructure. Not only will this remove any services from a third party that tracks your data, it will also secure and smooth your transaction. As a result, no single entity will be able to control or manipulate the network of systems on their will.

D-Web is expected to bring 3 major changes to global internet architecture:

End of Free World: Money will become a native feature of the Internet.
Distributed Information: Decentralised applications offering users new capabilities.
Peer-to-Peer interaction: No involvement of third parties, users will have more control over their digital identities and data.

Benefits of D-Web

No Ads - Since Dweb is driven through money, there is nothing free of charge. We will not require an existing economic model where marketing and data sharing drive profitability.
No dependence on central authority: Remember how many times your work got stuck just because Google's server was down. There will be no such circumstances in Web3.0.
No central censorship: Government or any other single organisation will have no censorship over what you see or use.
Faster and Safer: Since there is no third party involved, transactions tend to be faster. Also no one is tracking your data, so you have complete control over your personals.

When is this happening?

To be fair, it's actually happening. Thousands of companies are investing billions in developing these decentralised networks.

Let me give some examples:

Brave Browser: It is blockchain based browser, co founded by Brendan Eich, creator of JavaScript. I have been using it for about an year now, and I absolutely love it.
DTube: A blockchain based alternative of Youtube, it has been getting lot of sensation lately. It's smooth and interactive and has potential to go further heights in near future.
EOS Dynasty: It is Blockchain based gaming platform, which has nearly 12,000 unique daily users, claiming to be the first role-playing, player-versus-player (PvP) game based on blockchain.
MakerDAO: A decentralized credit service that runs on the Ethereum blockchain platform, MakerDAO supports Dai, a stablecoin whose value is pegged to the U.S. dollar.

Well, that's all for this article. I hope I did spark a little interest in you towards decentralisation. I believe this is the biggest thing happening in tech industry that will drastically change the way we use internet in coming years.

You can read more about this at:

The Meaning of Decentralization by Vitalic Buterin
Understanding Web 3 — A User Controlled Internet by Emre Tekisalp
Evolution of Web, by Pragati Verma

What do you think about decentralisation? Is it good thing or bad? Let's hear your thoughts in the comment section.

Thanks for reading. Have a nice day.

Django, Null=True or Blank=True or both

Anubhav Singhal — Fri, 25 Jun 2021 06:00:22 +0000

When we add a database field to Django, we have several options for defining the modal field. They usually have default values that we can override according to our needs.

To use modal fields effectively, one must have a thorough understanding of their definitions.

Null

Every column in the database is defined to hold certain attributes. Sometimes we want to keep our columns optional, thus hold a NULL value, and we set these permissions as

NewField = models.charField( max_length=10, null=True)
# This sets the NewField to be an optional field in DB

NewField = models.charField( max_length=10, null=False)
# This sets the NewField to be a mandatory field in DB

Blank

Every Django model field is also defined to hold certain attributes. Sometimes we want to keep our fields blank with no form value, and we set these permissions as:

NewField = models.charField( max_length=10, blank=True)
# This sets the NewField to be allowed to stay blank

NewField = models.charField( max_length=10, blank=False)
# This sets the NewField to not be allowed to stay blank

Null and Blank

By now, it should be clear that Null affects the database table definition and blank affects model validation. There are four ways to use these attributes:

# 1. Requires both
Name = models.charField( max_length=10, null=False, blank=False)

# 2. Requires DB value
Name = models.charField( max_length=10, null=False, blank=True)

# 3. Requires modal value
Name = models.charField( max_length=10, null=True, blank=False)

# 4. Requires none
Name = models.charField( max_length=10, null=True, blank=True)

Let's discuss each distinctively:

1.) Null=False, Blank=False
This is the default condition for modal fields. It means the value is required both in the DB and in models.

2.) Null=False, Blank=True
This is a condition where forms don't require a value, but the field does.

Let's take an example: If your model has a field whose value is being calculated from other models in the field. Then you would want to keep 'Black=True' to not accept values from the user, and 'Null=False' to enforce that a value is always provided.

3.) Null=True, Black=False
This is a condition where form requires a value, but DB doesn't. This is not a very commonly used configuration, I haven't seen one yet. (If you happen to know any, put them down in the comments.)

4.) Null=True, Black=True
This is a condition, where form doesn't require a value, and DB doesn't require a value either. This is pretty self explanatory since the former is reflected with the latter.

You might now have a good idea of what these two attributes mean, and how they are to be used together.
You can read more about them here

Have a good day. Happy Coding.

Why we should always use ORM?

Anubhav Singhal — Sun, 20 Jun 2021 12:32:23 +0000

// Detect dark theme var iframe = document.getElementById('tweet-1405771005126008833-786'); if (document.body.className.includes('dark-theme')) { iframe.src = "https://platform.twitter.com/embed/Tweet.html?id=1405771005126008833&theme=dark" }

Interacting with the database is a key component of an application and the manner that we do it makes a big impact in the process of development and user experience.

There are several techniques, one of which is ORM. Let's talk in depth about it.

Note: I'll be using Django as a reference, but the same principles apply almost everywhere.

What is ORM ?

ORM is an acronym that stands for Object Relational Mapping. An object is what you use in your programming language, a relation is your database, and mapping is the link between the two.

ORM is a technique that lets you query and manipulates data from a database using an object-oriented paradigm. It encapsulates the code needed to communicate with the database, so you don't use SQL anymore; you interact directly with an object in the same language you're using.

Read more at What is an ORM, how does it work

ORM Lazy-Loading

In ORM, Querysets are known to be lazily loaded in order to load only what is required rather than the entire database.

Lazy loading means that until you perform certain actions on the queryset, such as iterating over it, the corresponding DB query won't be made.

For. e.g

result= Person.objects.all()
# Query hasn't been executed yet

temp=result.filter(age__lt=45)
# Query still hasn't been executed

for obj in temp:
    print(obj)

# Now query has been excecuted

ORM Caching

Interacting with large databases is a time consuming task, that's why Querysets are cached. The primary motive for ORM caching is to increase performance through localised data access as an alternative to making a database round trip to retrieve it.

For e.g. (Continued from last example)

result= Person.objects.all()
# Query hasn't been executed yet

temp=result.filter(age__lt=45)
# Query still hasn't been executed

for obj in temp:
    print(obj)
# Now query has been excecuted

for obj in temp:
    print(obj.age,": ", obj)
# Query hasn't been executed this time, because of caching.

Read more at Django Optimization: Or how we avoided memory mishaps

Pros of using ORM

Production: You don't have to be an expert in SQL queries, since you don't have to write SQL. Also, a lot of stuff is done automatically, hence Your code becomes short, clean, and easy to maintain.

Flexibility: it is generally available in the language of your choice, and lets you use OOPs goodness like inheritance very easily.

Cons of using ORM

ORM has tendency to slow down a little, as compared to direct communication with SQL.
Developer has to go through ORM library, and understand it's functions and utilities so as to be able to use it efficiently.

To summarise, I believe in most of the use cases benefits of using ORM easily exceeds drawbacks. I've been using ORM for a while now, and it's significantly improved my development experience.

What do you think? Put down in the comments. As always suggestions are always welcome.

Find me on: Twitter | GitHub | LinkedIn

Happy Coding.

Getting started with Asynchronous programming

Anubhav Singhal — Thu, 10 Jun 2021 06:54:56 +0000

Generally, when we code an application, a chunk of code runs at a time. So if our code contains a certain number of tasks, then each of them is compiled one at a time. This form of programming is called Synchronous programming.

But, don't you think, most of the computer systems are often equipped with multiple processors that can run several operations together. So, what's the point of executing one task at a time?

Asynchronous Programming

Modern software development revolves around doing multiple tasks simultaneously, making use of maximum computer potential to save as much time as we can. This form of programming is referred to as Asynchronous programming.

How do we do that?

In asynchronous programming, a program shares its processing to multiple threads. A thread is a single process that a program can use to complete tasks. Each thread can only do a single task at once.

// single thread application.
Thread: Task 1 -> Task 2 -> Task 3 -> Task 4 -> END

So if we use a double thread for the above program, then we can decrease processing time to almost half.

// Multi threaded application.
Thread A: Task 1 -> Task 3 -> END
Thread B: Task 2 -> Task 4 -> END

Most of the programming languages such as Python, JavaScript are old and are single-threaded built to work synchronously. Later with time, they got tools to help with such problems and send some processing to different threads.

New programming languages such as GO, Rust, etc. use multi-threading by default.

Asynchronous web applications

"Over 50% of mobile users abandons websites that take longer than three seconds to load." - Research by Google

Let's discuss an application of asynchronous programming in a web apps through a general example. Consider you have a mailing application and you're task is to send 5 emails.

Assuming one mail takes 2sec to process, then this task is going to cost 10sec in total. This is not good for users, most of the users are not going to wait for 10sec for completion of tasks.

what happens if we try to do this asynchronously?

I am sharing my Django based codebase, which is using the Django-celery package to complete tasks in different threads.

Note: If you're not familiar with python and Django, no worries, just take a look at the codebase to know what's happening and you can apply similar functionality in your applications.

If you code this task synchronously then:

# proj/urls.py
urlpatterns = [
    path('', index),
]

#proj/views.py
def index(request):
    curr_time = datetime.now()
    print("Process initiated at", curr_time)
    send_mail()    # Send 1st mail
    send_mail()    # Send 2nd mail
    send_mail()    # Send 3rd mail
    send_mail()    # Send 4th mail
    send_mail()    # Send 5th mail

    done_time = datetime.now()
    print("Process completed at", done_time)
    total_time = done_time-curr_time
    print("Total time for sending 5 mails:", total_time)

    return HttpResponse("Mails, sent successfully.")

Which returns output as:

Process initiated at 2021-06-09 09:01:58.158870
Process completed at 2021-06-09 09:02:08.179977
Total time for sending 5 mails: 0:00:10.021107

Notice how our function took 10.021107s to execute.

Now part of our code that's consuming most of the time is send_mail(). If you think about it, we can create a separate thread for this process, and let it run. This was, our main thread would execute instantly. This will let the user know that his mails are sending in process, and he can continue with other works.

Let's edit our index function and to send these mails asynchronously by using celery.

So, refactored function is:

# proj/urls.py
urlpatterns = [
    path('', index),
]

#proj/views.py
def index(request):
    curr_time = datetime.now()
    print("Process initiated at", curr_time)
    send_mail.delay()    # Send 1st mail with celery
    send_mail.delay()    # Send 2nd mail with celery
    send_mail.delay()    # Send 3rd mail with celery
    send_mail.delay()    # Send 4th mail with celery
    send_mail.delay()    # Send 5th mail with celery

    done_time = datetime.now()
    print("Process initiated at", done_time)
    total_time = done_time-curr_time
    print("Total time for sending 5 mails:", total_time)

    return HttpResponse("Mails, sent successfully.")

which returns output as:

Process initiated at 2021-06-09 09:09:19.496051
Process initiated at 2021-06-09 09:09:19.549268
Total time for sending 5 mails: 0:00:00.053217

Notice, this time our function took only 0.053217s to execute.

This is how modern web applications are developed to handle time taking tasks on different threads, and process the main thread as fast as possible.

By now, I am hoping you have good understanding of Asynchronous programming and its applications. If you like the article, share it among your peers.

Did I miss anything? Put down in the comments. As always suggestions are always welcome.

Find me on: Twitter | GitHub | LinkedIn

Happy Coding.

Guide to effective coding with Codeforces

Anubhav Singhal — Thu, 03 Jun 2021 10:56:09 +0000

Codeforces is one of the most popular platforms for practising competitive programming, world’s top programmers participate in contests held here.

I have been participating on codeforces for about two years now, and I can surely say that it has given me the best learning experience and lots of fun.

Writing from experience, beginners go through lot of trouble to understand how to practice on Codeforces and excel in competitive programming. Today, I am going to share a quick guide to the website’s UI, and strategies to practice CP.

Home tab

Homepage of CF, contains details of new challenges, their tutorials, some good recent blogs.

In the right division of this page, you’ll see a countdown to the next challenge contest with a link to register for the challenge. You can't participate in a challenge without participation.

Codeforces Blogs: This is one of the most essential parts of Codeforces, personally I have learned a lot of things from user’s blogs. Almost all professional programmer writes blog on codeforces based on their experience, they share their tricks and sometimes you might even find out really good algorithms that are hardly available on any other websites.

For eg. once I got an an error called “IDLENESS LIMIT ERROR”, which I had never heard of. I searched it over different websites but found no solution, but then when I tried to find it on codeforces blogs, I found the solution to the error within a few minutes.

There are other interesting stuff on this page but for a beginner, I’ll say, that’s all for the homepage you need to know.

Contests

This tab offers you details of upcoming contests and previously held contests.

The above image is an example of how contents are displayed, let’s break it down.

Enter: When you enter any past contest, you get to access all questions as in practice sessions.
Virtual Participation: This is like a virtual contest, in case you missed any contest or want to participate again. Your ratings won’t be affected by this participation, but you do get to see your rank in the rank-list generated in the live contest.
Final Standing: It’s the final rank-list of all the participants of the contest, below which shows how many questions of that contest you solved. ( Reference image shows “5 out of 9” because that’s my data.)

There are some other sections as well, but, this is all a beginner should be concerned about.

Problemset

A heavenly tab, for practising thousands of questions from various topics.

This is the tab that you are going to use most, and yeah, I have tried my best to explain it all.

The above image is an example of how the problems list is displayed, let’s break it down.

Question code: Like you see in image “1320 A” or “1313C1” these are question codes. Sometimes editorials use question code only instead of full names, so don’t panic over there.
Name: Obviously question name is pretty clear to you, but look, on the right side of this column, there is a grey text that tells topics tags of questions. These tags sometimes serve as a hint to the solution so if you don’t wanna see them, you may turn that off from setting in the right division.
Column 3: This column gives you an option to mark that question for any future reference. This column also tells which questions are solved, solved ones are colored and unsolved are left blank.
Column 4: It tells you about the level of the question in the form of rating, greater the rating, harder the problem.
Column 5: It’s a list of all solutions submitted for that solution. Also, if you click on the head of this column, questions get sorted based on submission.

Next is Filter Section, it is an important section in the right division of the page. Here you can filter the question list based on your choice.

For example, I have given difficulty from 1100–1200 and added basic question tags, which I personally believe every beginner should follow.

User’s profile

When you click on someone’s username then you are directed to their profile.

A user profile tells everything about a user’s life on CodeForces. Everything is open; details of all their contests, links to all their blogs, a little about their institution and where they belong to.

Obviously, most of this is pretty clear, I won’t go on every detail, but of course the useful ones.

Add Friend: Right next to the username, you see a star, that’s an option to add someone as a friend. By adding them as a friend, you can see your friends in rank-list of every contest.
Send message: This is really a useful option, you can drop a private message to a user and have a conversation regarding any question.
Rating names: This might be a little new for beginners, but on CF, coder’s profile is clubbed based on their rating. Like for tourist it’s Legendary Grandmaster, which is super hard to achieve.

How to practice efficiently?

Problemset tab is dedicated for practice purpose, but there are different strategies to use this set of problems for efficient growth. I am going to share strategy that I have been using for about a year now, and it has worked wonders for me.

These are some of the basic topics that are building blocks of a competitive programmer:

Greedy
Brute Force
Sorting
Binary Search
Two pointer
Maths
Combinatorics

What I do is, I choose any two of them, based on my skill-set and filter out questions based on these topics. To filter out questions, you can use filter section (explained in Problemset section), and give appropriate rating interval and start practising these questions.

Based on my experience, I’ll suggest to try Greedy+ Implementation in rating interval of 1000–1200, for absolute beginners.

Other special tools for Codeforces

These tools will help you to grow faster

Codeforces Visualizer: It’s an open hosted visualizer for codeforces accounts that tells you complete details of a user on codeforces, such as: his rating change, no. of questions attempted by user, topics wise distribution of user’s practice, etc. Like to visualizer is here.
Rating predictor: It’s a browser extension, available for most of the popular browser, it predicts rating changes live at the contest. It’s not 100% correct, but mostly accurate.
StopStalk: It’s another platform like codeforces visualizer, but the difference is that it creates leader-board for your friends in your institution and you can see each and every thing they are doing on different programming websites such as: Codeforces, Codechef, UVa, etc. Link to stopstalk is here.

As for the beginner, now you can easily find your way with CF’s UI, if you have any doubts put that down in the comment section, I’ll respond to it as soon as I see it.

If you are an absolute beginner and you want to get detailed insights of how to get into programming, then check out my other article where I have covered everything with beginners perspective, here is link to it.

Stay healthy, Keep learning, Keep coding!

5 most underrated skills of a top developer

Anubhav Singhal — Wed, 26 May 2021 10:01:32 +0000

You all might have stumbled upon blogs like "Best books you should read to become a top developer", "Best frameworks you should learn to become a successful developer", etc. We all aspire to be ninja developers, and so, we try to gain more and more understanding of technical concepts.

Today, I am going to take you through some of the most basic, yet important skills, that bring a very significant impact upon a developer's life.

#1 Touch typing

We have 10 fingers, and the standard Qwerty keyboard is beautifully designed to use each of our fingers all together, without even looking at the keyboard.

Still, I've seen plenty of developers who type with 2-3 fingers only. Most of the time they spend is looking at the keyboard and then checking on the screen if they typed correctly.

We got to learn to use the keyboard, before using a keyboard. Touch typing is one of the best productivity hacks for developers, you save a lot of time and energy.

Wanna learn touch typing? Checkout KeyBr, 10FastFingers

#2 Documentation

Documenting a project is something that we all know is a good practice, but the least of us care to follow. Good documentation is one of the most important part of the Open Source world, includes information for contributors, applied coding conventions, file organizations, comments, naming conventions, programming practices, etc.

"Workers spend about 2.5 hours per day, or roughly 30% of the workday, searching for information."
Xenit

When you write clear and accurate documentation of your projects, not only it gives an easy way to others when they look at your code, it also works as an easy checkpoint for you while revisiting code after a week/month/year. It might be tiring at the beginning but very effective in the long run.

Check this: How to write a good documentation

#3 Data Structures and Algorithms

We're living in a world where data is more costly than oil/gold. More and more data is getting stored, processed, and slowing down the processing time of the systems, which costs tech companies a fortune. Effective and efficient use of these data is a challenge, and that's where DSA plays a very significant role.

Under the cloak of all your SQL and Linux commands are algorithms and data structures. Google manages to search plenty of information in a fraction of seconds, all thanks to its Page Rank algorithm. Spotify, compared to it's competitors, consumes least data and gives the best personalized music experience, thanks to its BaRT algorithm that analyzes every piece of audio to give you the one that Spotify is confident you’ll like.

Real-world problems that take months can be solved in minutes using the knowledge of DSA. Understanding of data structures and algorithms may not seem relevant in the development of small scale applications, but makes an exceptional difference in large scale applications.

For more interest, check this: Improving your Algorithms & Data Structure Skills

#4 Coding standards

Following standard coding practices have a very positive impact on the software and growth of the organization, it decreases security concerns and enhances performance very significantly.

Series of procedures are explicitly defined of each programming language, they can be for various aspects of the program written in that language and are considered as essential attributes of software development.

// Detect dark theme var iframe = document.getElementById('tweet-1048257153205600256-112'); if (document.body.className.includes('dark-theme')) { iframe.src = "https://platform.twitter.com/embed/Tweet.html?id=1048257153205600256&theme=dark" }

To structure a smoother process of maintaining the code and providing readability to the code, coding standards, and code quality are essential to be managed by every developer.

Read more: Importance of Code Quality and Coding Standard in Software Development

#5 Communication & Collaboration

Communication skills are equally as important as technical skills. It's said that failures in software teams result more often from communication issues than from technical problems. Just like every other aspect of life, communication and collaboration play a very crucial role in software development. Being a talented developer won't bring the desired results if there isn't a successful collaboration.

There are many success stories that I can talk about where effective collaboration led to a smart product. E.g. Twitter, Jack Dorsey was paired up with Biz Stone during a hackathon. He and Biz came up with the idea of Twitter, which today has 150M+ active users worldwide.

How to connect with fellow developers, and build up strong connections, asking for help, pointing bugs, and all together staying humble and polite is an art that every developer should master.

Learn more at Communication is Key to Software Engineering

These were the 5 most underrated skills of a top developer, in my opinion at least.

What do you think? Did I miss any? Put it down in the comments.

Find me on: Twitter | GitHub | LinkedIn

Happy Coding!

My Experience with Crio: Winter of Doing

Anubhav Singhal — Thu, 28 Jan 2021 09:20:14 +0000

Crio.do is a platform that empowers developers to crack real-world industry problems with a moto Learn by Doing. Crio’s mission is to empower developers with excellent applied-learning opportunities at scale and construct the country’s product development talent.

Read more at: Crio.Do, by YourStory

Crio launched an initiative called Crio: Winter of Doing, considered to be India's largest tech externship program for developers. I got to know about this program through my college seniors, I applied for this program, and fortunately, I received an invitation for stage 1.

I have completed Stage 1 of this program, and in this article, I'll be sharing my adventurous journey with Crio.

Learning Bytes

CWOD's stage 1 was a complete package of an enormous learning experience. It consisted of 8 modules with hands-on experience, and a participant must complete these modules properly to get qualified for Stage 2.

CWOD referred to these modules as Bytes. These bytes were important basic concepts of software development that every software developer must be equipped with. The list of these bytes are:

HTTP
Objective of this module was to get a clear understanding of how HTTP works and use tools like cURL & Postman to perform HTTP requests and analyze responses.
I have shared my notes of this module in an article: Link
REST
Objective of this module was to understand what REST APIs are, and how to make REST API calls. I have already been working with rest API's for a long time, still, this module was a good learning experience for me.
I have shared my notes of this module with some extra research: Link.
Linux Basics 1
This was the most interesting module of this stage, I always preferred Linux for my computer, and I had a basic understanding of how Linux works. After this module, I love Linux more.
Deploy app server in AWS
Objective of this module was to help participants to launch their first virtual server in AWS, deploy the app backend server, and connect the mobile app to the app backend server. I must say, with 0 experience this module was most challenging for me.
More the challenge, better the learning experience.
Git Basics

It's tough to imagine software development without version control systems. Git Basics bytes was a complete learning path for beginners to get proficient with git and GitHub. Its hands-on experience equipped with GitLab and Gitpod made the whole process very smooth.
HTML and CSS

HTML and CSS are the fundamentals of frontend development. The objective of this module was to get started using HTML for web pages, using CSS to style web pages, and create finally create the first static website.
QPrep JavaScript
JavaScript is one of the most famous languages among developers. In this module, we learned Javascript ES6 features, and we practiced them by solving several problems. For every problem, we had to construct a solution coded in JavaScript on Crio's editor.
QProfile
The final byte, and the most amazing one as well. This module was all about implementing what we learned in previous bytes. Here we were supposed to construct a portfolio website fetching details from our GitHub through APIs and host it on Netlify & Heroku. We were equipped with materials and the format of the profile.
Check out my Q profile, Anubhav Singhal's Qprofile

Other activities

Stage 1 was a lot of fun, we had a lot of learning experiences and we had few fun activities as well. Some of them are listed below:

Speaker Sessions
Crio team onboarded some of the great influencers from the tech industry such as Binny Bansal (Co-founder of Flipkart), Vivek Ravishankar (Co-founder of Hackerrank), etc. It was great hearing from such eminent personalities and learn about their experience.
Meme war
One of the slack channels was filled with memes made by thousands of developers from various parts of the country. It was great to see how hilarious they were. I didn't make any meme but surely enjoyed a lot.
Sherlock
A puzzle game, with interesting problems about the internet and it's working. I did participate in this, and I wish it had more level to solve, cause I had a lot of fun doing it.

There were more activities since they weren't mandatory, I only participated in these two as per my convenience.

Badge and Achievements

I received two batches,

Disciplined Rooster for showing up every day, and,
Unstoppable Bull for completing all tasks with excellence.

Conclusion

I wasn't sure while applying to this, but it really worked out to be great.

I connected with some good devs across the country, who helped me whenever I was stuck somewhere.
I polished my existing skill-set, and ofcourse acquired new skills as well.
I always wanted to have a portfolio website, now I have one: Anubhav Singhal's Qprofile
Community on the slack channel was just amazing.
The best start to 2021 for sure.

Thanks for reading, I hope my insights were helpful to you.
Find me on various platforms: LinkedIn | Twitter | GitHub

Happy Coding

Cloud Computing: Beginners guide

Anubhav Singhal — Mon, 25 Jan 2021 06:14:48 +0000

We all have been witnessing this buzz about cloud services, tech giants such as Google, Amazon, Microsoft, etc. releasing their cloud service platform such as GCP, AWS, Azure, etc. Every major company is hiring cloud developers.

In this article, I'll be covering some basic understanding of cloud computing, how it is changing the tech industry, and why every developer should (must) be skilled with it.

If you need light in your room, what are you going to do?

Simple, just switch on the lights. In the worst case, you're going to take an electricity connection, install the bulb and never worry about it again. What you're not going to do is, produce electricity, pass it from different stations to your room, manufacture a bulb, etc.

We don't care about the production, delivery, or maintenance of the power, we just pay for those services and let the service provider handle this professionally. This is something that cloud computing does for software developers.

Cloud Computing

The concept of cloud computing is very much similar to the example we discussed earlier. Cloud computing is the on-demand availability of computer system resources, especially data storage and computing power, without direct active management by the user.

Computing services are delivered through the internet, instead of maintaining CPUs and storage in your data center, you rent them for the time that you need, and maintenance is on the cloud service providers.

Benefits of Cloud Computing

Global reach: Available in numerous locations, which gives you fast online reach to everyone in the world.
Scalability: Add/Remove extra CPUs, Memory, Server, etc. as per your need, whenever you want.
Elasticity: Service providers automatically use extra resources when needed, or remove extra resources when not needed.

Pay as you use: Pay only for what you use, and how long you use, with zero maintenance cost.
Updates: Since everything is maintained by a cloud service provider, so if any new tech is available, the service provider gets it for you. If anything fails, the service provider fixes it for you.

Types of Cloud Computing

Cloud computing types are based on service deployment models which let you choose the level of control over your information and types of services you need to provide. These are generally in three types:

Iaas: Infrastructure as a Service, requires the most user management of all the cloud services. The user is responsible for managing the operating systems, data, and applications.
Paas: Platform as a Service, requires less user management. The cloud provider manages the operating systems, and the user is responsible for the applications and data they run and store.
Saas: Software as a Service, requires the least amount of management. The cloud provider is responsible for managing everything, and the end-user just uses the software.

Here is an informative image that will help you to visualize difference between these three forms of cloud services, with your level of control.

Here are some of the basic examples of different cloud service providers with their different types of cloud services.

Future of Cloud Computing

If you are a software developer or aspired to be one, you surely would have understood how significant these cloud services are, for your career.
As per 2020, Annual cloud infrastructure has managed to produce revenue of $111 Billion, where AWS itself contributes to 33% followed by Azure at 18% and GCP at 9%.
According to an article at Robert Half, DevOps and Cloud development is one of the highest-paid IT jobs of 2021.

This was an introductory article on Cloud Computing. If you find this useful, follow me for series of articles on cloud services and software development.

Find me on different platforms: LinkedIn | Twitter | GitHub

Happy Coding

What exactly is API?

Anubhav Singhal — Wed, 13 Jan 2021 05:15:48 +0000

APIs are one of the most significant parts of software development, every developer must be well versed with them. I have been working as a golang backend engineer for about a year now, have constructed plenty of APIs for various projects.

Recently, I came through an interesting session on APIs at Crio: Learn by Doing and am sharing its notes with DevCommunity. Let's get it started!

What is an API?

API stands for Application Programming Interface, is a set of functions that allows applications to access data and interact with external software components, operating systems, or microservices.

In simple words, an API is like a waiter in a restaurant. You don’t go into a cafe and walk straight into the kitchen to tell the chef what you wanna eat. The waiter does that for you, and that’s exactly what an API is - with the client being you, the customer, and any resource that can send data, being the chef.

Benefits of using APIs

Security: While using an API, client-side and server-side application works independently, and they communicate through API, so if anyone tries to hack into the client-side app, the server stays unaffected and secured.
Flexibility: APIs allow content to be embedded from any site or application more easily. For e.g. an API written in GO can be used by Node.js/Django.
Efficiency: When access is provided to an API, the content generated can be published automatically and is available for every channel. It allows it to be shared and distributed more easily.
Innovation: With an API, an application layer can be created which can be used to distribute information and services to new audiences which can be personalized to create custom user experiences.

REST API

REST stands for Representational State Transfer, it is the most popular web API architecture. They follow a client-server model where one software program sends a request and the other response with some data.

These APIs generally receive a response in JSON format, it's a standard format that is easily "understandable" by applications and can be handled well in most languages. For e.g. Ruby app can easily use JSON response from Java sever.

JSON stand for JavaScript Object Notation, it is a lightweight data-interchange format. It is easy for humans to read and write. It is easy for machines to parse and generate. Read more about it here

There are several other forms of APIs (SOAP, XML-RPC, JSON-RPC, etc.), we'll limit our discussion to REST only. For more info, Click here

REST != HTTP

A lot of people prefer to compare HTTP with REST. REST and HTTP are not same.

In the REST architectural style, data and functionality are considered resources and are accessed using Uniform Resource Identifiers (URIs). The resources are acted upon by using a set of simple, well-defined operations. The clients and servers exchange representations of resources by using a standardized interface and protocol – typically HTTP.

Resources are decoupled from their representation so that their content can be accessed in a variety of formats, such as HTML, XML, plain text, PDF, JPEG, JSON, and others. Metadata about the resource is available and used, for example, to control caching, detect transmission errors, negotiate the appropriate representation format, and perform authentication or access control. And most importantly, every interaction with a resource is stateless.

API Request & Response

REST API request generally consists of Method, Body(auth and other parameters), and Host. Here is a sample request that I have been working on recently.

As stated earlier, REST API responses generally in JSON format. Here is a sample response to the above API requests.

Note: To get a similar response from the previous request, you'll have to add an API key: and API secret.

For more information, goto reastfulapi.net

I hope you have a good understanding of APIs now. If this article helped you, support it, and share it among your peers.

Connect with me: LinkedIn | Twitter | GitHub

Happy Coding!

HTTP Fundamentals

Anubhav Singhal — Mon, 11 Jan 2021 07:46:13 +0000

I have been working as a golang backend engineer for about a year now, have been playing with HTTP response and requests on daily basis. Understanding HTTP is the core of application development, and every developer should be crystal clear with them.

Recently, I came through an interesting session on HTTP at Crio: Learn by Doing and am sharing its notes with DevCommunity. Let's get it started!

What is HTTP?

HTTP stands for HyperText Transfer Protocol. It is, like the name suggests, a set of rules for querying the web.

As we humans communicate with each other through a common language following a set of grammatical rules. On the web, clients and servers communicate through requests and responses, that follow a set of rules called HTTP.

The client makes an HTTP request that contains methods, headers, body, etc., and when the server receives that request, it responds to the client with an HTTP response that contains status, headers, body, etc.

HTTP Methods

Like our language has different kinds of statements(Interrogative, Informative, Imperative, etc.), there are several types of HTTP methods of clients requests with specific roles. Some of the most important methods are:

GET
POST
PUT
DELETE

GET

GET methods are the HTTP requests which a client makes to a server for getting resources from the server. For e.g., whenever you open Google in your browser, it makes a GET request to google's server.

POST

POST methods are the HTTP requests which a client makes for sending new data to a server. For e.g. when you add a tweet, your application makes a POST request to twitter's server.

PUT

PUT methods are almost like POST methods, instead of adding information to a server, they are intended to update existing information on the server. For e.g. when you change your profile pic on Twitter, your application makes a PUT request to the server.

DELETE

DELETE methods are the HTTP requests which a client makes to delete the existing data from the server. For e.g. whenever you delete a tweet on Twitter, your application makes a DELETE request to the server.

There are more HTTP methods, but we'll limit our discussion till here only. Click here to learn more.

HTTP status codes

HTTP Status codes are part of the HTTP Response. It helps the client understand what happened to the request. It's a 3 digit numeric code(like 404, 502), which has an appropriate definition in HTTP bias, a reason phrase is also returned along with it. For eg. 404: Page not found!

There are 5 types of HTTP status codes based on the starting digit:

1xx: Information Responses
2xx: Successful Responses
3xx: Redirect Responses
4xx: Client Errors
5xx: Server Errors

check more about various status codes here .

How to make an HTTP request?

Instead of your browser, there are several other ways to make HTTP requests and accept responses from servers, these are incredibly useful for developers to test their applications before deploying. We'll look into 2 most popular way of making HTTP requests:

Using CLI
Using GUI

Making HTTP requests with CLI

cURL is like a web-browser, but for the command line. Use this link to download and install cURL in your machine. You can follow this tutorial to understand how to use cURL commands to make HTTP requests.

Making HTTP requests with GUI

There are various software that are available for making HTTP requests, either of them can be used. Postman is one of the most famous apps for it, you can install it on your machine using this link.

I hope you have a good understanding of HTTP basics now. If this article helped you, support it, and share it among your peers.

Connect with me: LinkedIn | Twitter | GitHub