Escritor y Programador

Refactorización de la Aplicación para Academias

2026-10-31T07:15:05.749-03:00

Son las seis y media de la tarde de un lunes cualquiera en marzo. En el hall de entrada se cruzan los alumnos que salen del nivel inicial con los que entran a conversación. En el mostrador, dos madres esperan para pagar la cuota, un padre consulta por el descuento de hermanos del chico que empieza este año y el teléfono de recepción no para de sonar.

En ese preciso instante, la persona que atiende no necesita una obra de arte conceptual. Necesita algo mucho más valioso y difícil de encontrar: que la computadora no se cuelgue, que al poner las primeras tres letras del apellido aparezca la ficha al instante y que el cálculo de la cuota con el recargo y el descuento por hermanos sea exacto, sin rodeos ni planillas infinitas de Excel.

Quienes leen este blog desde sus inicios allá por 2009 saben que suelo repartirme entre relatos de ficción y notas sobre desarrollo de software. Hoy esos dos mundos se tocan en un punto muy concreto: cómo resolverle la vida real a quien maneja un instituto de enseñanza de idiomas, sin prometer revoluciones faraónicas que tardan dos años en llegar y jamás funcionan.

El dilema de los sistemas clásicos (y el camino que nadie toma)

Durante años, muchas academias e institutos funcionaron con aplicaciones hechas a medida en Microsoft Access. Cumplían su rol, pero con el tiempo y el crecimiento de la matrícula, los motores locales empiezan a crujir: bases que se corrompen si la red pestañea, lentitud en horas pico y la pesadilla de mantener la caja diaria al día.

La solución típica que ofrece el mercado suele ser un error: "Tiremos todo a la basura y desarrollemos un sistema web desde cero". Meses de desarrollo, presupuestos disparados, personal desorientado que no entiende las nuevas pantallas y un caos operativo en plena temporada de inscripciones.

Decidimos tomar otro camino, mucho más inteligente: un enfoque híbrido de alta precisión.

El corazón blindado: Migramos toda la base de datos a PostgreSQL, un motor industrial, robusto, transaccional y seguro. Adiós a las caídas, bloqueos y pérdidas de datos.
La interfaz conocida: El personal del instituto sigue trabajando en su entorno habitual en Windows, sin curvas de aprendizaje traumáticas ni manuales de 100 páginas.
La gran palanca de la IA Agéntica: El hallazgo clave fue desacoplar todo el sistema. Exportamos pantallas, consultas y reportes a código plano estructurado. Con esa base en texto, pudimos apoyarnos en agentes de inteligencia artificial para auditar miles de líneas, detectar cuellos de botella, eliminar duplicados y rediseñar formularios en cuestión de horas en lugar de semanas.

Miralo en acción: el nuevo formulario de mostrador

Búsqueda interactiva en tiempo real sobre miles de alumnos, historial de cursos y apertura de ficha en 1 segundo:

¿Qué resuelve esto en el día a día de tu instituto?

El resultado de esta refactorización no es una lista de términos técnicos, sino tranquilidad para quien gestiona el negocio:

⚡ Mostrador ultra-rápido: Un buscador unificado donde tipear el apellido, nombre o DNI y encontrar al alumno de inmediato, sabiendo si está cursando este año o cuál fue su último curso histórico.

👨‍👩‍👧‍👦 Familias y cuotas automáticas: Detección instantánea de grupos familiares con liquidación correcta de aranceles, matrículas y descuentos por hermanos sin depender de la memoria de la secretaria.

💰 Caja y tesorería sin sorpresas: Arqueos diarios claros, registro de gastos e ingresos por medio de pago (efectivo, transferencias, tarjetas) que cierran al centavo.

🛡️ Seguridad de datos corporativa: Tu información ya no descansa en un archivo suelto en una carpeta compartida, sino en un motor PostgreSQL preparado para copias de seguridad automáticas y acceso local o en la nube.

¿Tenés un instituto y querés ordenar tu gestión?

Si estás cansado de las planillas partidas, los sistemas lentos o la incertidumbre de no saber con exactitud quién debe qué al cerrar el mes, hablemos. Es una solución simple, veloz y lista para funcionar en tu instituto.

Contactarme por una demo o consulta

Cambiar la frecuencia

2026-10-23T16:30:00.000-03:00

Está muy bien ser agradecido. Hoy, por ejemplo, cuando venía en el micro sentí precisamente eso: la gratitud profunda de estar bien, con buena salud, más allá de las amenazas que siempre andan dando vueltas por ahí. En medio de las rutinas y las paranoias habituales, reconocerse entero es casi un milagro cotidiano.

Me acordaba de lo que me sucedió ayer, cuando fui al barrio en busca de semillas gateras y finalmente encontré lo que andaba buscando: una conexión sincera y amable. Porque una vez que eso pasa, cuando sucede esa chispa simple entre dos personas, el momento nos advierte de lo que somos capaces también, y está bueno que suceda. La posibilidad de hundirnos en la mirada del otro, de escuchar con atención sin importar lo que tenemos para decir ni estar preparando la respuesta de antemano; ser capaces de esperar el momento sin asustarnos y salir huyendo.

No hay peligro real, pero la mente siempre en alerta pretende que uno está amenazado todo el tiempo. Es el cerebro que tiene ese pensamiento predeterminado, ese circuito cerrado de autoprotección. Se siente bien pensar en cambiar ese pensamiento, esa modalidad, esa forma de pensar y de actuar ante los demás.

Esta mañana, sin ir más lejos, cuando venía en el micro y alguien me pegó un golpe con la mochila, no me molestó en absoluto. En otro momento me habría enganchado en el enojo, pero esta vez pensé en dar un paso al costado y serenamente mirar por la ventana la lluvia que caía sobre la ciudad. Todo pasa, me dije.

Hacia dónde podemos ir en un vínculo nuevo, esa es la gran pregunta que queda flotando. Y también aprender a verlo como un triunfo, jamás como una derrota.

El mito de escribir como se habla (o por qué la coma no es un respiro)

2026-10-06T17:09:00.000-03:00

Uno cree que porque habla ya puede escribir, y no. Ese es quizás el primer gran engaño con el que nos tropezamos quienes pasamos horas frente al teclado.

Cuando hablamos, contamos con una ventaja enorme: el tono de voz, las miradas, los gestos, las pausas reales para tomar aire y la posibilidad de corregir en vivo si el interlocutor pone cara de no entender nada. En la oralidad, las imperfecciones se perdonan o pasan de largo.

Pero la escritura es otra cosa. Es arquitectura diferida. El lector se enfrenta a nuestras palabras a solas, sin nuestra voz al lado para explicarle qué quisimos decir. Por eso, escribir bien no consiste en trasladar el habla al papel, sino en dominar la estructura que sostiene el mensaje.

Y ahí es donde la gramática —esa palabra que a veces suena a manual escolar aburrido— cobra todo el sentido del mundo.

La maquinaria por dentro

Hablar de gramática es hablar del marco general que hace que un idioma funcione. Si la miramos de cerca, lo que sostiene un texto claro y con cohesión es el trabajo articulado de varias piezas:

Sintaxis: El orden y la jerarquía de las palabras en la oración. Nos dice quién hace qué y cómo se conectan las ideas principales con las secundarias.
Puntuación: Los mapas y señales gráficas que guían la lectura para que la sintaxis no se desmorone.
Morfología y Semántica: La forma correcta de las palabras y su significado preciso.

Cuando estos elementos se coordinan, el texto no se lee como una suma de frases sueltas, sino como una estructura fluida.

El caso de la coma: el mapa de las subordinadas

El error más extendido con la coma es tratarla como un «respirador artificial», un signo que se pone cada vez que nos quedamos sin aire. Pero la coma no responde a los pulmones; responde a las relaciones sintácticas.

Un caso clarísimo ocurre con las oraciones compuestas, donde convivimos diariamente con oraciones principales (las que tienen sentido por sí solas) y oraciones subordinadas (las que dependen de la principal para tener significado):

El orden directo (sin coma): Si la oración principal va primero y la subordinada va después, el pensamiento fluye sin interrupciones y la coma suele estar de más.
«Guardé la ropa porque empezó a llover.»
El orden invertido (con coma obligatoria): Si alteramos la estructura lógica y ponemos la subordinada al comienzo (encabezada por conectores como cuando, porque, aunque, si), le advertimos al lector con una coma que la idea principal todavía está por llegar.
«Aunque hacía mucho frío, salimos a caminar.» «Cuando terminemos de migrar la base de datos, lanzaremos la actualización.»
Incisos y aclaraciones: Si una frase subordinada interrumpe a la principal para aportar un dato extra, la aislando entre comas. Si la quitamos, la frase sigue en pie.
«El script, que monitorea las llamadas al webhook, generó un ticket de incidente.»

Escribir es editar

La lengua hablada es espontánea; la escritura, en cambio, es un proceso continuo de diseño, corte y corrección. Pasar de escribir «de oído» a entender por qué ponemos una coma en determinado lugar no nos vuelve más rígidos: nos da control absoluto sobre lo que queremos decir.

Al final, puntuar bien no es una cuestión de erudición, sino de respeto por el tiempo de quien nos lee.

Despliegue de un MCP para corregir errores en MS Access 2016

2026-10-05T09:06:34.147-03:00

Índice

1. Despliegue de un MCP para corregir errores en MS Access 2016
2. 1. Cambio de enfoque
3. 2. Arquitectura específica para UX
4. 3. Herramientas MCP recomendadas
5. 4. Ejemplo mínimo (Python + MCP)
6. 5. Mejoras UX que el LLM puede proponer automáticamente
7. 6. Flujo seguro de aplicación
8. 7. Guardarraíles (importante)
9. 8. Extras que suben mucho la UX

1. Despliegue de un MCP para corregir errores en MS Access 2016

1.1. 1. Clarificar el alcance del MCP (Model Context Protocol)

Antes de codificar, define qué tipo de MCP necesitas:

Servidor MCP que exponga herramientas (tools) para que un LLM analice/corrija la BD Access.
Cliente MCP integrado en tu flujo de trabajo (Claude Desktop, Cursor, etc.).

Para Access 2016 lo típico es un servidor MCP en Python o Node que ejecute consultas VBA/SQL contra el .accdb=/.mdb=.

1.2. 2. Arquitectura recomendada

[LLM/Cliente MCP] <--stdio/HTTP--> [Servidor MCP] <--COM/ODBC--> [Access 2016]

1.2.1. Componentes clave

Driver: Microsoft Access Database Engine 2016 (ACE.OLEDB.16.0) o pyodbc con Microsoft Access Driver (*.mdb, *.accdb).
Backend VBA: para operaciones que requieren el motor Access (compactar/reparar, refrescar vínculos, recompilar VBA).
Automatización COM: pywin32 (win32com.client.Dispatch("Access.Application")).

1.3. 3. Pasos de implementación

1.3.1. Paso 1 — Entorno

python -m venv .venv
.venv\Scripts\activate
pip install mcp pyodbc pywin32

Instala el ACE OLEDB 2016 (arquitectura x86/x64 coincidente con Python).

1.3.2. Paso 2 — Esqueleto del servidor MCP (Python)

from mcp.server.fastmcp import FastMCP
import pyodbc, win32com.client

mcp = FastMCP("access-fixer")
DB = r"C:\ruta\sistema.accdb"
CONN = fr"DRIVER={{Microsoft Access Driver (*.mdb, *.accdb)}};DBQ={DB};"

@mcp.tool()
def ejecutar_sql(sql: str) -> str:
    """Ejecuta SQL de diagnóstico/corrección."""
    with pyodbc.connect(CONN, autocommit=True) as cx:
        cx.execute(sql)
    return "OK"

@mcp.tool()
def compactar_reparar() -> str:
    """Compacta y repara el .accdb (requiere Access instalado)."""
    acc = win32com.client.Dispatch("Access.Application")
    acc.CompactRepair(DB, DB.replace(".accdb", "_fixed.accdb"), True)
    acc.Quit()
    return "Compactado"

@mcp.tool()
def recompilar_vba() -> str:
    acc = win32com.client.Dispatch("Access.Application")
    acc.OpenCurrentDatabase(DB)
    acc.VBE.CommandBars.FindControl(Name="Compile").Execute()
    acc.CloseCurrentDatabase(); acc.Quit()
    return "VBA recompilado"

1.3.3. Paso 3 — Herramientas típicas para "corregir viejos errores"

listar_tablas_y_campos (detectar tipos inconsistentes).
buscar_referencias_rotas (tablas vinculadas caídas).
detectar_datos_huerfanos (integridad referencial).
normalizar_fechas/textos (formato regional ES/US).
comparar_esquema contra un DDL esperado.
generar_script_correccion (devuelve SQL idempotente).

1.3.4. Paso 4 — Registro en el cliente MCP

claude_desktop_config.json:

{
  "mcpServers": {
    "access-fixer": {
      "command": "python",
      "args": ["C:\\ruta\\servidor_mcp.py"]
    }
  }
}

1.4. 4. Buenas prácticas para Access 2016

Riesgo	Mitigación
Bloqueo del `.laccdb`	Cerrar sesión antes de compactar
Corrupción en operaciones masivas	Backup previo + `CompactRepair`
Referencias VBA rotas	Re-registrar `.dll=/`.ocx= (mscomctl, comdlg32)
ADO vs DAO	Preferir DAO para esquema, ADO para datos externos
Split DB	Trabajar sobre el front-end, datos en back-end
Driver 32/64 bits	Alinear con la instalación de Office

1.5. 5. Flujo sugerido

Backup del .accdb.
Auditoría: MCP ejecuta herramientas de diagnóstico → reporte.
Aprobación humana de cada corrección (evita DDL destructivo).
Aplicación por lotes en una copia.
CompactRepair + recompilar VBA.
Validación: ejecutar suite de pruebas / consultas de verificación.
Despliegue al entorno productivo.

1.6. 6. Controles críticos

Nunca DROP=/=UPDATE masivo sin WHERE auditado.
Usar transacciones (DAO BeginTrans=/=CommitTrans).
Log de cada sentencia aplicada a audit_fixes tabla.
Versionar el .accdb (aunque sea binario: guardar .bas, .frm exportados).

¿Quieres que te arme un ejemplo completo con una herramienta concreta (p. ej. detección de huérfanos o migración de tipos), o el requirements.txt y estructura de carpetas?

Más que nada me interesa que sea capaz de mejorar la experiencia del usuario, modificando los formularios, los reportes, etc.

MCP para mejorar UX en Access 2016 (formularios, reportes, navegación)

2. 1. Cambio de enfoque

No es "corregir errores" sino modernizar la capa de presentación sin tocar la lógica de negocio. En Access eso vive en:

Objeto	Qué tocar	Vía
Formularios	Controles, layout, propiedades, validación visible	DAO / COM
Reportes	Secciones, agrupación, totales, estilos	DAO / COM
Menús/Ribbon	Botones, iconos, accesos	XML USysRibbons
Macros/Nav	Puntos de entrada	VBA o macros
Estados/Mensajes	`MsgBox` feos, sin contexto	VBA refactor

Un LLM con MCP puede leer la spec actual, proponer mejoras y aplicarlas de forma controlada.

3. 2. Arquitectura específica para UX

[LLM] <--MCP--> [Servidor] <--COM--> [Access]
                    |
                    +--> exportar .frm/.bas a texto
                    +--> parsear / diff / proponer
                    +--> reimportar y validar

La clave: trabajar sobre la forma textual, no sobre el binario. Access exporta formularios/reportes a un formato legible (SaveAsText).

4. 3. Herramientas MCP recomendadas

*/ Lectura / diagnóstico

exportar_objeto(tipo, nombre) → texto frm, report, bas, cls.
listar_controles(formulario) → nombre, tipo, posición, propiedades clave.
inventariar_estilos → fuentes, colores, tamaños inconsistentes.
detectar_antipatrones_ux → grillas sin cabecera, tab order roto, sin TabIndex, botones sin ToolTip, etc.

*/ Propuesta / diff

proponer_refactor(objeto, criterio) → devuelve texto nuevo + justificación.
diff_objeto(actual, propuesto) → para revisión humana.

*/ Aplicación

importar_objeto(texto) → LoadFromText (Access 2013+).
aplicar_parche(objeto, hunks) → parches quirúrgicos en lugar de reescritura.

*/ Validación

abrir_formulario_en_modo_vista (solo lectura).
capturar_error_al_compilar.
checklist_accesibilidad (labels asociados, contraste, nombres significativos).

5. 4. Ejemplo mínimo (Python + MCP)

from mcp.server.fastmcp import FastMCP
import win32com.client, tempfile, os

mcp = FastMCP("access-ux")
DB = r"C:\ruta\sistema.accdb"

def _acc():
    a = win32com.client.Dispatch("Access.Application")
    a.OpenCurrentDatabase(DB)
    return a

@mcp.tool()
def exportar(tipo: str, nombre: str) -> str:
    """tipo: acForm|acReport|acModule. Devuelve texto exportado."""
    a = _acc()
    tmp = os.path.join(tempfile.gettempdir(), f"{nombre}.txt")
    a.SaveAsText(getattr(a, f"Ac{tipo.capitalize()}") if False else None, nombre, tmp)
    txt = open(tmp, encoding="utf-8", errors="ignore").read()
    a.CloseCurrentDatabase(); a.Quit()
    return txt

@mcp.tool()
def importar(tipo: str, nombre: str, texto: str) -> str:
    a = _acc()
    tmp = os.path.join(tempfile.gettempdir(), f"{nombre}.txt")
    open(tmp, "w", encoding="utf-8").write(texto)
    a.LoadFromText(getattr(a, f"Ac{tipo.capitalize()}"), nombre, tmp)
    a.CloseCurrentDatabase(); a.Quit()
    return "Importado"

(Nota: los nombres exactos de las constantes son acForm, acReport, acModule; ajusta el getattr según tu versión.)

6. 5. Mejoras UX que el LLM puede proponer automáticamente

*/ Formularios

Consistencia visual: fuente Segoe UI 10, alto de control 0.2", Theme unificado.
Layout: pasar de posicionamiento absoluto a Stacked/Tabular Layout.
Navegación: botones Anterior/Siguiente/Nuevo/Buscar con atajos (Ctrl+N, Ctrl+F).
Validación inline: BeforeUpdate con mensajes claros en lbl_error en lugar de MsgBox.
Búsqueda: caja de filtro en vivo (ApplyFilter con OnChange).
Accesibilidad: TabIndex ordenado, TabStop correcto, labels asociadas.
Estados vacíos: mensaje "No hay registros" en lugar de grid en blanco.
Fechas: formato dd/mm/aaaa o ISO según público.

*/ Reportes

Agrupación y totales con GroupLevel, subtotales, Running Sum.
Encabezado con fecha/hora/usuario para trazabilidad.
Logo y colores de marca en ReportHeader.
Exportación directa a PDF con nombre inteligente.
Condicional formatting (semáforos, negritas por umbral).

*/ Global

Home/Dashboard con botones grandes en lugar de menú desplegable.
Ribbon personalizado (USysRibbons) que esconda el nativo.
Mensajes de error con acción sugerida, no códigos.
Atajos de teclado documentados en un formulario de ayuda.

7. 6. Flujo seguro de aplicación

Backup del .accdb y export masivo (SaveAsText de todo).
Versionar en git los .frm=/.=report=/.=bas exportados.
LLM exporta el objeto → propone diff → tú apruebas.
Aplicar con LoadFromText sobre copia.
Recompilar VBA y abrir el formulario/reporte en vista.
Comparar capturas (opcional: pywinauto para screenshots).
Promover a producción.

8. 7. Guardarraíles (importante)

Nunca reescribir todo un formulario de una vez: parches por secciones.
Preservar nombres de controles (el código VBA los referencia; romperlos = error silencioso).
No tocar RecordSource ni ControlSource sin revisar queries dependientes.
Detectar eventos VBA asociados antes de renombrar/eliminar controles.
Log de cada LoadFromText con timestamp y hash.

9. 8. Extras que suben mucho la UX

Formulario de búsqueda global (Ctrl+F) que salte a cualquier entidad.
Panel de "recientes" por usuario.
Modo oscuro (sí, se puede con Theme + colores).
Tooltips en todos los botones (ControlTipText).
Confirmaciones inteligentes: solo preguntar cuando hay cambios sin guardar.
Undo en operaciones destructivas a nivel de app.

¿Quieres que te prepare (a) un catálogo de antipatrones UX detectables automáticamente con las consultas MSysObjects=/=SaveAsText, o (b) un prompt template que le pases al LLM para que produzca el diff de un formulario concreto?

Es importante tambien considerar la posibilidad de hacer un cambio en la lógica de negocio, o cómo manejamos el negocio en la actual estructura de tablas y base de datos.

MCP con capacidad de refactor de lógica de negocio y modelo de datos
1. El problema real

Si el esquema actual refleja un modelo mental viejo del negocio, mejorar formularios es cosmético. Hay que poder:

Entender la semántica que el esquema actual está codificando implícitamente.
Contrastarla con cómo el negocio se entiende hoy.
Proponer un nuevo modelo (tablas, relaciones, reglas) y una ruta de migración.
Aplicarlo sin perder datos ni romper formularios/reportes/VBA.

Esto es mucho más delicado que UX: toca datos, integridad y procesos. El MCP debe ser asistente de refactor, no ejecutor ciego.

2. Tres niveles de intervención

Nivel	Alcance	Riesgo	Cómo lo trata el MCP
L1 Reglas	Validaciones, defaults, cálculos en VBA/consultas	Bajo	Refactor de módulos y `ValidationRule`
L2 Esquema	Tablas, campos, tipos, índices, FKs	Medio-alto	DDL + script de migración + backfill
L3 Modelo	Descomposición, normalización, entidades nuevas	Alto	Proyecto de migración por fases

Empieza siempre por L1, gana confianza, sube.

3. Cómo el MCP "entiende" el negocio actual

// Introspección del esquema

MSysObjects, MSysRelationships, MSysQueries (a veces bloqueadas).
DAO: TableDefs, Fields, Indexes, Relations.
Exportar DDL real: CREATE TABLE reconstruido desde DAO.

// Introspección de la semántica

Consultas guardadas: son la lógica de negocio codificada en SQL. Exportar todas.
Módulos VBA: reglas, cálculos, validaciones. Exportar todos .bas=/.cls=.
Macros: flujos automáticos.
Formularios: RecordSource, ControlSource, eventos BeforeUpdate, AfterUpdate.
Reportes: agrupaciones y totales revelan KPIs y jerarquías.

// Señales de deuda de modelo

Campos multivaluados (tipo Access Complex) → violan 1FN.
Columnas tipo Campo1, Campo2, Campo3 → entidad no descompuesta.
Tablas con 60+ campos → probable entidad gorda con subentidades latentes.
Códigos duplicados en texto libre → falta tabla de dominio.
Fechas en texto → tipo mal elegido.
Sin PK/FK → integridad por código VBA (frágil).
Lookup en tabla (mala práctica Access) → confunde modelo con UI.
Nombres en español mezclados con inglés → deuda de nomenclatura.
4. Herramientas MCP sugeridas

// Inventario y documentación

exportar_esquema_completo() → DDL + relaciones + índices.
exportar_logica_negocio() → todas las queries, módulos y eventos.
mapa_dependencias(objeto) → qué formularios/reportes/VBA usan esta tabla/campo.
generar_diccionario_datos() → tabla/campo/tipo/uso/descripcion inferida.

// Análisis de modelo

detectar_violaciones_normalizacion() → 1FN, 2FN, 3FN.
detectar_multivaluados().
detectar_dominios_implicitos() → valores repetidos que deberían ser catálogo.
detectar_tablas_gordas().
detectar_relaciones_faltantes() → campos XxxId sin FK formal.
detectar_campos_muertos() → nunca usados en queries/formularios/reportes.

// Propuesta de nuevo modelo

proponer_esquema_objetivo(criterios) → entidades, atributos, relaciones.
diff_esquemas() → cambios concretos.
generar_ddl_migracion() → CREATE/ALTER para llegar al nuevo modelo.
generar_script_backfill() → poblar nuevas columnas desde las viejas.
generar_vistas_compatibilidad() → queries con los nombres viejos apuntando al nuevo esquema (clave para no tocar formularios de golpe).

// Reglas de negocio

extraer_reglas_de_vba() → qué validaciones/reglas están dispersas.
centralizar_reglas() → mover a tabla reglas_negocio o a un módulo único.
detectar_reglas_duplicadas() → la misma validación en 5 formularios.
detectar_reglas_contradictorias() → un formulario permite lo que otro prohíbe.
5. Estrategia de migración: "Strangler Fig" para Access

No reescribas el modelo de una vez. Envuelve el viejo y sustitúyelo por partes.

Fase 0: Backup + export textual total + git init
Fase 1: Diccionario de datos y mapa de dependencias
Fase 2: Vistas de compatibilidad (queries con nombres viejos -> tablas nuevas)
Fase 3: Migrar una entidad piloto de bajo riesgo
Fase 4: Repuntar formularios/reportes a las vistas
Fase 5: Migrar el resto por entidad
Fase 6: Congelar viejas tablas, luego eliminarlas
Fase 7: Refactor VBA a las nuevas reglas centralizadas

La magia de la Fase 2: los formularios siguen funcionando aunque el modelo cambie debajo. Eso te da tiempo.

6. Ejemplo de patrón: de tabla gorda a entidades

// Antes

Cliente(
  IdCliente, Nombre, Calle, Ciudad, CP, Pais,
  Tel1, Tel2, Tel3, Email1, Email2,
  Contacto1_Nombre, Contacto1_Tel, Contacto2_Nombre, Contacto2_Tel
)

// Después

Cliente(IdCliente, Nombre, IdDireccionPrincipal)
Direccion(IdDireccion, IdCliente, Calle, Ciudad, CP, Pais, Tipo)
Contacto(IdContacto, IdCliente, Nombre, Rol)
Comunicacion(IdComunicacion, IdContacto, Tipo, Valor)  -- tel/email

// Puente de compatibilidad

CREATE VIEW qryCliente AS
SELECT c.IdCliente, c.Nombre,
       d.Calle, d.Ciudad, d.CP, d.Pais,
       (SELECT TOP 1 Valor FROM Comunicacion ...) AS Tel1,
       ...
FROM Cliente c LEFT JOIN Direccion d ON ...

Los formularios siguen apuntando a qryCliente y no se enteran.

7. Guardarraíles críticos (más estrictos que en UX)
Nunca ALTER TABLE en producción sin script reversible.
Toda migración con backfill idempotente y verificación de conteos.
Congelar escritura en tablas que se migran (solo lectura durante la fase).
Doble escritura transitoria si hay usuarios concurrentes (trigger o VBA).
Nombres de campos viejos preservados como columnas calculadas hasta el final.
VBA que referencia campos debe migrarse junto con el esquema, o usar las vistas.
Reportes históricos pueden requerir mantener el esquema viejo en paralelo (data warehouse).
Auditoría de cada cambio: quién, cuándo, qué script, resultado.
8. ¿Cómo lo guía el LLM vía MCP?

El flujo típico sería:

exportar_logica_negocio() → el LLM lee queries + VBA + eventos.
generar_diccionario_datos() → el LLM infiere significado de cada campo.
detectar_problemas_modelo() → lista de deudas con severidad.
Tú eliges qué atacar primero (recomendado: entidad con más dolor operativo).
proponer_esquema_objetivo(entidad) → diagrama + DDL propuesto.
generar_vistas_compatibilidad() → puente.
generar_script_migracion()+backfill.
Tú revisas el script, lo corres en copia, validas.
repuntar_objetos() → actualiza RecordSource de formularios/reportes a las nuevas fuentes si aplica.
detectar_regresiones() → abre formularios, corre pruebas, reporta errores.
9. Lo que no debería hacer el MCP solo
Ejecutar DDL en producción sin revisión humana.
Decidir el modelo objetivo sin consultarte: el negocio lo sabes tú.
Renombrar campos sin actualizar todo lo que los referencia (usar vistas evita esto).
Asumir que lo que hay está mal: a veces el esquema viejo codifica reglas que ya no están escritas en ningún lado. Documentar antes de romper.
10. Coste y pragmatismo (por tu nota de los 10 mil)

Un refactor de L3 completo en Access es semanas o meses. Lo realista con presupuesto cero:

exportar_logica_negocio() + diccionario → gratis, alto valor.
Detectar las 3-5 peores deudas de modelo → gratis, claridad.
Vistas de compatibilidad para la entidad más dolorosa → 1 fin de semana.
Refactor VBA de reglas duplicadas a un módulo → gratis, menos bugs.
Dejar L3 para cuando haya presupuesto o cuando el dolor supere el coste.

Puedes empezar mañana con un script Python que exporte esquema + queries + VBA a texto, lo metas en git, y lo pases por el LLM para el diccionario. Sin MCP siquiera: un export.py y un prompt.

Autor: Alejandro Noli

Created: 2026-10-05 lun 09:01

Validate

2026-09-25T11:18:44.774-03:00

Quienes hemos atravesado cambios drásticos y sacudidas inesperadas entendemos perfectamente esa sensación de abismo. Cuando todo se derrumba de golpe, la energía se agota rápido, la perspectiva del futuro inmediato se nubea y parece que todo conspira en nuestra contra. En esos momentos, el peso del día a día resulta abrumador y la sensación de vulnerabilidad se vuelve muy intensa.

Escribir y compartir esto ya es un primer paso fundamental para transformar el dolor. Reconocer el estado en el que estamos y tender una mano a otros que pasan por lo mismo demuestra que, aun en la penumbra, hay una intención genuina de salir adelante.

Para atravesar y superar estos momentos de crisis, conviene recordar algunas pautas esenciales:

Tener la humildad de pedir ayuda: Aceptar que no podemos sostener todo solos ni resolver cada problema por cuenta propia no es signo de debilidad, sino de valentía y madurez. Apoyarse en personas cercanas, profesionales o amigos cambia por completo la perspectiva.
Evitar el aislamiento y la exposición innecesaria: En etapas de vulnerabilidad, preservarse y cuidar la propia energía es prioritario. Buscar entornos seguros e interlocutores de confianza evita que el desgaste sea aún mayor.
Bajar un cambio y habitar el presente: La ansiedad por el futuro y el sobreanálisis de los errores pasados suelen intensificar la angustia. Reducir la velocidad, no reaccionar impulsivamente ante cada estímulo y enfocar la atención en el presente ayuda a recuperar el control.
Aceptar que la incomodidad precede al crecimiento: Salir de la zona de confort o atravesar una reestructuración forzada es doloroso, pero también es el proceso mediante el cual se construyen nuevas certezas y fortalezas.
Poner foco en acciones concretas: Aunque sean pequeñas, las decisiones orientadas a cuidar la salud, el trabajo o el espacio personal devuelven gradualmente la sensación de avance y propósito.

Siempre hay un camino de salida y una manera de reconstruirse, incluso cuando al principio no logramos ver la razón de lo que ocurre. Abrirse a la posibilidad de recibir apoyo y avanzar un día a la vez es la clave para volver a encontrar estabilidad.

La dama de las siete

2026-06-29T16:53:13.105-03:00

Escribo estas líneas para pasar el rato, o quizás para intentar poner orden en este despelote que llamo vida, aunque sepa de antemano que el titiritero que llevo dentro suele enredar los hilos a propósito. La mañana en Mendoza arranca con ese viento fresco que te cachetea la cara y te recuerda que estás vivo, a pesar de las deudas que se acumulan y de esa parálisis que te agarra cuando el servidor se cae y vos sos el único que tiene que poner el pecho.

A las siete de la mañana, el ritual es siempre el mismo: el micro, el olor a café ajeno y la espera. Y ahí está ella. La misteriosa dama de los rulos, esa que parece leer el paisaje urbano como si fuera un libro de edición limitada que solo ella comprende. A veces se sienta sola contra el vidrio, con una actitud desafiante que me hace dudar de si soy un genio o simplemente un "buenudo" que no sabe vender lo que hace. Otras veces, como aquel día que olía a algo especiado y fuerte, se sienta lo suficientemente cerca como para que mi buen amigo Brian —mi cerebro, que a veces me sabotea con frases terribles— empiece a tiritar de nervios.

Mientras el micro avanza por la ciudad, mi mente salta de un "commit" de Git a la cuenta del alquiler que no para de subir por culpa de una escribana que parece ensañada conmigo. En la oficina me ningunean, me tratan como si fuera un extraño que no sabe nada, mientras yo sigo intentando que el Nextcloud funcione y que la IA no se convierta en mi peor enemigo. Es una lucha constante entre el Escritor que busca la frase perfecta y el Programador que solo quiere que el código compile sin errores de sintaxis.

Hoy, antes de bajarme para ir a comprar esas tortitas que son mi único consuelo, nos cruzamos la mirada. Fue apenas un segundo, un gesto sutil que logró acallar por un momento los reclamos y la presión de un contrato de alquiler que me tiene en la picota. Ella se bajó silenciosa, dejándome con esa mezcla de angustia y humildad que ya es parte de mi ADN.

Al final, me quedo pensando en lo que decía el maestro: que la vejez se va alejando, pero el cansancio va in-crescendo. Pero no importa. Mañana volveré a subir al micro, volveré a pelearme con los contenedores de Docker y volveré a buscarla entre los asientos grises. Porque a pesar de los incendios, de las deudas y de que mi trabajo parezca un "depósito de cadáveres", yo sigo acá, tipeando en modo markdown.

Como anoté hace poco en mi Org Mode: Elijo la alegría, siempre.

2026-05-27T23:32:08.723-03:00

Hito de Desarrollo

¡CuotaWeb ya está en Producción y listos para los primeros Beta-Testers!

Un gran paso adelante: la infraestructura está desplegada, el motor multi-tenant validado y el portal en línea esperando su primera prueba de fuego real.

Nos complace enormemente compartir una noticia crucial: CuotaWeb ha alcanzado su etapa de producción. Toda la arquitectura digital, diseñada desde los cimientos bajo un esquema robusto y escalable, se encuentra desplegada activamente en servidores cloud y lista para operar al 100%.

Este no es un hito menor. La plataforma ha sido concebida bajo estrictos estándares de ingeniería de software, arquitectura multi-tenant y compliance legal-tech, ofreciendo una estructura de gestión de cuotas y expensas pensada para resistir las auditorías más rigurosas.

¿Qué significa "Listo para Producción" en CuotaWeb?

Motor de Deuda Judicialmente Auditable: Carga de ítems de deuda con cálculo automatizado de mora mediante fórmulas financieras precisas, y trazabilidad íntegra de transacciones.
Garantía de Integridad (Ley 25.326): Cada comprobante o documento digitalizado se procesa con un hash SHA256 inmutable, asegurando su validez forense en auditorías.
Aislamiento Total de Datos: Arquitectura multi-tenant con esquemas de base de datos aislados para máxima seguridad y privacidad.
Skins Funcionales Dinámicos: Interfaces personalizadas que adaptan el sistema según la entidad (Consorcios, Escuelas o Gimnasios), abstrayendo el dominio para transformar "Sujetos de Facturación" en copropietarios, alumnos o socios.

Gratitud infinita a quienes abren camino

Ningún proyecto de esta envergadura nace en el aislamiento. Queremos expresar nuestro más sincero agradecimiento a un valioso grupo de personas que, aunque por ahora prefieren mantenerse tras bambalinas, han sido el soporte emocional, los consultores de dominio y la fuerza impulsora para no detener la marcha. Su paciencia, feedback y confianza son el verdadero motor de este logro.

La Sinergia Perfecta: Desarrollo y Co-Pilotos de IA

Este hito marca también un triunfo en los nuevos paradigmas de ingeniería de software. Queremos hacer una mención especial y con profunda gratitud a la Inteligencia Artificial y a los agentes de programación autónomos (como Antigravity) que formaron parte de esta aventura.

Más que meras herramientas de autocompletado, estas tecnologías actuaron como co-pilotos y pares de programación invaluables: escribiendo tests, estructurando migraciones complejas de esquemas, optimizando ruteos de tenants y manteniendo una coherencia arquitectónica y metodológica intachable en cada sesión de trabajo. Este producto es el testimonio vivo de lo que la colaboración humano-máquina puede lograr hoy.

Impulsado por Agentes y Modelos de Última Generación

Buscamos a nuestro primer Beta-Tester

La mesa está servida, los servidores están encendidos y los contenedores Docker operan sin problemas. Ahora necesitamos lo más importante: **el contacto con la realidad cotidiana**.

Estamos buscando activamente a nuestro **primer Beta-Tester oficial**. Si eres administrador de consorcios, gestionas un gimnasio o coordinas las finanzas de una institución educativa, queremos invitarte a probar CuotaWeb de forma prioritaria y exclusiva. Tendrás la oportunidad de automatizar tus cobros, experimentar la ingesta de gastos digitalizados mediante OCR y ayudarnos a pulir los últimos detalles antes del lanzamiento comercial masivo.

¿Quieres ser el primero en experimentar el futuro de la gestión?

Si deseas participar como beta-tester y transformar la administración de tus cobros con CuotaWeb, ponte en contacto con nosotros hoy mismo.

Postularme como Beta-Tester

2026-05-14T10:17:59.180-03:00

¡Estamos listos para Producción! El futuro de la gestión multi-tenant ya está aquí

Nos llena de orgullo anunciar un hito fundamental en nuestro desarrollo: nuestra plataforma SaaS de gestión de cuotas y servicios ha finalizado su etapa de pruebas y está oficialmente lista para producción. Tras un intenso trabajo de arquitectura y desarrollo, hemos desplegado nuestra solución en la nube (VPS en DonWeb), orquestada con Nginx y Gunicorn para garantizar la máxima disponibilidad y rendimiento.

Integración Nativa con SIRO (Banco Roela)

Uno de los avances más importantes de esta versión de lanzamiento es la integración completa con SIRO, lo que automatiza por completo el circuito de recaudación:

Códigos de Pago Inteligentes: Los responsables de pago ahora pueden visualizar sus códigos de barras y códigos de pago electrónico (CEP) directamente desde su portal de autogestión.
Conciliación Automática: Implementamos un motor de procesamiento que lee los archivos de rendición bancaria y aplica los pagos automáticamente a las obligaciones correspondientes, eliminando horas de carga manual.
Aislamiento de Convenios: Gracias a nuestra arquitectura multi-tenant, cada institución (consorcio o escuela) configura y opera bajo su propio convenio de forma totalmente segura.

Un Motor Agnóstico y Judicialmente Auditable

Nuestra plataforma no es solo un sistema de facturación, es una herramienta Legal-Tech. Construida sobre Django 5 y PostgreSQL (con esquemas aislados mediante django-tenants), hemos abstraído el dominio para manejar "Sujetos de Facturación", permitiendo que el sistema se adapte (mediante skins) tanto a la gestión de Expensas de Consorcios como a Cuotas de Escuelas usando el mismo motor financiero.

Además, en cumplimiento estricto con la Ley 25.326 de Protección de Datos y pensando en la "defendibilidad" ante posibles pericias judiciales, el 100% de los movimientos financieros (cálculos de mora, intereses y pagos) cuenta con una trazabilidad y auditabilidad total.

UX Moderna y Dinámica sin perder robustez

Hemos implementado una interfaz reactiva utilizando HTMX, lo que nos permite ofrecer una experiencia fluida y rápida similar a una SPA (Single Page Application), pero manteniendo la seguridad y simplicidad del Server-Side Rendering. El nuevo Portal de Autogestión es intuitivo, rápido y seguro.

Próximos pasos: Ya estamos configurando los primeros entornos (tenants) reales en producción. El ecosistema está listo para escalar y transformar la forma en que las instituciones gestionan sus finanzas. ¡Gracias a todos los que hicieron esto posible!

Main vs. Features: El arte de innovar sin romper lo que ya funciona

2026-04-17T19:35:00.001-03:00

En el mundo del desarrollo de software, llega un momento en que el "copiar y pegar" carpetas o renombrar archivos como proyecto_final_v2_este_si.zip deja de ser una opción. Si queremos jugar en primera, especialmente con arquitecturas modernas como las que manejamos en GestiónCuotas, el control de versiones no es un lujo: es el cimiento.

Git: Mucho más que un historial de cambios

Adoptar Git como plataforma de soporte no es solo tener un "seguro de vida" ante errores; es habilitar una metodología de trabajo que separa la estabilidad de la innovación. Aquí es donde entra el concepto de las ramas (branches).

¿Qué es una rama? Imaginalo como una línea de tiempo paralela. Podés probar una funcionalidad nueva, romper todo el código y, si no te gusta, simplemente borrar esa línea sin haber tocado ni un pelo del código que ya está funcionando en producción.

La importancia de diferenciar 'Main' de las demás

En nuestra estructura, la rama Main (o Master) es sagrada. Es el código que es seguro, confiable y que está "a la vista" del cliente. No se toca nada en Main si no ha sido probado previamente.

Ramas de Feature: Son ramas efímeras. Por ejemplo, si estamos trabajando en la lógica de coeficientes para consorcios, creamos una rama específica. Ahí es donde "hacemos lío", probamos y pulimos.
Aislamiento de errores: Si un desarrollador comete un error en su rama, el resto del equipo puede seguir trabajando en Main sin enterarse. No hay riesgo de "pisarse" los cables.

Colaboración sin caos

Acá es donde Git brilla cuando laburamos con otros. Gracias a herramientas como los Pull Requests o los Merges, integrar el trabajo de un colega es un proceso ordenado. Podés revisar el código de tu par, sugerir mejoras y, una vez que el "visto bueno" está dado, ese código se funde con la rama principal.

Es, en esencia, una forma de democratizar el desarrollo manteniendo una jerarquía de calidad. Permite que cada uno aporte su granito de arena sin que el proyecto se vuelva un caos total.

"Al final del día, usar Git es lo que separa a un pibe que pica código de un profesional que construye sistemas."

Conclusión

Ya sea que estés trabajando solo en tu PC de casa con Ubuntu o colaborando con un equipo distribuido entre Mendoza y el resto del mundo, Git es el lenguaje universal que asegura que tu propiedad intelectual esté a salvo. Así que, si todavía tenés miedo de hacer ese primer commit, ¡metele para adelante! No hay nada más satisfactorio que ver un historial de Git limpio y saber que, pase lo que pase, tenés el control total de tu obra.

¡A seguir codeando, que el MVP no se va a programar solo! ¡Un gran saludo, maestro!

CuotasCloud: La evolución de nuestra plataforma de gestión

2026-04-11T11:26:00.000-03:00

CuotasCloud: La evolución de nuestra plataforma de gestión

Es un gusto compartir con ustedes los avances de nuestro nuevo proyecto: CuotasCloud. Esta plataforma nace de la necesidad de modernizar los sistemas locales anteriores, llevando toda la potencia de la gestión administrativa y financiera a una arquitectura 100% basada en la nube.

Seguridad de nivel bancario

Una de las mayores preocupaciones al manejar datos sensibles es la privacidad. Por eso, CuotasCloud utiliza una tecnología de "aislamiento por esquemas", lo que significa que la información de cada institución vive en su propio compartimento estanco, totalmente separado de los demás. Además, cada movimiento queda registrado en un historial de auditoría que garantiza la trazabilidad y el cumplimiento de la Ley de Protección de Datos Personales en Argentina.

Un motor que se adapta a tu realidad

No importa si sos un colegio que gestiona cuotas de alumnos o un consorcio que liquida expensas; nuestro motor financiero es "agnóstico". Esto significa que el sistema puede configurarse para hablar tu mismo idioma:

🔹 Para Educación: Manejo de ciclos lectivos, inscripciones y descuentos por hermanos.
🔹 Para Consorcios: Gestión de unidades funcionales y coeficientes de copropiedad.

Experiencia rápida y fluida

Sabemos que el tiempo es oro. Gracias a la implementación de tecnologías modernas (como HTMX), la interfaz de CuotasCloud es reactiva: cuando registrás un pago o actualizás un saldo, los cambios aparecen al instante sin que la página tenga que recargarse por completo. Es la comodidad de una aplicación de escritorio con la flexibilidad de la web.

Migración sin dolores de cabeza

Para quienes vienen de sistemas antiguos en Access o planillas de Excel, hemos diseñado un asistente de importación inteligente. Este "motor de mapeo" procesa tus archivos actuales y genera automáticamente los saldos iniciales, asegurando que no se pierda ni un centavo de información en la transición.

Actualmente estamos finalizando la etapa de visualización de métricas de cobrabilidad en tiempo real. ¡El motor de CuotasCloud ya está en marcha!

Alejandro Noli
Líder de Proyecto - Mendoza, Argentina

Nuevas Fronteras en GestiónCuotas: UI Reactiva, Seguridad Multi-Tenant y Migración de Datos

2026-04-04T14:52:00.000-03:00

Nuevas Fronteras en GestiónCuotas: UI Reactiva, Seguridad Multi-Tenant y Migración de Datos

¡Seguimos avanzando a paso firme en el desarrollo de nuestro motor de gestión SaaS! Durante las últimas semanas, el equipo se ha centrado en tres pilares fundamentales que transforman el proyecto de un motor de backend robusto a una plataforma lista para el despliegue inicial. Estos avances no solo mejoran la experiencia de usuario, sino que también solidifican la arquitectura para garantizar la seguridad, escalabilidad y auditabilidad que nos propusimos desde el inicio.

A continuación, detallamos las tres grandes fases que hemos completado.

1. Fase 1.3: Ficha de Detalle Reactiva con HTMX

La interacción del administrador con el estado de cuenta de un sujeto de facturación (sea un alumno o un copropietario) es una de las tareas más recurrentes. Para hacer este proceso ágil y moderno, hemos implementado una "Ficha de Detalle" que evita las recargas de página completas, ofreciendo una experiencia de usuario fluida y eficiente.

¿Cómo lo logramos?

Interactividad con HTMX: Utilizamos la biblioteca HTMX para enviar solicitudes al backend y actualizar solo los fragmentos necesarios del DOM. Al registrar un pago, únicamente la tabla de deudas y el saldo total se actualizan, sin que el navegador deba recargar toda la página.
Diseño limpio con Tailwind CSS: La interfaz fue construida con clases utilitarias de Tailwind CSS, logrando un diseño profesional, agnóstico y semántico. Los colores de los estados (Verde para Pagado, Rojo para Vencido) permiten una rápida identificación visual.
Feedback al Usuario: Implementamos indicadores de carga (hx-indicator) que muestran un spinner mientras el motor procesa un pago, informando al usuario que una acción está en progreso.

Ejemplo del botón de pago en nuestro template de Django:

<!-- Formulario de Pago con HTMX -->
<form hx-post="{% url 'facturacion:registrar_pago' sujeto.id %}" 
      hx-target="#tabla-deudas-container"
      hx-swap="innerHTML"
      hx-indicator="#pago-loading">
    
    <button type="submit" class="btn-pagar">
        <span id="pago-text">Registrar Pago</span>
        <!-- Indicador de carga -->
        <svg id="pago-loading" class="htmx-indicator animate-spin" xmlns="http://www.w3.org/2000/svg" fill="none" viewBox="0 0 24 24">
            <circle class="opacity-25" cx="12" cy="12" r="10" stroke="currentColor" stroke-width="4"></circle>
            <path class="opacity-75" fill="currentColor" d="M4 12a8 8 0 018-8v8H4z"></path>
        </svg>
    </button>
</form>

2. Fase 1.4: Sistema de Seguridad Multi-Tenant (RBAC)

La seguridad y el aislamiento de datos son innegociables en una arquitectura SaaS multi-tenant. Hemos implementado un Control de Acceso Basado en Roles (RBAC) que se integra perfectamente con django-tenants.

Niveles de Acceso Definidos:

SuperAdmin (Global): Control total sobre el esquema public, responsable de crear y gestionar los Tenants (los clientes del SaaS).
Admin de Tenant: El administrador principal de una escuela o consorcio. Puede configurar su tenant, crear otros usuarios y acceder a reportes.
Operador de Caja: Un rol con permisos limitados, enfocado en la operatoria diaria. Solo puede ver estados de cuenta y registrar pagos.

Gracias al middleware de django-tenants, cualquier intento de un usuario de un tenant de acceder a datos de otro es bloqueado a nivel de base de datos, garantizando un aislamiento total.

Adicionalmente, se implementaron decoradores de permisos personalizados (ej. @role_required('admin')) para proteger las vistas y servicios de forma granular. Para una trazabilidad legal completa, se extendió el AbstractAuditModel para registrar el usuario (ID y Rol) que realizó cada cambio, incluyendo una "instantánea" del rol en el momento de la operación.

3. Fase 1.5: Asistente de Importación de Datos Legados

Para facilitar la transición de nuestros primeros clientes, hemos desarrollado un "Asistente de Importación" que permite migrar datos desde archivos Excel/CSV de forma segura y controlada.

Características Clave:

Motor de Mapeo Agnóstico: El servicio utiliza la biblioteca Pandas para procesar los archivos. Mapea columnas con nombres genéricos (ej. 'DNI_TUTOR', 'SALDO_ADEUDADO') a los modelos abstractos de nuestro sistema, asegurando la flexibilidad.
Creación de Saldos Iniciales: Al importar, el sistema genera automáticamente una "Cuota de Ajuste" o "Saldo Inicial" para cada sujeto, garantizando que su cuenta corriente en el nuevo sistema refleje con precisión su estado anterior.
Reporte de Errores Detallado: Si una fila del archivo contiene errores (ej. un CUIT duplicado o un formato de fecha inválido), el proceso no se detiene. En su lugar, se registran los errores y se genera un log para que el usuario pueda corregir solo las entradas problemáticas, mientras se procesan las válidas.
Trazabilidad y Auditoría: Cada registro creado mediante este proceso queda marcado en nuestro AbstractAuditModel como una "Carga Masiva Inicial", cumpliendo con nuestros estrictos requisitos de auditabilidad y defendibilidad judicial.
Interfaz con HTMX para el progreso: El asistente de importación incorpora una vista simple con HTMX que muestra una barra de progreso o un spinner, manteniendo al usuario informado sobre el estado del procesamiento del archivo.

Conclusión y Próximos Pasos

Con estos avances, GestiónCuotas está más cerca que nunca de su lanzamiento piloto. Hemos sentado las bases de una interfaz de usuario moderna, un sistema de seguridad robusto y una vía de migración eficiente para nuestros futuros clientes e inversores.

El próximo gran paso será el despliegue del Dashboard de Control de Gestión, donde los administradores podrán visualizar métricas de cobrabilidad en tiempo real. ¡El motor está listo y funcionando!

Publicado por el equipo de desarrollo de GestiónCuotas - Mendoza, 2026.

Sistema de Gestión de Cuotas y Pagos para Instituciones Educativas

2026-03-12T05:30:00.002-03:00

Estado Actual de la Aplicación de Gestión de Cuotas

Sistema de Gestión de Cuotas y Pagos para Instituciones Educativas

Esta aplicación web, desarrollada con Django, está diseñada para optimizar la administración financiera de instituciones educativas. Permite gestionar de forma eficiente las cuotas estudiantiles, los pagos recibidos y el estado de cuenta de cada alumno.

Funcionalidades Principales:

Gestión Integral de Alumnos: Mantenimiento centralizado de la información de alumnos y sus familias, incluyendo datos de contacto, DNI, fecha de nacimiento, y estado de pago anual o convenios.
Administración de Ciclos Lectivos y Cursos: Define y organiza los ciclos lectivos, asignando cursos con montos base de cuota a cada uno. La aplicación se enfoca en el ciclo lectivo activo para reflejar el contexto financiero actual.
Inscripciones y Acuerdos de Pago: Registra las inscripciones de alumnos a cursos específicos, estableciendo el monto exacto de la cuota acordada para esa inscripción y permitiendo definir su estado (Activa, Baja, Egresado).
Registro Detallado de Pagos: Permite registrar cada pago recibido, especificando el concepto (cuota mensual, matrícula, material, etc.), el método de pago (efectivo, transferencia, mercado pago, etc.), el mes y año correspondiente, y el monto abonado. Soporta movimientos de crédito y débito.
Cálculo Automático de Deudas: Basándose en las inscripciones activas y los pagos registrados para el ciclo lectivo actual, la aplicación calcula automáticamente el saldo adeudado por cada alumno, identificando los meses pendientes de pago y el monto total de la deuda.
Visión Clara del Estado Financiero: Ofrece perfiles detallados de cada alumno, mostrando su historial de pagos, inscripciones activas, deuda actual, y el próximo mes a abonar. Incluye estadísticas de pagos y cantidad de transacciones.
Gestión por Instituto: La aplicación soporta la administración de múltiples instituciones (Institutos), asegurando que los usuarios solo vean la información correspondiente a su entidad.
Acceso Web y Navegación Intuitiva: Las funcionalidades son accesibles a través de una interfaz web clara y organizada, con rutas específicas para listar alumnos, ver detalles individuales, registrar pagos y gestionar inscripciones.

Esta herramienta simplifica la labor administrativa, reduce errores manuales y proporciona una visión precisa y actualizada de las finanzas estudiantiles, facilitando una gestión más ágil y transparente.

2026-03-03T00:00:00.001-03:00

Informe de Estado y Proyección: Sistema de Gestión Académica

Fecha: 2 de marzo de 2026
Proyecto: Migración y Escalabilidad del Sistema de Cuotas y Alumnos
Estado: Fase de Infraestructura Core Completada

1. Resumen de lo Realizado hasta la Fecha

Se ha completado con éxito la transición del antiguo modelo de datos (basado en Access) hacia una arquitectura web moderna utilizando Django y PostgreSQL. Este cambio garantiza integridad de datos, capacidad de acceso multiusuario simultáneo y seguridad remota.

Logros Técnicos:

Normalización de Base de Datos: Se implementó una jerarquía relacional lógica: Ciclo Lectivo > Curso > Inscripción > Alumno. Esto permite que la academia crezca año tras año manteniendo un histórico impecable sin duplicar fichas de alumnos.
Gestión de Ciclos Lectivos: Implementación de una entidad global que permite "activar" o "desactivar" periodos académicos. Esto automatiza la lógica de cobro y asegura que los administrativos siempre trabajen sobre el año vigente por defecto.
Módulo de Cobranza Dinámico: Creación de un sistema de seguimiento de cuotas por mes, permitiendo el registro detallado de medios de pago (Efectivo, Transferencia, Mercado Pago) y vinculándolos a una inscripción específica.
Interfaz de Administración Avanzada: Configuración de un panel de control con edición anidada (Inlines). Ahora, desde la ficha de un alumno, es posible gestionar sus inscripciones y pagos de forma centralizada.

2. Estructura de Datos Actual

El sistema ha sido diseñado bajo tres pilares de consistencia:

El Ciclo Lectivo: Es el eje temporal (ej. 2025, 2026). Controla cuándo inician las actividades y cuál es el periodo de facturación actual.
El Curso: Está anclado a un Ciclo Lectivo y define la oferta académica y el costo base de la cuota para ese periodo.
La Inscripción: Es el contrato legal/económico. Vincula al alumno con un curso y permite pactar montos especiales (becas o acuerdos por contingencia).

3. Visión de Futuro: Próximos Módulos

El sistema está preparado para evolucionar de una herramienta de gestión administrativa a una Plataforma Educativa Integral.

A. Módulo de Calificaciones (Acceso Docente Seguro)

Este es el próximo hito fundamental. El objetivo es descentralizar la carga de notas manteniendo la máxima seguridad:

Roles de Usuario (RBAC): Perfil específico para "Profesores". El docente solo podrá visualizar y editar los datos de los alumnos inscritos en sus cursos asignados.
Privacidad de Datos: El personal docente no tendrá acceso a la información financiera ni a datos sensibles de contacto de las familias.
Libreta Digital y Actas: Interfaz intuitiva para carga de calificaciones. Incluirá un sistema de "Cierre de Acta" para bloquear las notas una vez finalizado el periodo de carga.

B. Portal para Familias y Alumnos

Autogestión: Consulta online de estados de cuenta y descarga de recibos.
Boletín de Calificaciones: Visualización en tiempo real de las notas cargadas.

C. Auditoría y Cumplimiento Legal

Logs de Actividad: Registro automático de cada cambio realizado en el sistema (quién modificó una nota, quién registró un pago).
Protección de Datos: Adaptación de los formularios a los marcos legales de protección de datos personales.

4. Conclusión Técnica

La base actual es sólida y escalable. Gracias al uso de Docker, el sistema es "cloud-ready", permitiendo una migración inmediata a un servidor web cuando se decida abrir el acceso a los profesores. La arquitectura modular garantiza que la incorporación del sistema de notas sea un proceso fluido.

Mejoras en el Software de Gestión de Cuotas

2025-03-21T03:00:00.001-03:00

El software sigue funcionando. No está roto. No ha colapsado. Pero la deuda técnica está ahí, acumulándose como una pila de tareas pendientes que nunca encuentran su momento. Ha llegado la hora de hacer algo al respecto.

El objetivo para lo que queda del año es claro: mejorar lo que ya está, saldar deudas técnicas y dejar el código en un estado más sólido y mantenible. No se trata de una revolución, sino de pequeños ajustes, optimizaciones y rediseños que hagan la diferencia.

¿Qué cambios se vienen?

👉 Refactorización del código: Hay fragmentos que funcionan, sí, pero con un nivel de rudeza que duele ver. La idea es hacerlos más eficientes, más organizados y más fáciles de mantener.

👉Optimización de la gestión de cuotas: Mejorar la estructura de los datos y los reportes para hacer el seguimiento de pagos más claro y ágil.

👉Automatización de tareas repetitivas: Reducir el trabajo manual con VBA y macros, permitiendo que el sistema haga más con menos intervención.

👉Interfaz más intuitiva: Sin necesidad de una revolución estética, pequeños ajustes pueden hacer que el uso del software sea más fluido y amigable.

El dilema de siempre

Este es un proyecto sin un retorno económico directo. No hay una retribución esperándome al final del camino. Hacerlo es una cuestión de convicción, de satisfacción personal, de la certeza de que algo que fue útil puede ser mejor y más duradero.

Y aunque el código pueda mejorar y el sistema pueda optimizarse, hay un límite: no puedo hacerlo público. No es un software para compartir abiertamente, sino una herramienta con información sensible que debe mantenerse en su contexto.

Conclusión

Se vienen meses de trabajo silencioso. No será un desarrollo frenético ni un rediseño total, pero cada mejora sumará a la estabilidad del sistema. Quizás, en el futuro, este software pueda trascender más allá de su uso actual y convertirse en algo más grande. Pero por ahora, lo que toca es seguir adelante, mejorar lo que se pueda y disfrutar del proceso. 👍

2025-03-19T10:55:00.000-03:00

Todo software tiene una historia, pero no todas las historias de software comienzan con un plan claro. Algunas surgen en medio de la incertidumbre, sin un objetivo del todo definido, avanzando a tientas, buscando su rumbo. Así nació este proyecto: sin un destino claro, pero con la certeza de que debía existir.

Al principio, la pregunta era siempre la misma: ¿hacia dónde debería ir esto? No había respuestas definitivas, solo un proceso de prueba y error, de ideas que parecían buenas hasta que dejaban de serlo, de soluciones improvisadas que con el tiempo demostraban su valor. Y en ese andar incierto, sin saberlo, se estaba aplicando una de las ideas más poderosas del desarrollo de software moderno: el agilismo.

Años después, cuando Alistair Cockburn presentó en Mendoza su visión sobre el agilismo, quedó claro que este método no es solo una estrategia consciente, sino también una forma natural de crear. Construir sin tener todos los datos de antemano. Permitir que la propia necesidad del proyecto vaya tirando de la cuerda, en lugar de esperar a que todo esté perfectamente planeado antes de empezar.

Muchos proyectos nacen bajo un aura de contradicciones y dudas. Pero el secreto no está en resolver todas esas dudas antes de dar el primer paso, sino en avanzar a pesar de ellas. No dudes. Ve hacia adelante.

Quien construye algo con verdadera determinación lo hace a cualquier costo. Desafía obstáculos, aprende en el camino y encuentra maneras de seguir adelante cuando todo parece indicar lo contrario. No espera el momento perfecto, porque sabe que nunca llegará. Y en esa constancia, tarde o temprano, hay una recompensa. No siempre es el reconocimiento externo, ni siquiera el éxito comercial. A veces, la mayor satisfacción es poder mirarse al espejo y ver a alguien que defendió, cuidó y valoró una idea a lo largo del tiempo. Un año, dos… o toda una vida.

Introducción

2025-03-18T15:53:00.000-03:00

Todo software tiene una historia. Nace con una idea, crece con el esfuerzo de quienes lo construyen y, con el tiempo, se transforma en algo más grande de lo que sus creadores imaginaron en un principio. Este es el relato de una aplicación que comenzó como un simple experimento y terminó convirtiéndose en una herramienta utilizada en diversas instituciones. Su código evolucionó, se adaptó a nuevas necesidades y sobrevivió a los cambios tecnológicos y organizativos que tantas veces dejan atrás a proyectos similares.

Este libro no es un manual técnico, ni una guía para programadores. Es la historia de un sistema que nació, creció y aún sigue funcionando, sorteando obstáculos y aprovechando cada oportunidad de mejora. No se trata solo de líneas de código, sino de decisiones, aprendizajes y dilemas que todo software atraviesa en su camino.

A lo largo de sus capítulos, se explorará cómo se gestó la idea original, los desafíos técnicos y humanos que surgieron en su desarrollo, los momentos de crisis en los que casi fue abandonado y las decisiones clave que permitieron su continuidad. También se abordará el contexto en el que se implementó, los cambios que experimentó con el tiempo y la visión de futuro que hoy se proyecta sobre él.

Este libro es para quienes disfrutan las historias de creación y evolución tecnológica. Para los curiosos que alguna vez se preguntaron cómo un conjunto de archivos en una computadora puede convertirse en una herramienta esencial en la vida de muchas personas. Para quienes saben que el software no es solo código, sino también historia.

Reflexiones Sobre un Proyecto Literario

2025-01-17T12:35:00.001-03:00

Hoy quiero compartir con ustedes una idea que viene rondando mi cabeza desde hace un tiempo: la posibilidad de escribir un libro sobre la experiencia de desarrollar una aplicación que lleva años funcionando, evolucionando, y adaptándose a nuevas necesidades. Este software, que comenzó como una herramienta sencilla para gestionar las cuotas en un instituto, ha crecido conmigo, tanto a nivel técnico como personal.

No planeo entrar en muchos detalles por ahora, pero sí me entusiasma explorar este proyecto desde una perspectiva reflexiva. ¿Qué significó empezar sin grandes planes? ¿Cómo las pequeñas soluciones se convirtieron en algo más grande? ¿Qué enseñanzas me dejó este viaje como programador, como colaborador, y como alguien que trata de construir algo útil y duradero?

Pero más allá de la idea técnica, creo que este libro también sería una forma de enfrentar una época personal complicada. El estrés, las molestias cervicales, y las consecuencias de algunos hábitos negativos, me han hecho reflexionar sobre cómo encontrar formas más saludables de canalizar la energía y el pensamiento. A veces, escribir puede ser una válvula de escape poderosa, y siento que compartir este proyecto podría ser una manera de sanar mientras me conecto con otros que quizás estén en un camino similar.

Quiero que este libro, si llega a ver la luz, sea algo más que un manual técnico. Quiero que sea una conversación sobre creatividad, errores, aprendizajes y la relación que tenemos con nuestro trabajo, especialmente en un campo como el desarrollo de software, que avanza a una velocidad vertiginosa.

Me gustaría escuchar sus opiniones: ¿les parece interesante un libro de este tipo? ¿Qué aspectos les gustaría leer en una obra que hable sobre la construcción de software desde cero y sobre el impacto que tiene en nuestras vidas?

Espero que esta idea sea el inicio de un diálogo y, quizás, el comienzo de un proyecto que no solo cuente una historia, sino que inspire a otros a compartir las suyas.

Gracias por tomarse el tiempo de leer esto, y por cualquier comentario o sugerencia que quieran dejar. Estoy atento y con muchas ganas de escuchar sus devoluciones. 😊

Relatar, nada.

2023-11-17T12:49:00.000-03:00

Se dijo en la oficina que hacía calor y que había que prender el aire acondicionado, de todos modos estamos preparados para lo peor. Hoy, tendremos viento zonda de manera que lo que se viene es aleccionador, para algunos. Tendremos que mirar hacia adelante otra no queda. Después, mirar hacia el pasado y sentir que lo que hicimos tuvo algún sentido quizás oculto, quizás extraño.

Llegó enojado, con el ceño fruncido y lo peor es que ni sabe que está enojado. Lo oculta para sí y para los demás, evita tomar contacto con esas emociones no quiere reconocerlo, oculta su rostro para que los demás no se enojen. ¡Pero que se enojen! Que no se disgusten. ¡Pero que se disgusten! Toda su vida pretendió ser alguien que no era dejando de lado sus verdaderas intenciones, sus gustos, lo que pensaba. Y así, en una actitud temeraria, volcaba sus frustraciones en cada relación, en cada vínculo que se acercaba. Estaban ya convencidos que de pegarle hasta matarlo, él lo agradecería. ¿Y por qué actuaba así? Era incapaz de hacer lo que le sugerían. Eso de sentarse con alguien a conversar pidiendo nuevas condiciones laborales no estaba siquiera en sus más remotos planes. Hoy, alguien se lo sugería y ya salía corriendo a pensar que era la solución. Todo lo que le decían que hiciera, él estaba dispuesto a coronar la semana haciendo caso. Y si no, al menos a angustiarse por la idea.

Le dijo lo que pensaba, ni más ni menos. Se quedó mudo. No habló una sóla palabra más en toda la mañana. Tiró al piso su celular, en señal de disconformidad evidente, mientras se puso a verificar que su computadora nueva funcionara bien. Quienes estaban a su alrededor no entendían la maniobra, lo miraban de reojo de vez en cuando buscando una respuesta o un gesto de desquicio, algo. Se lo notaba nervioso tal vez apurado. Se venía el evento del año, ese en el que todos se encuentran para celebrar los logros anuales y no estaba entusiasmado con la idea de participar. Lo que pasaba cada vez que hacía flan en microondas, lo tenía perplejo. Asustado. Inerme. Impotente. Los demás, acusaban al resto de no ocuparse, como si fuera tan fácil. El, subía los estados. Esa era su tarea.

2023-04-10T15:08:00.000-03:00

La mañana se presentó bastante agradable, más bien tirando a fresca en San Rafael, pero todos en su mayoría concurrieron al trabajo. Menos él, que tenía cosas que hacer, dijo. Leer, en primer término el nuevo contrato de alquiler. Revisar, después, el estado del cerco perimetral y controlar que no hayan bichos nuevos. Los de siempre serán tenidos en cuenta por el jardinero, dijo. Sonó su teléfono. Era el jefe. Había que mover cientos de expedientes de lugar, como quien saca la basura en su casa y la lleva a un depósito de chatarra para ser depositada ahí hasta nuevo aviso, mientras hace lugar en la habitación. Todo eso, por el mismo precio. No había justicia en este mundo, todos navegaban en internet menos él. Todos estaban contentos por la llegada del nuevo menos él, que sería quien tendría que prestar su computadora. Todos estaban ansiosos por la llegada del nuevo, menos él que tenía que ceder como de costumbre a los caprichos de los otros que decían: se ha aislado nuevamente. No responde los llamados ni nada. El celular no hace otra cosa que gritar ahí su espanto y él, nada.

Fue y compró una docena de facturas y las puso ahí, a disposición de todos para que se sirva quien quiera. Sin embargo, alguien fue y retiró ocho dejando el peladero. Ya estaban nerviosos querían saber quién había sido. Estaban angustiados porque si algo así era posible de suceder, qué nos esperaba en adelante. Todos enterados de la situación, tenían que resolver y actuar en consecuencia. Era difícil. No quería que esto pasara, no otra vez. Pero estaba ahí y era él quien tenía que hacerse cargo. No había nadie más en el lugar, ni cámaras que atestiguaran lo que sucedía en la cocina cuando se iban todos. Sería más barato que un sanguche.

Revisó su correo y ahí estaba. Era la acreditación para el ingreso a la oficina. Estaban todos contentos con su llegada, menos ella. Había puesto cara de mala, la conocían bien. No hizo más que poner un pie en la oficina y ella empezó a patear al piso, con gesto de delincuenta. La quisimos de inmediato. Recordamos lo que pasaba antes, cuando los que venían de afuera eran tratados con sangre en las manos, en la ropa, en los labios. Morder ahí, era posible. Y eso querían todos.

Encontró el password y eso le hizo sentir útil, una vez más. En cuanto pudo, se fue a caminar. Dejó de lado lo que había hecho hasta ahora. Empezó por socavar su espacio, lentamente, buscando rechazar lo que había hecho hasta el momento. Pero fue imposible, estaba bien preparado, había hecho lo que hay que hacer: estudiar y ser consecuente con sus ideas. Lo que no estaba del todo bien, era que no le daban ni bolilla. Estaba dándolo todo y sin embargo se encontraba con un hermetismo imposible de romper y eso le provocaba angustia y tristeza. ¿Por qué, si él había intentado todo para ser agradable, para ser alguien en su vida y conversar, al menos conversar? Pero no, recibía un silencio que le calaba el alma, ese frío invernal que conmueve al espíritu.

Se levantó al fin de su silla. Fue al baño y al regresar intentó cruzar una palabra con el ortiba del jefe. Ese que siempre está molestando con peticiones insoportables, llenas de ego donde lo único que importa es satisfacer las inquietudes de ese ego inflado y lleno de suberbia, tal como lo señala su esposa en cada enfrentamiento. Están separados. Hace años. Y las últimas reuniones eran por la tenencia de los hijos y, por supuesto, por la tenencia de la antigua máquina de escribir Olivetti que habían decidido transformar en un botín de guerra.

Pero siguen frente a frente, bajo la tutela y el amparo protector de un abogado que hace las veces de mediador. Están juntos, inseparables, al final. Todo parece arreglarse hasta que de pronto estalla la más mínima chispa y se enciende de nuevo la impiadosa vanidad que destruye todo alrededor. Están cansados, lo dijo él, pero siguen porque no tienen dinero, que si no. Otro sería el cantar.

Nada

2023-02-22T13:18:00.003-03:00

Un gato grande, eso debería buscar. Pero cómo saber si se volverá grande o no, y digo que el tamaño importa porque después tendrá que pasar por la ventanuca que le dejamos abierta todos los días para que salga y de una vuelta por la vereda, así se distrae un poco y no se pone tan intenso en casa lo queremos grande decía porque es más adecuado para acariciar, tenés más piel y coso.

Lo que vimos ayer nos conmovió: uno que cuidaba la ventana de su casa y salió a recibirnos pero con mucha cautela, se escondió detrás de una baranda y allí estuvo el rato que duró nuestra recorrida por el barrio. Dimos un par de vueltas a la manzana y después de discutir sobre la conveniencia o no de pasar por esa ventana, llegamos a casa cansados pero contentos de haber hecho ejercicio otra vez. La enfermedad nos tuvo atrapados un tiempo en casa, sin poder caminar algo que disfrutamos siempre. Alquilamos un auto y así nos fue.

Poema

2023-02-06T17:22:00.001-03:00

Seré sincero esta vez recordar

Lo vivido intensamente es fácil

lo dicen todos de una vez

Hay que soltar dejar ir

Uno acompaña, qué diablos para qué

Si al final termina tendido

En una cama matrimonial cubierto

De las más espléndidas estrellas

Que uno quiera imaginar

Aquí también seré sincero

No hay noche que no la sueñe

para vos será fácil no sé

en cambio para mí, una tortura.

Poema

2022-11-22T16:36:00.001-03:00

Fundirse en uno estimula

cierta pereza intrínseca que disuelve

la llama pobre del estilo

sufrir lo que viene

estibar rosas a lo largo

transitando en lo alto

un augurio de paloma que vuela

bajo sin derramar una sola gota

sensatez qué difícil hallazgo

aniquilado en vida soy,

muero como decía en lo alto

al mismo tiempo recibo y sueño

Poema

2022-10-03T08:38:00.000-03:00

Empieza como trueno y atraviesa la tarde

Silenciosa y taciturna

Deseamos convalecer a su lado

Demorar esa espera

Quedarnos quietos calientes

Mirando la nada como si

Hubiera un mañana

Es inaudito nadie dura tanto

En esas condiciones

En su lugar ya me hubiera ido

Cómo hace

Espera como un animal

Sin despertar sospechas

Un familiar recorre la tarde

Montado en un café.

Borracho

2022-07-18T12:54:00.004-03:00

Este espejo delante

es muy tibio

sabe de rincones y mañanas

busca en la nevera un espacio más

donde envolver un tibio repasador

después de dejar los cubiertos en orden

bajo la espesa rutina

de todo un universo

que se cuela

entre los párpados batientes

de mi amada,

que no repara en el hecho

de que

yo cambié para mejor.

Poema

2022-05-30T16:52:00.002-03:00

Olvidar es lo tibio dicen aquí

adentro cabe un alfiler

estruendo y risas

golpes de puño y sable

Termino aquí franco

estival es el tiempo

que tengo entre sábanas

blancas y fragancias

sintiendo lo usual

fingiendo querer

transpirar la nada

y velar por la salud

corbata y vestido

taco y pelo ondulado

quiebre y resplandor

sumiso y rapaz