R2F0ZS5pbyBBTUEgbWV0IE1hY2Fyb25Td2FwIC0gRWVuIGdlZGVjZW50cmFsaXNlZXJkZSBiZXVycyB2b29yIGhldCBvbXdpc3NlbGVuIHZhbiBCRVAtMjAgdG9rZW5z

<p><img src="https://gimg2.gateimg.com/image/article/16915652141.jpeg" alt=""><br><strong>Tijd: 16 september 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 Luke, oprichter van MacaronSwap in de <a href="https://t.me/gateio" rel="nofollow noopener noreferrer" target="_blank">Gate.io Uitwisseling Gemeenschap</a>.</strong><br><strong>Officiële website: <a href="https://macaronswap.com/" rel="nofollow noopener noreferrer" target="_blank">https://macaronswap.com/</a></strong><br><strong>Twitter: <a href="https://twitter.com/macaronswap" rel="nofollow noopener noreferrer" target="_blank">https://twitter.com/macaronswap</a></strong><br><strong>Volg MacaronSwap op <a href="https://twitter.com/macaronswap" rel="nofollow noopener noreferrer" target="_blank">Sjilpen</a> en <a href="https://t.me/macaronswap" rel="nofollow noopener noreferrer" target="_blank">Telegram</a></strong><br><strong>Gast</strong><img src="https://gimg2.gateimg.com/image/article/16915654552.jpg" alt=""><br><strong>Luke - Oprichter van MacaronSwap</strong></p>
<h2 id="h2-Vraag20en20antwoord20van20Gateio726266"><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-V120Wat20is20uw20project20precies20en20kunt20u20ons20meer20vertellen20over20uw20visie447542"><a name="V1: Wat is uw project precies en kunt u ons meer vertellen over uw visie?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>V1: Wat is uw project precies en kunt u ons meer vertellen over uw visie?</h3><p><strong>Luke</strong> We hebben een zeer ervaren team dat al vele jaren op het gebied van informatietechnologie op ondernemingsniveau heeft gewerkt.<br><img src="https://gimg2.gateimg.com/image/article/16915654903.png" alt=""><br>Ons project heeft tot doel gedecentraliseerde apps te bouwen die een belangrijk onderdeel van crypto zullen zijn en die het echte leven raken door delen van informatietechnologieën te kruisen.</p>
<h3 id="h3-V220Ok20en20hoe20is20het20bouwen20geweest20Wat20zijn20enkele20van20de20belangrijkste20mijlpalen20die20jullie20tot20nu20toe20hebben20bereikt20en20waarom20zijn20ze20belangrijk835113"><a name="V2: Ok en hoe is het bouwen geweest? Wat zijn enkele van de belangrijkste mijlpalen die jullie tot nu toe hebben bereikt en waarom zijn ze belangrijk?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>V2: Ok en hoe is het bouwen geweest? Wat zijn enkele van de belangrijkste mijlpalen die jullie tot nu toe hebben bereikt en waarom zijn ze belangrijk?</h3><p><strong>Luke</strong>: Onze tokenlancering en MCRN IDO in maart 2021 waren erg spannend voor ons. Ondanks dat er te veel concurrenten waren, hebben we een goede prestatie geleverd. Pancake Farm listings (2 keer hebben we veilingen van Pancake gewonnen, we zijn enthousiast om een kernboerderij op hun platform te openen) en de notering op Gate.io waren erg belangrijk voor ons om de reputatie en erkenning te vergroten. Wij waren het eerste project dat een Lossless Lottery op Binance Smart Chain heeft gebouwd, en tot nu toe werkt het goed.</p>
<h3 id="h3-V320Dus20het20lijkt20erop20dat20je20het20aan20de20technische20kant20heel20goed20doet20Hoe20zit20het20met20je20gemeenschap20Hoe20is20je20community20gegroeid20sinds20je20voor20het20eerst20bent20gestart47751"><a name="V3: Dus het lijkt erop dat je het aan de technische kant heel goed doet. Hoe zit het met je gemeenschap? Hoe is je community gegroeid sinds je voor het eerst bent gestart?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>V3: Dus het lijkt erop dat je het aan de technische kant heel goed doet. Hoe zit het met je gemeenschap? Hoe is je community gegroeid sinds je voor het eerst bent gestart?</h3><p><strong>Luke</strong>: Ja, we vertrouwen op onze technische mogelijkheden en vaardigheden. Zowel @macaronchef als ik hebben ongeveer 15 jaar ervaring in informatietechnologie.</p>
<p>Het aantal mensen dat zich bewust is van onze gemeenschap en Macaron is toegenomen. Het was net rond 2000 terwijl we MCRN IDO deden. Nu hebben we 39.200 volgers op Twitter, 22313 op Telegram. Deze gebruikers hebben 432000+ transacties gedaan in 6 maanden.</p>
<h3 id="h3-Q420En20een20goed20team20erachter20Kun20je20ons20nu20meer20vertellen20over20je20bedrijfsmodel794167"><a name="Q4: En een goed team erachter! Kun je ons nu meer vertellen over je bedrijfsmodel?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q4: En een goed team erachter! Kun je ons nu meer vertellen over je bedrijfsmodel?</h3><p><strong>Luke</strong>: We staan open voor communicatie om ons bedrijf uit te breiden naar andere ketens (momenteel op Binance Smart Chain, op <a href="/price/polygon-matic" rel="nofollow noopener noreferrer" target="_blank">Polygon</a> binnenkort) en we willen samenwerken met de op ecosysteem gerichte projecten.</p>
<p>We zullen gedecentraliseerde financiële applicaties creëren die in staat zullen zijn om het echte leven in een duurzaam model aan te nemen.</p>
<h3 id="h3-Q520Ok20heel20interessant20maar20het20lijkt20erop20dat20er20andere20vergelijkbare20voorstellen20in20de20industrie20zijn20Wat20zijn20enkele20van20de20concurrenten20die20u20heeft20gedentificeerd20crypto20of20noncrypto20en20hoe20onderscheidt20u20zich46768"><a name="Q5: Ok, heel interessant… maar het lijkt erop dat er andere vergelijkbare voorstellen in de industrie zijn. Wat zijn enkele van de concurrenten die u heeft geïdentificeerd (crypto of non-crypto) en hoe onderscheidt u zich?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q5: Ok, heel interessant… maar het lijkt erop dat er andere vergelijkbare voorstellen in de industrie zijn. Wat zijn enkele van de concurrenten die u heeft geïdentificeerd (crypto of non-crypto) en hoe onderscheidt u zich?</h3><p><strong>Luke</strong>: In de crypto, vooral aan de kant van Decentralized Finance, zijn er eerlijk gezegd te veel concurrenten. Om tussen hen op te vallen, moeten projectteams iets unieks doen. Zodra we het basislijn van onze structuur aannemen, die overeenkomsten heeft met andere projecten, zullen we beginnen met het opbouwen van onze unieke functies die ons onderscheiden van de anderen, mensen zullen gemakkelijk onze verschillen, professionaliteit en platform intelligentie zien na Q4 2021.</p>
<h3 id="h3-V620Hoe20zit20het20met20de20structuur20van20de20token20Vertel20ons20meer20over20de20tokenomics20achter20het20project196270"><a name="V6: Hoe zit het met de structuur van de token. Vertel ons meer over de tokenomics achter het project." class="reference-link"></a><span class="header-link octicon octicon-link"></span>V6: Hoe zit het met de structuur van de token. Vertel ons meer over de tokenomics achter het project.</h3><p><strong>Luke</strong> In het begin kunnen we zeggen dat we een gebruikersvriendelijke tokenomics hebben opgebouwd die gebruikers samen laten groeien. We waren eens geen hebzuchtig team toen we tokenomics bouwden. Dit gaf gebruikers vertrouwen. En alle fondsen werden tot nu toe met hun goedkeuring uitgegeven met ons governance-mechanisme, we waren heel transparant voor hen.<br><img src="https://gimg2.gateimg.com/image/article/16915654734.png" alt=""><br>MCRN is ook een governance-token. Alle voorstellen en stemactiviteiten worden deelgenomen en bijgehouden op;<br><a href="https://vote.macaronswap.finance" rel="nofollow noopener noreferrer" target="_blank">https://vote.macaronswap.finance</a></p>
<h3 id="h3-Vraag20720Dus20wat20staat20er20te20gebeuren20Waar20ga20je20naartoe20in20de20komende20jaren20en20wat20zijn20de20volgende20belangrijke20updates20voor20jou927985"><a name="Vraag 7: Dus wat staat er te gebeuren? Waar ga je naartoe in de komende jaren en wat zijn de volgende belangrijke updates voor jou?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Vraag 7: Dus wat staat er te gebeuren? Waar ga je naartoe in de komende jaren en wat zijn de volgende belangrijke updates voor jou?</h3><p><strong>Luke</strong>: Zoals ik al zei, hebben onze kernleden jarenlang voor grote bedrijven gewerkt op het gebied van informatietechnologie, het zal ons echt helpen om iets innovatiefs te bouwen en we willen onze ervaring presenteren aan de gedecentraliseerde wereld. We zullen dApps bouwen die de adoptie van cryptocurrencies in de echte wereld zullen bevorderen.</p>
<h3 id="h3-Q820Ok20best20cool20En20om20het20af20te20ronden20voordat20we20overgaan20op20vragen20van20ons20publiekHoe20voel20je20je20op20dit20moment20over20de20industrie20en20waar20denk20je20dat20je20past870513"><a name="Q8: Ok, best cool. En om het af te ronden voordat we overgaan op vragen van ons publiek…Hoe voel je je op dit moment over de industrie en waar denk je dat je past?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q8: Ok, best cool. En om het af te ronden voordat we overgaan op vragen van ons publiek…Hoe voel je je op dit moment over de industrie en waar denk je dat je past?</h3><p><strong>Luke</strong>: De cryptobranche groeit dagelijks, de adoptie neemt toe en de reputatie van de projecten groeit. We bouwen nog steeds aan de basis van ons project, maar de huidige situatie is al veel verder dan die van veel andere projecten. Na het vierde kwartaal van 2021 zullen we de volgende routekaart uitbrengen, waarin veel punten staan om aan de cryptobranche te voldoen met het echte leven.</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 is toegestaan om het artikel opnieuw te plaatsen op voorwaarde dat Gate.io wordt vermeld. In alle glen zullen juridische stappen worden ondernomen vanwege auteursrechtinbreuk.<br></div><p></p><br></div></div></div>