R2F0ZS5pbyBBTUEgbWV0IERDUk4tQSBFZW4gbWVlciBwcm9ncmVzc2lldmUgZW4gZ2ViYWxhbmNlZXJkZSBjcnlwdG9jdXJyZW5jeSBiZXN0dXVyZCBkb29yIGRlIGdlbWVlbnNjaGFw

<p><img src="https://gimg2.gateimg.com/image/article/16790436011.jpg" alt=""><br><strong>Tijd: 21 oktober 2022, 11:00 UTC</strong><br><strong><a href="https://www.gate.io" target="_blank">Gate.io</a> hield een AMA (Ask-Me-Anything) sessie met Stephanie Lee, Community Manager bij DCRN 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://dcrn.xyz/home" rel="nofollow noopener noreferrer" target="_blank">https://dcrn.xyz/home</a></strong></p>
<p><strong>Twitter: <a href="https://twitter.com/Decred_Next" rel="nofollow noopener noreferrer" target="_blank">https://twitter.com/Decred_Next</a></strong></p>
<p><strong>Volg DCRN op <a href="https://twitter.com/Decred_Next" rel="nofollow noopener noreferrer" target="_blank">Twitter</a> en <a href="https://t.me/DecredNext_EN" rel="nofollow noopener noreferrer" target="_blank">Telegram</a></strong><br><strong>Gast</strong><img src="https://gimg2.gateimg.com/image/article/16790437542.jpg" alt=""><br><strong>Stephanie Lee - Gemeenschapsmanager bij DCRN</strong></p>
<h2 id="h2-QampA20van20Gateio463765"><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-Q120Kun20je20ons20een20korte20introductie20geven20over20DCRN547841"><a name="Q1: Kun je ons een korte introductie geven over DCRN?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q1: Kun je ons een korte introductie geven over DCRN?</h3><p><strong>Stephanie</strong>: Ja, tuurlijk. DecredNext is een gedecentraliseerde autonome cryptocurrency die duurzaam, flexibel en 100% open source is. DecredNext erft de verdiensten van <a href="/price/decred-dcr" rel="nofollow noopener noreferrer" target="_blank">Decred</a> en maakt gebruik van een hybride van Proof-of-Work (PoW) en Proof-of-Stake (PoS) en die het beste van beide werelden combineert.</p>
<p><a href="/price/decred-dcr" rel="nofollow noopener noreferrer" target="_blank">Decred</a>-Next behoudt uitstekende kenmerken zoals hoge beveiliging, sterke aanpasbaarheid en duurzame ontwikkeling van <a href="/price/decred-dcr" rel="nofollow noopener noreferrer" target="_blank">Decred</a>. Bovendien zijn we van plan om in de toekomst EVM, sharding, OmniLayer en andere functies te realiseren.</p>
<p><a href="/price/decred-dcr" rel="nofollow noopener noreferrer" target="_blank">Decred</a>-Next maakt een efficiëntere circulatie van digitale activa mogelijk en stelt gebruikers in staat slimme contracten te schrijven en NFT’s uit te geven. In vergelijking met <a href="/price/decred-dcr" rel="nofollow noopener noreferrer" target="_blank">Decred</a>, <a href="/price/decred-dcr" rel="nofollow noopener noreferrer" target="_blank">Decred</a>-Next is efficiënter, robuuster, vitatiever en competitiever.</p>
<h3 id="h3-Q220Kun20je20ook20het20team20introduceren445494"><a name="Q2: Kun je ook het team introduceren?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q2: Kun je ook het team introduceren?</h3><p><strong>Stephanie</strong> Het oprichtingsteam van de DCRN bestaat uit belangrijke leden van <a href="/price/decred-dcr" rel="nofollow noopener noreferrer" target="_blank">Decred</a> en andere gedecentraliseerde ontwikkelingsprojecten, waaronder software-ingenieurs en productmanagers die eerder bij Google en Meta werkten. Het team is gepassioneerd over de toekomst van DCRN.</p>
<h3 id="h3-Q320Kun20je20ons20uitleggen20hoe20het20incentivedistributiemechanisme20van20DCRN20werkt20en20ons20vertellen20over20het20hybride20consensusmechanisme97215"><a name="Q3: Kun je ons uitleggen hoe het incentive-distributiemechanisme van DCRN werkt en ons vertellen over het hybride consensusmechanisme?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q3: Kun je ons uitleggen hoe het incentive-distributiemechanisme van DCRN werkt en ons vertellen over het hybride consensusmechanisme?</h3><p><strong>Stephanie</strong>: Wat betreft het incentiviseringsprogramma, erft DecredNext <a href="/price/decred-dcr" rel="nofollow noopener noreferrer" target="_blank">Decred</a> aangezien de blokbeloningen worden verdeeld tussen Proof-of-Work (PoW) miners, belanghebbenden en de DecredNext Treasury. 60% van de blokbeloning gaat naar Proof of Work miners.</p>
<p>30% van de blokbeloning gaat naar de houders van de tickets die in dat blok hebben gestemd. De overige 10% van de blokbeloning gaat naar de DecredNext-schatkist. Houders van actieve tickets beslissen hoe die schatkist wordt gebruikt.</p>
<h3 id="h3-Q420Kun20je20ons20ook20vertellen20waarom20DCRN20van20plan20is20om20zich20af20te20splitsen20van20DCR20Wat20zijn20de20voordelen20van20DCRN20in20vergelijking20met20DCR20na20de20afsplitsing147195"><a name="Q4: Kun je ons ook vertellen waarom DCRN van plan is om zich af te splitsen van DCR? Wat zijn de voordelen van DCRN in vergelijking met DCR na de afsplitsing?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q4: Kun je ons ook vertellen waarom DCRN van plan is om zich af te splitsen van DCR? Wat zijn de voordelen van DCRN in vergelijking met DCR na de afsplitsing?</h3><p><strong>Stephanie</strong>: Absoluut, weer een briljante vraag.</p>
<p>Er zijn twee belangrijke redenen voor deze moeilijke beslissing.</p>
<p>Allereerst zijn wij van mening dat PoW een dominante rol moet spelen in DCR en dat wij het niet eens zijn met de subsidieverdeling van 10%, PoW/ 80%, PoS in het belang van de gemeenschap. Door het verminderen van het aandeel van PoW tot 10% hebben we een verlies van rekenkracht en waardevermindering van de mijnbouwmachines gezien.</p>
<p>Ten tweede hadden we het origineel verwacht <a href="/price/decred-dcr" rel="nofollow noopener noreferrer" target="_blank">Decred</a> om meer te verkennen om de gemeenschap te versterken, maar weinig hebben we gezien. Vooral in het afgelopen jaar is de ontwikkeling van DCR zeer teleurstellend geweest. De totale marktkapitalisatie van DCR is uit de TOP100 glen.</p>
<p>Bovendien zagen we weinig groei van de gemeenschap, omdat we veel kansen hebben gemist in GAMEFI, NFT, WEB3.0, enz. We zagen echter geen inspanningen op het gebied van marketing, terwijl de populariteit van de ecologie en de gemeenschap afnam.</p>
<p>Daarom zijn we enthousiast om de gemeenschap weer groot te maken door DCRN te introduceren, dat is ontworpen om een natuurlijk gebalanceerd systeem te bouwen en het gedijen van de gemeenschap te stimuleren.</p>
<p>In vergelijking met DCR ontwikkelt DCRN een uitbreidbare ecologie die een groot aantal toepassingen en innovaties zou ondersteunen. We gebruiken EVM, sharding, OmniLayer om meer mogelijkheden in Web 3.0 te verkennen.</p>
<h3 id="h3-Q520Kun20je20ons20vertellen20over20de20roadmap20van20het20project170832"><a name="Q5: Kun je ons vertellen over de roadmap van het project?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q5: Kun je ons vertellen over de roadmap van het project?</h3><p><strong>Stephanie</strong>: Voor de routekaart</p>
<ol>
<li>Tegen oktober 2022 kan DCRN worden gebruikt om hashrate (mijnbouwmachine huren) te kopen op het blake 256 hash rate handelsplatform, waar kopers en verkopers van blake 256 hashrate kunnen handelen.</li><li>Tegen maart 2022 zal het TPS-promotieproject worden voltooid, waarbij gebruik wordt gemaakt van Zero Knowledge of Sharding-technologie.</li><li>Tegen juni 2022 zullen de EVM en OmniLayer worden geïntegreerd in het DCRN-mainnet, waarna we het ecosysteem kunnen ontwikkelen van <a href="/price/decred-dcr" rel="nofollow noopener noreferrer" target="_blank">Decred</a>-Volgende.</li></ol>
<p>Dit is onze routekaart voor onze belangrijkste mijlpalen.</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 enkele beleggingsaanbeveling.<br></em><div><em></em>Gate.io behoudt alle rechten 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 inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div>