Demystifying REST APIs

Recently, I conducted interview preparations with junior developers, during which we discussed REST APIs. While many developers use REST APIs daily for tasks like CRUD operations or building apps with external databases, not everyone fully understands what they are and how they work. This article aims to explain REST APIs in a simpler and clearer way.

In this article, we'll break down the concept of REST APIs in simple terms, so you can understand how they work and why they're so important in modern web development.

What is a REST API(Representational State Transfer Application Programming Interface)?

The more common definition is that it's a set of rules and conventions for building and interacting with web services. At its core, a REST API allows different software applications to communicate with each other over the internet.

A simple definition:
A REST API is a way for two computer systems to talk to each other over the internet.

It's like a waiter in a restaurant. You (the client) can ask the waiter (the API) for things (like food from the menu) by using a specific language (like HTTP). The waiter then goes to the kitchen (the server), gets the food (the data), and brings it back to you.
REST APIs make it easy for different systems to work together and share information.

Key Principles of RESTful APIs:

1. Stateless:
Each request from a client to a server must contain all the information necessary to understand the request.
When a client (like a web browser or a mobile app) sends a request to a server, it needs to include everything the server needs to understand and fulfill that request. This includes the type of request (e.g., GET for retrieving data, POST for sending data to be processed), the URL of the resource being requested, any parameters or data needed for the request, and any authentication credentials if required.

Each request from the client is treated as a standalone request, independent of any previous requests. The server does not rely on any information from previous requests to process the current request.

By ensuring that each request contains all the necessary information and that the server does not rely on any previous requests, REST APIs make each request independent. This independence allows for better scalability and reliability, as the server can process requests in any order and can easily distribute requests across multiple servers if needed.

2. Client-server:
The client and server should be separate from each other, and the communication between them should be based on standard protocols like HTTP.
This means that the client (like a web browser or a mobile app) and the server (which stores and manages data) should be separate and should communicate using a standard language called HTTP.

Imagine the client is a person ordering food at a restaurant, and the server is the kitchen. The client tells the server what they want using a standard menu (HTTP), and the server prepares the food accordingly. The client doesn't need to know how the food is prepared, and the server doesn't need to know who ordered it - they just follow the standard way of communicating.

This separation and standardization make it easier for different clients and servers to work together, just like how different restaurants can use the same menu format to take orders.

3. Uniform interface:
This is a central constraint of REST. It means that the API should have a consistent and predictable interface. Resources should be identified in requests, and the representation of a resource should be separate from its internal implementation.

Consistent and predictable interface: A RESTful API should be like a well-organized library, where all the books are arranged in a standard way and easy to find. Similarly, the API should have a clear and organized structure that makes it easy for software (like apps or websites) to understand and use.

Identifying resources: In the library analogy, each book is a "resource." When you want to find a book, you need to know its title or where it's located. Similarly, in a RESTful API, resources are identified by unique addresses (URLs) that clients use to access them.

Separation of representation and implementation: Imagine if the library changed how it stores books (implementation), but the way you search for them or borrow them (representation) stayed the same. This is similar in a RESTful API, where the internal workings of the server can change, but how clients interact with it remains consistent.

4. Cacheable:
Responses from the server should be explicitly marked as cacheable or non-cacheable to improve performance.

When you visit a website, your browser saves some of the website's data so that if you visit the same site again, it can load faster. This saved data is called a "cache." In a similar way, servers can tell your browser whether it's okay to save (cache) certain parts of their responses.

When a server marks a response as cacheable, it tells your browser that it's okay to save that response for a certain amount of time. This means that if you visit the same page again, your browser can load it from the cache instead of downloading it again from the server. This can make websites load faster and reduce the load on the server.

On the other hand, if a server marks a response as non-cacheable, it means that your browser shouldn't save that response. This is useful for dynamic content that changes frequently and shouldn't be cached.

In simple terms, marking responses as cacheable or non-cacheable helps improve performance by allowing browsers to save certain parts of a website and avoid downloading them again, making the browsing experience faster for users.

5. Layered system:
The architecture should be designed in layers, allowing each layer to only know about the layer immediately beneath it. This improves scalability and simplifies implementation.

Let's consider a web application like Facebook. It can be divided into several layers:

Presentation Layer: This is the part of Facebook that you interact with - the user interface (UI) where you see your news feed, post updates, and chat with friends.

Application Layer: This layer handles the business logic of Facebook. It decides how to process your requests, such as creating a new post or sending a friend request.

Data Layer: This layer deals with storing and retrieving data. It includes databases where your posts, photos, and friend connections are stored.

In this example, each layer is designed to only communicate with the layer directly below it. For instance, the presentation layer sends a request to the application layer when you want to post something. The application layer then processes the request and may interact with the data layer to store the new post.

This layered approach makes it easier to maintain and scale Facebook. If they want to change how posts are displayed (presentation layer), they can do so without needing to modify the logic for creating posts (application layer) or how posts are stored (data layer).

Why RESTful APIs are Important?

RESTful APIs are popular in web development because they are simple, lightweight, and scalable. They allow developers to build APIs that can be consumed by various clients, such as web browsers, mobile apps, and IoT devices. RESTful APIs make it easy for different systems to work together and share information, which is essential in today's interconnected world.

In conclusion, REST APIs are a fundamental part of modern web development. By understanding the key principles of RESTful APIs, you'll be better equipped to build and interact with web services, taking your development skills to the next level.