Interview Preparations

REST

REST is an architectural style for designing networked applications. A RESTful API (Application Programming Interface) is an API that adheres to the principles of REST. RESTful APIs are commonly used in web development to allow communication between different systems and enable clients (such as web browsers or mobile apps) to interact with server resources.

Here are some key concepts related to RESTful APIs:

1. Resources:

In REST, everything is considered a resource, which can be an object, data, or service. Each resource is uniquely identified by a URI (Uniform Resource Identifier).

2. HTTP Methods (CRUD operations):

RESTful APIs use standard HTTP methods to perform operations on resources. The primary HTTP methods used in REST are:
- GET: Retrieve a resource.
- POST: Create a new resource.
- PUT: Update a resource (or create if it doesn't exist).
- PATCH: Partially update a resource.
- DELETE: Delete a resource.

3. Representation:

Resources are represented in different formats such as JSON, XML, or HTML. Clients interact with these representations rather than directly with the resource.

4. Stateless Communication:

Each request from a client to a server must contain all the information needed to understand and fulfill the request. The server does not store any information about the client's state between requests.

5. Stateless Server:

The server does not store any information about the client's state between requests. Each request from a client contains all the information needed to understand and process the request.

6. Uniform Interface:

RESTful APIs have a uniform and consistent interface that simplifies communication between clients and servers. This includes a standardized way of representing resources, using standard HTTP methods, and having a consistent URI structure.

Example Usage:

Consider a simple RESTful API for managing a collection of books:

GET /books: Retrieve a list of all books.
GET /books/id: Retrieve details of a specific book.
POST /books: Create a new book.
PUT /books/id: Update the details of a specific book.
DELETE /books/id: Delete a specific book.

How it's Used:

HTTP Requests:
- Clients make HTTP requests to the server using various methods (GET, POST, PUT, PATCH, DELETE).
URI (Uniform Resource Identifier):
- Each resource is identified by a unique URI.
Data Representation:
- Resources are represented in a standard format (JSON or XML) in the request and response bodies.
Stateless Communication:
- Each request is independent and contains all the information needed for the server to understand and fulfill it.
HTTP Response Codes:
- Servers respond with appropriate HTTP status codes to indicate the success or failure of the request.

Benefits of RESTful APIs:

Simplicity and Scalability: RESTful APIs are simple and easy to understand, making them scalable and adaptable.
Statelessness: Stateless communication simplifies server and client implementations.
Uniform Interface: Consistent design principles make it easy for developers to work with APIs.
Standardization: Use of standard HTTP methods and status codes.

RESTful APIs are widely used in modern web development for building scalable, flexible, and interoperable systems. They provide a standardized way for different applications and services to communicate over the web.

HTTP methods

used to interact with web resources?

HTTP methods, also known as HTTP verbs, define the actions that can be performed on resources identified by a URL. They indicate the desired operation to be performed on the identified resource. Here are some of the commonly used HTTP methods:

1. GET:

Purpose: Retrieve data from the server.
Example: Fetching the content of a web page, requesting information from an API.

2. POST:

Purpose: The POST method is used to submit data to be processed to a specified resource. It is often used to create a new resource on the server.
Idempotence: POST requests are not idempotent. Making the same POST request multiple times may result in the creation of multiple resources or different resource representations.
Use Cases:
- Creating a new record, entity, or resource on the server.
- Submitting form data.
- Uploading a file.
Example:
```
POST /api/users
Content-Type: application/json
 
{
  "name": "John Doe",
  "email": "john@example.com"
}
```
- Use POST when you want to create a new resource on the server without specifying its identifier. The server typically generates a new identifier for the resource.
- POST is suitable when the creation of a resource involves processing on the server or when the server is responsible for assigning identifiers.

3. PUT:

Purpose: The PUT method is used to update a resource on the server. If the resource does not exist, PUT can create it.
Idempotence: PUT requests are idempotent. Making the same PUT request multiple times should have the same effect as making it once.
Use Cases:
- Updating an existing resource with a specific identifier.
- Creating a new resource with a specific identifier if it does not exist.
Example:
```
PUT /api/users/123
Content-Type: application/json
 
{
  "name": "Updated Name",
  "email": "updated.email@example.com"
}
```
- Use PUT when you want to update an existing resource or create a new resource with a specific identifier.
- PUT is suitable when the client knows the specific identifier of the resource it wants to update or create.

4. PATCH:

Purpose: Apply partial modifications to a resource.
Example: Updating specific fields of an existing resource.

5. DELETE:

Purpose: Delete a specified resource.
Example: Deleting a user account, removing a record from a database.

6. HEAD:

Purpose: Retrieve only the headers of a resource without the body.
Example: Checking if a resource has been modified without fetching the entire content.

7. OPTIONS:

Purpose: Describe the communication options for the target resource.
Example: Used to determine which HTTP methods are allowed on a particular resource.

8. TRACE:

Purpose: Echoes the received request so that a client can see what (if any) changes or additions have been made by intermediate servers.
Example: Diagnosing network-related issues.

9. CONNECT:

Purpose: Establishes a tunnel to the server identified by a given URI.
Example: Used in the context of the HTTP CONNECT method for creating a secure connection.

10. OPTIONS:

Purpose: Describes the communication options for the target resource.
Example: Used to determine which HTTP methods are allowed on a particular resource.

Additional Methods (Not as Common):

LOCK, UNLOCK: Used for resource locking mechanisms.
PROPFIND, PROPPATCH: Used for WebDAV to retrieve properties, or to set and remove properties on resources.
MKCOL: Used to create collections (directories) on the server.
COPY, MOVE: Used for copying or moving resources from one URI to another.

How They Are Used:

GET: Used for safe and idempotent retrieval of resources.
POST: Used for non-idempotent operations and submitting data to be processed.
PUT: Used for idempotent update or creation of a resource.
PATCH: Used for partial updates to a resource.
DELETE: Used for deleting a resource.

These HTTP methods play a crucial role in RESTful web services, where they align with the standard CRUD (Create, Read, Update, Delete) operations. Understanding the semantics and appropriate use of each method is essential for designing a well-architected and efficient web application or API.

HTTP status codes

HTTP status codes are three-digit numbers returned by a server in response to a client's request made to the server. These codes indicate the result of the request or provide information about the status of the server or the requested resource. HTTP status codes are grouped into different ranges, and the range from 200 to 599 is commonly used. Here's an overview of the HTTP status codes in this range:

2xx Success

200 OK:
- The request was successful, and the server has returned the requested data.
- Example: Successful retrieval of a web page.
201 Created:
- The request was successful, and a new resource was successfully created as a result.
- Example: After submitting a form, a new record is created.
202 Accepted:
- The request has been accepted for processing, but the processing is not complete.
- Example: Asynchronous operations where the result is not immediately available.
204 No Content:
- The server successfully processed the request, but there is no additional content to send back.
- Example: Deleting a resource.

3xx Redirection

301 Moved Permanently:
- The requested resource has been permanently moved to a new location, and future requests should use the new URL.
- Example: URL redirection after a website restructuring.
302 Found (or Moved Temporarily):
- The requested resource has been temporarily moved to a different location, and the original URL should still be used for future requests.
- Example: Temporary redirection.
304 Not Modified:
- The client's cached copy of the resource is still valid, and the server does not need to send a new copy.
- Example: Used in conjunction with conditional GET requests.

4xx Client Errors

400 Bad Request:
- The server could not understand the request due to malformed syntax or invalid request message framing.
- Example: Malformed request parameters.
401 Unauthorized:
- The request requires user authentication. The user must provide credentials to access the requested resource.
- Example: Accessing a protected API without authentication.
403 Forbidden:
- The server understood the request, but it refuses to authorize it.
- Example: Accessing a resource for which the user does not have permission.
404 Not Found:
- The requested resource could not be found on the server.
- Example: Accessing a URL that doesn't exist.

5xx Server Errors

500 Internal Server Error:
- A generic error message indicating that an unexpected condition has occurred on the server.
- Example: An unhandled exception occurred during the execution of a server-side script.
501 Not Implemented:
- The server does not support the functionality required to fulfill the request.
- Example: Using an HTTP method that is not implemented on the server.
502 Bad Gateway:
- The server, while acting as a gateway or proxy, received an invalid response from an upstream server.
- Example: Proxy server receiving an invalid response from the upstream server.
503 Service Unavailable:
- The server is currently unable to handle the request due to temporary overloading or maintenance of the server.
- Example: Server overloaded and cannot handle additional requests at the moment.

These are some of the commonly used HTTP status codes between 200 and 600, representing various outcomes of client-server interactions. The first digit of the status code indicates the general category of the response, while the following two digits provide more specific information.

Communication Between Frontend and Backend:

Several techniques are used for communication between the frontend and backend:

REST APIs (Representational State Transfer):
- REST is an architectural style for designing networked applications. RESTful APIs provide a standardized way for the frontend to interact with the backend over HTTP. They use standard HTTP methods (GET, POST, PUT, DELETE) for operations and often communicate using JSON as the data format.
AJAX (Asynchronous JavaScript and XML):
- AJAX is a technique that allows the frontend to make asynchronous requests to the backend without reloading the entire page. It enables updating parts of a webpage dynamically without a full page refresh. Modern applications often use AJAX to fetch data and update the UI in real-time.
Websockets:
- Websockets provide a bidirectional communication channel between the frontend and backend. Unlike traditional HTTP requests, websockets allow real-time, two-way communication. This is especially useful for applications that require instant updates, such as chat applications or live data feeds.

In summary, the frontend and backend of a web application work together to provide a seamless user experience. The backend handles server-side logic, interacts with databases, and processes requests, while the frontend handles the user interface and communicates with the backend to fetch or update data. Technologies like REST APIs, AJAX, and websockets facilitate this communication, enabling dynamic and responsive web applications.

API Call Testing