R2F0ZS5pbyBBTUEgbWV0IEhpc3RvcnlEQU8gLSBPbSBlZW4gYmxvY2tnZXNjaGllZGVuaXMgdGUgc2xhYW4=

<p><img src="https://gimg2.gateimg.com/image/article/167531685111.jpeg" alt=""><br><strong>Tijd: 12 okt 2022, 3:00 UTC</strong><br><strong><a href="https://www.gate.io" target="_blank">Gate.io</a> organiseerde een AMA (Ask-Me-Anything) sessie met de mede-oprichter van HistoryDAO, Sky Harris 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://historydao.io/" rel="nofollow noopener noreferrer" target="_blank">https://historydao.io/</a></strong><br><strong>Twitter: <a href="https://twitter.com/History_DAO" rel="nofollow noopener noreferrer" target="_blank">https://twitter.com/History_DAO</a></strong><br><strong>Discord: <a href="https://discord.gg/zUTG6sQxNx" rel="nofollow noopener noreferrer" target="_blank">https://discord.gg/zUTG6sQxNx</a></strong><br><strong>Volg HistoryDAO op <a href="https://t.me/historydao_official" rel="nofollow noopener noreferrer" target="_blank">Telegram</a> en <a href="https://twitter.com/History_DAO" rel="nofollow noopener noreferrer" target="_blank">Twitter</a></strong><br><strong>Gast</strong><img src="https://gimg2.gateimg.com/image/article/167531701922.png" alt=""><br><strong>Sky Harris - Medeoprichter van HistoryDAO</strong><br>Uit de Verenigde Staten. Afgestudeerd aan de Universiteit van Utah met een bachelor in het Engels en een minor in geschiedenis. Algehele beheer van het bedrijf en het content governance comité. Meer dan 10 jaar ervaring in contentproductie en marktstrategie. Voormalig ByteDance-utive met uitgebreid netwerk in Noord-Amerikaanse industrie.</p>
<h3 id="h3-Vraag20amp20Antwoord20van20Gateio717728"><a name="Vraag &amp; Antwoord van Gate.io" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Vraag &amp; Antwoord van Gate.io</h3><h3 id="h3-Q120Kunt20u20zichzelf20en20HistoryDAO20alstublieft20introduceren420514"><a name="Q1: Kunt u zichzelf en HistoryDAO alstublieft introduceren?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q1: Kunt u zichzelf en HistoryDAO alstublieft introduceren?</h3><p><strong>Lucht</strong>: Hallo allemaal! Ik ben Sky Harris, mede-oprichter van HistoryDAO. Ik heb eerder gewerkt aan een uitleenprotocol, een DEX-builder, een <a href="/web3" target="_blank" class="blog_inner_link">Web3</a> OS en een fiat-crypto-betaling oplossing. Ik kom uit een Web2 technische marketing achtergrond bij ByteDance en Lenovo, en ik ben verheugd om vandaag HistoryDAO te introduceren.</p>
<p>HistoryDAO is waar de wereld geschiedenis vastlegt in Web3. De wereld komt samen op het HistoryDAO-platform om historische en huidige gebeurtenissen onveranderlijk op de blockchain te slaan en te bewaren als HistoryNFT’s. De decentralisatie en democratisering van geschiedenis ligt nu in onze handen met blockchain- en NFT-technologie, bestuurd door ons, de DAO, het volk.<br><img src="https://gimg2.gateimg.com/image/article/167531776533.png" alt=""><br>Schrijf, neem op, analyseer, oordeel en sla onze wereld op zoals deze zich elke dag over de hele wereld ontvouwt met HistoryDAO en HistoryNFTs.</p>
<h3 id="h3-V220In20de20vorige20vraag20noemde20je20dat20HistoryDAO20de20plaats20is20waar20de20geschiedenis20van20de20Web3wereld20wordt20vastgelegd20wat20erg20interessant20klinkt20Kun20je20uitleg20geven20over20de20oorspronkelijke20bedoeling20en20het20concept20van20HistoryDAO657918"><a name="V2: In de vorige vraag noemde je dat HistoryDAO de plaats is waar de geschiedenis van de Web3-wereld wordt vastgelegd, wat erg interessant klinkt. Kun je uitleg geven over de oorspronkelijke bedoeling en het concept van HistoryDAO?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>V2: In de vorige vraag noemde je dat HistoryDAO de plaats is waar de geschiedenis van de Web3-wereld wordt vastgelegd, wat erg interessant klinkt. Kun je uitleg geven over de oorspronkelijke bedoeling en het concept van HistoryDAO?</h3><p><strong>Lucht</strong>: Zeker weten! Als historici hebben we talloze voorbeelden van geschiedenis die oneerlijk en onwaar is geschreven door de overwinnaars. Miljoenen documenten, artefacten en kostbare stukken geschiedenis zijn verloren gegaan gedurende ons duizenden jaren van menselijk bestaan.</p>
<p>HistoryDAO geeft de macht terug in handen van de mensen om geschiedenis echt en onveranderlijk vast te leggen. We zagen dat de huidige zakelijke trends in de journalistiek klik-aas bedrijfsmodellen zijn die er alleen op gericht zijn de aandacht van hun klanten te trekken en vaak opruiend zijn. We willen de manier veranderen waarop geschiedenis wordt vastgelegd in Web3.</p>
<h3 id="h3-Q320Wat20is20de20huidige202020Status2020en20toekomstig20ontwikkelingsplan20van20HistoryDAO704547"><a name="Q3: Wat is de huidige   Status  en toekomstig ontwikkelingsplan van HistoryDAO?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q3: Wat is de huidige <a href="https://www.gate.io/trade/SNT_USDT" target="_blank">Status</a> en toekomstig ontwikkelingsplan van HistoryDAO?</h3><p><strong>Lucht</strong>: Bezoek vandaag nog het HistoryDAO-platform op historydao.io om je HistoryNFT’s te maken. Je kunt ook een NFT-serie maken om belangrijke actuele gebeurtenissen bij te houden terwijl ze zich ontvouwen, en individuele momenten maken die anderen kunnen kopen en verzamelen als HistoryNFT’s.</p>
<p>Financier de serie via een INO (Initial NFT Offering)!</p>
<p>Huidige gebeurtenissen, sport, kunst, muziek, literatuur, ruimteverkenning, politiek - dit zijn allemaal categorieën die uitstekende HistoryNFT’s vormen.</p>
<p>We hebben zojuist de HAO-token gelanceerd, die gebruikers kunnen inzetten om deel te nemen aan DAO-governance, evenals communityvoting die de kwaliteit van HistoryNFTs waarborgt en de beste NFTs naar voren brengt op het platform.</p>
<p>We zijn gisteren gelanceerd op Gate.io! Je kunt $HAO daar vandaag vinden met USDT/HAO handelsparen!</p>
<h3 id="h3-Q420Is20er20enig20verschil20tussen20de20Initial20NFT20Offering20INO20die20door20HistoryDAO20is20gepionierd20en20ICO20en20IEO442782"><a name="Q4: Is er enig verschil tussen de Initial NFT Offering (INO) die door HistoryDAO is gepionierd en ICO en IEO?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q4: Is er enig verschil tussen de Initial NFT Offering (INO) die door HistoryDAO is gepionierd en ICO en IEO?</h3><p><strong>Lucht</strong>: Ze zijn behoorlijk verschillend in die zin dat ICO’s en IEO’s zich richten op tokenverkoop, terwijl onze INO zich richt op NFT-verkoop. Beide zijn vormen van crowdfunding/fondsenwerving, dus werken ze in principe enigszins vergelijkbaar.</p>
<p>Maar cruciaal is dat een INO kan worden gelanceerd en deelgenomen door iedereen. We willen deze ideeën van democratisering en decentralisatie echt doordringen. En dat doen we hier ook met INO’s.</p>
<h3 id="h3-Q520Wat20zijn20de20voordelen20van20HistoryDAO20in20vergelijking20met20andere20NFTprojecten92630"><a name="Q5: Wat zijn de voordelen van HistoryDAO in vergelijking met andere NFT-projecten?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q5: Wat zijn de voordelen van HistoryDAO in vergelijking met andere NFT-projecten?</h3><p><strong>Lucht</strong>: Met HistoryDAO genereren gebruikers de inhoud. Het succes van het platform is het succes van haar gemeenschap.</p>
<p>Gedecentraliseerd, gedemocratiseerd, door het volk en voor het volk. De meeste NFT’s zijn projecten die zijn gelanceerd door een platform/bedrijf en worden vermarkt naar de gebruikersbasis, die de NFT’s koopt voor verzameldoeleinden, gebruikersdoeleinden, vroegtijdige toegang, enz.<br><img src="https://gimg2.gateimg.com/image/article/167531779744.png" alt=""><br>Maar met HistoryNFT’s creëren gebruikers de inhoud, zij bepalen welke NFT’s succesvol moeten zijn op basis van hun merites en kwaliteit. Dat is behoorlijk uniek.</p>
<h3 id="h3-Q620Wat20zijn20de20huidige20partners20van20HistoryDAO20Wat20is20de20vorm20van20samenwerking864983"><a name="Q6: Wat zijn de huidige partners van HistoryDAO? Wat is de vorm van samenwerking?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q6: Wat zijn de huidige partners van HistoryDAO? Wat is de vorm van samenwerking?</h3><p><strong>Lucht</strong>: We hebben samengewerkt met Metabit om ons project op te schalen en deel uit te maken van de ontwikkeling van huidige en toekomstige blockchains en alle toepassingen die daar bovenop zullen worden gebouwd.</p>
<p>We hebben ook samengewerkt met VoiceStreet, een natuurlijke partner voor ons, omdat ze muziek brengen naar Web3 en de metaverse. Er zullen veel legendarische momenten in de muziek zijn die het waard zijn om als geschiedenis NFT’s te worden gemunt.</p>
<p>Near, Alchemy Pay, ForTube, PlayerOne, SomnLife, XCarnival, Heartrate, FitR, Drive2, LingoesGame, Port3, YeehaGame, Voice Street, Metabit, UneMeta, BetaMars, D1verse, Proud Kitty Gang, EyesFi, Jungo, CandyKitty, Quest3, Theia, Midgard Saga, Genki, and Twitterscan zijn allemaal projecten waarmee we hebben samengewerkt op het gebied van merken en gemeenschappen.</p>
<h3 id="h3-Q720Hoe20neem20je20deel20aan20HistoryDAO20als20gebruiker941748"><a name="Q7: Hoe neem je deel aan HistoryDAO als gebruiker?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q7: Hoe neem je deel aan HistoryDAO als gebruiker?</h3><p><strong>Lucht</strong>: Op HistoryDAO kunnen gebruikers op veel spannende manieren momenten uit de huidige gebeurtenissen of geschiedenis als een History NFT creëren. Gebruik krantenkoppen, artikelen, afbeeldingen en meer om deze momenten te creëren.</p>
<p>Je kunt ook je NFT-collectie crowdfunden via onze INO-functie, waar je een reeks History NFT’s kunt maken om belangrijke gebeurtenissen bij te houden en deze aan andere gebruikers uit te geven.</p>
<p>Gebruikers kunnen ook deelnemen aan DAO-functies zoals projectbestuur, community-stemming om uitstekende History NFT’s te bevorderen en te belonen, stemmen om onnauwkeurige History NFT’s te verwijderen en meer.</p>
<p>We hebben ook een marktplaats gelanceerd voor het kopen, verkopen en verhandelen van HistoryNFT’s!<br><img src="https://gimg2.gateimg.com/image/article/167531778055.png" alt=""><br>Verder dan dat, doe zeker mee aan onze sociale activiteiten, draag bij aan het gesprek, deel interessant nieuws, en maak deel uit van onze geweldige gemeenschap.</p>
<h3 id="h3-Q820Kunnen20NFTs20die20op20HistoryDAO20zijn20gemaakt20worden20verhandeld158752"><a name="Q8: Kunnen NFT’s die op HistoryDAO zijn gemaakt worden verhandeld?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q8: Kunnen NFT’s die op HistoryDAO zijn gemaakt worden verhandeld?</h3><p><strong>Lucht</strong>: Dat kunnen ze zeker! Ze kunnen worden verhandeld op elke belangrijke ETH/BNB NFT-marktplaats van derden, aangezien we tegenwoordig het maken van munten in zowel ETH als <a href="/price/bnb-bnb" target="_blank" class="blog_inner_link">BNB</a> toestaan.</p>
<p>De HistoryDAO NFT Marketplace biedt de laagste transactiekosten en de meeste informatie die beschikbaar is voor het verhandelen van NFT’s, dus probeer het uit!</p>
<h3 id="h3-V920Kun20je20kort20het20economische20model20van20HistoryDAO20introduceren20Zal20HistoryDAO20later20een20token20uitgeven20Wat20zullen20de20kenmerken20van20het20token20zijn144029"><a name="V9: Kun je kort het economische model van HistoryDAO introduceren? Zal HistoryDAO later een token uitgeven? Wat zullen de kenmerken van het token zijn?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>V9: Kun je kort het economische model van HistoryDAO introduceren? Zal HistoryDAO later een token uitgeven? Wat zullen de kenmerken van het token zijn?</h3><p><strong>Lucht</strong> We hebben zojuist de $ HAO-token gelanceerd, waarmee gebruikers kunnen deelnemen aan alle geweldige functies die onze DAO te bieden heeft.</p>
<p>Door uitstekende History NFT’s te slaan, worden gebruikers beloond tijdens reguliere prijsevenementen om de beste History NFT’s te promoten. Deze NFT’s komen dan in aanmerking voor een reeks prijzen gedurende de weken, maanden en jaren om hun kwaliteit te waarborgen en geweldige makers op ons platform voortdurend te belonen.</p>
<p>History NFT-series hebben verschillende functies om makers te belonen. Individuele History NFT’s in een History NFT-serie worden vermeld en kunnen worden gekocht door andere gebruikers, waarbij meer belangrijke gebeurtenissen in een History NFT-serie waarschijnlijk meer waarde verzamelen. Denk bijvoorbeeld aan het NBA-seizoen, waarbij reguliere wedstrijden, play-offs en de finales allemaal verschillende marktprijzen en waarderingen accumuleren.</p>
<h3 id="h3-Q1020Wat20vind20je20van20de20huidige20stand20van20ontwikkeling20op20de20NFTmarkt724771"><a name="Q10: Wat vind je van de huidige stand van ontwikkeling op de NFT-markt?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q10: Wat vind je van de huidige stand van ontwikkeling op de NFT-markt?</h3><p><strong>Lucht</strong>: We geloven dat er een nieuw tijdperk van NFT’s voor ons ligt. Door gebruikers gegenereerd, door gebruikers gepromoot, door gebruikers bestuurd. Dit NFT 2.0-tijdperk zal een breed scala aan NFT’s zien met verschillende functionaliteiten die op verschillende manieren betekenis hebben in vergelijking met eerdere NFT-projecten. En het vastleggen van geschiedenis zal daar een belangrijk onderdeel van zijn.</p>
<div class="blog-details-info"><br><div>Auteur: <strong>Rio Fu.</strong>, Gemeenschap van Gate.io<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de standpunten 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 zal worden 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>