<?xml version="1.0" encoding="utf-8" standalone="yes"?><rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom"><channel><title>Umanistica Digitale |</title><link>https://clementgodbarge.com/it/category/umanistica-digitale/</link><atom:link href="https://clementgodbarge.com/it/category/umanistica-digitale/index.xml" rel="self" type="application/rss+xml"/><description>Umanistica Digitale</description><generator>HugoBlox Kit (https://hugoblox.com)</generator><language>it-it</language><lastBuildDate>Tue, 05 May 2026 00:00:00 +0000</lastBuildDate><image><url>https://clementgodbarge.com/media/icon_hu_64a6c3bec25b3d7b.png</url><title>Umanistica Digitale</title><link>https://clementgodbarge.com/it/category/umanistica-digitale/</link></image><item><title>tei-mcp v0.3: codificare in TEI senza riscrivere la fonte</title><link>https://clementgodbarge.com/it/post/tei-mcp-span-locked/</link><pubDate>Tue, 05 May 2026 00:00:00 +0000</pubDate><guid>https://clementgodbarge.com/it/post/tei-mcp-span-locked/</guid><description>&lt;p&gt;Quando ho
, lo scopo era impedire agli assistenti IA di allucinare marcatura TEI. L’ancoraggio allo schema ha risolto una parte del problema: con un accesso diretto, per mezzo di strumenti, alla specifica P5, il modello non deve più indovinare che cosa significhi un elemento o quali attributi accetti. L’output passa la validazione.&lt;/p&gt;
&lt;p&gt;Ma nella codifica TEI l’allucinazione ha due facce, e lo schema ne coglie una sola. Validare rispetto alla specifica vi dice che la &lt;em&gt;marcatura&lt;/em&gt; è ben formata; non dice nulla del &lt;em&gt;testo&lt;/em&gt; che quella marcatura racchiude. Ed è lì, nel testo, che si annidano le allucinazioni più dannose. La composizione span-locked, novità di punta della v0.3, è pensata apposta per impedirle.&lt;/p&gt;
&lt;details class="print:hidden xl:hidden" &gt;
&lt;summary&gt;Indice dei Contenuti&lt;/summary&gt;
&lt;div class="text-sm"&gt;
&lt;nav id="TableOfContents"&gt;
&lt;ul&gt;
&lt;li&gt;&lt;a href="#lallucinazione-che-lo-schema-non-vede"&gt;L’allucinazione che lo schema non vede&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="#la-composizione-span-locked"&gt;La composizione span-locked&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="#che-cosè-e-che-cosa-non-è"&gt;Che cos’è, e che cosa non è&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="#perché-conta-al-di-là-della-tei"&gt;Perché conta, al di là della TEI&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="#come-aggiornare"&gt;Come aggiornare&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;
&lt;/nav&gt;
&lt;/div&gt;
&lt;/details&gt;
&lt;h2 id="lallucinazione-che-lo-schema-non-vede"&gt;L’allucinazione che lo schema non vede&lt;/h2&gt;
&lt;p&gt;Chiedete a un modello di codificare una lettera francese del Cinquecento e otterrete spesso un documento TEI dall’aria impeccabile: header compilato, tag &lt;code&gt;&amp;lt;persName&amp;gt;&lt;/code&gt; al posto giusto, &lt;code&gt;&amp;lt;dateline&amp;gt;&lt;/code&gt; ben formata. Passatelo per &lt;code&gt;validate_document&lt;/code&gt;, e passa.&lt;/p&gt;
&lt;p&gt;Poi confrontate il corpo con la fonte.&lt;/p&gt;
&lt;p&gt;&lt;code&gt;mesme&lt;/code&gt; è diventato &lt;code&gt;même&lt;/code&gt;. Una virgola è migrata. &lt;code&gt;luy&lt;/code&gt; è stato modernizzato in &lt;code&gt;lui&lt;/code&gt; senza dir niente a nessuno. Una frase ostica nel manoscritto è stata «corretta» in qualcosa di più pulito. Nessuna di queste modifiche era stata richiesta; nessuna viene segnalata. Il documento è valido per lo schema e sbagliato in silenzio.&lt;/p&gt;
&lt;p&gt;In un flusso di lavoro archivistico – dove il testo codificato diventa il documento definitivo su cui contano lettori, indici di ricerca e citazioni – è questo il guasto che conta di più. Un tag malformato è una seccatura; una grafia modernizzata che nessuno nota per cinque anni è una corruzione.&lt;/p&gt;
&lt;h2 id="la-composizione-span-locked"&gt;La composizione span-locked&lt;/h2&gt;
&lt;p&gt;La nuova versione (v0.3) include un meccanismo di prevenzione delle allucinazioni mirato proprio a questo guasto. L’obiettivo di progetto è rendere le allucinazioni nel corpo del testo impossibili per costruzione, non semplicemente improbabili.&lt;/p&gt;
&lt;p&gt;L’idea è semplice: &lt;strong&gt;il modello non batte mai il corpo del testo&lt;/strong&gt;.&lt;/p&gt;
&lt;p&gt;Il flusso di lavoro, invece, è questo:&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;Il modello chiama &lt;code&gt;get_source(&amp;quot;letter_001&amp;quot;)&lt;/code&gt; e riceve il testo semplice di partenza come stringa immutabile.&lt;/li&gt;
&lt;li&gt;Per ogni tag che vuole applicare, chiama &lt;code&gt;tag_span(&amp;quot;letter_001&amp;quot;, start, end, element_path, attrs)&lt;/code&gt;, registrando un elemento TEI su un intervallo di caratteri della fonte.&lt;/li&gt;
&lt;li&gt;Quando ha finito, chiama &lt;code&gt;compose(&amp;quot;letter_001&amp;quot;)&lt;/code&gt;. Il server intercala i tag registrati nel testo semplice originale, produce la TEI finale e poi verifica &lt;em&gt;byte per byte&lt;/em&gt; che il contenuto testuale piatto del documento prodotto sia uguale alla fonte.&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;Se i byte coincidono, il documento viene restituito. Se non coincidono – se i tag del modello implicano in qualche modo un corpo che differisce dalla fonte anche di un solo carattere – &lt;code&gt;compose()&lt;/code&gt; solleva un’eccezione invece di consegnare un documento corrotto.&lt;/p&gt;
&lt;p&gt;Non esiste percorso, in questo flusso, che porti il modello a produrre un documento TEI con un corpo diverso dalla fonte. L’invariante è meccanico, non comportamentale: non dovete fidarvi del modello perché non allucini; dovete fidarvi di un &lt;code&gt;==&lt;/code&gt; fra due stringhe di byte.&lt;/p&gt;
&lt;h2 id="che-cosè-e-che-cosa-non-è"&gt;Che cos’è, e che cosa non è&lt;/h2&gt;
&lt;p&gt;La composizione span-locked è &lt;strong&gt;complementare&lt;/strong&gt; all’ancoraggio allo schema, non lo sostituisce. Gli strumenti di ancoraggio (&lt;code&gt;validate_document&lt;/code&gt;, &lt;code&gt;lookup_element&lt;/code&gt;, &lt;code&gt;valid_children&lt;/code&gt; e il resto dei sedici originali) aiutano il modello a produrre TEI &lt;em&gt;valida&lt;/em&gt;; la composizione span-locked garantisce che il corpo del testo dentro quella TEI sia &lt;em&gt;fedele&lt;/em&gt; alla fonte. Un flusso di codifica che si possa mettere in produzione deve soddisfare entrambi gli assi, e ora un solo server li copre tutti e due.&lt;/p&gt;
&lt;p&gt;Non è nemmeno la panacea. &lt;code&gt;compose()&lt;/code&gt; non verifica ancora che i tag registrati siano ammessi da una personalizzazione ODD caricata: arriverà. I tag registrati vivono nella memoria del processo e non sopravvivono a un riavvio. E i file di partenza devono essere leggibili da dove gira il server. Sono tutte cose risolvibili, e nessuna intacca l’invariante di fondo.&lt;/p&gt;
&lt;h2 id="perché-conta-al-di-là-della-tei"&gt;Perché conta, al di là della TEI&lt;/h2&gt;
&lt;p&gt;Lo schema si generalizza. Ogni volta che si chiede a un modello di annotare, trasformare o incapsulare un testo – e ogni volta che l’integrità di quel testo conta più della capacità del modello di «migliorarlo» – la soluzione ha la stessa forma. Non chiedete al modello di ribattere il testo; chiedetegli istruzioni sul testo, e lasciate che un compositore deterministico le applichi sotto un invariante di uguaglianza.&lt;/p&gt;
&lt;p&gt;Per le edizioni digitali, in particolare, questo cambia ciò che si può affidare a un modello senza rimorsi. La codifica diventa d’un tratto un compito delegabile, senza dover confrontare a mano ogni output con la fonte. La macchina fa la parte noiosa; il curatore rivede la marcatura, non l’ortografia.&lt;/p&gt;
&lt;h2 id="come-aggiornare"&gt;Come aggiornare&lt;/h2&gt;
&lt;p&gt;Se avete già 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;Oppure da zero:&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;Per usare la composizione span-locked, indicate al server una directory di file di testo semplice:&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;Il nome di ogni file, senza estensione, diventa l’ID del documento (&lt;code&gt;letter_001.txt&lt;/code&gt; → &lt;code&gt;letter_001&lt;/code&gt;).&lt;/p&gt;
&lt;p&gt;Codice sorgente, documentazione completa e note di progetto sull’invariante:
&lt;/p&gt;</description></item><item><title>Un’edizione digitale d’altro genere</title><link>https://clementgodbarge.com/it/post/cavriana-edition/</link><pubDate>Tue, 24 Mar 2026 00:00:00 +0000</pubDate><guid>https://clementgodbarge.com/it/post/cavriana-edition/</guid><description>&lt;p&gt;La maggior parte delle fonti primarie non vede mai la luce. Il modello a cui ci affidiamo per rimediare, l’edizione digitale finanziata a bando, è troppo caro, troppo accentrato e troppo fragile per reggere su larga scala. Ho appena pubblicato
in cui spiego perché l’edizione critica delle lettere di Cavriana la sto costruendo in un altro modo: fonti primarie digitalizzate che crescono per accumulo, con un’infrastruttura minima e una manutenzione automatica, aperte alla collaborazione e così poco costose da non aver bisogno di alcun finanziamento. È un argomento a favore di un’umanistica digitale che stia in piedi anche senza il sostegno delle istituzioni.&lt;/p&gt;</description></item><item><title>tei-mcp: la TEI P5 per gli agenti IA</title><link>https://clementgodbarge.com/it/post/tei-mcp/</link><pubDate>Sun, 15 Mar 2026 00:00:00 +0000</pubDate><guid>https://clementgodbarge.com/it/post/tei-mcp/</guid><description>&lt;p&gt;Chi ha provato a far scrivere XML TEI a un assistente IA per la programmazione sa già come va a finire: sbaglia. Gli elementi spuntano dove non dovrebbero, gli attributi vengono inventati, le regole di annidamento ignorate. Il modello ha un’idea vaga dell’aspetto della TEI, ma nessuna conoscenza affidabile della specifica.&lt;/p&gt;
&lt;p&gt;tei-mcp rimedia dando agli agenti IA un accesso diretto, per mezzo di strumenti, alle Guidelines della TEI P5.&lt;/p&gt;
&lt;details class="print:hidden xl:hidden" &gt;
&lt;summary&gt;Indice dei Contenuti&lt;/summary&gt;
&lt;div class="text-sm"&gt;
&lt;nav id="TableOfContents"&gt;
&lt;ul&gt;
&lt;li&gt;&lt;a href="#che-cosè-mcp"&gt;Che cos’è MCP?&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="#che-cosa-fa-tei-mcp"&gt;Che cosa fa tei-mcp&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="#perché-conta"&gt;Perché conta&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="#per-cominciare"&gt;Per cominciare&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;
&lt;/nav&gt;
&lt;/div&gt;
&lt;/details&gt;
&lt;h2 id="che-cosè-mcp"&gt;Che cos’è MCP?&lt;/h2&gt;
&lt;p&gt;Il
(MCP) è uno standard aperto che permette alle applicazioni di IA di collegarsi a fonti di dati e strumenti esterni. Pensate a una porta USB per l’IA: un solo protocollo con cui qualunque client compatibile – Claude, Cursor, Windsurf e altri – si innesta su servizi specializzati.&lt;/p&gt;
&lt;p&gt;Un server MCP espone degli &lt;em&gt;strumenti&lt;/em&gt; che l’IA può chiamare nel corso di una conversazione. Invece di affidarsi a ciò che ricorda dell’addestramento, il modello interroga una fonte viva e autorevole.&lt;/p&gt;
&lt;h2 id="che-cosa-fa-tei-mcp"&gt;Che cosa fa tei-mcp&lt;/h2&gt;
&lt;p&gt;tei-mcp analizza la specifica ODD della TEI P5 ed espone 16 strumenti, che rispondono alle domande più comuni di chi cura o codifica un’edizione:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;Che cos’è questo elemento?&lt;/strong&gt; Cerca qualunque elemento, classe, macro o modulo per nome, senza distinguere maiuscole e minuscole e con suggerimenti in caso di refuso.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Quali attributi accetta?&lt;/strong&gt; Risolve gli attributi lungo l’intera gerarchia di classi: prima quelli locali, poi quelli ereditati, in ordine.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Che cosa può contenere?&lt;/strong&gt; Espande i modelli di contenuto in alberi strutturati, oppure restituisce l’elenco piatto dei figli ammessi.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Questo elemento può stare qui?&lt;/strong&gt; Verifica l’annidamento genitore-figlio, o segue la raggiungibilità lungo l’intera gerarchia degli elementi.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Il mio documento è valido?&lt;/strong&gt; Valida un file XML TEI rispetto alla specifica: modelli di contenuto, valori degli attributi, liste chiuse di valori, integrità dei riferimenti e avvisi di deprecazione.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;E lo schema del mio progetto?&lt;/strong&gt; Carica un file di personalizzazione ODD per restringere tutto quanto sopra al sottoinsieme di TEI proprio del vostro progetto.&lt;/li&gt;
&lt;/ul&gt;
&lt;h2 id="perché-conta"&gt;Perché conta&lt;/h2&gt;
&lt;p&gt;Codificare in TEI vuol dire consultare le Guidelines di continuo. I codificatori esperti hanno interiorizzato gli schemi più comuni, ma anche loro devono controllare la specifica per gli elementi meno familiari o per i modelli di contenuto più intricati. Per gli assistenti IA, che di quella conoscenza interiorizzata non hanno nulla, il problema è peggiore: allucinano una marcatura plausibile all’occhio e sbagliata nella sostanza.&lt;/p&gt;
&lt;p&gt;Con tei-mcp l’IA non deve più tirare a indovinare: cerca la risposta nella specifica prima di scrivere una sola parentesi angolare. Il risultato è una marcatura conforme alla TEI P5, o alla personalizzazione ODD del vostro progetto.&lt;/p&gt;
&lt;h2 id="per-cominciare"&gt;Per cominciare&lt;/h2&gt;
&lt;p&gt;Si installa da 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;Poi lo si aggiunge alla configurazione del client 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;Al primo avvio il server scarica la specifica TEI; funziona con qualsiasi client compatibile con MCP.&lt;/p&gt;
&lt;p&gt;Codice sorgente e documentazione completa:
&lt;/p&gt;</description></item><item><title>Insegnare il binario con l’emulatore del telegrafo ITA2</title><link>https://clementgodbarge.com/it/post/baudot/</link><pubDate>Thu, 13 Feb 2025 00:00:00 +0000</pubDate><guid>https://clementgodbarge.com/it/post/baudot/</guid><description>&lt;h2 id="rendere-concreto-lastratto"&gt;Rendere concreto l’astratto&lt;/h2&gt;
&lt;p&gt;Questo emulatore ITA2 è, prima di tutto, un sussidio didattico. Rende visibile e manipolabile ciò che di solito resta sulla lavagna, e introduce così gli studenti a un’idea cardine dell’informatica e delle telecomunicazioni: la rappresentazione binaria, cioè il modo in cui un testo diventa una sequenza di uno e di zero.
Se ne parla quasi sempre in astratto; ma vedere i fori comparire uno dopo l’altro sul nastro fa capire, meglio di qualsiasi spiegazione, come un oggetto fisico possa portare informazione digitale.
&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="un-po-di-storia-dal-telegrafo-al-calcolatore"&gt;Un po’ di storia: dal telegrafo al calcolatore&lt;/h2&gt;
&lt;p&gt;Il codice ITA2 (International Telegraph Alphabet No. 2), detto anche codice Baudot-Murray, fu messo a punto negli anni Venti del Novecento come perfezionamento del codice telegrafico ideato da Émile Baudot negli anni Settanta dell’Ottocento. Da questi primi sistemi di telecomunicazione l’informatica ha ereditato parecchio:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;la codifica a 5 bit è uno dei primi esempi di codifica dei caratteri;&lt;/li&gt;
&lt;li&gt;l’angustia del repertorio (con 5 bit si hanno appena 32 combinazioni) suggerì l’ingegnoso meccanismo di commutazione LETTERS/FIGURES, fra lettere e cifre;&lt;/li&gt;
&lt;li&gt;il sistema rimase in servizio sulle telescriventi fino a Novecento inoltrato.&lt;/li&gt;
&lt;/ul&gt;
&lt;h2 id="le-macchine-a-stati-giocando"&gt;Le macchine a stati, giocando&lt;/h2&gt;
&lt;p&gt;La commutazione LETTERS/FIGURES è il modo più naturale di introdurre le macchine a stati. Provando e riprovando, gli studenti scoprono da soli che la stessa sequenza di fori significa caratteri diversi a seconda della modalità in cui si trova la macchina; e questa esperienza diretta di una codifica che dipende dallo stato li prepara a nozioni informatiche ben più complesse.
La sequenza &lt;code&gt;00011&lt;/code&gt;, per esempio, vale:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;la lettera «A» in modalità LETTERS;&lt;/li&gt;
&lt;li&gt;la cifra «1» in modalità FIGURES.
Questa doppia lettura, che dipende dallo stato, è alla radice stessa del modo in cui i calcolatori trattano i dati.&lt;/li&gt;
&lt;/ul&gt;
&lt;h2 id="attività-per-la-classe"&gt;Attività per la classe&lt;/h2&gt;
&lt;p&gt;Qualche idea per portare l’emulatore ITA2 in aula:&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;&lt;strong&gt;Decifrazione&lt;/strong&gt;: far decodificare agli studenti messaggi trasmessi in sequenze ITA2&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Codifica efficiente&lt;/strong&gt;: discutere perché la commutazione fosse tanto preziosa per risparmiare banda&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Evoluzione delle codifiche&lt;/strong&gt;: confrontare i 5 bit dell’ITA2 con i 7 di ASCII e con Unicode&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Physical computing&lt;/strong&gt;: collegare questo sistema d’altri tempi ai microcontrollori di oggi, Arduino in testa&lt;/li&gt;
&lt;/ol&gt;
&lt;h2 id="un-vantaggio-per-laccessibilità"&gt;Un vantaggio per l’accessibilità&lt;/h2&gt;
&lt;p&gt;Interesse storico a parte, l’approccio viene incontro a studenti che imparano in modi diversi:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;chi apprende con gli occhi vede le sequenze;&lt;/li&gt;
&lt;li&gt;chi apprende con le mani interviene direttamente sul processo di codifica;&lt;/li&gt;
&lt;li&gt;chi ha un’inclinazione teorica può spingersi fino agli aspetti matematici della teoria dell’informazione.&lt;/li&gt;
&lt;/ul&gt;
&lt;h2 id="note-tecniche"&gt;Note tecniche&lt;/h2&gt;
&lt;p&gt;L’emulatore è scritto in JavaScript e si integra senza fatica in qualunque piattaforma didattica basata sul web. Il codice è modulare e si lascia adattare a contesti d’insegnamento diversi.
Il codice sorgente, con l’emulatore da provare, è qui:
&lt;/p&gt;</description></item></channel></rss>