Patrón Blackboard

Descripción General

El Patrón Blackboard es un patrón de diseño behavioral que provee un espacio de conocimiento compartido (el blackboard) donde módulos independientes y especializados llamados Knowledge Sources colaboran para resolver problemas complejos. Cada Knowledge Source lee del blackboard, evalúa el estado actual, y contribuye soluciones parciales cuando puede.

El patrón brilla cuando ningún único algoritmo puede resolver un problema, pero múltiples heurísticas especializadas pueden abordarlo incrementalmente. Un componente Control orquesta el proceso, decidiendo qué Knowledge Source debería actuar siguiente basado en el estado actual del blackboard.

Aplicaciones del mundo real incluyen reconocimiento de voz, procesamiento de lenguaje natural, reconocimiento de imágenes, y problemas de optimización donde múltiples heurísticas contribuyen soluciones parciales.

Cuándo Usar

Usa el Patrón Blackboard cuando:

• Ningún algoritmo determinístico puede resolver el problema
• Múltiples heurísticas o algoritmos especializados pueden contribuir soluciones parciales
• El espacio de problema es grande y requiere exploración
• Las soluciones pueden ser refinadas incrementalmente por módulos independientes
• Necesitas una arquitectura flexible y extensible para sistemas de IA o heurísticas

Cuándo Evitar

• Problemas simples solucionables por un único algoritmo
• Requerimientos de performance estrictos donde el overhead de coordinación es inaceptable
• Cuando comportamiento determinístico y predecible es requerido
• Sistemas pequeños donde la complejidad de coordinación supera los beneficios

Solución

Python

from abc import ABC, abstractmethod
from dataclasses import dataclass, field
from typing import List, Dict, Any, Optional
from enum import Enum
import random

class Confidence(Enum):
    LOW = 1
    MEDIUM = 2
    HIGH = 3

@dataclass
class Hypothesis:
    content: str
    confidence: Confidence
    source: str

@dataclass
class Blackboard:
    hypotheses: List[Hypothesis] = field(default_factory=list)
    final_solution: Optional[str] = None
    complete: bool = False

    def add_hypothesis(self, hypothesis: Hypothesis):
        self.hypotheses.append(hypothesis)

    def get_best_hypothesis(self) -> Optional[Hypothesis]:
        if not self.hypotheses:
            return None
        return max(self.hypotheses, key=lambda h: h.confidence.value)

    def set_solution(self, solution: str):
        self.final_solution = solution
        self.complete = True


class KnowledgeSource(ABC):
    def __init__(self, name: str):
        self.name = name

    @abstractmethod
    def can_contribute(self, blackboard: Blackboard) -> bool:
        pass

    @abstractmethod
    def contribute(self, blackboard: Blackboard):
        pass


class PatternMatcher(KnowledgeSource):
    def can_contribute(self, blackboard: Blackboard) -> bool:
        return len(blackboard.hypotheses) < 3

    def contribute(self, blackboard: Blackboard):
        bb = blackboard
        bb.add_hypothesis(Hypothesis(
            content="Patrón detectado: probablemente función",
            confidence=Confidence.MEDIUM,
            source=self.name
        ))


class SemanticAnalyzer(KnowledgeSource):
    def can_contribute(self, blackboard: Blackboard) -> bool:
        return any(h.source == "PatternMatcher" for h in blackboard.hypotheses)

    def contribute(self, blackboard: Blackboard):
        bb = blackboard
        bb.add_hypothesis(Hypothesis(
            content="Análisis semántico: intención de usuario es ejecución de query",
            confidence=Confidence.HIGH,
            source=self.name
        ))


class ConfidenceEvaluator(KnowledgeSource):
    def can_contribute(self, blackboard: Blackboard) -> bool:
        best = blackboard.get_best_hypothesis()
        return best is not None and best.confidence == Confidence.HIGH

    def contribute(self, blackboard: Blackboard):
        best = blackboard.get_best_hypothesis()
        if best:
            blackboard.set_solution(best.content)


class Controller:
    def __init__(self, blackboard: Blackboard, sources: List[KnowledgeSource]):
        self.blackboard = blackboard
        self.sources = sources

    def solve(self, max_iterations: int = 10):
        for _ in range(max_iterations):
            if self.blackboard.complete:
                break

            for source in self.sources:
                if source.can_contribute(self.blackboard):
                    source.contribute(self.blackboard)
                    break


# Uso
bb = Blackboard()
sources = [
    PatternMatcher("PatternMatcher"),
    SemanticAnalyzer("SemanticAnalyzer"),
    ConfidenceEvaluator("ConfidenceEvaluator"),
]
controller = Controller(bb, sources)
controller.solve()

print(f"Solución: {bb.final_solution}")
print(f"Todas las hipótesis: {[h.content for h in bb.hypotheses]}")

Java

import java.util.*;

enum Confidence { LOW, MEDIUM, HIGH }

record Hypothesis(String content, Confidence confidence, String source) {}

class Blackboard {
    private final List<Hypothesis> hypotheses = new ArrayList<>();
    private String finalSolution;
    private boolean complete = false;

    public void addHypothesis(Hypothesis h) { hypotheses.add(h); }
    public List<Hypothesis> getHypotheses() { return hypotheses; }
    public boolean isComplete() { return complete; }

    public Hypothesis getBestHypothesis() {
        return hypotheses.stream()
            .max(Comparator.comparingInt(h -> h.confidence().ordinal()))
            .orElse(null);
    }

    public void setSolution(String solution) {
        this.finalSolution = solution;
        this.complete = true;
    }

    public String getFinalSolution() { return finalSolution; }
}

abstract class KnowledgeSource {
    protected final String name;
    public KnowledgeSource(String name) { this.name = name; }
    public String getName() { return name; }

    public abstract boolean canContribute(Blackboard bb);
    public abstract void contribute(Blackboard bb);
}

class PatternMatcher extends KnowledgeSource {
    public PatternMatcher() { super("PatternMatcher"); }
    public boolean canContribute(Blackboard bb) { return bb.getHypotheses().size() < 3; }
    public void contribute(Blackboard bb) {
        bb.addHypothesis(new Hypothesis("Patrón detectado: probablemente función", Confidence.MEDIUM, name));
    }
}

class SemanticAnalyzer extends KnowledgeSource {
    public SemanticAnalyzer() { super("SemanticAnalyzer"); }
    public boolean canContribute(Blackboard bb) {
        return bb.getHypotheses().stream().anyMatch(h -> h.source().equals("PatternMatcher"));
    }
    public void contribute(Blackboard bb) {
        bb.addHypothesis(new Hypothesis("Semántica: intención de usuario es query execution", Confidence.HIGH, name));
    }
}

class ConfidenceEvaluator extends KnowledgeSource {
    public ConfidenceEvaluator() { super("ConfidenceEvaluator"); }
    public boolean canContribute(Blackboard bb) {
        Hypothesis best = bb.getBestHypothesis();
        return best != null && best.confidence() == Confidence.HIGH;
    }
    public void contribute(Blackboard bb) {
        Hypothesis best = bb.getBestHypothesis();
        if (best != null) bb.setSolution(best.content());
    }
}

class Controller {
    private final Blackboard blackboard;
    private final List<KnowledgeSource> sources;

    public Controller(Blackboard blackboard, List<KnowledgeSource> sources) {
        this.blackboard = blackboard;
        this.sources = sources;
    }

    public void solve(int maxIterations) {
        for (int i = 0; i < maxIterations && !blackboard.isComplete(); i++) {
            for (KnowledgeSource source : sources) {
                if (source.canContribute(blackboard)) {
                    source.contribute(blackboard);
                    break;
                }
            }
        }
    }
}

// Uso
Blackboard bb = new Blackboard();
List<KnowledgeSource> sources = List.of(
    new PatternMatcher(),
    new SemanticAnalyzer(),
    new ConfidenceEvaluator()
);
Controller controller = new Controller(bb, sources);
controller.solve(10);
System.out.println("Solución: " + bb.getFinalSolution());

JavaScript

const Confidence = {
  LOW: 1,
  MEDIUM: 2,
  HIGH: 3,
};

class Blackboard {
  constructor() {
    this.hypotheses = [];
    this.finalSolution = null;
    this.complete = false;
  }

  addHypothesis(hypothesis) {
    this.hypotheses.push(hypothesis);
  }

  getBestHypothesis() {
    if (this.hypotheses.length === 0) return null;
    return this.hypotheses.reduce((best, h) =>
      h.confidence > best.confidence ? h : best
    );
  }

  setSolution(solution) {
    this.finalSolution = solution;
    this.complete = true;
  }
}

class KnowledgeSource {
  constructor(name) {
    this.name = name;
  }

  canContribute(blackboard) {
    throw new Error('Must implement canContribute');
  }

  contribute(blackboard) {
    throw new Error('Must implement contribute');
  }
}

class PatternMatcher extends KnowledgeSource {
  constructor() { super('PatternMatcher'); }
  canContribute(bb) { return bb.hypotheses.length < 3; }
  contribute(bb) {
    bb.addHypothesis({
      content: 'Patrón detectado: probablemente función',
      confidence: Confidence.MEDIUM,
      source: this.name,
    });
  }
}

class SemanticAnalyzer extends KnowledgeSource {
  constructor() { super('SemanticAnalyzer'); }
  canContribute(bb) {
    return bb.hypotheses.some(h => h.source === 'PatternMatcher');
  }
  contribute(bb) {
    bb.addHypothesis({
      content: 'Análisis semántico: intención de usuario es ejecución de query',
      confidence: Confidence.HIGH,
      source: this.name,
    });
  }
}

class ConfidenceEvaluator extends KnowledgeSource {
  constructor() { super('ConfidenceEvaluator'); }
  canContribute(bb) {
    const best = bb.getBestHypothesis();
    return best && best.confidence === Confidence.HIGH;
  }
  contribute(bb) {
    const best = bb.getBestHypothesis();
    if (best) bb.setSolution(best.content);
  }
}

class Controller {
  constructor(blackboard, sources) {
    this.blackboard = blackboard;
    this.sources = sources;
  }

  solve(maxIterations = 10) {
    for (let i = 0; i < maxIterations && !this.blackboard.complete; i++) {
      for (const source of this.sources) {
        if (source.canContribute(this.blackboard)) {
          source.contribute(this.blackboard);
          break;
        }
      }
    }
  }
}

// Uso
const bb = new Blackboard();
const sources = [
  new PatternMatcher(),
  new SemanticAnalyzer(),
  new ConfidenceEvaluator(),
];
const controller = new Controller(bb, sources);
controller.solve();
console.log('Solución:', bb.finalSolution);

Explicación

El Patrón Blackboard consiste en tres componentes:

• Blackboard: Una estructura de datos compartida que mantiene el estado actual del problema y las hipótesis acumuladas
• Knowledge Sources: Módulos independientes que leen del blackboard, evalúan condiciones, y contribuyen soluciones parciales
• Controller: Orquesta el proceso seleccionando qué Knowledge Source debería contribuir siguiente

Los Knowledge Sources no se comunican directamente entre sí. Solo interactúan a través del blackboard, haciendo el sistema loosely coupled y altamente extensible. Nuevos Knowledge Sources pueden agregarse sin modificar los existentes.

Variantes

Variante	Estrategia de Control	Caso de Uso
Opportunistic	Cualquier fuente puede contribuir cuando condiciones se cumplen	Sistemas simples, descentralizados
Priority-based	El controller selecciona la fuente elegible de mayor prioridad	Sistemas complejos con muchas fuentes
Event-driven	Las fuentes reaccionan a cambios del blackboard	Sistemas de IA reactivos
Hierarchical	Múltiples blackboards en diferentes niveles de abstracción	Resolución de problemas multi-etapa

Mejores Prácticas

• Mantén Knowledge Sources independientes. No deberían comunicarse directamente.
• Usa una priority queue para el controller. Selecciona la fuente más prometedora para actuar siguiente.
• Implementa confidence scoring. Las hipótesis deberían incluir niveles de confianza para mejor toma de decisiones.
• Establece límites de iteración. Previene loops infinitos cuando ninguna solución converge.
• Loguea todas las contribuciones. Debuggear sistemas blackboard requiere trazabilidad.

Errores Comunes

• Acoplamiento fuerte entre fuentes. La comunicación directa derrota el propósito del patrón.
• Condiciones de terminación faltantes. Sin max iterations o checks de completitud, el sistema puede loopar para siempre.
• Sobreescribir hipótesis de alta confianza. Nuevas contribuciones no deberían reemplazar ciegamente mejores hipótesis.
• Controller monolítico. Un controller complejo se vuelve bottleneck y single point of failure.
• Ignorar race conditions. En implementaciones multi-threaded, sincronizar acceso al blackboard.

Ejemplos del Mundo Real

Sistemas de Reconocimiento de Voz

El reconocimiento de voz moderno usa múltiples Knowledge Sources: modelos acústicos, modelos de lenguaje, diccionarios de pronunciación, y analizadores contextuales. Cada uno contribuye hipótesis sobre lo que se dijo, y el sistema converge en la transcripción más probable.

Pipelines de Reconocimiento de Imágenes

Los sistemas de visión por computadora a menudo usan arquitecturas blackboard donde detectores de bordes, reconocedores de formas, y clasificadores semánticos contribuyen interpretaciones parciales de una imagen.

Solvers de Optimización

Los problemas de satisfacción de restricciones y solvers de optimización (como los usados en scheduling y routing) usan múltiples heurísticas que refinan iterativamente un espacio de soluciones compartido.

Preguntas Frecuentes

Q: Cuál es la diferencia entre Blackboard y Pipeline? A: Los Pipelines pasan datos linealmente de una etapa a la siguiente. Blackboard permite que cualquier Knowledge Source contribuya en cualquier momento basado en el estado actual.

Q: Cómo decide el controller qué fuente activar? A: Estrategias comunes incluyen ordenamiento por prioridad, umbrales de confianza, o bidding basado en subastas donde cada fuente califica su habilidad para contribuir.

Q: Es Blackboard adecuado para sistemas real-time? A: Puede ser desafiante debido al overhead de coordinación. Los sistemas real-time pueden preferir pipelines determinísticos o máquinas de estado.