R2F0ZS5pbyBBTUEgbWV0IFRlbG9zLUpvdXcgdGh1aXNiYXNpcyB2b29yIHZlaWxpZ2UsIHNjaGFhbGJhcmUgZW4gc3VwZXJjaGFyZ2VkIGdhbWluZ2VydmFyaW5nZW4=

<p><img src="https://gimg2.gateimg.com/image/article/16904384191.jpg" alt=""><br><strong>Tijd: 18 november 2021, 13:00 UTC</strong><br><strong><a href="https://www.gate.io" target="_blank">Gate.io</a> organiseerde een AMA (Ask-Me-Anything) sessie met Justin Giudici, Hoofd Product bij The Telos Foundation in de <a href="https://t.me/gateio" rel="nofollow noopener noreferrer" target="_blank">Gate.io Exchange Gemeenschap</a>.</strong><br><strong>Officiële Website: <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>Volg Telos op <a href="https://twitter.com/HelloTelos" rel="nofollow noopener noreferrer" target="_blank">Twitter</a> en <a href="https://t.me/HelloTelos" rel="nofollow noopener noreferrer" target="_blank">Telegram</a></strong><br><strong>Gast</strong><img src="https://gimg2.gateimg.com/image/article/16904386052.png" alt=""><br><strong>Justin Giudici - Hoofd van Product bij The Telos Foundation</strong></p>
<h2 id="h2-Vraag20en20antwoord20van20Gateio821622"><a name="Vraag en antwoord van Gate.io" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Vraag en antwoord van Gate.io</h2><h3 id="h3-Q120Justin20kun20je20de20gemeenschap20vertellen20over20Telos20en20hoe20het20zich20onderscheidt20van20andere20smart20contractplatforms20daarbuiten276034"><a name="Q1: Justin, kun je de gemeenschap vertellen over Telos en hoe het zich onderscheidt van andere smart contract-platforms daarbuiten?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q1: Justin, kun je de gemeenschap vertellen over Telos en hoe het zich onderscheidt van andere smart contract-platforms daarbuiten?</h3><p><strong>Justin</strong>: Telos qua positionering en prestaties gaat de strijd aan en overtreft zelfs andere grote smart contract platforms.</p>
<p>We hebben de snelste transacties van elk EVM-netwerk met onze TelosEVM en de meeste transacties per seconde.</p>
<p>We zijn ook het enige netwerk dat C++ slimme contracten aanbiedt, evenals Solidity/Vyper (EVM) contracten.</p>
<p>We hebben ook de kleinste ecologische voetafdruk van alle blockchains wat betreft energieverbruik.</p>
<p>Wat ons ook onderscheidt, is hoe gedecentraliseerde controle over Telos is. De oorspronkelijke oprichters (er waren er 150) deelden ongeveer 6% van de oorspronkelijke toewijzing van de keten.</p>
<p>De rest werd airdropped<br>We hebben ook geen ICO gedaan, dus in veel opzichten zijn wij het enige belangrijke smart contractplatform met een lancering die enigszins vergelijkbaar is met <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a>.</p>
<p>Zelfs de Telos Foundation heeft geen grote holdings zoals andere stichtingen ook.. Het wordt maandelijks verdeeld tokens door de gemeenschap via een smart contract.. Het houdt momenteel ongeveer 2m van de in totaal 355m TLOS.</p>
<p>Tot op heden hebben we meer dan 100 projecten gebouwd of gebouwd op ons netwerk en bieden we mogelijk de hoogste prestaties en decentralisatie op de markt van vandaag. We zijn begonnen terrein te winnen na een aantal kleinere gemeenschapverkopen, die ons in staat hebben gesteld onze marketingaanwezigheid te vergroten en te beginnen met het vermelden op grote beurzen.</p>
<p>Onze groei van het afgelopen jaar is ongelooflijk geweest.</p>
<h3 id="h3-Q220Telos20beweert20RealWorldReady20te20zijn20kunt20u20ons20iets20meer20vertellen20over20wat20dit20betekent977767"><a name="Q2: Telos beweert #RealWorldReady te zijn, kunt u ons iets meer vertellen over wat dit betekent?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q2: Telos beweert #RealWorldReady te zijn, kunt u ons iets meer vertellen over wat dit betekent?</h3><p><strong>Justin</strong>: Omdat Real World-apps kiezen voor telos!</p>
<p>Voorbeeld: Zeptagram maakt crowdfunding van nieuwe nummers/albums mogelijk - waardoor muzikanten de productie en marketing van hun muziek kunnen financieren en fans een aandeel en inkomsten van de muziek van hun favoriete artiesten kunnen bezitten.</p>
<p>We willen echt verder gaan dan alleen NFT’s en mooncoins en oplossingen bieden voor echte mensen.<br><img src="https://gimg2.gateimg.com/image/article/16904386303.jpg" alt=""><br>We hebben projecten die echte wereldactiva tokeniseren zoals onroerend goed, muziek, en nog veel meer.</p>
<h3 id="h3-Q320Nu20was20de20Telos20EVM20onlangs20een20belangrijke20release20voor20jouw20ecosysteem20kun20je20meer20delen20over20deze20spannende20mijlpaal578273"><a name="Q3: Nu was de Telos EVM onlangs een belangrijke release voor jouw ecosysteem, kun je meer delen over deze spannende mijlpaal?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q3: Nu was de Telos EVM onlangs een belangrijke release voor jouw ecosysteem, kun je meer delen over deze spannende mijlpaal?</h3><p><strong>Justin</strong> Ja, natuurlijk!</p>
<p>Dus slechts enkele weken geleden hebben we onze baanbrekende EVM uitgebracht! Voor degenen die het niet weten, EVM staat voor <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> Virtuele Machine - Het is in feite een platform voor het draaien van een op <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> gebaseerd netwerk van slimme contracten en applicaties. Binance Smart Chain draait EVM, <a href="/price/avalanche-avax" rel="nofollow noopener noreferrer" target="_blank">Avalanche</a> draait een EVM, en <a href="/price/fantom-ftm" rel="nofollow noopener noreferrer" target="_blank">Fantom</a> draait een EVM en nu heeft Telos natuurlijk zijn eigen EVM.</p>
<p>Het verschil is dat Telos de beste prestaties heeft op het gebied van schaalbaarheid en transactiesnelheid. We hebben ook geen front running.</p>
<p>Doordat Telos zijn eigen EVM heeft, zijn ook belangrijke applicaties zoals Sushiswap begonnen met implementeren op Telos (via TelosEVM).</p>
<p>Enorm nieuws dat gisteren is vrijgegeven! Hopelijk zijn ze vandaag volledig operationeel.</p>
<p>We hebben al meer dan 100 projecten die gebruik maken van Telos Native c++.. Nu met Telos EVM verwachten we de komende maanden honderden nieuwe dapps.</p>
<p>De Ethereum-wereld is explosief - met zoveel open source software beschikbaar om te implementeren. We worden letterlijk overweldigd door de hoeveelheid partners die nu willen implementeren.</p>
<p>Anyswap is een andere belangrijke partner die gisteren is ingezet. Dit is de nummer 1 brug op basis van TVL en ze ontgrendelen alle TelosEVM om te beginnen met implementeren (je kunt geen DeFi doen zonder de belangrijkste activa zoals ETH, USDT, enz.).<br><img src="https://gimg2.gateimg.com/image/article/16904386424.jpg" alt=""><br>Hier is nog een vergelijking - alleen met de andere EVM’s</p>
<h3 id="h3-Q420Met20de20lancering20van20Telos20EVM20gaande20waar20kunnen20mensen20in20de20toekomst20naar20uitkijken20qua20andere20producten20of20mijlpalen281168"><a name="Q4: Met de lancering van Telos EVM gaande, waar kunnen mensen in de toekomst naar uitkijken qua andere producten of mijlpalen?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q4: Met de lancering van Telos EVM gaande, waar kunnen mensen in de toekomst naar uitkijken qua andere producten of mijlpalen?</h3><p><strong>Justin</strong> We zijn momenteel app na app aan het lanceren. Anyswap en <a href="/price/sushi-sushi" rel="nofollow noopener noreferrer" target="_blank">Sushi</a> zoals vermeld zijn slechts het begin!<br>👆Dit is een van die spannende apps die eraan komt.</p>
<p>Telos Punks!</p>
<p>We hebben enkele verschillende NFT-marktplaatsen die worden ingezet op ons netwerk. Een daarvan is van een bekend merk in crypto.</p>
<p>We hebben zoveel DeFi dat naast Sushiswap komt. Ik zou verrast zijn als we aan het einde van het jaar geen 10 concurrerende AMM’s hebben.</p>
<p>Bijna dagelijks zullen we nieuwe partners ontketenen.. helaas mag ik niet te veel zeggen over wat er aan zit te komen! (Partner NDA’s)</p>
<p>Magic is een project dat vorige week is aangekondigd.</p>
<p>Elk Finance was een ander.</p>
<p>We hebben al enkele behoorlijk grote lanceringen aangekondigd, zoals Starter!</p>
<p>Dit alles binnen de eerste 2 weken.</p>
<p>Hoewel ik graag meer zou willen zeggen over de toekomst, denk ik dat het recente verleden indicatief is geweest.</p>
<p>Op het gebied van technische implementaties is er een nieuwe block explorer voor EVM onderweg, ook RPC2.0 die functies voor ontwikkelaars uitbreidt.</p>
<p>We hebben ook verdere web3-portemonnee aankondigingen/partnerschappen en verbeteringen van EVM-compatibiliteit in onze eigen Telos Wallet.</p>
<div class="blog-details-info"><br><div>Auteur: <strong>Rio Fu.</strong>, Gate.io Gemeenschap<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de standpunten van de onderzoeker en vormt geen enkele beleggingssuggestie.<br></em><div><em></em>Gate.io behoudt alle rechten voor op dit artikel. Het opnieuw plaatsen van het artikel is toegestaan mits Gate.io wordt vermeld. In alle glen zal juridische actie worden ondernomen wegens schending van het auteursrecht.<br></div><p></p><br></div></div></div>