DEV Community: AUGUSTO JOAQUIN RIVERA MUÑOZ

Enterprise Patterns en Golang: Desacoplando tu código con el Patrón Repositorio

AUGUSTO JOAQUIN RIVERA MUÑOZ — Sat, 06 Dec 2025 01:21:43 +0000

¡Entendido! Aquí tienes el contenido listo para copiar y pegar. He elegido el lenguaje Golang (Go) porque es el estándar actual para desarrollo backend empresarial de alto rendimiento y se ajusta perfectamente a los patrones de arquitectura limpia.

El patrón elegido es el Repository Pattern (Patrón Repositorio), uno de los más fundamentales del libro de Martin Fowler para desacoplar la lógica de negocio de la base de datos.

Parte 1: El Artículo (Para Dev.To / Medium / HashNode)
Título: 🏛️ Enterprise Patterns en Golang: Desacoplando tu código con el Patrón Repositorio

Subtítulo: Cómo aplicar las enseñanzas de Martin Fowler en el desarrollo moderno de microservicios con Go.

Tags: #Golang #SoftwareArchitecture #DesignPatterns #Backend #CleanCode

Introducción: El problema del acoplamiento
Cuando leemos "Patterns of Enterprise Application Architecture" de Martin Fowler, a veces pensamos en sistemas monolíticos antiguos de Java. Sin embargo, estos patrones son más relevantes que nunca en la era de los microservicios.

Un error común en aplicaciones Go es mezclar las consultas SQL (SELECT * FROM...) directamente dentro de los controladores HTTP o la lógica de negocio. Esto hace que el código sea imposible de testear y difícil de migrar.

Hoy implementaremos el Repository Pattern. Este patrón crea una capa de abstracción entre el dominio (tu lógica) y el mapeo de datos (tu base de datos), permitiendo que tu aplicación evolucione sin romper el núcleo del negocio.

El Escenario
Imaginemos un sistema empresarial de gestión de empleados. Necesitamos crear un empleado y guardarlo. No nos importa si se guarda en Postgres, MySQL o en Memoria; nuestra lógica de negocio no debería saberlo.

La Implementación en Go
Primero, definimos nuestra Entidad (El Dominio).

// domain/employee.go
package domain

type Employee struct {
    ID        string
    Name      string
    Role      string
    Salary    float64
}

Ahora, la clave del patrón: La Interfaz del Repositorio. Esto es el contrato que define qué necesitamos, sin decir cómo se hace.

// domain/repository.go
package domain

// EmployeeRepository define el contrato para acceder a los datos
type EmployeeRepository interface {
    Save(employee *Employee) error
    FindByID(id string) (*Employee, error)
}

Implementamos la lógica de negocio (Service Layer). Fíjate cómo el servicio pide un EmployeeRepository en su constructor. Esto es Inyección de Dependencias.

// service/employee_service.go
package service

import (
    "errors"
    "enterprise-patterns/domain"
)

type EmployeeService struct {
    repo domain.EmployeeRepository
}

func NewEmployeeService(repo domain.EmployeeRepository) *EmployeeService {
    return &EmployeeService{repo: repo}
}

func (s *EmployeeService) RegisterEmployee(id, name, role string) error {
    if name == "" {
        return errors.New("el nombre no puede estar vacío")
    }

    // Lógica de negocio: Regla empresarial
    // "Solo los gerentes pueden tener bonos iniciales (simulado aquí)"
    emp := &domain.Employee{
        ID:   id,
        Name: name,
        Role: role,
    }

    return s.repo.Save(emp)
}

Finalmente, la implementación concreta (La infraestructura). Aquí es donde iría SQL, pero usaremos un mapa en memoria para el demo.

// infrastructure/memory_repo.go
package infrastructure

import (
    "errors"
    "enterprise-patterns/domain"
)

type InMemoryEmployeeRepo struct {
    store map[string]*domain.Employee
}

func NewInMemoryRepo() *InMemoryEmployeeRepo {
    return &InMemoryEmployeeRepo{
        store: make(map[string]*domain.Employee),
    }
}

func (r *InMemoryEmployeeRepo) Save(employee *domain.Employee) error {
    if _, exists := r.store[employee.ID]; exists {
        return errors.New("el empleado ya existe")
    }
    r.store[employee.ID] = employee
    return nil
}

func (r *InMemoryEmployeeRepo) FindByID(id string) (*domain.Employee, error) {
    if emp, ok := r.store[id]; ok {
        return emp, nil
    }
    return nil, errors.New("empleado no encontrado")
}

Uso en el main.go
Así es como unimos todo:

// main.go
package main

import (
    "fmt"
    "enterprise-patterns/infrastructure"
    "enterprise-patterns/service"
)

func main() {
    // 1. Crear la implementación concreta (Infraestructura)
    repo := infrastructure.NewInMemoryRepo()

    // 2. Inyectar el repositorio en el servicio (Dominio)
    empService := service.NewEmployeeService(repo)

    // 3. Ejecutar la lógica
    err := empService.RegisterEmployee("001", "Carlos Dev", "Senior Engineer")

    if err != nil {
        fmt.Println("Error:", err)
    } else {
        fmt.Println("Empleado registrado exitosamente usando Repository Pattern!")
    }
}

Conclusión
Al usar el Repository Pattern, hemos logrado que nuestro EmployeeService sea 100% agnóstico de la base de datos. Si mañana queremos cambiar de memoria a MongoDB, solo creamos un nuevo archivo en infrastructure y no tocamos ni una línea de la lógica de negocio. Eso es arquitectura empresarial robusta.

Testing Management Tools: A Complete Comparative Guide with Real-World Examples

AUGUSTO JOAQUIN RIVERA MUÑOZ — Tue, 02 Dec 2025 16:44:24 +0000

Introduction

In today's fast-paced software development landscape, choosing the right testing and CI/CD management tool is crucial for team productivity and code quality. With numerous options available—each with unique features, pricing models, and integration capabilities—developers often face a challenging decision.

This comprehensive guide compares the most popular testing management and CI/CD platforms, providing real-world code examples and public repository references to help you make an informed choice.

Featured Tools Overview

GitHub Actions: Native CI/CD for GitHub repositories
GitLab CI: Integrated pipeline automation within GitLab
Jenkins: Open-source automation server
CircleCI: Cloud-based CI/CD platform
Bitbucket Pipelines: Atlassian's automation solution
Travis CI: Continuous integration service
TeamCity: JetBrains' build management system
Tekton: Kubernetes-native CI/CD framework
Harness: Enterprise continuous delivery platform

1. GitHub Actions

Key Features

Native integration with GitHub repositories
Free tier with unlimited public repositories
YAML-based workflow configuration
Extensive marketplace of pre-built actions
Strong community support

Real-World Example: Node.js Testing Pipeline

name: Node.js CI/CD
on:
  push:
    branches: [main, develop]
  pull_request:
    branches: [main]

jobs:
  test:
    runs-on: ubuntu-latest
    strategy:
      matrix:
        node-version: [16.x, 18.x]
    steps:
      - name: Checkout code
        uses: actions/checkout@v3
      - name: Setup Node.js
        uses: actions/setup-node@v3
        with:
          node-version: ${{ matrix.node-version }}
      - name: Install dependencies
        run: npm ci
      - name: Run linter
        run: npm run lint
      - name: Run tests
        run: npm test
      - name: Upload coverage
        uses: codecov/codecov-action@v3

Public Repository Examples

microsoft/vscode - Uses GitHub Actions extensively
facebook/react - Complex testing workflows

2. GitLab CI

Key Features

Built-in CI/CD without third-party integration
Docker support out of the box
.gitlab-ci.yml configuration file
Free tier for public projects
Comprehensive artifact management

Real-World Example: Python Application Pipeline

stages:
  - lint
  - test
  - build
  - deploy

lint:
  stage: lint
  image: python:3.9
  script:
    - pip install flake8 black
    - black --check .
    - flake8 .

test:
  stage: test
  image: python:3.9
  services:
    - postgres:13
  variables:
    POSTGRES_DB: test_db
    POSTGRES_USER: user
    POSTGRES_PASSWORD: password
  script:
    - pip install -r requirements.txt
    - pytest --cov=. --cov-report=xml
  coverage: '/TOTAL.*?\s+(\d+%)$/'
  artifacts:
    reports:
      coverage_report:
        coverage_format: cobertura
        path: coverage.xml

build:
  stage: build
  image: docker:latest
  services:
    - docker:dind
  script:
    - docker build -t myapp:$CI_COMMIT_SHA .
    - docker tag myapp:$CI_COMMIT_SHA myapp:latest

Public Repository Examples

gitlab-examples/gitlab-ci-examples

3. Jenkins

Key Features

Open-source and highly extensible
Vast plugin ecosystem (1800+ plugins)
Support for distributed builds
Pipeline as Code with Jenkinsfile
On-premise deployment

Real-World Example: Java Application with Jenkinsfile

pipeline {
    agent any

    environment {
        MAVEN_HOME = tool 'Maven3'
        PATH = "${MAVEN_HOME}/bin:${PATH}"
    }

    stages {
        stage('Checkout') {
            steps {
                checkout scm
            }
        }

        stage('Build') {
            steps {
                sh 'mvn clean compile'
            }
        }

        stage('Test') {
            steps {
                sh 'mvn test'
            }
            post {
                always {
                    junit 'target/surefire-reports/*.xml'
                }
            }
        }

        stage('Code Quality') {
            steps {
                sh 'mvn sonar:sonar -Dsonar.projectKey=myapp'
            }
        }

        stage('Package') {
            steps {
                sh 'mvn package -DskipTests'
            }
        }

        stage('Deploy') {
            when {
                branch 'main'
            }
            steps {
                sh 'docker build -t myapp:${BUILD_NUMBER} .'
                sh 'docker push myapp:${BUILD_NUMBER}'
            }
        }
    }

    post {
        always {
            cleanWs()
        }
        failure {
            emailext(
                subject: 'Build Failed: ${PROJECT_NAME}',
                body: 'Build failed. Check Jenkins for details.',
                to: '${DEFAULT_RECIPIENTS}'
            )
        }
    }
}

Public Repository Examples

jenkinsci/jenkins - Jenkins itself uses Jenkins

4. CircleCI

Key Features

Cloud-hosted with no infrastructure management
Fast builds with optimized environment
Generous free tier
Reusable workflow components (Orbs)
Excellent documentation

Real-World Example: React Application Pipeline

version: 2.1

orbs:
  node: circleci/node@5.1.0

commands:
  install_and_test:
    steps:
      - node/install-packages:
          pkg-manager: npm
      - run:
          name: Run linter
          command: npm run lint
      - run:
          name: Run tests
          command: npm test -- --coverage
      - run:
          name: Build application
          command: npm run build

jobs:
  test:
    executor: node/default
    steps:
      - checkout
      - install_and_test
      - store_artifacts:
          path: coverage
      - store_test_results:
          path: test-results

  deploy:
    executor: node/default
    steps:
      - checkout
      - install_and_test
      - run:
          name: Deploy to production
          command: npm run deploy

workflows:
  test-and-deploy:
    jobs:
      - test
      - deploy:
          requires:
            - test
          filters:
            branches:
              only: main

Public Repository Examples

laravel/laravel - Uses CircleCI

5. Bitbucket Pipelines

Key Features

Integrated with Bitbucket repositories
Atlassian ecosystem integration
Built-in Docker support
bitbucket-pipelines.yml configuration
Free tier for small teams

Real-World Example: Go Application Pipeline

image: golang:1.19

pipelines:
  default:
    - step:
        name: Build and Test
        caches:
          - go
        script:
          - go get ./...
          - go test -v ./...
          - go build -o app .
        artifacts:
          - app

  branches:
    main:
      - step:
          name: Build and Test
          caches:
            - go
          script:
            - go get ./...
            - go test -v ./...
            - go build -o app .
      - step:
          name: Deploy
          trigger: manual
          script:
            - docker build -t myapp:latest .
            - docker push myapp:latest

Comparison Table

Feature	GitHub Actions	GitLab CI	Jenkins	CircleCI	Bitbucket
Hosted/Self	Hosted	Both	Self	Hosted	Hosted
Cost	Free (public)	Free (public)	Free	Free tier	Free tier
Learning Curve	Easy	Medium	Hard	Easy	Easy
Integration	GitHub native	GitLab native	Any	Any	Bitbucket native
Scaling	Excellent	Excellent	Requires setup	Excellent	Good
Community Support	Excellent	Very Good	Excellent	Very Good	Good

Best Practices When Choosing a Tool

Consider Your Repository Host: If already using GitHub, GitHub Actions is often the simplest choice
Evaluate Scalability: For large teams, consider Jenkins or self-hosted GitLab CI
Test Integration Needs: Ensure the tool integrates with your other services
Check Community Resources: Strong community support means better documentation and troubleshooting
Start with Free Tier: Most tools offer generous free tiers—experiment first
Plan for Growth: Consider your team's growth and the tool's pricing model

Conclusion

There is no one-size-fits-all solution for CI/CD and testing management. Your choice depends on your specific needs, team size, technology stack, and budget. GitHub Actions excels for GitHub users, GitLab CI for GitLab users, Jenkins for customization needs, CircleCI for rapid setup, and Bitbucket Pipelines for Atlassian ecosystems.

Start by testing your top choices with your actual project to see which feels most natural to your workflow.

Resources & Public Examples

GitHub Actions Documentation
GitLab CI/CD Documentation
Jenkins Documentation
CircleCI Documentation
Bitbucket Pipelines Documentation
Awesome CI/CD - Curated list of CI/CD resources

Share your experience in the comments! Which CI/CD tool do you prefer and why? Have you successfully migrated between platforms? I'd love to hear your insights!

Build Your First Remote MCP Server on Cloudflare Workers

AUGUSTO JOAQUIN RIVERA MUÑOZ — Mon, 01 Dec 2025 04:08:49 +0000

Remote MCP (Model Context Protocol) servers enable AI clients like Claude Desktop or VSCode extensions to securely interact with external tools via standardized SSE endpoints, deployable in minutes on Cloudflare Workers.

What is MCP?
MCP standardizes how large language models connect to services, acting like a universal interface for tools, resources, and prompts. Cloudflare simplifies remote servers with built-in OAuth, Durable Objects for state, and SSE transport, eliminating manual serialization or routing code. Clients connect via URLs like https://your-mcp.workers.dev/sse, supporting authentication flows.

Quickstart Deployment
Create a public authless server using Cloudflare's template: run npm create cloudflare@latest -- my-mcp-server --template=cloudflare/ai/demos/remote-mcp-authless in your terminal. This generates a Worker exposing basic tools; deploy with npx wrangler deploy after logging in via npx wrangler login. The server runs at remote-mcp-server-authless..workers.dev/sse, ready for Claude or VSCode connection without custom code.

For authenticated setups, wrap your MCP logic in Cloudflare's OAuthProvider: import libraries like @modelcontextprotocol/sdk/server/mcp.js and define tools with Zod schemas, e.g., a counter tool persisting state via Durable Objects.

Public Example Repository
Deploy Google's Cloud Run MCP server from https://github.com/GoogleCloudPlatform/cloud-run-mcp, which provides tools like deploy-local-folder for app deployments. Configure in VSCode with "command": "npx", "args": ["-y", "@google-cloud/cloud-run-mcp"] after GCP auth, or connect Claude Desktop to its SSE endpoint. Test by listing services: the repo includes full setup for production use.

Connecting Clients
In Claude Desktop, add the SSE URL under MCP settings and authenticate if needed; VSCode uses extensions like Cline with mcp-remote adapter for legacy support. Tools appear as callable functions, e.g., incrementing counters or generating images via @cf/black-forest-labs/flux-1-schnell. Sessions maintain state across calls, enabling agentic workflows like persistent todos.

Enterprise Design Patterns: Practical Examples from Martin Fowler's Catalog

AUGUSTO JOAQUIN RIVERA MUÑOZ — Mon, 15 Sep 2025 00:43:04 +0000

Enterprise applications handle complex business processes and data at scale. To manage this complexity, established design patterns provide reusable architectural solutions that promote maintainability, scalability, and clarity. Martin Fowler’s Patterns of Enterprise Application Architecture catalog organizes these solutions into categories that guide developers in building robust enterprise software.

This article introduces three fundamental Enterprise Design Patterns — Repository, Service Layer, and Model View Controller (MVC) — with real code examples in Python.

Repository Pattern
The Repository pattern mediates between the domain and data mapping layers, providing a clean API to access domain objects without exposing database details.

Example in Python

class Customer:
    def __init__(self, customer_id, name):
        self.customer_id = customer_id
        self.name = name

class CustomerRepository:
    def __init__(self):
        self.customers = {}

    def add(self, customer: Customer):
        self.customers[customer.customer_id] = customer

    def get_by_id(self, customer_id):
        return self.customers.get(customer_id)

repo = CustomerRepository()
repo.add(Customer(1, "Alice"))
print(repo.get_by_id(1))  # Customer object for Alice

Service Layer Pattern
This pattern centralizes an application's business logic in a service layer, decoupling it from controllers or UI components, improving modularity and testability.

Example in Python

class OrderService:
    def __init__(self, customer_repo):
        self.customer_repo = customer_repo

    def place_order(self, customer_id, items):
        customer = self.customer_repo.get_by_id(customer_id)
        if not customer:
            raise ValueError("Customer not found")
        # Process order for the customer
        print(f"Order placed for {customer.name} with items: {items}")

customer_repo = CustomerRepository()
customer_repo.add(Customer(1, "Alice"))

order_service = OrderService(customer_repo)
order_service.place_order(1, ["item1", "item2"])

Model View Controller (MVC) Pattern
MVC separates an application into three components: Model (business logic/data), View (UI), and Controller (handles input and updates).

Basic Python Console Example

class Model:
    def __init__(self):
        self.data = "Hello from Model"

class View:
    def display(self, data):
        print(f"View displaying: {data}")

class Controller:
    def __init__(self, model, view):
        self.model = model
        self.view = view

    def update_view(self):
        data = self.model.data
        self.view.display(data)

model = Model()
view = View()
controller = Controller(model, view)
controller.update_view()

Final Remarks
These patterns provide powerful ways to architect scalable and maintainable enterprise applications. Applying them effectively can reduce code duplication, isolate concerns, and improve clarity, leading to higher-quality software.

Software Design Principles: A Practical Example in Python

AUGUSTO JOAQUIN RIVERA MUÑOZ — Mon, 15 Sep 2025 00:36:38 +0000

Introduction
Software design principles are essential guidelines that help developers create maintainable, scalable, and flexible software. Rather than simply writing code that works, good design ensures that software is easy to extend, understand, and test over time.

Some core principles include SOLID, DRY, KISS, and YAGNI. This article focuses on the SOLID principles, showing how they apply in a real-world Python example: designing a notification system that is extensible and testable.

The SOLID Principles Overview

Single Responsibility Principle (SRP): A class should have only one reason to change.
Open/Closed Principle (OCP): Software entities should be open for extension, but closed for modification.
Liskov Substitution Principle (LSP): Subtypes must be substitutable for their base types.
Interface Segregation Principle (ISP): Clients shouldn’t be forced to depend on interfaces they don’t use.
Dependency Inversion Principle (DIP): High-level modules shouldn’t depend on low-level modules; both should depend on abstractions.

Real-World Example: Notification System in Python
Imagine a system that sends notifications via multiple channels: Email and SMS. We want to design it so adding new channels (e.g., Push notifications, Webhooks) is easy without modifying existing code.

Step 1: Define an abstraction for notification

from abc import ABC, abstractmethod

class Notifier(ABC):
    @abstractmethod
    def send(self, message: str, recipient: str):
        pass

Step 2: Implement concrete notifiers

class EmailNotifier(Notifier):
    def send(self, message: str, recipient: str):
        print(f"Sending Email to {recipient}: {message}")

class SMSNotifier(Notifier):
    def send(self, message: str, recipient: str):
        print(f"Sending SMS to {recipient}: {message}")

Step 3: Create a notification service that uses dependency injection

class NotificationService:
    def __init__(self, notifier: Notifier):
        self.notifier = notifier

    def notify(self, message: str, recipient: str):
        self.notifier.send(message, recipient)

Step 4: Usage example

if __name__ == "__main__":
    email_notifier = EmailNotifier()
    sms_notifier = SMSNotifier()

    service = NotificationService(email_notifier)
    service.notify("Welcome!", "user@example.com")

    service = NotificationService(sms_notifier)
    service.notify("Your code is 1234", "+1234567890")

Explanation

Each notifier class has a single responsibility (SRP).
Adding new notification channels does not modify existing classes, but extends functionality (OCP).
NotificationService depends on the abstraction Notifier (DIP), promoting flexibility.
Different concrete implementations can be swapped without changing the service (LSP).

Visualization and Dashboard Tools in Python: Streamlit, Dash, and Bokeh (with Code Examples and Cloud Deployment)

AUGUSTO JOAQUIN RIVERA MUÑOZ — Sun, 14 Sep 2025 02:17:19 +0000

Data visualization plays a crucial role in data science, analysis, and interactive application development. To convert data into dynamic visual experiences, Python offers tools that simplify building dashboards and reports without deep web development knowledge. Among these, Streamlit, Dash, and Bokeh stand out, each with unique features, strengths, and use cases.

This article provides an overview of these tools, practical code examples, and guidelines for deploying applications to the cloud, enabling easy access and collaboration.

What Are Streamlit, Dash, and Bokeh?

**Streamlit **is a Python library to build interactive web apps quickly with minimal lines of code. It’s ideal for prototyping and small applications thanks to its ease and speed.
Dash, created by Plotly, is a more robust and structured framework suited for enterprise applications requiring higher customization and complexity.
**Bokeh **focuses on creating interactive, high-performance visualizations, with strong capabilities for detailed and rich visual applications.

Code Examples

import streamlit as st
import pandas as pd
import numpy as np

st.title("Dashboard with Streamlit")

data = pd.DataFrame({
    'A': np.random.randn(100),
    'B': np.random.randn(100)
})

st.line_chart(data)

Dash

from dash import Dash, html, dcc
import plotly.express as px
import pandas as pd

app = Dash(__name__)

df = pd.DataFrame({
    "Category": ["A", "B", "C"],
    "Values": [4, 1, 2]
})

fig = px.bar(df, x="Category", y="Values")

app.layout = html.Div([
    html.H1("Dashboard with Dash"),
    dcc.Graph(figure=fig)
])

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

Bokeh

from bokeh.plotting import figure, show
from bokeh.io import output_file

output_file("plot.html")

p = figure(title="Scatter Plot")

p.circle([1, 2, 3, 4, 5], [6, 7, 2, 4, 5], size=15, color="navy", alpha=0.5)

show(p)

Cloud Deployment

Streamlit Community Cloud

Push your app code and requirements.txt to GitHub.
Connect your GitHub account to https://streamlit.io/cloud.
Select the repository and main script (e.g., app.py).
Deploy the app with one click and get a public URL.

Dash on Google Cloud Run (or similar services)

Containerize your Dash app with Docker.
Push the Docker image to Google Container Registry.
Deploy the container using Google Cloud Run to access a public URL.

Bokeh on Posit Connect or Google Cloud Run

Prepare the app for execution with bokeh serve.
Deploy the app on Posit Connect or as a Docker container in Google Cloud Run.
Access your interactive visualizations via a public URL.

Quick Comparison

Final Thoughts

These tools democratize the creation of interactive dashboards and reports, allowing Python developers and data scientists to share insights beyond static graphics. Cloud deployment eases collaboration and remote access, a crucial step to bring projects from local environments to production.

Teams are encouraged to experiment with these tools and share use cases, benefits, and challenges according to their needs.