R2F0ZS5pbyBBTUEgY29uIE51bWJlcnMgUHJvdG9jb2wgLSBHYXJhbnRpcmUgbGEgcHJvdmVuaWVuemEgcGVyIHR1dHRpIGkgbWVkaWEgZGlnaXRhbGkgY3JlYXRpIGRhIGVzc2VyaSB1bWFuaSAmIEFJ

<p><img src="https://gimg2.gateimg.com/image/article/16892357031.jpeg" alt=""><br><strong>Ora: 15 novembre 2021, 13:00 UTC</strong><br><strong><a href="https://www.gate.io" target="_blank">Gate.io</a> ha ospitato una sessione di AMA (Ask-Me-Anything) con Sofia Yan, Co-fondatrice &amp; CGO di Numbers Protocol nel <a href="https://t.me/gateio" rel="nofollow noopener noreferrer" target="_blank">Comunità di scambio Gate.io</a>.</strong><br><strong>Sito ufficiale: <a href="https://www.numbersprotocol.io/" rel="nofollow noopener noreferrer" target="_blank">https://www.numbersprotocol.io/</a></strong><br><strong>Twitter: <a href="https://twitter.com/numbersprotocol" rel="nofollow noopener noreferrer" target="_blank">https://twitter.com/numbersprotocol</a></strong><br><strong>Segui il protocollo dei numeri su <a href="https://twitter.com/numbersprotocol" rel="nofollow noopener noreferrer" target="_blank">Twitter</a> e <a href="https://t.me/numbersprotocol" rel="nofollow noopener noreferrer" target="_blank">Telegram</a></strong><br><strong>Ospite</strong><img src="https://gimg2.gateimg.com/image/article/16892359172.jpg" alt=""><br><strong>Sofia Yan - Co-fondatrice &amp; CGO di Numbers Protocol</strong></p>
<h2 id="h2-Domande20e20risposte20da20Gateio56948"><a name="Domande e risposte da Gate.io" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Domande e risposte da Gate.io</h2><h3 id="h3-Q120Quindi20prima20di20tutto20capiamoci20meglio20tu20e20il20tuo20progetto20Puoi20iniziare20presentandoti20e20presentando20il20tuo20team20alla20nostra20comunit229757"><a name="Q1: Quindi prima di tutto, capiamoci meglio tu e il tuo progetto! Puoi iniziare presentandoti e presentando il tuo team alla nostra comunità?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q1: Quindi prima di tutto, capiamoci meglio tu e il tuo progetto! Puoi iniziare presentandoti e presentando il tuo team alla nostra comunità?</h3><p><strong>Sofia</strong>: Sicuramente!</p>
<p>Siamo una squadra piccola ma forte.</p>
<p>Sono il co-fondatore e direttore della crescita di Numbers, ho più di 8 anni di esperienza nello sviluppo aziendale e nel marketing.</p>
<p>Prima di unirmi a Numbers, ho lavorato per una startup di intelligenza artificiale e per una società di valutazione della proprietà intellettuale come vendite e responsabile dello sviluppo aziendale.</p>
<p>Amo le nuove sfide e abbraccio le nuove tecnologie e credo fermamente che la tecnologia debba essere utilizzata per portare bene alla società.</p>
<p>Tammy, la nostra fondatrice e Chief Product Officer, è una scienziata dei dati e una laureata in fisica delle particelle presso l’Università di Manchester.</p>
<p>La sua tesi riguardava la ricerca del bosone di Higgs dai dati massivi generati dal collisore di adroni. Prima di fondare Numbers, ha lavorato per Canonical, Viscovery e DT42 come ingegnere del software, responsabile tecnico, sviluppatore di intelligenza artificiale, CEO e fondatore. È amante degli animali e ha forte fede nella libertà dei dati.</p>
<p>Bofu, il nostro fondatore e Chief Technology Officer, è un ingegnere del software e un architetto con oltre 15 anni di esperienza in ingegneria dei dati, sistemi embedded, intelligenza artificiale e IoT.</p>
<p>È un innovatore di Arm, uno dei primi cinque sviluppatori open source di Taiwan nel 2017, nonché consulente e opinionista leader in materia di blockchain e politiche dei dati a Taiwan.</p>
<p>È anche l’architetto e lo sviluppatore dei progetti open source BerryNet e Mediant. Ha una forte fede in FLOSS, la libertà di Internet ed è molto attivo nella comunità open source.</p>
<p>Ethan, il nostro responsabile della comunità globale degli sviluppatori, fa molte cose per noi qui a Numbers. Avendo ottenuto il suo Master in Informatica presso l’Università di Georgia Tech, è un membro del nostro team di sviluppo e ha una buona comprensione della nostra tecnologia e dei nostri prodotti.</p>
<p>Ha anche un’ampia esperienza nella crescita delle comunità, avendo lavorato come social media per il team di esport di Jeremey Lin nel 2016. Non vede l’ora di interagire con la nostra comunità e con il nostro progetto.</p>
<p>Oltre a ciò, il resto del team si divide tra eccellenti ingegneri di backend, frontend e un po’ di marketing.</p>
<h3 id="h3-Q220Come20va20il20tuo20progetto20Ci20puoi20parlare20del20Protocollo20Numbers20e20di20cosa20stai20cercando20di20ottenere477968"><a name="Q2: Come va il tuo progetto? Ci puoi parlare del Protocollo Numbers e di cosa stai cercando di ottenere?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q2: Come va il tuo progetto? Ci puoi parlare del Protocollo Numbers e di cosa stai cercando di ottenere?</h3><p><strong>Sofia</strong>: Numbers Protocol è una startup con sede a Taiwan, con la visione di creare una rete fotografica decentralizzata per il Web3.0.</p>
<p>I media digitali sono una GRANDE parte della nostra vita quotidiana. Li consumiamo costantemente per l’intrattenimento che offrono e per i modi illimitati con cui possono informarci.</p>
<p>Tuttavia, i media digitali come si trovano nell’attuale internet hanno problemi. Inseguibili, non verificabili, facilmente copiati e manipolati, i contenuti digitali di oggi non hanno protezione, fiducia e libertà.</p>
<p>Ogni giorno vengono rubate 2,5 milioni di immagini non autorizzate per un ammontare giornaliero di danni pari a 600 miliardi. La diffusione incontrollata di informazioni errate rende impossibile distinguere cosa sia vero o falso. Le grandi aziende tecnologiche manipolano l’accesso alle informazioni.</p>
<p>Questi sono GRANDI problemi e influenzano la nostra società. Questo è il problema principale che stiamo cercando di risolvere.<br><img src="https://gimg2.gateimg.com/image/article/16892359473.png" alt=""><br>Mentre tutto il mondo ha poca fiducia nei media digitali ad un minimo storico, Numbers Protocol mira a portare integrità e autenticità allo spazio del contenuto digitale creando una rete fotografica decentralizzata in cui gli asset sono tracciabili e verificabili attraverso il suo innovativo processo di Cattura, Sigillo, Traccia.</p>
<h3 id="h3-Q320Hai20un20prodotto20funzionante20Quali20funzionalit20ha20Cosa20possiamo20fare20con20esso507761"><a name="Q3: Hai un prodotto funzionante? Quali funzionalità ha? Cosa possiamo fare con esso?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q3: Hai un prodotto funzionante? Quali funzionalità ha? Cosa possiamo fare con esso?</h3><p><strong>Sofia</strong>: Sì, abbiamo un paio di prodotti che sono già stati lanciati da un po’ di tempo.</p>
<p>La nostra soluzione non si limita solo al livello del protocollo. Abbiamo anche creato una serie di strumenti e servizi per consentire agli utenti di registrare e recuperare asset nella rete. Questi includono Capture App, Seal API e Trace Site.</p>
<p>Capture App è la prima fotocamera blockchain al mondo costruita per Web3.0, la prima fotocamera NFT e anche il primo portafoglio per asset fotografici.</p>
<p>Con Capture App, gli utenti possono stabilire la proprietà e il contesto al momento della creazione. Le informazioni vengono sigillate sulla blockchain e gli utenti possono accedere alle applicazioni dell’ecosistema dall’App senza la dipendenza delle piattaforme di terze parti.</p>
<p>Scattare una foto con Capture App è come scattare una foto tradizionale, tuttavia ci sono molte cose che accadono dietro le quinte per proteggere l’asset. Quando un’immagine viene catturata, Capture App utilizza l’hardware del dispositivo per raccogliere i metadati, come le firme e le identificazioni, per stabilire il creatore e il contesto.</p>
<p>Seal API è uno strumento per sviluppatori che aiuta gli utenti avanzati a utilizzare facilmente il protocollo Numbers per creare, registrare e recuperare asset nella rete.</p>
<p>Ha un ricco set di API con un’interfaccia amichevole per gli sviluppatori per creare applicazioni dell’ecosistema.</p>
<p>Trace è un sito web per leggere l’iniezione di foto e la storia onchain. Fornisce una visualizzazione cronologica di base delle foto in modo che i lettori possano accedere facilmente alle informazioni di nascita delle foto come chi e quando è stata creata.</p>
<p>I protocolli e gli strumenti sono efficaci solo se utilizzati, pertanto, Numbers Protocol ha costruito applicazioni native per aiutare a stabilire le fondamenta dell’ecosistema e consentire agli utenti di vivere la rete fotografica di prossima generazione.</p>
<p>In futuro, questa rete fotografica può svilupparsi in settori come le notizie, i social media e il gaming grazie ai contributi della comunità di sviluppatori che sfruttano i nostri strumenti e applicazioni!</p>
<h3 id="h3-Q420E20che20dire20del20token20NUM20Cosa20possiamo20farne880744"><a name="Q4: E che dire del token $NUM? Cosa possiamo farne?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q4: E che dire del token $NUM? Cosa possiamo farne?</h3><p><strong>Sofia</strong>: NUM è il token del protocollo nativo di NUMbers Protocol.</p>
<p>È principalmente un token di utilità progettato per incentivare gli utenti a creare, archiviare e verificare contenuti con buona integrità.</p>
<p>La visione di Numbers Protocol è creare un ecosistema in cui le foto (che comprendono sia immagini che video) abbiano importanza, sfruttando prove, registri di integrità e provenienza dei dati per aumentare la credibilità e la legittimità delle foto registrate nella rete.</p>
<p>I partecipanti, come i verificatori e gli altri operatori di rete, possono ottenere ricompense fornendo servizi per aumentare la credibilità e la legittimità delle foto registrate.<br><img src="https://gimg2.gateimg.com/image/article/16892359614.png" alt=""><br>I token $NUM possono anche essere utilizzati per pagare i servizi in esecuzione nella rete fotografica decentralizzata.<br>O visita il nostro Medium per saperne di più!</p>
<h3 id="h3-Q520Quali20sono20i20vantaggi20del20Protocollo20Numbers20rispetto20alla20maggior20parte20dei20progetti20attualmente20presenti20sul20mercato991147"><a name="Q5: Quali sono i vantaggi del Protocollo Numbers rispetto alla maggior parte dei progetti attualmente presenti sul mercato?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q5: Quali sono i vantaggi del Protocollo Numbers rispetto alla maggior parte dei progetti attualmente presenti sul mercato?</h3><p><strong>Sofia</strong>: Il fenomeno del ‘Fare clic con il tasto destro e salvare’ è un grosso problema nelle attuali comunità fotografiche. Le foto nella rete del protocollo Numbers non possono essere acquisite in questo modo.</p>
<p>Come esempio, CaptureClub è un mercato NFT nativo per Numbers Protocol. Gli asset possono essere scaricati solo dopo l’acquisto o l’acquisizione di una licenza.</p>
<p>Inoltre, tutte le foto nella rete del protocollo Numbers hanno certificati di autenticità associati e metadati C2PA incorporati in ogni risorsa. I metadati includono informazioni come creatore, proprietario e altre informazioni contestuali.</p>
<p>Le informazioni incorporate rendono possibile tracciare l’asset stesso.</p>
<div class="blog-details-info"><br><div>Autore: <strong>Rio Fu.</strong>, Comunità Gate.io<br><div class="info-tips"><em>Questo articolo rappresenta solo le opinioni del ricercatore e non costituisce alcun suggerimento di investimento.<br></em><div><em></em>Gate.io si riserva tutti i diritti su questo articolo. La ripubblicazione dell'articolo sarà consentita a condizione che si faccia riferimento a Gate.io. In tutti i casi, saranno intraprese azioni legali a causa di violazioni del copyright.<br></div><p></p><br></div></div></div>