RGVTY2krTWVtZSwgw4ggdW4gYWx0cm8gbnVvdm8gdGlwbyBkaSBwb3RlbnppYWxlIHRyYWNjaWEgZGkgY29tYmluYXppb25lPw==

2024-11-21, 08:29

<p><img src="https://gimg2.gateimg.com/image/article/17321773501690791857hotspot.jpeg" alt=""></p>
<h2 id="h2-TLDR779569"><a name="[TL;DR]:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL;DR]:</h2><p>Il campo DeSci, come un campo emergente che può essere combinato con applicazioni reali, ha di recente attirato l’attenzione di un gran numero di investitori e flussi di capitale, a partire dagli investimenti in BIO Protocol.</p>
<p>La combinazione di DeSci e Meme è diventata anche un nuovo argomento caldo, e i progetti innovativi RIF e URO dalla piattaforma Pump.Science hanno attirato una significativa attenzione di mercato.</p>
<p>Alcuni progetti DeSci, come Sci Hub, hanno un certo grado di innovazione e praticità. Con la popolarità di Meme, aiutano a migliorare l’interesse pubblico e la consapevolezza di DeSci.</p>
<h2 id="h2-Introduzione366339"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>Dopo AI Meme, mascotte Meme, artwork Meme e animal rescue Meme, anche il settore DeSci ha recentemente attirato l’attenzione del mercato, a partire dagli investimenti su larga scala nel protocollo di cura decentralizzato e di liquidità BIO Protocol, e una nuova ondata di Meme ha silenziosamente fatto la sua comparsa.</p>
<p>Anche se la popolarità di DeSci nell’industria è ancora bassa, questo nuovo concetto ha evidenziato un nuovo livello di popolarità con l’aggiunta di Meme. Questo articolo esplorerà questo in dettaglio.</p>
<h2 id="h2-DeSci20Molecule20DAO20e20PumpScience785584"><a name="DeSci, Molecule DAO e Pump.Science" class="reference-link"></a><span class="header-link octicon octicon-link"></span>DeSci, Molecule DAO e Pump.Science</h2><p>DeSci, anche conosciuto come ‘scienza decentralizzata’, è un campo emergente delle criptovalute che mira a utilizzare <a href="/web3" rel="nofollow noopener noreferrer" target="_blank">Web3</a> tecnologie (inclusi NFT, smart contract e DAO) per promuovere un finanziamento equo ed equo, la creazione, la revisione, la conservazione e la diffusione della conoscenza scientifica. Questa azione innovativa incoraggia gli scienziati a condividere pubblicamente i risultati delle loro ricerche, rendendo facile per chiunque accedere e contribuire agli successi scientifici.</p>
<p>Sebbene DeSci sia ancora un concetto nuovo per molti operatori crittografici e la sua popolarità non sia alta, molti VC e KOL hanno espresso pubblicamente il loro <a href="/price/optimism-op" rel="nofollow noopener noreferrer" target="_blank">ottimismo</a> riguardo a questo campo.</p>
<p>Secondo le statistiche di ThePASS dell’anno scorso, DAO ha rappresentato la maggior parte tra le organizzazioni legate a DeSci, tra cui quelle famose come ResearchHub, VitaDAO, MoonDAO, CrunchDAO, ecc.<img src="https://gimg2.gateimg.com/image/article/17321775521.jpeg" alt=""><br>Fonte: ThePASS</p>
<p>L’articolo presenta principalmente il <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> Ecosistema Molecule DAO, un’organizzazione DeSci attiva costruita nel 2020. Non solo ha proposto il concetto di combinare la proprietà intellettuale con la criptovaluta utilizzando la tecnologia IP-NFT, consentendo la condivisione della proprietà dei progetti di ricerca scientifica, ma ha anche lanciato un lancio di Meme coin chiamato Pump.Science alla conferenza <a href="/price/solana-sol" target="_blank" class="blog_inner_link">Solana</a> Breakpoint su Token 2049.<img src="https://gimg2.gateimg.com/image/article/17321775732.jpeg" alt=""><br>Origine: molecule.xyz</p>
<p>A differenza di altre piattaforme di Meme coin, la caratteristica di Pump.Science è il supporto alla ricerca sperimentale medica. I ricercatori medici possono presentare proposte di ricerca sui farmaci e condurre esperimenti sui vermi sulla piattaforma. Gli utenti possono partecipare al processo sperimentale scambiando Meme token che rappresentano farmaci, prevedendo gli effetti dei farmaci in base ai risultati sperimentali e continuando a scambiare Meme token.</p>
<p>In altre parole, Pump.Science può essere visto come un gioco di previsione sperimentale sull’estensione della durata della vita basato su token. Dopo aver emesso token Meme che rappresentano farmaci su Pump.fun, i giocatori possono condurre transazioni direttamente. Quando la capitalizzazione di mercato raggiunge i $10.000, l’organizzazione di ricerca medica ORA Biomedical utilizzerà il farmaco in esperimenti e pubblicherà regolarmente i risultati dei test sulla piattaforma Pump.Science. Questo modello innovativo non fornisce solo supporto finanziario per gli esperimenti medici, ma offre anche agli utenti un modo interessante per partecipare alla ricerca scientifica.<br><img src="https://gimg2.gateimg.com/image/article/17321775923.jpeg" alt=""><br>Sorgente: pump.science</p>
<p>Di recente, le due criptovalute Meme di Pump.Science sono diventate rapidamente popolari, attirando l’attenzione del mercato verso la traccia DeSci.</p>
<h2 id="h2-Con20un20aumento20centuplicato20in20una20settimana20RIF20URO20e20SCIHUB20stanno20diventando20virali700433"><a name="Con un aumento centuplicato in una settimana, RIF, URO e SCIHUB stanno diventando virali" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Con un aumento centuplicato in una settimana, RIF, URO e SCIHUB stanno diventando virali</h2><p>Questa settimana, DeSci ha ricevuto molta attenzione con il supporto di CZ, Vitalik e altre piattaforme. In particolare, i token DAO dell’ecosistema BIO come VITA, ATH e RSC hanno visto tutti significativi aumenti, e anche nel contesto di vari settori Altcoin che vengono sanguinati, questi token hanno mantenuto una forte performance.</p>
<p>Forse ispirato da AIMeme, la combinazione di DeSci+Meme è diventata un nuovo punto di riferimento. Anche se le due nuove monete, RIF e URO, dalla piattaforma Pump.science non hanno attratto molta attenzione nelle fasi iniziali del loro lancio, con capitalizzazioni di mercato che oscillavano intorno a $150.000, questi due token hanno recentemente sperimentato una crescita esplosiva. In meno di due giorni, le capitalizzazioni di mercato di RIF e URO sono schizzate a $173 milioni e $55,6 milioni, un aumento straordinario di cento volte.</p>
<h2 id="h2-Rifampicina20RIF200610"><a name="Rifampicina (RIF)" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Rifampicina (RIF)</h2><p>Rifampicina è un meme dell’ecosistema BIO, che rappresenta il <a href="/price/compound-comp" rel="nofollow noopener noreferrer" target="_blank">composto</a> rifampicina. La rifamicina (RIF), come antibiotico, è stata tradizionalmente utilizzata per trattare la tubercolosi e altre malattie.</p>
<p>Tuttavia, negli ultimi anni, i ricercatori hanno scoperto che potrebbe avere effetti inaspettati sull’anti-invecchiamento. Nei piccoli organismi come il C. elegans, un organismo modello comunemente utilizzato nella ricerca sull’invecchiamento, è stato dimostrato che il RIF attiva i meccanismi di difesa naturali delle cellule, combatte lo stress e i danni, e prolunga la vita di questi organismi.</p>
<p>Sebbene al momento non sia chiaro se la rifampicina possa produrre lo stesso effetto negli esseri umani, la sua capacità di promuovere la salute cellulare l’ha resa un argomento di grande interesse nella ricerca sulla terapia anti-invecchiamento.<img src="https://gimg2.gateimg.com/image/article/17321776244.jpeg" alt=""><br>Origine: pump.science</p>
<h2 id="h2-Urolitina20A20URO763260"><a name="Urolitina A (URO)" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Urolitina A (URO)</h2><p>Urolitina (URO) è un composto che il corpo umano produce quando si consumano alimenti ricchi di tannini ellagici, come il melograno.</p>
<p>Ha una speciale funzione di “pulizia cellulare”, che può rimuovere le vecchie e disfunzionali mitocondri (la fabbrica di energia delle cellule), permettendo ai mitocondri freschi e sani di prosperare.</p>
<p>Questo processo è chiamato mitofagia ed è stato dimostrato prolungare la durata di vita di C. elegans, rendendo le sue cellule più efficienti e vitali.</p>
<p>Nella ricerca umana, gli uroliti hanno anche mostrato potenziale nel migliorare la salute muscolare e l’energia, cosa che è una buona notizia per questi due aspetti che gradualmente diminuiscono con l’età.<br><img src="https://gimg2.gateimg.com/image/article/17321776545.jpeg" alt=""><br>Fonte: pump.science</p>
<h2 id="h2-SciHub20SCIHUB332619"><a name="Sci-Hub (SCIHUB)" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Sci-Hub (SCIHUB)</h2><p>Sci-Hub è considerato un pioniere del movimento DeSci ed è cresciuto in un database contenente 88.343.822 articoli di ricerca e libri. Con un traffico globale fino a 60.000 visite all’ora, attira l’attenzione di numerosi scienziati e ingegneri e forma un forte consenso nella comunità.</p>
<p>La piattaforma Sci Hub stessa è una piattaforma DeSci dedicata a fornire risorse accademiche gratuite e servizi di e-book. Il suo concetto principale è che la conoscenza umana dovrebbe essere libera e non monopolizzata dalle autorità accademiche e dagli editori. Questo concetto risponde alla diffusa richiesta di accesso alle risorse accademiche, specialmente quando si è di fronte a elevate tariffe di abbonamento e rigide restrizioni sul copyright.<img src="https://gimg2.gateimg.com/image/article/17321776746.jpeg" alt=""><br>Origine: sci-hub.se</p>
<p>Sci Hub collabora anche con altri progetti DeSci come Ocean Protocol, BIO Protocol e Dlifexyz per promuovere la ricerca scientifica e la condivisione dei dati. Questi progetti consentono a più persone di accedere liberamente e condividere la conoscenza scientifica attraverso mercati di dati decentralizzati, tokenizzazione della proprietà intellettuale scientifica e monetizzazione della vita digitale, promuovendo ulteriormente lo sviluppo di DeSci.</p>
<p>La capitalizzazione di mercato della criptovaluta Meme scihub con lo stesso nome ha raggiunto i 38 milioni di dollari, e il trading è molto attivo.<img src="https://gimg2.gateimg.com/image/article/17321776927.jpeg" alt=""><br>Origine: Gate.io</p>
<p>Vale la pena menzionare che tutti e tre i principali token sono stati elencati su Gate.io.</p>
<h2 id="h2-Riepilogo152844"><a name="Riepilogo" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Riepilogo</h2><p>Come visto dal sopra, il campo DeSci, come campo emergente che può essere combinato con applicazioni del mondo reale, ha recentemente attirato l’attenzione di molti investitori e afflussi di capitale.</p>
<p>A differenza delle tradizionali Meme coin, che hanno proprietà puramente di intrattenimento, le Meme coin DeSci cercano spesso di combinare la ricerca scientifica e progetti educativi, aggiungendo un livello di significato e valore, attirando così un gruppo di persone che perseguono l’innovazione tecnologica e il contributo sociale.</p>
<p>In effetti, ci sono effettivamente alcuni progetti DeSci come Sci Hub che hanno un certo grado di innovazione e praticità, ma naturalmente, anche queste nuove cose sono state criticate. Le monete Meme correlate derivate da esse possono contribuire ad aumentare l’interesse pubblico e la consapevolezza del DeSci fino a un certo punto, aprendo nuovi canali per la raccolta di fondi per la ricerca scientifica, e persino incoraggiare più persone a partecipare alle attività di ricerca scientifica.</p>
<p>Tuttavia, per tornare al punto, molti progetti DeSci sono ancora nelle prime fasi, e ci sono incertezze riguardo alla tecnologia, al finanziamento e alla legge. L’effimera eccitazione che circonda molte Meme coins è il risultato del comportamento del mercato, e gli investitori devono rimanere razionali e vigili sui potenziali rischi.</p>
<div class="blog-details-info"><br><div>Autore:<strong>Charle Y.</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. Tutti gli investimenti comportano rischi intrinseci; è essenziale prendere decisioni prudenti.<br></em><div><em></em>Gate.io si riserva tutti i diritti su questo articolo. Sarà consentito il ripostaggio dell'articolo a condizione che venga citato Gate.io. In tutti i casi, verranno intraprese azioni legali a causa di violazione del copyright.<br></div><p></p><br></div></div></div></div>