UEVQRSAyLjAgemV0IGVlbiBuaWV1d2UgdHJlbmQgaW4gZ2FuZywgemFsIE1lbWVjb2luIGhldCAyLjAtdGlqZHBlcmsgaW5sdWlkZW4/

2023-07-26, 02:29

<p><img src="https://gimg2.gateimg.com/blog/1679447253155655279redian.jpeg" alt=""></p>
<h2 id="h2-TLDR448947"><a name="TL;DR" class="reference-link"></a><span class="header-link octicon octicon-link"></span>TL;DR</h2><p>Tegenwoordig lijken Web3-bouwers altijd geobsedeerd te zijn door probleemoplossing, soms zelfs problemen te creëren om ze op te lossen.</p>
<p>Verslaafd zijn aan vechten tegen niet-bestaande tegenstanders is geen goede fenomeen.</p>
<p>Naar mijn mening ontbreekt het Web3-bouwers over het algemeen aan vertrouwen, in die mate dat ze altijd hun producten wat onnodige “heiligheid” moeten geven. Dit komt voort uit de afkeuring van de mainstream wereld, en ook uit de druk die wordt uitgeoefend door de senioren van de cryptomarkt (onder de glorie van <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> en <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a>, elk project is iets gedimd).</p>
<p>In deze ongezonde sfeer lijken bepaalde activa bijzonder misplaatst. Ze streven geen gebruiksscenario’s na of willen ultieme problemen oplossen, maar lijken in plaats daarvan enigszins komisch en belachelijk. Maar juist deze ‘clownstijl’ activa hebben veel consensus en populariteit verworven, en zelfs een nieuwe richting gevormd - Memecoin.</p>
<h2 id="h2-Memecoin20Onorthodoxe20Crypto20Cultuur518512"><a name="Memecoin: Onorthodoxe Crypto Cultuur" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Memecoin: Onorthodoxe Crypto Cultuur</h2><p><img src="https://gimg2.gateimg.com/image/article/16903383605301690338213_.pic_hd.jpg" alt=""></p>
<p>De vroegste verschijning van dit soort activa kan worden teruggevoerd tot 2013 toen een cryptocurrency genaamd <a href="/price/dogecoin-doge" rel="nofollow noopener noreferrer" target="_blank">Dogecoin</a> stond bekend om zijn hondelogo en vriendelijke gemeenschapsactiviteiten. Sindsdien is Memecoin een populaire innovatieve manier geworden om gebruikers aan te trekken en specifieke netwerkgemeenschappen te bevorderen. In de loop der tijd zijn er steeds meer Memecoin-projecten ontstaan, elk met unieke meme-elementen en gemeenschap.</p>
<p>Echter, in vergelijking met andere belangrijke cryptomunten, vanwege de unieke aard van Memecoin, zijn de prijsschommelingen vaak groot, zodat investeerders op korte termijn hoge rendementen kunnen behalen, maar ook onvermijdelijk potentiële risico’s lopen.</p>
<h2 id="h2-PEPE20202020Stijgend20met20de20trend20in20juli137629"><a name="PEPE 2.0 - Stijgend met de trend in juli" class="reference-link"></a><span class="header-link octicon octicon-link"></span>PEPE 2.0 - Stijgend met de trend in juli</h2><p><img src="https://gimg2.gateimg.com/image/article/16903383935311690338226_.pic.jpg" alt=""></p>
<p>Terugkijkend naar de eerste helft van 2023, zelfs als de markt sterk bearish is, zijn er nog steeds enkele projecten die uitblinken op de markt. Daarvan kan de kracht van Memecoin niet worden genegeerd. Zelfs wat betreft prijsprestaties en vermogenseffecten is Memecoin PEPE ongetwijfeld een sterke kanshebber voor de positie van best presterende crypto-activa gedurende heel 2023.</p>
<p>Tot op de dag van vandaag is de populariteit van PEPE aanzienlijk afgenomen, maar zijn ‘mythe’ beperkt zich niet alleen tot zichzelf. Deze juli hebben sommige laatkomers geprofiteerd van de wind en zelfs nieuwe verhalen ontwikkeld.</p>
<p>Op 30 juni 2023 werd de ‘2.0 versie’ (onofficieel) van de best presterende Memecoin PEPE in 2023, PEPE 2.0, uitgebracht. Tot verbazing steeg de prijs binnen slechts een week met bijna 1.000%.</p>
<p><img src="https://gimg2.gateimg.com/image/article/16903384215321690338238_.pic.jpg" alt=""></p>
<p>Zelfs op Twitter circuleert er nog steeds een stadslegende dat PEPE 2.0 portefeuillehouders heeft omgevormd van $900 naar $176.000 in minder dan 24 uur.<br><img src="https://gimg2.gateimg.com/image/article/16903384445331690338253_.pic.jpg" alt=""></p>
<p>Zoals de naam al doet vermoeden, haalde de naamgeving van PEPE 2.0 ongetwijfeld veel inspiratie uit de originele PEPE. En het is juist vanwege deze ‘hete’ naamgeving dat PEPE 2.0 in zijn vroege stadia snel een brede gebruikersgroep aantrok. Dit is ook het doel dat de meeste Memecoins weken of zelfs maanden nodig hebben om te bereiken.</p>
<p>Met de hete fermentatie van PEPE2.0 en de voortdurende stijging van de prijs begon het enkele potentiële gebruikers aan te trekken in de Memecoin Niche-markt, wat de prijsgroei verder stimuleerde.</p>
<p><img src="https://gimg2.gateimg.com/image/article/16903384705341690338268_.pic.jpg" alt=""></p>
<h2 id="h2-Memecoin20Op20Weg20Naar20het202020Tijdperk132822"><a name="Memecoin Op Weg Naar het 2.0 Tijdperk?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Memecoin Op Weg Naar het 2.0 Tijdperk?</h2><p><img src="https://gimg2.gateimg.com/image/article/16903384875361690338284_.pic.jpg" alt=""></p>
<p>Naast de prijs heeft PEPE 2.0 ook enkele nieuwe trends op gang gebracht.</p>
<p>Vergezeld door de korte lancering van PEPE 2.0, begonnen ook zijn tijdgenoten Floki 2.0, Bobo 2.0, Shib2.0 en anderen op het cryptotoneel te verschijnen. De positionering van deze tokens is vergelijkbaar met PEPE 2.0, en het zijn allemaal bijgewerkte versies van Memecoin met vergelijkbare namen.</p>
<p>Volgens onze consistente kennis lijken deze ‘imitatieprojecten’ alleen maar genegeerd te worden en in de war te zijn. Maar onverwacht wonnen deze tokens snel miljoenen dollars aan handelsvolume en honderdduizenden dollars aan liquiditeit zodra ze in omloop waren gebracht, en het aantal wallet-adressen voor houders bereikte op een gegeven moment vijf cijfers. De prijs van SHIB2.0 steeg zelfs met een ongelofelijke 1.773% in slechts één dag. Sommige trouwe gebruikers voeren zelfs prijsanalyses uit voor hen in de komende decennia met grote ernst.</p>
<p>Is het Memecoin 2.0 tijdperk echt hier?</p>
<p>Hoewel de huidige cryptomarkt misschien niet als de donkerste tijden wordt beschouwd, is het tot een dieptepunt gedaald. De langdurige stilte op de markt heeft te veel druk gelegd op mensen, zowel economisch als emotioneel.</p>
<p>Wanneer de scherpe stijging van PEPE wordt weerspiegeld in de springende cijfers op de Candlestick-grafiek, is het ongetwijfeld heftig stimulerend voor de zenuwen van mensen. Het zorgt er niet alleen voor dat mensen zuchten en de kans om rijk te worden missen, maar het verergert ook de hebzucht en doet geleidelijk hun rationaliteit verliezen, wat heeft geleid tot een nieuwe verhaallijn in het Memecoin 2.0-tijdperk.</p>
<p>Naar mijn mening is Memecoin een zeer interessant bezit, ook al is het lange tijd bekritiseerd vanwege een gebrek aan innovatie en overmatige promotie, het kan niet ontkend worden dat het nog steeds de harten van veel gebruikers verovert met zijn meest authentieke en eenvoudige emotionele waarde.</p>
<p>Als <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> het tijdperk van decentralisatie heeft ingeluid en <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> een rijk crypto-ecosysteem heeft opgebouwd, weerspiegelt Memecoin echt de ware gevoelens van gewone gebruikers als de bouwers van een gedecentraliseerde wereld.</p>
<p>Maar wat betreft de huidige ‘2.0-gekte’, hoop ik dat deze Memecoins niet alleen 2.0 genoemd zullen worden, maar ook nieuwe emotionele dragers zullen hebben in het nieuwe tijdperk. We hopen dat latere generaties ons de emotionele resonantie van de 2.0-versie kunnen brengen.</p>
<div class="blog-details-info"><br><div>Auteur:<strong>Leo F.</strong>, Gate.io Onderzoeker<br><div>Vertaler: Joy Z.<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de standpunten van de onderzoeker en vormt geen enkele beleggingsadvies.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Het opnieuw plaatsen van dit artikel is toegestaan op voorwaarde dat Gate.io wordt vermeld. In alle glen zal er juridische actie worden ondernomen wegens auteursrechtenschending.<br></div><p></p><br></div></div></div></div>