DEV Community: Mayra

Unifying the Ecosystem: Building and Deploying an MCP Server for Modern Clients

Mayra — Mon, 01 Dec 2025 00:08:29 +0000

The Power of the MCP Server
The modern development landscape is diverse, requiring seamless communication between tools like AI assistants (e.g., Claude), IDEs (e.g., VSCode), and custom CLI tools. This is where the Message Control Protocol (MCP) Server steps in, acting as a unified communication broker.

The MCP Server provides a single, standardized endpoint for command execution and data exchange. This article provides a concise guide to building a basic MCP Server using Python and deploying it to Google Cloud Run, demonstrating its immediate utility for diverse MCP Clients.

Server Implementation Core (Python & Flask)
We use Python and the Flask framework to create a simple HTTP service that listens for POST requests containing our MCP message format (JSON).

_The MCP Message Protocol
_All client-server communication adheres to a simple JSON structure:

{
  "client_id": "vscode-ext-001",
  "command": "GET_STATUS",
  "payload": {
    "target_resource": "db_connection"
  }
}

_Flask Handler Snippet
_The core logic processes the incoming command and returns a structured response:

from flask import Flask, request, jsonify

app = Flask(__name__)

def process_command(data):
    """Handles business logic based on the MCP command."""
    command = data.get("command")

    if command == "GET_STATUS":
        # Simulates checking resource status
        resource = data.get("payload", {}).get("target_resource", "unknown")
        status = "OK" if resource == "service-A" else "ERROR"
        return {"status": "success", "response": f"Status for {resource}: {status}"}

    return {"status": "error", "response": f"Unknown command: {command}"}

@app.route('/mcp/control', methods=['POST'])
def mcp_handler():
    try:
        data = request.get_json()
        if not data:
            return jsonify({"status": "error", "response": "Invalid JSON"}), 400

        response = process_command(data)
        return jsonify(response), 200

    except Exception as e:
        return jsonify({"status": "fatal_error", "response": str(e)}), 500

if __name__ == "__main__":
    import os
    port = int(os.environ.get("PORT", 8080))
    app.run(host="0.0.0.0", port=port)

Cloud Run Deployment (Serverless)
We containerize the Python server using a Dockerfile and deploy it to Google Cloud Run for automatic scalability and high availability.

Dockerfile Summary
The Dockerfile sets up the Python environment, installs dependencies from requirements.txt, and runs the Flask application on the port specified by Cloud Run.

# (Omitted full Dockerfile for brevity)
# Key steps: FROM python:3.10-slim, COPY requirements.txt, RUN pip install, CMD ["python", "app.py"]

Deployment Steps
After building the Docker image and pushing it to a container registry, the deployment is executed:

# 1. Build: gcloud builds submit --tag gcr.io/[PROJECT-ID]/mcp-server
# 2. Deploy: gcloud run deploy mcp-server --image gcr.io/[PROJECT-ID]/mcp-server --platform managed --allow-unauthenticated

The deployed service provides a public URL (e.g., https://mcp-server-xyz.a.run.app) for all clients to connect.

MCP Client Connectivity
Our deployed server is now ready to serve any client adhering to the MCP structure.

Client Example 1: AI Assistant (e.g., Claude)
An AI assistant can be configured to use our MCP Server URL as an external tool. When a developer asks, "What's the status of Service-A?", the AI translates this into the GET_STATUS command and sends it to the server. The server responds with the status, which the AI then converts back into a natural language response: "Service-A is currently reporting an OK status."

Client Example 2: VSCode Extension
A VSCode extension can connect to the MCP Server to trigger actions. For instance, a button press in the IDE might send an EXECUTE_JOB command to clean up local resources or initiate a deployment pipeline. The server handles the logic, and the extension confirms success to the user, enhancing developer workflow directly within the IDE.

Conclusion
By implementing the MCP Server on a serverless platform like Google Cloud Run, we have established a scalable and flexible control layer. This unified protocol simplifies tool integration, paving the way for more powerful and interconnected development ecosystems.

Observability Practices in Modern Applications: Real-Time Monitoring with Prometheus and Grafana

Mayra — Sun, 30 Nov 2025 23:54:01 +0000

Observability is a critical practice in modern software development. It allows teams to understand the internal state of applications by collecting, analyzing, and visualizing data from logs, metrics, and traces. Unlike traditional monitoring, observability provides a proactive approach to detecting, diagnosing, and resolving issues before they affect users.

In this article, we will explore observability practices using Prometheus for metrics collection and Grafana for visualization, with a simple real-world example in Python.

Core Observability Practices

Structured Logging: Captures application events in a consistent format, making it easier to analyze errors.
Metrics Collection: Monitors system performance, such as CPU usage, memory consumption, or request latency.
Distributed Tracing: Tracks requests across multiple services to detect bottlenecks.
Proactive Alerts: Notifies teams when system behavior deviates from expected patterns.

Practical Example: Counting Requests in a Web Application
We'll create a Python application that tracks incoming requests and exposes metrics to Prometheus.
Python Code Example:

from prometheus_client import start_http_server, Counter
import random
import time

# Create a counter metric for HTTP requests
REQUEST_COUNT = Counter('app_requests_total', 'Total HTTP Requests')

def process_request():
    """Simulate processing a request"""
    REQUEST_COUNT.inc()  # Increment the counter
    time.sleep(random.random())  # Simulate request processing time

if __name__ == '__main__':
    # Expose metrics on port 8000 for Prometheus
    start_http_server(8000)
    print("Server running on port 8000. Metrics exposed for Prometheus.")
    while True:
        process_request()

Explanation:

Every call to process_request() increments the app_requests_total counter.
Prometheus scrapes the metrics from http://localhost:8000/metrics.
Grafana can then visualize these metrics in real time using dashboards.

Real-World Benefits

By implementing observability practices like this:
Teams can detect unusual spikes in requests or errors before they affect users.
Engineers gain actionable insights to improve system reliability and performance.
Scaling this setup allows monitoring of microservices or distributed systems efficiently.

Conclusion
Observability is essential for modern applications, especially in distributed and cloud-native environments. By combining metrics collection with powerful visualization tools like Prometheus and Grafana, developers can maintain high system reliability and respond quickly to incidents.

Next Steps / Recommendation:

Extend this example to include logging structured errors using Python’s logging module.
Implement alerting in Grafana for threshold breaches.
Explore distributed tracing with tools like Jaeger or OpenTelemetry.

Repository Pattern in Golang: A Practical Guide

Mayra — Fri, 07 Nov 2025 03:04:31 +0000

The Repository Pattern, documented in Martin Fowler's "Patterns of Enterprise Application Architecture," separates data access logic from business logic. This article demonstrates its implementation in Golang through a real-world e-commerce example.

The Problem
Without proper separation, your code mixes business logic with database operations:

func ProcessOrder(orderID string) error {
    db.Query("SELECT * FROM orders WHERE id = ?", orderID)
    // Business rules buried in database code
}

Problems:

Tight coupling to database
Hard to test
Code duplication
Can't switch databases easily

The Solution: Repository Pattern

The pattern provides an abstraction layer between business logic and data access, treating data like an in-memory collection.

Benefits:

Testability (easy to mock)
Flexibility (switch databases)
Clean separation of concerns
Centralized data access

Implementation

Domain Model

// domain/product.go
package domain

import "time"

type Product struct {
    ID          string
    Name        string
    Price       float64
    Stock       int
    Category    string
    CreatedAt   time.Time
    UpdatedAt   time.Time
}

func (p *Product) Validate() error {
    if p.Name == "" {
        return errors.New("name required")
    }
    if p.Price < 0 {
        return errors.New("invalid price")
    }
    return nil
}

Repository Interface

// repository/interface.go
package repository

import (
    "context"
    "github.com/yourusername/ecommerce-repository/domain"
)

type ProductRepository interface {
    Create(ctx context.Context, product *domain.Product) error
    FindByID(ctx context.Context, id string) (*domain.Product, error)
    FindAll(ctx context.Context) ([]*domain.Product, error)
    FindByCategory(ctx context.Context, category string) ([]*domain.Product, error)
    Update(ctx context.Context, product *domain.Product) error
    Delete(ctx context.Context, id string) error
}

PostgreSQL Implementation

// repository/postgres.go
package repository

import (
    "context"
    "database/sql"
    "github.com/yourusername/ecommerce-repository/domain"
)

type PostgresProductRepository struct {
    db *sql.DB
}

func NewPostgresProductRepository(db *sql.DB) *PostgresProductRepository {
    return &PostgresProductRepository{db: db}
}

func (r *PostgresProductRepository) Create(ctx context.Context, product *domain.Product) error {
    query := `
        INSERT INTO products (id, name, price, stock, category, created_at, updated_at)
        VALUES ($1, $2, $3, $4, $5, $6, $7)
    `
    _, err := r.db.ExecContext(ctx, query,
        product.ID, product.Name, product.Price, 
        product.Stock, product.Category, time.Now(), time.Now())
    return err
}

func (r *PostgresProductRepository) FindByID(ctx context.Context, id string) (*domain.Product, error) {
    query := `SELECT id, name, price, stock, category, created_at, updated_at 
              FROM products WHERE id = $1`

    product := &domain.Product{}
    err := r.db.QueryRowContext(ctx, query, id).Scan(
        &product.ID, &product.Name, &product.Price,
        &product.Stock, &product.Category, &product.CreatedAt, &product.UpdatedAt)

    if err == sql.ErrNoRows {
        return nil, fmt.Errorf("product not found")
    }
    return product, err
}

func (r *PostgresProductRepository) FindByCategory(ctx context.Context, category string) ([]*domain.Product, error) {
    query := `SELECT id, name, price, stock, category, created_at, updated_at 
              FROM products WHERE category = $1`

    rows, err := r.db.QueryContext(ctx, query, category)
    if err != nil {
        return nil, err
    }
    defer rows.Close()

    var products []*domain.Product
    for rows.Next() {
        p := &domain.Product{}
        err := rows.Scan(&p.ID, &p.Name, &p.Price, &p.Stock, 
                        &p.Category, &p.CreatedAt, &p.UpdatedAt)
        if err != nil {
            return nil, err
        }
        products = append(products, p)
    }
    return products, nil
}

func (r *PostgresProductRepository) Update(ctx context.Context, product *domain.Product) error {
    query := `UPDATE products SET name=$1, price=$2, stock=$3, 
              category=$4, updated_at=$5 WHERE id=$6`
    _, err := r.db.ExecContext(ctx, query, product.Name, product.Price,
        product.Stock, product.Category, time.Now(), product.ID)
    return err
}

func (r *PostgresProductRepository) Delete(ctx context.Context, id string) error {
    query := `DELETE FROM products WHERE id = $1`
    _, err := r.db.ExecContext(ctx, query, id)
    return err
}

In-Memory Implementation (Testing)

// repository/memory.go
package repository

import (
    "context"
    "sync"
    "github.com/yourusername/ecommerce-repository/domain"
)

type InMemoryProductRepository struct {
    mu       sync.RWMutex
    products map[string]*domain.Product
}

func NewInMemoryProductRepository() *InMemoryProductRepository {
    return &InMemoryProductRepository{
        products: make(map[string]*domain.Product),
    }
}

func (r *InMemoryProductRepository) Create(ctx context.Context, product *domain.Product) error {
    r.mu.Lock()
    defer r.mu.Unlock()
    r.products[product.ID] = product
    return nil
}

func (r *InMemoryProductRepository) FindByID(ctx context.Context, id string) (*domain.Product, error) {
    r.mu.RLock()
    defer r.mu.RUnlock()

    product, exists := r.products[id]
    if !exists {
        return nil, fmt.Errorf("not found")
    }
    return product, nil
}

func (r *InMemoryProductRepository) FindByCategory(ctx context.Context, category string) ([]*domain.Product, error) {
    r.mu.RLock()
    defer r.mu.RUnlock()

    var products []*domain.Product
    for _, p := range r.products {
        if p.Category == category {
            products = append(products, p)
        }
    }
    return products, nil
}

Business Service

// service/product_service.go
package service

import (
    "context"
    "github.com/yourusername/ecommerce-repository/domain"
    "github.com/yourusername/ecommerce-repository/repository"
)

type ProductService struct {
    repo repository.ProductRepository
}

func NewProductService(repo repository.ProductRepository) *ProductService {
    return &ProductService{repo: repo}
}

func (s *ProductService) CreateProduct(ctx context.Context, product *domain.Product) error {
    if err := product.Validate(); err != nil {
        return err
    }
    return s.repo.Create(ctx, product)
}

func (s *ProductService) GetProduct(ctx context.Context, id string) (*domain.Product, error) {
    return s.repo.FindByID(ctx, id)
}

func (s *ProductService) GetProductsByCategory(ctx context.Context, category string) ([]*domain.Product, error) {
    return s.repo.FindByCategory(ctx, category)
}

Main Application

// main.go
package main

import (
    "database/sql"
    "log"
    "net/http"
    "github.com/gorilla/mux"
    _ "github.com/lib/pq"
)

func main() {
    db, _ := sql.Open("postgres", "postgres://user:pass@localhost/ecommerce?sslmode=disable")
    defer db.Close()

    // Switch implementations easily
    repo := repository.NewPostgresProductRepository(db)
    // Or use: repo := repository.NewInMemoryProductRepository()

    service := service.NewProductService(repo)

    r := mux.NewRouter()
    r.HandleFunc("/products", createProduct(service)).Methods("POST")
    r.HandleFunc("/products/{id}", getProduct(service)).Methods("GET")
    r.HandleFunc("/products", listProducts(service)).Methods("GET")

    log.Fatal(http.ListenAndServe(":8080", r))
}

Testing Example

func TestProductService(t *testing.T) {
    repo := repository.NewInMemoryProductRepository()
    service := service.NewProductService(repo)

    product := &domain.Product{
        ID: "1", Name: "Mouse", Price: 29.99, Stock: 50, Category: "electronics"}

    err := service.CreateProduct(context.Background(), product)
    if err != nil {
        t.Fatal(err)
    }

    found, _ := service.GetProduct(context.Background(), "1")
    if found.Name != "Mouse" {
        t.Errorf("expected Mouse, got %s", found.Name)
    }
}

Database Schema

CREATE TABLE products (
    id VARCHAR(255) PRIMARY KEY,
    name VARCHAR(255) NOT NULL,
    price DECIMAL(10, 2) NOT NULL,
    stock INTEGER NOT NULL,
    category VARCHAR(100) NOT NULL,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

CREATE INDEX idx_category ON products(category);

Running the Project

# Setup
go mod init github.com/yourusername/ecommerce-repository
go get github.com/gorilla/mux github.com/lib/pq

# Run with PostgreSQL
DATABASE_URL="postgres://user:pass@localhost/ecommerce" go run main.go

# Run with in-memory (testing)
USE_MEMORY=true go run main.go

# Test API
curl -X POST http://localhost:8080/products \
  -d '{"id":"1","name":"Mouse","price":29.99,"stock":50,"category":"electronics"}'

curl http://localhost:8080/products/1
curl http://localhost:8080/products?category=electronics

Key Advantages

Easy Testing: Swap PostgreSQL for in-memory implementation
Database Independence: Change databases without touching business logic
Clean Code: Each layer has one responsibility
Maintainability: All queries in one place

When to Use
Use Repository Pattern when:

Complex business logic
Need to support multiple databases
High test coverage required
Large team with separate concerns

Avoid when:

Simple CRUD apps
Prototypes
Very small projects

Conclusion
The Repository Pattern provides a clean separation between business logic and data access. This example shows how to implement it in Golang with real code that you can use in production.

References

GitHub: https://github.com/mayrafc/golang-repository-pattern.git
Martin Fowler's Book: "Patterns of Enterprise Application Architecture"

Beyond Traditional Dashboards: A Deep Dive into Modern Data Visualization Tools

Mayra — Sun, 14 Sep 2025 05:41:07 +0000

In today's data-driven world, the ability to create interactive, engaging visualizations has become crucial for data scientists, analysts, and developers. While traditional business intelligence tools have their place, modern Python-based visualization frameworks like Streamlit, Dash, and Bokeh are revolutionizing how we build and deploy data applications. These tools enable rapid prototyping, seamless interactivity, and cloud deployment without extensive web development knowledge.

Why Modern Visualization Tools Matter ⚡

Traditional dashboard solutions often require significant setup time, expensive licenses, and specialized skills. Modern Python-based tools democratize data visualization by:

Lowering the barrier to entry - Pure Python development
Enabling rapid prototyping - From concept to deployment in hours
Providing native interactivity - Built-in widgets and real-time updates
Supporting cloud deployment - Easy scaling and sharing
Integrating seamlessly with the Python data ecosystem

Streamlit: The Fastest Way to Build Data Apps 🚀

Overview
Streamlit has gained massive popularity for its simplicity and speed. With just a few lines of Python code, you can create sophisticated web applications that automatically update as users interact with them.

Key Features

Magic commands - Automatic rendering of variables and plots
Built-in widgets - Sliders, buttons, file uploads, and more
Caching system - Optimized performance for data processing
Component ecosystem - Extensible with custom components

Code Example: Interactive Stock Price Dashboard

import streamlit as st
import pandas as pd
import yfinance as yf
import plotly.graph_objects as go
from datetime import datetime, timedelta

# App configuration
st.set_page_config(page_title="Stock Price Dashboard", layout="wide")
st.title("📈 Interactive Stock Price Dashboard")

# Sidebar for user inputs
st.sidebar.header("Stock Selection")
ticker = st.sidebar.text_input("Enter Stock Symbol", value="AAPL")
period = st.sidebar.selectbox("Time Period", 
                             ["1mo", "3mo", "6mo", "1y", "2y", "5y"])

# Fetch and display data
@st.cache_data
def load_stock_data(symbol, period):
    stock = yf.Ticker(symbol)
    data = stock.history(period=period)
    return data, stock.info

try:
    data, info = load_stock_data(ticker, period)

    # Display company info
    col1, col2, col3, col4 = st.columns(4)
    with col1:
        st.metric("Current Price", f"${data['Close'][-1]:.2f}")
    with col2:
        change = data['Close'][-1] - data['Close'][-2]
        st.metric("Daily Change", f"${change:.2f}", 
                 delta=f"{(change/data['Close'][-2]*100):.2f}%")
    with col3:
        st.metric("Volume", f"{data['Volume'][-1]:,}")
    with col4:
        st.metric("Market Cap", f"${info.get('marketCap', 0):,}")

    # Interactive chart
    fig = go.Figure()
    fig.add_trace(go.Candlestick(
        x=data.index,
        open=data['Open'],
        high=data['High'],
        low=data['Low'],
        close=data['Close'],
        name=ticker
    ))

    fig.update_layout(
        title=f"{ticker} Stock Price",
        yaxis_title="Price ($)",
        template="plotly_dark"
    )

    st.plotly_chart(fig, use_container_width=True)

    # Data table
    if st.checkbox("Show Raw Data"):
        st.dataframe(data.tail(10))

except Exception as e:
    st.error(f"Error fetching data for {ticker}: {str(e)}")

# Footer
st.markdown("---")
st.markdown("Built with Streamlit 🚀")

*Deployment on Streamlit Cloud ☁️

Push your code to GitHub
Connect your repository to Streamlit Cloud
Deploy with one click - no configuration needed!

# requirements.txt
streamlit
pandas
yfinance
plotly

Dash: Enterprise-Grade Interactive Applications 🏢

Overview

Developed by Plotly, Dash is perfect for building production-ready applications with complex interactivity and custom styling. It's built on top of Flask, React, and Plotly.js.
Key Features

Callback system - Reactive programming model
Enterprise security - Authentication and authorization
Custom styling - Full CSS and component customization
Scalability - Built for production environments

Code Example: Sales Analytics Dashboard

import dash
from dash import dcc, html, Input, Output, callback
import plotly.express as px
import pandas as pd
import numpy as np
from datetime import datetime, timedelta

# Sample data generation
np.random.seed(42)
dates = pd.date_range(start='2023-01-01', end='2024-01-01', freq='D')
products = ['Product A', 'Product B', 'Product C', 'Product D']
regions = ['North', 'South', 'East', 'West']

data = []
for date in dates:
    for product in products:
        for region in regions:
            sales = np.random.normal(1000, 200) * (1 + 0.1 * np.sin(date.dayofyear * 2 * np.pi / 365))
            data.append({
                'Date': date,
                'Product': product,
                'Region': region,
                'Sales': max(0, sales),
                'Units': int(sales / np.random.uniform(10, 50))
            })

df = pd.DataFrame(data)

# Initialize Dash app
app = dash.Dash(__name__)

# Define layout
app.layout = html.Div([
    html.H1("Sales Analytics Dashboard", 
            style={'textAlign': 'center', 'color': '#2c3e50'}),

    html.Div([
        html.Div([
            html.Label("Select Product:"),
            dcc.Dropdown(
                id='product-dropdown',
                options=[{'label': p, 'value': p} for p in products],
                value=products,
                multi=True
            )
        ], className='six columns'),

        html.Div([
            html.Label("Select Date Range:"),
            dcc.DatePickerRange(
                id='date-range',
                start_date=df['Date'].min(),
                end_date=df['Date'].max(),
                display_format='YYYY-MM-DD'
            )
        ], className='six columns'),
    ], className='row'),

    html.Br(),

    html.Div([
        html.Div([
            dcc.Graph(id='sales-trend')
        ], className='six columns'),

        html.Div([
            dcc.Graph(id='regional-sales')
        ], className='six columns'),
    ], className='row'),

    html.Div([
        dcc.Graph(id='product-comparison')
    ])
])

# Callbacks
@app.callback(
    [Output('sales-trend', 'figure'),
     Output('regional-sales', 'figure'),
     Output('product-comparison', 'figure')],
    [Input('product-dropdown', 'value'),
     Input('date-range', 'start_date'),
     Input('date-range', 'end_date')]
)
def update_charts(selected_products, start_date, end_date):
    # Filter data
    filtered_df = df[
        (df['Product'].isin(selected_products)) &
        (df['Date'] >= start_date) &
        (df['Date'] <= end_date)
    ]

    # Sales trend over time
    daily_sales = filtered_df.groupby(['Date', 'Product'])['Sales'].sum().reset_index()
    trend_fig = px.line(daily_sales, x='Date', y='Sales', color='Product',
                       title='Sales Trend Over Time')

    # Regional sales distribution
    regional_sales = filtered_df.groupby('Region')['Sales'].sum().reset_index()
    regional_fig = px.pie(regional_sales, values='Sales', names='Region',
                         title='Sales by Region')

    # Product comparison
    product_sales = filtered_df.groupby('Product')['Sales'].sum().reset_index()
    comparison_fig = px.bar(product_sales, x='Product', y='Sales',
                           title='Sales by Product')

    return trend_fig, regional_fig, comparison_fig

if __name__ == '__main__':
    app.run_server(debug=True)

Deployment on Heroku

# Procfile
web: gunicorn app:server

# requirements.txt
dash
plotly
pandas
numpy
gunicorn

# For Heroku deployment, modify the last line:
server = app.server

if __name__ == '__main__':
    app.run_server(debug=True)

Bokeh: High-Performance Interactive Visualizations ⚡
Overview
Bokeh excels at creating highly interactive visualizations that can handle large datasets efficiently. It's particularly strong for real-time applications and complex multi-plot layouts.

Key Features

High performance - WebGL rendering for large datasets
Server applications - Built-in server for real-time updates
Flexible layouts - Complex multi-plot arrangements
JavaScript integration - Custom interactions and extensions

Code Example: Real-time IoT Sensor Dashboard

import numpy as np
import pandas as pd
from datetime import datetime, timedelta
from bokeh.layouts import column, row
from bokeh.models import ColumnDataSource, DatetimeTickFormatter
from bokeh.plotting import figure, curdoc
from bokeh.models.widgets import Div
import random

# Initialize data sources
source_temp = ColumnDataSource(data=dict(time=[], temperature=[]))
source_humidity = ColumnDataSource(data=dict(time=[], humidity=[]))
source_pressure = ColumnDataSource(data=dict(time=[], pressure=[]))

# Create figures
temp_plot = figure(title="Temperature Sensor", x_axis_type='datetime', 
                   width=400, height=300)
temp_plot.line('time', 'temperature', source=source_temp, 
               line_width=2, color='red', legend_label="°C")

humidity_plot = figure(title="Humidity Sensor", x_axis_type='datetime', 
                      width=400, height=300)
humidity_plot.line('time', 'humidity', source=source_humidity, 
                   line_width=2, color='blue', legend_label="%")

pressure_plot = figure(title="Pressure Sensor", x_axis_type='datetime', 
                      width=800, height=300)
pressure_plot.line('time', 'pressure', source=source_pressure, 
                   line_width=2, color='green', legend_label="hPa")

# Format datetime axes
for plot in [temp_plot, humidity_plot, pressure_plot]:
    plot.xaxis.formatter = DatetimeTickFormatter(hours="%H:%M")
    plot.legend.location = "top_left"

# Statistics display
stats_div = Div(text="<h3>Real-time Statistics</h3>", width=800, height=100)

def update_data():
    # Simulate sensor data
    new_time = datetime.now()
    new_temp = 20 + 5 * np.sin(new_time.minute * 2 * np.pi / 60) + random.normalvariate(0, 1)
    new_humidity = 50 + 10 * np.cos(new_time.minute * 2 * np.pi / 60) + random.normalvariate(0, 2)
    new_pressure = 1013 + 20 * np.sin(new_time.minute * 4 * np.pi / 60) + random.normalvariate(0, 5)

    # Update data sources
    source_temp.stream(dict(time=[new_time], temperature=[new_temp]), rollover=100)
    source_humidity.stream(dict(time=[new_time], humidity=[new_humidity]), rollover=100)
    source_pressure.stream(dict(time=[new_time], pressure=[new_pressure]), rollover=100)

    # Update statistics
    if len(source_temp.data['temperature']) > 0:
        avg_temp = np.mean(source_temp.data['temperature'][-10:])
        avg_humidity = np.mean(source_humidity.data['humidity'][-10:])
        avg_pressure = np.mean(source_pressure.data['pressure'][-10:])

        stats_text = f"""
        <h3>Real-time Statistics (Last 10 readings)</h3>
        <p><strong>Average Temperature:</strong> {avg_temp:.2f}°C</p>
        <p><strong>Average Humidity:</strong> {avg_humidity:.2f}%</p>
        <p><strong>Average Pressure:</strong> {avg_pressure:.2f} hPa</p>
        <p><strong>Last Update:</strong> {new_time.strftime('%H:%M:%S')}</p>
        """
        stats_div.text = stats_text

# Layout
layout = column(
    Div(text="<h1>IoT Sensor Dashboard</h1>", width=800, height=50),
    row(temp_plot, humidity_plot),
    pressure_plot,
    stats_div
)

# Add to document
curdoc().add_root(layout)
curdoc().add_periodic_callback(update_data, 1000)  # Update every second
curdoc().title = "IoT Sensor Dashboard"

Deployment on Bokeh Server

# Run locally
bokeh serve --show dashboard.py

# For cloud deployment (requirements.txt)
bokeh
numpy
pandas

Cloud Deployment Strategies ☁️

Streamlit Cloud (Easiest)

**Pros: **Free, zero configuration, automatic updates from GitHub
Cons: Limited customization, resource constraints
Best for: Prototypes, small applications, demos

Heroku (Balanced)

Pros:Easy deployment, good free tier, supports all frameworks
Cons: Dyno sleep on free tier, can be expensive at scale
Best for: Medium-scale applications, team projects

AWS/GCP/Azure (Enterprise)

Pros: Full control, unlimited scaling, enterprise features
Cons: Complex setup, cost management required
Best for: Production applications, large-scale deployments

Conclusion ✅

Choose Streamlit for quick prototypes and simple apps
Choose Dash for enterprise applications with custom styling
Choose Bokeh for high-performance, real-time visualizations

These tools revolutionize data visualization by enabling data scientists to build interactive dashboards without web development expertise. Start with the tool that fits your needs and expand as requirements grow.

Enterprise Design Patterns: Implementing the Active Record Pattern in Ruby

Mayra — Sun, 14 Sep 2025 04:41:46 +0000

Enterprise applications power businesses from banks to e-commerce platforms. Building robust, maintainable, and scalable enterprise systems requires not only well-written code but also the right architectural patterns.

One powerful pattern from Martin Fowler’s Catalog of Patterns of Enterprise Application Architecture is the Active Record Pattern. This pattern combines the domain object with data persistence, simplifying CRUD operations and making the code straightforward for smaller domains or prototyping.

What is the Active Record Pattern?
The Active Record Pattern maps an object in the application directly to a row in the database. Each object is responsible for saving, updating, and deleting itself from the database.

Benefits:

Easy to understand and implement
Encapsulates data access logic within the object
Reduces boilerplate code for CRUD operations

Drawback:

Can become messy for complex domains where business logic grows

Real-World Example: User Management System in Ruby
We will implement a simple user system where the User object handles its own persistence using the Active Record pattern.

# user.rb
require 'sqlite3'

# Create database connection
DB = SQLite3::Database.new "enterprise.db"
DB.execute <<-SQL
  CREATE TABLE IF NOT EXISTS users (
    id INTEGER PRIMARY KEY,
    name TEXT,
    email TEXT
  );
SQL

class User
  attr_accessor :id, :name, :email

  def initialize(name, email, id=nil)
    @name = name
    @email = email
    @id = id
  end

  def save
    if @id
      DB.execute("UPDATE users SET name=?, email=? WHERE id=?", [@name, @email, @id])
    else
      DB.execute("INSERT INTO users (name, email) VALUES (?, ?)", [@name, @email])
      @id = DB.last_insert_row_id
    end
  end

  def self.find(id)
    row = DB.execute("SELECT * FROM users WHERE id=?", id).first
    row ? User.new(row[1], row[2], row[0]) : nil
  end

  def self.all
    DB.execute("SELECT * FROM users").map { |row| User.new(row[1], row[2], row[0]) }
  end

  def delete
    DB.execute("DELETE FROM users WHERE id=?", @id) if @id
  end
end

Demo

# main.rb
require_relative 'user'

# Create users
alice = User.new("Alice", "alice@example.com")
alice.save

bob = User.new("Bob", "bob@example.com")
bob.save

# List all users
puts "All users:"
User.all.each { |user| puts "#{user.id}: #{user.name} (#{user.email})" }

# Find and update user
user = User.find(1)
user.name = "Alice Smith"
user.save

# Delete a user
User.find(2).delete

puts "After updates:"
User.all.each { |user| puts "#{user.id}: #{user.name} (#{user.email})" }

Expected Output:
All users: 1: Alice (alice@example.com) 2: Bob (bob@example.com) After updates: 1: Alice Smith (alice@example.com)
Why Active Record Helps

Encapsulation: Each object handles its own persistence
Simplicity: Easy to implement for small applications or prototypes
Readability: CRUD operations are directly visible on the object

For more complex systems, patterns like Repository or Unit of Work might be better, but Active Record is excellent for quick development and simple domains.

Conclusion
The Active Record Pattern is a practical enterprise design pattern for managing domain objects with integrated persistence. By using Ruby, we demonstrated a user management system where objects can save, update, and delete themselves, making the code readable, maintainable, and easy to extend.

Java Design Principle: Open/Closed Explained

Mayra — Sun, 14 Sep 2025 04:33:50 +0000

One of the biggest challenges in software development is keeping systems flexible and scalable without breaking existing functionality. This is where software design principles come in, helping developers build robust and maintainable applications.

A key principle is the Open/Closed Principle (OCP), part of SOLID, which states:

“Software entities should be open for extension but closed for modification.”

This means your code should allow adding new functionality without changing existing code.

Real-World Problem
Imagine a payment processing system. At first, it only accepts credit cards, but later, users request PayPal and cryptocurrency payments.

Bad design: constantly modifying the same class, increasing the risk of errors.
Good design with OCP: create new classes to extend functionality without touching existing code.

Example in Java

// Common interface for any payment method
interface PaymentMethod {
    void pay(double amount);
}

// Initial implementation: Credit Card
class CreditCardPayment implements PaymentMethod {
    @Override
    public void pay(double amount) {
        System.out.println("Paying $" + amount + " with Credit Card.");
    }
}

// New implementation: PayPal
class PayPalPayment implements PaymentMethod {
    @Override
    public void pay(double amount) {
        System.out.println("Paying $" + amount + " with PayPal.");
    }
}

// New implementation: Cryptocurrency
class CryptoPayment implements PaymentMethod {
    @Override
    public void pay(double amount) {
        System.out.println("Paying $" + amount + " with Cryptocurrency.");
    }
}

// PaymentProcessor class WITHOUT modifying existing code
class PaymentProcessor {
    private final PaymentMethod paymentMethod;

    public PaymentProcessor(PaymentMethod paymentMethod) {
        this.paymentMethod = paymentMethod;
    }

    public void process(double amount) {
        paymentMethod.pay(amount);
    }
}

// Demo main
public class Main {
    public static void main(String[] args) {
        PaymentProcessor creditCard = new PaymentProcessor(new CreditCardPayment());
        creditCard.process(100);

        PaymentProcessor paypal = new PaymentProcessor(new PayPalPayment());
        paypal.process(200);

        PaymentProcessor crypto = new PaymentProcessor(new CryptoPayment());
        crypto.process(300);
    }
}

Expected Output
Paying $100 with Credit Card. Paying $200 with PayPal. Paying $300 with Cryptocurrency.

Design Explanation

PaymentMethod interface: defines a contract all payment types must follow.
Concrete classes (CreditCardPayment, PayPalPayment, CryptoPayment): implement the contract.
PaymentProcessor: executes any implementation of PaymentMethod.
Extensibility: if a new method like Apple Pay is added, just create a new class implementing the interface—no existing code is modified.

Benefits of the Open/Closed Principle
✔️ Fewer errors: existing working code remains untouched.
✔️ Reusability: new classes only implement the common interface.
✔️ Scalability: easily add new functionality.
✔️ Maintainability: code is modular and clear.

Conclusion
The Open/Closed Principle (OCP) teaches developers how to design systems that grow without breaking existing functionality. This Java example demonstrates how a payment system can adapt to new methods by extending the code with new classes.

Applying OCP results in software that is robust, flexible, and ready for future changes.

Automating Unit Testing with Jenkins: A Complete Real-World Example

Mayra — Thu, 03 Jul 2025 21:02:42 +0000

In the fast-paced world of software development, automation is key to delivering reliable code efficiently. Continuous Integration and Continuous Deployment (CI/CD) tools like Jenkins help developers automate repetitive tasks such as building, testing, and deploying applications.

In this article, we’ll explore how to use Jenkins to automate the execution of unit tests using a simple Node.js project. This includes a real-world working example, full code, and explanations. You’ll also find a public GitHub repository with everything set up.

What is Jenkins?
Jenkins is an open-source CI/CD server that allows developers to automate the building, testing, and deployment of software. It is highly customizable through a vast ecosystem of plugins and supports a wide range of languages, platforms, and tools.

Jenkins vs Other CI/CD Tools

Jenkins shines when you need maximum flexibility and control in your CI/CD pipelines.

Project Overview
We’ll build a simple Node.js application with a unit test, then automate testing using a Jenkins Pipeline. The project includes:

A basic JavaScript function (sum)
A test using Jest
A Jenkinsfile to define the pipeline

Project Structure:

jenkins-test-example/
├── Jenkinsfile
├── package.json
├── app.js
└── __tests__/
    └── app.test.js

Jenkinsfile


pipeline {
    agent any

    stages {
        stage('Install Dependencies') {
            steps {
                sh 'npm install'
            }
        }

        stage('Run Tests') {
            steps {
                sh 'npm test'
            }
        }
    }

    post {
        success {
            echo '✅ Tests passed!'
        }
        failure {
            echo '❌ Tests failed!'
        }
    }
}

This Jenkinsfile defines two main stages: installing dependencies and running tests. It also provides a post-build message depending on success or failure.

package.json

{
  "name": "jenkins-test-example",
  "version": "1.0.0",
  "scripts": {
    "test": "jest"
  },
  "devDependencies": {
    "jest": "^29.0.0"
  }
}

app.js

function sum(a, b) {
  return a + b;
}

module.exports = sum;

tests/app.test.js

const sum = require('../app');

test('adds 1 + 2 to equal 3', () => {
  expect(sum(1, 2)).toBe(3);
});

How to Run It Locally

Install Node.js
Clone or download the project
Run the following in terminal: npm install npm test You should see:

PASS  __tests__/app.test.js
✓ adds 1 + 2 to equal 3

Public Repository

You can find the complete working project here:
https://github.com/mayrafc/Jenkins

Final Thoughts
Jenkins is a mature, flexible, and powerful tool for automating software development pipelines. With the example shown in this article, you can start creating your own automated testing workflows today.

If you're looking for full control and extensibility, Jenkins remains one of the best options in the DevOps world.

Applying API Testing Frameworks: Real-World Examples Using Postman

Mayra — Thu, 05 Jun 2025 20:03:25 +0000

In the API-driven world of modern software, backend services are only as reliable as the tests we write for them. Whether you’re building a microservice or a full RESTful API, API testing is essential to validate your endpoints, responses, and business logic.

In this article, I’ll walk you through how to use Postman—one of the most popular API testing frameworks—to create real-world API tests with practical examples and code.

🔹Why Use a Framework Like Postman?

Postman allows developers and QA engineers to:

Create and send HTTP requests to an API
Write automated test scripts in JavaScript
Organize requests into collections
Use environments and variables to test across stages (dev, staging, production)

It combines ease of use with powerful features for testing REST, GraphQL, and SOAP APIs.

🔹Real-World API Testing Scenario

Let’s assume you’re building an API for a bookstore. You have this endpoint:

GET https://api.mybookstore.com/books

Your goal is to verify that:

The server responds with HTTP 200
The response body is JSON
Each book object has a title, author, and price

🔹Creating a Test in Postman

After sending the request in Postman, go to the Tests tab and write:

pm.test("Status code is 200", function () {
    pm.response.to.have.status(200);
});

pm.test("Response is JSON", function () {
    pm.response.to.be.json;
});

pm.test("Each book has required fields", function () {
    const books = pm.response.json();
    books.forEach(book => {
        pm.expect(book).to.have.property("title");
        pm.expect(book).to.have.property("author");
        pm.expect(book).to.have.property("price");
    });
});

These scripts use Postman’s built-in Chai.js assertion library to check the API response.

🔹Testing with Parameters and Edge Cases

Let’s test a filtered request like:

GET https://api.mybookstore.com/books?author=Orwell
You can write a test to ensure that all returned books are from that author:

pm.test("Books returned are by Orwell", function () {
    const books = pm.response.json();
    books.forEach(book => {
        pm.expect(book.author).to.eql("Orwell");
    });
});

This is a real-world example of validating query parameters and filtering logic in the backend.

🔹Using Environments for Flexibility

You can define variables in Postman environments like:

base_url = https://api.mybookstore.com

Then, in your requests:

{{base_url}}/books

This allows you to reuse the same tests for:

Local development (localhost)
Staging (staging.mybookstore.com)
Production (api.mybookstore.com)

🔹Organizing Tests in Collections

Postman lets you organize your requests into collections with folders like:

/books endpoints
/authors endpoints
/orders endpoints

Each folder can contain multiple request types (GET, POST, PUT, DELETE) and associated tests. This structure mimics how your backend is organized.

Conclusion

Good testing makes great APIs. Postman empowers developers to test early, test often, and test well—with minimal setup and maximum impact.

Applying the SAST Tool Checkov to a Terraform IaC Project

Mayra — Mon, 21 Apr 2025 02:17:26 +0000

Infrastructure as Code (IaC) is a powerful practice that allows developers to define and manage cloud infrastructure using code. However, just like application code, IaC can introduce security risks if not properly reviewed.

Static Application Security Testing (SAST) tools help detect vulnerabilities before infrastructure is deployed. In this article, we will use Checkov, a SAST tool designed for IaC, to scan a small Terraform project and identify security issues.

What is Checkov?

Checkov is an open-source SAST tool developed by Bridgecrew. It scans Terraform, Kubernetes, CloudFormation, and other IaC templates for misconfigurations and insecure code patterns.

Key features:

Supports multiple IaC platforms
Easy to install
Detects real-world cloud security issues
Works locally or in CI/CD pipelines

Installation

Installing Checkov is very simple. Just use pip:

pip install checkov

After installation, you can scan your project folder with:

checkov -d .

Terraform Example

Here is a basic Terraform configuration that creates a public S3 bucket:

# main.tf
provider "aws" {
  region = "us-east-1"
}

resource "aws_s3_bucket" "my_bucket" {
  bucket = "my-public-bucket-123"
  acl    = "public-read"
}

Although this configuration works, it has a security flaw: the bucket is publicly accessible, which may expose sensitive files.

Scanning with Checkov

When we run checkov -d . in the folder containing main.tf, Checkov scans the code and outputs a warning like:

Check: CKV_AWS_20
Message: S3 Bucket has an ACL defined which allows public access.
File: /main.tf:6-10
Severity: HIGH

This means Checkov successfully identified the risk of public access in the bucket.

Fixing the Issue

To fix this vulnerability, we can change the ACL to "private":

resource "aws_s3_bucket" "my_bucket" {
  bucket = "my-public-bucket-123"
  acl    = "private"
}

After updating the code and scanning again, Checkov confirms that the issue is resolved.

Conclusion

Using a tool like Checkov helps prevent cloud misconfigurations before deployment. It’s easy to use, fast, and powerful — making it perfect for scanning Terraform and other IaC platforms.

By integrating Checkov into your workflow, you improve security and reduce risk in your infrastructure.

Applying the SAST Tool RIPS to a PHP Application

Mayra — Mon, 21 Apr 2025 01:52:58 +0000

In secure software development, static application security testing (SAST) is a crucial technique for identifying vulnerabilities before an application reaches production. This article demonstrates the application of the RIPS Code Analysis tool on a small PHP web application to identify potential security risks through automated analysis.

What is RIPS?

RIPS (Real-time Intrusion Prevention System) is a tool specialized in analyzing PHP source code. It is widely recognized for its ability to detect vulnerabilities such as SQL injections, XSS, CSRF, file inclusion, and other common errors in PHP applications. RIPS analyzes data flow and code structure to pinpoint potential attack vectors.

Although RIPS has been acquired by SonarSource, the free version is still available and valid for academic or testing purposes.

Installation and Use of RIPS (Free Version)

For this article, the free version of RIPS was used, which can be run locally through a browser. The following steps were followed:

Download the ZIP file from a reliable repository (e.g., GitHub: RIPS).
Extract the files to a local server (XAMPP, WAMP, or any PHP environment).
Access it through the browser at the local path, for example:

http://localhost/RIPS/

4.Select the PHP source code directory you wish to analyze.

PHP Application

Below is the PHP code used for the analysis:

<?php
// file: greeting.php
$name = $_GET['name'];
echo "Hello, " . $name;
?>

This code appears harmless, but it has a security issue: the content displayed comes directly from the user (via $_GET) and is not validated.

What Does RIPS Detect in This Code?

When analyzing this file with RIPS, it reports:

⚠️ Cross-Site Scripting (XSS): Since we are displaying something from the user ($name) without validating it, an attacker could enter:

http://localhost/greeting.php?name=<script>alert('Hacked')</script>

This would trigger a popup on the page, demonstrating that the site is vulnerable.

How to Fix It?

One way to fix this issue is by using htmlspecialchars() to sanitize the input before displaying it:

<?php
// file: greeting_safe.php
$name = htmlspecialchars($_GET['name']);
echo "Hello, " . $name;
?>

With this change, if someone tries to inject code, the browser will not execute it.

Conclusion

RIPS is a useful and easy-to-use tool for finding security flaws in PHP code. In this case, it helped us identify that we were displaying user input without validation, which could be dangerous.

Thanks to RIPS's analysis, we were able to fix the Cross-Site Scripting (XSS) issue and make our application more secure.

Deploying a Node.js Application on AWS

Mayra — Sat, 06 Jul 2024 03:10:29 +0000

Deploying applications to the cloud is essential for modern software development, offering scalability, reliability, and cost-efficiency. AWS (Amazon Web Services) is a leading cloud service provider that offers various deployment options such as Elastic Beanstalk, EC2, and Lambda. This article focuses on deploying a Node.js application using AWS Elastic Beanstalk, highlighting its simplicity and efficiency.

Why Choose AWS?
AWS provides several advantages for application deployment:

Scalability: AWS services can automatically scale to handle increased traffic and workload.
Reliability: AWS's global infrastructure ensures high availability and fault tolerance.
Cost-Effectiveness: Pay-as-you-go pricing allows optimized cost management.
Flexibility: A wide range of services cater to different deployment needs, from fully managed services to more granular control.

AWS Deployment Options

- Elastic Beanstalk

Elastic Beanstalk simplifies deployment and management by handling the
underlying infrastructure.

- EC2 (Elastic Compute Cloud)

Provides scalable virtual servers, offering more control over the
deployment environment.

- Lambda

Enables serverless deployment, allowing code execution in response to
events without managing servers.

Deploying a Node.js Application Using AWS Elastic Beanstalk

Prerequisites
Before you start, ensure you have:

An AWS account
AWS Command Line Interface (CLI) installed and configured
Node.js installed on your local machine

Step-by-Step Deployment Guide

Step 1: Set Up Your Environment

Install AWS CLI: Download and install the AWS CLI. Configure it with your AWS credentials:

aws configure

Install Elastic Beanstalk CLI: Install the Elastic Beanstalk CLI to interact with the service:

pip install awsebcli

- Create a New Directory for Your Project:

mkdir my-aws-app
cd my-aws-app

Step 2: Initialize Your Application

- Initialize Elastic Beanstalk:
Set up a new Elastic Beanstalk application in your project directory:

eb init -p node.js my-aws-app

Step 3: Create Your Node.js Application

- Create a Simple Express Application:
Initialize a new Node.js project and install Express.js:

npm init -y
npm install express

-Create app.js with the following content:

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

app.get('/', (req, res) => {
  res.send('Hello, AWS Elastic Beanstalk!');
});

const port = process.env.PORT || 3000;
app.listen(port, () => {
  console.log(`Server running on port ${port}`);
});

- Update package.json:
Ensure your package.json includes a start script:

{
  "name": "my-aws-app",
  "version": "1.0.0",
  "description": "A simple Node.js app on AWS Elastic Beanstalk",
  "main": "app.js",
  "scripts": {
    "start": "node app.js"
  },
  "dependencies": {
    "express": "^4.17.1"
  }
}

Step 4: Deploy Your Application
Create a new environment for your application:

eb create my-aws-env

- Deploy Your Application:
Deploy your application to the created environment:

eb deploy

Step 5: Monitor Your Application

- Open Your Application in Your Browser:
After deployment, open your application using:

eb open

- Monitor Environment Health:
Use the Elastic Beanstalk dashboard on the AWS Management Console to monitor your application's health, logs, and metrics.

Conclusion
AWS Elastic Beanstalk simplifies the deployment process, allowing developers to focus on building applications rather than managing infrastructure. By following this guide, you can efficiently deploy a Node.js application on AWS and leverage AWS's robust cloud services.

API Architecture Styles: Sockets

Mayra — Wed, 12 Jun 2024 03:49:30 +0000

API architecture is fundamental to modern application development, enabling efficient communication between different systems. One architecture style particularly useful for real-time communication is the use of sockets. This article provides a comprehensive introduction to sockets, how they work, their practical applications and a code example.

What are Sockets?

A socket is like a digital plug that allows two different computer programs to communicate with each other over a network. Sockets are like a telephone line that connects two people, allowing them to talk and listen at the same time. Using sockets, applications can send and receive data in real time. Sockets can use different protocols, such as TCP for a secure and reliable connection, or UDP for faster but less secure communication.

How Sockets Work

To understand how sockets work, let's consider a simple analogy: a telephone conversation between two people.

Opening the Connection:
Client and Server: In the context of sockets, one program acts as a server (waiting for incoming connections) and another as a client (initiating the connection).
IP Address and Port: To establish a connection, the client needs to know the IP address of the server and the port on which the server is listening.
Connection Establishment:
TCP: Uses a three-way handshake process to ensure a reliable connection.
UDP: Does not require a handshake and is ideal for applications that need to transmit data quickly without concern for reliability (e.g., live video streams).
Data Exchange:
Bidirectional: Once the connection is established, both ends can send and receive data simultaneously, as in a telephone conversation where both people can talk and listen at the same time.
Closing the Connection:
Termination: At the end of the communication, both ends close the connection to free up resources.

Basic Example of Sockets in Python

To illustrate how sockets work, here is a simple example of a server and a client in Python.

Server (server.py):

import socket
#Create a TCP/IP socket
server_socket = socket.socket()
server_socket.bind(('localhost', 9999))
server_socket.listen(1)
#
print("Esperando conexión...")
connection, address = server_socket.accept()
print("Conexión establecida desde:", address)
#We receive customer data
data = connection.recv(1024)
print("Mensaje recibido:", data.decode())
#We send a response to the customer
connection.sendall(data)
#We close the connection
connection.close()

Cliente (client.py):

#Create a TCP/IP socket
client_socket = socket.socket()
client_socket.connect(('localhost', 9999))
#We send a message to the servermessage = "Hola, soy el cliente"
client_socket.sendall(message.encode())
#We received the response from the server
data = client_socket.recv(1024)
print("Respuesta del servidor:", data.decode())
#We close the connection
client_socket.close()

This example shows how a client connects to a server, sends a message and receives a response. The server listens for incoming connections, receives data and responds with the same data.

Practical Applications of Sockets

Live Chats:

Example: applications such as WhatsApp and Telegram use sockets to send and receive messages instantaneously. Each message sent is translated into data that travels through a socket to the recipient in real time.

Online Games:

Example: Multiplayer games like Fortnite and Call of Duty rely on sockets to synchronize player actions in real time, providing a fluid and responsive gaming experience.

Sockets are an essential technology for real-time communication in a variety of modern applications. From live chats to online games and live video streams, sockets enable seamless and continuous interaction between clients and servers. Although they can be complex to implement, the benefits they offer in terms of speed and bidirectionality make them indispensable in the development of real-time and interactive applications.