Qml0Y29pbi1vbnR3aWtrZWxhYXJzIGJla3JpdGlzZXJlbiBvcG5pZXV3IGRlIG9yZGluYWxlIGdldGFsbGVuIGVuIGJld2VyZW4gZGF0ICdPcmRpbmFscycgZWVuIGFsdGNvaW4tendlbmRlbCBpcyBkaWUgZ2VicnVpa21hYWt0IHZhbiBkZSByZXB1dGF0aWUgdmFuIEJUQyBvbSB0ZSBwb21wZW4gZW4gdGUgdmVya29wZW4u

2024-01-04, 14:37

<p><img src="https://gimg2.gateimg.com/image/article/1690791857hotspot.jpeg" alt=""></p>
<h2 id="h2-TDLR658442"><a name="[TD;LR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TD;LR]</h2><p><a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Ontwikkelaar Jimmy Song noemde het Ordinals-protocol een Altcoin-zwendel;</p>
<p>Al in 2018 hadden Jimmy Song en ‘Bitcoin Jesus’ Roger Ver een eeuwenlang gokspel;</p>
<p>Kunnen OG-bijdragers of speculanten het Bitcoin-ecosysteem vertegenwoordigen?</p>
<h2 id="h2-Introductie340040"><a name="Introductie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introductie</h2><p>Onlangs heeft nog een andere kernontwikkelaar van <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> Ordinals opnieuw bekritiseerd en beschuldigde het van een Altcoin-zwendel en wees erop dat het de populariteit van Bitcoin gebruikt om investeerders te misleiden.</p>
<p>Op 1 januari 2024 heeft Bitcoin-ontwikkelaar Jimmy Song getweet en kritiek geuit op het Ordinals-protocol, waarbij hij verklaarde dat het een Altcoin-zwendel was op basis van de populariteit van Bitcoin en beweerde dat het Bitcoin gebruikte om een vertrouwde identiteit te verkrijgen.</p>
<p>Hij wees erop dat de reden waarom Ordinals en BRC-20 protocollen populair zijn geworden, is omdat Bitcoin de reputatie van “shitcoin” kan vermijden in vergelijking met tokens die worden uitgegeven op <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> of <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> Song gelooft dat door verschillende aspecten van de Ordinals-beweging te ontleden, men een vergelijkbare ‘verkoop-up’ aard kan ontdekken als Altcoin, dat zich richt op tokenverkoop en speculatie in plaats van het bevorderen van de missie van economische vrijheid van Bitcoin.</p>
<p>Ondertussen drong hij er bij de gemeenschap op aan om onderscheid te maken tussen Bitcoin en de houders van deze frauduleuze tokens, en genadeloos hun frauduleuze gedrag bloot te leggen. Eerder uitte Bitcoin-coreontwikkelaar Luke Dashjr ook een soortgelijke mening over Ordinals, waarbij hij gelooft dat het gelijk staat aan het lanceren van spam-aanvallen op het Bitcoin-netwerk en hoopt dat dit in toekomstige versies wordt opgelost.<br><img src="https://gimg2.gateimg.com/image/article/1704378776img_v3_026p_261523b2-dc92-46b8-adf6-414fc57899ix.jpg" alt=""></p>
<h2 id="h2-Wie20is20Jimmy20Song935078"><a name="Wie is Jimmy Song?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wie is Jimmy Song?</h2><p>Jimmy Song - Medeoprichter van <a href="/price/decred-dcr" rel="nofollow noopener noreferrer" target="_blank">Decred</a>/DCR Coin, de kernontwikkelaar van Bitcoin, en partner bij Blockchain Capital LLC.</p>
<p>Song is een programmeur met 20 jaar ervaring en is zeer actief op het gebied van Bitcoin. Hij is redacteur bij Bitcoin Techtalk en ook blogger bij Media. Hij heeft bijgedragen aan de Bitcoin-kern en andere Bitcoin-projecten, en levert een open-source bijdrage aan veel verschillende Bitcoin-projecten. Hij is ook de auteur van O’Reilly’s ‘Programming Bitcoin’, ‘Little Bitcoin Book’, ‘Thank God for Bitcoin’ en ‘Bitcoin and the American Dream’.</p>
<p>Hij is de voormalige vicepresident van Engineering bij de Bitcoin Wallet Armory, en gedurende het grootste deel van zijn carrière werkte Song als softwareontwikkelaar bij meerdere bedrijven in verschillende sectoren zoals entertainment, gezondheidszorg en e-commerce.</p>
<p>In 2014 trad hij toe tot Monetas en leidde hij bijna een jaar lang de ontwikkeling van Bitcoin-integratie via open transacties. Na het beheren van de ontwikkeling van een commercieel vriendelijke Bitcoin-portemonnee voor Armory Technologies, werd hij de hoofdarchitect van Paxos en creëerde hij blockchain-oplossingen voor institutionele entiteiten.</p>
<p>Werd in januari 2018 lid van Blockchain Capital als venture-partner.</p>
<p>Bovendien exploiteert hij ook een winstgevend bedrijf genaamd Programming Blockchain, dat wereldwijd studenten traint om blockchain-programmering en ontwikkelingstechnieken te leren.<br><img src="https://gimg2.gateimg.com/image/article/1704378807img_v3_026p_1c101a40-ac8e-491c-8f33-dc5b65738cix.jpg" alt=""></p>
<p>Al in 2018 hadden Bitcoin Core-ontwikkelaar Jimmy Song en ‘Bitcoin Jesus’ Roger Ver een eeuwenlange gok. In dat cruisedebat ging Jimmy Song een zeer spannende intellectuele strijd aan tegen BCH, BTC en Roger.</p>
<p>Jimmy beschuldigd <a href="/price/bitcoin-cash-bch" rel="nofollow noopener noreferrer" target="_blank">Bitcoin Cash</a> van een fiatvaluta met Bitcontinent als centrale bank en beschuldigde de Bitcoin Cash-gemeenschap ervan dat ze CSW hadden geïnfiltreerd, een oplichter die ‘Satoshi heeft gekaapt om de heren te maken’. Hij bekritiseerde ook: ‘Voor gecentraliseerde valuta’s is het erg handig om een marionettengod te creëren.’</p>
<h2 id="h2-De20Stem20van20de20Gemeenschap946380"><a name="De Stem van de Gemeenschap" class="reference-link"></a><span class="header-link octicon octicon-link"></span>De Stem van de Gemeenschap</h2><p>In feite heeft de Ordinals-technologie sinds de lancering in januari 2023 intense discussies veroorzaakt in de Bitcoin-gemeenschap.</p>
<p>Mensen die Ordinals ondersteunen, hebben doorgaans de volgende soorten opvattingen:</p>
<ol>
<li><p>Bitcoin-miners: Sommige Bitcoin-miners ondersteunen Ordinals omdat het hen voorziet van een nieuwe inkomstenbron. Door gegevens op de blockchain te verbranden, kunnen miners extra kosten in rekening brengen.</p>
</li><li><p>Beurzen: Sommige beurzen ondersteunen ook Ordinals omdat ze gebruikers kunnen aantrekken door nieuwe diensten aan te bieden, zoals het ondersteunen van NFT-handel die is geregistreerd door Ordinals.</p>
</li><li><p>Ontwikkelaars van Layer 2-oplossingen: Deze ontwikkelaars zijn optimistisch over Ordinals omdat ze de mogelijkheid bieden om meer functies te implementeren op het Bitcoin-netwerk, zoals het creëren van gedecentraliseerde toepassingen.</p>
</li><li><p>Sommige technologie-enthousiastelingen: ze geloven dat Ordinals extra gebruiksmogelijkheden heeft toegevoegd voor Bitcoin-netwerken, niet langer alleen peer-to-peer cash-en. Ze geloven dat dit de waarde van de Bitcoin-database kan verhogen.</p>
</li></ol>
<p>Er zijn echter ook mensen die zich verzetten tegen Ordinals, vooral omdat ze bezorgd zijn dat het Bitcoin-netwerk complexer zal worden en de stabiliteit en veiligheid van zijn kerntaken als valuta zal beïnvloeden. Zo maken sommige Bitcoin-gekken (maximalisten) zich zorgen dat het gebruik van Ordinals kan leiden tot transactieverstopping en vergroting van de kosten.<br><img src="https://gimg2.gateimg.com/image/article/1704378862img_v3_026p_1e7af74e-0cac-4c13-9817-8db5d8410bix.jpg" alt=""></p>
<p>Giacomo Zucco is een actieve Bitcoin en Lightning Network Protocol consultant en docent. Hij is betrokken geweest bij meerdere projecten, waaronder BHB Network, BTCTimes, Relax, BCademy en Notarify, die zich richten op het stimuleren van de ontwikkeling van Bitcoin.</p>
<p>Daarnaast heeft Zucco deelgenomen aan projecten zoals GreenAddress, AssoBIT, Blockchain Lab en Bitcoin Magazine. Hij is actief in de Bitcoin-gemeenschap als educatief medewerker, adviseur, ondernemer en geek en ondersteunt projecten waarvan hij gelooft dat ze belangrijk zijn voor de toekomst van Bitcoin.</p>
<p>In een eerdere conversatie met Bitcoin magazine, vergeleek Giacomo Zucco onomwonden Ordinals met de grote ‘drugsmarkt’ van Bitcoin. Hij geloofde dat Ordinals innovatieve dingen waren die werden gepresenteerd door technologische hype en dat ze al in 2012 waren verschenen. ‘Ze hebben gewoon de namen van echte projecten vóór Bitcoin hergebruikt, ze hebben gewoon een naam gekocht om een dwaas project uit te geven.’ Het is dus niet iets wat we moeten accepteren.</p>
<p>“Ordinals transacties zijn scams zonder spam. Inie transacties zijn spam en scams, objectief gezien het slechtst,” zei Giacomo Zucco in een recente verklaring.</p>
<p>Max Keiser, hoewel geen ontwikkelaar van Bitcoin Core, staat bekend om zijn onwrikbaar vertrouwen en vroege investeringen in Bitcoin. Hij is een bekende voorstander en verspreider van Bitcoin, en bespreekt vaak Bitcoin in de media en openbare lezingen, waarbij hij het gebruik en de waarde ervan promoot. Hij is een ware Bitcoin-maximalist.</p>
<p>“Ordinaal nummer is een fout. Een oplossing komt binnenkort,” zei Max Keiser, onder vermelding van een screenshot van het registratienummer CVE-2023-50428 van Ordinals in de Amerikaanse Nationale Kwetsbaarheidsdatabase.</p>
<p>Al in februari 2023 lanceerde Adam Back, de pionier van PoW, kritiek op Ordinals, waarbij hij het ‘waardeloos’ noemde. Samson Mow, voormalig Chief Strategy Officer van Blockstream, stelde ook vraagtekens bij de opwinding rond Ordinals en BRC-20 tokens in Bitcoin, en gelooft dat deze hype niet houdbaar is en voorspelt dat deze binnen enkele maanden zal verdwijnen.</p>
<p>Maar Casey Rodarmor, de maker van het Ordinals protocol, gelooft dat de klachten van deze tegenstanders hen zwak doen lijken.<br><img src="https://gimg2.gateimg.com/image/article/1704378909img_v3_026p_97c28640-c315-4a3b-96b6-c82b8457f1ix.jpg" alt=""></p>
<h2 id="h2-Samenvattend817611"><a name="Samenvattend" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Samenvattend</h2><p>Uiteindelijk kan de controverse rond inies ideologisch worden begrepen als een conflict tussen de ‘technische factie’ en de ‘transactionele factie’. Van de acties van Luke Dashjr tot de uitgebreide opmerkingen van Jimmy Song vandaag, de ‘debat over de betekenis’ van de inie heeft de verdeeldheid binnen de gemeenschap verder versterkt.</p>
<p>Kunnen OG-bijdragers of speculanten het Bitcoin-ecosysteem vertegenwoordigen?</p>
<p>Feitelijk bevat de financiële markt zelf geen moraliteit, alles wordt bepaald door mechanismen en regels.</p>
<p>Tegenstanders van het vele problemen van Ordinals geloven dat ze nieuwe gebruiks scenario’s en economische kansen naar het Bitcoin-netwerk kunnen brengen, terwijl tegenstanders bezorgd zijn dat dit de essentie en efficiëntie van Bitcoin als digitaal goud kan beïnvloeden.</p>
<p>De ontwikkeling van het Bitcoin-ecosysteem wordt echter niet beperkt door een enkel perspectief of gebeurtenis. Ondanks verschillende perspectieven en mogelijke uitdagingen, toont het Bitcoin-ecosysteem aanpassingsvermogen en diversiteit, voortdurend evoluerend en integrerend nieuwe protocollen, en uitbreidend naar nieuwe blockchainnetwerken.</p>
<p>Historische ervaring heeft aangetoond dat ondanks twijfels en onzekerheden innovatieve technologieën vaak kansen vinden voor groei en ontwikkeling te midden van uitdagingen. Als investeerders moeten we een rationele benadering hanteren ten opzichte van elk nieuw project, en we moeten ook zorgvuldig de achtergrond, het team, de technische kracht en het bedrijfsmodel van het project ueren en blindelings meegaan met de trend van investeringen vermijden. De cryptomarkt zit vol met kansen en risico’s, en het handhaven van rationaliteit en waakzaamheid is nodig om op de lange termijn stabiele rendementen te behalen.</p>
<div class="blog-details-info"><br><div>Auteur:<strong>Byron B.</strong>, Gate.io Onderzoeker<br><div>Vertaler: Joy Z.<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de visie 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 is toegestaan mits Gate.io wordt vermeld. In alle glen zullen juridische stappen worden ondernomen vanwege inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div></div>