<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Claranet Italia - Medium]]></title>
        <description><![CDATA[Combining pioneering technologies, practices, and expertise to propel your business ambitions - Medium]]></description>
        <link>https://medium.com/claranet-italia?source=rss----6c4a1c0b89d9---4</link>
        <image>
            <url>https://cdn-images-1.medium.com/proxy/1*TGH72Nnw24QL3iV9IOm4VA.png</url>
            <title>Claranet Italia - Medium</title>
            <link>https://medium.com/claranet-italia?source=rss----6c4a1c0b89d9---4</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sat, 21 Nov 2026 12:50:43 GMT</lastBuildDate>
        <atom:link href="https://medium.com/feed/claranet-italia" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Accelerating AWS deployment when using Typescript]]></title>
            <link>https://medium.com/claranet-italia/accelerating-aws-deployment-when-using-typescript-43d4346cb715?source=rss----6c4a1c0b89d9---4</link>
            <guid isPermaLink="false">https://medium.com/p/43d4346cb715</guid>
            <category><![CDATA[aws-lambda]]></category>
            <category><![CDATA[aws]]></category>
            <category><![CDATA[typescript]]></category>
            <dc:creator><![CDATA[Marco Zamprogno]]></dc:creator>
            <pubDate>Tue, 18 Jan 2022 13:23:49 GMT</pubDate>
            <atom:updated>2022-03-03T08:28:02.664Z</atom:updated>
            <content:encoded><![CDATA[<p><strong>Update</strong>: AWS announced <a href="https://aws.amazon.com/blogs/compute/building-typescript-projects-with-aws-sam-cli/">SAM Accelerate for Typescript</a>, which replaces the makefile with a native esbuild, enabling faster build time and cloud synchronization.</p><p>Also check out <a href="https://medium.com/@arsenyyankovski/how-we-sped-up-our-typescript-serverless-builds-ten-times-70-lambdas-under-1-minute-f79a925dfe4c">How We Sped Up Our TypeScript Serverless Builds Ten Times (70 Lambdas Under 1 Minute)</a>!</p><p>At the end of October, AWS <a href="https://aws.amazon.com/blogs/compute/accelerating-serverless-development-with-aws-sam-accelerate/">announced </a>the beta release of <a href="https://s12d.com/accelerate">AWS SAM Accelerate</a>, with the aim of shortening the distance between cloud and developers. It consists in a set of tools to instantaneously sync local code to cloud and reading output logs directly on our terminals, reducing the needs to locally emulate the application stack.</p><p>You can check a full vide demonstration by AWS <a href="https://www.youtube.com/watch?v=syHwvb_P4JM">here</a>.</p><p>The good news? It works great on Python!</p><p>The bad news? It doesn’t work very well (yet) with Typescript. But there are workarounds.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*tA2qvX318JroG1WEkCIYQg.png" /><figcaption><a href="https://www.youtube.com/watch?v=1dzihtC5LJ0">Getting Started with AWS SAM</a></figcaption></figure><h3>Premises and problems</h3><p>Premise: we based our Typescript project on this great article by <a href="https://evilmartians.com/chronicles/serverless-typescript-a-complete-setup-for-aws-sam-lambda">Evil Martians</a>. Things were going pretty well, until the number of our lambdas increased and the build time skyrocketed. And by increased I mean that sam build took 7 minutes on our fastest PC and 25 on our slowest, plus ~2 minutes of sam deploy.</p><p>This is a completely different topic and it’s mainly caused by how sam build handles builds via makefile, which is by coping the <em>entire folder</em> first and executing the makefile second. And since it can’t ignore folders like node_modules, even if it’s not included in the final zip, it won’t be a short process. We can only hope for AWS to add a flag to ignore folders in the future.</p><p>The long build time rapidly became unbearable when writing E2E tests and integrations tests with the frontend. We began searching for a way to speed up our feedback time, but:</p><ul><li>sam build &lt;function name&gt; just zip the entire project folder, then update all lambdas with this giant zip, and finally breaks everything because now every lambdas has a non-working zip.</li><li>sam build --cached does not work with makefiles.</li><li>sam local start-api was a no-go, because it doesn&#39;t support authorizers and we rely on them to provide the lambda some extra user data.</li></ul><h3>The solution</h3><p>What to do then? Well, there’s an extra command from the base aws-cli which allow to directly push a zip to the cloud, without passing via CloudFormation: aws lambda update-function-code.</p><p>So I tried writing a simple script based on this, and this is the result:</p><pre>#!/bin/bash</pre><pre>readonly ENV=${1}<br>readonly FUNCTION_NAME=${2}<br>readonly FULL_LAMBDA_NAME=&quot;$ENV-backend-$FUNCTION_NAME&quot;</pre><pre>echo &quot;Syncing Lambda Function $FULL_LAMBDA_NAME...&quot;</pre><pre>zip -ur0q lambda_to_upload.zip dist/ -x &#39;*__tests__*&#39;<br>aws lambda update-function-code --function-name $FULL_LAMBDA_NAME --zip-file fileb://lambda_to_upload.zip &gt; /dev/null<br>rm lambda_to_upload.zip</pre><pre>echo &quot;Finished syncing Lambda Function $FULL_LAMBDA_NAME&quot;</pre><p>Our /dist directory contains the compiled Javascript code, including tests, which are excluded from the zip. Given that a npm run build was already been executed, you can push your latest code to the cloud in seconds!</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*DMiPOB-kpp7giMy4" /><figcaption>Photo by <a href="https://unsplash.com/@glenwheeler?utm_source=medium&amp;utm_medium=referral">Glen Wheeler</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>But there’s more! What if we don’t really want to be bothered by running a build and deploy every time? npmalready provide us with an automatic incremental build, which is npm run watch (or node_modules/typescript/bin/tsc -w --preserveWatchOutput), so what if we execute this deploy every time a build is successful?</p><p><a href="https://www.npmjs.com/package/tsc-watch">tsc-watch</a> does exactly what we need! We can add a new script to our scripts part in our package.json made like this</p><pre>&quot;sync&quot;: &quot;tsc-watch --onSuccess \&quot;../scripts/deploy_single_lambda.sh $ENV $FUNCTION\&quot;&quot;</pre><p>and running it via shell by setting the local variables like this</p><p>$ENV=test $FUNCTION=NameOfTheFunction npm run sync</p><p>and that’s it!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=43d4346cb715" width="1" height="1" alt=""><hr><p><a href="https://medium.com/claranet-italia/accelerating-aws-deployment-when-using-typescript-43d4346cb715">Accelerating AWS deployment when using Typescript</a> was originally published in <a href="https://medium.com/claranet-italia">Claranet Italia</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Divide et Impera!]]></title>
            <link>https://medium.com/claranet-italia/divide-et-impera-15ae5ffbd6fa?source=rss----6c4a1c0b89d9---4</link>
            <guid isPermaLink="false">https://medium.com/p/15ae5ffbd6fa</guid>
            <category><![CDATA[meetings]]></category>
            <category><![CDATA[coaching]]></category>
            <category><![CDATA[facilitation]]></category>
            <category><![CDATA[brainstorming]]></category>
            <dc:creator><![CDATA[Pietro Di Bello]]></dc:creator>
            <pubDate>Thu, 11 Feb 2021 16:40:48 GMT</pubDate>
            <atom:updated>2021-02-11T16:40:48.481Z</atom:updated>
            <content:encoded><![CDATA[<h4><em>Stanchi di lunghe e infruttuose call di “brainstorming”? Provate il potere delle breakout rooms!</em></h4><p>Quale voto date all’ultima retrospective alla quale avete partecipato? O all’ultima code review?</p><figure><img alt="Quale voto date all’ultima retrospective alla quale avete partecipato? O all’ultima code review?" src="https://cdn-images-1.medium.com/max/1024/0*GWNbiSZUsOFEs4Vj" /><figcaption>Photo by <a href="https://unsplash.com/@magnetme?utm_source=medium&amp;utm_medium=referral">Magnet.me</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>Come technical coach, mi ritrovo spesso a partecipare a sessioni di brainstorming o planning (code review, sessioni architetturali, retrospectives, backlog refinement, etc) con tante persone, dev e non.<br>Una delle conseguenze che la pandemia di COVID-19 ha portato nel nostro lavoro è che tutte queste sessioni sono per forza di cose remote; siamo insomma diventati — volenti o nolenti — degli animali da videocall, e passiamo con <em>nonchalance</em> da una call Zoom/Teams/Google Meet/… all’altra.</p><p>Uno degli effetti più negativi che ho notato passando da sessioni co-localizzate a sessioni remote è la difficoltà di partecipazione di tutte le persone: vuoi per postura spesso passiva che assumiamo, stando tutti seduti davanti ad un monitor, vuoi per la facilità con la quale possiamo eclissarci, vuoi per altre distrazioni che ci arrivano dal nostro pc o dall’ambiente esterno, spesso noto che nelle sessioni remote intervengono sempre i “soliti noti”, o quelli molto sicuri di sé, o quelli estroversi, o quelli che si sentono in dovere di intervenire perché sono i “technical leaders”, lasciando nell’ombra i molti altri.<br>Tra l’altro da remoto si fa molta fatica ad interpretare le microespressioni facciali e il linguaggio del corpo dei partecipanti attraverso la loro webcam, e questo riduce ulteriormente la nostra capacità di intervenire per aiutare tutti a partecipare.</p><p>Non voglio con questo articolo proporre niente di rivoluzionario né in grado di risolvere tutti i problemi dovuti al lavoro da remoto (ché poi ha anche molti vantaggi, ben inteso).<br>Vorrei solo proporre una semplice tecnica che ho visto funzionare, che già adottavo nelle sessioni co-localizzate ma che ho tardato ad introdurre anche in quelle remote: la <strong>suddivisione dei partecipanti in piccoli gruppi</strong>.</p><p>Per farvi capire, vi racconto come si è svolta l’ultima sessione a cui ho partecipato come facilitatore: si trattava di un incontro per discutere di alcune scelte architetturali che avrebbero avuto impatti su tutti i team dell’organizzazione.</p><p>Innanzitutto ho cercato di non limitare la discussione solo ai senior dei vari team, ma di coinvolgere quanti più membri di tutti i team, per essere sicuro di averli tutti “a bordo”, attivi propositori del loro destino piuttosto che meri esecutori o “implementatori di specifiche”. <br>Il numero dei partecipanti non ci spaventava, anche perché lavorando per gruppi è facile suddividere un grosso numero di persone in tanti piccoli gruppi.</p><p>Per la call abbiamo usato Zoom, che è dotato dell’essenziale funzionalità di <em>“breakout rooms”</em> (le stanze virtuali nelle quali far lavorare i vari gruppi). Per fortuna tale feature è ora disponibile anche in Microsoft Teams e in Google Meet.<br>Abbiamo poi predisposto una board online (nel mio caso ho usato <a href="https://metroretro.io/">MetroRetro</a>, ma ottime alternative sono <a href="http://miro.com/">Miro</a>, <a href="http://mural.co/">Mural</a> o <a href="https://jamboard.google.com/">Google Jamboard</a>), assicurandomi che tutti avessero accesso alla board.</p><p>Dopo aver speso i primi 15 minuti a spiegare i motivi e gli obiettivi della sessione, per assicurarmi che tutti avessero le idee chiare su come contribuire, abbiamo diviso i partecipanti in gruppi di 4 persone (3–4 persone è il numero giusto in questi casi, non di più).</p><p>Nella successiva mezz’ora, ogni gruppo ha potuto confrontarsi, discutere e raccogliere le proposte e idee provenienti da ognuno.<br>Nel frattempo la board si è popola di post-it, segno che i gruppi stavano lavorando bene.</p><figure><img alt="una board piena di post-it è un buon segno che la riunione sta andando bene" src="https://cdn-images-1.medium.com/max/1024/1*SpeJswboAvPAnP60bBIW3w.png" /><figcaption>La board si riempie di post-it: buon segno!</figcaption></figure><p>Il facilitatore può in questi casi saltare da una stanza all’altra, per assicurarsi che il gruppo non sia bloccato nella discussione e mantenga il focus sul tema¹.</p><p>Quando la board era oramai quasi totalmente invasa di post-it, abbiamo riportato tutti i gruppi nella stanza principale di Zoom.<br>I gruppi si sono poi confrontati tra loro per ragionare sulle opzioni emerse e sulle considerazioni raccolte, raggruppando tematiche simili avvicinando tra loro i relativi post-it.</p><p>Quello che ho notato subito è che, nuovamente riunite insieme, tutte le persone hanno partecipato attivamente alle successive discussioni. <br>Questo è un primo effetto del lavoro in gruppi: <strong>le persone si “sbloccano” nel proprio gruppo, iniziano a sentirsi coinvolti e poi non si fermano più, anche una volta rientrati nella stanza “plenaria”.</strong></p><p>La suddivisione in gruppi è efficace in tutte le riunioni (remote e non) dove la partecipazione e il contributo di tutti è essenziale per il successo dell’iniziativa (e faccio fatica a trovare riunioni dove questo non sia necessario…).</p><p>D’altra parte non invento nulla, il primo riferimento all’uso di questa tecnica l’ho avuto anni fa venendo in contatto con <a href="https://www.liberatingstructures.com/"><strong>Liberating Structures</strong></a>, un insieme di tecniche di facilitazione molto efficaci e divertenti! Molti dei formati proposti in Liberating Structures fanno affidamento sulla divisione in gruppi, ad esempio <a href="https://www.liberatingstructures.com/1-1-2-4-all">“1–2–4-All”</a>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*JiKRgE-d_Wv6UjV0" /><figcaption>Photo by <a href="https://unsplash.com/@cwmonty?utm_source=medium&amp;utm_medium=referral">Chris Montgomery</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>La stessa parte di sintesi finale può essere fatta in gruppi o tutti assieme: ad esempio il <em>“dot voting”</em> usato per prioritizzare le opzioni emerse si può fare dividendosi in gruppi (meglio se diversi da quelli adottati precedentemente), piuttosto che in modo individuale, così da “costringere” le persone a confrontarsi e a convergere sulle opzioni ritenute più valide.<br>Una tecnica che si può adottare qui è quella di dividere in gruppi da due persone, e dare loro 3 voti, così da costringerli a convergere con almeno un voto su una opzione condivisa.</p><p>Vorrei concludere con due ultime osservazioni.</p><p>Primo: la divisione in gruppi è uno strumento che potete usare in ogni momento della sessione, ma non potete fare affidamento solo a quello per il buon esito dell’incontro.<br>Due momenti decisivi sono l’avvio e la conclusione:</p><ul><li>nel momento introduttivo, tutti insieme, si condividono l’agenda dell’incontro, gli obiettivi e le regole della discussione</li><li>nella parte finale si trova la convergenza come intero gruppo, si mettono a fuoco i prossimi passi e si conclude.</li></ul><p>In particolare, dedicate il giusto tempo alla convergenza finale. Nessuno vi vieta di usare anche qui più giri di feedback usando dei gruppi ristretti e ruotando le persone che vi partecipano.<br>L’importante è poi convergere tutti assieme.</p><p>Infine, quando non è opportuno dividere in gruppi i partecipanti ad una discussione? Personalmente non ho ancora incontrato situazioni dove non dividere in gruppi sarebbe stato più efficace ai fini della partecipazione. <br>Forse, quando la discussione verte su temi valoriali (ad esempio se state facendo una sessione per far emergere i valori della vostra azienda) potrebbe essere meglio non ricorrere troppo ai gruppi, anche perché spesso in questi casi le persone non avranno problemi a dire la loro.</p><p>Provate quindi ad adottare questa tecnica nel vostro prossimo evento remoto di team, che sia una retrospective, un backlog refinement, una code review, o altro, e fateci sapere come è andata!</p><p><strong>Note</strong></p><p>[1] Riguardo a questo, il mio amico coach <a href="https://medium.com/u/c008ac2d9213">Moretto Nik</a> mi ha ricordato di fare attenzione a piombare nelle stanze dei gruppi, perché a volte si rischia di rompere l’equilibrio del gruppo o banalmente interrompere una loro discussione. <br>Piuttosto in questi casi basta rimanere nella stanza “plenaria” e spiegare ai gruppi che in caso di dubbi possono richiamare il facilitatore nella loro stanza oppure raggiungerlo nella stanza principale per chiedergli aiuto.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=15ae5ffbd6fa" width="1" height="1" alt=""><hr><p><a href="https://medium.com/claranet-italia/divide-et-impera-15ae5ffbd6fa">Divide et Impera!</a> was originally published in <a href="https://medium.com/claranet-italia">Claranet Italia</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Come realizzare migliori prodotti digitali: i nostri tre pilastri]]></title>
            <link>https://medium.com/claranet-italia/come-realizzare-migliori-prodotti-digitali-i-nostri-tre-pilastri-3b7ec4407ecf?source=rss----6c4a1c0b89d9---4</link>
            <guid isPermaLink="false">https://medium.com/p/3b7ec4407ecf</guid>
            <category><![CDATA[agile-development]]></category>
            <category><![CDATA[team-collaboration]]></category>
            <category><![CDATA[agile]]></category>
            <dc:creator><![CDATA[Claranet Italia]]></dc:creator>
            <pubDate>Mon, 16 Nov 2020 08:30:43 GMT</pubDate>
            <atom:updated>2020-11-16T08:30:43.075Z</atom:updated>
            <content:encoded><![CDATA[<p>Negli ultimi mesi assieme ad uno dei nostri clienti, abbiamo sviluppato e messo in produzione un nuovo prodotto digitale. L’esperienza è stata davvero stimolante per tutto il team; abbiamo imparato tanto assieme e vorremmo cogliere l’occasione per condividere con voi alcuni spunti di riflessione che sono emersi nel corso dell’esperienza.</p><p>In questo articolo vi racconteremo perché <strong><em>team e collaborazione</em></strong>, <strong><em>un processo a supporto del prodotto</em></strong> e <strong><em>feedback come driver</em></strong> siano stati, e sono tuttora, i tre pilastri sui quali basiamo la realizzazione di un prodotto che soddisfi tutte le persone coinvolte.</p><p>Nei paragrafi successivi approfondiremo ognuno di questi tre pilastri, convinti che possano dare anche a voi solide fondamenta per la creazione di migliori prodotti digitali.</p><p><strong><em>Team e collaborazione</em></strong></p><p>In Claranet ci impegniamo per creare prodotti di qualità che soddisfino l’utilizzatore finale, qualità che si ottiene solo tramite un rapporto di fiducia e trasparenza con il cliente e con un team che ha in sé tutte le competenze utili a realizzare la miglior soluzione possibile.</p><p>Proponendoci come partner e non come semplici fornitori di servizi, fin da subito abbiamo condiviso la necessità di creare un team composto da persone provenienti dalle due diverse realtà così da mettere assieme esperienze su dominio, tecnologie, sviluppo del prodotto e facilitazione.</p><p>Un team non si può creare su carta ma nasce condividendo esperienze, si basa sulle qualità umane delle persone e si fortifica tramite i momenti vissuti assieme. In tal senso, è stato per noi fondamentale avere diverse sessioni di confronto e di feedback per verificare la direzione intrapresa, validando non solo ipotesi relative al prodotto ma anche buone pratiche architetturali, di sicurezza e di rilascio.</p><p>Ci siamo tutti impegnati per costruire un ambiente <em>safe-to-fail</em>, dove gli errori fossero visti come occasioni di apprendimento e ciascuna persona si sentisse libera di proporre soluzioni e fare domande. Questo tipo di ambiente ci ha permesso di dare reale valore ad eventi come le retrospettive, dove sono emersi spunti di discussione e miglioramento, e pre-mortem, dove abbiamo immaginato e condiviso le possibili cause di un eventuale fallimento dopo la messa in produzione.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*9v9ucktLEjEJqQ77Psz42Q.jpeg" /></figure><p>Scelta vincente è stata la volontà di avere all’interno del team un agile coach che non solo ha facilitato le cerimonie di team, ma che ci ha dato supporto nel dare la giusta direzione a livello di processo e di interazioni tra le persone per creare una realtà che fosse il più possibile autonoma.</p><p><strong><em>Processo a supporto del prodotto</em></strong></p><p>Abbiamo fatto i nostri primi passi come team definendo assieme tramite sessioni di brainstorming il<em> prodotto</em>, quali fossero le <em>figure</em> che lo avrebbero utilizzato e con che <em>obiettivo</em>.</p><p>In questo modo siamo riusciti a:</p><ul><li>Definire gli impatti<em> </em>positivi (<em>outcome</em>) che il sistema avrebbe avuto sugli utilizzatori e come avrebbe migliorato la qualità delle loro attività quotidiane</li><li>Identificare <em>macro-funzionalità</em> da dettagliare successivamente in user story per ottenere tali impatti</li></ul><p>Così facendo non abbiamo mai lavorato con una sterile lista di funzionalità calate dall’alto e da consegnare entro una data deadline, ma ci siamo focalizzati su una <em>delivery incrementale</em> che permettesse di avere un veloce riscontro in produzione sulle assunzioni fatte durante le sessioni di brainstorming.</p><p>Nel decidere sprint dopo sprint quali fossero le priorità ci siamo fatti guidare dal concetto di <em>walking skeleton: </em>abbiamo deciso di sviluppare volta per volta piccoli set di user story per stimolare il sistema in modo end to end. Così siamo riusciti fin da subito a toccare molteplici aree funzionali coinvolgendo diversi utilizzatori e abbiamo massimizzato, tramite degli esperimenti mirati, l’apprendimento nelle aree tecniche che ci erano più oscure.</p><p>Questo scheletro applicativo è stato poi esteso prendendo in considerazione quanto appreso durante lo sviluppo, rivedendo di continuo la roadmap ed integrandola con quanto emerso durante le demo.</p><p>Non solo gli aspetti di business sono stati affrontati in modo iterativo ma anche quelli architetturali e di sicurezza sono stati oggetto di un continuo raffinamento, garantendo una tensione positiva tra la delivery di valore e l’evoluzione della struttura tecnica.</p><p><strong><em>Feedback come driver</em></strong></p><p>Feedback è un concetto che ricorre spesso quando si realizza un nuovo prodotto utilizzando i metodi agili. Per noi però il feedback deve essere visto come una struttura frattale che a diversi livelli di complessità associa riscontri differenti e diversi contenuti informativi.</p><p>A livello del team di sviluppo, feedback importanti sono stati ottenuti dall’applicazione di pratiche come TDD e mob programming. Queste pratiche ci hanno permesso di rivedere con occhio critico quanto creato e hanno massimizzato la diffusione dell’apprendimento tecnico e di dominio.</p><p>Spostandoci al livello della classica iterazione SCRUM, grazie alla partecipazione del cliente abbiamo rafforzato l’idea che planning e refinement sono importantissimi perché ci hanno permesso di decidere assieme gli esperimenti per validare la vision. Per fare in modo che durante la demo ci fosse un riscontro veloce e oggettivo del valore consegnato è stato fondamentale avere persone di prodotto in grado di definire esperimenti piccoli ma di impatto per gli stakeholders e gli utilizzatori finali del sistema.</p><p>A livello di prodotto, raggiunto un insieme significativo di funzionalità, abbiamo cercato feedback in ambiente di produzione da parte dei veri utilizzatori del sistema. Per ottenere questo risultato abbiamo lavorato fin dai primi sprint per avere:</p><ul><li><strong>Continuous deployment</strong> su ambienti che fossero simili a quello di produzione per validare l’architettura e la scalabilità del sistema (questo ci ha permesso in corso d’opera di rivedere alcune scelte tecniche)</li><li><strong>Canary release</strong> che esponessero velocemente un subset di utenti al nuovo prodotto per evitare rilasci <em>big bang</em></li><li><strong>Interviste agli utenti campione</strong> per validare le nostre ipotesi iniziali sugli impatti e raccogliere informazioni sull’esperienza di utilizzo</li><li><strong>Monitoraggio delle metriche</strong> estratte dal sistema per avere evidenza di eventuali problematiche e indicazioni empiriche su possibili miglioramenti</li></ul><p>Ultima tipologia di feedback per noi è stata a livello di processo: aumentate la nostra conoscenza e confidenza in quello che rilasciavamo e la velocità con cui eravamo in grado di farlo, siamo giunti alla conclusione che SCRUM era diventato troppo rigido rispetto alla nostra esigenza di consegnare continuamente valore. Abbiamo quindi intrapreso la direzione di un flusso di lavoro più fluido che garantisse rilasci frequenti di singole user story senza dover attendere la fine canonica dello sprint, impattando positivamente tutti gli altri livelli di feedback.</p><p><strong><em>Per concludere…</em></strong></p><p>Questa esperienza ci ha confermato che, indipendentemente dal tipo di metodologia utilizzata, è fondamentale il coinvolgimento delle persone che conoscono bene il business: le pratiche tecniche e l’adozione di un processo ben definito non sono infatti condizioni sufficienti per ottenere un prodotto che soddisfi a pieno le aspettative dei vari stakeholder.</p><p>Tali persone ci aiutano a mantenere la direzione ben puntata verso la vision e hanno la capacità di vedere il minimo incremento necessario alla delivery di valore rimuovendo la complessità accidentale e gli sprechi collegati all’implementazione di edge cases che si verificano raramente.</p><p>Queste osservazioni non vogliono sminuire l’importanza della componente tecnica che per noi rimane il cuore di ogni prodotto digitale. Fondamentale è stato lavorare con attenzione sul codice tenendo sempre basso il debito tecnico, adottare pratiche che garantissero sufficiente elasticità di codice ed architettura per integrare velocemente il feedback, e assicurare che il team avesse a disposizione del tempo da utilizzare per il miglioramento continuo.</p><p>Abbiamo fatta nostra l’idea che emerge dalla prima frase del <a href="https://agilemanifesto.org/">Manifesto Agile</a>: <strong><em>“gli individui e le interazioni più che i processi e gli strumenti”</em></strong>. In questo strano periodo di lontananza forzata causata dal Covid, abbiamo osservato che la collaborazione tra le persone può essere altrettanto efficace anche quando non si è fisicamente co-locati, se ci si adatta e si cercano nuove forme di comunicazione e condivisione che facilitino il più possibile l’interazione, benché remota, delle persone coinvolte.</p><p>Se vi andasse di approfondire alcuni dei concetti presentati in questo post vi lasciamo delle letture che si sono rivelate molto utili:</p><ul><li><a href="https://www.oreilly.com/library/view/edge-value-driven-digital/9780135263617/">Edge: Value-Driven Digital Transformation</a></li><li><a href="https://www.oreilly.com/library/view/the-leaders-guide/9780470548684/">The Leader’s Guide to Radical Management</a></li><li><a href="https://www.impactmapping.org/book.html">Impact Mapping</a></li><li><a href="https://www.jpattonassociates.com/user-story-mapping/">User Story Mapping</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=3b7ec4407ecf" width="1" height="1" alt=""><hr><p><a href="https://medium.com/claranet-italia/come-realizzare-migliori-prodotti-digitali-i-nostri-tre-pilastri-3b7ec4407ecf">Come realizzare migliori prodotti digitali: i nostri tre pilastri</a> was originally published in <a href="https://medium.com/claranet-italia">Claranet Italia</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Il nostro percorso di recruitment visto tramite gli occhi di due nuovi colleghi]]></title>
            <link>https://medium.com/claranet-italia/il-nostro-percorso-di-recruitment-visto-tramite-gli-occhi-di-due-nuovi-colleghi-de2def849c60?source=rss----6c4a1c0b89d9---4</link>
            <guid isPermaLink="false">https://medium.com/p/de2def849c60</guid>
            <category><![CDATA[work-with-us]]></category>
            <category><![CDATA[recruitment]]></category>
            <dc:creator><![CDATA[Claranet Italia]]></dc:creator>
            <pubDate>Fri, 30 Oct 2020 08:18:38 GMT</pubDate>
            <atom:updated>2020-10-30T08:18:38.221Z</atom:updated>
            <content:encoded><![CDATA[<p><em>A poco più di due settimane dal primo giorno di lavoro Angelo e Walter, due nuovi colleghi, vi raccontano in questo articolo il percorso di recruitment che hanno affrontato per entrare a far parte del team Claranet Italia come agile developer.</em></p><p>Come software engineers che hanno da poco affrontato la ricerca di una nuova posizione lavorativa, sappiamo bene quanto possa essere impegnativo e pieno di incognite questo momento della vita di una persona.</p><p>Ci si trova a dover valutare svariate offerte, cercare di selezionare quelle maggiormente in linea con le proprie passioni e aspirazioni e dedicare una significativa quantità di tempo a migliorare il nostro CV. Una volta raggiunto un risultato soddisfacente, si manda la propria application con la speranza di essere ricontattati e, se tutto va nel modo giusto, presto o tardi si riceve nella mailbox la conferma di essere stati selezionati per l’iter di recruitment!</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*3kmtqGwH108DIjTnH-sr-Q.jpeg" /><figcaption>Se vi piace migliorare in modo continuo Claranet Italia è il posto giusto per voi!</figcaption></figure><p>Ma qui la strada si mette in salita, visto che ogni azienda ha un percorso diverso.</p><p>Entrare in Claranet Italia non è certo una passeggiata! Siamo però convinti che condividendo la nostra esperienza potremo farvi valutare l’idea di unirvi al nostro team e darvi dei suggerimenti utili che possano rendere il vostro percorso il più fluido possibile.</p><p>Il processo di recruitment del nostro team è scandito <em>da più iterazioni</em> che variano a seconda dell’esperienza della persona che invia la propria candidatura. Ci sono però dei punti cardine, che rimangono fissi per tutti i livelli di candidatura:</p><ul><li><strong>un colloquio conoscitivo</strong></li><li><strong>una coding challenge</strong></li><li><strong>un colloquio tecnico</strong></li></ul><p>Il colloquio conoscitivo iniziale consiste in un dialogo informale in cui si parla del proprio background, delle motivazioni che vi hanno spinto ad inviare una candidatura e ad una spiegazione generale sulla cultura e le modalità di lavoro del team.</p><p>Da questo primissimo step si avverte la forte cultura aziendale basata sui principi valori e pratiche dell’<a href="https://agilemanifesto.org/"><em>Agile Manifesto</em></a>. Per il nostro team, aderire a tale manifesto significa anche dare importanza al <em>miglioramento continuo</em>, alle <em>relazioni interpersonali</em> e creare un ambiente di lavoro<em> flessibile</em> e <em>motivante</em>.</p><p>In poche parole fin da subito si ha l’impressione di entrare a far parte di una realtà che pone molta attenzione alle condizioni lavorative delle proprie persone. Questa fase non deve essere vista solo come un momento per fare capire al team Claranet se siete persone adatte a diventare parte dell’azienda, ma serve anche per capire se il team Claranet fa al caso vostro!</p><p>Superato il colloquio conoscitivo, si passa allo step successivo: una coding challenge da risolvere nel linguaggio di programmazione che si preferisce in sette giorni a partire da una data a propria scelta. Questa tipologia di esercizio è senza dubbio il miglior modo di dimostrare le proprie hard skill di programmazione, decisamente preferibile rispetto alla solita sequela di domande-quiz così diffuse in altre realtà.</p><p>Per noi la coding challenge è stata un’esperienza alquanto positiva ma ci rendiamo conto che per esprimersi al meglio è necessario capire fin dal colloquio conoscitivo i criteri secondo cui viene valutato il codice, ad esempio:</p><ul><li>è necessario includere i test anche se non esplicitamente richiesti?</li><li>quali tecnologie è preferibile usare?</li><li>come viene valutato l’uso di framework?</li><li>quanto è importante seguire le best practice per il versioning del codice?</li></ul><p>Se la soluzione della coding challenge viene valutata positivamente si passa finalmente al colloquio tecnico: una tranquilla sessione di qualche ora in cui si discutono tematiche tecniche e si scrive del codice assieme.</p><p>Durante questa fase c’è continuo feedback dalla persona che darà una valutazione e per noi questo aspetto è molto positivo perché ci ha comunicato una significativa trasparenza nella valutazione. In particolare tramite il feedback abbiamo evitato quel limbo di pericoloso monologo interiore che fa percorrere vicoli bui che deviano dalla corretta soluzione.</p><p>Una volta completata con successo quest’ultima prova non rimane che la contrattazione sull’offerta finale in cui si conosce la persona responsabile dell’area di lavoro e si ha anche modo di discutere eventuali necessità che esulano dal normale contratto, ad esempio orari ancora più flessibili per poter incastrare meglio tutti gli impegni quotidiani in questo periodo complicato a causa del Covid.</p><p>Complessivamente, per noi l’intero processo è stato molto motivante. Non nascondiamo che abbia richiesto una dose significativa di tempo e impegno ma possiamo confermare che ne vale la pena!</p><p><a href="https://www.claranet.it/propos-de/lavora-con-noi"><strong><em>Quindi cosa aspettate a salire a bordo?</em></strong></a></p><p>Angelo e Walter!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=de2def849c60" width="1" height="1" alt=""><hr><p><a href="https://medium.com/claranet-italia/il-nostro-percorso-di-recruitment-visto-tramite-gli-occhi-di-due-nuovi-colleghi-de2def849c60">Il nostro percorso di recruitment visto tramite gli occhi di due nuovi colleghi</a> was originally published in <a href="https://medium.com/claranet-italia">Claranet Italia</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Un semplice rimedio alla paura del lock-in su AWS Lambda]]></title>
            <link>https://medium.com/claranet-italia/un-semplice-rimedio-alla-paura-del-lock-in-su-aws-lambda-5d7ce8265dd4?source=rss----6c4a1c0b89d9---4</link>
            <guid isPermaLink="false">https://medium.com/p/5d7ce8265dd4</guid>
            <category><![CDATA[repository-pattern]]></category>
            <category><![CDATA[aws-lambda]]></category>
            <category><![CDATA[serverless]]></category>
            <category><![CDATA[ports-and-adapters]]></category>
            <category><![CDATA[aws]]></category>
            <dc:creator><![CDATA[Mariano Calandra]]></dc:creator>
            <pubDate>Mon, 28 Sep 2020 14:29:12 GMT</pubDate>
            <atom:updated>2020-09-28T14:29:11.952Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*6htj8Xtnsz3Z7ifGo0iGew.png" /><figcaption>Photo by <a href="https://unsplash.com/@hussanamir?utm_source=unsplash&amp;utm_medium=referral&amp;utm_content=creditCopyText">Hussan Amir</a> on <a href="https://unsplash.com/s/photos/lcok?utm_source=unsplash&amp;utm_medium=referral&amp;utm_content=creditCopyText">Unsplash</a></figcaption></figure><blockquote>This is the italian version of a story originally in English that you will find <a href="https://medium.com/swlh/dr-vendor-lock-in-or-how-i-learned-to-stop-worrying-and-love-aws-lambda-c91264c6f39f">here</a>. Thanks to my colleague Paolo D’Incau for the Italian translation and invaluable feedback.</blockquote><p>Per chi non lo conoscesse, AWS Lambda è una servizio che permette di eseguire della business logic senza la necessità di dover gestire un server. Una volta caricato il codice sorgente, la piattaforma si occuperà di tutto il necessario per eseguirlo, garantendone la scalabilità in base al numero di richieste.</p><p>Una volta rilasciato, <strong>l’esecuzione di tale codice potrà essere avviata da altri servizi AWS</strong> (Amazon S3, Amazon SNS/SQS e così via) <strong>in risposta a determinati eventi</strong>. Ad esempio, al caricamento di un’immagine su S3, quest’ultimo potrà invocare l’esecuzione di una funzione Lambda che ne crei una miniatura. <br>Per rendere queste integrazioni il più semplice possibile, ci sono alcune convenzioni che dobbiamo tenere a mente.</p><p>Essendo queste convenzioni peculiari ad AWS Lambda, alcune persone valutano piattaforme alternative, come Kubernetes, <strong>preoccupate che tali convenzioni possano rappresentare un forte lock-in su AWS</strong>.</p><blockquote>Kubernetes is open source and runs on most environments, including on premises. Problem solved? Not quite — now you are tied to Kubernetes — think of all those precious YAML files! So you traded one lock-in for another, didn’t you?</blockquote><blockquote>– <a href="https://martinfowler.com/articles/oss-lockin.html">Gregor Hohpe</a></blockquote><p>Il punto è che <strong>non possiamo astrarci da tutto e prima o poi dovremo accettare un certo qual tipo di lock-in</strong>! In fondo abbiamo già accettato un lock-in nel momento in cui abbiamo scelto un linguaggio di programmazione per il nostro applicativo. Abbiamo accettato un lock-in quando abbiamo scelto un database piuttosto che un altro.</p><p>Chiarito quindi che non esiste un mondo <em>“100% lock-in free”</em>, dovremmo evitare di utiliazzare il termine “lock-in” e parlare piuttosto di <strong>switching cost</strong>, ovvero il costo che dovremo pagare se un giorno volessimo passare da una implementazione basata su AWS Lambda ad una basata su Amazon ECS. O da Microsoft SQL Server ad Oracle.</p><p>In questo articolo presenteremo due approcci che dovremmo tenere in considerazione quando scriviamo le nostre Lambda Function, in quanto ci consentiranno di mitigare il più possibile un eventuale switching cost:</p><ul><li>disaccoppiare la logica di business dal Lambda handler;</li><li>astrarre la logica di business dalla service call;</li></ul><h4>Disaccoppiare la logica di business dal Lambda handler</h4><p>AWS Lambda si basa su convenzioni, sono proprio queste convenzioni che ci permettono di eseguire il nostro codice senza troppi sforzi a livello di configurazione. La prima convenzione è relativa agli argomenti che la nostra Lambda Function accetta in ingresso.</p><p>Ci sono due principali argomenti che Lambda (come piattaforma), inietta in ogni Function:</p><ul><li><em>event source</em> — l’informazione relativa all’evento che ha causato l’esecuzione della Function;</li><li><em>execution context </em>— le informazioni di esecuzioni come running time, execution id, log stream usato e cosí via;</li></ul><p>Parlando in pseudo-codice, la nostra Function somiglia a qualcosa del genere:</p><pre>function handler(event, context) {<br>    // lines of code<br>}</pre><blockquote><strong>Pro-tip:</strong> Cercate di immaginare il vostro primo progetto software, probabilmente aveva molte funzioni (o metodi, se usavate un paradigma Object-Ordiented) ma solo una di queste funzioni era l’entrypoint del vostro progetto (in OOP lo chiameremmo metodo Main).</blockquote><blockquote>Allo stesso modo, la vostra Lambda Function (F maiuscola) potrà essere composta da diverse funzioni (o metodi) ma solo uno di queste sarà l’entrypoint e sarà proprio l’handler function (o handler method).</blockquote><p>Dimentichiamoci per il momento dell’<em>execution context</em> e concentriamoci sull’<em>event source</em> (ovvero sull’argomento event), in modo da fissare un concetto nella nostra mente: <strong>il modo in cui una Function viene invocata influenza la forma dell’event source.</strong></p><p>Ad esempio, se la nostra Lambda Function è <a href="https://docs.aws.amazon.com/lambda/latest/dg/API_Invoke.html"><em>direttamente</em> invocata usando la relativa API</a>, l’argomento event sarà il payload della richiesta e se volessimo leggere il valore della property a potremmo farlo usando event.a (Fig.1).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*3Qiuul3qsFZlms2N6O0ALw.png" /><figcaption>Fig.1</figcaption></figure><p>Tutto cambierebbe se la nostra Function fosse invocata per conto di un altro servizio. Un classico esempio potrebbe essere il caso in cui la Lambda Function venga esposta tramite API Gateway.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*pDFpgSHMuLCMKDk8XvQp7Q.png" /><figcaption>Fig.2</figcaption></figure><p>In questo caso la property a della query-string, sarebbe estraibile tramite event.queryStringParameters.a (Fig.2).</p><blockquote><strong>Reminder:</strong> il modo in cui una Function viene invocata influenza la forma dell’event source.</blockquote><p>Ma non è ancora finita! Un approccio comune quando Lambda è usato come backend per Amazon API Gateway consiste nel configurare quest’ultimo usando il cosiddetto <a href="https://docs.aws.amazon.com/apigateway/latest/developerguide/set-up-lambda-proxy-integrations.html">Lambda proxy integration</a>. In questo caso, la nostra Lambda Function dovrà ritornare un oggetto con tre properties: uno <em>status-code</em>, un <em>body</em> e una proprietà <em>headers</em> opzionale.</p><p>Per funzionare correttamente la Lambda dietro a <em>GET /calculator?a=3&amp;b=7</em> (Fig.2), dovrà somigliare a:</p><pre>// filename: lambda.pseudo (v.1)<br>function(event) {<br>    <strong>// parte 1 (mapping API Gateway)</strong><br>    a = event.queryStringParameters.a // 3<br>    b = event.queryStringParameters.b // 7<strong>    </strong></pre><pre><strong>    // parte 2 (logica di business)</strong><br>    body = {&quot;result&quot; : a + b}<strong>    </strong></pre><pre><strong>    // parte 3 (convenzioni Lambda/API Gateway)</strong><br>    body_s = body.stringify() // &quot;{\&quot;result\&quot; : 10}&quot;    </pre><pre>    return {<br>        statusCode: 200,<br>        body: body_s,<br>        headers: {&quot;content-type&quot;: &quot;application/json&quot;}<br>    }<br>}</pre><p>A causa di queste convenzioni, <strong>una sola riga di business logic necessita alcune righe di </strong><a href="https://en.wikipedia.org/wiki/Glue_code"><strong>glue code</strong></a>. Se volessimo portare questa Lambda in un container su Amazon ECS, dovremmo rifattorizzare il codice esistente con un alto switching cost!</p><blockquote><strong>Nota:</strong> Sono completamente d’accordo. La somma di due numeri non è un granché come business logic. Tuttavia, per mantenere una buona leggibilità e comprensione del testo fingeremo che lo sia.</blockquote><p>Come prima cosa, per abbassare questo costo, possiamo <a href="https://docs.aws.amazon.com/lambda/latest/dg/best-practices.html">disaccoppiare il nostro codice, estraendo la nostra logica di business dal Lambda handler</a>. Questa operazione non è difficile e possiamo cosí ottenere un buon risultato con pochi minuti di refactoring, semplicemente incapsulando la business logic in un componente a sé stante:</p><pre>// filename: calculator.pseudo</pre><pre>function sum(a, b) {<br>    return {&quot;result&quot;: a + b}<br>}</pre><p>Ora, il Lambda handler non è nulla più che glue code; è il punto in cui estrarremo il payload spedito da API Gateway (parte 1) eseguiremo la business logic (parte 2) e accontenteremo API Gateway fornendo in risposta un oggetto che contenga <em>status code</em>, <em>body</em> ed <em>headers</em> (parte 3):</p><pre>// filename: lambda.pseudo (v.2)</pre><pre>import Calculator from calculator.pseudo</pre><pre>function(event) {<br>    <strong>// parte 1 (mapping API Gateway)</strong><br>    a = event.queryStringParameters.a // 3<br>    b = event.queryStringParameters.b // 7<strong>    </strong></pre><pre><strong>    // parte 2 (logica di business)</strong><br>    calculator = new Calculator()<br>    result = calculator.sum(a, b) // {&quot;result&quot; : 10}<strong>    </strong></pre><pre><strong>    // parte 3 (convenzioni Lambda/API Gateway)</strong><br>    body = result.stringify() // &quot;{\&quot;result\&quot; : 10}&quot;    </pre><pre>    return {<br>        statusCode: 200,<br>        body: body,<br>        headers: {&quot;content-type&quot;: &quot;application/json&quot;}<br>    }<br>}</pre><p>Incapsulando la nostra logica in un file separato abbiamo creato margine di manovra. Se un domani volessimo containerizzare la nostra logica di business, questa sarà già separata dalle convenzioni proprie di Lambda ed API Gateway. <br>Un bel passo in avanti.</p><h4>Astrarre la business logic dalle call del service provider</h4><blockquote>«A posto così?»<br>«Beh, non ancora!»</blockquote><p>E’ molto probabile che, in applicazioni più complesse, la nostra business logic faccia delle chiamate ad altri servizi AWS tramite SDK. <br>Per esempio, immaginiamo di voler modificare il codice di <em>calculator.pseudo</em> affinché possa scrivere su di una tabella DynamoDB il risultato della somma di due numeri (facciamo finta che sia una operazione in un qualche modo sensato):</p><pre>// file: calculator.pseudo (v.2)</pre><pre>import doc_client from AWS.DynamoDB.DocumentClient()</pre><pre>function sum(a, b) {<br>    <strong>// calcolo del risultato (logica di business)</strong><br>    result = a + b</pre><pre>    <strong>// comunicazione con DynamoDB (con glue code)</strong><br>    params = {<br>        TableName: &quot;Results&quot;,<br>        Item: { &quot;value&quot;: result, &quot;id&quot;: uuid()}<br>    }</pre><pre>    doc_client.put(params)</pre><pre>    <strong>// return del risultato (logic di business)</strong><br>    return {&quot;result&quot;: result}<br>}</pre><p>La sola necessità di salvare dati su un database ci ha reso nuovamente accoppiati all’SDK di AWS ed alle convenzioni di DynamoDB.</p><p>Siamo ancora bloccati!</p><h4>Il Repository pattern</h4><p>Anni fa, quando ho iniziato in questo settore, la preoccupazione principale di ogni architect era il database!</p><p>La soluzione a questa problematica era il Repository pattern.</p><p>Per spiegare come funziona un repository, mi piace usare le parole che Eric Evans ha usato in <a href="https://amzn.to/2y0vZec">uno dei libri che ho amato di più</a> e che mi capita di citare in parecchi articoli:</p><blockquote>[A repository] provide methods to add and remove objects, which will encapsulate the actual insertion or removal of data in the data store. Provide methods that select objects based on some criteria and return fully instantiated objects or collections of objects whose attribute values meet the criteria, thereby encapsulating the actual storage and query technology.</blockquote><p>Con un repository possiamo:</p><blockquote>• decouple application and domain design from persistence technology […];<br>• allow easy substitution of a dummy implementation, for use in testing […];</blockquote><p>Vediamo come applicare questo concetto al nostro codice:</p><pre>// file: calculator.pseudo (v.3)</pre><pre>Calculator(_repository) {<br>    repository = _repository<br>}</pre><pre>function sum(a, b) {<br><strong>    // calcolo del risultato (logica di business)</strong><br>    result = a + b<strong>    <br>    <br>    // comunicazione con DynamoDB (tramite repository)</strong><br>    item = { &quot;value&quot;: result, &quot;id&quot;: uuid()}<br>    repository.save(item)</pre><pre><strong>    // return del risultato (logic di business)</strong><br>    return {&quot;result&quot;: result}<br>}</pre><p>Eradicata la parte di glue code relativa a DynamoDB dobbiamo incapsularla in un componente a sé stante:</p><pre>// file: repository.dynamodb.pseudo</pre><pre>import doc_client from AWS.DynamoDB.DocumentClient()</pre><pre>DynamoDbRepository(_tablename) {<br>    tablename = _tablename<br>}</pre><pre>function save(item) {<br>    params = {<br>        TableName: _tablename,<br>        Item: item<br>    }</pre><pre>    doc_client.put(params)<br>}</pre><p>Ora dobbiamo modificare il Lambda handler affinché possa istanziare il repository ddb:</p><pre>ddb = new DynamoDbRepository(“Results”)</pre><p>istanziare la logica di business iniettandovi il repository:</p><pre>calculator = new Calculator(ddb)</pre><p>eseguire la logica di business:</p><pre>result = calculator.sum(a, b)</pre><p>Ed ecco come sarà il nuovo handler:</p><pre>// filename: lambda.pseudo (v.3)</pre><pre>import Calculator from calculator.pseudo<br>import DynamoDbRepository from repository.dynamodb.pseudo</pre><pre>function(event) {<br>    <strong>// parte 1 (mapping API Gateway)</strong><br>    a = event.queryStringParameters.a // 3<br>    b = event.queryStringParameters.b // 7</pre><pre><strong>    // parte 2 (creazione dipendenze)<br></strong>    ddb = new DynamoDbRepository(&quot;Results&quot;)<br>    calculator = new Calculator(ddb)<br>    result = calculator.sum(a, b)</pre><pre><strong>    // 3rd part (mapping Lambda/API Gateway)</strong><br>    body = result.stringify() // i.e. &quot;{\&quot;result\&quot; : 10}&quot;</pre><pre>    return {<br>        statusCode: 200,<br>        body: body,<br>        headers: {&quot;content-type&quot;: &quot;application/json&quot;}<br>    }<br>}</pre><blockquote><strong>Pro-tip: </strong>In uno scenario reale, per implementare un buon repository tenete in considerazione l’uso di interfacce e il principio di Inversion of Control tramite Dependency Injection.</blockquote><h4>Da Repository a Ports and Adapters</h4><p>Supponiamo di essere ancora preoccupati dello switching cost relativo a Lambda e di volerlo mitigare; perché non estendere quanto visto relativamente alla dipendenza da DynamoDB anche ad altri tipi di dipendenze esterne?</p><p>Se la nostra applicazione ad esempio facesse uso di servizi come Amazon Simple Notification Service (SNS), o Amazon Simple Storage Service (S3) potremmo estrarre le relative sezioni di codice in dei moduli dedicati.</p><p>Ragionando in questo modo, ci stiamo avvicinando ad un design pattern chiamato <em>Ports and Adapters</em>. L’idea di fondo è che la business logic rappresenti il core del nostro sistema e viene invocata tramite delle <em>porte</em> che il sistema mette a disposizione. Queste porte schermano il sistema da meccanismi di comunicazione e sistemi esterni oltre che da tools e framework.</p><p>Inoltre tale approccio:</p><blockquote>allow an application to equally be driven by users, programs, automated test or batch scripts, and to be developed and tested in isolation from its eventual run-time devices and databases.</blockquote><blockquote>– Alistair Cockburn</blockquote><h4>Una questione di scelte</h4><p>In questo modo riusciamo ad astrarre dalla nostra business logic moltidettagli implementativi che potrebbero causare un alto switching cost. <br>Tuttavia dobbiamo sempre porci delle domande:</p><blockquote>«Ne vale pena?»</blockquote><p>Sì, sicuramente!</p><p>Usando un tale approccio non solo mitighiamo un eventuale switching cost, ma andiamo anche a migliorare il design e la testabilità del nostro applicativo.</p><p>Attenzione però a <strong>non cedere alla tentazione di voler creare una applicazione che sia totalmente cloud-agnostica</strong>. <br>Per favore, non fatelo!</p><p>Credo che per motivare questa frase, valga la pena citare questo tweet di Yan Cui che rende chiaro in pochissime parole il concetto.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*wx7iGsG8Cf_o_zOdRmmenA.png" /><figcaption><a href="https://lumigo.io/blog/you-are-wrong-about-serverless-vendor-lock-in/">https://lumigo.io/blog/you-are-wrong-about-serverless-vendor-lock-in/</a></figcaption></figure><p>Oltre a quanto scritto da Yan, dobbiamo considerare un altro aspetto molto più sottile. Ci sono molte definizioni per applicazioni <em>cloud-native</em>, quella che preferisco considera un’applicazione cloud-native se usa in modo intelligente le funzionalità messe a disposizione dal provider.</p><p>Su AWS, una delle funzionalità che preferisco sono le <a href="https://aws.amazon.com/blogs/compute/introducing-aws-lambda-destinations/">Lambda Destinations</a>, che permettono di scrivere molto meno codice (e meno codice implica meno rischio di introdurre regressioni) semplificando la creazione di applicazione event-driven. Sfortunamente questa funzionalità è strettamente legata ad AWS e incapsularla tramite Ports e Adapters è molto difficile, se non impossibile.</p><p>Dovremmo comunque usare questa funzionalità?</p><h4>Conclusioni</h4><p>La risposta alla precedente domanda è: dipende! :-)</p><p>Quello che più mi piace di Lambda è la possibilità di scrivere codice senza dovermi preoccupare della architettura sottostante. Mi piacciono anche alcune sue caratteristiche che velocizzano lo sviluppo dando grande valore al cliente (e il cliente ha sempre ragione).</p><p>D’altro canto cerco sempre di astrarmi il più possibile, per motiviti di testabilità piuttosto che per paura del lock-in. Come tutti i servizi AWS anche Lambda migliora di giorno in giorno, inoltre<strong> non c’è mai stato alcun servizio di AWS che ha avuto un incremento di prezzo</strong>, anzi ci sono dei tagli ai prezzi considerevoli. Per questo,<strong> non ho paura del lock-in e non avverto il bisogno di dover cambiare provider.</strong></p><p>Se alcune parti del vostro sistema sono assolutamente cruciali e meritano di essere multi-cloud o vendor-agnostiche allora mettete effort extra di astrazione su quelle e su null’altro. Contrariamente il vero rischio è quello di rendere il vostro codice inutilmente complesso.</p><p>My 2 cents.</p><h3>Approfondimenti</h3><ul><li>Gregor Hope — <a href="https://martinfowler.com/articles/oss-lockin.html">Don’t get locked up into avoiding lock-in</a>;</li><li>Mark Schwartz — <a href="https://aws.amazon.com/blogs/enterprise-strategy/switching-costs-and-lock-in/">Switching costs and lock-in</a>;</li><li>AWS Doc — <a href="https://docs.aws.amazon.com/lambda/latest/dg/best-practices.html">Best Practices for Working with AWS Lambda Functions</a>;</li><li>Eric Evans — <a href="https://amzn.to/2y0vZec">Domain Driven Design: Tackling Complexity in the heart of software</a>;</li><li>Slobodan Stojanović — <a href="https://vacationtracker.io/blog/big-bad-serverless-vendor-lock-in/">Big bad serverless vendor lock-in</a>;</li><li>Yan Cui — <a href="https://lumigo.io/blog/you-are-wrong-about-serverless-vendor-lock-in/">You are wrong about serverless vendor lock-in</a>;</li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=5d7ce8265dd4" width="1" height="1" alt=""><hr><p><a href="https://medium.com/claranet-italia/un-semplice-rimedio-alla-paura-del-lock-in-su-aws-lambda-5d7ce8265dd4">Un semplice rimedio alla paura del lock-in su AWS Lambda</a> was originally published in <a href="https://medium.com/claranet-italia">Claranet Italia</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Come ci siamo adattati al Covid-19]]></title>
            <link>https://medium.com/claranet-italia/come-ci-siamo-adattati-al-covid-19-e9a4c8889975?source=rss----6c4a1c0b89d9---4</link>
            <guid isPermaLink="false">https://medium.com/p/e9a4c8889975</guid>
            <category><![CDATA[covid19]]></category>
            <category><![CDATA[remote-working]]></category>
            <category><![CDATA[adaptation]]></category>
            <dc:creator><![CDATA[Marco Trincardi]]></dc:creator>
            <pubDate>Wed, 05 Aug 2020 15:26:28 GMT</pubDate>
            <atom:updated>2020-08-06T13:56:18.980Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*VhkAhu8pLsYKuygyY8undA.jpeg" /></figure><p>Abbiamo letto molti articoli di aziende che raccontano come sono cambiate con il Covid. Ecco come è andata in Claranet Italia.</p><p>Siamo andati full remote da fine febbraio, prima la nostra sede di Milano e poi una settimana dopo Trento e Roma. Siamo rimasti full remote da allora.<br>Vista la repentinità con cui è avvenuto, eravamo un pò spaventati, come tutti, da questo cambiamento.</p><p><strong><em>Perché il remote ha funzionato</em></strong></p><p>Siamo un’azienda che era già distribuita su 3 sedi, quindi abbiamo sempre usato strumenti di comunicazioni e condivisione della conoscenza (Videocall, Discourse, Slack)</p><p>Spesso i nostri team erano già distribuiti, composti da persone su diverse sedi, e alcuni di loro, già prima del Covid-19, facevano qualche giornata da remoto.</p><p>Come Manager non controllavo i team prima della pandemia, tanto meno ho cominciato a farlo adesso. Questo perché non credo nel micro management e perché abbiamo una cultura della fiducia e del rispetto. I team sono autonomi e responsabilizzati, quello che ci valuta è il raggiungimento dell’obiettivo del progetto, il feedback del cliente, e la marginalità sulle commesse, informazioni che sono condivise in trasparenza. Inoltre c’è un meccanismo implicito di peer-review all’interno dei team, perché un team sano spinge nella stessa direzione.</p><p>In generale è stata l’Agilità, vissuta come cultura aziendale più che come singola metodologia, che ha reso la transizione al full-remote praticamente indolore.</p><p>Fiducia, Commitment, Trasparenza, sono concetti che da noi sono “embedded”, non abbiamo dovuto impararli a causa del Covid.</p><p><strong><em>Feedback</em></strong></p><p>Dopo un paio di mesi abbiamo deciso di raccogliere feedback dai team sul lavoro remoto e, con sorpresa, il feedback è stato molto più positivo di quello atteso. Si è deciso di investire nel migliorare le condizioni di lavoro da casa, con un rimborso spesa per comprarsi una nuova sedia, pagarsi la connessione, etc Qualcuno è andato a prendersi sedie e monitor dagli uffici.</p><p><strong><em>Adattarsi al cambiamento</em></strong></p><p>La verità è che le cose cambiano intorno a noi senza che possiamo farci nulla. Quale esempio migliore di una pandemia!!</p><p>L’adattabilità è quella cosa che ti permette di vivere il cambiamento non come una cosa di cui essere spaventati, ma come l’occasione per provare qualcosa di diverso, e valutarne l’effetto. Più ci si trova fuori dalla confort zone, e più bisogna provare a fare cose diverse per adattarsi.</p><p>Lentamente in noi è cresciuta la consapevolezza che il cambiamento, portato dal Covid-19, non sarebbe stato passeggero e che era giunto il momento di ragionare su come cambiare per rispondere a questa nuova realtà.</p><p>Un primo cambiamento ha riguardato i servizi offerti; abbiamo fatto due esperimenti riguardanti il <em>coaching da remoto</em> ed il <em>training da remoto</em>. Erano due attività che fino a prima del Covid-19 eravamo convinti che non potessero avere la stessa resa da remoto. Ci sbagliavamo. Attraverso un processo di fatto di piccoli esperimenti abbiamo apportato modifiche nel modo di erogare coaching e training e la resa è migliorata al punto di non rimpiangere la modalità precedente.</p><p>Anche il mercato si è adeguato. Il nostro training Aws si era completamente fermato tra marzo e aprile. E’ incredibile come sia ripartito in modalità remota: a giugno abbiamo fatto il nostro <strong>record assoluto </strong>con oltre 150 persone formate online!</p><p>Un secondo cambiamento, più naturale, riguarda <em>aprire posizioni di lavoro full remote</em>. Se stiamo lavorando bene cosi’, perché non assumere persone che non sono vicine alle nostre sedi?</p><p>Un terzo cambiamento è stata la decisione di <em>chiudere la nostra sede di MIlano</em>, in Copernico. Ci ripenseremo nel 2021. Vogliamo una nuova sede, certo, ma vogliamo un posto che sia nostro, e dobbiamo ancora metabolizzare bene per capire cosa ci serve davvero.</p><p>Siamo cambiati, ci siamo adattati.</p><p><strong><em>Futuro</em></strong></p><p>Ci sono tutta una serie di questioni ancora da rispondere. Come creare momenti di incontro che non siano legati ad attività di progetto? Anche qui non partivamo da zero: Claranet, e ancora prima XPeppers, è organizzata in modo che le persone che fanno delivery si occupano anche di vari aspetti aziendali non legati ad attività progettuale, e la gestione di questo mix di attività viene fatta in autonomia. In questo modo persone che non fanno parte dello stesso team di progetto possono relazionarsi con altre di altri progetti, e svolgere delle attività in comune. Questo ci mette in una posizione migliore rispetto ad aziende tradizionali dove con il remote working forzato di fatto si sono creati dei team isolati.</p><p>Altro punto su cui stiamo ragionando è come sfruttare al meglio le sedi di Trento e Roma (e Milano quando ne prenderemo una nuova) come punti di aggregazione, per sfruttare al massimo i momenti di incontro, più che come solo posto di lavoro in cui si condivide uno spazio.</p><p>Ma c’è ancora tanto da ragionare e da migliorare.</p><p>Ultimo aspetto: essere remote first ci dovrebbe facilitare il lavoro all’estero. Abbiamo la fortuna di avere <em>sedi in quasi tutta Europa</em>. Ora la sfida è creare contenuti in lingua inglese che facciano capire meglio l’ottimo asset di conoscenza che abbiamo in Italia.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e9a4c8889975" width="1" height="1" alt=""><hr><p><a href="https://medium.com/claranet-italia/come-ci-siamo-adattati-al-covid-19-e9a4c8889975">Come ci siamo adattati al Covid-19</a> was originally published in <a href="https://medium.com/claranet-italia">Claranet Italia</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Perché è importante uno sviluppo iterativo e incrementale anche in una libreria OpenSource?]]></title>
            <link>https://medium.com/claranet-italia/perch%C3%A9-%C3%A8-importante-uno-sviluppo-iterativo-e-incrementale-anche-in-una-libreria-opensource-f5d5ca96ee99?source=rss----6c4a1c0b89d9---4</link>
            <guid isPermaLink="false">https://medium.com/p/f5d5ca96ee99</guid>
            <category><![CDATA[web-development]]></category>
            <category><![CDATA[iterative-development]]></category>
            <category><![CDATA[open-source]]></category>
            <category><![CDATA[kotlin]]></category>
            <dc:creator><![CDATA[Claranet Italia]]></dc:creator>
            <pubDate>Wed, 05 Aug 2020 07:47:07 GMT</pubDate>
            <atom:updated>2020-08-05T07:47:07.634Z</atom:updated>
            <content:encoded><![CDATA[<p>Questa è la nostra esperienza sulla realizzazione di una libreria OpenSource, di come lo sviluppo iterativo, incrementale si applichi non solo a progetti “commerciali” ma anche allo sviluppo open source, in particolare a quello guidato dalle esigenze e dal feedback.</p><p>Questa è la storia di <a href="https://daikonweb.github.io/">Daikon</a></p><blockquote>a dead simple and minimal framework for creating web applications in Kotlin with minimal effort</blockquote><p>Una libreria utiizzata in molti progetti del nostro team.</p><h3>La Nascita</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/533/1*-zn7bEud5roeEdXzepHfwA.jpeg" /></figure><p>Tutto è nato dal team in cui lavoriamo: il <strong>Team Vega</strong> e dal nostro coinvolgimento su progetti riguardanti lo sviluppo di applicazioni web in <strong>Kotlin</strong>.</p><p>Siamo stati per molto tempo dei fan di <a href="http://sparkjava.com/">SparkJava</a> per la sua semplicità e il suo <strong>DSL molto intuitivo</strong>.</p><p>Un’applicazione scritta in Spark è anche abbastanza <strong>semplice da testare</strong> e da manutenere, ma ci trovavamo spesso nelle condizioni di non poter usare <strong>SparkJava</strong> anche per i test.</p><p>In particolare, come spesso accade, abbiamo a che fare con servizi esterni (autenticazione, API varie, etc…), quindi nei test E2E ci piace (ove non sono disponibili i servizi veri) usare delle implementazioni che simulano il comportamento reale. Per fare questo solitamente creiamo dei test che lanciano delle API HTTP programmabili con validazioni e risposte realistiche.</p><p>Con <strong>SparkJava</strong> non possiamo lanciare più di un <strong>server HTTP</strong> nella stessa applicazione, questo perché dietro le quinte lavora con oggetti statici.</p><p>Sappiamo però che esistono librerie per soddisfare questa necessità ad esempio <a href="http://wiremock.org/">WireMock</a>, ma non ci siamo mai trovati troppo bene ed in più ci forzano a configurare API HTTP in due modi diversi:</p><ol><li>la libreria per il codice di produzione</li><li>la libreria per il codice di test</li></ol><p>Questo è stato uno dei motivi che hanno dato il via allo <strong>sviluppo di Daikon</strong>: avere un unico modo per lanciare più applicazioni che usano HTTP nella stessa suite di test.</p><p>In più volevamo anche qualcosa che fosse:</p><ul><li><strong>rapido a partire e a servire richieste</strong>, dato che ultimamente stiamo lavorando parecchio su container docker che per loro natura sono volatili e necessitano di startup veloci</li><li><strong>senza magia</strong>, ovvero la possibilità di capire facilmente come utilizzare la libreria senza magie/convenzioni che obblighino gli utilizzatori a fare mille ricerche su <strong>StackOverflow</strong>. (es: <a href="https://spring.io/projects/spring-boot">SpringBoot</a>)</li></ul><h3>L’Evoluzione</h3><p>Cosa sta dietro al concetto di iterativo-incrementale in pratica?</p><p>L’idea parte dalla necessità di trovare un modo per validare il prima possibile quello che stiamo sviluppando e capire se questo porta valore.</p><p>Per andare in questa direzione dobbiamo avere sempre qualcosa di funzionante e pronto per essere utilizzato anche se con funzionalità ridotte, grezze e migliorabili.</p><p>Non solo, gli incrementi e le raffinazioni devono essere guidate dal feedback e motivate da reali esigenze, senza speculare su quello che potrà essere o potrà avvenire nel futuro.</p><p>Oramai è qualcosa che noi in <a href="https://www.claranet.it/">Claranet Italia</a> diamo per scontato nella realizzazione dei progetti, ma non sempre è un concetto che viene applicato da chi sviluppa, in modo particolare nel mondo OpenSource.</p><p>A volte perché si sviluppa pensando a utilizzatori immaginari (non reali), a volte perché ci si fa prendere da manie di grandezza con il risultato di complicare il codice provando a renderlo più estensibile/configurabile/astratto, salvo poi ritrovarsi tra le mani un codice più complesso e difficile da manutenere senza una reale necessità.</p><p><strong>In Daikon tutto (o quasi) è stato guidato dal feedback e dalla necessità.</strong></p><p>Le prime versioni erano molto scarne: si faceva partire un’ applicazione web con pochi metodi HTTP supportati, solo GET, POST e poco altro.</p><p>Man mano che usavamo Daikon nei nostri progetti, ci rendevamo conto che mancavano delle funzionalità. Quindi cercavamo di utilizzare queste reali necessità come spinta alla crescita di Daikon invece che svilupparle all’interno dei singoli progetti.</p><p>Siccome non siamo soli nell’universo, anche i feedback di colleghi, clienti e collaboratori sono stati importantissimi per capire quali funzionalità aggiungere o affinare.</p><p>Nonostante avessimo testato l’applicazione con scrupolo e il suo design sia stato fatto in <a href="https://github.com/xpeppers/starway-to-orione#2-testing-and-tdd">TDD</a>, niente è esente da bug. Questi feedback, quindi, ci hanno aiutato molto a trovarne alcuni (pochi per fortuna), verificarli con dei test e correggerli.</p><p>Man mano che Daikon veniva usato ci sono stati segnalati alcuni miglioramenti che avrebbero potuto semplificare il suo utilizzo e così, basandoci su necessità, feedback e uso quotidiano, abbiamo fatto la sua roadmap, fino a renderlo una libreria stabile e usata in diversi progetti in produzione.</p><h3>I Traguardi Raggiunti</h3><p>Uno degli obiettivi che ci eravamo prefissati era di tenere la <strong>libreria il più snella possibile</strong>. Per questo motivo abbiamo sempre cercato di evitare l’aggiunta di dipendenze. Quando qualcosa si rendeva necessario (es: parsing delle richieste e risposte in JSON) creavamo delle estensioni per Daikon che a tutti gli effetti erano progetti separati.</p><p>In questo modo l’utilizzatore ha a disposizione il set minimo di funzionalità che gli servono ed eventualmente aggiunge le estensioni alla sue dipendenze per le altre funzionalità.</p><p>Per quanto riguarda le estensioni, ci è venuto in soccorso Kotlin che, grazie alle <a href="https://kotlinlang.org/docs/reference/extensions.html">Extension Functions</a>, ci ha permesso di trovare un modo elegante, leggero ed espressivo per estendere il core di Daikon.</p><p>Sono nate così diverse estensioni:</p><ul><li><a href="https://daikonweb.github.io/docs/extensions/freemarker.html">Daikon Freemarker</a></li><li><a href="https://daikonweb.github.io/docs/extensions/gson.html">Daikon Gson</a></li><li><a href="https://daikonweb.github.io/docs/extensions/jacksonxml.html">Daikon Jackson XM</a>L</li><li><a href="https://daikonweb.github.io/docs/extensions/eureka.html">Daikon Eureka</a></li><li><a href="https://daikonweb.github.io/docs/extensions/prometheus.html">Daikon Prometheus</a></li></ul><p>Dopo qualche tempo abbiamo iniziato a gestire anche alcuni servizi <strong>Serverless</strong>, quindi abbiamo deciso di estrarre l’intero routing nel <a href="https://github.com/daikonweb/daikon-core">CORE</a> di Daikon in modo che fosse flessibile ed utilizzabile sia come server HTTP (usando <strong>Jetty</strong>) sia in Lambda che semplifica la gestione di applicazioni serverless.</p><p>Quindi è nato un altro interessante progettino: <a href="https://daikonweb.github.io/docs/extensions/lambda.html">Daikon Lambda</a> che ha la stessa interfaccia e le stesse funzionalità di base di Daikon.</p><p>Abbiamo poi deciso di estendere il concetto di semplicità e minimalismo anche al client HTTP. Così è nato anche <a href="https://github.com/DaikonWeb/topinambur">Topinambur</a>.</p><h3>Collaborazione ed entusiasmo</h3><p>Una cosa che ci è piaciuta moltissimo è stato il fatto che il Team Vega non fosse solo in questa avventura. Ai nostri colleghi è piaciuto il progetto e si sono adoperati per darci una mano a realizzare qualcosa che mancava o a migliorare quanto avevamo fatto. Ad esempio <a href="https://daikonweb.github.io/docs/extensions/prometheus.html">Daikon Prometheus</a> è nato dall’esperienza in quell’ambito di un nostro collega che ha visto l’opportunità di estendere la nostra libreria con quanto conosceva.</p><p>I clienti, inoltre, si sono dimostrati da subito entusiasti del progetto, sia perché avevano a disposizione qualcosa di funzionante e semplice integrato nei loro progetti, sia perché lo hanno potuto integrare in altri loro sistemi senza difficoltà e molto velocemente. Senza contare il fatto che lo sviluppo di Daikon non aveva intaccato (se non positivamente ) la delivery del progetto.</p><h3>Feedback</h3><p>Daikon è un progetto in continua crescita che si evolverà ulteriormente grazie ai feedback che riceveremo.</p><p>Potete contribuire in vari modi:</p><ul><li>usatelo e diteci come vi trovate, cosa vorreste avere in più o cosa vorreste migliorare</li><li>diventate contributor del progetto</li><li>mettete un like a questo post e una stellina al <a href="https://github.com/DaikonWeb/daikon">progetto su GitHub</a>.</li></ul><p><strong>PS</strong>: vi siete chiesti come mai le librerie hanno nomi di vegetali? Basta nomi di animali, finalmente una libreria vegetariana!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f5d5ca96ee99" width="1" height="1" alt=""><hr><p><a href="https://medium.com/claranet-italia/perch%C3%A9-%C3%A8-importante-uno-sviluppo-iterativo-e-incrementale-anche-in-una-libreria-opensource-f5d5ca96ee99">Perché è importante uno sviluppo iterativo e incrementale anche in una libreria OpenSource?</a> was originally published in <a href="https://medium.com/claranet-italia">Claranet Italia</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>