R2F0ZS5pbyBBTUEgY29uIHIvQ3J5cHRvQ3VycmVuY3kgLSBMYSBwcmluY2lwYWxlIGNvbXVuaXTDoCBwZXIgbGUgbm90aXppZSwgZGlzY3Vzc2lvbmkgZSBhbmFsaXNpIHN1bGxlIGNyaXB0b3ZhbHV0ZS4=

<p><img src="https://gimg2.gateimg.com/image/article/167583600411.png" alt=""><br><strong>Ora: 15 ottobre 2022, 13:00 UTC</strong><br><strong><a href="https://www.gate.io" target="_blank">Gate.io</a> ha ospitato una sessione di AMA (Ask-Me-Anything) con il rappresentante di r/CryptoCurrency, John Murphy nel sito <a href="https://www.reddit.com/r/CryptoCurrency/" rel="nofollow noopener noreferrer" target="_blank">Gate.io Exchange Community]Reddit: [https://www.reddit.com/r/CryptoCurrency/</a></strong></p>
<p><strong>Twitter: <a href="https://twitter.com/CCMOD_" rel="nofollow noopener noreferrer" target="_blank">https://twitter.com/CCMOD_</a></strong><br><strong>Segui r/CryptoCurrency su <a href="https://twitter.com/CCMOD_" rel="nofollow noopener noreferrer" target="_blank">Twitter</a></strong></p>
<h2 id="h2-Domande20e20risposte20da20Gateio530970"><a name="Domande e risposte da Gate.io" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Domande e risposte da Gate.io</h2><h3 id="h3-Q120Potresti20prima20darmi20una20breve20introduzione20su20di20te595840"><a name="Q1: Potresti prima darmi una breve introduzione su di te?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q1: Potresti prima darmi una breve introduzione su di te?</h3><p><strong>Giovanni</strong>: Certo. Per formazione sono un scienziato/ingegnere dei materiali. Ho completato i miei studi di laurea presso la Drexel Univ, e poi ho fatto il mio dottorato in elaborazione e caratterizzazione dei semiconduttori presso la UT-Dallas. Dopo di che ho trascorso sei anni presso il Lawrence Livermore National Lab lavorando su rivelatori di radiazioni a base di semiconduttori e batterie nucleari.<br>Ma il mio vero amore è la criptovaluta. Ho iniziato a minare <a href="/price/dogecoin-doge" target="_blank" class="blog_inner_link">Dogecoin</a> subito dopo il lancio alla fine del 2013 e sono davvero caduto nella tana del coniglio del mining con GPU. Mi sono coinvolto con <a href="https://www.gate.io/trade/XMR_USDT" target="_blank">Monero</a> Molto presto, mi sono unito al team di moderazione di r/Cryptocurrency nel 2016 per aiutare con alcune funzionalità del bot. Nel 2018 ho effettivamente lanciato una criptovaluta che è ancora viva e vegeta oggi - Wownero. E ora sto lavorando a tempo pieno nella mia azienda nello spazio.</p>
<h3 id="h3-Q220Come2020cresciuta20la20comunit20su20rCryptoCurrency20nel20corso20degli20anni668714"><a name="Q2: Come è cresciuta la comunità su r/CryptoCurrency nel corso degli anni?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q2: Come è cresciuta la comunità su r/CryptoCurrency nel corso degli anni?</h3><p><strong>John</strong>: Si è davvero sviluppato insieme alle criptovalute nel loro complesso. Quando mi sono iscritto a r/CryptoCurrency all’inizio del 2014 c’erano forse 5-10 mila iscritti, e ora siamo oltre i 5,5 milioni.<br>La nostra crescita coincide con i cicli di mercato e tende ad andare in modo parabolico con il prezzo di <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a>. Penso in 2017⁄8siamo passati da 100k iscritti a oltre 500k, poi siamo cresciuti lentamente fino a superare 1M all’inizio del 2020, ma negli ultimi due anni di questo ciclo di mercato siamo ora arrivati oltre 5M.<br><img src="https://gimg2.gateimg.com/image/article/167583621522.png" alt=""><br>Una nota interessante di questa ultima fase di crescita è che r/CryptoCurrency è diventato un subreddit più grande e più attivo rispetto a r/ <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a>. Quindi, siamo ora la più grande comunità di criptovalute su Reddit e forse la più grande e attiva comunità interessata alle criptovalute su internet!</p>
<h3 id="h3-Q320Cosa20sono20esattamente20i20Reddit20Community20Points20e20in20particolare20i20MOON20di20Reddit813838"><a name="Q3: Cosa sono esattamente i Reddit Community Points e in particolare i MOON di Reddit?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q3: Cosa sono esattamente i Reddit Community Points e in particolare i MOON di Reddit?</h3><p><strong>John</strong>: Quindi, i Reddit Community Points (RCP) sono stati introdotti ufficialmente da Reddit nel giugno del 2020 in due subreddit: r/CryptoCurrency con MOONs come token di punti community di reddit e in r/FortniteBR con BRICKs come token.<br>C’è un po’ più di storia perché un subreddit di trading di ETH r/ETHtrader aveva lanciato DONUTs, come una sorta di versione prototipo di RCP, e penso che Reddit li abbia usati come modello e abbia persino aiutato i moderatori di quel sub con il loro esperimento DONUT, ma non sono stati ufficialmente creati o distribuiti da Reddit.<br>Gli RCP sono token che vengono distribuiti da Reddit una volta ogni quattro settimane agli utenti in base ai loro contributi (quanti voti positivi hanno ottenuto in pratica) a un subreddit. Questi token sono progettati per essere utilizzati per votare nei sondaggi di governance su come viene gestito il subreddit (e possono anche essere utilizzati per acquistare abbonamenti speciali e premi reddit). Quindi, in realtà gli RCP sono essenzialmente token di governance per un’operazione simile a una DAO di un subreddit.<br>Sono stati lanciati sulla testnet Rinkeby nel giugno 2020 e circa un anno dopo sono migrati sulla rete privata Arbitrum di Reddit che girava sulla testnet Rinkeby, e ora circa due mesi fa sono migrati sulla “mainnet” su Arbitrum Nova.</p>
<h3 id="h3-Q420Su20quale20rete20sono20le20LUNE20di20Reddit20In20che20modo20Arbitrum20Nova2020costruito20per20Socialfi20e20Gamefi286328"><a name="Q4: Su quale rete sono le LUNE di Reddit? In che modo Arbitrum Nova è costruito per Social-fi e Game-fi?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q4: Su quale rete sono le LUNE di Reddit? In che modo Arbitrum Nova è costruito per Social-fi e Game-fi?</h3><p><strong>Giovanni</strong>: Quindi, come ho detto, i MOON ora funzionano su Arbitrum Nova, che è una nuova rete di Off Chain Labs. Sono la stessa società che ha lanciato la rete Arbitrum One, uno dei layer 2 più popolari su Ethereum.<br>Arbitrum One utilizza la tecnologia di roll-up ottimistico per fornire agli utenti commissioni di transazione più basse per l’interazione con Defi, NFT, ecc.<br>Con Arbitrum Nova hanno collaborato con alcune grandi aziende come Reddit per creare un comitato per la disponibilità dei dati. Ciò consente alle commissioni di transazione di essere ancora più economiche di quanto non siano su Arbitrum One, motivo per cui dicono che è mirato per Game-fi e Social-fi dove gli utenti avranno probabilmente molte piccole transazioni.<br>Puoi vedere il loro elenco di partner qui: <a href="https://nova.arbitrum.io/" rel="nofollow noopener noreferrer" target="_blank">https://nova.arbitrum.io/</a>. Include Reddit, Consensys, Google Cloud e altri.</p>
<h3 id="h3-Q520Come20vedi20il20progresso20del20Socialfi20in20futuro14042"><a name="Q5: Come vedi il progresso del Social-fi in futuro?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q5: Come vedi il progresso del Social-fi in futuro?</h3><p><strong>John</strong>: È una domanda interessante che penso sia in realtà molto difficile prevedere come andrà a finire.<br>Personalmente penso che nel prossimo futuro vedremo altre grandi comunità esistenti cercare di aumentare il coinvolgimento degli utenti e il senso di proprietà emettendo un token, in modo simile a quanto Reddit ha fatto con MOON e BRICK (e altri RCP in arrivo?). r/CryptoCurrency è probabilmente la più grande DAO esistente con quasi 200k possessori di token M O O N che si qualificano come membri. Penso solo che sia molto più facile inserire un token in una grande comunità esistente piuttosto che costruire una comunità attorno a un token.<br>A lungo termine, è molto difficile dirlo, ma penso che continuerà a crescere, e ci saranno molti esperimenti interessanti, ma penso che continuerà ad essere utilizzato principalmente per aggiungere valore a una comunità esistente, e i tentativi di costruire una comunità attorno a un token avranno meno successo (sembra che in questo momento ci siano molte DAO senza un vero scopo là fuori)</p>
<h3 id="h3-Q620Le20borse20come20Gateio20implementeranno20funzionalit20sociali20nella20loro20funzionalit20di20token20di20scambio983942"><a name="Q6: Le borse come Gate.io implementeranno funzionalità sociali nella loro funzionalità di token di scambio?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q6: Le borse come Gate.io implementeranno funzionalità sociali nella loro funzionalità di token di scambio?</h3><p><strong>John</strong>: Personalmente penso che sia qualcosa con cui gli scambi potrebbero davvero coinvolgere gli utenti. Quasi tutti gli scambi hanno ora il proprio token che consente di ridurre le commissioni di negoziazione o qualche altro vantaggio, ma e se quei token avessero veri poteri di governance. Ovviamente ciò potrebbe comportare alcuni problemi regolamentari, ma penso che prima o poi qualcuno lo proverà. Se i detentori di token potessero davvero votare per dirigere gli affari dello scambio, come ad esempio le quotazioni dei token, o votare sui tassi delle commissioni, ecc.<br>Questa è anche una domanda su cui pensavo che forse anche Gate.io avrebbe qualche intuizione.</p>
<div class="blog-details-info"><br><div>Autore: <strong>Rio Fu.</strong>, Community di Gate.io<br><div class="info-tips"><em>Questo articolo rappresenta solo le opinioni del ricercatore e non costituisce alcun suggerimento di investimento.<br></em><div><em></em>Gate.io si riserva tutti i diritti su questo articolo. Sarà consentito il ripostaggio dell'articolo a condizione che si faccia riferimento a Gate.io. In tutti i casi, saranno intraprese azioni legali per violazione del copyright.<br></div><p></p><br></div></div></div>