RGUgbmlldXdlIERlUElOIFRyYWNrIGdhYXQgdmFuIHN0YXJ0LCBvbnRkZWsgZGUgcG90ZW50aWXMiGxlIGludmVzdGVyaW5nc21vZ2VsaWpraGVkZW4=

2024-01-19, 02:47

<p><img src="https://gimg2.gateimg.com/image/article/1690791857hotspot.jpeg" alt=""></p>
<h2 id="h2-TLDR884459"><a name="[TL;DR]:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL;DR]:</h2><p>De populariteit van de DePIN track neemt geleidelijk toe en het wordt verwacht dat het de marktdeelname-enthousiasme na de relais-inie zal leiden. Gate.io blijft aandacht besteden aan de populaire projecten van het track.</p>
<p>DePIN verwijst naar een gedecentraliseerd fysiek infrastructuurnetwerk, dat voortkomt uit <a href="/price/helium-hnt" rel="nofollow noopener noreferrer" target="_blank">Helium</a> in 2013 opgericht en in 2022 door Messari benoemd. Momenteel is het voornamelijk verdeeld in twee categorieën: fysieke resource netwerken en digitale resource netwerken.</p>
<p>DePIN moedigt gebruikers aan om idle netwerksoftware en hardwarebronnen te delen en te gebruiken, wat naar verwachting de evolutie van supply chains, industriële patronen en zelfs het hele economische ecosysteem zal veranderen. De ontwikkelingsvooruitzichten worden belemmerd en langdurig.</p>
<h2 id="h2-Introductie461830"><a name="Introductie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introductie</h2><p>In feite, al in de late november vorig jaar, toen de inies in volle gang waren, werd het DePIN-traject geleidelijk populair. Onlangs heeft Gate.io ook DePIN-gerelateerde tokens gelanceerd zoals Oort (OORT), Neurai (XNA), Dynex (DNX), Serenity Shield (SERSH), enzovoort. In dit artikel zullen we de ontwikkeling en investeringsmogelijkheden van dit traject aan de lezers introduceren.</p>
<h2 id="h2-Waarom20is20de20DePIN20Track20belangrijk5394"><a name="Waarom is de DePIN Track belangrijk?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Waarom is de DePIN Track belangrijk?</h2><p>DePIN (Decentralized Physical Infrastructure Networks), als vertegenwoordiger van gedecentraliseerde fysieke infrastructuurnetwerken, moedigt gebruikers aan om persoonlijke hulpbronnen te delen via tokenprikkels en gezamenlijk verschillende infrastructuurterreinen op te bouwen, zoals opslagruimte, communicatieverkeer, cloud computing en energie. Dit netwerk heeft als doel de monopoliepositie van gecentraliseerde instellingen te doorbreken en gebruikers meer flexibele, efficiënte en betrouwbare diensten te bieden.</p>
<p>De opkomst van DePIN is niet tolig, maar een onvermijdelijk resultaat van technologische ontwikkeling. Met de voortdurende volwassenheid en popularisering van blockchaintechnologie, realiseren steeds meer projecten zich het belang van gedecentraliseerde infrastructuur. DePIN biedt niet alleen gebruikers meer gemak en efficiënte diensten, maar biedt ook een nieuw podium voor ontwikkelaars en ondernemers om vrij hun creativiteit en talenten te ontplooien.<br><img src="https://gimg2.gateimg.com/image/article/1705632315img_v3_0278_c9cbc031-8a21-419f-9721-12441628f4ix.jpg" alt=""><br>Bron: Gate.io</p>
<p>De voortdurende groei van de marktwaarde in het DePIN-veld bewijst ook de erkenning en vraag van de markt. Volgens de gegevens van CoinGecko heeft de marktwaarde van het DePIN-veld $5,2 miljard bereikt, wat hoger is dan de $5 miljard in het orakelveld. Dit aantal toont niet alleen het vertrouwen van de markt aan, maar voorspelt ook enorme potentie voor de toekomst.</p>
<p>Naast de groei van de marktwaarde heeft DePIN ook steeds meer projecten aangetrokken om mee te doen. Vanaf de vroegste <a href="/price/arweave-ar" rel="nofollow noopener noreferrer" target="_blank">Arweave</a> en <a href="/price/filecoin-fil" rel="nofollow noopener noreferrer" target="_blank">Filecoin</a>, naar Helium, dat een vlucht nam in de vorige bullmarkt, en naar de onlangs langverwachte <a href="/price/render-rndr" rel="nofollow noopener noreferrer" target="_blank">Render</a> netwerk, deze projecten stimuleren voortdurend de ontwikkeling en groei van het DePIN-veld.<br>Dus waarom heeft DePIN de laatste tijd zoveel aandacht en achtervolging gekregen?</p>
<p>Ten eerste heeft de DePIN-track meer aandacht en steun gekregen door de toenemende verbetering van de infrastructuur. Dit betekent dat ontwikkelaars deze middelen gemakkelijker kunnen gebruiken om hun eigen toepassingen en diensten te bouwen.</p>
<p>Ten tweede stelde Messari voor het eerst het nieuwe concept van DePIN voor aan het einde van 2022 en beschouwde het als een van de belangrijkste gebieden voor cryptoinvesteringen in het komende decennium. Dit standpunt heeft breed weerklank gevonden in de markt en heeft meer vertrouwen en vitaliteit gegeven aan de DePIN-richting.</p>
<p>Natuurlijk raken mensen voortdurend in de ban en verkenning van het doorbreken van nieuwe verhalen, terwijl DePIN een natuurlijke achtergrond biedt van hoge verhalende ruimte voor hype. Na nieuwe verhaaltrends zoals inies en AI te hebben ervaren, zijn mensen op zoek gegaan naar andere gebieden met potentieel. De DePIN-track, nauw verbonden met Web2-gebruikers, is natuurlijk een belangrijke keuze geworden voor Web3-bouwers.</p>
<h2 id="h2-De20ontwikkelingsgeschiedenis20van20DePIN20Thick20Product20dat20de20weg20leidt890147"><a name="De ontwikkelingsgeschiedenis van DePIN Thick Product dat de weg leidt" class="reference-link"></a><span class="header-link octicon octicon-link"></span>De ontwikkelingsgeschiedenis van DePIN Thick Product dat de weg leidt</h2><p>In de beginjaren was er geen eenheid in de beschrijving van het opkomende vakgebied DePIN, en er waren verschillende namen zoals de internet-infrastructuurlaag, MachineFi, Token Incentive Physical Network, etc.</p>
<p>Tegen november 2022 had Messari gestemd over de veldnaam en DePIN gebruikt in zijn jaarlijkse en thematische rapporten, waardoor DePIN de uniforme naam voor het veld werd.</p>
<p>Vanaf de vroegste projecten zoals het gedecentraliseerde netwerk <a href="/price/helium-hnt" target="_blank" class="blog_inner_link">Helium</a> (2013) en de gedecentraliseerde opslag Storj (2014) en Sia (2015) hebben de projecten van DePIN zich voornamelijk gericht op opslag- en communicatietechnologie. Echter, met de voortdurende ontwikkeling van het internet, het internet der dingen en AI, breidt het DePIN-veld zich ook uit naar een breder scala aan industrieën. Volgens de classificatie van Messari kan DePIN worden onderverdeeld in twee categorieën: fysieke hulpbronnetwerken en digitale hulpbronnetwerken.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1705632362img_v3_0278_3a489810-2148-4fb6-80d9-2b1877cbabix.jpg" alt=""><br>Bron: Messari</p>
<p>Fysieke hulpbronnenetwerken omvatten draadloze netwerken, mobiele netwerken en energienetwerken, terwijl digitale hulpbronnenetwerken opslag-, bandbreedte- en rekenenetwerken omvatten. Op dit moment richten de projecten van DePIN zich voornamelijk op computertechnologie, opslag, communicatietechnologie en gegevensverzameling en -deling. Van de top 10 projecten qua marktwaarde behoren de meeste tot de opslag- en computervelden, terwijl er ook enkele uitstekende projecten zijn op het gebied van communicatietechnologie, zoals de industrieleidend Helium en de opkomende ster Theta.</p>
<p>Deze projecten maken volledig gebruik van blockchain-technologie om gebruikers gedecentraliseerde opslag- en computerdiensten te bieden, waardoor het monopolie van traditionele gecentraliseerde instellingen wordt doorbroken. In de toekomst, met de voortdurende vooruitgang van de technologie en de groeiende marktvraag, wordt verwacht dat het DePIN-veld een bredere ontwikkelingsruimte en kansen zal inluiden.</p>
<h2 id="h2-Lange20termijn20investeringsmogelijkheden20voor20DePIN388021"><a name="Lange termijn investeringsmogelijkheden voor DePIN" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Lange termijn investeringsmogelijkheden voor DePIN</h2><p>Vanuit een macroperspectief is de opkomst van het DePIN-project een revolutionaire marktverandering, met zijn gedecentraliseerde karakter dat de participatiebarrières verlaagt en het monopolie van gecentraliseerde reuzen doorbreekt. DePIN stimuleert gebruikers om bronnen te delen en een gratis concurrerend ecosysteem op te zetten, waardoor de markt opener, transparanter en fel concurrerend wordt.</p>
<p>Het mechanisme van DePIN transformeert traditionele kapitaalintensieve industrieën naar P2P- of P2P-modellen, waardoor er meer kansen ontstaan voor kleine en middelgrote ondernemingen en startups om op gelijke voet te concurreren met marktleiders. Bovendien heeft het DePIN-project zich getransformeerd van een kapitaalintensieve industrie naar een gedecentraliseerd model door gebruikers te stimuleren om middelen te leveren om een netwerk te vormen, monopolies op prijzen te doorbreken en gebruikers meer kosteneffectieve keuzes te bieden.</p>
<p>Over het algemeen maakt DePIN ook volledig gebruik van ongebruikte middelen en bevordert het een betere sociale ontwikkeling. Veel gebruikers hebben een grote hoeveelheid ongebruikte middelen, waaronder opslag, rekenkracht en energie. Door stimuleringsmechanismen moedigt DePIN gebruikers aan om deze middelen te delen en te gebruiken, waardoor het gebruik van middelen wordt gemaximaliseerd. Dit vermindert niet alleen verspilling van middelen, maar brengt ook meer duurzame ontwikkeling voor bedrijven en de samenleving met zich mee.</p>
<p>In recent opkomende DePIN-projecten zijn de visie en kenmerken van O2O-projecten zoals Uber en Meituan, die zijn ontwikkeld tot Web3, geleidelijk opgedoken. Deze projecten hebben als doel de web2-infrastructuur te vervangen, waardoor gebruikers die gegevens verstrekken rechtstreeks betaling van handelaars kunnen ontvangen en daarmee tussenpersonen kunnen elimineren. Dit betekent dat DePIN directe waardeoverdracht bereikt, de transactie-efficiëntie en transparantie verbetert door het opzetten van een gedecentraliseerd ecosysteem dat vraag en aanbod rechtstreeks verbindt.</p>
<p>Echter, de ontwikkeling van DePIN staat ook voor vele beperkingen en uitdagingen.</p>
<p>Ten eerste ontbrak het de industrie in de beginfase aan standaarden, wat resulteerde in een slechte ontwikkelaars- en gebruikerservaring. Op dit moment staat de ontwikkeling van de DePIN-industrie nog in de kinderschoenen, ontbreekt een volledige infrastructuur, en elk project moet onafhankelijk worden ontwikkeld. Bovendien heeft het project een relatief hoge begrips- en gebruiksdrempel voor gebruikersparticipatie, waarvoor leer- en bezittokens, het kopen en configureren van hardware en andere bewerkingen vereist zijn. Daarom is de gebruikerservaring van DePIN-projecten in de huidige markt gemiddeld, en moeten bedrijven de drempel voor gebruikersparticipatie en -gebruik samenvoegen en vereenvoudigen, de beschikbaarheid van het netwerk verbeteren om meer mogelijkheden te hebben om door te breken.</p>
<p>Aan de andere kant heeft DePIN ook te maken met het probleem van een gebrek aan concurrentievoordeel. Als bronproviders kunnen gebruikers gemakkelijk overschakelen naar andere netwerken, wat uitdagingen vormt voor de langetermijnstabiele ontwikkeling van DePIN-netwerken.</p>
<p>Om dit probleem aan te pakken, zijn sommige bedrijven begonnen zich te wijden aan infrastructuurconstructie en standaardisatiewerk. Bijvoorbeeld, <a href="/price/filecoin-fil" target="_blank" class="blog_inner_link">Filecoin</a> kondigde de lancering aan van Filecoin Data Tools om de ontwikkelaarservaring te verbeteren en uitgebreide oplossingen te bieden voor de behoeften van gegevensdiensten; <a href="/price/iotex-iotx" target="_blank" class="blog_inner_link">IoTex</a> ontwikkelt ook SDK en andere toolkits voor move to earn, in de hoop enkele standaarden en consensus op het niveau van DePIN te bereiken en de gezonde ontwikkeling van de industrie te bevorderen.<img src="https://gimg2.gateimg.com/image/article/1705632412img_v3_0278_5e58e58e-0687-4c55-8c66-9127698c21ix.jpg" alt=""><br>Bron: IoTex</p>
<p>Eenvoudig gezegd, blockchain technologie is bezig om meerdere industrieën te hervormen, zoals financiën (DeFi), gaming (GameFi) en verzamelobjecten (NFT). Echter, in vergelijking met de huidige marktgekte lijkt DePIN niet genoeg aandacht te hebben gekregen, maar in werkelijkheid heeft het sterke potentie om naadloos te integreren in de echte wereld, het monopolie van grote bedrijven te doorbreken en innovatie te stimuleren.</p>
<p>Bijvoorbeeld, de totale marktwaarde van de top tien cloudserviceproviders wereldwijd is ongeveer $5 biljoen. Als <a href="/web3" target="_blank" class="blog_inner_link">Web3</a> bedrijf een deel van deze markten zou kunnen veroveren, zou de waardering miljarden dollars kunnen bereiken. Momenteel is de totale marktwaarde van alle DePIN-cryptoprojecten $11 miljard.</p>
<p>Hoewel het DePIN-veld op korte termijn vele uitdagingen kent, zoals productervaring, felle concurrentie, hoge ontwikkelingsinvesteringen, regelgevende naleving en tekort aan talent, zal DePIN op de lange termijn een diepgaande impact hebben op de markt. Het heeft de evolutie van toeleveringsketens, industriepatronen en het gehele economische ecosysteem veranderd door barrières te verlagen, innovatie te bevorderen en onbenutte bronnen te benutten. Naarmate DePIN volwassen wordt, hebben we reden om te geloven dat het een sleutelrol zal spelen bij het stimuleren van sociale, zakelijke en individuele veranderingen.</p>
<p>Voor investeerders kan het DePIN-concept mogelijk een snelle ontwikkeling doormaken in de verwachting van de toekomstige bullmarkt. <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> halvering, trekt een grote hoeveelheid marktaandacht aan en levert aanzienlijke rendementen op voor de deelnemers. Gate.io zal zich blijven richten op dit gebied en meer veelbelovende projecttokens lanceren.</p>
<p>Ongeacht in welk veld of project u investeert, moeten investeerders altijd rekening houden met de relevante risico’s, aandacht besteden aan en volledig begrijpen van de relevante informatie in het DePIN-veld vooraf, wat ook het sleutelpunt is waar we aan het einde van eerdere artikelen over hebben gesproken.</p>
<div class="blog-details-info"><br><div>Auteur:<strong>Carl Y.</strong>, Gate.io onderzoeker<br><div>Vertaler: Joy Z.<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de standpunten van de onderzoeker en vormt geen enkele beleggingssuggestie.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Het opnieuw plaatsen van het artikel is toegestaan mits Gate.io wordt vermeld. In alle glen zal er juridische stappen worden ondernomen vanwege inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div></div>