R2F0ZS5pbyBBTUEgbWV0IFRvcmFoIC0gJ3Mgd2VyZWxkcyBlZXJzdGUgZ3JvZW5lIGdlZGVjZW50cmFsaXNlZXJkZSBQT0Qtb3BzbGFncHJvdG9jb2w=

2023-01-10, 07:44
<p><img src="https://gimg2.gateimg.com/image/article/1673335981Fg94DZjWQAAw_sa.jpeg" alt=""><br><strong>Tijd: 8 november 2022, 13.00 uur (UTC)</strong><br><strong>Gate.io organiseerde een AMA (vraag me alles) sessie met de mede-oprichter van Torah, Tyler Beaudin bij Gate.io Exchange Community</strong><br><strong>Officiële website: <a href="https://torah.ink/" rel="nofollow noopener noreferrer" target="_blank">https://torah.ink/</a></strong><br><strong>Volg Torah op Twitter, Discord en Telegram</strong></p>
<p><strong>Gast</strong><img src="https://gimg2.gateimg.com/image/article/167333617315.png" alt=""><br><strong>Tyler Beaudin - de mede-oprichter van Torah</strong><br>Ik ben Tyler Beaudin, een ecosysteemontwikkelaar bij Torah. Na mijn afstuderen aan de Kelley School of Business van de Indiana University, heb ik de eerste paar jaar van mijn carrière doorgebracht als analist bij Goldman Sachs. Daarna maakte ik de overstap naar VC-investeringen met een focus op vroege technologische startups. Investeren in technologiebedrijven met een positieve missie is mijn passie en het is hoe ik het Torah-project oorspronkelijk ontdekte! Sindsdien ben ik bij het project gekomen als ecosysteemontwikkelaar.</p>
<h2 id="h2-QampA20van20Gateio491720"><a name="Q&amp;A van Gate.io" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q&amp;A van Gate.io</h2><h3 id="h3-Q120Kunt20u20alstublieft20het20Torahproject20introduceren638115"><a name="Q1: Kunt u alstublieft het Torah-project introduceren?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q1: Kunt u alstublieft het Torah-project introduceren?</h3><p><strong>John</strong>: Torah maakt inactieve servers en intelligente hardware de toegang tot het ecosysteem van Web 3.0-toepassingen! Het Vortex Protocol en het POD-gegevensinteractieconcept van Torah bieden een solide hardware-infrastructuur voor de implementatie van WEB 3.0 door Torah.<br><img src="https://gimg2.gateimg.com/image/article/1673336339截屏2023-01-10 14.20.03.png" alt=""></p>
<h3 id="h3-Q220Wat20zijn20de20voordelen20en20kenmerken20van20gedistribueerde20opslag20in20vergelijking20met20traditionele20gegevensopslag17296"><a name="Q2: Wat zijn de voordelen en kenmerken van gedistribueerde opslag in vergelijking met traditionele gegevensopslag?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q2: Wat zijn de voordelen en kenmerken van gedistribueerde opslag in vergelijking met traditionele gegevensopslag?</h3><p><strong>John</strong>: Naar mijn mening komen de voordelen van gedistribueerde opslag voornamelijk tot uiting in drie aspecten: ten eerste, veiligheid, ten tweede, efficiëntie (kosten en waarde), en ten derde, de compatibiliteit van ecologische toepassingen.</p>
<p>Laten we het nu hebben over Torah: Op dit moment gaat de technologische vooruitgang behoorlijk snel en groeien het aantal en de prestaties van intelligente hardware om ons heen snel.</p>
<p>Als moderne mensen weten we misschien hoe we deze hardware moeten gebruiken, maar we realiseren ons misschien niet dat er wat rekenkracht verborgen zit in deze slimme hardware, en deze rekenkracht is al die tijd ongebruikt gebleven.</p>
<p>Mensen die in aanraking zijn gekomen met blockchain hebben misschien wel gehoord van het concept van het meta-universum, maar in feite zouden mensen die een diepgaand begrip hebben van het meta-universum moeten weten dat het huidige meta-universum nog in een zeer vroeg stadium verkeert, en een van de belangrijkste factoren die de ontwikkeling ervan belemmeren is de beperking van rekenkracht.</p>
<p>Het metaversum heeft enorme rekenkracht nodig, die niet kan worden geleverd door een centrale organisatie. Daarom, als we echt vooruitgang willen boeken in de toekomst, kan de hardware van elke gebruiker betrokken zijn.</p>
<p>Daarom heeft hardware altijd een zeer belangrijke positie ingenomen in het concept van de Torah. Als je gebruik kunt maken van de ongebruikte hardwarebronnen in je handen, bijdragen kunt leveren aan de ontwikkeling van de Metauniversum en Web3, en tegelijkertijd wat beloningen kunt krijgen, zal dit een vicieuze cirkel vormen.</p>
<p>Tegelijkertijd zal het hergebruik van ongebruikte bronnen ook van groot belang zijn voor energiebesparing en milieubescherming. Dit is ook het verschil tussen Torah en traditionele mijnbouw. Het kan deze ongebruikte intelligente hardware gebruiken via twee kerntechnologieën.</p>
<p>Het eerste is het gedistribueerde databasesysteem dat we zojuist hebben genoemd, namelijk FDB;</p>
<p>De tweede technologie heet FMS, wat een Internet of Things technologie is. Hiermee kunnen alle intelligente hardware van de gebruiker direct worden verbonden om rekenondersteuning te bieden.</p>
<p>Met de combinatie van deze twee technologieën kan Torah een groot aantal ongebruikte rekenbronnen centraliseren en ondersteuning bieden voor veel toepassingen via gedistribueerde databases.</p>
<p>Via Torah kunnen gewone gebruikers bijvoorbeeld hun inactieve bronnen gebruiken om rekenkracht bij te dragen aan de onderliggende servers van Twitter of Facebook. In dit proces zullen mensen ook dividenden ontvangen van Twitter of Facebook.</p>
<p>Dit bevordert niet alleen het recyclen van ongebruikte middelen, maar verbindt ook gewone gebruikers met grote bedrijven, wat in zekere mate overeenkomt met het concept van Web3.</p>
<p>Daarom zijn we er ook vast van overtuigd dat we een nieuw Web3-tijdperk kunnen creëren door volledig gebruik te maken van de inactieve hardware van mensen via Torah.</p>
<h3 id="h3-Q320Als20het20gaat20om20de20gedistribueerde20opslag20track20denk20je20altijd20aan20de20populaire20filecoin20Wat20zijn20de20verschillen20en20voordelen20tussen20Torah20en20hen148943"><a name="Q3: Als het gaat om de gedistribueerde opslag track, denk je altijd aan de populaire filecoin. Wat zijn de verschillen en voordelen tussen Torah en hen?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q3: Als het gaat om de gedistribueerde opslag track, denk je altijd aan de populaire filecoin. Wat zijn de verschillen en voordelen tussen Torah en hen?</h3><p><strong>John</strong>: Er zijn veel projecten op het spoor van gedistribueerde opslag. De meest bekende is IPFS, voornamelijk gedistribueerde bestandsopslag. Tora richt zich op gedistribueerde gegevensopslag. Vergeleken met IPFS zijn de belangrijkste voordelen van Torah voornamelijk onderverdeeld in de volgende aspecten<br>De eerste zijn de kosten. De investering van <a href="/price/filecoin-fil" target="_blank" class="blog_inner_link">Filecoin</a> in mechanische hardware is enorm. Als gebruikers eraan willen deelnemen, moeten ze investeren in veel harde schijven. Maar de Tora is anders dan zij. Het maakt voornamelijk gebruik van inactieve hardwarebronnen van mensen, zoals thuiscomputers en inactieve harde schijven. Dit betekent dat als mensen willen deelnemen aan de Tora, ze een deel van de ongebruikte hulpbronnen kunnen recyclen zonder enige extra investering.<br>Ten tweede, in termen van de operationele drempel, heeft Torah de laagste operationele moeilijkheidsgraad en hoeft het Linux-systeem zoals IPFS niet te gebruiken.<br>Bovendien nemen Filecoin en <a href="/price/chia-xch" target="_blank" class="blog_inner_link">Chia</a> beide PoS-rechten en rentebestendige mechanismen over. Torah, aan de andere kant, keurt het PoD-mechanisme voor gegevensinteractie goed, dat meer de nadruk legt op gegevensconnectiviteit tussen gedistribueerde gegevensopslagplaatsen. Daarom zijn Filecoin en Chia heel anders dan het stimuleringsmechanisme (mining-methode) van de Torah.<br>Het is de moeite waard om te benadrukken dat er economische modellen zijn in de ecoen van Filecoin en Torah (Chia heeft geen economisch model). Het economische model van de Tora is echter duidelijk voordeliger.<br>Filecoin bestaat tot nu toe ongeveer 7 jaar en de technologie of het concept zal onvermijdelijk achterblijven. De Tora is in de afgelopen jaren geboren en de technologie en filosofie zijn ook de nieuwste. Bovendien zijn op dit moment het gebruik van ongebruikte hulpbronnen, het economische model en de prijsprestaties van de valuta door de Tora in een goede staat.<br>Natuurlijk, dankzij het leren van Filecoin, Ethereum, <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> en andere voorgangers kon de Thora overmatige hardware-investeringen, een hoge technische drempel en enkele relatief onredelijke economische modellen vermijden. Het belangrijkste is dat het grootste kenmerk van de Thora zijn gedistribueerde database is, die grote voordelen heeft op applicatieniveau. Het kan gezegd worden dat ik uitkijk naar de prestaties van de Thora in de ecologische sector. Natuurlijk hebben ze nu spellen gelanceerd die vergelijkbaar zijn met het niveau van LOL, waarover je kunt lezen op de officiële website of Twitter van de Thora. Bij de analyse van een project is de ecologie van het project een zeer belangrijke overweging. Of het voldoende ecologie heeft, of het kan worden geïmplementeerd en of het beter ontwikkelingspotentieel heeft, zijn belangrijke criteria.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1673336379截屏2023-01-10 14.23.01.png" alt=""></p>
<h3 id="h3-Hoe20wordt20de20ecologische20toepassing20van20Torahs20gesloten20kringloop20ingezet793377"><a name="Hoe wordt de ecologische toepassing van Torah’s gesloten kringloop ingezet?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Hoe wordt de ecologische toepassing van Torah’s gesloten kringloop ingezet?</h3><p><strong>John</strong>: Op dit moment kan de Tora eigenlijk worden beschouwd als een onderliggend protocol. De voordelen van de onderliggende technologie liggen voor de hand. Het is zeer solide, betrouwbaar en geworteld. Torah combineert gedistribueerde gegevensopslag en Internet of Things-technologie, waarbij volledig gebruik wordt gemaakt van de intelligente hardware en servers aan de voorkant. De Tora heeft een nieuwe ecologie ontwikkeld.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1673336395截屏2023-01-10 14.21.34.png" alt=""></p>
<h3 id="h3-V520Kunt20u20ons20alstublieft20vertellen20wat20het20economische20model20en20de20empowerment20van20de20VP20is417016"><a name="V5: Kunt u ons alstublieft vertellen wat het economische model en de empowerment van de VP is?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>V5: Kunt u ons alstublieft vertellen wat het economische model en de empowerment van de VP is?</h3><p><strong>John</strong>: VP is de kern en het enige token van de Torah, met een totaal van 102,4 miljoen tokens. Maar deze tokens kunnen niet in een dag worden opgegraven. Volgens het officiële plan zal 90% van hen over 40 jaar worden geproduceerd en zal de productie elk jaar afnemen.<br>De kern van de Tora is eigenlijk een technologie die gebaseerd is op gedistribueerde gegevensopslag. Het beloningsmechanisme is anders dan PoS- en PoW-mining. Daarom kan worden gezegd dat de eerste drie jaar de gouden periode zijn voor de Tora-mijnbouw.<br>Op dit moment is het aantal wereldwijde knooppunten van de Tora ongeveer 24000. In de officiële planning van de Tora, wanneer het aantal wereldwijde knooppunten meer dan 100000 bereikt, zal Tora een onafhankelijke openbare keten lanceren.<br>Het huidige aantal wereldwijde adressen van de Tora is ongeveer 30942, en het aantal wereldwijde overdrachten is ongeveer 106000. Op dit moment is het aantal knooppunten in het hele netwerk ongeveer 24000, en elk knooppunt betekent een server. Met de toevoeging van steeds meer servers en intelligente hardware zullen de dataknooppunten van Torah sterker worden.<br>Ten tweede heeft de Tora een redelijk perfect economisch model. Vergeleken met Filecoin is het economische model van de Torah beter.</p>
<ol>
<li>Aangezien TORAH inactieve desktopcomputers kan gebruiken om deel te nemen, heeft Torah meer voordelen in de kosten van hardwaremachines. Bovendien is de periode voor de gelofte van de Tora 390 dagen. Na de vervaldatum kan het worden teruggenomen, wat gelijk staat aan een consensusprijs.</li><li>In termen van na de toezegging, binnen de eerste vijf maanden van de toezegging, kan Tora op elk moment 20% van de toegezegde tokens opnemen, zonder limiet op het aantal keren. Dit betekent dat gebruikers zelfs alle toegezegde tokens binnen één dag kunnen indienen. IPFS vereist een lineaire afgifte van maximaal 180 dagen en de cyclus is relatief lang.</li></ol>
<p>De meeste vroege deelnemers van Torah zijn instellingen en particuliere beleggers die hardware hebben en willen deelnemen aan de bouw van Web3. Echter, omdat Torah alleen normale bandbreedte, prestaties en voeding vereist, hoeven gebruikers niet te veel te investeren in hardware en is de kern ervan groen.</p>
<p>Torah zal zich in november en december aanmelden bij grote beurzen, zoals gate, Kucoin, HUOBI, enz., En ecologische toepassingen lanceren met TORAH als onderliggende technologie, die achtereenvolgens zullen worden gelanceerd. Op dit moment zijn er veel goede informatie en welzijnsactiviteiten op de Twitter en DISCORD van TORAH, dus let op en mis ze niet!</p>
<p>Op dit moment heeft Torah 24000 knooppunten in de wereld, wat gelijk staat aan tienduizenden services die over de hele wereld zijn gedistribueerd. Deze ongebruikte hardwarebronnen bieden geweldige rekenkracht-ondersteuning voor de verdere implementatie van Web 3.0!</p>
<p>Op basis van milieubescherming is het een zeer betekenisvolle zaak om thuiscomputers en servers die niet worden gebruikt in IDC-machineruimten een grotere rol te laten spelen. U kunt meer leren over Torah op de officiële website van 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>Auteur:<strong> Rio Fu.</strong>, Gate.io Community<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de mening van de onderzoeker en vormt geen beleggingsadvies.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Het opnieuw plaatsen van het artikel zal worden toegestaan mits Gate.io wordt vermeld. In alle glen zal juridische actie worden ondernomen vanwege inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div>
Share
gate logo
Gate
Trade Now
Join Gate to Win Rewards