R2F0ZS5pbyBBTUEgbWV0IE51bWJlcnMgUHJvdG9jb2wtWm9yZyB2b29yIGJld2V6ZW4gaGVya29tc3Qgdm9vciBhbGxlIGRpZ2l0YWxlIG1lZGlhIGdlbWFha3QgZG9vciBtZW5zZW4gJiBBSQ==

<p><img src="https://gimg2.gateimg.com/image/article/16892357031.jpeg" alt=""><br><strong>Tijd: 15 november 2021, 13:00 UTC</strong><br><strong><a href="https://www.gate.io" target="_blank">Gate.io</a> hosted een AMA (Ask-Me-Anything) sessie met Sofia Yan, mede-oprichter &amp; CGO van Numbers Protocol 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.numbersprotocol.io/" rel="nofollow noopener noreferrer" target="_blank">https://www.numbersprotocol.io/</a></strong><br><strong>Twitter: <a href="https://twitter.com/numbersprotocol" rel="nofollow noopener noreferrer" target="_blank">https://twitter.com/numbersprotocol</a></strong><br><strong>Volg Numbers Protocol op <a href="https://twitter.com/numbersprotocol" rel="nofollow noopener noreferrer" target="_blank">Twitter</a> en <a href="https://t.me/numbersprotocol" rel="nofollow noopener noreferrer" target="_blank">Telegram</a></strong><br><strong>Gast</strong><img src="https://gimg2.gateimg.com/image/article/16892359172.jpg" alt=""><br><strong>Sofia Yan - Medeoprichter &amp; CGO van Numbers Protocol</strong></p>
<h2 id="h2-Vraag20amp20Antwoord20van20Gateio412205"><a name="Vraag &amp; Antwoord van Gate.io" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Vraag &amp; Antwoord van Gate.io</h2><h3 id="h3-Q120Laten20we20eerst20wat20meer20over20jou20en20je20project20te20weten20komen20Kun20je20beginnen20met20jezelf20en20het20team20aan20onze20community20voor20te20stellen477695"><a name="Q1: Laten we eerst wat meer over jou en je project te weten komen! Kun je beginnen met jezelf en het team aan onze community voor te stellen?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q1: Laten we eerst wat meer over jou en je project te weten komen! Kun je beginnen met jezelf en het team aan onze community voor te stellen?</h3><p><strong>Sofia</strong>: Zeker weten!</p>
<p>We zijn een klein, maar sterk team.</p>
<p>Ik ben medeoprichter en Chief Growth Officer van Numbers, heb meer dan 8 jaar ervaring in business development en marketing.</p>
<p>Voor ik bij Numbers kwam werken, werkte ik voor een AI-startup en een bedrijf voor intellectuele eigendomswaardering als sales en hoofd business development.</p>
<p>Ik hou van nieuwe uitdagingen en omarm nieuwe technologieën en geloof sterk dat technologie gebruikt moet worden om het goede naar de samenleving te brengen.</p>
<p>Tammy, onze oprichter en Chief Product Officer, is een datawetenschapper en een doctoraat in deeltjesfysica afgestudeerd aan de Universiteit van Manchester.</p>
<p>Haar proefschrift ging over het zoeken naar het Higgs Boson uit enorme gegevens die worden gegenereerd door de hadron collider. Voordat ze Numbers oprichtte, werkte ze als software-ingenieur, technisch leider, AI-ontwikkelaar, CEO en oprichter voor Canonical, Viscovery en DT42. Ze is een dierenliefhebber en heeft een sterk geloof in gegevensvrijheid.</p>
<p>Bofu, onze oprichter en Chief Technology Officer, is een software-engineer en architect met meer dan 15 jaar ervaring in data engineering, embedded s, AI en IoT.</p>
<p>Hij is een Arm-innovator, de top vijf open-source ontwikkelaar van Taiwan 2017, en de consultant en opinieleider van blockchain en gegevensbeleid in Taiwan.</p>
<p>Hij is ook de architect en ontwikkelaar van de open-sourceprojecten BerryNet en Mediant. Hij heeft een sterk geloof in FLOSS, internetvrijheid en is zeer actief in de open-source community.</p>
<p>Ethan, onze wereldwijde communitymanager voor ontwikkelaars, doet veel dingen voor ons hier bij Numbers. Hij heeft zijn master in de informatica behaald aan de Georgia Tech University en is lid van ons ontwikkelingsteam en heeft een goed begrip van onze technologie en producten.</p>
<p>Hij heeft ook uitgebreide ervaring in het laten groeien van gemeenschappen omdat hij in 2016 diende als social media voor Jeremey Lin’s inaugurale Dota2 esports team. Hij kijkt uit naar interactie met onze gemeenschap en ons project.</p>
<p>Verder splitst de rest van het team zich tussen uitstekende backend-, front-end-engineers en een beetje marketing.</p>
<h3 id="h3-Q220Hoe20zit20het20met20uw20project20Kunt20u20ons20meer20vertellen20over20het20Numbers20Protocol20en20wat20u20probeert20te20bereiken932104"><a name="Q2: Hoe zit het met uw project? Kunt u ons meer vertellen over het Numbers Protocol en wat u probeert te bereiken?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q2: Hoe zit het met uw project? Kunt u ons meer vertellen over het Numbers Protocol en wat u probeert te bereiken?</h3><p><strong>Sofia</strong>: Numbers Protocol is een startup gevestigd in Taiwan, met de visie om een ​​gedecentraliseerd fotonetwerk te creëren voor Web3.0.</p>
<p>Digitale media is een GROOT onderdeel van ons dagelijks leven. We consumeren het voortdurend vanwege het entertainment dat het biedt en de oneindige manieren waarop het ons kan informeren.</p>
<p>Echter heeft digitale media, zoals het op het huidige internet is, problemen. Niet te traceren, niet te verifiëren, gemakkelijk te kopiëren en te manipuleren, heeft de digitale inhoud van vandaag geen bescherming, geen vertrouwen en geen vrijheid.</p>
<p>Elke dag worden 2,5 miljoen ongelicentieerde afbeeldingen gestolen, wat dagelijks neerkomt op 600 miljard aan schade. Rondgaande misinformatie maakt het onmogelijk om te bepalen wat waar of onwaar is. Grote techbedrijven manipuleren de toegang tot informatie.</p>
<p>Dit zijn GROTE problemen en ze hebben invloed op onze samenleving. Dat is het belangrijkste probleem dat we proberen op te lossen.<br><img src="https://gimg2.gateimg.com/image/article/16892359473.png" alt=""><br>Terwijl de hele wereld weinig vertrouwen heeft in digitale media op een historisch dieptepunt, heeft het Numbers Protocol tot doel integriteit en authenticiteit te brengen in de digitale inhoudsruimte door een gedecentraliseerd fotonetwerk te creëren waar activa zowel traceerbaar als verifieerbaar zijn via zijn innovatieve Capture, Seal, Trace-proces.</p>
<h3 id="h3-Q320Heb20je20een20werkend20product20Welke20functies20heeft20het20Wat20kunnen20we20ermee20doen528709"><a name="Q3: Heb je een werkend product? Welke functies heeft het? Wat kunnen we ermee doen?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q3: Heb je een werkend product? Welke functies heeft het? Wat kunnen we ermee doen?</h3><p><strong>Sofia</strong>: Ja, we hebben al een paar producten gelanceerd die al een tijdje actief zijn.</p>
<p>Onze oplossing blijft niet alleen op protocolniveau. We hebben ook een suite van tools en services gemaakt waarmee gebruikers activa in het netwerk kunnen registreren en ophalen. Deze omvatten Capture App, Seal API en Trace Site.</p>
<p>Capture App is ‘s werelds eerste blockchain-camera gebouwd voor Web3.0, de eerste NFT-camera en ook de eerste portemonnee voor foto-assets.</p>
<p>Met de Capture App kunnen gebruikers eigendom en context vaststellen op het moment van creatie. De informatie wordt verzegeld op de blockchain en gebruikers kunnen ecosysteemtoepassingen vanuit de App openen zonder afhankelijk te zijn van platforms van derden.</p>
<p>Het maken van een foto met een Capture App voelt hetzelfde als het maken van een traditionele foto, maar er gebeurt veel achter de schermen om het middel te beveiligen. Wanneer een afbeelding wordt vastgelegd, gebruikt Capture App de hardware van het apparaat om metadata te verzamelen, zoals handtekeningen en identiteiten, om de maker en de context vast te stellen.</p>
<p>Seal API is een ontwikkelaarstool die geavanceerde gebruikers helpt om Numbers Protocol eenvoudig te gebruiken om activa in het netwerk te maken, registreren en ophalen.</p>
<p>Het heeft een uitgebreide API-set met een vriendelijke interface voor ontwikkelaars om ecosysteemtoepassingen te maken.</p>
<p>Trace is een website voor het lezen van foto-injectie en onchain-geschiedenis. Het biedt een basischronologisch overzicht van foto’s, zodat lezers gemakkelijk toegang hebben tot de geboorte-informatie van foto’s, zoals wie en wanneer het is gemaakt.</p>
<p>Protocollen en tools zijn alleen effectief als ze worden gebruikt, daarom heeft Numbers Protocol native toepassingen gebouwd om de fundamenten van het ecosysteem te helpen vestigen en gebruikers in staat te stellen het fotonetwerk van de volgende generatie te ervaren.</p>
<p>In de toekomst kan dit foto-netwerk groeien naar gebieden zoals nieuws, sociale media en gaming met bijdragen van de ontwikkelaarsgemeenschap die gebruik maakt van onze tools en applicaties!</p>
<h3 id="h3-En20hoe20zit20het20met20de20NUMtoken20Wat20kunnen20we20ermee20doen580546"><a name="En hoe zit het met de $NUM-token? Wat kunnen we ermee doen?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>En hoe zit het met de $NUM-token? Wat kunnen we ermee doen?</h3><p><strong>Sofia</strong>: NUM is de inheemse protocoltoken van NUMbers Protocol.</p>
<p>Het is in de eerste plaats een utility-token dat is ontworpen om gebruikers te stimuleren om inhoud te maken, archiveren en verifiëren met goede integriteit.</p>
<p>Het doel van Numbers Protocol is het creëren van een ecosysteem waar foto’s (zowel afbeeldingen als video’s) belangrijk zijn door gebruik te maken van bewijzen, integriteitsrecords en gegevensherkomst om de geloofwaardigheid en legitimiteit van geregistreerde foto’s in het netwerk te vergroten.</p>
<p>Deelnemers, zoals verificateurs en andere netwerkoperators, kunnen beloningen krijgen door diensten te verlenen om de geloofwaardigheid en legitimiteit van geregistreerde foto’s te vergroten.<br><img src="https://gimg2.gateimg.com/image/article/16892359614.png" alt=""><br>$NUM-tokens kunnen ook worden gebruikt om te betalen voor diensten die worden uitgevoerd in het gedecentraliseerde fotonetwerk.<br>Of bezoek onze Medium-pagina om meer te weten te komen!</p>
<h3 id="h3-Q520Wat20zijn20de20voordelen20van20het20Numbers20Protocol20in20vergelijking20met20de20meeste20projecten20die20momenteel20op20de20markt20zijn210835"><a name="Q5: Wat zijn de voordelen van het Numbers Protocol in vergelijking met de meeste projecten die momenteel op de markt zijn?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q5: Wat zijn de voordelen van het Numbers Protocol in vergelijking met de meeste projecten die momenteel op de markt zijn?</h3><p><strong>Sofia</strong>: Het ‘Rechtsklikken &amp; Opslaan’ fenomeen is een groot probleem in de huidige fotogemeenschappen. Foto’s in het Numbers Protocol-netwerk kunnen niet op deze manier worden verkregen.</p>
<p>Als voorbeeld is CaptureClub een inheemse NFT-marktplaats voor Numbers Protocol. Activa kunnen alleen worden gedownload na aankoop of verkrijging van een licentie.</p>
<p>Bovendien hebben alle foto’s in het Numbers Protocol-netwerk bijbehorende certificaten van echtheid en C2PA-metadata die in elk activum zijn ingebed. Metadata bevat informatie zoals maker, eigenaar en andere contextuele informatie.</p>
<p>De ingebedde informatie maakt het mogelijk dat het actief zelf getraceerd kan worden.</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 beleggingsadvies.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Het opnieuw plaatsen van het artikel zal worden toegestaan mits Gate.io wordt vermeld. In alle glen zullen juridische stappen worden ondernomen vanwege inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div>