DEV Community: Muhammad Sufiyan Baig

5 Python Tricks Every Backend Dev Should Know

Muhammad Sufiyan Baig — Thu, 25 Jun 2026 17:30:44 +0000

As backend developers, we're constantly seeking ways to optimize our workflow and improve the quality of our code. One of the most effective methods to achieve this is by leveraging lesser-known Python features that can significantly enhance our development routine. Despite being experienced developers, many of us may not be aware of the various Python tricks that can boost our productivity and streamline our code. In this article, we'll delve into five key Python features that every backend developer should know, exploring how they can be incorporated into daily development to improve efficiency and code quality.

Efficient String Formatting with F-Strings

F-strings were introduced in Python 3.6 as a more efficient and readable way of formatting strings. They provide a concise and expressive syntax for embedding expressions inside string literals, using the f prefix before the string. However, many developers are not utilizing the full potential of f-strings by combining them with format specs. This allows for more precise control over the formatting of values, making the code more readable and maintainable. For example:

name = "John"
age = 30
print(f"{name} is {age} years old")  # Basic f-string usage
print(f"{name} is {age:02d} years old")  # Using format spec for padding

In the above example, the :02d format spec is used to pad the age value with a leading zero if it's less than 10. This demonstrates how f-strings can be used with format specs to create more sophisticated string formatting.

Simplified Assignments and Exception Handling

The walrus operator (:=) was introduced in Python 3.8 as a way to simplify assignments within conditional statements. This operator allows you to assign a value to a variable as part of a conditional statement, making the code more concise and readable. Another useful feature for exception handling is contextlib.suppress, which provides a context manager that suppresses specific exceptions within a block of code. This can be particularly useful when working with external libraries or APIs that raise exceptions that you want to ignore. Here's an example:

from contextlib import suppress

with suppress(FileNotFoundError):
    with open("example.txt", "r") as file:
        content = file.read()

if (n := len(content)) > 10:
    print(f"Content length: {n}")

In this example, the walrus operator is used to assign the length of the content string to the variable n within the conditional statement. The contextlib.suppress context manager is used to suppress the FileNotFoundError exception that might be raised when trying to open the file.

Optimizing Data Storage with Dataclass Slots

Dataclasses were introduced in Python 3.7 as a way to simplify the creation of classes that mainly contain data. One of the lesser-known features of dataclasses is the use of slots, which can optimize memory usage by preventing the creation of a __dict__ attribute for each instance. This can be particularly useful when working with large datasets or performance-critical code. Here's an example:

from dataclasses import dataclass

@dataclass(slots=True)
class Person:
    name: str
    age: int

person = Person("John", 30)
print(person.name)  # Accessing the name attribute

In this example, the dataclass decorator is used with the slots=True argument to prevent the creation of a __dict__ attribute for each instance of the Person class. This can help optimize memory usage and improve performance.

Improving Performance with Functools.Cache

Functools.cache was introduced in Python 3.9 as a way to cache the results of function calls, improving performance by avoiding redundant computations. This can be particularly useful when working with expensive function calls or recursive algorithms. Here's an example:

from functools import cache

@cache
def fibonacci(n):
    if n < 2:
        return n
    return fibonacci(n-1) + fibonacci(n-2)

print(fibonacci(10))  # Calculating the 10th Fibonacci number

In this example, the functools.cache decorator is used to cache the results of the fibonacci function, avoiding redundant computations and improving performance.

Conclusion and Key Takeaways

Incorporating these five Python features into your daily development routine can significantly improve your workflow and code quality. By utilizing f-strings with format specs, leveraging the walrus operator, implementing contextlib.suppress, optimizing data storage with dataclass slots, and improving performance with functools.cache, you can write more efficient, readable, and maintainable code. Remember to always keep exploring and learning about new Python features and tricks to stay up-to-date with the latest developments in the language. By doing so, you'll be able to take your backend development skills to the next level and deliver high-quality solutions with ease.

REST vs GraphQL: When to Use Which

Muhammad Sufiyan Baig — Mon, 22 Jun 2026 09:13:17 +0000

When designing a web application, one of the most critical decisions developers face is choosing the right API architecture. With the rise of REST (Representational State of Resource) and GraphQL, two popular approaches have emerged, each with its strengths and weaknesses. However, the choice between these two architectures is not a one-size-fits-all solution, and understanding the trade-offs between them is essential for making an informed decision in production environments. In this article, we will delve into the world of REST and GraphQL, exploring their characteristics, use cases, and limitations, to help developers make informed decisions about which approach to use in their applications.

Introduction to REST and GraphQL

REST, introduced by Roy Fielding in 2000, is an architectural style for designing networked applications. It is based on the idea of resources, which are identified by URIs, and can be manipulated using a fixed set of operations. REST is a simple, widely adopted, and well-established approach that has been used in countless web applications. On the other hand, GraphQL, developed by Facebook in 2015, is a query language for APIs that allows clients to specify exactly what data they need, reducing the amount of data transferred over the network. GraphQL provides a more flexible and efficient way of fetching data, especially in complex and nested data scenarios.

REST: Simplicity and Caching

REST's simplicity and caching capabilities make it an attractive choice for simple, read-heavy applications. With REST, each resource is identified by a unique URI, and clients can use standard HTTP methods (GET, POST, PUT, DELETE) to interact with these resources. This simplicity makes it easy to implement and understand, even for developers without extensive experience. Additionally, REST's use of HTTP methods and status codes provides a built-in caching mechanism, which can significantly improve performance in read-heavy applications. For example, a simple REST API for retrieving a list of users might look like this:

GET /users HTTP/1.1
Host: example.com
Accept: application/json

This simplicity and caching capability make REST a great choice for applications with simple data needs, such as a blog or a news website.

GraphQL: Flexibility and Complex Data Handling

GraphQL's flexibility and ability to handle complex, nested data queries make it an ideal choice for applications with intricate data needs. With GraphQL, clients can specify exactly what data they need, reducing the amount of data transferred over the network. This is particularly useful in applications with complex, nested data structures, such as social media platforms or e-commerce websites. For example, a GraphQL query for retrieving a user's profile information, including their friends and posts, might look like this:

query {
  user(id: 1) {
    name
    friends {
      name
      posts {
        title
        content
      }
    }
  }
}

This query allows the client to specify exactly what data they need, reducing the amount of data transferred over the network and improving performance.

Choosing Between REST and GraphQL

The choice between REST and GraphQL depends on the specific requirements of the application and the trade-offs between simplicity, performance, and flexibility. If the application has simple data needs and is read-heavy, REST might be a better choice due to its simplicity and caching capabilities. On the other hand, if the application has complex, nested data needs, GraphQL might be a better choice due to its flexibility and ability to handle complex data queries. Here are some key factors to consider when choosing between REST and GraphQL:

Data complexity: If the application has simple data needs, REST might be a better choice. If the application has complex, nested data needs, GraphQL might be a better choice.
Performance: If the application is read-heavy, REST's caching capabilities might provide better performance. If the application has complex data queries, GraphQL's ability to reduce data transfer might provide better performance.
Development complexity: If the application has a simple architecture, REST might be easier to implement. If the application has a complex architecture, GraphQL might require more development effort.

Conclusion

In conclusion, the choice between REST and GraphQL depends on the specific needs of the application, and understanding the strengths and weaknesses of each approach is essential for making an informed decision in production environments. By weighing the trade-offs between REST and GraphQL, developers can make informed decisions about which approach to use in their applications, leading to more efficient, scalable, and maintainable software systems. Whether you choose REST or GraphQL, the key is to understand the use cases and limitations of each approach and to select the one that best fits your application's requirements. Ultimately, a well-designed API architecture is critical to the success of any web application, and choosing the right approach is the first step towards building a robust, scalable, and maintainable system.

Stop Hand-Tuning ETL Batch Sizes. Use PID Control Instead.

Muhammad Sufiyan Baig — Tue, 31 Mar 2026 11:08:49 +0000

You've done this before. You need to batch-process a large dataset. You pick a chunk size — maybe 1000, maybe 10000 — run a quick test, it looks fine, and you ship it.

Three weeks later, your pipeline is crawling at 15% CPU while you're paying for 8 cores. Or it's randomly OOM-crashing on Tuesday nights when the dataset is slightly wider than usual.

This is the static batch size problem, and it's more expensive than most teams realize.

What's actually happening

When you hard-code a batch size, you're making a bet:

"This number will be optimal on every run, on every machine, under every memory condition, forever."

That's never true. The optimal chunk size is a function of:

Current available memory
How heavy the transformation is for this batch
How many other jobs are competing for resources
Row width variation in the dataset

No static number wins across all these dimensions. You need continuous adaptation.

Enter PID control

PID (Proportional-Integral-Derivative) control is a feedback algorithm used in virtually every control system on the planet — thermostats, drone stabilizers, industrial robots, cruise control.

The idea: measure the current output, compare it to the target, and adjust the control variable to close the gap. Crucially, the adjustment accounts for:

P (Proportional): how far off you are right now
I (Integral): how long you've been off (accumulated error)
D (Derivative): whether you're getting closer or further away

Applied to ETL chunking:

Control Theory	ETL Pipeline
Control variable	chunk size
Measured variable	processing latency per chunk
Setpoint	target latency (e.g., 500ms)
PID output	adjustment to chunk size

If chunks are processing in 200ms and your target is 500ms → the system can handle larger chunks → PID increases chunk size. If chunks are taking 900ms → too slow → PID decreases chunk size.

StreamChunk: PID control for Python data pipelines

# https://pypi.org/project/streamchunk/
pip install streamchunk

Basic usage

from streamchunk import StreamChunker, FileSource

source = FileSource("events.csv")

chunker = StreamChunker(
    source,
    target_latency_ms=500,
    max_memory_pct=80,
    min_chunk_size=100,
    max_chunk_size=50_000,
)

for chunk, meta in chunker:
    result = transform(chunk)
    load(result)
    chunker.report_latency(meta.chunk_id, meta.elapsed_ms)

That's the full loop. No tuning. report_latency() feeds the actual processing time back into the PID controller, which computes the next chunk size. Convergence happens in 5–10 iterations — typically the first few seconds of a run.

The math (briefly)

error(t)  = target_latency_ms - actual_latency_ms
integral += error(t)
derivative = error(t) - error(t-1)

adjustment = kp*error(t) + ki*integral + kd*derivative
new_size   = clamp(current_size + adjustment, min_size, max_size)

Default gains: kp=0.3, ki=0.05, kd=0.1. These are conservative by design — fast convergence without overshoot in bursty workloads.

Memory ceiling: the OOM killer

The PID loop is smooth and gradual. But what if memory spikes suddenly? StreamChunk adds a hard ceiling that overrides PID output entirely:

mem = psutil.virtual_memory().percent
if mem >= max_memory_pct:
    return max(min_chunk_size, current_size // 2)  # immediate halving

This fires every call until memory drops below threshold. Set max_memory_pct=80 and OOM crashes become essentially impossible.

Going parallel

ParallelStreamChunker distributes work across a worker pool — each worker gets its own dataset partition and its own independent PID controller:

from streamchunk import ParallelStreamChunker

parallel = ParallelStreamChunker(
    data=dataset,
    processor=my_transform_func,
    mode="thread",   # or "process"
    n_workers=16,
    target_latency_ms=500,
    max_memory_pct=80,
)

results = parallel.run()
summary = parallel.summary()

print(f"Total rows: {summary['total_rows']:,}")
print(f"p95 latency: {summary['p95_latency_ms']:.1f}ms")
print(f"Throughput: {summary['rows_per_sec']:,} rows/sec")

Thread vs Process: which one?

StreamChunk auto-detects your CPU topology:

from streamchunk import detect_cpu_threads
print(detect_cpu_threads())
# {'logical_threads': 16, 'physical_cores': 8,
#  'recommended_io': 16, 'recommended_cpu': 8}

The recommended_io vs recommended_cpu distinction matters:

mode="thread" + I/O-bound work (Kafka, DB, API): Python's GIL releases during I/O waits. 16 threads = 16 concurrent I/O operations. 12–14× speedup on 8-core/16-thread.
mode="process" + CPU-bound work (transforms, ML inference): GIL bypassed entirely. Uses physical core count only to avoid hyperthreading overhead. 6–7× speedup.

Data sources

StreamChunk ships with five production sources and a clean extension API:

# Any iterable
from streamchunk.sources import GeneratorSource
source = GeneratorSource(range(10_000_000))

# CSV / JSONL (memory-efficient, never loads full file)
from streamchunk.sources import FileSource
source = FileSource("data.jsonl", format="jsonl")

# Apache Kafka (unbounded stream)
from streamchunk.sources import KafkaSource
source = KafkaSource("topic", "broker:9092",
    security_protocol="SSL",
    ssl_cafile="/certs/ca.pem")

# Any SQLAlchemy DB (parameterized, safe)
from streamchunk.sources import DatabaseSource
source = DatabaseSource(
    "postgresql://user:pass@host/db",
    "SELECT * FROM logs WHERE ts > :since",
    params={"since": cutoff}
)

# Paginated REST API
from streamchunk.sources import APISource
source = APISource("https://api.example.com/records",
    headers={"Authorization": f"Bearer {token}"},
    page_param="cursor")

Building a custom source

Only two methods required:

from streamchunk.sources import BaseSource
from typing import List, Any

class RedisStreamSource(BaseSource):
    def pull(self, n: int) -> List[Any]:
        return self.redis.xread({"stream": self._cursor},
                                count=n, block=100)

    def is_exhausted(self) -> bool:
        return self._done

Async support

Drop-in async iteration for asyncio-based pipelines:

async def run_async_pipeline():
    chunker = StreamChunker(source, target_latency_ms=300)
    async for chunk, meta in chunker.aiter():
        await async_transform(chunk)
        chunker.report_latency(meta.chunk_id, meta.elapsed_ms)

Prometheus + Grafana integration

from streamchunk import start_metrics_server

start_metrics_server(port=8000)  # starts HTTP /metrics endpoint

# Metrics exposed:
# streamchunk_rows_total (Counter)
# streamchunk_chunks_total (Counter)
# streamchunk_chunk_size_current (Gauge)
# streamchunk_memory_pct (Gauge)
# streamchunk_latency_ms (Histogram → p50/p95/p99 in Grafana)

YAML config for deployment

# streamchunk.yaml
target_latency_ms: 500
max_memory_pct: 80
min_chunk_size: 100
max_chunk_size: 50000
initial_chunk_size: 1000

chunker = StreamChunker.from_config("streamchunk.yaml", source)

Useful when deploying across multiple environments (dev/staging/prod) with different hardware profiles.

Benchmark results

Tested on 8-core / 16-thread cloud instance, 10 representative pipelines:

Configuration	Throughput
Single-threaded, no PID	Baseline
Single-threaded + PID	~99% of baseline (overhead negligible)
Thread mode, 16 workers	12–14× baseline
Process mode, 8 workers	6–7× baseline

Pipeline-level impact:

Metric	Before	After
Runtime	4 hours	17–25 min
CPU utilization	12–20%	85–95%
OOM crash rate	~24%	~0%
Manual tuning	Required	Eliminated

PID overhead per chunk: ~0.1–0.5ms (dominated by psutil.virtual_memory() call, not the PID math itself).

Design patterns used

This library leans on classical OOP patterns:

Pattern	Where
Iterator Protocol	`StreamChunker.__iter__()` is a standard Python iterator
Observer	`report_latency()` feeds user observations back to controller
Strategy	`mode="thread"/"process"` swaps executor at runtime
Template Method	`BaseSource` ABC — subclasses implement `pull()` and `is_exhausted()`
Factory Method	`StreamChunker.from_config()` — alternative YAML constructor
Facade	`__init__.py` exports — clean public API over complex internals
DTO	`ChunkMetadata` dataclass — immutable per-chunk telemetry bundle

Quick reference

# Install — https://pypi.org/project/streamchunk/
pip install streamchunk
pip install "streamchunk[kafka,database,prometheus,pandas,async]"

# Single worker
StreamChunker(source, target_latency_ms=500, max_memory_pct=80)

# Parallel
ParallelStreamChunker(data, processor, mode="thread", n_workers=16)

# From config
StreamChunker.from_config("config.yaml", source)

# Async
async for chunk, meta in chunker.aiter(): ...

# Metrics server
start_metrics_server(port=8000)

# CPU info
detect_cpu_threads()  # → {logical, physical, recommended_io, recommended_cpu}

# Stats
chunker.stats()  # → {total_rows, total_chunks, avg_latency_ms, p95_latency_ms, ...}

The takeaway

Manual batch size tuning is a solved problem — it just hasn't been widely recognized as a control theory problem yet. PID control gives you:

Automatic adaptation to any machine, any dataset, any workload
Hard memory ceiling that prevents OOM crashes
12–14× throughput on I/O-bound work with zero extra configuration
Prometheus metrics and async support out of the box

StreamChunk v2.0.1 · MIT License · Python 3.8–3.13 · 📦 PyPI

If you've ever woken up at 2 AM because a batch size was wrong, this one's for you.

Drop a comment if you're doing something interesting with ETL pipelines — always curious how others are handling this.

Docker Commands Cheat Sheet

Muhammad Sufiyan Baig — Tue, 04 Feb 2025 09:52:01 +0000

Mastering Docker: A Comprehensive Guide

Introduction

Docker has revolutionized the way developers build, ship, and run applications. It provides a lightweight, portable, and consistent environment to deploy applications seamlessly across different platforms. This guide covers essential Docker concepts and commands, making it easier for you to work with containers effectively.

Basic Docker Concepts

What is Docker?

Docker is an open-source platform that automates application deployment using lightweight, portable containers. It enables developers to package applications along with their dependencies, ensuring consistency across different environments.

Container

A container is a self-sufficient executable unit that includes everything needed to run an application, such as code, runtime, libraries, and dependencies.

Image

An image is a read-only template containing an application and its dependencies. Containers are instantiated from images, allowing multiple containers to run from the same image.

Dockerfile

A Dockerfile is a script that contains a set of instructions to build a Docker image. It specifies the base image, dependencies, environment variables, and commands required to run an application.

Docker Compose

Docker Compose is a tool used to define and manage multi-container applications. It uses a docker-compose.yml file to configure services, networks, and volumes in a structured way.

Volume

A Docker volume is a persistent storage mechanism that allows containers to share and retain data beyond their lifecycle.

Network

Docker networks provide a way for containers to communicate securely. Types include:

Bridge (default) - Isolated networks for inter-container communication.
Host - Shares the host network.
Overlay - Used in Swarm mode for cross-host communication.

Container Management Commands

# Start and stop containers
docker start <container_name>
docker stop <container_name>
docker restart <container_name>
docker rm <container_name>  # Remove a container

# List containers
docker ps           # Running containers
docker ps -a        # All containers (including stopped ones)
docker container ls # Alternative command

Image Management Commands

# View and remove images
docker images         # List all images
docker image ls       # Alternative command
docker rmi <image_id> # Remove an image

# Build, pull, and push images
docker build -t my-node-app .   # Build an image from a Dockerfile
docker pull <image_name>        # Download an image from Docker Hub
docker push <image_name>        # Upload an image to Docker Hub
docker tag <image_id> <repo>:<tag> # Tag an image for pushing

Running Containers

# Run containers interactively
docker run -it <image_name>
docker run -it -p 8000:8000 docker-app-1  # Port mapping

docker run -it -p <exposing_port:internal_port> -e <key=value> -e <key=value> <image_name> # Pass environment variables

docker run --name <container_name> -d <image_name> # Run in detached mode
docker run --rm <image_name> # Remove container after stopping

Executing Commands Inside Containers

docker exec -it <container_name> <command> # Execute a command
docker exec -it <container_name> bash      # Open a Bash shell
docker attach <container_name>             # Attach to a running container
docker logs <container_name>                # View logs
docker logs -f <container_name>             # Follow logs in real time

Networking in Docker

# List, create, and remove networks
docker network ls
docker network create <network_name>
docker network inspect <network_name>
docker network connect <network_name> <container_name>
docker network disconnect <network_name> <container_name>
docker network rm <network_name>

Managing Volumes

# View and create volumes
docker volume ls
docker volume create <volume_name>
docker volume inspect <volume_name>

docker volume rm <volume_name>  # Remove a volume

docker run -v <volume_name>:<container_path> <image_name> # Mount a volume

Docker Compose Commands

docker-compose up       # Start containers
docker-compose up -d    # Start in detached mode
docker-compose down     # Stop and remove containers
docker-compose up --build  # Rebuild and restart containers
docker-compose logs     # View logs
docker-compose ps       # List running services
docker-compose exec <service_name> <command>  # Run command in a service

Cleaning Up Docker Resources

# Remove unused containers, networks, and images
docker system prune  # Remove unused resources
docker system prune -a  # Remove all unused images, containers, networks

docker container prune  # Remove all stopped containers
docker volume prune  # Remove all unused volumes
docker network prune  # Remove all unused networks

Dockerfile Essentials

# Define base image
FROM node:16-alpine

# Set working directory
WORKDIR /app

# Copy application files
COPY . .

# Install dependencies
RUN npm install

# Set environment variables
ENV PORT=8000

# Expose port
EXPOSE 8000

# Define the command to run the application
CMD ["node", "index.js"]

Conclusion

Docker is an essential tool for modern application deployment, simplifying containerized environments for scalable and efficient workflows. This guide serves as a handy reference to help you master Docker commands and concepts quickly.

Have any questions or suggestions? Drop them in the comments below! 🚀

Docker for Beginners: Containerizing Your First Application

Muhammad Sufiyan Baig — Thu, 30 Jan 2025 09:03:16 +0000

What is Docker?

Docker is a platform that enables users to package applications into lightweight, independent containers known as Docker containers. Unlike traditional virtual machines (VMs), Docker containers share the host system’s kernel, ensuring better speed, resource efficiency, and consistency across different environments.

Prerequisites

Before you begin, ensure you have the following installed:

Docker Desktop (for macOS/Windows) or Docker Engine (for Linux). Install it from Docker's official website.
A simple application. In this guide, we will use a basic Node.js "Hello World" server.

Step 1: Create a Sample Application

Create a basic Node.js app with the following files:

1. `package.json`

{
  "name": "docker-demo",
  "version": "1.0.0",
  "main": "server.js",
  "scripts": {
    "start": "node server.js"
  },
  "dependencies": {
    "express": "^4.18.2"
  }
}

2. `server.js`

const express = require('express');  
const app = express();  
const port = 3000;  

app.get('/', (req, res) => {  
  res.send('Hello from Docker!');  
});  

app.listen(port, () => {  
  console.log(`App running on http://localhost:${port}`);  
});

Step 2: Write a Dockerfile

Create a Dockerfile in your project’s root directory:

FROM node:18-alpine  

WORKDIR /app  

COPY package*.json ./  

RUN npm install  

COPY . .  

EXPOSE 3000  

CMD ["npm", "start"]

Explanation:

FROM: Uses Node.js (Alpine Linux variant) as the base image.
WORKDIR: Sets the working directory inside the container.
COPY: Copies necessary files into the container.
RUN: Installs dependencies.
EXPOSE: Declares the port but does not automatically map it.
CMD: Defines the command to start the application.

Step 3: Build the Docker Image

Navigate to your project directory and run:

docker build -t my-first-docker-app .

-t my-first-docker-app: Tags the image with a name.
.: Specifies the current directory as the build context.

Step 4: Run the Container

Start the container with the following command:

docker run -p 3000:3000 my-first-docker-app

-p 3000:3000: Maps port 3000 of your local machine to port 3000 inside the container.
Open http://localhost:3000 in your browser to see the message: “Hello from Docker!”

Best Practices for Beginners

Use a .dockerignore file: Prevent unnecessary files (e.g., node_modules, .env) from being copied.
Optimize Image Size: Prefer smaller base images like alpine variants.
Avoid Running as Root: Add a non-root user for better security.
Clean Up Unused Images/Containers:

  docker rm <container_id>  # Remove stopped containers
  docker rmi <image_id>      # Remove unused images

Conclusion

You have successfully containerized your first application using Docker. Docker simplifies dependency management and ensures application consistency across different environments.

To further explore Docker, try experimenting with Docker Compose for multi-container applications or explore the vast Docker ecosystem.

Happy Containerizing! 🐳

DEV Community: Muhammad Sufiyan Baig

5 Python Tricks Every Backend Dev Should Know

Efficient String Formatting with F-Strings

Simplified Assignments and Exception Handling

Optimizing Data Storage with Dataclass Slots

Improving Performance with Functools.Cache

Conclusion and Key Takeaways

REST vs GraphQL: When to Use Which

Introduction to REST and GraphQL

REST: Simplicity and Caching

GraphQL: Flexibility and Complex Data Handling

Choosing Between REST and GraphQL

Conclusion

Stop Hand-Tuning ETL Batch Sizes. Use PID Control Instead.

What's actually happening

Enter PID control

StreamChunk: PID control for Python data pipelines

Basic usage

The math (briefly)

Memory ceiling: the OOM killer

Going parallel

Thread vs Process: which one?

Data sources

Building a custom source

Async support

Prometheus + Grafana integration

YAML config for deployment

Benchmark results

Design patterns used

Quick reference

The takeaway

Docker Commands Cheat Sheet

Mastering Docker: A Comprehensive Guide

Introduction

Basic Docker Concepts

What is Docker?

Container

Image

Dockerfile

Docker Compose

Volume

Network

Container Management Commands

Image Management Commands

Running Containers

Executing Commands Inside Containers

Networking in Docker

Managing Volumes

Docker Compose Commands

Cleaning Up Docker Resources

Dockerfile Essentials

Conclusion

Docker for Beginners: Containerizing Your First Application

What is Docker?

Prerequisites

Step 1: Create a Sample Application

1. package.json

2. server.js

Step 2: Write a Dockerfile

Explanation:

Step 3: Build the Docker Image

Step 4: Run the Container

Best Practices for Beginners

Conclusion

1. `package.json`

2. `server.js`