R2xpIHN2aWx1cHBhdG9yaSBkaSBCaXRjb2luIGNyaXRpY2FubyBhbmNvcmEgZ2xpIG9yZGluYWxpLCBzb3N0ZW5lbmRvIGNoZSAiR2xpIG9yZGluYWxpIHNvbm8gdW5hIHRydWZmYSBhbHRjb2luIGNoZSB1dGlsaXp6YSBsYSByZXB1dGF6aW9uZSBkaSBCVEMgcGVyIHBvbXBhcmUgZSB2ZW5kZXJl

2024-01-04, 14:37

<p><img src="https://gimg2.gateimg.com/image/article/1690791857hotspot.jpeg" alt=""></p>
<h2 id="h2-TDLR88469"><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> Lo sviluppatore Jimmy Song ha definito il protocollo Ordinals come una truffa di Altcoin;</p>
<p>Già nel 2018, Jimmy Song e il “Bitcoin Jesus” Roger Ver avevano un gioco d’azzardo centenario;</p>
<p>Gli OG contributori o speculatori possono rappresentare l’ecosistema Bitcoin?</p>
<h2 id="h2-Introduzione649222"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>Recentemente, un altro sviluppatore principale di <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> ha nuovamente criticato Ordinals, accusandolo di essere una truffa Altcoin e sottolineando che sta utilizzando la popolarità di Bitcoin per ingannare gli investitori.</p>
<p>Il 1° gennaio 2024, lo sviluppatore di Bitcoin Jimmy Song ha twittato criticando il protocollo Ordinals, affermando che si trattava di una truffa Altcoin basata sulla popolarità di Bitcoin e sostenendo che utilizzasse Bitcoin per ottenere un’identità fidata.</p>
<p>Ha osservato che il motivo per cui gli Ordinali e i protocolli BRC-20 sono diventati popolari è perché Bitcoin può evitare la reputazione di ‘shitcoin’ rispetto ai token emessi su <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> o <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> Song ritiene che analizzando vari aspetti del movimento degli Ordinals, si possa scoprire una natura simile di “vendita” agli Altcoin, che si concentra sulla vendita e speculazione dei token anziché promuovere la missione della libertà economica di Bitcoin.</p>
<p>Nel frattempo, ha esortato la comunità a distinguere tra Bitcoin e i detentori di questi token fraudolenti, e a esporre senza pietà il loro comportamento fraudolento. In precedenza, il core developer di Bitcoin Luke Dashjr ha espresso una visione simile verso Ordinals, ritenendo che sia equivalente a lanciare attacchi di spam sulla rete Bitcoin e spera che venga risolto nelle versioni future.<br><img src="https://gimg2.gateimg.com/image/article/1704378776img_v3_026p_261523b2-dc92-46b8-adf6-414fc57899ix.jpg" alt=""></p>
<h2 id="h2-Chi2020Jimmy20Song489703"><a name="Chi è Jimmy Song?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Chi è Jimmy Song?</h2><p>Jimmy Song - Co fondatore di <a href="/price/decred-dcr" rel="nofollow noopener noreferrer" target="_blank">Decred</a>/DCR Coin, sviluppatore principale di Bitcoin e partner presso Blockchain Capital LLC.</p>
<p>Song è un programmatore con 20 anni di esperienza ed è molto attivo nel campo Bitcoin. È un redattore di Bitcoin Techtalk e anche un blogger di Media. Ha contribuito al core di Bitcoin e ad altri progetti Bitcoin ed è un collaboratore open-source di molti diversi progetti Bitcoin. È anche l’autore di “Programming Bitcoin”, “Little Bitcoin Book”, “Thank God for Bitcoin” e “Bitcoin and the American Dream” di O’Reilly.</p>
<p>È il precedente Vice Presidente dell’Ingegneria al Bitcoin Wallet Armory, e per la maggior parte della sua carriera, Song ha lavorato come sviluppatore di software in molte aziende in vari campi come intrattenimento, assistenza sanitaria e commercio elettronico.</p>
<p>Nel 2014, si unì a Monetas e guidò lo sviluppo dell’integrazione di Bitcoin tramite transazioni aperte per quasi un anno. Dopo aver gestito lo sviluppo di un portafoglio Bitcoin commercialmente friendly per Armory Technologies, divenne l’architetto capo di Paxos, creando soluzioni blockchain per entità istituzionali.</p>
<p>Entrato a far parte di Blockchain Capital come partner di venture nel gennaio 2018.</p>
<p>Inoltre, gestisce anche un’azienda a scopo di lucro chiamata Programming Blockchain, che forma studenti in tutto il mondo per imparare la programmazione blockchain e le tecniche di sviluppo.<br><img src="https://gimg2.gateimg.com/image/article/1704378807img_v3_026p_1c101a40-ac8e-491c-8f33-dc5b65738cix.jpg" alt=""></p>
<p>Già nel 2018, lo sviluppatore principale di Bitcoin Jimmy Song e il “Bitcoin Jesus” Roger Ver hanno avuto una scommessa della durata di un secolo. In quel dibattito in crociera, Jimmy Song ha intrapreso una battaglia intellettuale molto appassionante contro BCH, BTC e Roger.</p>
<p>Jimmy ha accusato <a href="/price/bitcoin-cash-bch" rel="nofollow noopener noreferrer" target="_blank">Bitcoin Cash</a> di essere una valuta fiat con Bitcontinent come banca centrale, e ha accusato la comunità di <a href="/price/bitcoin-cash-bch" target="_blank" class="blog_inner_link">Bitcoin Cash</a> di infiltrare CSW, un truffatore che ha “dirottato Satoshi per fare i signori.” Ha anche criticato, “Per le valute centralizzate, creare un dio burattino è molto utile.”</p>
<h2 id="h2-La20Voce20della20Comunit126293"><a name="La Voce della Comunità" class="reference-link"></a><span class="header-link octicon octicon-link"></span>La Voce della Comunità</h2><p>In effetti, dalla sua introduzione nel gennaio 2023, la tecnologia degli Ordinals ha suscitato intense discussioni nella comunità Bitcoin.</p>
<p>Le persone che supportano gli ordinali di solito hanno i seguenti tipi di opinioni:</p>
<ol>
<li><p>Minatori di Bitcoin: Alcuni minatori di Bitcoin supportano gli ordini come fonte di reddito supplementare. Bruciando i dati sulla blockchain, i minatori possono addebitare commissioni aggiuntive.</p>
</li><li><p>Scambi: alcuni scambi supportano anche gli Ordinali perché possono attirare gli utenti fornendo nuovi servizi, come il supporto per le transazioni NFT registrate dagli Ordinali.</p>
</li><li><p>Sviluppatori di soluzioni di Layer 2: Questi sviluppatori sono ottimisti riguardo agli Ordinals perché offrono la possibilità di implementare ulteriori funzionalità sulla rete Bitcoin, come la creazione di applicazioni decentralizzate.</p>
</li><li><p>Alcuni appassionati di tecnologia: Ritengono che Ordinals abbia aggiunto casi d’uso per le reti Bitcoin, non solo come sistemi di denaro peer-to-peer. Credono che questo possa aumentare il valore del database di Bitcoin.</p>
</li></ol>
<p>Tuttavia, ci sono anche persone che si oppongono agli Ordinals, preoccupate principalmente che renderanno la rete Bitcoin più complessa e potrebbero influire sulla stabilità e sicurezza delle sue funzioni principali come valuta. Ad esempio, alcuni appassionati di Bitcoin (massimisti) sono preoccupati che l’uso degli Ordinals possa portare a congestione delle transazioni e aumento delle commissioni.<br><img src="https://gimg2.gateimg.com/image/article/1704378862img_v3_026p_1e7af74e-0cac-4c13-9817-8db5d8410bix.jpg" alt=""></p>
<p>Giacomo Zucco è un consulente e insegnante attivo di Bitcoin e del protocollo Lightning Network. Ha partecipato a numerosi progetti, tra cui BHB Network, BTCTimes, Relax, BCademy e Notarify, dedicati alla promozione dello sviluppo di Bitcoin.</p>
<p>Inoltre, Zucco ha partecipato a progetti come GreenAddress, AssoBIT, Blockchain Lab e Bitcoin Magazine. È attivo nella comunità Bitcoin come educatore, consulente, imprenditore e appassionato, supportando progetti che ritiene importanti per il futuro di Bitcoin.</p>
<p>In una precedente conversazione con Bitcoin magazine, Giacomo Zucco ha candidamente confrontato gli Ordinals con il grande “mercato delle droghe” di Bitcoin. Credeva che gli Ordinals fossero cose innovative presentate dall’entusiasmo tecnologico e che fossero già apparsi nel 2012. “Hanno semplicemente riutilizzato i nomi di progetti reali precedenti a Bitcoin, hanno semplicemente acquistato un nome per emettere un progetto folle.” Pertanto, non è qualcosa che dobbiamo accettare.</p>
<p>“Le transazioni ordinate sono truffe senza spam. Le transazioni di iscrizione sono spam e truffe, oggettivamente le peggiori”, ha detto Giacomo Zucco in una dichiarazione recente correlata.</p>
<p>Max Keiser, sebbene non sia uno sviluppatore di Bitcoin Core, è noto per la sua fede incrollabile e i suoi investimenti precoci in Bitcoin. È un noto sostenitore e divulgatore di Bitcoin, spesso discutendo di Bitcoin nei media e nelle conferenze pubbliche, promuovendone l’uso e il valore. È un vero massimizzatore di Bitcoin.</p>
<p>“Il numero ordinale è un errore. La correzione è in arrivo”, ha detto Max Keiser, citando uno screenshot del numero di registrazione di Ordinals CVE-2023-50428 nel National Vulnerability Database degli Stati Uniti.</p>
<p>Già nel febbraio 2023, Adam Back, il pioniere di PoW, ha lanciato una critica agli Ordinals, definendoli “inutili”. Samson Mow, ex Chief Strategy Officer di Blockstream, ha anche messo in dubbio la frenesia degli Ordinals e dei token BRC-20 in Bitcoin, ritenendo che questo hype sia insostenibile e prevedendo che si dissiperà entro pochi mesi.</p>
<p>Ma Casey Rodarmor, il creatore del protocollo Ordinals, crede che le lamentele di questi oppositori li facciano apparire deboli.<br><img src="https://gimg2.gateimg.com/image/article/1704378909img_v3_026p_97c28640-c315-4a3b-96b6-c82b8457f1ix.jpg" alt=""></p>
<h2 id="h2-Per20riassumere422446"><a name="Per riassumere" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Per riassumere</h2><p>In definitiva, la controversia che circonda le iscrizioni può essere compresa ideologicamente come un conflitto tra la “fazione tecnica” e la “fazione transazionale”. Dalle azioni di Luke Dashjr ai lunghi commenti di Jimmy Song di oggi, il “dibattito sul significato” dell’iscrizione ha ulteriormente intensificato le divisioni nella comunità.</p>
<p>Possono i contributori OG o gli speculatori rappresentare l’ecosistema Bitcoin?</p>
<p>Fondamentalmente, il mercato finanziario stesso non contiene moralità, tutto è determinato da meccanismi e regole.</p>
<p>Affrontando i molteplici problemi degli ordinali, i sostenitori credono che possano portare nuovi scenari d’uso e opportunità economiche alla rete Bitcoin, mentre gli avversari sono preoccupati che ciò possa influenzare l’essenza e l’efficienza del Bitcoin come oro digitale.</p>
<p>Tuttavia, lo sviluppo dell’ecosistema Bitcoin non è limitato da una singola prospettiva o evento. Nonostante prospettive e sfide potenzialmente diverse, l’ecosistema Bitcoin dimostra adattabilità e diversità, evolvendo costantemente e integrando nuovi protocolli, espandendosi in nuove reti blockchain.</p>
<p>L’esperienza storica ha dimostrato che nonostante i dubbi e le incertezze, le tecnologie innovative spesso trovano opportunità di crescita e sviluppo in mezzo alle sfide. Come investitori, dobbiamo mantenere un approccio razionale a qualsiasi nuovo progetto, e dovremmo anche valutare attentamente lo sfondo del progetto, il team, la forza tecnica e il modello di business, e evitare di seguire ciecamente la tendenza degli investimenti. Il mercato delle criptovalute è pieno di opportunità e rischi, e mantenere la razionalità e la vigilanza è necessario per ottenere efficacemente rendimenti stabili a lungo termine.</p>
<div class="blog-details-info"><br><div>Autore:<strong>Byron B.</strong>, Ricercatore di Gate.io<br><div>Traduttore: Joy Z.<br><div class="info-tips"><em>Questo articolo rappresenta solo le opinioni del ricercatore e non costituisce alcun suggerimento di investimento.<br></em><div><em></em>Gate.io si riserva tutti i diritti su questo articolo. La ripubblicazione dell'articolo sarà consentita a condizione che venga citato Gate.io. In tutti i casi, saranno intraprese azioni legali a causa della violazione del copyright.<br></div><p></p><br></div></div></div></div>