TmF2aWdhcmUgbGEgZmlkdWNpYSBpbiBEZUZpOiBsJ2VmZmV0dG8gTGluZHkgc3VsbCdhZmZpZGFiaWxpdMOgIGRlbCBtYXJjaGlv

2024-11-12, 07:30

<p><img src="https://gimg2.gateimg.com/image/article/17313961831692587449analysis.jpeg" alt=""></p>
<h2 id="h2-TL20DR706642"><a name="[TL; DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL; DR]</h2><p>L’effetto Lindy è una teoria che aiuta gli investitori di criptovalute a valutare i livelli di rischio dei diversi progetti DeFi.</p>
<p>I protocolli DeFi aggiornabili possono costruire nel tempo un effetto Lindy a livello di marchio.</p>
<p>C’è il pericolo che alcuni investitori possano mantenere una fiducia di pregiudizio cognitivo sui protocolli aggiornabili che possono sviluppare vulnerabilità a causa di alcuni aggiornamenti.</p>
<h2 id="h2-Introduzione573440"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>Gli investitori intelligenti spesso utilizzano metodi diversi per valutare il potenziale a breve e lungo termine di alcuni strumenti di investimento. Questo è particolarmente importante quando si selezionano asset criptati in cui investire. Gli investitori al dettaglio e istituzionali possono utilizzare l’effetto Lindy per valutare il potenziale degli asset digitali prima di investire in essi. Questa analisi esamina l’effetto Lindy e la sua applicazione nella valutazione del potenziale delle criptovalute.</p>
<p>Articolo correlato: <a href="https://www.gate.io/learn/articles/returning-to-power-law-the-ultimate-secret-of-bitcoin/2840" target="_blank">Il segreto definitivo di Bitcoin: ritorno alla legge del potere</a></p>
<h2 id="h2-Paradosso20tra20la20natura20priva20di20fiducia20delle20criptovalute20limportanza20della20fiducia20nei20marchi20DeFi342215"><a name="Paradosso tra la natura priva di fiducia delle criptovalute: l’importanza della fiducia nei marchi DeFi" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Paradosso tra la natura priva di fiducia delle criptovalute: l’importanza della fiducia nei marchi DeFi</h2><p>Di solito, gli utenti di criptovalute mantengono la loro fiducia nei marchi DeFi che hanno utilizzato per lunghi periodi. Poiché ci sono molte minacce di attacchi maligni, utilizzano i protocolli che si sono dimostrati sicuri e che soddisfano le loro esigenze da molto tempo. Ad esempio, molti utenti di criptovalute investono in <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">bitcoin</a> perché la sua blockchain non è mai stata violata fin dalla sua creazione. In alcuni casi la fiducia degli investitori <a href="https://www.gate.io/learn/articles/how-defi-protocols-generate-revenue-and-why-its-important/2890" target="_blank">certi protocolli DeFi</a> rimane anche dopo alcuni aggiornamenti. Tuttavia, ogni aggiornamento porta al ripristino dell’intero sistema che può portare a vulnerabilità.</p>
<p>Leggi anche: <a href="https://www.gate.io/learn/articles/top-8-defi-protocols-on-ton/4032" target="_blank">Top 8 protocolli DeFi su TON</a></p>
<p>Anche se le criptovalute sono state progettate per essere prive di fiducia, nel tempo gli utenti sviluppano fiducia nei confronti di esse. <a href="https://www.gate.io/learn/articles/defi-eco-2024-preview-key-trends-and-direction-predictions-for-the-industry/1387" target="_blank">certi ecosistemi DeFi</a> o attività digitali. Sia la fiducia che la longevità dei progetti DeFi influenzano alcune persone a investire in protocolli DeFi specifici o attività digitali. Comprendere come funziona l’effetto Lindy potrebbe aiutare gli utenti a valutare in modo sistematico alcuni progetti DeFi prima di investire in essi.</p>
<h2 id="h2-Comprendere20lEffetto20Lindy250308"><a name="Comprendere l’Effetto Lindy" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Comprendere l’Effetto Lindy</h2><p>L’effetto Lindy, anche chiamato legge Lindy, è una teoria che afferma che la durata di una cosa non deperibile o pratica culturale è positivamente correlata alla sua età. Per illustrare, nella vita reale le persone tendono a fidarsi delle tecnologie, delle idee o dei fenomeni culturali che esistono da lungo tempo. In altre parole, dopo molto tempo di esistenza, le tecnologie diventano più affidabili di prima poiché sarebbero state perfezionate per superare determinate minacce possibili. Quindi, le tecnologie che hanno superato molte sfide in passato hanno maggiori probabilità di superare le minacce potenziali.</p>
<p>L’effetto Lindy è molto praticabile nel settore della blockchain. Aiuta a spiegare le blockchain, i protocolli DeFi e gli asset digitali che esistono da molto tempo. Tale resilienza dimostra la loro possibile longevità futura, la loro validità e redditività. Criptovalute che sono sul mercato da molto tempo come <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">bitcoin</a> e ETH dimostrano questo principio. In particolare, le persone vedono i progetti DeFi che hanno mantenuto per lunghi periodi un’alta sicurezza, decentralizzazione, immutabilità, scalabilità e supporto della comunità come resilienti e affidabili. Tale fiducia nel marchio crittografico è una delle ragioni per cui molte persone investono di più in determinati progetti basati su blockchain rispetto ad altri.</p>
<p>Leggi anche: <a href="https://www.gate.io/learn/articles/the-great-return-of-de-fi/4386" target="_blank">Il grande ritorno di DeFi</a></p>
<h2 id="h2-Leffetto20Lindy20nei20protocolli20DeFi770811"><a name="L’effetto Lindy nei protocolli DeFi" class="reference-link"></a><span class="header-link octicon octicon-link"></span>L’effetto Lindy nei protocolli DeFi</h2><p>L’effetto Lindy è molto applicabile <a href="https://www.gate.io/post/CryptoPotato/status/7400343" target="_blank">nel settore DeFi</a> dove troviamo protocolli aggiornabili e immutabili. Questo principio si applica maggiormente ai protocolli DeFi immutabili che sono beni non deperibili. In altre parole, un protocollo DeFi immutabile non può essere aggiornato. Pertanto, mantengono il loro status all’interno del settore blockchain. Se tali protocolli sono stati sicuri, senza sfruttamenti fin dalla loro nascita, è molto probabile che rimangano gli stessi in futuro</p>
<p>Un protocollo DeFi che si è dimostrato immutabile è <a href="/price/uniswap-uni" rel="nofollow noopener noreferrer" target="_blank">Uniswap</a> La v1, lanciata nel novembre 2018 e la v2, lanciata nel 2020, che hanno mantenuto il loro status da allora. Dall’apertura non sono state aggiornate tramite hard fork o mezzi simili. La cosa notevole è che hanno mantenuto la loro sicurezza DeFi da quando sono stati lanciati. Pertanto, gli utenti si aspettano che continuino a funzionare senza problemi senza sviluppare vulnerabilità.</p>
<p>Anche l’effetto Lindy sembra applicarsi fortemente al bitcoin, lanciato nel 2009. Come sappiamo, il <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">bitcoin</a> si è comportato bene negli ultimi 15 anni e sta mostrando segni di crescita sostenuta. Questo crea fiducia nel marchio dei principali criptovalute. Questo è il motivo per cui molti paesi hanno introdotto derivati del bitcoin. <a href="https://www.gate.io/bitwiki/detail/731/bitcoin-etfs" target="_blank">come gli ETF BTC</a>. Poiché è stata la prima criptovaluta, il bitcoin ha un ottimo track record. Ha superato diversi ostacoli, tra cui l’attenzione normativa di molti paesi.</p>
<p>In base all’effetto Lindy, il bitcoin potrebbe rimanere uno dei migliori asset di investimento se viene ampiamente accettato come mezzo di scambio e come deposito decentralizzato di ricchezza. Grazie alla sua rete sicura, molti investitori al dettaglio e istituzionali sono disposti ad investire in esso. Già nel 2021 El Salvador è diventato il <a href="https://www.gate.io/blog/1269/el-salvador-purchases-an-additional-80-btc" target="_blank">primo paese ad adottare bitcoin</a> come mezzo di pagamento legale. In modo significativo, la sua offerta limitata migliora la sua proposta di valore.</p>
<h2 id="h2-La20sfida20con20i20protocolli20aggiornabili417040"><a name="La sfida con i protocolli aggiornabili" class="reference-link"></a><span class="header-link octicon octicon-link"></span>La sfida con i protocolli aggiornabili</h2><p>Come detto in precedenza, l’effetto Lindy si applica perfettamente ai protocolli immutabili che non sono stati violati negli ultimi anni, diciamo dieci anni circa. Tuttavia, questo non vale per i protocolli aggiornabili. I protocolli DeFi aggiornabili sono le blockchain che possono essere aggiornate di volta in volta. Spesso, gli sviluppatori li aggiornano per aggiungere nuove funzionalità e risolvere problemi di sicurezza. <a href="/price/aave-aave" rel="nofollow noopener noreferrer" target="_blank">Aave</a>, <a href="https://www.gate.io/how-to-buy/compound-comp" target="_blank">Compound</a> e Lido sono esempi di protocolli DeFi aggiornabili.</p>
<p>A differenza dei protocolli immutabili che mantengono lo stesso stato, quelli aggiornabili cambiano ogni volta che viene lanciato un nuovo aggiornamento. Ciò avviene perché ogni volta che viene aggiunto un patch, il codice del protocollo cambia. In base all’effetto Lindy, ogni volta che viene lanciato un aggiornamento emerge una nuova entità che diventa soggetta a valutazione del rischio. Il fatto che l’ultimo aggiornamento possa presentare nuove vulnerabilità significa che gli utenti potrebbero avere bisogno di tempo per confermare la sua efficienza e sicurezza, tra le altre caratteristiche chiave.</p>
<p>Lo stesso principio si applica ai contratti intelligenti che sono costruiti su protocolli aggiornabili. Allo stesso modo, il lancio di un nuovo aggiornamento sulla blockchain sottostante resetta l’effetto Lindy per entrambi i protocolli. Questo vale anche per i protocolli modulari in cui le parti immutabili del <a href="/price/stacks-stx" rel="nofollow noopener noreferrer" target="_blank">pile</a> vengono sostituiti con dei nuovi.</p>
<h2 id="h2-Effetto20Lindy20di20livello20marchio20in20DeFi201818"><a name="Effetto Lindy di livello marchio in DeFi" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Effetto Lindy di livello marchio in DeFi</h2><p>La reputazione del marchio nel settore delle criptovalute dipende dalla popolarità del progetto DeFi dal momento del suo lancio. Come già osservato, l’effetto Lindy a livello di protocollo si resetta ogni volta che c’è un aggiornamento. Tuttavia, l’effetto Lindy a livello di marchio continua a crescere nonostante l’aggiornamento. Inoltre, la fiducia in tali protocolli DeFi cresce in base alla reputazione del team, al record di sicurezza del progetto e al track record complessivo. Altri fattori che aiutano a migliorare i marchi DeFi includono il coinvolgimento della comunità, gli sforzi di marketing e le verifiche regolari.</p>
<h2 id="h2-Il20bias20cognitivo20della20sovrafiducia982726"><a name="Il bias cognitivo della sovrafiducia" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Il bias cognitivo della sovrafiducia</h2><p>A volte gli utenti trascurano la sicurezza DeFi di diversi protocolli perché hanno avuto a che fare con essi per lunghi periodi. Anche se tali progetti hanno avuto aggiornamenti recenti dei protocolli DeFi che potrebbero aver cambiato il loro stato di sicurezza. Il motivo per cui gli utenti si attengono a tali progetti DeFi è il loro bias cognitivo. Il fatto che tali progetti abbiano avuto buone performance negli ultimi anni senza incidenti gravi li porta a mantenere la fiducia in essi. Tuttavia, a causa di alcuni aggiornamenti, i protocolli una volta affidabili potrebbero incontrare vulnerabilità impreviste nonostante gli aggiornamenti ben intenzionati.</p>
<p>In particolare, questa fiducia si sviluppa nel corso di molti anni. Un esempio è <a href="https://www.gate.io/how-to-buy/euler-eul" target="_blank">quello di Euler</a> che è stato hackerato nel marzo 2023 dopo aver introdotto un aggiornamento con una nuova funzionalità mirata a migliorarne la funzionalità. Purtroppo, quell’aggiornamento è diventato il facilitatore dello sfruttamento.</p>
<h2 id="h2-Come20applicare20lEffetto20Lindy20nella20valutazione20dei20protocolli20e20dei20marchi20DeFi23873"><a name="Come applicare l’Effetto Lindy nella valutazione dei protocolli e dei marchi DeFi" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Come applicare l’Effetto Lindy nella valutazione dei protocolli e dei marchi DeFi</h2><p>L’effetto Lindy ci illumina sulla necessità di valutare gli elementi sottostanti, le caratteristiche e le tecnologie delle blockchain i cui prodotti intendiamo investire. In effetti, c’è la necessità di effettuare una completa valutazione del rischio DeFi di ogni progetto in cui intendiamo investire. È importante valutare la sua struttura di governance, la sicurezza della rete e i processi di consenso. Pertanto, diventa essenziale <a href="https://www.gate.io/learn/articles/3-opportunities-and-2-challenges-for-de-fi-in-new-era/4681" target="_blank">investire in marchi DeFi</a> che hanno un track record di decentralizzazione e sicurezza. Inoltre, diventa fondamentale mettere risorse personali in progetti che sono stati sul mercato per lunghi periodi.</p>
<p>L’effetto Lindy insegna agli investitori la necessità di avere una prospettiva a lungo termine quando si investe in progetti e asset DeFi. Pertanto, dovremmo astenerci dal investire in progetti criptati con la speranza di generare profitti rapidi basati su tendenze speculative. È anche importante rendersi conto che ci sono molti protocolli aggiornabili che accumulano l’effetto Lindy. Pertanto, gli investitori possono investire in essi.</p>
<h2 id="h2-Conclusione565601"><a name="Conclusione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusione</h2><p>L’effetto Lindy è una legge che aiuta gli investitori di criptovalute a valutare il valore di vari progetti DeFi prima di investire in essi. Afferma che la speranza di vita di una cosa non deperibile è positivamente correlata alla sua età. In questo contesto, alcune tecnologie come le blockchain possono accumulare l’effetto Lindy. Infine, gli investitori dovrebbero valutare la sicurezza, la decentralizzazione e la affidabilità dei progetti digitali in cui desiderano investire.</p>
<div class="blog-details-info"><br><div>Autore:<strong>Mashell C.</strong>, Ricercatore Gate.io<br><div class="info-tips"><em>Questo articolo rappresenta solo le opinioni del ricercatore e non costituisce alcun suggerimento di investimento. Tutti gli investimenti comportano rischi intrinseci; la prudenza decisionale è essenziale.<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 fornito il riferimento a Gate.io. In tutti i casi, saranno adottate azioni legali per violazione del copyright.<br></div><p></p><br></div></div></div>