Quick Backend Handbook for Frontend Developers

As a frontend engineer, possessing a certain level of backend knowledge is crucial. In the ever-evolving landscape of web application development, frontend engineers need to comprehensively understand the backend domain, including database management, security, the use of web frameworks, AOP programming paradigm, and the features of commonly used languages and frameworks. This manual will provide you with a brief yet comprehensive overview of backend knowledge, helping you better grasp the key points of backend development.

Databases

1. Database Selection

Choose the type of database that suits the project’s requirements, including relational databases (such as MySQL, PostgreSQL) and NoSQL databases (such as MongoDB, Redis). Understand their characteristics, advantages, and disadvantages to ensure the selection of a database that aligns with the project’s needs.

2. Database Design

Learn to conduct proper database design, including table normalisation, index optimisation, and relationship modeling. Good database design is crucial for application performance and scalability.

In most cases, achieving the third normal form is a good baseline. This helps ensure clarity in data structure and minimizes redundancy. If the project demands high performance, moderate redundancy may be considered to reduce join operations. In such cases, reaching Boyce-Codd Normal Form (BCNF) or higher is advisable.

3. Database Optimisation

In MongoDB, indexing plays a crucial role in performance optimisation, speeding up data queries and improving retrieval efficiency. Here are some key advantages of MongoDB indexes for performance optimisation:

4. Hardware

The read and write speeds of storage media are influenced by various factors, including hardware types, interface standards, cache sizes, and more. Here’s a comparison of the read and write speeds of common storage media:

Understanding the order of magnitude of hardware speeds can help strike a balance between read and write performance and storage space when designing databases. For example, storing hot data on SSDs and cold data on SATA hard disks can achieve a balance between performance and cost.

Security

The backend serves as the last line of defense, ensuring data security. When designing backend applications, various aspects of security, including data encryption, user authentication, and access control, need to be considered. Understanding common security issues and solutions helps in designing secure backend applications.

1. Data Encryption

Common encryption algorithms play a crucial role in securing data during transmission and storage. Here are some commonly used encryption algorithms and their applications on the web:

2. Common Attacks

When designing backend applications, it’s essential to consider common attack methods, including SQL injection, XSS attacks, CSRF attacks, etc. Here are some common attack methods and preventive measures:

Web Frameworks

1. Choosing the Right Backend Framework

Understand popular backend frameworks such as Express (Node.js), Django (Python), and Spring Boot (Java), and select a framework that suits the project requirements.

2. Restful API

Restful API is a design style for building scalable web services. Here are some common Restful API design principles:

A simple way to judge whether an API design is Restful is to check if there are verbs in the URL. If there are, it may not be Restful.

3. ORM (Object Relational Mapping)

ORM is a programming technique that converts data between incompatible type systems, such as object-oriented programming languages and relational databases. Here are some common ORM frameworks:

AOP (Aspect-Oriented Programming)

While the CRUD operations discussed earlier cover the basics, real-world development often involves considerations such as logging, caching, transactions, and more. These concerns can be addressed using Aspect-Oriented Programming (AOP).

AOP is a programming paradigm designed to improve code modularity and maintainability by separating cross-cutting concerns from the core business logic. Cross-cutting concerns refer to functionalities scattered throughout the application that are unrelated to the core concerns, such as logging, transaction management, security, etc.

from fastapi import FastAPI, Depends, HTTPException
from fastapi.security import OAuth2PasswordBearer
from jose import JWTError, jwt
from typing import List

app = FastAPI()

# Sample JWT token validation function
async def get_current_user(token: str = Depends(OAuth2PasswordBearer(tokenUrl="token"))):
    credentials_exception = HTTPException(
        status_code=401,
        detail="Could not validate credentials",
        headers={"WWW-Authenticate": "Bearer"},
    )
    try:
        payload = jwt.decode(token, "secret_key", algorithms=["HS256"])
        username: str = payload.get("sub")
        if username is None:
            raise credentials_exception
    except JWTError:
        raise credentials_exception

    return username

# AOP-style logging aspect
def log_request(endpoint):
    async def wrapper(*args, **kwargs):
        print(f"Received request to {endpoint.__name__}")
        response = await endpoint(*args, **kwargs)
        print(f"Request to {endpoint.__name__} completed")
        return response
    return wrapper

# Applying AOP aspect to an endpoint
@app.get("/items/", response_model=List[str])
@log_request
async def read_items(current_user: str = Depends(get_current_user)):
    return [{"item": "Item 1"}, {"item": "Item 2"}]

In the example above, the log_request function acts as an AOP aspect, responsible for logging the start and end of a request. This aspect is applied to the /items/ route using the @log_request decorator. This way, we can add cross-cutting concerns like logging without modifying the core business logic.

Synchronous, Asynchronous, and Multi-threading Thread Pool

Synchronous vs. Asynchronous

Examples of Asynchronous Programming in Javascript

Callback Function:

function fetchData(callback) {
  // Simulating asynchronous operation
  setTimeout(() => {
    const data = 'Async Data';
    callback(data);
  }, 1000);
}

fetchData((result) => {
  console.log(result); // Handling the retrieved data in the callback function
});

Promise:

function fetchData() {
  return new Promise((resolve, reject) => {
    // Simulating asynchronous operation
    setTimeout(() => {
      const data = 'Async Data';
      resolve(data);
      // Alternatively, reject(new Error('Asynchronous operation failed'));
    }, 1000);
  });
}

fetchData()
  .then((result) => {
    console.log(result); // Handling the retrieved data in the 'then' method of the Promise
  })
  .catch((error) => {
    console.error(error); // Handling errors in the Promise
  });

Async/Await:

async function fetchData() {
  return new Promise((resolve) => {
    // Simulating asynchronous operation
    setTimeout(() => {
      const data = 'Async Data';
      resolve(data);
    }, 1000);
  });
}

async function getData() {
  try {
    const result = await fetchData();
    console.log(result); // Handling the retrieved data in the 'async/await' context
  } catch (error) {
    console.error(error); // Handling errors in asynchronous operations
  }
}

getData();

Multithreading and Thread Pool

Threads:

A thread is the smallest unit that the operating system can schedule for execution, consisting of a thread ID, program counter, register set, and stack. In a multithreaded environment, multiple threads share common resources such as code segments and data segments, but each thread has its own registers and stack for storing thread-specific data.

Thread Pool:

A thread pool is a mechanism for managing and reusing threads to improve thread utilization and reduce the overhead of thread creation and destruction. A thread pool consists of a certain number of threads that wait for task allocation and execution. When a task arrives, the thread pool assigns a thread to execute the task, and upon completion, the thread is not destroyed but returned to the thread pool, awaiting the next task. This approach avoids the frequent creation and destruction of threads, improving system performance and responsiveness.

Docker Principles

Docker leverages certain features of the Linux kernel, such as Namespaces and Control Groups (Cgroups). Namespaces isolate processes, networks, file systems, etc., while Cgroups restrict and monitor resource usage, such as CPU and memory. Docker utilizes UnionFS to implement layered container images, providing a lightweight, portable containerization platform to simplify application deployment, management, and scalability.

Docker’s core concepts include Images, Containers, Repositories, and Services.

Images: A Docker image forms the foundation of a container, containing all the necessary files, libraries, and dependencies required to run an application. Images are immutable, ensuring consistent runtime environments across different environments.

Containers: Containers are instances of Docker images. Each container is isolated, with its own file system, process space, and network interface. Containers offer a lightweight, portable runtime environment.

Dockerfile: A Dockerfile is a text file used to define the process of building a Docker image. It allows developers to specify the application’s environment, dependencies, and how to run it.

Networking and Port Mapping: Docker enables communication between containers and the host or other containers. Each container has its own network namespace, and Docker provides network drivers (e.g., bridge, host, overlay) to configure communication between containers. Docker also supports port mapping, allowing internal container ports to be mapped to ports on the host for external access.

Container Orchestration: Docker provides container orchestration tools like Docker Compose and Kubernetes. Docker Compose is used to manage and coordinate the deployment, scaling, and updating of multiple containers. A simple docker-compose.yml file may look like:

version: '3'
services:
  web:
    image: nginx
    ports:
      - "8080:80"
  db:
    image: postgres

Docker Repositories: Docker repositories serve as centralized storage and management for Docker images. They allow users to upload and download Docker images, facilitating sharing and deployment of applications across different environments. Docker officially provides the public Docker Hub repository, where users can find a plethora of official and community-maintained images. Additionally, users can set up their private Docker repositories to meet specific needs or enhance security. Here are some commonly used repositories:

Docker Services: Docker services provide an abstraction layer for defining and running distributed applications within Docker. Services can encompass multiple instances of containers running on different nodes, enabling load balancing and high availability. Docker services are often used in conjunction with Docker Compose, where a docker-compose.yml file defines the service configuration.

References

https://fastapi.tiangolo.com/

https://spring.io/projects/spring-boot/

https://www.prisma.io/

https://www.sqlalchemy.org/

https://beanie-odm.dev/

https://hub.docker.com/