RGUgb3Brb21lbmRlIHRyZW5kOiB3ZWxrZSBuaWV1d2Uga2Fuc2VuIGJpZWR0IERlU2NpIGFhbj8=

2025-01-08, 09:26

<h2 id="h2-TL20DR124962"><a name="[TL; DR]:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL; DR]:</h2><p>Onlangs heeft de markt een stijgende golf van interesse in DeSci gezien.<br>Zo vroeg als 2021 kwam DeSci in de schijnwerpers door VitaDAO op te richten, maar slaagde er niet in brede aandacht te krijgen.</p>
<p>Het was pas recent, met de geconcentreerde uitbraak van een reeks trendy gebeurtenissen, dat dit eens zo nichemarkt opnieuw aanzienlijke marktfocus kreeg.</p>
<h2 id="h2-Introduction179274"><a name="Introduction" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduction</h2><p>De oorspronkelijke bedoeling van DeSci is om een gedeeld academisch onderzoeksecosysteem voor wetenschappers en geleerden te creëren. Het doel is om financieringsbarrières in traditioneel wetenschappelijk onderzoek te slechten, wereldwijde samenwerking tussen wetenschappers te bevorderen en de openheid en transparantie van onderzoeksgegevens te waarborgen. Daarom is DeSci lange tijd gezien als verheven en onbereikbaar, beschouwd als een “ivoren toren” -experiment en verwaarloosd door de reguliere markt. Onlangs heeft een reeks trending events echter interesse gewekt en is DeSci snel een centraal punt geworden in opkomende markten.</p>
<h2 id="h2-Wat20is20DeSci961727"><a name="Wat is DeSci?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wat is DeSci?</h2><p>DeSci, of Decentralized Science, verwijst naar een gedecentraliseerd model van wetenschappelijk onderzoek.<br><img src="https://gimg2.gateimg.com/image/article/1736329665screenshot-20250108-172335.png" alt=""><br>Waarom zou het ecosysteem voor wetenschappelijk onderzoek decentralisatie moeten nastreven? De reden hiervoor is dat onder het traditionele wetenschappelijke onderzoekssysteem gecentraliseerde entiteiten vaak de belangrijke elementen domineren die nodig zijn voor wetenschappelijke ontwikkeling, zoals middelen en financiering, waardoor ze aanzienlijke controle uitoefenen over onderzoeksresultaten en voortgang. Vanuit een breder perspectief heeft deze karakteristiek in zekere mate praktische obstakels gecreëerd voor de vooruitgang van de wetenschap.</p>
<p>Onder het traditionele onderzoeksmodel blijft het balanceren van veiligheid, transparantie, stimuleringsmechanismen en toegankelijkheid op het gebied van kennisdeling een uitdaging in de hele industrie. Traditionele modellen vertrouwen meestal op gecentraliseerde verificatieen, die de inclusiviteit en brede deelname kunnen beperken. Bovendien slaagt het bestaande model er vaak niet in om kennisbijdragers adequaat te stimuleren, waardoor de ontwikkeling van wetenschappelijke inspanningen wordt belemmerd.</p>
<p>Het is tegen deze achtergrond dat DeSci (Decentralized Science) is ontstaan. Door gebruik te maken van blockchain-technologieën zoals tokens, NFT’s en gedecentraliseerde autonome organisaties (DAO’s), biedt DeSci een gedecentraliseerde benadering om verschillende aspecten van traditionele wetenschappelijke vakgebieden te transformeren, waaronder fondsenwerving, gegevensuitwisseling, publiceren en samenwerken. Dit biedt een eerlijker, transparanter en gedecentraliseerder platform voor wetenschappelijk onderzoek.</p>
<p>Bijvoorbeeld, op het gebied van fondsenwerving wordt theoretisch verwacht dat financiers, wetenschappers en uitgevers samenwerken om de vooruitgang, verspreiding en toepassing van wetenschappelijk onderzoek te bevorderen. In het traditionele onderzoeksmodel zijn deze drie belangrijke onderdelen - fondstoewijzing door financiers, onderzoek uitgevoerd door wetenschappers en verspreiding van resultaten door uitgevers - vaak gefragmenteerd vanwege problemen met de verdeling van belangen. Als onafhankelijke economische entiteiten worden ze meer gedreven door individuele belangen dan door de collectieve doelen van de wetenschappelijke gemeenschap. Deze situatie leidt tot inefficiënte allocatie van middelen en belemmert het delen van onderzoeksresultaten, wat uiteindelijk de gezonde ontwikkeling van wetenschappelijk onderzoek belemmert.</p>
<p>Aan de andere kant kan DeSci transparante en efficiënte financieringsondersteuning bieden voor onderzoeksprojecten via DAO’s en getokeniseerde economische modellen, waardoor verspilling van middelen wordt vermeden. In combinatie met blockchaintechnologie kan het het academische publicatieproces decentraliseren, waardoor transparantie en verifieerbaarheid van onderzoeksresultaten worden gewaarborgd, terwijl publicatiekosten worden verlaagd en de monopolistische invloed van traditionele uitgevers wordt verminderd. Belangrijker nog, financiers kunnen de vertaling van onderzoeksresultaten naar praktische toepassingen versnellen door community-gedreven wetenschappelijke samenwerkingsmodellen te introduceren, waardoor de maatschappelijke impact van wetenschappelijk onderzoek wordt vergroot.</p>
<p>Het is duidelijk dat, onder het DeSci-model, blockchaintechnologie de beveiliging van gegevensopslag in wetenschappelijk onderzoek verbetert; DAO’s zorgen voor transparantie bij de toewijzing van financiering en projectbestuur; en tokens stimuleren onderzoekers, moedigen deelname aan en bevorderen eigendom van onderzoeksresultaten. In die zin maakt DeSci gebruik van <a href="/web3" rel="nofollow noopener noreferrer" target="_blank">Web3</a> technologieën om een meer rechtvaardige en inclusieve infrastructuur op te bouwen voor wetenschappelijk onderzoek. Bovendien is de speculatieve aard van cryptocurrency-markten constructief geïntegreerd in het niet-speculatieve domein van wetenschappelijk onderzoek.</p>
<h2 id="h2-Belangrijke20gebeurtenissen20die20de20opkomst20van20DeSci20stimuleren491616"><a name="Belangrijke gebeurtenissen die de opkomst van DeSci stimuleren" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Belangrijke gebeurtenissen die de opkomst van DeSci stimuleren</h2><p>De oorspronkelijke bedoeling van DeSci was om een gedeeld academisch onderzoeksecosysteem voor wetenschappers te creëren. Om deze reden heeft DeSci lang geworsteld om de waarde die <a href="/web3" target="_blank" class="blog_inner_link">Web3</a> echt aanbrengt volledig te absorberen - namelijk, gemeenschapseffecten en een efficiënt economisch systeem - vanuit het perspectief van het onderzoeken van het traject en het verhaal.</p>
<p>De basis van DeSci ligt bijvoorbeeld in een actief ecosysteem dat wordt ondersteund door een efficiënt tokensysteem en gemeenschapseffecten. De sleutel tot zo’n economisch systeem is brede gebruikersdeelname. Als gebruikers niet echt betrokken kunnen zijn of onvoldoende motivatie hebben om tokens vast te houden en te verhandelen, zal de prijs, liquiditeit en het hele economische systeem van de token moeilijk te handhaven zijn. Daarom kan een duurzaam mechanisme niet uitsluitend worden gebaseerd op wetenschappers binnen de academische gemeenschap als kerndeelnemers. Dit is een van de belangrijkste redenen waarom DeSci, ondanks dat het in 2021 in de publiciteit kwam met de oprichting van VitaDAO, geen brede aandacht heeft gekregen.</p>
<p>Het was pas onlangs, met het opkomen van een reeks prominente gebeurtenissen, dat de DeSci-sector eindelijk aanzienlijke marktaandacht kreeg en een rijzende ster werd in de <a href="/web3" target="_blank" class="blog_inner_link">Web3</a>-ruimte.</p>
<p>Een toonaangevende community fundraisingscampagne van een project bereikte zijn limiet en haalde een indrukwekkende $33 miljoen op. Al snel volgden er berichten dat Vitalik een offline DeSci-thema-evenement bijwoonde in Bangkok. In een podcast deelde Vitalik zijn hoop om meer innovatie te zien in de DeSci-ruimte. Op 3 januari van dit jaar werd de BIO-token gelanceerd en steeg snel naar een piekprijs van $1,477, waarbij deelnemers aan de openbare verkoop theoretisch rendementen behaalden tot 58x. Een reeks hoogwaardige evenementen heeft de snelle stijging in de populariteit van DeSci aangewakkerd.</p>
<p>Zelfs op marktniveau zijn er discussies begonnen over de vraag of DeSci de volgende bullmarkt zou kunnen leiden. Volgens Kaito-gegevens is het verhaal rond het DeSci-concept van begin 2024 tot eind 2024 met 2.640% gegroeid.<br><img src="https://gimg2.gateimg.com/image/article/1736329694screenshot-20250108-134530.png" alt=""><br>Het kan gezegd worden dat de hype rondom het DeSci verhaal volledig is ontstoken. Het is echter de moeite waard om op te merken dat DeSci projecten zich nog in de vroege prestatiefases bevinden in de kapitaalmarkt.<br><img src="https://gimg2.gateimg.com/image/article/1736329722DeSci.png" alt=""><br>Op het moment van publicatie op Gate.io toont CoinGecko-gegevens aan dat de totale marktkapitalisatie van AI Agent-gerelateerde tokens ongeveer $2,1 miljard is. Hoewel de totale marktkapitalisatie nog geen grootschalig effect heeft bereikt, blijft de groeiende invloed van dit vakgebied zich uitbreiden. In de toekomst, naarmate er meer projecten worden geïmplementeerd en onderzoeksresultaten worden toegepast, wordt verwacht dat de prestaties van DeSci op de kapitaalmarkt gestaag zullen verbeteren, waardoor de weg wordt vrijgemaakt voor diepere integratie tussen wetenschap en <a href="/web3" target="_blank" class="blog_inner_link">Web3</a> met bredere ontwikkelingsvooruitzichten.</p>
<h2 id="h2-Top20DeSci20Projects20om20in20de20gaten20te20houden884952"><a name="Top DeSci Projects om in de gaten te houden" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Top DeSci Projects om in de gaten te houden</h2><p>BioDAO Protocol ($BIO)<br><img src="https://gimg2.gateimg.com/image/article/1736329744BIo.png" alt=""></p>
<p>BIO Protocol is een protocol voor curation en liquiditeit in Gedecentraliseerde Wetenschap (DeSci), aanvankelijk gefinancierd door Binance Labs. Het heeft tot doel om ondersteuning te bieden voor wetenschappelijke onderzoeksprojecten en innovatie in wetenschappelijk onderzoek te stimuleren.</p>
<p>De kerncomponenten van het protocol omvatten BioDAO, een curatiesysteem, tokenisering van intellectueel eigendom en liquiditeitsmechanismen, en een stimuleringssysteem. Door middel van meerdere rondes van veilingen en airdrop-programma’s heeft het BIO Protocol een diverse en zeer betrokken gemeenschap opgebouwd, waarbij de basis wordt gelegd voor een gedecentraliseerd biomedisch onderzoeksnetwerk.</p>
<p>Het protocol haalt in de eerste plaats geld op via tokenverkopen om de ontwikkeling van biotechnologieprojecten te ondersteunen en vestigt gedeeld eigendom van intellectuele eigendom onder zijn leden. Volgens officiële informatie heeft BioDAO: Launch succesvol zeven sub-DAO’s geïnitieerd, waarvan drie extra sub-DAO’s momenteel in ontwikkeling zijn.</p>
<p>SCI-HUB ($SCIHUB)<br><img src="https://gimg2.gateimg.com/image/article/1736329762screenshot-20250108-161003.png" alt=""><br>SCI-HUB is een platform dat gratis toegang tot en downloads van wetenschappelijke artikelen mogelijk maakt en valt onder wetenschappelijke donatie. Het is momenteel onderwerp van controverse. Voorstanders beweren dat het wetenschappers en studenten wereldwijd gratis toegang geeft tot wetenschappelijke artikelen, waardoor het monopolie van wetenschappelijke uitgevers wordt doorbroken en gedecentraliseerde wetenschap wordt vertegenwoordigd. Aan de andere kant beweren critici (FUD) dat SCI-HUB een piratensite is voor wetenschappelijke artikelen. Het omzeilt de betaalmuren van uitgevers via verschillende methoden en biedt miljoenen wetenschappelijke artikelen en werken zonder het aanpakken van auteursrechtskwesties, wat zorgen baart over piraterij-naleving.</p>
<p>ResearchHub ($RSC)</p>
<p><img src="https://gimg2.gateimg.com/image/article/1736329778screenshot-20250108-161622.png" alt=""></p>
<p>ResearchHub is een innovatief online platform dat wetenschappelijke ontdekking versnelt door samenwerking en open onderzoek te bevorderen. Het stelt onderzoekers, wetenschappers en liefhebbers in staat om wetenschappelijke inhoud over disciplines heen te delen, bespreken en ueren binnen een gedecentraliseerde gemeenschap.</p>
<p>Door deelname te stimuleren met RSC, verbetert ResearchHub de transparantie en beloont bijdragen zoals het delen van preprints, het beoordelen van papers en deelname aan academische discussies. Haar missie is om traditionele barrières in de academische wereld af te breken, de snelle verspreiding van kennis te faciliteren en wereldwijde samenwerking te bevorderen. Het platform is opgericht door Brian Armstrong, de oprichter van Coinbase, en wordt voornamelijk gebruikt om gebruikers te stimuleren om hoogwaardige inhoud op het platform te publiceren.</p>