R2F0ZS5pbyBBTUEgY29uIEFnb3JpYy1IYXJkZW5lZCBKYXZhU2NyaXB0IFNtYXJ0IENvbnRyYWN0cyB8IEdvdmVybmF0byBkYSBCTEQ=

<p><img src="https://gimg2.gateimg.com/image/article/17030488361.jpeg" alt=""><br><strong>Ora: 18 dicembre 2023, 17:00 UTC</strong><br><strong><a href="https://www.gate.io" target="_blank">Gate.io</a> ha ospitato una sessione AMA (Ask-Me-Anything) con Dean Tribble, CEO di <a href="/price/agoric-bld" target="_blank" class="blog_inner_link">Agoric</a> nel <a href="https://t.me/gateio" rel="nofollow noopener noreferrer" target="_blank">Comunità di scambio Gate.io</a>.</strong><br><strong>Sito ufficiale: https:// <a href="/price/agoric-bld" rel="nofollow noopener noreferrer" target="_blank">Agoric</a>.com/</strong><br><strong>Twitter: <a href="https://twitter.com/agoric" rel="nofollow noopener noreferrer" target="_blank">https://twitter.com/agoric</a></strong><br><strong>Segui Agoric su <a href="https://t.me/agorics" rel="nofollow noopener noreferrer" target="_blank">Telegram</a> e <a href="https://twitter.com/agoric" rel="nofollow noopener noreferrer" target="_blank">Twitter</a></strong><br><strong>Ospite</strong><img src="https://gimg2.gateimg.com/image/article/17030491422.jpeg" alt=""><br><strong>Dean Tribble — CEO di Agoric</strong></p>
<h2 id="h2-Domande20e20risposte20da20Gateio49550"><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-Q120Puoi20per20favore20presentarti20ai20membri20della20Community20e20fare20unintroduzione20sul20tuo20progetto269863"><a name="Q1: Puoi per favore presentarti ai membri della Community e fare un’introduzione sul tuo progetto?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q1: Puoi per favore presentarti ai membri della Community e fare un’introduzione sul tuo progetto?</h3><p><img src="https://gimg2.gateimg.com/image/article/17030492753.jpeg" alt=""><br><strong>Dean</strong>: Ciao. Sono il CEO di Agoric s. Abbiamo costruito il software per la rete Agoric. Agoric è una piattaforma blockchain di livello 1 e di contratti intelligenti che consente ai milioni di sviluppatori Java nel mondo di costruire e distribuire contratti intelligenti, utilizzando la loro competenza, strumenti e ambienti di programmazione esistenti.</p>
<h3 id="h3-Q220Puoi20condividere20la20visione20dietro20Agoric20e20come20mira20a20portare20valore20allo20spazio20della20blockchain799310"><a name="Q2: Puoi condividere la visione dietro Agoric e come mira a portare valore allo spazio della blockchain?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q2: Puoi condividere la visione dietro Agoric e come mira a portare valore allo spazio della blockchain?</h3><p><strong>Dean</strong>: In Agoric, vogliamo vedere più cooperazione nel mondo, e gli smart contract sono uno strumento incredibilmente potente per aiutare a farlo: gli smart contract consentono agli estranei di collaborare! Perché questo abbia importanza, però, deve essere accessibile alla maggior parte dei programmatori del mondo. Non è di grande aiuto se, per costruire uno smart contract, devi andare a trovare uno dei soli 10k sviluppatori costosi di Solidity. Quindi abbiamo deciso di incontrare gli sviluppatori dove si trovano e di metterli in grado di creare contratti intelligenti nel linguaggio di programmazione più popolare, Java.</p>
<h3 id="h3-Q320Quali20vantaggi20offrono20i20contratti20intelligenti20Java683457"><a name="Q3: Quali vantaggi offrono i contratti intelligenti Java?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q3: Quali vantaggi offrono i contratti intelligenti Java?</h3><p><strong>Dean</strong>: Java ha diversi vantaggi importanti. Essendo il linguaggio di programmazione più popolare al mondo, già 15M+ sviluppatori lo conoscono!</p>
<p>Il linguaggio è flessibile, accessibile e viene fornito con un enorme ecosistema di strumenti per sviluppatori per la creazione, il test e il rilascio di applicazioni. Gli sviluppatori possono sfruttare quell’ecosistema con le loro competenze di programmazione esistenti per iniziare rapidamente.</p>
<p>Infine, utilizziamo il grande supporto di Java per i framework per fornire un framework e una libreria di componenti in rapida crescita di DeFi, NFT e contratti cross-chain, molto simile a quello che gli sviluppatori di Java web2 vivono quando costruiscono con le loro librerie React, Node o Vue preferite.</p>
<p>Potrei andare avanti per molto tempo! JS è utilizzato per controllare letteralmente miliardi di dollari in transazioni al giorno, ad esempio</p>
<h3 id="h3-D420In20che20modo20la20catena20agorica20comunica20con20altre20catene36665"><a name="D4: In che modo la catena agorica comunica con altre catene?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>D4: In che modo la catena agorica comunica con altre catene?</h3><p><strong>Dean</strong>: Agoric è stato appositamente costruito per interagire con altre catene.</p>
<p>Per realizzare ciò, Agoric utilizza il protocollo di comunicazione Inter-Blockchain (IBC), che in realtà abbiamo contribuito a creare! IBC è lo standard per il cross-chain tra diverse blockchain nella rete Cosmos e si sta espandendo ad altre come <a href="/price/avalanche-avax" rel="nofollow noopener noreferrer" target="_blank">Avalanche</a>(è stato lanciato di recente) e <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> (in corso).</p>
<p>Questo posiziona Agoric come il posto migliore per scrivere smart contract che comunicano cross-chain!</p>
<h3 id="h3-Q520Qual2020il20ruolo20del20token20BLD20nellecosistema20Agoric20e20come20contribuisce20alla20funzionalit20della20rete230436"><a name="Q5: Qual è il ruolo del token BLD nell’ecosistema Agoric e come contribuisce alla funzionalità della rete?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q5: Qual è il ruolo del token BLD nell’ecosistema Agoric e come contribuisce alla funzionalità della rete?</h3><p><strong>Dean</strong>: BLD è il token nativo di Agoric per lo staking e la governance. Agoric è una catena di Proof-of-Stake (costruita con CometBFT di Cosmos). I partecipanti scommettono i loro token BLD per partecipare al processo di convalida delle transazioni sulla rete Agoric. Questo processo garantisce che la rete operi con una robusta integrità. Inoltre, gli scommettitori del token BLD governano la catena e possono votare su cose come gli aggiornamenti della catena, fornendo agli scommettitori di BLD il controllo finale sulla rete Agoric.<br><img src="https://gimg2.gateimg.com/image/article/17030492984.jpeg" alt=""><br>Inoltre, l’altro token chiave nell’ecosistema Agoric è IST, che è implementato da Inter Protocol. IST è un token stabile progettato per mantenere la parità con il dollaro USA. È compatibile con le catene abilitate da IBC nell’ecosistema Cosmos e viene utilizzato principalmente per pagare commissioni e servizi sulla catena Agoric.</p>
<p>(ed è tutto scritto utilizzando lo stesso framework e componenti smart contract Zoe che gli sviluppatori utilizzano per costruire le loro applicazioni)</p>
<h3 id="h3-Q620In20poche20parole20cosa20distingue20Agoric20dagli20altri20L1484309"><a name="Q6: In poche parole, cosa distingue Agoric dagli altri L1?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q6: In poche parole, cosa distingue Agoric dagli altri L1?</h3><p><strong>Dean</strong>: In una parola, “programmabilità”.</p>
<p>Permette in modo unico a milioni di sviluppatori di entrare nel mondo delle criptovalute e consente in modo unico ai già sviluppatori di criptovalute di creare rapidamente applicazioni cross-chain, tutto in Java.</p>
<p>Immagina milioni di sviluppatori Java che innovano in web3, utilizzando gli stessi strumenti di cui sono già esperti. Ad esempio, ci sono molti sviluppatori FinTech imprenditoriali, finanziariamente motivati ed esperti là fuori. Molti hanno esaminato le attuali blockchain e si sono tirati indietro a causa della difficoltà e dell’insicurezza della programmazione.</p>
<p>Presso Agoric, la nostra catena di livello 1 e la piattaforma di contratti intelligenti consentono loro di unirsi ad altri sviluppatori di criptovalute nella costruzione della prossima ondata di soluzioni blockchain.</p>
<h2 id="h2-QampA20live20dalla20community388518"><a name="Q&amp;A live dalla community" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q&amp;A live dalla community</h2><h3 id="h3-Q120Ho20letto20che20tutti20i20tipi20di20asset20digitali20possono20essere20facilmente20creati20ma20soprattutto20possono20essere20trasferiti20esattamente20nello20stesso20modo20con20esattamente20le20stesse20propriet20di20sicurezza20Questo20mi20sembra20magico20come20siete20riusciti20a20farlo20Qual2020il20segreto20dietro20questo892649"><a name="Q1: Ho letto che tutti i tipi di asset digitali possono essere facilmente creati, ma soprattutto possono essere trasferiti esattamente nello stesso modo, con esattamente le stesse proprietà di sicurezza. Questo mi sembra magico, come siete riusciti a farlo? Qual è il segreto dietro questo?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q1: Ho letto che tutti i tipi di asset digitali possono essere facilmente creati, ma soprattutto possono essere trasferiti esattamente nello stesso modo, con esattamente le stesse proprietà di sicurezza. Questo mi sembra magico, come siete riusciti a farlo? Qual è il segreto dietro questo?</h3><p><strong>Dean</strong>: Il framework del contratto intelligente Zoe fornisce pratiche librerie JavaSript per gestire asset. Quindi puoi avere un Portafoglio di un particolare tipo di asset, prelevare un Pagamento, inviarlo a qualcuno e loro lo depositano nel loro Portafoglio. Il tipo di asset potrebbe essere fungibile, non fungibile (ad esempio, un insieme di NFT) o semi-fungibile. Un componente del contratto intelligente (ad esempio, un’asta) potrebbe gestire tutto questo senza modifiche; ad esempio, 30 righe di codice JS possono implementare un’asta che funziona per vendere 50 ATOM o un insieme di 3 NFT distinti.</p>
<h3 id="h3-Q220Java2020uno20dei20linguaggi20pi20utilizzati20dagli20sviluppatori20di20app20e20giochi20tuttavia2020stato20in20gran20parte20obsoleto20a20causa20delle20continue20vulnerabilit20di20crittografia20che20presenta20Quindi20perch20hai20deciso20di20utilizzare20questo20tipo20di20tecnologia20sulla20blockchain20Quali20vantaggi20offre20rispetto20a20Python50178"><a name="Q2: Java è uno dei linguaggi più utilizzati dagli sviluppatori di app e giochi, tuttavia è stato in gran parte obsoleto a causa delle continue vulnerabilità di crittografia che presenta. Quindi, perché hai deciso di utilizzare questo tipo di tecnologia sulla blockchain? Quali vantaggi offre rispetto a Python?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q2: Java è uno dei linguaggi più utilizzati dagli sviluppatori di app e giochi, tuttavia è stato in gran parte obsoleto a causa delle continue vulnerabilità di crittografia che presenta. Quindi, perché hai deciso di utilizzare questo tipo di tecnologia sulla blockchain? Quali vantaggi offre rispetto a Python?</h3><p><strong>Dean</strong>: Java è evoluto da umili origini. È progettato per essere molto mutevole, il che storicamente lo ha reso facile da attaccare. MA…. siamo stati nel comitato delle norme di Java per oltre 15 anni, guidando nel linguaggio la capacità di bloccarlo e renderlo abbastanza sicuro da essere utilizzato per controllare letteralmente trilioni di dollari ogni giorno in tutto, dalle applicazioni bancarie agli strumenti come Salesforce ai terminali di intermediazione come Bloomberg. Abbiamo costruito un’operazione di blocco in Java standard per irrobustirlo in modo che tu possa eseguire JS in un ambiente immutabile in modo sicuro. Viene utilizzato, ad esempio, per abilitare cose come le snap di MetaMask, dove puoi estendere il portafoglio con plugin JS per supportare catene come Agoric. I contratti intelligenti su Agoric sono scritti in quel Java irrobustito, quindi non soffrono della vulnerabilità a cui ti riferisci.</p>
<h3 id="h3-Q320Eccitato20perch20Agoric20sta20implementando20il20modello20di20commissioni20IST20nella20mainnet20Correggetemi20se20sbaglio20ma20credo20che20questo20significhi20che20i20detentori20di20BLD20riceveranno20ricompense20IST20insieme20alle20ricompense20BLD20Cose20eccitanti20da20una20catena20estremamente20promettente192871"><a name="Q3: Eccitato perché Agoric sta implementando il modello di commissioni $IST nella mainnet. Correggetemi se sbaglio, ma credo che questo significhi che i detentori di $BLD riceveranno ricompense $IST insieme alle ricompense $BLD? Cose eccitanti da una catena estremamente promettente." class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q3: Eccitato perché Agoric sta implementando il modello di commissioni $IST nella mainnet. Correggetemi se sbaglio, ma credo che questo significhi che i detentori di $BLD riceveranno ricompense $IST insieme alle ricompense $BLD? Cose eccitanti da una catena estremamente promettente.</h3><p><strong>Dean</strong>: Infatti, Agoric è uno dei primi progetti dual-token progettati (dal whitepaper): BLD è la base dell’economia dello staking e IST è il token stabile per le commissioni.</p>
<p>Se pensi ai prezzi del gas come al tuo affitto o alle spese postali, non ti aspetteresti di pagare l’affitto o le spese postali con un asset volatile come l’oro, o le azioni di Apple, o Eth. Tutti abbiamo scoperto letteralmente migliaia di anni fa che avere un’economia che utilizza un token stabile per i pagamenti, l’unità di valore, ecc. crea un’economia migliore e più vivace. Quindi utilizziamo IST per il gas, ecc.</p>
<p>Quindi il sistema è progettato affinché IST venga fornito come ricompensa, una volta che è fuori dalla fase di avvio. Al momento, sta ancora crescendo e diffondendosi nell’ecosistema intercatena, dove le commissioni vanno riservate in modo che possa crescere più velocemente. Mi aspetto che la comunità BLD non attivi le ricompense IST fino a quando non sarà ampiamente utilizzato e adottato. A quel punto, alcune commissioni andranno al pool di ricompense BLD.</p>
<h3 id="h3-Q420Dal20momento20che20gli20NFT20sono20popolari20al20giorno20doggi20avete20un20piano20per20lintegrazione20degli20NFT975135"><a name="Q4: Dal momento che gli NFT sono popolari al giorno d’oggi, avete un piano per l’integrazione degli NFT?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q4: Dal momento che gli NFT sono popolari al giorno d’oggi, avete un piano per l’integrazione degli NFT?</h3><p><strong>Dean</strong>: Il framework del contratto intelligente Zoe supporta tutti i tipi di contratti intelligenti e supporta sicuramente in modo fluido e integra gli NFT. La libreria dei componenti ha già componenti per la creazione di NFT, le aste di NFT, ecc. Il nostro primo hackathon per sviluppatori completamente nuovi al mondo delle criptovalute è stato quello di creare i propri NFT! Allo stesso modo, la prima applicazione di terze parti da distribuire su mainnet ha creato nuovi ‘NFT dinamici’, che consentono di includere nei NFT altri componenti patrimoniali; ad esempio, un NFT di un personaggio di gioco che contiene oggetti dell’inventario come maschere e attrezzi. Gli stessi componenti possono essere utilizzati, ad esempio, per un biglietto per un evento che contiene il parcheggio VIP e i buoni per le bevande.<br><img src="https://gimg2.gateimg.com/image/article/17030493365.jpeg" alt=""><br>Allo stesso modo, un’altra app di terze parti (Crabble) in fase di sviluppo consente il noleggio di NFT con utilità come abbonamenti, biglietti stagionali, ecc. Ciò sblocca un nuovo e ricco mercato per gli NFT. Stiamo anche collaborando con altre reti NFT nell’interchain (ad esempio, OmniFlix e Stargaze) per poterle programmare sulla catena Agoric in Java.</p>
<h3 id="h3-Q520Come20hai20coinvolto20la20comunit20nello20sviluppo20del20progetto20e20come20costruisci20una20forte20comunit20per20crescere20a20livello20globale630751"><a name="Q5: Come hai coinvolto la comunità nello sviluppo del progetto? e come costruisci una forte comunità per crescere a livello globale?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q5: Come hai coinvolto la comunità nello sviluppo del progetto? e come costruisci una forte comunità per crescere a livello globale?</h3><p><strong>Dean</strong>: Lavoriamo attivamente con la nostra fantastica community in diverse regioni, tra cui Turchia, Russia, Indonesia e presto ci espanderemo in India e Argentina. Abbiamo una nuova serie di articoli introduttivi sul nostro sito web che risponde a domande come cosa è Agoric, BLD o IST, attualmente disponibile in inglese.</p>
<p>Abbiamo appena tenuto il nostro primo meetup ad Ankara, in Turchia, dove oltre 80 studenti universitari hanno partecipato per conoscere i vantaggi di costruire con Agoric. Ci siamo anche alleati con altre catene di Cosmos per ospitare il nostro primo meetup a Bangalore, in India, dove oltre 150 costruttori di criptovalute si sono riuniti per conoscere Cosmos e Agoric.<br><img src="https://gimg2.gateimg.com/image/article/17030493486.jpeg" alt=""><br>Infine, ci espanderemo in Sud America con il nostro primo incontro a Buenos Aires nel gennaio 2024!<br>Se desideri partecipare a uno dei nostri prossimi eventi, iscriviti al nostro calendario degli eventi.<br><a href="https://lu.ma/agoric-events" rel="nofollow noopener noreferrer" target="_blank">https://lu.ma/agoric-events</a></p>
<p>Se vuoi contribuire a promuovere in una specifica regione organizzando incontri o workshop, puoi contattarci nel nostro server Discord: <a href="https://agoric.com/discord" rel="nofollow noopener noreferrer" target="_blank">https://agoric.com/discord</a></p>
<h3 id="h3-Q620La20fornitura20totale20del20token20BLD2020di20100674514720monete20BLD20Puoi20dirci20come2020distribuito20il20token20Quali20sono20i20modi20esistenti20che20offri20per20ottenere20questo20token342594"><a name="Q6: La fornitura totale del token $BLD è di 1.006.745.147 monete BLD. Puoi dirci come è distribuito il token? Quali sono i modi esistenti che offri per ottenere questo token?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q6: La fornitura totale del token $BLD è di 1.006.745.147 monete BLD. Puoi dirci come è distribuito il token? Quali sono i modi esistenti che offri per ottenere questo token?</h3><p><strong>Dean</strong>: Per tutti i dettagli dell’economia, della distribuzione dei token, ecc., visita la pagina dell’economia sul sito web di Agoric: <a href="https://agoric.com/economy" rel="nofollow noopener noreferrer" target="_blank">https://agoric.com/economy</a> , e ovviamente presso lo scambio. Puoi acquistare BLD da Gate.io, ovviamente (e anche da altri DEX e CEX). Grazie a Gate.io per l’elenco di BLD e per renderlo accessibile alla tua vasta comunità. Non vediamo l’ora di avere molti nuovi detentori di token, sviluppatori e progetti da qui!</p>
<div class="blog-details-info"><br><div>Autore:<strong> Rio Fu.</strong>, Comunità 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 sia citato Gate.io. In tutti i casi, saranno intraprese azioni legali per violazione del copyright.<br></div><p></p><br></div></div></div>