R2F0ZS5pbyBBTUEgbWV0IFN3YXJtLUEgZ2VkZWNlbnRyYWxpc2VlcmRlIGdlZ2V2ZW5zb3BzbGFnIGVuIGRpc3RyaWJ1dGlldGVjaG5vbG9naWU=

<p><img src="https://gimg2.gateimg.com/image/article/16796446751.png" alt=""><br><strong>Tijd: 23 maart 2023, 13:00 UTC</strong><br><strong><a href="https://www.gate.io" target="_blank">Gate.io</a> organiseerde een AMA (Ask-Me-Anything) sessie met Gregor Žavcer,Directeur van de Swarm Foundation in de <a href="https://t.me/gateio" rel="nofollow noopener noreferrer" target="_blank">Gate.io Exchange Gemeenschap</a>.</strong><br><strong>Officiële Website: <a href="https://www.ethswarm.org/" rel="nofollow noopener noreferrer" target="_blank">https://www.ethswarm.org/</a></strong></p>
<p><strong>Twitter: <a href="https://twitter.com/ethswarm" rel="nofollow noopener noreferrer" target="_blank">https://twitter.com/ethswarm</a></strong></p>
<p><strong>Volg Swarm op <a href="https://twitter.com/ethswarm" rel="nofollow noopener noreferrer" target="_blank">Sjilpen</a> en <a href="https://discord.ethswarm.org/" rel="nofollow noopener noreferrer" target="_blank">Discord</a></strong><br><strong>Gast</strong><img src="https://gimg2.gateimg.com/image/article/16796448682.png" alt=""><br><strong>Gregor Žavcer — Directeur van de Swarm Foundation</strong><br>Ben al sinds voor 2009 bezig met het verkennen van gedecentraliseerde bedrijfsmodellen en p2p-gegevens. Ik ben in 2015 toegetreden tot de blockchain-ruimte, heb gewerkt en geadviseerd over verschillende op gegevens gerelateerde projecten in web3. Ik ondersteun Swarm al sinds 2016 en ben in 2019 fulltime toegetreden toen Swarm afstudeerde van <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> Stichting.</p>
<p>Q&amp;A van Gate.io</p>
<h3 id="h3-Q120Er20is20geen20web320zonder20opslag20Ben20je20het20eens20met20de20stelling507839"><a name="Q1: “Er is geen web3 zonder opslag”. Ben je het eens met de stelling?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q1: “Er is geen <a href="/web3" target="_blank" class="blog_inner_link">web3</a> zonder opslag”. Ben je het eens met de stelling?</h3><p><strong>Gregor</strong>: Ja, helemaal. Ik zou zelfs zeggen dat er geen web3 is zonder gedecentraliseerde opslag, waar moeten alle activa immers worden opgeslagen?</p>
<p>Om eigendom mogelijk te maken in web3 is opslag essentieel. Gegevens en informatie moeten gedecentraliseerd worden opgeslagen, wat inhoudt dat geen enkele entiteit het kan controleren.</p>
<p>Dit is ook hoe Swarm begon, om het te voltooien <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> wereldcomputer. Vandaag is dit nog belangrijker.</p>
<p><strong>Antonio</strong>: Waar worden mijn crypto-kittens opgeslagen? Echte eigendom en privacy van activa zijn cruciaal. Zelfs de nodes die de informatie hosten, mogen geen gegevens kunnen verwijderen.</p>
<h3 id="h3-Q220Hoe20werkt202020Ethereum2020het20probleem20van20opslag20aanpakken568439"><a name="Q2: Hoe werkt   Ethereum  het probleem van opslag aanpakken?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q2: Hoe werkt <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> het probleem van opslag aanpakken?</h3><p><strong>Gregor</strong>: Het was vanaf het begin duidelijk dat on-chain communicatie en on-chain opslag duur zouden zijn; de <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> blockchain was nooit bedoeld om gegevens op te slaan.</p>
<p>Echter, oplossingen die verder gaan dan het opslaan van transactiegeschiedenis zijn zeer nodig voor de toekomst van web3.</p>
<p>Swarm is de tool die was bedoeld om het probleem van opslag op te lossen. Swarm was altijd bedoeld als de harde schijf van de wereld om blockchain aan te vullen.</p>
<p>Dus, op een bepaalde manier gaat Swarm verder waar blockchain eindigt als het gaat om privé- of big data.</p>
<p><strong>Antonio</strong>: <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> + <a href="/price/bittorrent-btt" rel="nofollow noopener noreferrer" target="_blank">BitTorrent</a> = Swarm.</p>
<h3 id="h3-Q320Swarm20heeft20tot20op20heden20een20lange20weg20afgelegd20Wat20zijn20de20sterke20punten20in20vergelijking20met20andere20opslagoplossingen448072"><a name="Q3: Swarm heeft tot op heden een lange weg afgelegd. Wat zijn de sterke punten in vergelijking met andere opslagoplossingen?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q3: Swarm heeft tot op heden een lange weg afgelegd. Wat zijn de sterke punten in vergelijking met andere opslagoplossingen?</h3><p><strong>Gregor</strong>: De architectuur en het ontwerp van Swarm maken het de meest gedecentraliseerde opslag van allemaal.</p>
<p>Op Swarm maken gegevens-uploaders ‘een contract’ met het netwerk, niet met een specifieke opslagplaats. Dit betekent dat het sterker is voor censuurbestendigheid.</p>
<p>Bovendien heeft de ‘upload en verdwijn’-functie van Swarm, wat betekent dat men geen node hoeft te draaien om gegevens op het netwerk op te slaan, ook een weg geopend voor zeer privé communicatieprotocollen.</p>
<p>Samen zorgt dit voor een zeer krachtige combinatie, een onstuitbaar netwerk met zeer sterke privacy-eigenschappen. We zien het graag als infrastructuur voor een zelf-soevereine digitale samenleving.</p>
<p><strong>Antonio</strong>: Ik zou zeggen dat de hardwarevereisten om een node te laten draaien zeer minimaal zijn in vergelijking met andere oplossingen: een Raspberry Pi zou voldoende kunnen zijn.</p>
<p>En zoals ik eerder al zei, kunnen zelfs de knooppunten die de gegevens opslaan het niet censureren of annuleren. Ze kunnen de gegevens niet reconstrueren of weten wat ze opslaan, omdat ze ‘confetti’ van de gegevens opslaan. Toch worden ze betaald.</p>
<h3 id="h3-Q420Kun20je20ons20vertellen20wat20er20op20dit20moment20gebeurt20bij20Swarm721526"><a name="Q4: Kun je ons vertellen wat er op dit moment gebeurt bij Swarm?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q4: Kun je ons vertellen wat er op dit moment gebeurt bij Swarm?</h3><p><strong>Gregor</strong>: Kortom, we zijn er nu klaar voor.</p>
<p>Na jaren van onderzoek en iteraties heeft Swarm eindelijk toestemmingsloze gedecetraliseerde persistentiegaranties gekraakt.</p>
<p>Daarnaast vond er in februari een prijsafstemming van het netwerk plaats en bereikten we de belangrijke mijlpaal dat Swarm een economisch zelfvoorzienend netwerk werd.</p>
<p>Met andere woorden, node operators worden nu beloond en het runnen van een node is winstgevend geworden. We zien nieuwe nodes toetreden tot het netwerk en natuurlijk ook nieuwe uploads.</p>
<p>Onlangs werd de eerste mijlpaal van het uploaden van Wikipedia naar Swarm voltooid. Momenteel wordt er gewerkt aan het zoeken, en andere openbare goede gegevenssets vinden hun weg, zoals OpenStreetMaps en nog veel meer.</p>
<p>Er is nog veel te doen, maar nu al kunnen dapp-ontwikkelaars dapps snel ontwikkelen, vooral door gebruik te maken van laag 2-tools zoals Fairdrive als een gegevensportemonnee, fairOS voor gedecentraliseerde backend en anderen.</p>
<p>Als Swarm een auto zou zijn, is het nu tijd voor een ritje.</p>
<h3 id="h3-Q520Hoe20zal20de20toekomst20van20Swarm20eruit20zien601144"><a name="Q5: Hoe zal de toekomst van Swarm eruit zien?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q5: Hoe zal de toekomst van Swarm eruit zien?</h3><p><strong>Gregor</strong>: We zijn net begonnen. We verwachten dat het netwerk sterker zal worden naarmate er meer nodes toetreden, en we verwachten dat er veel meer gemeenschappelijke goede gegevens beschikbaar zullen zijn voor gebruikers en ontwikkelaars. Onze technische routekaart heeft de volgende mijlpaal ingesteld voor ondersteuning van grote bestanden, waarna we verder gaan met het mogelijk maken dat gedecentraliseerde servicediensten op Swarm kunnen draaien. Denk aan Airbnb, Uber,… zonder tussenpersonen, waar iedereen het uiteindelijk zou kunnen maken door alleen een beschrijving van de dienst te schrijven.</p>
<p>We kijken ook veel naar hoe Swarm kan helpen bij de problemen van gegevensbeschikbaarheid - waar slaan rollups gegevens op.</p>
<p><strong>Antonio</strong>: Het is behoorlijk opwindend. De belofte van onstuitbare opslag betekent veel voor het web3-ecosysteem, omdat data alles is. U zou in staat zijn om uw gegevens veilig en privé op te slaan, openbare repositories te maken die door gemeenschappen kunnen worden gebruikt voor algemeen nut.</p>
<p>Host applicaties die niet kunnen worden afgesloten. En natuurlijk alle soorten blockchain-gegevens. Swarm is bijzonder goed gepositioneerd om een speler te worden in het Data Beschikbaarheidsecosysteem, de plaats waar rollups de gegevens zullen opslaan.</p>
<p>Zodra de rollups hun magie creëren, zullen ze in combinatie met Swarm dapps onstuitbaar zijn. Ik kan niet wachten.</p>
<div class="blog-details-info"><br><div>Auteur:<strong> Rio Fu.</strong>, Gate.io Community<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 voor op dit artikel. Het opnieuw posten van het artikel is toegestaan mits Gate.io wordt vermeld. In alle glen zullen juridische stappen worden ondernomen wegens schending van het auteursrecht.<br></div><p></p><br></div></div></div>