R2F0ZS5pbyBBTUEgY29uIFRvcmFoIC0gSWwgcHJpbW8gcHJvdG9jb2xsbyBkaSBhcmNoaXZpYXppb25lIFBPRCBkZWNlbnRyYWxpenphdG8gZSB2ZXJkZSBhbCBtb25kbw==

<p><img src="https://gimg2.gateimg.com/image/article/1673335981Fg94DZjWQAAw_sa.jpeg" alt=""><br><strong>Ora: 8 novembre 2022, 13:00 (UTC)</strong><br><strong>Gate.io ha ospitato una sessione AMA (Ask-Me-Anything) con il Co-Fondatore di Torah, Tyler Beaudin presso la Comunità di Gate.io Exchange</strong><br><strong>Sito Web Ufficiale: <a href="https://torah.ink/" rel="nofollow noopener noreferrer" target="_blank">https://torah.ink/</a></strong><br><strong>Segui Torah su Twitter, Discord e Telegram</strong></p>
<p><strong>Ospite</strong><img src="https://gimg2.gateimg.com/image/article/167333617315.png" alt=""><br><strong>Tyler Beaudin - il co-fondatore di Torah</strong><br>Sono Tyler Beaudin, uno sviluppatore di ecosistemi presso Torah. Dopo essermi laureato alla Kelley School of Business dell’Università dell’Indiana, ho continuato a trascorrere i primi anni della mia carriera come analista presso Goldman Sachs. Successivamente, sono passato agli investimenti in VC con particolare attenzione alle startup tecnologiche in fase iniziale. Investire in aziende tecnologiche con una missione positiva è la mia passione, ed è così che ho scoperto il Progetto Torah! Da allora mi sono unito al progetto come sviluppatore di ecosistemi.</p>
<h2 id="h2-Domande20e20risposte20da20Gateio279596"><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-Q120Potresti20presentare20il20progetto20Torah459597"><a name="Q1: Potresti presentare il progetto Torah?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q1: Potresti presentare il progetto Torah?</h3><p><strong>John</strong>: La Torah rende i server inattivi e l’hardware intelligente l’ingresso nell’ecosistema delle applicazioni Web 3.0! Il protocollo Vortex di Torah e il concetto di interazione dei dati POD forniscono una solida infrastruttura hardware per l’implementazione del WEB 3.0 da parte di Torah.<br><img src="https://gimg2.gateimg.com/image/article/1673336339截屏2023-01-10 14.20.03.png" alt=""></p>
<h3 id="h3-Q220Quali20sono20i20vantaggi20e20le20caratteristiche20dello20storage20distribuito20rispetto20allo20storage20dati20tradizionale325961"><a name="Q2: Quali sono i vantaggi e le caratteristiche dello storage distribuito rispetto allo storage dati tradizionale?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q2: Quali sono i vantaggi e le caratteristiche dello storage distribuito rispetto allo storage dati tradizionale?</h3><p><strong>Giovanni</strong>: A mio parere, i vantaggi dello storage distribuito sono principalmente riflessi in tre aspetti: primo, sicurezza; secondo, efficienza (costo e valore); terzo, la compatibilità delle applicazioni ecologiche.</p>
<p>Ora parliamo di Torah: Attualmente, la velocità del progresso tecnologico è piuttosto veloce, e il numero e le prestazioni dell’hardware intelligente intorno a noi stanno crescendo rapidamente.</p>
<p>Come persone moderne, potremmo sapere come utilizzare queste apparecchiature, ma potremmo non rendere conto che c’è una certa potenza di calcolo nascosta in queste apparecchiature intelligenti e questa potenza di calcolo è rimasta inattiva.</p>
<p>Le persone che hanno contattato la blockchain potrebbero aver sentito parlare del concetto di meta universo, ma in realtà, le persone che hanno una profonda comprensione del meta universo dovrebbero sapere che l’attuale meta universo è ancora in una fase molto iniziale e uno dei principali fattori che ne ostacolano lo sviluppo è la limitazione della potenza di calcolo.</p>
<p>L’universo meta ha bisogno di una grande potenza di calcolo, che non può essere fornita da alcuna organizzazione centrale. Pertanto, se vogliamo davvero fare buoni progressi in futuro, potrebbe essere coinvolto l’hardware di ogni utente.</p>
<p>Pertanto, nel concetto della Torah, l’hardware è sempre stato in una posizione estremamente importante. Se puoi sfruttare le risorse hardware inutilizzate tra le tue mani, contribuire allo sviluppo del Metauniverso e del <a href="/web3" target="_blank" class="blog_inner_link">Web3</a> e nel frattempo ottenere alcune ricompense, si formerà un circolo virtuoso.</p>
<p>Nel frattempo, questo tipo di riutilizzo delle risorse inutilizzate avrà anche un grande significato per il risparmio energetico e la protezione dell’ambiente. Questa è anche la differenza tra Torah e l’estrazione mineraria tradizionale. Può utilizzare queste risorse intelligenti inutilizzate attraverso due tecnologie principali.</p>
<p>Il primo è il sistema di database distribuito che abbiamo appena menzionato, ovvero FDB;</p>
<p>La seconda tecnologia si chiama FMS, che è una tecnologia Internet delle cose. Può connettere direttamente tutto l’hardware intelligente dell’utente per fornire supporto informatico.</p>
<p>Con la combinazione di queste due tecnologie, la Torah può centralizzare un gran numero di risorse informatiche inattive e fornire supporto per molte applicazioni attraverso database distribuiti.</p>
<p>Ad esempio, attraverso Torah, gli utenti comuni possono utilizzare le loro risorse inutilizzate per contribuire alla potenza di calcolo dei server sottostanti di Twitter o Facebook. In questo processo, le persone riceveranno anche dividendi da Twitter o Facebook.</p>
<p>Questo non solo promuove il riciclaggio delle risorse inutilizzate, ma lega anche gli utenti ordinari con le grandi imprese, il che in una certa misura coincide con il concetto di Web3.</p>
<p>Pertanto, crediamo fermamente che possiamo creare una nuova era Web3 sfruttando appieno l’hardware inattivo delle persone attraverso la Torah.</p>
<h3 id="h3-Q320Quando20si20tratta20del20percorso20di20archiviazione20distribuita20penserai20sempre20al20popolare20filecoin20Quali20sono20le20differenze20e20i20vantaggi20tra20la20Torah20e20loro991208"><a name="Q3: Quando si tratta del percorso di archiviazione distribuita, penserai sempre al popolare filecoin. Quali sono le differenze e i vantaggi tra la Torah e loro?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q3: Quando si tratta del percorso di archiviazione distribuita, penserai sempre al popolare filecoin. Quali sono le differenze e i vantaggi tra la Torah e loro?</h3><p><strong>John</strong> Ci sono molti progetti sulla pista di archiviazione distribuita. Quello più famoso è IPFS, principalmente per l’archiviazione di file distribuiti. Torah si concentra sull’archiviazione di dati distribuiti. Rispetto a IPFS, i vantaggi principali di Torah sono principalmente divisi nei seguenti aspetti. In primo luogo, il costo. L’investimento di <a href="/price/filecoin-fil" target="_blank" class="blog_inner_link">Filecoin</a> nell’hardware meccanico è enorme. Se gli utenti vogliono partecipare, devono investire in molti dischi rigidi. Ma Torah è diverso da loro. Utilizza principalmente le risorse hardware inutilizzate delle persone, come i computer domestici e i dischi rigidi inutilizzati. Ciò significa che se le persone vogliono partecipare a Torah, possono riciclare alcune risorse inutilizzate senza alcun investimento aggiuntivo. In secondo luogo, in termini di soglia operativa, Torah ha la difficoltà operativa più bassa e non ha bisogno di utilizzare il sistema Linux come IPFS. Inoltre, Filecoin e <a href="/price/chia-xch" target="_blank" class="blog_inner_link">Chia</a> adottano entrambi meccanismi di prova dei diritti e degli interessi PoS. Torah, d’altra parte, adotta il meccanismo di prova dell’interazione dei dati PoD, che enfatizza di più la connettività dei dati tra i negozi di dati distribuiti. Pertanto, Filecoin e Chia sono molto diversi dal meccanismo di incentivi di Torah (metodo di mining). Vale la pena sottolineare che ci sono modelli economici negli ecosistemi di Filecoin e Torah (Chia non ha un modello economico). Tuttavia, il modello economico di Torah è ovviamente più vantaggioso. Filecoin esiste da circa 7 anni e la sua tecnologia o concetto inevitabilmente saranno indietro. Torah è nato negli ultimi anni e la sua tecnologia e filosofia sono anche le ultime. Inoltre, al momento attuale, l’utilizzo delle risorse inutilizzate, il modello economico e le prestazioni del prezzo della valuta di Torah sono in uno stato buono. Naturalmente, grazie al suo apprendimento da Filecoin, Ethereum, … <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> e altri predecessori, Torah è stata in grado di evitare investimenti hardware eccessivi, un’elevata soglia tecnica e alcuni modelli economici relativamente irragionevoli.<br>La cosa più importante è che la più grande caratteristica della Torah è il suo database distribuito, che ha grandi vantaggi a livello di applicazione. Si può dire che nel settore ecologico, non vedo l’ora di vedere l’esecuzione della Torah. Naturalmente, al momento, hanno lanciato giochi simili al livello LOL, che puoi imparare dal sito Web ufficiale della Torah o da Twitter.<br>Quando analizziamo un progetto, l’ecologia del progetto è una preoccupazione molto importante. Se ha abbastanza ecologia, se può essere attuato e se ha un migliore potenziale di sviluppo sono criteri importanti.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1673336379截屏2023-01-10 14.23.01.png" alt=""></p>
<h3 id="h3-D420Come20viene20implementata20lapplicazione20ecologica20della20Torah20a20ciclo20chiuso919944"><a name="D4: Come viene implementata l’applicazione ecologica della Torah a ciclo chiuso?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>D4: Come viene implementata l’applicazione ecologica della Torah a ciclo chiuso?</h3><p><strong>John</strong>: Al momento, Torah può effettivamente essere considerata come un protocollo sottostante. I vantaggi della tecnologia sottostante sono evidenti. È molto solida, affidabile e radicata. Torah combina archiviazione dati distribuita e tecnologia Internet of Things, sfruttando appieno l’hardware intelligente front-end e i server. Torah ha sviluppato una nuova ecologia.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1673336395截屏2023-01-10 14.21.34.png" alt=""></p>
<h3 id="h3-Q520Puoi20per20favore20dirci20qual2020il20modello20economico20e20lempowerment20del20VP790192"><a name="Q5: Puoi per favore dirci qual è il modello economico e l’empowerment del VP?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q5: Puoi per favore dirci qual è il modello economico e l’empowerment del VP?</h3><p><strong>John</strong>: VP è il token principale ed unico di Torah, con un totale di 102,4 milioni di token. Ma questi token non possono essere estratti in un solo giorno. Secondo il piano ufficiale, il 90% di essi verrà prodotto in 40 anni e la produzione diminuirà ogni anno.<br>Il nucleo di Torah è effettivamente una tecnologia basata sulla memorizzazione dati distribuita. Il suo meccanismo di ricompensa è diverso dal mining PoS e PoW. Pertanto, i primi tre anni possono essere considerati il periodo d’oro per il mining di Torah.<br>Attualmente, il numero di nodi globali di Torah è di circa 24000. Nel piano ufficiale di Torah, quando il numero di nodi globali raggiunge più di 100000, Torah lancerà una catena pubblica indipendente.<br>Il numero attuale di indirizzi globali di Torah è di circa 30942 e il numero di trasferimenti globali è di circa 106000. Attualmente, il numero di nodi in tutta la rete è di circa 24000, e ogni nodo rappresenta un server. Con l’aggiunta di sempre più server e hardware intelligenti, i nodi dati di Torah diventeranno sempre più forti.<br>In secondo luogo, Torah ha un modello economico abbastanza perfetto. Rispetto a Filecoin, il modello economico di Torah è migliore.</p>
<ol>
<li>Poiché TORAH può utilizzare computer desktop inutilizzati per partecipare, Torah ha maggiori vantaggi nel costo delle macchine hardware. Inoltre, il periodo di pre-impegno di Torah è di 390 giorni. Dopo la scadenza, può essere ripreso, il che equivale a un premio di consenso.</li><li>In termini di post-impegno, entro i primi cinque mesi dell’impegno, Torah può ritirare il 20% dei token impegnati in qualsiasi momento, senza limiti sul numero di volte. Ciò significa che gli utenti possono addirittura inviare tutti i token impegnati entro un solo giorno. IPFS richiede una distribuzione lineare fino a 180 giorni, e il suo ciclo è relativamente lungo.</li></ol>
<p>La maggior parte dei primi partecipanti alla Torah sono istituzioni e investitori al dettaglio che hanno hardware e vogliono partecipare alla costruzione del Web3. Tuttavia, poiché la Torah richiede solo larghezza di banda, prestazioni e alimentazione normali, gli utenti non dovranno investire troppo in hardware e il suo nucleo è verde.</p>
<p>Torah si collegherà a grandi exchange a novembre e dicembre, come gate, Kucoin, HUOBI, ecc., e lancerà applicazioni ecologiche con TORAH come tecnologia sottostante, che saranno lanciate in successione. Al momento, ci sono molte buone attività di informazione e benessere su Twitter e DISCORD di TORAH, quindi puoi mantenere la tua attenzione e non perderle!</p>
<p>Al momento, Torah ha 24000 nodi nel mondo, che equivale a decine di migliaia di servizi distribuiti in tutto il mondo. Queste risorse hardware inutilizzate forniscono un grande supporto di risorse di calcolo per l’ulteriore implementazione di Web 3.0!</p>
<p>Sulla base della protezione dell’ambiente, è una causa molto significativa permettere ai computer domestici inutilizzati e ai server nelle sale macchine IDC di svolgere un ruolo più importante. Puoi saperne di più su Torah sul sito ufficiale di Torah: <a href="https://torah.ink/" rel="nofollow noopener noreferrer" target="_blank">https://torah.ink/</a>.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1673336411截屏2023-01-10 14.24.22.png" alt=""></p>
<div class="blog-details-info"><br><div>Autore: <strong>Rio Fu.</strong>, Community di 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 della violazione del copyright.<br></div><p></p><br></div></div></div>