<?xml version="1.0" encoding="UTF-8"?>
<rss version="2.0" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom">
  <channel>
    <title>Cialtr.One</title>
    <link>https://cialtr.one/</link>
    <atom:link href="https://cialtr.one/rss.xml" rel="self" type="application/rss+xml" />
    <description>Un blog che non sa di esserlo.</description>
    <language>it-IT</language>
    <lastBuildDate>Sat, 21 Nov 2026 16:52:21 GMT</lastBuildDate>
    <generator>Astro</generator>
    <item>
      <title>Entity Framework: come far schifo con le computed properties</title>
      <link>https://cialtr.one/articoli/entity-framework-computed-properties-performance-query-ottimizzazione/</link>
      <guid isPermaLink="true">https://cialtr.one/articoli/entity-framework-computed-properties-performance-query-ottimizzazione/</guid>
      <pubDate>Tue, 12 Aug 2025 00:00:00 GMT</pubDate>
      <category>csharp</category>
      <category>entity-framework</category>
      <category>linq</category>
      <category>dotnet</category>
      <category>performance</category>
      <content:encoded><![CDATA[<p>Sono passati almeno cent’anni dall’ultimo articolo che ho pubblicato in questo ameno luogo. E’ cambiato tutto, il mondo è a rotoli.</p>
<p>Il rotolamento del mondo odierno è certamente dovuto alla noia della vita senza i miei articoli, la mia prosa affilata e i miei ragionamenti profondi. Solo qualità, ormai perduta.</p>
<p>Poniamo fine a questo scempio.</p>
<p>Pochi giorni fa, mentre svolgevo la mia attività preferita, lavorare, ho scoperto che usando la direttiva <code>Select</code> di Linq, all’interno di una query Entity Framework, e selezionando una <code>computed property</code> dell’entità, la query, inevitabilmente, fa schifo.</p>
<blockquote>
<p>In poche parole, il framework non riesce a determinare quali campi sono necessari per la <code>computed property</code> e quindi selezionerà tutti i campi dell’entità. Badabim Badabum!</p>
</blockquote>
<p>Per esempio, il codice seguente che, tra le altre cose, esegue una select sul campo <code>FullName</code> dell’entità <code>User</code>:</p>
<pre class="language-cs" data-language="cs"><code class="language-cs"><span class="token class-name"><span class="token keyword">var</span></span> missingSubmission <span class="token operator">=</span> <span class="token keyword">await</span> db<span class="token punctuation">.</span>ItpReportApprovals
    <span class="token punctuation">.</span><span class="token function">Where</span><span class="token punctuation">(</span>r <span class="token operator">=&gt;</span> r<span class="token punctuation">.</span>Month <span class="token operator">==</span> month<span class="token punctuation">)</span>
    <span class="token punctuation">.</span><span class="token function">Where</span><span class="token punctuation">(</span>r <span class="token operator">=&gt;</span> r<span class="token punctuation">.</span>StatusCode <span class="token operator">==</span> <span class="token punctuation">(</span><span class="token keyword">int</span><span class="token punctuation">)</span> ApprovalStatus<span class="token punctuation">.</span>Missing <span class="token operator">||</span> r<span class="token punctuation">.</span>StatusCode <span class="token operator">==</span> <span class="token punctuation">(</span><span class="token keyword">int</span><span class="token punctuation">)</span> ApprovalStatus<span class="token punctuation">.</span>Saved<span class="token punctuation">)</span>
    <span class="token punctuation">.</span><span class="token function">Include</span><span class="token punctuation">(</span>x <span class="token operator">=&gt;</span> x<span class="token punctuation">.</span>StrategicBusinessUnit<span class="token punctuation">)</span>
    <span class="token punctuation">.</span><span class="token function">Include</span><span class="token punctuation">(</span>x <span class="token operator">=&gt;</span> x<span class="token punctuation">.</span>Manager<span class="token punctuation">)</span>
    <span class="token punctuation">.</span><span class="token function">Select</span><span class="token punctuation">(</span>x <span class="token operator">=&gt;</span> <span class="token keyword">new</span> <span class="token punctuation">{</span>
        ManagerName <span class="token operator">=</span> x<span class="token punctuation">.</span>Manager<span class="token punctuation">.</span>FullName<span class="token punctuation">,</span>
        ManagerEmail <span class="token operator">=</span> x<span class="token punctuation">.</span>Manager<span class="token punctuation">.</span>Email<span class="token punctuation">,</span>
        SbuName <span class="token operator">=</span> x<span class="token punctuation">.</span>StrategicBusinessUnit<span class="token punctuation">.</span>Name
    <span class="token punctuation">}</span><span class="token punctuation">)</span>
    <span class="token punctuation">.</span><span class="token function">ToListAsync</span><span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">;</span></code></pre>
<p>produce la query SQL:</p>
<pre class="language-sql" data-language="sql"><code class="language-sql"><span class="token keyword">SELECT</span>
  u<span class="token punctuation">.</span>id<span class="token punctuation">,</span>
  u<span class="token punctuation">.</span>account_manager_id<span class="token punctuation">,</span>
  u<span class="token punctuation">.</span>address<span class="token punctuation">,</span>
  u<span class="token punctuation">.</span>birthplace<span class="token punctuation">,</span>
  u<span class="token punctuation">.</span>citizenship<span class="token punctuation">,</span>
  u<span class="token punctuation">.</span>date_of_birth<span class="token punctuation">,</span>
  u<span class="token punctuation">.</span>email<span class="token punctuation">,</span>
  u<span class="token punctuation">.</span>fiscal_code<span class="token punctuation">,</span>
  u<span class="token punctuation">.</span>gender<span class="token punctuation">,</span>
  u<span class="token punctuation">.</span>gis_code<span class="token punctuation">,</span>
  u<span class="token punctuation">.</span>has_legally_protected_status<span class="token punctuation">,</span>
  u<span class="token punctuation">.</span>holidays<span class="token punctuation">,</span>
  u<span class="token punctuation">.</span>home_address<span class="token punctuation">,</span>
  u<span class="token punctuation">.</span>name<span class="token punctuation">,</span>
  u<span class="token punctuation">.</span>password_hash<span class="token punctuation">,</span>
  u<span class="token punctuation">.</span>permission<span class="token punctuation">,</span>
  u<span class="token punctuation">.</span>personal_email<span class="token punctuation">,</span>
  u<span class="token punctuation">.</span>phone<span class="token punctuation">,</span>
  u<span class="token punctuation">.</span>role<span class="token punctuation">,</span>
  u<span class="token punctuation">.</span><span class="token keyword">status</span><span class="token punctuation">,</span>
  u<span class="token punctuation">.</span>surname<span class="token punctuation">,</span>
  s<span class="token punctuation">.</span>name
<span class="token keyword">FROM</span>
  prod<span class="token punctuation">.</span>itp_report_approvals <span class="token keyword">AS</span> i
  <span class="token keyword">INNER</span> <span class="token keyword">JOIN</span> prod<span class="token punctuation">.</span>users <span class="token keyword">AS</span> u <span class="token keyword">ON</span> i<span class="token punctuation">.</span>manager_id <span class="token operator">=</span> u<span class="token punctuation">.</span>id
  <span class="token keyword">INNER</span> <span class="token keyword">JOIN</span> prod<span class="token punctuation">.</span>strategic_business_units <span class="token keyword">AS</span> s <span class="token keyword">ON</span> i<span class="token punctuation">.</span>strategic_business_unit_id <span class="token operator">=</span> s<span class="token punctuation">.</span>id
<span class="token keyword">WHERE</span>
  i<span class="token punctuation">.</span><span class="token keyword">month</span> <span class="token operator">=</span> @ __month_0
  <span class="token operator">AND</span> i<span class="token punctuation">.</span><span class="token keyword">status</span> <span class="token operator">IN</span> <span class="token punctuation">(</span><span class="token number">4</span><span class="token punctuation">,</span> <span class="token number">3</span><span class="token punctuation">)</span><span class="token punctuation">;</span></code></pre>
<p>questo perchè il campo <code>FullName</code> dell’entità <code>User</code> è definito come:</p>
<pre class="language-cs" data-language="cs"><code class="language-cs"><span class="token keyword">public</span> <span class="token return-type class-name"><span class="token keyword">string</span></span> FullName  <span class="token operator">=&gt;</span> <span class="token interpolation-string"><span class="token string">$"</span><span class="token interpolation"><span class="token punctuation">{</span><span class="token expression language-csharp">Name</span><span class="token punctuation">}</span></span><span class="token string"> </span><span class="token interpolation"><span class="token punctuation">{</span><span class="token expression language-csharp">Surname</span><span class="token punctuation">}</span></span><span class="token string">"</span></span></code></pre>
<p>Entity Framework non riesce a convertire in maniera ottimizzata la query e quindi seleziona tutti i campi dell’entità. Andando contro quello che Microsoft stessa suggerisce per le query, ovvero ridurre allo stretto necessario i campi ritornati.</p>
<p>Provando a riscrivere il codice C# come segue:</p>
<pre class="language-cs" data-language="cs"><code class="language-cs"><span class="token class-name"><span class="token keyword">var</span></span> missingSubmission <span class="token operator">=</span> <span class="token keyword">await</span> db<span class="token punctuation">.</span>ItpReportApprovals
    <span class="token punctuation">.</span><span class="token function">Where</span><span class="token punctuation">(</span>r <span class="token operator">=&gt;</span> r<span class="token punctuation">.</span>Month <span class="token operator">==</span> month<span class="token punctuation">)</span>
    <span class="token punctuation">.</span><span class="token function">Where</span><span class="token punctuation">(</span>r <span class="token operator">=&gt;</span> r<span class="token punctuation">.</span>StatusCode <span class="token operator">==</span> <span class="token punctuation">(</span><span class="token keyword">int</span><span class="token punctuation">)</span> ApprovalStatus<span class="token punctuation">.</span>Missing <span class="token operator">||</span> r<span class="token punctuation">.</span>StatusCode <span class="token operator">==</span> <span class="token punctuation">(</span><span class="token keyword">int</span><span class="token punctuation">)</span> ApprovalStatus<span class="token punctuation">.</span>Saved<span class="token punctuation">)</span>
    <span class="token punctuation">.</span><span class="token function">Include</span><span class="token punctuation">(</span>x <span class="token operator">=&gt;</span> x<span class="token punctuation">.</span>StrategicBusinessUnit<span class="token punctuation">)</span>
    <span class="token punctuation">.</span><span class="token function">Include</span><span class="token punctuation">(</span>x <span class="token operator">=&gt;</span> x<span class="token punctuation">.</span>Manager<span class="token punctuation">)</span>
    <span class="token punctuation">.</span><span class="token function">Select</span><span class="token punctuation">(</span>x <span class="token operator">=&gt;</span> <span class="token keyword">new</span> <span class="token punctuation">{</span>
        ManagerName <span class="token operator">=</span> x<span class="token punctuation">.</span>Manager<span class="token punctuation">.</span>Name<span class="token punctuation">,</span>
        ManagerSurname <span class="token operator">=</span> x<span class="token punctuation">.</span>Manager<span class="token punctuation">.</span>Surname<span class="token punctuation">,</span>
        ManagerEmail <span class="token operator">=</span> x<span class="token punctuation">.</span>Manager<span class="token punctuation">.</span>Email<span class="token punctuation">,</span>
        SbuName <span class="token operator">=</span> x<span class="token punctuation">.</span>StrategicBusinessUnit<span class="token punctuation">.</span>Name
    <span class="token punctuation">}</span><span class="token punctuation">)</span>
    <span class="token punctuation">.</span><span class="token function">ToListAsync</span><span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">;</span></code></pre>
<p>e quindi facendo leva unicamente sui campi <code>Name</code> e <code>Surname</code> che sono mappati su colonne del database:</p>
<pre class="language-cs" data-language="cs"><code class="language-cs"><span class="token punctuation">[</span><span class="token attribute"><span class="token class-name">Column</span><span class="token attribute-arguments"><span class="token punctuation">(</span><span class="token string">"name"</span><span class="token punctuation">)</span></span></span><span class="token punctuation">]</span> <span class="token keyword">public</span> <span class="token return-type class-name"><span class="token keyword">string</span></span> Name <span class="token punctuation">{</span> <span class="token keyword">get</span><span class="token punctuation">;</span> <span class="token keyword">set</span><span class="token punctuation">;</span> <span class="token punctuation">}</span>
<span class="token punctuation">[</span><span class="token attribute"><span class="token class-name">Column</span><span class="token attribute-arguments"><span class="token punctuation">(</span><span class="token string">"surname"</span><span class="token punctuation">)</span></span></span><span class="token punctuation">]</span> <span class="token keyword">public</span> <span class="token return-type class-name"><span class="token keyword">string</span></span> Surname <span class="token punctuation">{</span> <span class="token keyword">get</span><span class="token punctuation">;</span> <span class="token keyword">set</span><span class="token punctuation">;</span> <span class="token punctuation">}</span></code></pre>
<p>La risultante query SQL sarà:</p>
<pre class="language-sql" data-language="sql"><code class="language-sql"><span class="token keyword">SELECT</span>
  u<span class="token punctuation">.</span>name    <span class="token keyword">AS</span> <span class="token string">"ManagerName"</span><span class="token punctuation">,</span>
  u<span class="token punctuation">.</span>surname <span class="token keyword">AS</span> <span class="token string">"ManagerSurname"</span><span class="token punctuation">,</span>
  u<span class="token punctuation">.</span>email   <span class="token keyword">AS</span> <span class="token string">"ManagerEmail"</span><span class="token punctuation">,</span>
  s<span class="token punctuation">.</span>name    <span class="token keyword">AS</span> <span class="token string">"SbuName"</span>
<span class="token keyword">FROM</span>
  prod<span class="token punctuation">.</span>itp_report_approvals <span class="token keyword">AS</span> i
  <span class="token keyword">INNER</span> <span class="token keyword">JOIN</span> prod<span class="token punctuation">.</span>users <span class="token keyword">AS</span> u <span class="token keyword">ON</span> i<span class="token punctuation">.</span>manager_id <span class="token operator">=</span> u<span class="token punctuation">.</span>id
  <span class="token keyword">INNER</span> <span class="token keyword">JOIN</span> prod<span class="token punctuation">.</span>strategic_business_units <span class="token keyword">AS</span> s <span class="token keyword">ON</span> i<span class="token punctuation">.</span>strategic_business_unit_id <span class="token operator">=</span> s<span class="token punctuation">.</span>id
<span class="token keyword">WHERE</span>
  i<span class="token punctuation">.</span><span class="token keyword">month</span> <span class="token operator">=</span> @ __month_0
  <span class="token operator">AND</span> i<span class="token punctuation">.</span><span class="token keyword">status</span> <span class="token operator">IN</span> <span class="token punctuation">(</span><span class="token number">4</span><span class="token punctuation">,</span> <span class="token number">3</span><span class="token punctuation">)</span></code></pre>
<p>Molto meglio! Come vedete il framework ha individuato correttamente i campi su cui eseguire la select.</p>
<p>A noi non rimane quindi che comporre <code>Name</code> e <code>Surname</code> in separata sede.</p>
<p>Risultato interessante che è stato permesso dal fatto che, da qualche tempo, ho messo mano e sistemato i log del progetto dal quale ho estratto il codice di cui sopra. Ora i log sono colorati (assolutamente fondamentale) e riportano, in ambiente di sviluppo locale, le query che Entity Framework esegue.</p>
<p>Uno spasso.</p>
<p>Saluti.</p>
]]></content:encoded>
    </item>
    <item>
      <title>Organizzare le chiamate API in Javascript</title>
      <link>https://cialtr.one/articoli/javascript-organizzare-api/</link>
      <guid isPermaLink="true">https://cialtr.one/articoli/javascript-organizzare-api/</guid>
      <pubDate>Thu, 10 Aug 2023 00:00:00 GMT</pubDate>
      <category>javascript</category>
      <category>api</category>
      <category>axios</category>
      <category>frontend</category>
      <category>pattern</category>
      <content:encoded><![CDATA[<blockquote>
<p>E’ da molto che non scrivo nulla, era prevedibile, sono un cialtrone. Ho due o tre articoli marcescenti nella repository Git, incompiuti, mai pubblicati, vediamo se questo riesco a finirlo.</p>
<p>Dai, dai, dai!</p>
</blockquote>
<p>Oggi vorrei scrivere di una cosa a me cara: come organizzare il codice in modo che non sembri una discarica, nello specifico, come organizzare il codice per le chiamate API di un progetto frontend basato genericamente su Javascript e Axios. Se usate librerie differenti per le chiamate HTTP o i metodi nativi Javascript l’approccio descritto andrà ugualmente bene, magari adattandolo un pochettino ecco.</p>
<p>Io sto un pò in fissa con l’organizzazione del codice, già le mie doti da sviluppatore sono esigue, se poi è tutto un gran casino chi ci capisce qualcosa? C’è bisogno di ordine!</p>
<p>Ho già detto che sono scarso no? Ecco, inizialmente nei progetti scrivevo cose simili:</p>
<pre class="language-javascript" data-language="javascript"><code class="language-javascript"><span class="token keyword">const</span> auth <span class="token operator">=</span> <span class="token template-string"><span class="token template-punctuation string">`</span><span class="token string">Bearer </span><span class="token interpolation"><span class="token interpolation-punctuation punctuation">${</span>token<span class="token interpolation-punctuation punctuation">}</span></span><span class="token template-punctuation string">`</span></span>
<span class="token keyword">const</span> data <span class="token operator">=</span> <span class="token keyword">await</span> Axios<span class="token punctuation">.</span><span class="token function">get</span><span class="token punctuation">(</span><span class="token string">'http://localhost:3000/api/v1/users'</span><span class="token punctuation">,</span> auth<span class="token punctuation">)</span>
  <span class="token punctuation">.</span><span class="token function">then</span><span class="token punctuation">(</span><span class="token parameter">res</span> <span class="token operator">=&gt;</span> res<span class="token punctuation">.</span>data<span class="token punctuation">)</span>
  <span class="token punctuation">.</span><span class="token function">catch</span><span class="token punctuation">(</span><span class="token parameter">err</span> <span class="token operator">=&gt;</span> console<span class="token punctuation">.</span><span class="token function">error</span><span class="token punctuation">(</span>err<span class="token punctuation">)</span><span class="token punctuation">)</span></code></pre>
<p>Tutte le pagine o componenti del progetto avevano la loro lista di chiamate scritte in questo modo, uno schifo immondo.</p>
<p>Ogni volta dovevo ripetere URL base, endpoint e stringa di autorizzazione, demenziale.</p>
<p>Configurazione di Axios, zero. Gestione errori, ogni volta diversa. Cambiare un endpoint era una pena.</p>
<h2 id="service-pattern-scelgo-te">Service Pattern, scelgo te</h2>
<p>Con un pò di ricerca sui motori di ricerca e studiando altri piccoli progetti open-source su GitHub sono venuto a conoscenza del <strong>Service Pattern</strong>.</p>
<p>Utilizzando parole a caso e confuse definiamo il <strong>Service Pattern</strong>:</p>
<blockquote>
<p>Il <strong>Service Pattern</strong> permette di creare tanti piccoli servizi da associare idealmente a ciascun controller nel nostro backend e scrivere al loro interno le funzioni che si occupano di fare le chiamate e recuperare i dati. Così facendo si centralizzano le chiamate in un singolo file, riducendo il costo degli interventi futuri.</p>
</blockquote>
<p>Anche il client Axios viene centralizzato, la sua inizializzazione avviene in un file Javascript separato dove comodamente possiamo configurare tutto quello che ci pare e sfruttare caratteristiche avanzate di Axios come gli <code>interceptors</code>.</p>
<p>Tutto questo ben di dio viene sistemato in una cartella <code>api</code> del progetto.</p>
<p>Per utilizzarlo poi si tratta di importare il servizio nel componente e chiamare il metodo che ci serve.</p>
<h3 id="dalle-parole-ai-fatti">Dalle parole ai fatti</h3>
<p>La struttura di cartelle che andremo a replicare sarà la seguente:</p>
<pre class="language-markdown" data-language="markdown"><code class="language-markdown">src/
├── api/
│   ├── client/
│   │   └── index.js
│   ├── services/
│   │   ├── user-service.js
│   │   ├── product-service.js
│   │   ├── .
│   │   └── .
│   └── index.js
├── .
├── .
└── .</code></pre>
<p>Creiamo il file <code>index.js</code> all’interno della cartella <code>api/client</code>.</p>
<pre class="language-javascript" data-language="javascript"><code class="language-javascript"><span class="token comment">// api/client/index.js</span>
<span class="token keyword">import</span> axios <span class="token keyword">from</span> <span class="token string">'axios'</span>

<span class="token keyword">const</span> axiosClient <span class="token operator">=</span> axios<span class="token punctuation">.</span><span class="token function">create</span><span class="token punctuation">(</span><span class="token punctuation">{</span>
  <span class="token literal-property property">baseURL</span><span class="token operator">:</span> <span class="token string">'http://localhost:3000/'</span><span class="token punctuation">,</span>
  <span class="token literal-property property">headers</span><span class="token operator">:</span> <span class="token punctuation">{</span>
    <span class="token string-property property">'Accept'</span><span class="token operator">:</span> <span class="token string">'application/json'</span><span class="token punctuation">,</span>
    <span class="token string-property property">'Content-Type'</span><span class="token operator">:</span> <span class="token string">'application/json'</span><span class="token punctuation">,</span>
  <span class="token punctuation">}</span><span class="token punctuation">,</span>
  <span class="token comment">// ... opzioni ulteriori ...</span>
<span class="token punctuation">}</span><span class="token punctuation">)</span>

<span class="token keyword">export</span> <span class="token keyword">default</span> axiosClient</code></pre>
<p>Il file è basilare e configura solamente l’URL base per tutte le chiamate e l’header. Le opzioni <code>Accept</code> e <code>Content-type</code> indicano rispettivamente che il client axios si aspetta di ricevere risposte JSON da parte del backend e che invierà dati in formato JSON al backend.</p>
<p>Se volessimo configurare altre cose elaborate e fighissime (esempio, il token di autenticazione) nel client Axios prima di utilizzarlo in giro nell’applicazione, questo è il posto perfetto, tutto bello ordinato in un singolo file e perfettamente gestibile / espandibile nel futuro. Il potere dell’essere ordinati!</p>
<p>Creiamo ora il file <code>user-service.js</code> all’interno della cartella <code>api/services</code>. Ci servirà per recuperare informazioni da un ipotetico <code>UsersController</code> nel backend dell’applicazione.</p>
<pre class="language-javascript" data-language="javascript"><code class="language-javascript"><span class="token comment">// api/services/user-service.js</span>
<span class="token keyword">import</span> axiosClient <span class="token keyword">from</span> <span class="token string">'../client'</span>

<span class="token keyword">const</span> <span class="token function-variable function">getUsers</span> <span class="token operator">=</span> <span class="token punctuation">(</span><span class="token punctuation">)</span> <span class="token operator">=&gt;</span> axiosClient<span class="token punctuation">.</span><span class="token function">get</span><span class="token punctuation">(</span><span class="token string">'api/v1/users'</span><span class="token punctuation">)</span>
<span class="token keyword">const</span> <span class="token function-variable function">getUserById</span> <span class="token operator">=</span> <span class="token parameter">id</span> <span class="token operator">=&gt;</span> axiosClient<span class="token punctuation">.</span><span class="token function">get</span><span class="token punctuation">(</span><span class="token template-string"><span class="token template-punctuation string">`</span><span class="token string">api/v1/users/</span><span class="token interpolation"><span class="token interpolation-punctuation punctuation">${</span>id<span class="token interpolation-punctuation punctuation">}</span></span><span class="token template-punctuation string">`</span></span><span class="token punctuation">)</span>
<span class="token keyword">const</span> <span class="token function-variable function">createUser</span> <span class="token operator">=</span> <span class="token parameter">data</span> <span class="token operator">=&gt;</span> axiosClient<span class="token punctuation">.</span><span class="token function">post</span><span class="token punctuation">(</span><span class="token string">'api/v1/users'</span><span class="token punctuation">,</span> data<span class="token punctuation">)</span>
<span class="token comment">// ... altre chiamate API relative all'entità users ...</span>

<span class="token keyword">export</span> <span class="token keyword">default</span> <span class="token punctuation">{</span>
  getUsers<span class="token punctuation">,</span>
  getUserById<span class="token punctuation">,</span>
  createUser<span class="token punctuation">,</span>
  <span class="token comment">// ...</span>
<span class="token punctuation">}</span></code></pre>
<p>Non rimane che esportare il servizio tramite il file <code>index.js</code> (detto anche <em>barrel file</em>) nella cartella <code>api</code> per consolidare i nostri servizi e renderli facilmente importabili nei componenti frontend.</p>
<pre class="language-javascript" data-language="javascript"><code class="language-javascript"><span class="token comment">// api/index.js</span>
<span class="token keyword">export</span> <span class="token punctuation">{</span> <span class="token keyword">default</span> <span class="token keyword">as</span> UserService <span class="token punctuation">}</span> <span class="token keyword">from</span> <span class="token string">'./services/user-services'</span>
<span class="token comment">// ... altri export ...</span></code></pre>
<p>Ora possiamo usare il servizio nei nostri componenti come segue:</p>
<pre class="language-javascript" data-language="javascript"><code class="language-javascript"><span class="token comment">// componente 1</span>
<span class="token keyword">import</span> <span class="token punctuation">{</span> UserService <span class="token punctuation">}</span> <span class="token keyword">from</span> <span class="token string">'/api'</span>

<span class="token keyword">async</span> <span class="token keyword">function</span> <span class="token function">fetchUsers</span><span class="token punctuation">(</span><span class="token punctuation">)</span> <span class="token punctuation">{</span>
  <span class="token keyword">const</span> <span class="token punctuation">{</span> data <span class="token punctuation">}</span> <span class="token operator">=</span> <span class="token keyword">await</span> UserService<span class="token punctuation">.</span><span class="token function">getUsers</span><span class="token punctuation">(</span><span class="token punctuation">)</span>
  console<span class="token punctuation">.</span><span class="token function">log</span><span class="token punctuation">(</span>data<span class="token punctuation">)</span>
<span class="token punctuation">}</span></code></pre>
<p>Questo processo può essere ripetuto per altre entità, ed esempio possiamo creare il <code>product-service.js</code> per l’entità prodotti.</p>
<blockquote>
<p>Ho volutamente evitato la gestione degli errori con i blocchi <code>try/catch</code> per non invischiarmi in ulteriori concetti da spiegare. Capitemi, già così non so quello che sto facendo e dicendo. Chiaramente ne eviterò la trattazione anche nelle seguenti parti di questo articolo.</p>
</blockquote>
<h3 id="cosa-ci-piace">Cosa ci piace</h3>
<ul>
<li>Riutilizzabile</li>
<li>Manutenzione semplice</li>
<li>Codice conciso e leggibile</li>
</ul>
<p>Quanti bei punti a favore!</p>
<h3 id="cosa-non-ci-piace">Cosa non ci piace</h3>
<p>Può essere tutto bello bellissimo? Può andare tutto liscio? No.</p>
<p>Utilizzando questo approccio è emersa una criticità che ha catturato la mia attenzione: se devo sistematicamente modificare la risposta dell’enpoint dovrò farlo direttamente nel componente non potendo direttamente agire nel servizio causa potenziali effetti indesiderati.</p>
<p>Facciamo un esempio, stupido.</p>
<p>In alcune sezioni dell’applicazione, una volta recuperatu tutti gli utenti dal backend, ho la necessità di ampliare la risposta con il nome completo dell’utente. In ogni componente in cui è richiesto dovrò modificare come segue:</p>
<pre class="language-javascript" data-language="javascript"><code class="language-javascript"><span class="token comment">// componente 2</span>
<span class="token keyword">import</span> <span class="token punctuation">{</span> UserService <span class="token punctuation">}</span> <span class="token keyword">from</span> <span class="token string">'/api'</span>

<span class="token keyword">async</span> <span class="token keyword">function</span> <span class="token function">fetchUsers</span><span class="token punctuation">(</span><span class="token punctuation">)</span> <span class="token punctuation">{</span>
  <span class="token keyword">const</span> data <span class="token operator">=</span> <span class="token keyword">await</span> UserService<span class="token punctuation">.</span><span class="token function">getUsers</span><span class="token punctuation">(</span><span class="token punctuation">)</span>
    <span class="token punctuation">.</span><span class="token function">then</span><span class="token punctuation">(</span><span class="token punctuation">(</span><span class="token parameter">res</span><span class="token punctuation">)</span> <span class="token operator">=&gt;</span> <span class="token punctuation">{</span>
      <span class="token keyword">return</span> res<span class="token punctuation">.</span>data<span class="token punctuation">.</span><span class="token function">map</span><span class="token punctuation">(</span><span class="token punctuation">(</span><span class="token parameter">user</span><span class="token punctuation">)</span> <span class="token operator">=&gt;</span> <span class="token punctuation">{</span>
        <span class="token keyword">return</span> <span class="token punctuation">{</span>
          <span class="token operator">...</span>user<span class="token punctuation">,</span>
          <span class="token literal-property property">fullName</span><span class="token operator">:</span> <span class="token template-string"><span class="token template-punctuation string">`</span><span class="token interpolation"><span class="token interpolation-punctuation punctuation">${</span>user<span class="token punctuation">.</span>name<span class="token interpolation-punctuation punctuation">}</span></span><span class="token string"> </span><span class="token interpolation"><span class="token interpolation-punctuation punctuation">${</span>user<span class="token punctuation">.</span>surname<span class="token interpolation-punctuation punctuation">}</span></span><span class="token template-punctuation string">`</span></span>
        <span class="token punctuation">}</span>
      <span class="token punctuation">}</span><span class="token punctuation">)</span>
    <span class="token punctuation">}</span><span class="token punctuation">)</span>
  console<span class="token punctuation">.</span><span class="token function">log</span><span class="token punctuation">(</span>data<span class="token punctuation">)</span>
<span class="token punctuation">}</span></code></pre>
<p>Ripetere questa modifica, soprattutto se è necessaria in molti punti, diventa un fastidio e rovina quanto di buono fatto fino a ora in ambito manutenzione futura.</p>
<p>In alternativa, potremmo inserire questa logica direttamente nel metodo <code>getUsers()</code> del servizio. Questo però modifica sostanzialmente l’oggetto ritornato dal metodo, che passa da una <code>Promise</code> a un <code>Array</code> di oggetti, di conseguenza vanno controllate e adattate, se possibile, tutte le sezioni di codice dove il metodo viene invocato. Una discreta rottura di palle, oltre ad andare contro ogni tipo di best practice della programmazione.</p>
<h2 id="introduciamo-il-decorator-pattern">Introduciamo il Decorator Pattern</h2>
<p>Il mondo è bello perchè ci sono tanti pattern!</p>
<p>Siccome ero stufo e mi sembrava ci fosse spazio di manovra per migliorare in maniera sostanziale, ho ripreso le ricerche sul web e con un pò di perseveranza e un lento incedere sono incappato nel <strong>Decorator Pattern</strong>.</p>
<p>Di nuovo, cerchiamo di spiegarlo con parole semplici ma confuse:</p>
<blockquote>
<p>Il <strong>Decorator Pattern</strong> ci permette di estendere le funzionalità di una classe o un metodo senza alterare il comportamento della classe o metodo base. Una sorta di wrapper.</p>
</blockquote>
<p>Utilizzando il <strong>Decorator Pattern</strong> possiamo, per esempio, estendere il metodo <code>getUsers()</code> così da manipolare la risposta a nostro piacimento senza intaccare il metodo originale.</p>
<h3 id="implementiamo-implementiamo">Implementiamo, implementiamo</h3>
<p>Andiamo con calma e facciamo un passo indietro, per implementare il Decorator Pattern la struttura delle cartelle andrà modificata come segue:</p>
<pre class="language-markdown" data-language="markdown"><code class="language-markdown">src/
├── api/
│   ├── client/
│   │   └── index.js
│   ├── modules/
│   │   ├── user-api.js
│   │   ├── product-api.js
│   │   ├── .
│   │   └── .
│   └── index.js
├── services/
│   ├── modules/
│   │   ├── user-service.js
│   │   ├── product-service.js
│   │   ├── .
│   │   └── .
│   └── index.js
├── .
├── .
└── .</code></pre>
<p>La parte <code>api/client</code> rimmarrà identica.</p>
<p>Vediamo la struttura del file <code>user-api.js</code> nella cartella <code>api/modules</code>:</p>
<pre class="language-javascript" data-language="javascript"><code class="language-javascript"><span class="token comment">// api/modules/user-api.js</span>
<span class="token keyword">import</span> axiosClient <span class="token keyword">from</span> <span class="token string">'../client'</span>

<span class="token keyword">const</span> <span class="token function-variable function">getUsers</span> <span class="token operator">=</span> <span class="token punctuation">(</span><span class="token punctuation">)</span> <span class="token operator">=&gt;</span> axiosClient<span class="token punctuation">.</span><span class="token function">get</span><span class="token punctuation">(</span><span class="token string">'api/v1/users'</span><span class="token punctuation">)</span>
<span class="token keyword">const</span> <span class="token function-variable function">getUserById</span> <span class="token operator">=</span> <span class="token parameter">id</span> <span class="token operator">=&gt;</span> axiosClient<span class="token punctuation">.</span><span class="token function">get</span><span class="token punctuation">(</span><span class="token template-string"><span class="token template-punctuation string">`</span><span class="token string">api/v1/users/</span><span class="token interpolation"><span class="token interpolation-punctuation punctuation">${</span>id<span class="token interpolation-punctuation punctuation">}</span></span><span class="token template-punctuation string">`</span></span><span class="token punctuation">)</span>
<span class="token keyword">const</span> <span class="token function-variable function">createUser</span> <span class="token operator">=</span> <span class="token parameter">data</span> <span class="token operator">=&gt;</span> axiosClient<span class="token punctuation">.</span><span class="token function">post</span><span class="token punctuation">(</span><span class="token string">'api/v1/users'</span><span class="token punctuation">,</span> data<span class="token punctuation">)</span>
<span class="token comment">// ... altre chiamate API relative all'entità users ...</span>

<span class="token keyword">export</span> <span class="token keyword">default</span> <span class="token punctuation">{</span>
  getUsers<span class="token punctuation">,</span>
  getUserById<span class="token punctuation">,</span>
  createUser<span class="token punctuation">,</span>
  <span class="token comment">// ...</span>
<span class="token punctuation">}</span></code></pre>
<p>Il contenuto è quello del precedente file <code>user-service</code> nella cartella <code>api/services</code>, un semplice rename del file.</p>
<p>Il file <code>index.js</code> ora esporterà i file dalla cartella <code>api/modules</code>:</p>
<pre class="language-javascript" data-language="javascript"><code class="language-javascript"><span class="token comment">// api/index.js</span>
<span class="token keyword">export</span> <span class="token punctuation">{</span> <span class="token keyword">default</span> <span class="token keyword">as</span> UserApi <span class="token punctuation">}</span> <span class="token keyword">from</span> <span class="token string">'./modules/user-api'</span>
<span class="token comment">// ... altri export ...</span></code></pre>
<p>Passiamo alla parte interessante, la cartella <code>services</code>, e creiamo il file <code>user-service.js</code> nella cartella <code>services/modules</code>:</p>
<pre class="language-javascript" data-language="javascript"><code class="language-javascript"><span class="token comment">// services/modules/user-service.js</span>
<span class="token keyword">import</span> UserApi <span class="token keyword">from</span> <span class="token string">'../api'</span>

<span class="token keyword">async</span> <span class="token keyword">function</span> <span class="token function">getUsers</span><span class="token punctuation">(</span><span class="token punctuation">)</span> <span class="token punctuation">{</span>
  <span class="token keyword">const</span> <span class="token punctuation">{</span> data <span class="token punctuation">}</span> <span class="token operator">=</span> <span class="token keyword">await</span> userAPI<span class="token punctuation">.</span><span class="token function">getUsers</span><span class="token punctuation">(</span><span class="token punctuation">)</span>
  <span class="token keyword">return</span> data
<span class="token punctuation">}</span>

<span class="token keyword">async</span> <span class="token keyword">function</span> <span class="token function">getUsersWithFullName</span><span class="token punctuation">(</span><span class="token punctuation">)</span> <span class="token punctuation">{</span>
  <span class="token keyword">const</span> <span class="token punctuation">{</span> data <span class="token punctuation">}</span> <span class="token operator">=</span> <span class="token keyword">await</span> userAPI<span class="token punctuation">.</span><span class="token function">getUsers</span><span class="token punctuation">(</span><span class="token punctuation">)</span>
  <span class="token keyword">return</span> data<span class="token punctuation">.</span><span class="token function">map</span><span class="token punctuation">(</span><span class="token parameter">user</span> <span class="token operator">=&gt;</span> <span class="token punctuation">(</span><span class="token punctuation">{</span> <span class="token operator">...</span>user<span class="token punctuation">,</span> <span class="token literal-property property">fullName</span><span class="token operator">:</span> <span class="token template-string"><span class="token template-punctuation string">`</span><span class="token interpolation"><span class="token interpolation-punctuation punctuation">${</span>user<span class="token punctuation">.</span>firstName<span class="token interpolation-punctuation punctuation">}</span></span><span class="token string"> </span><span class="token interpolation"><span class="token interpolation-punctuation punctuation">${</span>user<span class="token punctuation">.</span>lastName<span class="token interpolation-punctuation punctuation">}</span></span><span class="token template-punctuation string">`</span></span> <span class="token punctuation">}</span><span class="token punctuation">)</span><span class="token punctuation">)</span>
<span class="token punctuation">}</span>

<span class="token keyword">export</span> <span class="token keyword">default</span> <span class="token punctuation">{</span>
  getUsers<span class="token punctuation">,</span>
  getUsersWithFullName<span class="token punctuation">,</span>
  <span class="token comment">// ... altri metodi</span>
<span class="token punctuation">}</span></code></pre>
<p>Di fatto abbiamo preso il metodo <code>getUsers()</code> delle nostre API e l’abbiamo abbellito con dell’ulteriore codice che ci permette di manipolare i dati che ci arrivano dal backend senza rompere nulla.</p>
<p>Abbiamo disaccoppiato il recupero dei dati dal backend dall’esposizione dei dati stessi all’interno del nostro frontend.</p>
<p>Come fatto in precedenza, è il momento del file <code>index.js</code>.</p>
<pre class="language-javascript" data-language="javascript"><code class="language-javascript"><span class="token comment">// services/index.js</span>
<span class="token keyword">export</span> <span class="token punctuation">{</span> <span class="token keyword">default</span> <span class="token keyword">as</span> UserService <span class="token punctuation">}</span> <span class="token keyword">from</span> <span class="token string">'./modules/user-service'</span>
<span class="token comment">// ... altri export ...</span></code></pre>
<p>Passiamo ai componenti frontend:</p>
<pre class="language-javascript" data-language="javascript"><code class="language-javascript"><span class="token comment">// componente 1</span>
<span class="token keyword">import</span> <span class="token punctuation">{</span> UserService <span class="token punctuation">}</span> <span class="token keyword">from</span> <span class="token string">"/api"</span><span class="token punctuation">;</span>

<span class="token keyword">async</span> <span class="token keyword">function</span> <span class="token function">fetchUsers</span><span class="token punctuation">(</span><span class="token punctuation">)</span> <span class="token punctuation">{</span>
    <span class="token keyword">const</span> <span class="token punctuation">{</span> data <span class="token punctuation">}</span> <span class="token operator">=</span> <span class="token keyword">await</span> UserService<span class="token punctuation">.</span><span class="token function">getUsers</span><span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
    console<span class="token punctuation">.</span><span class="token function">log</span><span class="token punctuation">(</span>data<span class="token punctuation">)</span><span class="token punctuation">;</span>
<span class="token punctuation">}</span></code></pre>
<pre class="language-javascript" data-language="javascript"><code class="language-javascript"><span class="token comment">// componente 2</span>
<span class="token keyword">import</span> <span class="token punctuation">{</span> UserService <span class="token punctuation">}</span> <span class="token keyword">from</span> <span class="token string">"/api"</span><span class="token punctuation">;</span>

<span class="token keyword">async</span> <span class="token keyword">function</span> <span class="token function">fetchUsers</span><span class="token punctuation">(</span><span class="token punctuation">)</span> <span class="token punctuation">{</span>
    <span class="token keyword">const</span> <span class="token punctuation">{</span> data <span class="token punctuation">}</span> <span class="token operator">=</span> <span class="token keyword">await</span> UserService<span class="token punctuation">.</span><span class="token function">getUsersWithFullName</span><span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
    console<span class="token punctuation">.</span><span class="token function">log</span><span class="token punctuation">(</span>data<span class="token punctuation">)</span><span class="token punctuation">;</span>
<span class="token punctuation">}</span></code></pre>
<p>Ma quanto è bello e ordinato? La bellezza.</p>
<h3 id="cosa-ci-piace-1">Cosa ci piace</h3>
<ul>
<li>Modularità</li>
<li>Manutenzione semplice semplice</li>
<li>Codice ancora più conciso</li>
<li>Alta separazione dei ruoli tra una funzione e l’altra</li>
</ul>
<p>La separazione dei ruoli è uno dei principi che compongono l’acronimo <strong>SOLID</strong>, nello specifico la <strong>S</strong> (<em>Single Responsibility Principle</em>). Una buona pratica della programmazione. Non siete contenti?</p>
<h3 id="cosa-non-ci-piace-1">Cosa non ci piace</h3>
<p>Trovo questo secondo approccio piacevole da utilizzare e facilmente scalabile ad applicazioni anche relativamente complesse.</p>
<p>Una pecca però che, a mio avviso, non posso non menzionare è il quantitativo di codice, c’è tanto codice da scrivere. Questo può impattare in due modi:</p>
<ul>
<li>Curva di apprendimento del codice più ripida per profili meno esperti</li>
<li>Rottura di palle in fase di creazione di un’app da zero</li>
</ul>
<h2 id="conclusioni">Conclusioni</h2>
<p>Sfruttando concetti di Javascript (ES modules per import/export) e design pattern reperiti qua e la, l’organizzazione del mio codice è notevolmente migliorata negli anni.</p>
<p>La struttura che organizza sia le chiamate API che i servizi per esporre i dati ricevuti dalle chiamate in moduli, permette di scrivere un codice più snello, di più facile manutenzione, che si presta maggiormente a essere esteso in futuro senza crisi isteriche e, ultimo ma non ultimo, che non ti genera quella sensazione di profonda nausa quando lo devi debuggare dopo sei mesi.</p>
<p>Non è tutto oro quel che luccica, seguire questa via porta con se la necessità di scrivere più codice che, soprattutto nelle fasi iniziali, può sembrare inutile ma che sulla lunga distanza porta, da mio punto di vista, benefici che sovrastano di gran lunga il fastidio iniziale, soprattutto se le dimensioni dell’applicazione crescono.</p>
<p>Sta a noi decidere se, per il nostro progettino scalcagnato, vale la pena seguire questa rotta o andare più allo sbaraglio.</p>
<p>Fine.</p>
]]></content:encoded>
    </item>
    <item>
      <title>Homelab Backup Strategy</title>
      <link>https://cialtr.one/articoli/homelab-backup-strategy/</link>
      <guid isPermaLink="true">https://cialtr.one/articoli/homelab-backup-strategy/</guid>
      <pubDate>Sat, 05 Nov 2022 00:00:00 GMT</pubDate>
      <category>homelab</category>
      <category>backup</category>
      <category>cloud</category>
      <category>storage</category>
      <category>nas</category>
      <content:encoded><![CDATA[<blockquote>
<p><strong>TL;DR</strong></p>
<p>L’articolo comincia con uno sproloquio sui miei rapporti problematici con i backup, potete saltarlo e andare <a href="#so-what">qua</a>.</p>
</blockquote>
<blockquote>
<p><strong>TL;DR - bis</strong></p>
<p>Questo articolo non vuole essere una guida esaustiva di come impostare tecnicamente il backup, non troverete comandi o script. Solo una descrizione di come ho organizzato io la faccenda.</p>
</blockquote>
<p>Durante il mio peregrinare informatico una cosa è rimasta pressochè costante:</p>
<blockquote>
<p>La mia gestione dei backup è vergognosa.</p>
</blockquote>
<p>Alla veneranda età di molti anni e dopo aver perso un discreto numero di dati qua e la mi sarei anche rotto i coglioni di essere così asino nella gestione di una fase importante dell’informatica come il backup dei dati. Per questo ho deciso di provare a sistemare le cose e scrivere questo articolo.</p>
<p>Alla base di tutto questo disagio da archiviazione ci sono tre pilastri fondamentali:</p>
<ul>
<li>Sono un cretino</li>
<li>Gli hard disk mi odiano</li>
<li>Un mix dei due</li>
</ul>
<h2 id="sono-un-cretino">Sono un cretino</h2>
<p>Fulgido esempio sono i miei frequenti formattoni per ripulire il PC e installare da capo il sistema operativo: puntualmente perdevo pezzi per strada e tanti saluti a qualcosa di presumibilmente importante.</p>
<h3 id="soluzione">Soluzione</h3>
<p>Ho smesso di installare nuovamente il sistema operativo ogni mese.</p>
<h2 id="gli-hard-disk-mi-odiano">Gli hard disk mi odiano</h2>
<p>Il concetto non si limita solo agli hard disk ma a qualsiasi pezzo di elettronica in grado di memorizzare dei dati. Tendo ad avere un rapporto amore/odio con questi dispositivi. Ogni tanto mi lasciano a piedi senza tante spiegazioni.</p>
<p>Esempio pratico: tanti anni fa, torno da un viaggio con tante belle foto nella Compact Flash (si sono vecchio), attacco felice il card reader al PC e successivamente la Compact Flash al lettore. Per qualche motivo qualcosa non funziona e la Compact Flash, che due minuti prima funzionava correttamente nella macchina fotografica, è illeggibile. Scatta il panico e il piantino (ero giovane ed emotivamente fragile, ora sono solo emotivamente fragile), non avevo idea di come gestire la cosa. Per fortuna esiste mio padre che suggerì di usare un approccio più razionale e provare a recuperare i dati. Missione riuscita, le foto resuscitano e io sono contento.</p>
<p>PS: ad oggi non so dove siano finite quelle foto, forse perse nuovamente per il motivo numero uno, sono un cretino.</p>
<h3 id="soluzione-1">Soluzione</h3>
<p>Quando tocco un dispositivo di memorizzazione faccio tutti i movimenti molto lentamente nella speranza che non si spaventi. E con i guanti in nitrile.</p>
<h2 id="il-mix">Il mix</h2>
<p>Il mix è quando prendi un NAS, ci ficchi dentro un HDD ciccione per fare il backup di tutto quello che vuoi e ci copi dentro un tot di file dal tuo PC. Passa del tempo e l’HDD si spacca per un motivo ignoto. Ovviamente tu, tutto fiero del tuo nuovo dispositivo di backup, avevi cancellato dal PC i dati che avevi messo nel NAS.</p>
<p>Le bestemmie volano, i santi si incazzano, qualcosa è stato recuperato, ma non tutto.</p>
<h3 id="soluzione-2">Soluzione</h3>
<p>L’articolo che sto scrivendo. 🤬</p>
<h2 id="so-what">So What?</h2>
<p>Riassunte le agonie del passato, dedichiamoci al presente.</p>
<p>Come dicevo pocanzi, mi sono cotto il razzo di perdere dati e vivere con l’ansietta mal celata di perdere tutto se capita una sfiga all’hardware, faccio una cazzata, o qualsiasi altra evenienza. Ho cominciato quindi un percorso personale di formazione tipo monaco shaolin (oppure Goku con i vestiti ultra pesanti), ne sarà valsa la pena? boh, vedremo, sicuramente ho appreso molte cose interessanti.</p>
<p>Quello che ho capito è che per fare un backup dei propri dati serve:</p>
<ul>
<li>rovistare nell’internet per trovare cosa funziona e cosa no</li>
<li>realizzare un piano di backup</li>
<li>implementare automatismi, un backup senza automatismi non è un backup</li>
</ul>
<p>Il mio personale trigger per questa rivoluzione copernicana dei backup è stato <a href="https://youtu.be/S0KZ5iXTkzg">questo</a> video YouTube di <a href="https://www.jeffgeerling.com/">Jeff Geerling</a> (ah… YouTube), un pazzo scatenato che si diletta con RaspberryPi, selfhosting, homelabbing e tante cose nerdoline. Da Jeff ho appreso una verità fondamentale:</p>
<blockquote>
<p>Avere una sola copia di backup dei tuoi dati, non è un backup.</p>
</blockquote>
<p>Quindi? quante copie dei propri dati servono? una volta fatte le copie, dove le salvo? tenerle sullo stesso dispositivo potrebbe sembrare stupido. Una serie di interessanti domande che trovano una risposta con la strategia di <strong>backup 3-2-1</strong>, scopriamola in maniera cialtrona.</p>
<h2 id="backup-3-2-1">Backup 3-2-1</h2>
<p>Il nome <strong>3-2-1</strong> deriva dal fatto che i numeri identificano effettivamente qualcosa, nello specifico:</p>
<ul>
<li>Numero minimo di copie</li>
<li>Numero minimo di dispositivi di archiviazione</li>
<li>Numero di copie offsite</li>
</ul>
<h3 id="3---copie">3 - Copie</h3>
<p>Le copie del tuo file devono essere almeno tre:</p>
<ol>
<li>File originale</li>
<li>Copia 1</li>
<li>Copia 2</li>
</ol>
<h3 id="2---dispositivi-di-archiviazione">2 - Dispositivi di archiviazione</h3>
<p>Le tre copie del tuo file vanno dislocate in almeno due diversi dispositivi:</p>
<ul>
<li>HDD del tuo PC</li>
<li>NAS</li>
</ul>
<p>Oppure:</p>
<ul>
<li>NAS</li>
<li>Disco esterno</li>
</ul>
<p>And so on, avete capito.</p>
<h3 id="1---copia-offsite">1 - Copia offsite</h3>
<blockquote>
<p>Per <strong>offsite</strong> si intende genericamente una località che non coincide con quella originale/principale.</p>
</blockquote>
<p>Una copia di backup va quindi depositata su un dispositivo che non risiede nello stesso luogo fisico delle altre. Questo può essere un server nella cantina dei tuoi genitori, a casa di un amico oppure un server in un qualche datacenter sperso nel mondo.</p>
<h2 id="il-processo-di-backup">Il processo di backup</h2>
<p>Preso atto che la strategia che voglio seguire è questa benedetta 3-2-1, quali sono gli strumenti che mi permettono di implementarla? dove salvo la roba? chi sono? perchè lo faccio? Una domanda alla volta…</p>
<p>La situazione ferri vecchi divora elettricità in casa è la seguente:</p>
<ul>
<li>1 NAS</li>
<li>1 Nodo Proxmox</li>
<li>2 RaspberryPi</li>
</ul>
<p>Il NAS contiene un pò di roba, tutto quello che c’è li dentro è l’unica copia esistente, bella storia (fortunatamente i dischi sono in RAID1 quindi un minimo di protezione esiste). I Raspberry contengono qualche DB, configurazioni varie (DNS, applicazioni, ecc.). Infine, il serverino Proxmox inizia a contenere qualche virtual machine interessante e relativi dati. Niente di tutto quello che ho appena nominato è coperto da backup. Evviva. 🤡</p>
<p>Tutto quello che segue è implementato tramite una serie di <a href="https://www.geeksforgeeks.org/bash-scripting-introduction-to-bash-and-bash-scripting/">script bash</a> e automatizzato con <a href="https://www.geeksforgeeks.org/crontab-in-linux-with-examples/">crontab</a>. Ah Linux.❤️</p>
<h3 id="nas">NAS</h3>
<p>Per risolvere questa spiacevole situazione l’idea è quella di creare una macchina virtuale in Proxmox, montare al suo interno tutte le cartelle condivise rilevanti del NAS, eseguire un backup incrementale criptato  su disco locale di Proxmox tramite quella figata di strumento che è <a href="https://www.borgbackup.org/">Borg</a> e, infine, sparare tutto su un servizio di storage S3 con <a href="https://rclone.org/">Rclone</a> (altro programma atomico). In questo modo dovrei avere almeno tre copie, in due dispositivi diversi, di cui una lontano da qui.</p>
<h3 id="raspberry-e-vms">Raspberry e VMs</h3>
<p>Un Raspberry e le macchine virtuali su Proxmox invece contengono un pò di applicazioni e una istanza PostgreSQL, tutto più o meno su Docker (perchè sono nabbo).</p>
<p>Per il DB l’approccio è quello di fare un dump tramite riga di comando, salvare il dump compresso in una cartella di rete e, dalla macchina Borg, far partire il backup incrementale e successivo caricamento in S3. Per coordinare le attività dell’host DB e l’host Borg uso dei semplici file semaforo che indicano quando il dump è stato eseguito correttamente e può cominciare il backup con Borg. Un approccio assolutamente basico, del secolo scorso, ma al momento funziona.</p>
<p>Le applicazioni invece richiedono uno step ulteriore, vanno stoppati i container. Una volta fermati tutti i container si procede come per il DB. Anche in questo caso è tutto coordinato tramite file di semaforo, 1990 style.</p>
<h3 id="borg-e-rclone">Borg e Rclone</h3>
<p><a href="https://www.borgbackup.org/">Borg</a> e <a href="https://rclone.org/">Rclone</a> sono due programmi esagerati, free e open source. Il tipico software che ti fa affiorare la mai sopita sindrome dell’impostore e domandare se è giusto che tu sei pagato per produrre monnezza mentre ci sono tizi che confezionano perle gratuite a beneficio della comunità. Mah.</p>
<p>Borg produce backup criptati (<a href="https://dropbox.tech/security/zxcvbn-realistic-password-strength-estimation">scegliete bene la vostra password</a>), compressi e incrementali. Oltre a questo riesce a gestire in autonomia il ciclo di vita dei backup tramite il comando <code>prune</code>. Per esempio, gli si può chiedere di tenere 4 backup giornalieri, 1 settimanale, 1 mensile, 1 annuale. Oppure un pò il cazzo che vi pare a voi, gusti son gusti. In questo modo si può personalizzare il profilo di backup sulle nostre esigenze e si ottimizza lo spazio occupato.</p>
<p>Rclone invece è il compagno di merende perfetto per Borg e della <strong>strategia 3-2-1</strong>, lui “semplicemente” tiene sincronizzate due cartelle, una in locale e una remota in cloud. Finito il backup con Borg, se ne prende carico Rclone e lo carica dove serve a voi.</p>
<p>Entrambi i programmi hanno altre mille funzioni che non so usare. 👍</p>
<h3 id="storage-detour">Storage Detour</h3>
<p>Per il servizio storage la scelta è infinita, personalmente ho scelto lo storage <strong>Glacier</strong> di <a href="https://www.scaleway.com/en/">Scaleway</a> perchè stavo cercando uno storage di tipo S3 dal prezzo contenuto.</p>
<p>Mentre scrivo questo articolo, un backup di 360GB su Scaleway costa 0.69€/mese.</p>
<h2 id="migliorie">Migliorie</h2>
<p>Tutto può essere migliorato, soprattutto quello che faccio io. Quindi ho cominciato a pensare come rendere un pò meno pessimo tutto questo cinema. Magari un giorno aggiornerò questo articolo con le novità.</p>
<h3 id="e-mail">E-mail</h3>
<p>Sono arrivato alla conclusione che un buon passo in avanti potrebbe essere l’implementazione di un servizio di invio e-mail. Alla fine di ciascun processo di backup lo script invia una e-mail di rapporto per avere facilmente un riscontro che tutto abbia funzionato a dovere.</p>
<p>Integrare l’invio di e-mail in uno script bash dovrebbe risultare abbastanza semplice grazie a <a href="https://wiki.archlinux.org/title/SSMTP">sSMTP</a>, un piccolo programma che ha l’unico scopo di inviare e-mail tramite protocollo SMTP. Anche la configurazione del servizio Sendgrid con sSMTP sembra elementare.</p>
<p>Nutro, quindi, una flebile speranza di poter procedere con questa implementazione senza scontrarmi con troppi problemi. Mi accontento di un <em>giusto</em> ammontare di problemi, beata ingenuità.</p>
<h3 id="backup-db-incrementale">Backup DB incrementale</h3>
<p>Rendere efficiente il backup del DB non è una priorità, al momento il backup pesa 4MB una volta compresso.</p>
<p>Però, però… dire <em>backup incrementale</em> fa sempre figo.</p>
<p>Siccome il DB è un PostgreSQL due ottimi candidati sono <a href="https://pgbarman.org/">Barman</a> e <a href="https://pgbackrest.org/">pgBackRest</a>. Al contrario dell’invio delle e-mail automatiche di rapporto, la configurazione di questi due programmi non pare del tutto banale, vanno studiati più a fondo. L’idea stuzzica ma bisogna capire il rapporto costi/benefici.</p>
<p>Prenderà sicuramente del tempo.</p>
<h2 id="ho-finito-le-cose-da-dire">Ho finito le cose da dire</h2>
<p>Santo cielo quanto ho scritto, e chi se lo aspettava.</p>
<p>La fase di backup dei propri dati è importante, tenere al sicuro da occhi indiscreti questi dati è importante, automatizzare il processo è importante. Tutti punti che possono essere migliorati ed espansi nel tempo ma che è bene cominciare ad affrontare in maniera sistematica anche con un approccio rudimentale. E poi spippolare con script vari è sempre divertente.</p>
<p>Fate sti cazzo di backup. Love and peace. 🌈</p>
]]></content:encoded>
    </item>
    <item>
      <title>Ventoy - come rendere figo il boot da USB</title>
      <link>https://cialtr.one/articoli/ventoy-usb-boot/</link>
      <guid isPermaLink="true">https://cialtr.one/articoli/ventoy-usb-boot/</guid>
      <pubDate>Fri, 10 Jun 2022 00:00:00 GMT</pubDate>
      <category>usb</category>
      <category>boot</category>
      <category>ventoy</category>
      <content:encoded><![CDATA[<p>Dai si, forse lo scrivo questo articolo su <a href="https://www.ventoy.net/">Ventoy</a>. Ma prima…</p>
<blockquote>
<p><strong>Tech fun fact</strong></p>
<p>Ho appena aggiornato <a href="https://gohugo.io/">Hugo</a> alla versione 100.2, cosa che non mi porta assolutamente alcun beneficio o nuova feature a cui sono interessato, però, dico io, perchè non aggiornare una cosa quando puoi farlo e il progetto non è <strong>mission critical</strong>? Inoltre ho fatto un piccolo fix alla configurazione per la formattazione delle date e ora anche <strong>maggio</strong> viene abbreviato in <strong>mag</strong>!</p>
</blockquote>
<p>Dicevamo, <strong>Ventoy</strong>, tool gratuito open-source pazzesco per creare USB avviabili (<em>i.e.</em> quelle con cui installi il SO del PC). Ma non i soliti drive USB da quintali di GB con dentro solo una misera immaginetta ISO (<em>i.e.</em> la versione 22.04 LTS di Ubuntu pesa 3.4GB) e che devi formattare se vuoi fare un pò di distro hopping su Linux oppure se vuoi riconvertirla ad archivio dati.</p>
<h2 id="il-futuro-è-qui">Il futuro è qui</h2>
<p>Con Ventoy puoi avere quante ISO <em>avviabili</em> vuoi nella tua chiavetta USB semplicemente copiandole all’interno della chiavetta, l’unico limite è la capacità di archiviazione della stessa! Ci pensa poi Ventoy in fase di boot a mostrare un semplice menù di scelta e tu decidi quale ISO avviare. 😳</p>
<p>Dai, ecco il <a href="https://www.ventoy.net/">sito ufficiale</a>, per agevolare.</p>
<p>Di cosa stiamo parlando!!?!?! Magia pura.</p>
<p>Non finisce qui, di fianco alle ISO puoi piazzare quello che vuoi, cartelle, documenti, immagini, usare la chiavetta come fosse storage, non solo come un disco d’avvio! 💦</p>
<p>Boh, basta, fine. Tool definitivo. Lo puoi anche installare su SSD, quindi puoi farti un SSD portatile da 1TB con installato Ventoy e usarlo contemporaneamente sia come disco di avvio che come storage, decisamente più rapido di una chiavetta. <strong>WOAH!</strong> (cit.)🚗</p>
<p>Poi chiaramente ci sono anche <em>advanced featuressss</em> che io non ho sondato perchè sono pur sempre <em>cialtr.one</em>™.</p>
<p>Ah si, come ogni cosa ho scoperto questo tool tramite un video su YouTube… grazie <a href="https://www.youtube.com/c/OneMarcFifty">Marc il tedescone</a>.❤️</p>
<p>Alla fine l’ho scritto questo “pezzo” su Ventoy. Un saluto.</p>
]]></content:encoded>
    </item>
    <item>
      <title>Limoncello del Bressa</title>
      <link>https://cialtr.one/articoli/limoncello-scientifico/</link>
      <guid isPermaLink="true">https://cialtr.one/articoli/limoncello-scientifico/</guid>
      <pubDate>Mon, 02 May 2022 00:00:00 GMT</pubDate>
      <category>limoncello</category>
      <category>scientifico</category>
      <category>Bressanini</category>
      <content:encoded><![CDATA[<p>Ho appena finito di imbottigliare un litro di limoncello e come ogni volta sono dovuto andare in giro a recuperare le dosi/quantità/rapporti/ecc. perchè me li dimentico. Risolvo scrivendo queste quattro parole sgrammaticate <em>en-passant</em> così da avere uno schemino veloce per il futuro.</p>
<p>Ovviamente la ricetta è basata sul video YouTube (oh, l’ho mai detto che ho visto una volta un video su YouTube che…) del mitico <a href="https://it.wikipedia.org/wiki/Dario_Bressanini">Dario Bressanini</a> in cui spiega per filo e per segno come fare un limoncello su basi scientifiche senza dare retta a nonna Pina, zia Lella e il cugino Aldo (incidentalmente è lo stesso trio che ogni volta rovina i piani segreti del <strong>Nuovo Ordine Mondiale</strong>, i supereroi di cui non abbiamo bisogno ma che ci meritiamo).</p>
<p>Ah già il video, il video lo trovate a questo <a href="https://youtu.be/W5C0Qyt44dU">linkone YouTubbone</a>.</p>
<p>Bando agli esoterismi e buttiamo giù i building blocks di questo masterpiece (si, ho studiato):</p>
<h2 id="scorza-di-limone-vs-alcool">Scorza di limone vs. Alcool</h2>
<p>Tutto molto facile: 100g di alcool alimentare per ogni 40g di scorza di limone.</p>
<h2 id="resting-time">Resting time</h2>
<ul>
<li>Minimo: 24 ore.</li>
<li>Massimo: 72 ore.</li>
</ul>
<p>E la Sciura Lella muta.</p>
<p>Mia preferenza: 24 ore, perchè poi diventa più amarognolo.</p>
<h2 id="sugar-free-no">Sugar Free? NO</h2>
<p>Il peso dello zucchero corrisponde a metà del peso dell’alcool utilizzato.</p>
<h2 id="lacqua-che-fa-ruggine">L’acqua che fa ruggine</h2>
<p>La mia personale preferenza è la seguente:</p>
<p>Il peso dell’acqua è 1.2 volte il peso dell’alcool utilizzato.</p>
<p>Che poi è lo stesso rapporto che usa il Bressa nel video, sono pigro.</p>
<h2 id="resting-time---2">Resting time - 2</h2>
<p>Bevibile da subito ma da il meglio di se dopo una settimana di rest in frigo. Come il Barolo.</p>
<p><em>Bonne nuit and au revoir</em> a tutti miei readers!</p>
]]></content:encoded>
    </item>
    <item>
      <title>Moka Pot Americano</title>
      <link>https://cialtr.one/articoli/moka-pot-americano/</link>
      <guid isPermaLink="true">https://cialtr.one/articoli/moka-pot-americano/</guid>
      <pubDate>Mon, 31 Jan 2022 00:00:00 GMT</pubDate>
      <category>coffee</category>
      <category>moka pot</category>
      <category>americano</category>
      <content:encoded><![CDATA[<p>Sta cosa del caffè mi ha preso male, altro pippozzo sconclusionato in arrivo.</p>
<p>E siccome non mi fisso con le cose, protagonista la nostra <a href="https://cialtr.one/articoli/il-caffe-con-la-moka/">magica Moka</a>, di nuovo.</p>
<h2 id="diluire-il-caffè-della-moka">Diluire il caffè della Moka</h2>
<p>In uno dei miei recenti viaggi nell’entroterra di YouTube un tizio a caso asseriva che diluendo con acqua bollente il caffè che della Moka viene fuori una cosa carina al palato.</p>
<p><strong>Chi sono io per non provare?</strong></p>
<p>Ed effettivamente è vero, viene bene.</p>
<p>Il brodo che ne esce credo si chiami <strong>Moka Pot Americano</strong>.</p>
<h3 id="come-fare-il-moka-pot-americano">Come fare il Moka Pot Americano</h3>
<p>Sarò breve (cit.)</p>
<ol>
<li>Versate il caffè nella tazzina e abbiate l’accortezza di pesarlo.</li>
<li>Mettete circa il 70/80% di quel peso in acqua bollente.</li>
<li>Bevete.</li>
</ol>
<blockquote>
<h4 id="esempio-pratico-per-chi-come-me-è-fortissimo-con-le-percentuali">Esempio pratico per chi come me è fortissimo con le percentuali</h4>
<p>Avete 100g di caffè (bevanda) nella tazzina, mettete tra i 70g e 80g di acqua</p>
</blockquote>
<p>La bevanda che ne risulta dovrebbe essere un caffè meno intenso ma non per questo meno ricco di sapori e profumi, anzi.</p>
<p>L’ho fatto provare anche alla mia dolce metà e la risposta è stata decisamente positiva nonchè sobria.</p>
<blockquote>
<p>ESTICAZZI!</p>
</blockquote>
<p>PS: magari un giorno rivedrò anche l’italiano di questi <em>“articoli”</em></p>
]]></content:encoded>
    </item>
    <item>
      <title>Il caffè con la Moka</title>
      <link>https://cialtr.one/articoli/il-caffe-con-la-moka/</link>
      <guid isPermaLink="true">https://cialtr.one/articoli/il-caffe-con-la-moka/</guid>
      <pubDate>Tue, 25 Jan 2022 00:00:00 GMT</pubDate>
      <category>coffee</category>
      <category>moka</category>
      <category>moka pot</category>
      <content:encoded><![CDATA[<blockquote>
<p><strong>TL;DR</strong></p>
<ol>
<li>Lavare la Moka</li>
<li>Scaldare l’acqua prima di metterla nella caldaia</li>
<li>No alle montagnole di caffè nel filtro</li>
<li>Fuoco basso e spegnere appena comincia a gorgogliare</li>
<li>Mescolare prima di servire</li>
</ol>
</blockquote>
<p>Che poi io di caffè ne bevo veramente poco, giusto un assaggio qua e la per farmi la bocca. Però ultimamente sto in fissa con il caffè e tutti i rocamboleschi modi per estrarlo. Per esempio, recentemente ho preso un arnese chiamato <em>Clever Dripper</em>, tira fuori un caffè mica male. Questo <em>“articolo”</em> però parla di un grande classico, la Moka e il caffè.</p>
<p>L’idea di buttare giù queste righe disordinate parte da questo <a href="https://youtu.be/rpyBYuu-wJI">video</a> su YouTube che ha sbloccato la mia innata qualità di spaccare il cazzo a tutti con “ma sai che se fai così viene meglio? l’ho letto su internet”.</p>
<p>Inventata nel 1933 da <strong>Alfonso Bialetti</strong> che guardava la moglie fare la lavatrice (per dire, il genio). Talmente famosa e figa che è in esposizione permanente alla Triennale di Milano e al MoMa di New York. Non mi dilungo troppo, se volete ulteriori informazioni, come sempre, <a href="https://it.wikipedia.org/wiki/Moka">Wikipedia</a> o <a href="https://it.wikipedia.org/wiki/Internet">Internet</a> hanno la soluzione.</p>
<p>Tornando al rapporto tra Moka e caffè, nonostante tutta questa notorietà, non sempre la protagonista di questo <em>“articolo”</em> viene usata correttamente. È facile preda di qualche <strong>errore operativo tramandato da generazioni</strong> che si frappone tra voi e un caffè che non sappia di schifo bruciato. Proverò ad elencare di seguito come andrebbe usata correttamente la Moka per fare il caffè. Come va usata la Moka per altri usi, invece, non lo so.</p>
<blockquote>
<p><strong>Fun fact</strong></p>
<p>Se provate ad usare una Moka correttamente in pubblico sarete oggetto di notevoli attenzioni come se veniste da un pianeta differente e anche di qualche sbeffeggio:</p>
<ul>
<li>“ma come, scaldi l’acqua prima?”</li>
<li>“ma sei pazzo, la lavi?”</li>
<li>“tieni il coperchio aperto? mia nonna non lo fa”</li>
<li>“ma sei coglione?”</li>
</ul>
<p>Avrete quindi modo di praticare l’arte dell’inutile saccenza e rispondere con manifesta superiorità autoproclamata.</p>
</blockquote>
<h2 id="laviamola-sta-poveretta">Laviamola sta poveretta</h2>
<p>Prima di cominciare questo paragrafo mi preme enunciare un comandamento che è stato omesso quella volta dalle tavole originarie:</p>
<blockquote>
<p>Non lavare la Moka d’altri.</p>
</blockquote>
<p>Fatelo con la vostra, ma, siccome è una pratica poco diffusa in Italia, non fatelo con quella di altri, magari parte la lite e finiscono amicizie, sia mai.</p>
<p>Dicevamo, la Moka va lavata, con acqua e sapone, come un qualsiasi attrezzo da cucina, magari non usate la paglietta o la parte aggressiva della spugna, ma lavatela. Questo perchè il deposito di caffè che rimane non migliora i caffè successivi, saprà solo da rancido.</p>
<p>No, l’alluminio non vi ucciderà perchè lavate la Moka. Se aveta una Moka in acciaio il problema neppure si pone.</p>
<h2 id="lacqua-e-le-sue-magie">L’acqua e le sue magie</h2>
<p>L’acqua gioca un ruolo fondamentale nella preparazione del caffè con la Moka, temperatura e quantità sono due aspetti importanti.</p>
<p>Riguardo la temperatura le correnti di pensiero sono due:</p>
<ul>
<li>Acqua bollente nella caldaia</li>
<li>Acqua fredda nella caldaia</li>
</ul>
<p>Scaldare l’acqua prima di metterla nella caldaia aiuta a evitare che il caffè macinato si surriscaldi dentro al filtro nell’attesa che l’acqua fredda arrivi a temperatura. In questo modo preserviamo le qualità del caffè.</p>
<p>Si potrebbe obbiettare che “eh ma così il caffè viene a contatto con l’acqua troppo calda!” e lo si rovina ugualmente. Da quello che ho capito, anche facendo bollire l’acqua, tempo che la si versa nella caldaia, si avvita e blabla, la temperatura dell’acqua non risulterà troppo alta da compromettere l’estrazione del caffè. Invece, sarà prossima a temperature ottimali di estrazione.</p>
<p><strong>L’acqua va scaldata in un pentolino a parte, non direttamente nella caldaia.</strong></p>
<p>Personalmente preferisco l’approccio di inserire acqua calda nella caldaia, il caffè sembra risultare più <em>morbido</em>. Suggestioni di un palato inversamente fine.</p>
<p>Vogliamo parlare ora della quantità di acqua necessaria? Parliamone.</p>
<p>La questione è breve: l’acqua deve toccare la parte bassa della valvola di sfiato e non andare oltre. Tutto il resto è cialtroneria.</p>
<h2 id="caffè-si-caffè-no-caffè-chachacha">Caffè si, caffè no, caffè chachacha</h2>
<p>Dopo l’acqua venne il caffè. La scelta del caffè è un torbido guazzabuglio personale, tostato chiaro per chi “a me piace acido”, tostato scuro per chi preferisce un sentore più amaro, più arabica per un gusto più rotondo, qualche percentuale di robusta per avere quel <strong>kick di caffeina</strong> che vi porta fino a sera con livelli di iperattività da record. Fate un pò il cazzo che vi pare.</p>
<p>Quello che ci interessa è la macinatura. Il caffè per espresso è macinato estremamente sottile, non va bene per la Moka. Se usate il caffè per espresso si genererà una specie di tappo nel filtro che renderà difficile il passaggio dell’acqua aumentando la pressione nella caldaia e, di conseguenza, la temperatura dell’acqua. Questo rovinerà il vostro caffè.</p>
<p>Il caffè macinato per la Moka deve quindi trovarsi in una via di mezzo tra la macinatura per espresso e la macinatura per caffè filtro.</p>
<p>Ora che abbiamo il nostro caffè macinato di fronte dobbiamo capire come riempire il filtro. Il filtro va riempito il giusto, senza comprimere il caffè al suo interno e senza fare la montagnola. La montagnola non ha senso, riduce l’uniformità di estrazione, fa un pasticcio.</p>
<p>Inserite il caffè nel filtro, livellate delicatamente e fermatevi qui. <strong>Non comprimete il caffè e non escogitate altri modi per farne entrare di più</strong>, non serve.</p>
<p>NEXT!</p>
<h2 id="low--slow">Low &amp; Slow</h2>
<p>La Moka richiede un approccio con il calore che ricorda quello del Barbecue Americano, Low&amp;Slow. Quindi fornello basso e facciamolo uscire lento sto caffè, nessuna fretta. 🐌</p>
<p>Questo è l’unico step che probabilmente quasi tutti azzeccano, la fonte di calore per la Moka va tenuta bassa per poter estrarre correttamente il caffè e ritardare il più possibile il momento in cui inizia a gorgogliare. La bassa potenza mantiene la pressione sotto controllo a beneficio della temperatura dell’acqua che sale verso il caffè. <strong>Caldo si, ma non troppo</strong>.</p>
<p>Quello che invece nessuno fa è spegnere tutto appena ci sono i primi sentori di gorgoglio. Il gorgogliare è dovuto alla pressione che ormai ha raggiunto livelli pazzeschi e spara cannonate d’acqua su per il filtro invece di estrarre il caffè. Continuare in questo processo rovina quanto di buono fatto fino ad ora.</p>
<blockquote>
<p>STACCA! STACCA!</p>
</blockquote>
<h2 id="il-gran-finale">Il gran finale</h2>
<p>Tutto finito? abbiamo il nostro caffè e possiamo berlo in pace? No, manca poco ma no, non possiamo ancora berlo.</p>
<p>Appena abbiamo staccato la fonte di calore dobbiamo correre sotto il lavandino e raffreddare la caldaia della Moka, questo serve a interrompere in maniera definitiva l’estrazione del caffè. A onor del vero non ho ben capito l’utilità di quest’ultima parte visto che il caffè è già uscito e abbiamo tolto la fonte di calore, dovrò documentarmi.</p>
<p>Fatto anche questo non ci resta che mescolare il caffè prima di servirlo. I primi strati di caffè che escono dalla Moka sono decisamente più densi e intensi degli ultimi, diamo una breve mescolata e riportiamo tutto alla pari.</p>
<p>Ora si, possiamo berlo sto cazzo di caffè. ☕️</p>
]]></content:encoded>
    </item>
    <item>
      <title>Il mio primo articolo</title>
      <link>https://cialtr.one/articoli/primo-articolo/</link>
      <guid isPermaLink="true">https://cialtr.one/articoli/primo-articolo/</guid>
      <pubDate>Fri, 07 Jan 2022 00:00:00 GMT</pubDate>
      <content:encoded><![CDATA[<p>Cominciamo così, con due paragrafi <a href="https://loremipsum.io/">Lorem Ipsum</a> in un <em>quoteblock</em>. Solo qualità.</p>
<blockquote>
<p>Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Eu ultrices vitae auctor eu augue. Massa eget egestas purus viverra. Bibendum est ultricies integer quis auctor elit. Sit amet facilisis magna etiam tempor. Viverra suspendisse potenti nullam ac tortor. Pellentesque elit eget gravida cum sociis. Ac feugiat sed lectus vestibulum. Ipsum dolor sit amet consectetur adipiscing elit duis. Neque gravida in fermentum et sollicitudin ac orci phasellus egestas. Turpis massa tincidunt dui ut ornare lectus sit amet est. Cursus sit amet dictum sit amet justo donec enim diam. Sem nulla pharetra diam sit amet. Turpis massa sed elementum tempus egestas sed.</p>
<p>Mauris sit amet massa vitae tortor condimentum lacinia quis. In hendrerit gravida rutrum quisque non tellus orci ac. Fermentum iaculis eu non diam phasellus vestibulum lorem sed risus. Netus et malesuada fames ac turpis egestas maecenas pharetra convallis. In fermentum et sollicitudin ac orci. Ac auctor augue mauris augue neque gravida in fermentum. Leo a diam sollicitudin tempor id eu. Cras tincidunt lobortis feugiat vivamus at augue. Sed enim ut sem viverra aliquet eget sit. Laoreet sit amet cursus sit amet. Cursus sit amet dictum sit amet justo. Metus dictum at tempor commodo ullamcorper. Viverra maecenas accumsan lacus vel. Lectus sit amet est placerat in egestas erat. Augue lacus viverra vitae congue eu consequat ac felis. Id neque aliquam vestibulum morbi blandit cursus risus at. Senectus et netus et malesuada fames ac turpis. Vitae semper quis lectus nulla at volutpat diam ut. Odio tempor orci dapibus ultrices. In arcu cursus euismod quis viverra nibh.</p>
</blockquote>
]]></content:encoded>
    </item>
  </channel>
</rss>
