WmFsIERlUElOIGRlIG1lZXN0IHdhYXJkZXZvbGxlIGludmVzdGVyaW5nIGluIGNyeXB0b2dyYWZpc2NoZSBhY3RpdmEgd29yZGVuPw==

2024-01-10, 07:20

<p><img src="https://gimg2.gateimg.com/image/article/1692587449analysis.jpeg" alt=""></p>
<h2 id="h2-TDLR404825"><a name="TD;LR" class="reference-link"></a><span class="header-link octicon octicon-link"></span>TD;LR</h2><p>Plotseling lijkt iedereen enthousiast te zijn over DePIN, maar eigenlijk is het al een ‘oude bekende’ van ons, alleen met een nieuwe naam en een frisse start.</p>
<p>Wat maakt DePIN zo populair? Waarom zijn mensen opeens bereid om te geloven dat het de beste investeringsrichting van 24 jaar is? Is het alleen maar overdreven promotie van de sectorrotatie, of hebben we het echt zo nodig?<br><img src="https://gimg2.gateimg.com/image/article/1704874593img_v3_026v_c952c15c-1e38-4861-bfc9-9c96ecdf22ix.jpg" alt=""></p>
<h2 id="h2-DePIN2020wat20zijn20ze684990"><a name="DePIN - wat zijn ze?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>DePIN - wat zijn ze?</h2><p>DePIN staat voor Decentralized physical infrastructure, wat verwijst naar gedecentraliseerde fysieke infrastructuur en voortdurende connectiviteit met real-world use cases. Kort gezegd maakt DePIN gebruik van een token-economisch model om de implementatie van fysieke infrastructuur te stimuleren, waardoor mijnwerkers en gebruikers hun hardware, netwerkruimte of rekenkracht kunnen delen en op die manier grootschalige netwerkeffecten kunnen creëren. Dit ontgrendelt de snelle ontwikkeling van diverse innovatieve DApps op basis van real-world data.</p>
<p>Maar zoals we aan het begin zeiden, is DePIN een oude partner met een nieuwe naam, de <a href="/price/filecoin-fil" target="_blank" class="blog_inner_link">FileCoin</a> waar we bekend mee zijn, <a href="/price/arweave-ar" rel="nofollow noopener noreferrer" target="_blank">arweave</a> en <a href="/price/helium-hnt" rel="nofollow noopener noreferrer" target="_blank">Helium</a> Het is een typisch voorbeeld, en ze zijn allemaal oude, langbestaande projecten.</p>
<p><a href="/price/filecoin-fil" rel="nofollow noopener noreferrer" target="_blank">Filecoin</a> <a href="/price/arweave-ar" target="_blank" class="blog_inner_link">Arweave</a> en Gate.io zijn beide ontworpen als opslagproducten. In eenvoudige bewoordingen betekent dit dat mijnwerkers hun ongebruikte netwerknodes bijdragen en beloond worden met tokens. Gebruikers betalen voor en gebruiken deze netwerkruimte voor opslag, waardoor er een gedecentraliseerde cloudopslag ontstaat.</p>
<p>Helium stelt gebruikers in staat hardware te kopen of te bouwen, deze in te voegen in een hotspot en zich zo bij het netwerk aan te sluiten om internetdiensten in dat geografische gebied te leveren. Als beloning verzamelt de hotspot de Helium-tokens HNT.</p>
<p>Helium heeft een voorsprong op dit gebied en trekt samenwerking aan met projecten op het gebied van weersvolging, luchtkwaliteitsbewaking en GPS-integratie. Tegelijkertijd kopen mensen die een netwerk van verbonden hardware gebruiken gegevenspunten (DC) om verbrande HNT te krijgen, wat helpt bij het handhaven van de vraag en het aanbod van HNT door verbranding en het slaan van munten.</p>
<p>Volgens Messari, die het concept van DePIN heeft geïntroduceerd, kan Depin worden onderverdeeld in vier delen: servernetwerk, draadloos netwerk, sensorisch netwerk en energienetwerk.<br><img src="https://gimg2.gateimg.com/image/article/1704874644img_v3_026v_e1a4521a-775e-46b2-9ddf-4f63b3552dix.jpg" alt=""><br>Afbeelding met dank aan MESSARI</p>
<h2 id="h2-Wat20is20het20probleem20dat20DePIN20wil20oplossen125453"><a name="Wat is het probleem dat DePIN wil oplossen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wat is het probleem dat DePIN wil oplossen</h2><p>Om het probleem te begrijpen dat DePIN probeert op te lossen, kun je er een glimp van opvangen vanuit zijn economische model. We kunnen het zien als het bestaan van twee hoofdgroepen in het netwerk: leveranciers en vragers, waarbij leveranciers hun eigen netwerkknooppunten, inactieve ruimte of rekenkracht leveren en middelen uitwisselen voor tokens; Vragers betalen tokens om bronnen of diensten te kopen, zoals de opslagdiensten van FileCoin.</p>
<p>Wat DePIN bijzonder maakt, is dat de ICT-bronnen (informatie- en computer technologie) die het betreft, in het traditionele model zeer gecentraliseerd zijn, net als cloud computing en big data zoals we die kennen, die over het algemeen worden beheerst door grote bedrijven op een bijna monopolistische manier, met invloed op de hardware en ontwikkeling ervan, hoge prijzen, wat resulteert in een zeer hoge toegangsdrempel, en deze hoge prijzen zullen zeker worden doorberekend aan de consument.</p>
<p>Bovendien is het gebruik van gecentraliseerde infrastructuur zoals cloud computing laag. Volgens het rapport van Flexera 2022 wordt gemiddeld 32% van het cloud budget van bedrijven verspild, wat betekent dat een derde van de middelen onbenut blijft. Deze problemen kunnen allemaal worden opgelost in het DePIN-model.</p>
<p>DePIN heeft op natuurlijke wijze het probleem van monopolie en centralisatie vermeden, en heeft op efficiënte wijze ongebruikte middelen geïntegreerd en opgeroepen, samen met synergie met andere trajecten, zoals DePIN +AI samenwerking, waardoor een grote hoeveelheid reken- en opslagbehoeften perfect wordt ingezet voor AI, waardoor de productiviteit van het Web3-domein wordt bevrijd. Het bestaande project Akash Network is hiervan een typisch voorbeeld: in vergelijking met gecentraliseerde cloud-infrastructuur is het goedkoop en biedt het toegang zonder vergunning.</p>
<p>Het populaire DePIN-project is nu niet alleen beperkt tot opslag, zoals Grass dat gebruikt Tokens om gebruikers te stimuleren om ongebruikte bandbreedte te delen, om echte netwerkgegevens vast te leggen en te gebruiken, en om een ​​gedecentraliseerde kunstmatige intelligentie-orakel te bouwen. Verdien passief inkomen zonder de privacy van individuen te schaden.</p>
<h2 id="h2-Waarom20geloven20we20dat20DePIN20weer20werkt362921"><a name="Waarom geloven we dat DePIN weer “werkt”?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Waarom geloven we dat DePIN weer “werkt”?</h2><p>Eigenlijk hebben veel spelers geen goede indruk van deze ‘oude bekenden’ zoals FileCoin. Enkele jaren geleden was het opslagparcours ook erg populair, maar daarna daalde de prijs snel en waren veel mensen boos op de FIL-dealers. Maar los van de acties van individuele projectpartijen, waarom geloven we nu dat DePIN, een nieuw gezicht, wonderen kan verrichten?</p>
<p>DePIN zelf is ‘sprekend’, met een redelijk token-economisch model en gebruiksscenario, waardoor het een goede basis heeft; maar voorheen leek DePIN beperkt, mede doordat het gehele blockchain-ecosysteem nog erg primitief is, met weinig bruikbare netwerken en toepassingen. Nu begint het netwerk enige omvang te krijgen, heeft het een basis gelegd en is het tijd voor oplossingen zoals L2 om het schaalbaarheidsprobleem van het netwerk aan te pakken.<br><img src="https://gimg2.gateimg.com/image/article/1704874675img_v3_026v_e4b0537d-bc5f-4a47-a45d-7c47c0986fix.jpg" alt=""><br>Afbeeldingsbron: Messari</p>
<p>Vooral met de komst van de 24-jarige halverende bullmarkt staan GameFi en andere tracks die veel rekenkracht en informatie vereisen op het punt zich in te spannen, het is onmogelijk om alle gegevens op de keten in te zetten en er is meer rekenkracht nodig om het interactiegedrag dat in het netwerk plaatsvindt te ondersteunen en te analyseren, en DEPIN is nauw verbonden met web2, en het idee van “realtime” introductie van blockchain zoals orakels heeft ook infrastructuur nodig om te voltooien.</p>
<p>Wat DePIN wil doen, is efficiënt de stroom van middelen mogelijk maken, wat een manier is om het netwerk ‘opnieuw te verdelen’, of het nu gaat om de ongebruikte machines van mijnwerkers, de mobiele telefoons, personal computers en zelfs voertuigen van gewone gebruikers, die allemaal kunnen worden ingezet in het ‘hergebruik’ kanaal en het hele netwerk kunnen laten schitteren en opwarmen. Men kan zeggen dat het nu het juiste moment is voor DePIN, gezien de vooruitgang die is geboekt in de onderliggende architectuur.</p>
<h2 id="h2-De20uitdagingen20en20pijnpunten20van20DePIN991999"><a name="De uitdagingen en pijnpunten van DePIN" class="reference-link"></a><span class="header-link octicon octicon-link"></span>De uitdagingen en pijnpunten van DePIN</h2><p>Maar het moet ook worden toegegeven dat, net als de opslagdiensten van FIL en AR, het gebruik van DePIN nog steeds beperkt is en DePIN nog steeds niet genoeg aantrekkingskracht heeft om gebruikers aan te moedigen om deel te nemen aan de ontwikkeling of het gebruik van de dienst; De token-economie van DePIN is eigenlijk net als de meeste projecten, nog steeds in de fase van staking-het vasthouden van tokens-wachten op waardestijging, en er is nog geen sterke drijvende kracht gezien in termen van aanbod en vraag.</p>
<p>Ten tweede vereist DePIN eigenlijk een aanzienlijke hoeveelheid begripskosten, vergeleken met meme of inies, waardoor spelers in de gemeenschap kunnen discussiëren en kunnen deelnemen aan het laatste deel van de beknopte en gemakkelijk te begrijpen dingen, de visie van DePIN is zeer ambitieus, maar het vereist langetermijninvesteringen om te realiseren, zelfs als het een tijdje een hot topic van discussie wordt, DePIN is niet gemakkelijk om marktsentiment te mobiliseren, tenzij er enkele projecten zijn met grote aankondigingen of baanbrekende samenwerking, de meeste kunnen nog steeds lauw blijven.</p>
<p>Tot slot, het opbouwen van DePIN vereist ook relatief veeleisend talent, wat ook van invloed is op de ontwikkeling en het beheer. Gewone spelers vinden het moeilijk om een rol te vinden, naast het gebruik van diensten en het kopen van munten; misschien hebben we een economisch model nodig dat voor iedereen begrijpelijk en gemakkelijk toegankelijk is, en een verhaal dat vol vertrouwen is, net zoals het duidelijk is in het motto “Het graveren is geld drukken”.</p>
<p>Over het algemeen weten we allemaal dat DePIN noodzakelijk en nuttig is, maar hoe kunnen we meer mensen betrekken? Dit is momenteel een pijnpunt dat moet worden opgelost. We kunnen erop vertrouwen dat DePIN de noodzakelijke kracht zal zijn om de <a href="/web3" target="_blank" class="blog_inner_link">web3</a> en zelfs de echte wereld te veranderen en de digitale economische kosmos te bevorderen.</p>
<div class="blog-details-info"><br>  <div>Auteur:<strong>Sherry S.</strong>, Gate.io onderzoeker<br>  <div class="info-tips"><em> Dit artikel vertegenwoordigt alleen de opvattingen van de auteur en vormt geen enkel handelsadvies.<br></em><div><em></em> Deze inhoud is origineel en auteursrechtelijk beschermd door Gate.io. Vermeld de auteur en de bron als u deze wilt herdrukken, anders zullen juridische stappen worden ondernomen.<br></div><p></p><br></div></div></div>