R2F0ZS5pbyBBTUEgY29uIFRlbG9zOiBsYSB0dWEgY2FzYSBwZXIgZXNwZXJpZW56ZSBkaSBnaW9jbyBzaWN1cmUsIHNjYWxhYmlsaSBlIHBvdGVuemlhdGU=

<p><img src="https://gimg2.gateimg.com/image/article/16904384191.jpg" alt=""><br><strong>Ora: 18 novembre 2021, 13:00 UTC</strong><br><strong><a href="https://www.gate.io" target="_blank">Gate.io</a> ha ospitato una sessione AMA (Ask-Me-Anything) con Justin Giudici, Responsabile del Prodotto presso The Telos Foundation nel <a href="https://t.me/gateio" rel="nofollow noopener noreferrer" target="_blank">Comunità di scambio Gate.io</a>.</strong><br><strong>Sito web ufficiale: <a href="https://www.telos.net/" rel="nofollow noopener noreferrer" target="_blank">https://www.telos.net/</a></strong><br><strong>Twitter: <a href="https://twitter.com/HelloTelos" rel="nofollow noopener noreferrer" target="_blank">https://twitter.com/HelloTelos</a></strong><br><strong>Segui Telos su <a href="https://twitter.com/HelloTelos" rel="nofollow noopener noreferrer" target="_blank">Twitter</a> e <a href="https://t.me/HelloTelos" rel="nofollow noopener noreferrer" target="_blank">Telegram</a></strong><br><strong>Ospite</strong><img src="https://gimg2.gateimg.com/image/article/16904386052.png" alt=""><br><strong>Justin Giudici - Responsabile prodotto presso la Fondazione Telos</strong></p>
<h2 id="h2-QampA20da20Gateio367520"><a name="Q&amp;A da Gate.io" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q&amp;A da Gate.io</h2><h3 id="h3-Q120Justin20puoi20parlare20alla20community20di20Telos20e20di20come20si20differenzia20dalle20altre20piattaforme20di20contratti20intelligenti20l20fuori88799"><a name="Q1: Justin, puoi parlare alla community di Telos e di come si differenzia dalle altre piattaforme di contratti intelligenti là fuori?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q1: Justin, puoi parlare alla community di Telos e di come si differenzia dalle altre piattaforme di contratti intelligenti là fuori?</h3><p><strong>Justin</strong>: Telos in termini di posizionamento e prestazioni va a testa a testa e supera persino altre grandi piattaforme di contratti intelligenti.</p>
<p>Abbiamo le transazioni più veloci tra tutte le reti EVM grazie alla nostra TelosEVM e il maggior numero di transazioni al secondo.</p>
<p>Siamo anche l’unico network che offre smart contract in C++ oltre a contratti Solidity/Vyper (EVM).</p>
<p>Abbiamo anche la più bassa impronta di carbonio tra tutte le blockchain in termini di consumo energetico.</p>
<p>Ciò che ci distingue è anche il controllo decentralizzato di Telos. Gli originali fondatori (erano 150) avevano circa il 6% dell’allocazione iniziale della catena.</p>
<p>Il resto è stato distribuito tramite airdrop.<br>Inoltre, non abbiamo fatto alcuna ICO, quindi sotto molti aspetti siamo l’unico importante platform smart contract con un lancio simileish a <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a>.</p>
<p>Anche la Fondazione Telos non ha una grande quantità di token come altre fondazioni. Riceve token distribuiti mensilmente dalla comunità tramite smart contract. Attualmente detiene circa 2 milioni di TLOS sui 355 milioni totali.</p>
<p>Fino ad oggi abbiamo oltre 100 progetti costruiti o basati sulla nostra rete e offriamo indiscutibilmente le migliori prestazioni e decentralizzazione sul mercato odierno. Stiamo cominciando a fare progressi dopo alcune vendite comunitarie più piccole che ci hanno permesso di aumentare la nostra presenza di marketing e iniziare la quotazione su importanti scambi.</p>
<p>Il nostro crescita nell’ultimo anno è stato incredibile.</p>
<h3 id="h3-Q220Telos20sostiene20di20essere20RealWorldReady20puoi20dirci20qualcosa20di20pi20su20cosa20significa20questo219002"><a name="Q2: Telos sostiene di essere #RealWorldReady, puoi dirci qualcosa di più su cosa significa questo?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q2: Telos sostiene di essere #RealWorldReady, puoi dirci qualcosa di più su cosa significa questo?</h3><p><strong>Justin</strong>: Perché le app del mondo reale scelgono Telos!</p>
<p>Esempio: Zeptagram consente il crowdfunding di nuove canzoni/album - permettendo ai musicisti di finanziare la produzione e il marketing della loro musica e consentendo ai fan di possedere una quota e ricavare profitti dalla musica dei loro artisti preferiti.</p>
<p>Vogliamo davvero portare le criptovalute oltre i soli NFT e mooncoin e offrire soluzioni per persone reali.<br><img src="https://gimg2.gateimg.com/image/article/16904386303.jpg" alt=""><br>Abbiamo progetti che stanno tokenizzando asset del mondo reale come immobili, musica e molto altro ancora.</p>
<h3 id="h3-Q320Ora20il20Telos20EVM2020stata20una20importante20release20per20il20tuo20ecosistema20di20recente20puoi20condividere20di20pi20su20questa20emozionante20pietra20miliare627390"><a name="Q3: Ora, il Telos EVM è stata una importante release per il tuo ecosistema di recente, puoi condividere di più su questa emozionante pietra miliare?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q3: Ora, il Telos EVM è stata una importante release per il tuo ecosistema di recente, puoi condividere di più su questa emozionante pietra miliare?</h3><p><strong>Justin</strong>: Sì, naturalmente!</p>
<p>Quindi solo poche settimane fa abbiamo rilasciato il nostro rivoluzionario EVM! Per chi non lo sa, EVM è <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> Macchina virtuale: fondamentalmente è una piattaforma per eseguire una rete <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> basata su smart contract e applicazioni. Binance Smart Chain esegue EVM. <a href="/price/avalanche-avax" rel="nofollow noopener noreferrer" target="_blank">Avalanche</a> esegue un EVM e <a href="/price/fantom-ftm" rel="nofollow noopener noreferrer" target="_blank">Fantom</a> esegue un EVM e ora ovviamente Telos ha il proprio EVM.</p>
<p>La differenza è che Telos ha la migliore performance in termini di scalabilità e velocità delle transazioni. Non abbiamo nemmeno front running.</p>
<p>Telos, avendo la propria EVM, ha anche significato che importanti applicazioni come Sushiswap hanno iniziato a dispiegarsi su Telos (tramite TelosEVM).</p>
<p>Enormi notizie che sono state rilasciate ieri! Speriamo che siano completamente operativi oggi.</p>
<p>Abbiamo già oltre 100 progetti che utilizzano Telos Native c ++.. Ora, con Telos EVM, ci aspettiamo centinaia di nuove dapp nei prossimi mesi.</p>
<p>Il mondo Ethereum è esplosivo - con così tanto software open source disponibile per il deployment. Siamo letteralmente sopraffatti dalla quantità di partner che cercano di deployare in questo momento.</p>
<p>Anyswap è un altro importante partner che è stato implementato ieri. Questo è il ponte numero 1 per TVL e stanno sbloccando tutti i TelosEVM per iniziare l’implementazione (non si può fare DeFi senza gli asset principali come ETH, USDT, ecc).<br><img src="https://gimg2.gateimg.com/image/article/16904386424.jpg" alt=""><br>ecco un altro confronto diretto - solo con gli altri EVM</p>
<h3 id="h3-Q420Con20il20lancio20di20Telos20EVM20in20corso20a20quali20altri20prodotti20o20traguardi20possono20guardare20le20persone20in20futuro138417"><a name="Q4: Con il lancio di Telos EVM in corso, a quali altri prodotti o traguardi possono guardare le persone in futuro?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q4: Con il lancio di Telos EVM in corso, a quali altri prodotti o traguardi possono guardare le persone in futuro?</h3><p><strong>Justin</strong>: Attualmente stiamo rilasciando app dopo app. Anyswap e <a href="/price/sushi-sushi" rel="nofollow noopener noreferrer" target="_blank">Sushi</a> come accennato sono solo l’inizio!<br>👆Questo è una di queste app emozionanti in arrivo.</p>
<p>Telos Punks!</p>
<p>Abbiamo alcune piattaforme di mercato NFT multiple in fase di implementazione sulla nostra rete. Uno di essi proviene da un marchio ben noto nel settore cripto.</p>
<p>Abbiamo così tanto DeFi in arrivo insieme a Sushiswap. Sarei sorpreso se entro la fine dell’anno non avessimo 10 AMM concorrenti.</p>
<p>Quasi quotidianamente rilasceremo nuovi partner.. sfortunatamente non mi è permesso dire troppo su ciò che sta arrivando! (Partner NDA’s)</p>
<p>Magic è uno di quei progetti che è stato annunciato la scorsa settimana.</p>
<p>Elk Finance è stata un’altra.</p>
<p>Abbiamo già avuto alcuni lanci piuttosto grandi annunciati come Starter!</p>
<p>Tutto questo entro le prime 2 settimane.</p>
<p>Quindi, anche se vorrei poter dire di più sul futuro, penso che il recente passato sia stato indicativo.</p>
<p>Per quanto riguarda le implementazioni tecniche, è in arrivo un nuovo esploratore di blocchi per EVM, anche RPC2.0 che espande le funzionalità per gli sviluppatori.</p>
<p>Abbiamo anche ulteriori annunci/partnership per il portafoglio <a href="/web3" target="_blank" class="blog_inner_link">web3</a> e miglioramenti alla compatibilità EVM nel nostro Telos Wallet.</p>
<div class="blog-details-info"><br><div>Autore: <strong>Rio Fu.</strong>, Comunità 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>