<?xml version="1.0" encoding="utf-8" standalone="yes"?><rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom"><channel><title>Humanidades Digitales |</title><link>https://clementgodbarge.com/es/category/humanidades-digitales/</link><atom:link href="https://clementgodbarge.com/es/category/humanidades-digitales/index.xml" rel="self" type="application/rss+xml"/><description>Humanidades Digitales</description><generator>HugoBlox Kit (https://hugoblox.com)</generator><language>es-es</language><lastBuildDate>Tue, 05 May 2026 00:00:00 +0000</lastBuildDate><image><url>https://clementgodbarge.com/media/icon_hu_64a6c3bec25b3d7b.png</url><title>Humanidades Digitales</title><link>https://clementgodbarge.com/es/category/humanidades-digitales/</link></image><item><title>tei-mcp v0.3: codificar en TEI sin reescribir la fuente</title><link>https://clementgodbarge.com/es/post/tei-mcp-span-locked/</link><pubDate>Tue, 05 May 2026 00:00:00 +0000</pubDate><guid>https://clementgodbarge.com/es/post/tei-mcp-span-locked/</guid><description>&lt;p&gt;Cuando
, el objetivo era que los asistentes de IA dejaran de alucinar marcado TEI. El anclaje en el esquema (&lt;em&gt;schema grounding&lt;/em&gt;) resolvió parte del problema: con acceso directo, mediante herramientas, a la especificación P5, el modelo ya no tiene que adivinar qué significa un elemento ni qué atributos acepta. La salida valida.&lt;/p&gt;
&lt;p&gt;Pero en la codificación TEI la alucinación tiene dos caras, y el esquema solo atrapa una. Validar contra la especificación garantiza que el &lt;em&gt;marcado&lt;/em&gt; está bien formado; no dice nada del &lt;em&gt;texto&lt;/em&gt; que ese marcado envuelve. Y es ahí —en el texto mismo— donde anidan las alucinaciones más dañinas. La composición con intervalos bloqueados, la gran novedad de la v0.3, está pensada precisamente para impedirlas.&lt;/p&gt;
&lt;details class="print:hidden xl:hidden" &gt;
&lt;summary&gt;Índice&lt;/summary&gt;
&lt;div class="text-sm"&gt;
&lt;nav id="TableOfContents"&gt;
&lt;ul&gt;
&lt;li&gt;&lt;a href="#la-alucinación-que-el-esquema-no-atrapa"&gt;La alucinación que el esquema no atrapa&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="#la-composición-con-intervalos-bloqueados"&gt;La composición con intervalos bloqueados&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="#qué-es-esto-y-qué-no-es"&gt;Qué es esto, y qué no es&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="#por-qué-importa-más-allá-de-la-tei"&gt;Por qué importa más allá de la TEI&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="#cómo-obtener-la-actualización"&gt;Cómo obtener la actualización&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;
&lt;/nav&gt;
&lt;/div&gt;
&lt;/details&gt;
&lt;h2 id="la-alucinación-que-el-esquema-no-atrapa"&gt;La alucinación que el esquema no atrapa&lt;/h2&gt;
&lt;p&gt;Pida a un modelo que codifique una carta francesa del siglo XVI y obtendrá, muchas veces, un documento TEI de aspecto impecable: la cabecera rellena, las etiquetas &lt;code&gt;&amp;lt;persName&amp;gt;&lt;/code&gt; en su sitio, el &lt;code&gt;&amp;lt;dateline&amp;gt;&lt;/code&gt; bien formado. Páselo por &lt;code&gt;validate_document&lt;/code&gt; y lo supera.&lt;/p&gt;
&lt;p&gt;Compare ahora el cuerpo con la fuente.&lt;/p&gt;
&lt;p&gt;&lt;code&gt;mesme&lt;/code&gt; se ha convertido en &lt;code&gt;même&lt;/code&gt;. Una coma ha cambiado de sitio. &lt;code&gt;luy&lt;/code&gt; se ha modernizado en silencio en &lt;code&gt;lui&lt;/code&gt;. Una cláusula de lectura difícil en el manuscrito ha sido «corregida» hasta quedar más limpia. Nadie pidió ninguno de esos cambios; ninguno aparece señalado. El documento es válido según el esquema y está calladamente equivocado.&lt;/p&gt;
&lt;p&gt;Para un flujo de trabajo archivístico —donde el texto codificado se convierte en el registro permanente del que dependerán lectores, índices de búsqueda y citas— este es el modo de fallo que más importa. Una etiqueta malformada es una molestia; una grafía modernizada que nadie advierte en cinco años es una corrupción.&lt;/p&gt;
&lt;h2 id="la-composición-con-intervalos-bloqueados"&gt;La composición con intervalos bloqueados&lt;/h2&gt;
&lt;p&gt;La nueva versión (v0.3) incorpora un mecanismo de prevención de alucinaciones dirigido justo a ese modo de fallo. El objetivo de diseño es que las alucinaciones en el cuerpo del texto sean imposibles por construcción, no simplemente improbables.&lt;/p&gt;
&lt;p&gt;La idea es sencilla: &lt;strong&gt;el modelo nunca teclea el cuerpo del texto&lt;/strong&gt;.&lt;/p&gt;
&lt;p&gt;El flujo de trabajo es, en cambio, el siguiente:&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;El modelo llama a &lt;code&gt;get_source(&amp;quot;letter_001&amp;quot;)&lt;/code&gt; y recibe el texto plano de la fuente como cadena inmutable.&lt;/li&gt;
&lt;li&gt;Por cada etiqueta que quiera aplicar, llama a &lt;code&gt;tag_span(&amp;quot;letter_001&amp;quot;, start, end, element_path, attrs)&lt;/code&gt;, con lo que registra un elemento TEI sobre un rango de caracteres de la fuente.&lt;/li&gt;
&lt;li&gt;Al terminar, llama a &lt;code&gt;compose(&amp;quot;letter_001&amp;quot;)&lt;/code&gt;. El servidor intercala las etiquetas registradas en el texto plano original, genera el TEI final y comprueba después, &lt;em&gt;byte a byte&lt;/em&gt;, que el contenido textual plano del documento generado es idéntico a la fuente.&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;Si los bytes coinciden, el documento se devuelve. Si no —si las etiquetas del modelo implican de algún modo un cuerpo que se aparta de la fuente aunque sea en un solo carácter—, &lt;code&gt;compose()&lt;/code&gt; lanza una excepción en lugar de entregar un documento corrupto.&lt;/p&gt;
&lt;p&gt;No hay ningún camino en este flujo de trabajo por el que el modelo pueda producir un documento TEI cuyo cuerpo difiera de la fuente. El invariante es mecánico, no conductual. No hace falta confiar en que el modelo no alucine; basta confiar en una comprobación &lt;code&gt;==&lt;/code&gt; entre dos cadenas de bytes.&lt;/p&gt;
&lt;h2 id="qué-es-esto-y-qué-no-es"&gt;Qué es esto, y qué no es&lt;/h2&gt;
&lt;p&gt;La composición con intervalos bloqueados &lt;strong&gt;complementa&lt;/strong&gt; el anclaje en el esquema; no lo sustituye. Las herramientas de anclaje (&lt;code&gt;validate_document&lt;/code&gt;, &lt;code&gt;lookup_element&lt;/code&gt;, &lt;code&gt;valid_children&lt;/code&gt; y el resto de las dieciséis originales) ayudan al modelo a producir TEI &lt;em&gt;válido&lt;/em&gt;; la composición con intervalos bloqueados garantiza que el cuerpo del texto dentro de ese TEI sea &lt;em&gt;fiel&lt;/em&gt; a la fuente. Un flujo de codificación que pueda desplegarse de verdad tiene que satisfacer ambos ejes, y ahora los dos quedan cubiertos por un solo servidor.&lt;/p&gt;
&lt;p&gt;Tampoco es una varita mágica. &lt;code&gt;compose()&lt;/code&gt; todavía no comprueba que las etiquetas registradas sean admisibles según la personalización ODD cargada; eso queda para más adelante. Las etiquetas registradas viven en la memoria del proceso y no sobreviven a un reinicio. Y los archivos fuente tienen que poder leerse desde donde se ejecute el servidor. Todo ello tiene arreglo; nada de ello socava el invariante central.&lt;/p&gt;
&lt;h2 id="por-qué-importa-más-allá-de-la-tei"&gt;Por qué importa más allá de la TEI&lt;/h2&gt;
&lt;p&gt;El patrón se generaliza. Siempre que se pida a un modelo que anote, transforme o envuelva un fragmento de texto —y siempre que la integridad del texto importe más que la capacidad del modelo para «mejorarlo»— vale la misma forma de solución: no pedir al modelo que vuelva a teclear el texto, sino que produzca instrucciones sobre él, y dejar que un compositor determinista las aplique bajo un invariante de igualdad.&lt;/p&gt;
&lt;p&gt;Para las ediciones digitales en particular, esto cambia lo que se puede pedir a un modelo con responsabilidad. De pronto, la codificación es una tarea que se puede delegar sin tener que cotejar a mano cada salida con la fuente. La máquina se ocupa de la parte tediosa; el editor revisa el marcado, no la ortografía.&lt;/p&gt;
&lt;h2 id="cómo-obtener-la-actualización"&gt;Cómo obtener la actualización&lt;/h2&gt;
&lt;p&gt;Si ya tiene instalado tei-mcp:&lt;/p&gt;
&lt;div class="highlight"&gt;&lt;pre tabindex="0" class="chroma"&gt;&lt;code class="language-bash" data-lang="bash"&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt;uvx tei-mcp@latest
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;O desde cero:&lt;/p&gt;
&lt;div class="highlight"&gt;&lt;pre tabindex="0" class="chroma"&gt;&lt;code class="language-bash" data-lang="bash"&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt;pip install tei-mcp
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;Para usar la composición con intervalos bloqueados, apunte el servidor a un directorio con los archivos fuente en texto plano:&lt;/p&gt;
&lt;div class="highlight"&gt;&lt;pre tabindex="0" class="chroma"&gt;&lt;code class="language-bash" data-lang="bash"&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt;&lt;span class="nb"&gt;export&lt;/span&gt; &lt;span class="nv"&gt;TEI_MCP_SPAN_SOURCE_ROOT&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;/path/to/sources
&lt;/span&gt;&lt;/span&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt;uvx tei-mcp
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;El nombre base de cada archivo se convierte en su identificador de documento (&lt;code&gt;letter_001.txt&lt;/code&gt; → &lt;code&gt;letter_001&lt;/code&gt;).&lt;/p&gt;
&lt;p&gt;Código fuente, documentación completa y notas de diseño del invariante:
&lt;/p&gt;</description></item><item><title>Una edición digital de otro tipo</title><link>https://clementgodbarge.com/es/post/cavriana-edition/</link><pubDate>Tue, 24 Mar 2026 00:00:00 +0000</pubDate><guid>https://clementgodbarge.com/es/post/cavriana-edition/</guid><description>&lt;p&gt;La mayoría de las fuentes primarias no llega nunca a publicarse. Y el modelo con que pretendemos remediarlo —la edición digital financiada con subvenciones— es demasiado caro, demasiado centralizado y demasiado frágil para funcionar a gran escala. Acabo de publicar
en la que explico por qué estoy construyendo de otro modo la edición crítica de las cartas de Cavriana: fuentes primarias digitalizadas que crecen orgánicamente, con una infraestructura mínima y un mantenimiento automatizado, abiertas a la colaboración y tan baratas que ni siquiera hacen falta subvenciones. Es un alegato en favor de unas humanidades digitales que funcionen con o sin apoyo institucional.&lt;/p&gt;</description></item><item><title>tei-mcp: TEI P5 para agentes de IA</title><link>https://clementgodbarge.com/es/post/tei-mcp/</link><pubDate>Sun, 15 Mar 2026 00:00:00 +0000</pubDate><guid>https://clementgodbarge.com/es/post/tei-mcp/</guid><description>&lt;p&gt;Quien haya usado un asistente de programación con IA para escribir XML TEI habrá notado, seguramente, que se equivoca: aparecen elementos donde no deben, se inventan atributos, se ignoran las reglas de anidamiento. El modelo tiene una idea aproximada de qué aspecto tiene la TEI, pero ningún conocimiento fiable de la especificación.&lt;/p&gt;
&lt;p&gt;tei-mcp resuelve el problema dando a los agentes de IA acceso directo, mediante herramientas, a las directrices TEI P5.&lt;/p&gt;
&lt;details class="print:hidden xl:hidden" &gt;
&lt;summary&gt;Índice&lt;/summary&gt;
&lt;div class="text-sm"&gt;
&lt;nav id="TableOfContents"&gt;
&lt;ul&gt;
&lt;li&gt;&lt;a href="#qué-es-mcp"&gt;¿Qué es MCP?&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="#qué-hace-tei-mcp"&gt;Qué hace tei-mcp&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="#por-qué-importa"&gt;Por qué importa&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="#primeros-pasos"&gt;Primeros pasos&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;
&lt;/nav&gt;
&lt;/div&gt;
&lt;/details&gt;
&lt;h2 id="qué-es-mcp"&gt;¿Qué es MCP?&lt;/h2&gt;
&lt;p&gt;El
(MCP) es un estándar abierto que permite a las aplicaciones de IA conectarse con fuentes de datos y herramientas externas. Piénsese en él como en un puerto USB para la IA: un único protocolo con el que cualquier cliente compatible —Claude, Cursor, Windsurf y otros— puede enchufarse a servicios especializados.&lt;/p&gt;
&lt;p&gt;Un servidor MCP expone &lt;em&gt;herramientas&lt;/em&gt; que la IA puede invocar en mitad de una conversación. En vez de fiarse de lo que memorizó durante el entrenamiento, el modelo consulta una fuente viva y autorizada.&lt;/p&gt;
&lt;h2 id="qué-hace-tei-mcp"&gt;Qué hace tei-mcp&lt;/h2&gt;
&lt;p&gt;tei-mcp analiza la especificación ODD de TEI P5 y expone 16 herramientas que responden a las preguntas más frecuentes de un editor o codificador:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;¿Qué es este elemento?&lt;/strong&gt; Consulta de cualquier elemento, clase, macro o módulo por su nombre, sin distinguir mayúsculas de minúsculas y con sugerencias en caso de errata.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;¿Qué atributos admite?&lt;/strong&gt; Resolución de los atributos a lo largo de toda la jerarquía de clases: primero los locales, después los heredados, por orden.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;¿Qué puede contener?&lt;/strong&gt; Expansión de los modelos de contenido en árboles estructurados, o lista plana de los hijos válidos.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;¿Puede ir aquí este elemento?&lt;/strong&gt; Comprobación del anidamiento padre-hijo, o rastreo de la alcanzabilidad a través de toda la jerarquía de elementos.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;¿Es válido mi documento?&lt;/strong&gt; Validación de un archivo XML TEI contra la especificación: modelos de contenido, valores de atributos, listas cerradas de valores, integridad de las referencias y avisos de obsolescencia.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;¿Y el esquema de mi proyecto?&lt;/strong&gt; Carga de un archivo de personalización ODD que restringe todo lo anterior al subconjunto de la TEI propio de su proyecto.&lt;/li&gt;
&lt;/ul&gt;
&lt;h2 id="por-qué-importa"&gt;Por qué importa&lt;/h2&gt;
&lt;p&gt;Codificar en TEI obliga a consultar las directrices sin descanso. Los codificadores experimentados interiorizan los patrones más comunes, pero hasta ellos tienen que mirar la especificación ante un elemento poco familiar o un modelo de contenido complejo. Para los asistentes de IA, que carecen de ese saber interiorizado, el problema es peor: alucinan un marcado de aspecto plausible pero incorrecto.&lt;/p&gt;
&lt;p&gt;Con tei-mcp la IA no tiene que adivinar: puede buscar la respuesta en la especificación antes de escribir un solo paréntesis angular. El resultado es un marcado conforme a TEI P5, o a la personalización ODD de su proyecto.&lt;/p&gt;
&lt;h2 id="primeros-pasos"&gt;Primeros pasos&lt;/h2&gt;
&lt;p&gt;Instálelo desde PyPI:&lt;/p&gt;
&lt;div class="highlight"&gt;&lt;pre tabindex="0" class="chroma"&gt;&lt;code class="language-bash" data-lang="bash"&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt;pip install tei-mcp
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;Añádalo después a la configuración de su cliente MCP:&lt;/p&gt;
&lt;div class="highlight"&gt;&lt;pre tabindex="0" class="chroma"&gt;&lt;code class="language-json" data-lang="json"&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt;&lt;span class="p"&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt; &lt;span class="nt"&gt;&amp;#34;mcpServers&amp;#34;&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt; &lt;span class="nt"&gt;&amp;#34;tei&amp;#34;&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt; &lt;span class="nt"&gt;&amp;#34;command&amp;#34;&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s2"&gt;&amp;#34;uvx&amp;#34;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt; &lt;span class="nt"&gt;&amp;#34;args&amp;#34;&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="s2"&gt;&amp;#34;tei-mcp&amp;#34;&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt; &lt;span class="p"&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt; &lt;span class="p"&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt;&lt;span class="p"&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;El servidor descarga la especificación TEI la primera vez que se ejecuta y funciona con cualquier cliente compatible con MCP.&lt;/p&gt;
&lt;p&gt;Código fuente y documentación completa:
&lt;/p&gt;</description></item><item><title>Enseñar el sistema binario con el emulador de telégrafo ITA2</title><link>https://clementgodbarge.com/es/post/baudot/</link><pubDate>Thu, 13 Feb 2025 00:00:00 +0000</pubDate><guid>https://clementgodbarge.com/es/post/baudot/</guid><description>&lt;h2 id="dar-cuerpo-a-lo-abstracto"&gt;Dar cuerpo a lo abstracto&lt;/h2&gt;
&lt;p&gt;Este emulador de ITA2 es, ante todo, un recurso para el aula. Al volver visibles y manipulables las nociones abstractas de la codificación, introduce a los estudiantes en una idea central de la informática y de las telecomunicaciones: la representación binaria, esto es, el modo en que un texto se convierte en una secuencia de unos y ceros.
Solemos explicar todo esto en abstracto; ver cómo van apareciendo los agujeros en la cinta ayuda, en cambio, a comprender que un sistema físico puede contener información digital.
&lt;div class="baudot-emulator"&gt;
&lt;h2&gt;ITA2 (Baudot-Murray) Telegraph Type Emulator&lt;/h2&gt;
&lt;p&gt;Type a word in the input below to see its representation on the ITA2 tape.&lt;/p&gt;
&lt;div class="baudot-controls"&gt;
&lt;label for="baudot-input"&gt;Type word:&lt;/label&gt;
&lt;input id="baudot-input" class="text-input" size="50" maxlength="50" /&gt;
&lt;button type="button" id="baudot-ltr-button" class="control-button active"&gt;LTR&lt;/button&gt;
&lt;button type="button" id="baudot-fig-button" class="control-button"&gt;FIG&lt;/button&gt;
&lt;/div&gt;
&lt;div class="tape-outer-container"&gt;
&lt;div class="tape-container"&gt;
&lt;table&gt;
&lt;tbody id="baudot-tape"&gt;&lt;/tbody&gt;
&lt;/table&gt;
&lt;/div&gt;
&lt;/div&gt;
&lt;style&gt;
.baudot-emulator {
--light-color: #f3f4f6;
--dark-color: #1f2937;
--light-alt-color: #e5e7eb;
--dark-alt-color: #374151;
font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Oxygen-Sans, Ubuntu, Cantarell, 'Helvetica Neue', sans-serif;
max-width: 100%;
margin: 2rem 0;
padding: 0;
box-sizing: border-box;
}
.baudot-emulator {
--tape-bg: var(--light-color);
--hole-bg: var(--light-color);
--hole-border: #d1d5db;
--punched-bg: var(--dark-color);
--punched-border: var(--dark-color);
--sprocket-bg: var(--light-color);
--sprocket-border: #9ca3af;
--button-bg: var(--light-color);
--button-bg-active: #d1d5db;
--button-text: var(--dark-color);
--button-border: #d1d5db;
--input-bg: white;
--input-border: #d1d5db;
--input-text: var(--dark-color);
--line-number: #6b7280;
}
html.dark .baudot-emulator,
html[data-theme='dark'] .baudot-emulator,
body.dark .baudot-emulator {
--tape-bg: var(--dark-alt-color);
--hole-bg: var(--dark-alt-color);
--hole-border: #4b5563;
--punched-bg: var(--light-color);
--punched-border: var(--light-color);
--sprocket-bg: var(--dark-alt-color);
--sprocket-border: #9ca3af;
--button-bg: var(--dark-alt-color);
--button-bg-active: #4b5563;
--button-text: var(--light-color);
--button-border: #4b5563;
--input-bg: var(--dark-alt-color);
--input-border: #4b5563;
--input-text: var(--light-color);
--line-number: #9ca3af;
}
.baudot-controls {
margin-bottom: 1.5rem;
display: flex;
flex-wrap: wrap;
align-items: center;
gap: 0.5rem;
}
.baudot-emulator .text-input {
flex: 1;
min-width: 200px;
padding: 0.5rem;
font-size: 1rem;
border: 1px solid var(--input-border);
border-radius: 4px;
background: var(--input-bg);
color: var(--input-text);
}
.baudot-emulator .control-button {
padding: 0.5rem 1rem;
background: var(--button-bg);
color: var(--button-text);
border: 1px solid var(--button-border);
border-radius: 4px;
cursor: pointer;
font-size: 0.9rem;
}
.baudot-emulator .control-button.active {
background: var(--button-bg-active);
font-weight: bold;
}
.tape-outer-container {
padding: 0;
margin-bottom: 1.5rem;
border-radius: 4px;
overflow: hidden;
}
.tape-container {
width: 100%;
overflow-x: auto;
background: var(--tape-bg);
padding: 1rem 0.5rem;
}
.baudot-emulator table {
border-collapse: collapse;
width: 100%;
table-layout: fixed;
border: none;
}
.baudot-emulator tr {
height: 24px;
border: none;
}
.baudot-emulator td {
border: none;
padding: 0;
}
.baudot-emulator .line-number {
width: 20px;
text-align: center;
color: var(--line-number);
font-size: 0.8rem;
padding: 0 8px 0 0;
font-weight: bold;
}
.baudot-emulator .cell {
position: relative;
width: 20px;
height: 20px;
}
.baudot-emulator .cell-content {
position: absolute;
top: 50%;
left: 50%;
transform: translate(-50%, -50%);
width: 12px;
height: 12px;
border-radius: 50%;
background: var(--hole-bg);
border: 1px solid var(--hole-border);
}
.baudot-emulator .punched .cell-content {
background: var(--punched-bg);
border: 1px solid var(--punched-border);
}
.baudot-emulator .sprocket-hole {
position: absolute;
left: 50%;
top: 100%;
transform: translate(-50%, -50%);
width: 4px;
height: 4px;
border-radius: 50%;
background: var(--sprocket-bg);
border: 1px solid var(--sprocket-border);
z-index: 2;
}
&lt;/style&gt;
&lt;script&gt;
document.addEventListener('DOMContentLoaded', function() {
initBaudotEmulator();
});
function initBaudotEmulator() {
if (!document.getElementById('baudot-input')) return;
const textInput = document.getElementById('baudot-input');
const tape = document.getElementById('baudot-tape');
const ltrButton = document.getElementById('baudot-ltr-button');
const figButton = document.getElementById('baudot-fig-button');
const ita2Code = {
'A': '00011', 'B': '11001', 'C': '01110', 'D': '01001', 'E': '00001',
'F': '01101', 'G': '11010', 'H': '10100', 'I': '00110', 'J': '01011',
'K': '01111', 'L': '10010', 'M': '11100', 'N': '01100', 'O': '11000',
'P': '10110', 'Q': '10111', 'R': '01010', 'S': '00101', 'T': '10000',
'U': '00111', 'V': '11110', 'W': '10011', 'X': '11101', 'Y': '10101',
'Z': '10001',
'1': '00011', '2': '11001', '3': '01110', '4': '01001', '5': '00001',
'6': '01101', '7': '11010', '8': '10100', '9': '01011', '0': '11000',
'-': '00011', '?': '00100', ':': '01010', '(': '11000', ')': '11101',
'.': '01000', ',': '00010', "'": '10001', '=': '01111', '/': '10011',
'+': '11011', ' ': '00100',
'FIG': '11011', 'LTR': '11111',
};
function generateTape() {
let rows = '';
for (let row = 0; row &lt; 5; row++) {
rows += '&lt;tr&gt;';
rows += `&lt;td class="line-number"&gt;${row + 1}&lt;/td&gt;`;
for (let col = 0; col &lt; 50; col++) {
rows += `&lt;td id="baudot_${row}_${col}" class="cell unpunched"&gt;
&lt;div class="cell-content"&gt;&lt;/div&gt;
${row === 2 ? '&lt;div class="sprocket-hole"&gt;&lt;/div&gt;' : ''}
&lt;/td&gt;`;
}
rows += '&lt;/tr&gt;';
}
tape.innerHTML = rows;
}
function updateITA2Code(word) {
clearTape();
word = word.toUpperCase();
let tapePosition = 0;
let currentCharType = 'LTR';
ltrButton.classList.add('active');
figButton.classList.remove('active');
for (let i = 0; i &lt; word.length; i++) {
const char = word[i];
let code = ita2Code[char] || ita2Code[' '];
let requiredCharType = /[A-Z ]/.test(char) ? 'LTR' : 'FIG';
if (requiredCharType !== currentCharType) {
const shiftCode = requiredCharType === 'LTR' ? ita2Code['LTR'] : ita2Code['FIG'];
punchTape(shiftCode, tapePosition++);
currentCharType = requiredCharType;
ltrButton.classList.toggle('active', currentCharType === 'LTR');
figButton.classList.toggle('active', currentCharType === 'FIG');
}
punchTape(code, tapePosition++);
}
}
function punchTape(code, tapePosition) {
if (tapePosition &gt;= 50) return;
for (let bit = 0; bit &lt; 5; bit++) {
const cell = document.getElementById(`baudot_${bit}_${tapePosition}`);
if (cell) {
cell.className = code[bit] === '1' ? 'cell punched' : 'cell unpunched';
}
}
}
function clearTape() {
for (let i = 0; i &lt; 50; i++) {
for (let bit = 0; bit &lt; 5; bit++) {
const cell = document.getElementById(`baudot_${bit}_${i}`);
if (cell) {
cell.className = 'cell unpunched';
}
}
}
}
generateTape();
textInput.addEventListener('input', function() {
updateITA2Code(this.value);
});
ltrButton.addEventListener('click', function() {
this.classList.add('active');
figButton.classList.remove('active');
if (textInput.value) {
updateITA2Code(textInput.value);
}
});
figButton.addEventListener('click', function() {
this.classList.add('active');
ltrButton.classList.remove('active');
if (textInput.value) {
updateITA2Code(textInput.value);
}
});
if (textInput.value) {
updateITA2Code(textInput.value);
}
}
&lt;/script&gt;
&lt;/div&gt;
&lt;/p&gt;
&lt;h2 id="contexto-histórico-del-telégrafo-al-ordenador"&gt;Contexto histórico: del telégrafo al ordenador&lt;/h2&gt;
&lt;p&gt;El código ITA2 (Alfabeto Telegráfico Internacional n.º 2), llamado también código Baudot-Murray, se desarrolló en los años veinte del siglo pasado como perfeccionamiento del código telegráfico que Émile Baudot había ideado en la década de 1870. Aquellos primeros sistemas de telecomunicación dejaron una huella directa en la informática posterior:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;Su esquema de cinco bits fue una de las primeras codificaciones de caracteres&lt;/li&gt;
&lt;li&gt;Las limitaciones del repertorio (con cinco bits solo caben 32 combinaciones) obligaron a idear el ingenioso mecanismo de cambio LETRAS/CIFRAS&lt;/li&gt;
&lt;li&gt;Los teletipos siguieron usando este sistema hasta bien entrado el siglo XX&lt;/li&gt;
&lt;/ul&gt;
&lt;h2 id="aprender-las-máquinas-de-estados-jugando"&gt;Aprender las máquinas de estados jugando&lt;/h2&gt;
&lt;p&gt;El mecanismo de cambio LETRAS/CIFRAS es la puerta natural a las máquinas de estados. A fuerza de probar, los estudiantes descubren que un mismo patrón puede representar caracteres distintos según el modo en que se encuentre la máquina; y esa experiencia directa de una codificación dependiente del estado los prepara para nociones informáticas más complejas.
Así, el patrón de bits &lt;code&gt;00011&lt;/code&gt; representa:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;la letra «A» en modo LETRAS&lt;/li&gt;
&lt;li&gt;la cifra «1» en modo CIFRAS
Esta doble lectura según el estado está en la raíz misma de cómo los ordenadores manejan los datos.&lt;/li&gt;
&lt;/ul&gt;
&lt;h2 id="actividades-para-el-aula"&gt;Actividades para el aula&lt;/h2&gt;
&lt;p&gt;Algunas maneras de sacar partido al emulador en clase:&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;&lt;strong&gt;Reto de descifrado&lt;/strong&gt;: dar a los estudiantes mensajes codificados en ITA2 para que los descifren&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Codificación eficiente&lt;/strong&gt;: discutir por qué el mecanismo de cambio importaba tanto para ahorrar ancho de banda&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Evolución de las codificaciones&lt;/strong&gt;: comparar los cinco bits del ITA2 con los siete de ASCII y con Unicode&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Computación física&lt;/strong&gt;: tender un puente entre este sistema histórico y microcontroladores actuales como Arduino&lt;/li&gt;
&lt;/ol&gt;
&lt;h2 id="ventajas-para-la-accesibilidad"&gt;Ventajas para la accesibilidad&lt;/h2&gt;
&lt;p&gt;Más allá de su interés histórico, el enfoque se adapta a distintos estilos de aprendizaje:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;Quien aprende con los ojos ve los patrones&lt;/li&gt;
&lt;li&gt;Quien aprende con las manos interviene directamente en el proceso de codificación&lt;/li&gt;
&lt;li&gt;Quien prefiere los conceptos puede explorar la vertiente matemática de la teoría de la información&lt;/li&gt;
&lt;/ul&gt;
&lt;h2 id="detalles-de-implementación"&gt;Detalles de implementación&lt;/h2&gt;
&lt;p&gt;El emulador está escrito en JavaScript y se integra sin dificultad en cualquier plataforma docente basada en la web. El código es modular y puede adaptarse a contextos de enseñanza muy distintos.
El código fuente está disponible, y el emulador puede probarse, en el
&lt;/p&gt;</description></item></channel></rss>