R2F0ZS5pbyBBTUEgbWV0IEFnb3JpYy1IYXJkZW5lZCBKYXZhU2NyaXB0IFNtYXJ0IENvbnRyYWN0cyB8IEJlc3R1dXJkIGRvb3IgQkxE

<p><img src="https://gimg2.gateimg.com/image/article/17030488361.jpeg" alt=""><br><strong>Tijd: 18 december 2023, 17:00 UTC</strong><br><strong><a href="https://www.gate.io" target="_blank">Gate.io</a> georganiseerd een AMA (Vraag-Me-Alles) sessie met Dean Tribble, CEO van <a href="/price/agoric-bld" target="_blank" class="blog_inner_link">Agoric</a> 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: 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>Volg Agoric op <a href="https://t.me/agorics" rel="nofollow noopener noreferrer" target="_blank">Telegram</a> en <a href="https://twitter.com/agoric" rel="nofollow noopener noreferrer" target="_blank">Twitter</a></strong><br><strong>Gast</strong><img src="https://gimg2.gateimg.com/image/article/17030491422.jpeg" alt=""><br><strong>Dean Tribble - CEO van Agoric</strong></p>
<h2 id="h2-QampA20van20Gateio478081"><a name="Q&amp;A van Gate.io" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q&amp;A van Gate.io</h2><h3 id="h3-Q120Kun20je20jezelf20voorstellen20aan20de20leden20van20de20gemeenschap20en20een20introductie20geven20over20je20project347066"><a name="Q1: Kun je jezelf voorstellen aan de leden van de gemeenschap en een introductie geven over je project?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q1: Kun je jezelf voorstellen aan de leden van de gemeenschap en een introductie geven over je project?</h3><p><img src="https://gimg2.gateimg.com/image/article/17030492753.jpeg" alt=""><br><strong>Dean</strong>: Hallo. Ik ben CEO van Agoric s. We bouwen de software voor het Agoric-netwerk. Agoric is een layer-1 blockchain en smart contract platform dat miljoenen Java-ontwikkelaars ter wereld in staat stelt slimme contracten te bouwen en te implementeren, met behulp van hun bestaande expertise, tools en programmeeromgevingen.</p>
<h3 id="h3-Q220Kun20je20de20visie20achter20Agoric20delen20en20hoe20het20waarde20wil20toevoegen20aan20de20blockchain20ruimte18053"><a name="Q2: Kun je de visie achter Agoric delen en hoe het waarde wil toevoegen aan de blockchain ruimte?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q2: Kun je de visie achter Agoric delen en hoe het waarde wil toevoegen aan de blockchain ruimte?</h3><p><strong>Dean</strong>: Bij Agoric willen we meer samenwerking in de wereld zien, en slimme contracten zijn een ongelooflijk krachtig instrument om dat te laten gebeuren: slimme contracten maken het mogelijk dat vreemden samenwerken! Maar om dat relevant te laten zijn, moet het toegankelijk zijn voor de meeste programmeurs ter wereld. Het helpt niet veel als je een slim contract wilt laten bouwen en je een van de slechts 10k dure Solidity-ontwikkelaars moet vinden. Dus gingen we op pad om ontwikkelaars te ontmoeten waar ze zijn en hen in staat te stellen slimme contracten te bouwen in de meest populaire programmeertaal, Java.</p>
<h3 id="h3-Q320Welke20voordelen20bieden20Java20smart20contracts32560"><a name="Q3: Welke voordelen bieden Java smart contracts?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q3: Welke voordelen bieden Java smart contracts?</h3><p><strong>Dean</strong>: Java heeft verschillende belangrijke voordelen. Als de meest populaire programmeertaal op de planeet, weten al meer dan 15 miljoen ontwikkelaars het al!</p>
<p>De taal is flexibel, toegankelijk en wordt geleverd met een enorme ecosysteem van ontwikkelaarstools voor het bouwen, testen en implementeren van applicaties. Ontwikkelaars kunnen dat ecosysteem benutten met hun bestaande programmeervaardigheden om snel aan de slag te gaan.</p>
<p>Tot slot maken we gebruik van de geweldige ondersteuning voor frameworks van Java om een framework en een snel groeiende bibliotheek van DeFi, NFT en cross-chain contracten te bieden, die erg lijkt op wat web2 Java-ontwikkelaars ervaren bij het bouwen met hun favoriete React, Node of Vue-bibliotheken.</p>
<p>(Ik zou lang kunnen doorgaan! JS wordt bijvoorbeeld gebruikt om letterlijk biljoenen dollars aan transacties per dag te beheren)</p>
<h3 id="h3-Q420Hoe20communiceert20de20Agoricketen20met20andere20ketens806221"><a name="Q4: Hoe communiceert de Agoric-keten met andere ketens?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q4: Hoe communiceert de Agoric-keten met andere ketens?</h3><p><strong>Decaan</strong>: Agoric is speciaal gebouwd om samen te werken met andere chains.</p>
<p>Om dit te bereiken, gebruikt Agoric het Inter-Blockchain Communication (IBC) protocol, waar we eigenlijk aan hebben geholpen creëren! IBC is de standaard voor cross-chain tussen verschillende blockchains in het Cosmos-netwerk, en breidt uit naar andere zoals <a href="/price/avalanche-avax" rel="nofollow noopener noreferrer" target="_blank">Lawine</a> (is onlangs live gegaan) en <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> (in behandeling).</p>
<p>Dit positioneert Agoric als de beste plek om slimme contracten te schrijven die cross-chain communiceren!</p>
<h3 id="h3-Vraag20520Wat20is20de20rol20van20het20BLDtoken20in20het20Agoricecosysteem20en20hoe20draagt20het20bij20aan20de20functionaliteit20van20het20netwerk499998"><a name="Vraag 5: Wat is de rol van het BLD-token in het Agoric-ecosysteem en hoe draagt het bij aan de functionaliteit van het netwerk?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Vraag 5: Wat is de rol van het BLD-token in het Agoric-ecosysteem en hoe draagt het bij aan de functionaliteit van het netwerk?</h3><p><strong>Dean</strong>: BLD is de native token van Agoric voor staking en governance. Agoric is een Proof-of-Stake chain (gebouwd met Cosmos’ CometBFT). Deelnemers staken hun BLD-tokens om deel te nemen aan het transactiidatieproces op het Agoric-netwerk. Dit proces zorgt ervoor dat het netwerk met robuuste integriteit werkt. Bovendien hebben stakers van de BLD-token de controle over de chain en kunnen ze stemmen over zaken als chain-upgrades, waardoor BLD-stakers ultieme controle hebben over het Agoric-netwerk.<br><img src="https://gimg2.gateimg.com/image/article/17030492984.jpeg" alt=""><br>Daarnaast is de andere belangrijke token in het Agoric ecosysteem IST, dat geïmplementeerd wordt door Inter Protocol. IST is een stabiele token die is ontworpen om gelijkwaardig te blijven aan de USD. Het is compatibel met IBC-ingeschakelde ketens in het Cosmos-ecosysteem en wordt voornamelijk gebruikt om te betalen voor kosten en diensten op de Agoric-keten.</p>
<p>(en het is allemaal geschreven met behulp van hetzelfde Zoe smart contract framework en componenten als ontwikkelaars gebruiken om hun applicaties te bouwen)</p>
<h3 id="h3-Q620In20enkele20woorden20wat20maakt20Agoric20anders20dan20andere20L1s349058"><a name="Q6: In enkele woorden, wat maakt Agoric anders dan andere L1’s?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q6: In enkele woorden, wat maakt Agoric anders dan andere L1’s?</h3><p><strong>Dean</strong>: In één woord, ‘programmeerbaarheid’.</p>
<p>Het stelt miljoenen ontwikkelaars in staat om uniek in crypto te stappen en het stelt bestaande crypto-ontwikkelaars in staat om snel cross-chain applicaties te bouwen, allemaal in Java.</p>
<p>Stel je miljoenen Java-ontwikkelaars voor die innoveren in <a href="/web3" target="_blank" class="blog_inner_link">web3</a> en dezelfde tools gebruiken waar ze al experts in zijn. Bijvoorbeeld, er zijn veel ondernemende, financieel gemotiveerde, ervaren FinTech-ontwikkelaars die er zijn. Velen hebben de huidige blockchains bekeken en afgehaakt vanwege de moeilijkheid en onveiligheid van het programmeren ervan.</p>
<p>Bij Agoric stelt ons layer-1 chain en smart contract platform hen in staat om zich aan te sluiten bij andere crypto-ontwikkelaars bij het bouwen van de volgende golf van blockchain-oplossingen.</p>
<h2 id="h2-Live20vraag20en20antwoord20vanuit20de20community253370"><a name="Live vraag en antwoord vanuit de community" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Live vraag en antwoord vanuit de community</h2><h3 id="h3-Q120Ik20las20dat20allerlei20soorten20digitale20activa20gemakkelijk20kunnen20worden20gemaakt20maar20belangrijk20is20dat20ze20op20exact20dezelfde20manieren20kunnen20worden20overgedragen20met20exact20dezelfde20beveiligingseigenschappen20Dit20klinkt20als20magie20voor20mij20hoe20zijn20jullie20hierin20geslaagd20Wat20is20het20geheim20hierachter770768"><a name="Q1: Ik las dat allerlei soorten digitale activa gemakkelijk kunnen worden gemaakt, maar belangrijk is dat ze op exact dezelfde manieren kunnen worden overgedragen, met exact dezelfde beveiligingseigenschappen. Dit klinkt als magie voor mij, hoe zijn jullie hierin geslaagd? Wat is het geheim hierachter?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q1: Ik las dat allerlei soorten digitale activa gemakkelijk kunnen worden gemaakt, maar belangrijk is dat ze op exact dezelfde manieren kunnen worden overgedragen, met exact dezelfde beveiligingseigenschappen. Dit klinkt als magie voor mij, hoe zijn jullie hierin geslaagd? Wat is het geheim hierachter?</h3><p><strong>Dean</strong>: Het Zoe smart contract-raamwerk biedt handige Java-bibliotheken voor het afhandelen van activa. Zo kunt u bijvoorbeeld een portemonnee hebben van een bepaald type activum, een betaling opnemen, deze naar iemand sturen en zij storten het op hun portemonnee. Het type activum kan fungibel, niet-fungibel zijn (bijv. een set NFT’s) of semi-fungibel. Eén smart contract-component (bijv. een veiling) kan al deze zaken afhandelen zonder wijziging; bijv. 30 regels JS-code kunnen een veiling implementeren die werkt om 50 ATOM’s of een set van 3 verschillende NFT’s te verkopen.</p>
<h3 id="h3-Q220Java20is20een20van20de20meest20gebruikte20talen20door20app20en20gameontwikkelaars20echter20het20is20grotendeels20verouderd20geraakt20door20de20constante20versleutelingsfouten20die20ze20presenteren20Waarom20heb20je20dan20besloten20om20dit20type20technologie20te20gebruiken20op20blockchain20Welke20voordelen20biedt20het20voordat20Python292897"><a name="Q2: Java is een van de meest gebruikte talen door app- en game-ontwikkelaars, echter, het is grotendeels verouderd geraakt door de constante versleutelingsfouten die ze presenteren. Waarom heb je dan besloten om dit type technologie te gebruiken op blockchain? Welke voordelen biedt het voordat Python?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q2: Java is een van de meest gebruikte talen door app- en game-ontwikkelaars, echter, het is grotendeels verouderd geraakt door de constante versleutelingsfouten die ze presenteren. Waarom heb je dan besloten om dit type technologie te gebruiken op blockchain? Welke voordelen biedt het voordat Python?</h3><p><strong>Dean</strong>: Java is geëvolueerd van bescheiden begin. Het is ontworpen om zeer veranderlijk te zijn, wat historisch gezien gemakkelijk aan te vallen maakte. MAAR…. we zijn al meer dan 15 jaar lid van het Java-standaardcomité en hebben het vermogen toegevoegd om het te vergrendelen en het veilig genoeg te maken dat het wordt gebruikt om letterlijk biljoenen dollars per dag te beheren, van banktoepassingen tot tools zoals Salesforce en brokerage-terminals zoals Bloomberg. We hebben een lockdown-operatie in standaard Java gebouwd om het te versterken, zodat je JS veilig kunt uitvoeren in een onveranderlijke omgeving. Het wordt bijvoorbeeld gebruikt om dingen zoals MetaMask-snaps mogelijk te maken, waar je de portemonnee kunt uitbreiden met JS-plug-ins om ketens zoals Agoric te ondersteunen. Slimme contracten op Agoric zijn geschreven in die geharde Java, zodat ze niet kwetsbaar zijn voor de door u genoemde kwetsbaarheid.</p>
<h3 id="h3-Q320Enthousiast20omdat20agoric20het20IST20vergoedingsmodel20in20het20mainnet20implementeert20Corrigeer20me20als20ik20het20mis20heb20maar20ik20geloof20dat20dit20betekent20BLD20stakers20naast20BLD20beloningen20ook20IST20beloningen20zullen20ontvangen20Spannend20spul20van20een20uiterst20veelbelovende20keten304347"><a name="Q3: Enthousiast omdat agoric het $IST vergoedingsmodel in het mainnet implementeert. Corrigeer me als ik het mis heb, maar ik geloof dat dit betekent $BLD stakers naast $BLD beloningen ook $IST beloningen zullen ontvangen? Spannend spul van een uiterst veelbelovende keten." class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q3: Enthousiast omdat agoric het $IST vergoedingsmodel in het mainnet implementeert. Corrigeer me als ik het mis heb, maar ik geloof dat dit betekent $BLD stakers naast $BLD beloningen ook $IST beloningen zullen ontvangen? Spannend spul van een uiterst veelbelovende keten.</h3><p><strong>Dean</strong>: Inderdaad, Agoric is een van de eerste dual-token ontworpen (volgens het whitepaper): BLD is de basis van de staking economie en IST is de stabiele token voor kosten.</p>
<p>Als je de gasprijzen ziet als de huur van je post, zou je niet verwachten dat je de huur of post betaalt met een volatiel bezit zoals goud, Apple-aandelen of Eth. We ontdekten duizenden jaren geleden al dat het hebben van een economie die een stabiele token gebruikt voor betalingen, eenheid van waarde, enz. zorgt voor een betere en levendigere economie. Dus we gebruiken IST voor gas, enz.</p>
<p>Dus het systeem is ontworpen om IST te verstrekken als beloningen, EENMAAL het uit de opstartfase is. Op dit moment groeit en verspreidt het nog steeds in het interchain-ecosysteem, waar de kosten naar de Reserve gaan zodat het sneller kan groeien. Ik verwacht dat de BLD-gemeenschap de IST-beloningen niet inschakelt totdat deze breed wordt gebruikt en aangenomen. Dan zullen enkele kosten naar het BLD-beloningsfonds gaan.</p>
<h3 id="h3-Q420Aangezien20NFT20tegenwoordig20populair20is20hebt20u20daar20een20plan20voor20NFTintegratie684229"><a name="Q4: Aangezien NFT tegenwoordig populair is, hebt u daar een plan voor NFT-integratie?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q4: Aangezien NFT tegenwoordig populair is, hebt u daar een plan voor NFT-integratie?</h3><p><strong>Dean</strong>: Het Zoe smart contract framework ondersteunt allerlei soorten smart contracts en ondersteunt en integreert zeker soepel NFT’s. De componentenbibliotheek heeft al componenten voor het maken van NFT’s, NFT-veilingen, enzovoort. Onze eerste hackathon voor ontwikkelaars die helemaal nieuw zijn in crypto was om hun eigen NFT’s te maken! Op dezelfde manier creëerde de eerste externe applicatie die werd ingezet op mainnet nieuwe ‘dynamische NFT’s’, waarmee NFT’s andere activacomponenten kunnen bevatten; bijvoorbeeld een gamekarakter NFT dat inventarisitems zoals maskers en gereedschap bevat. Dezelfde componenten kunnen bijvoorbeeld worden gebruikt voor een evenementticket dat VIP-parkeren en drinktickets bevat.<br><img src="https://gimg2.gateimg.com/image/article/17030493365.jpeg" alt=""><br>Op dezelfde manier maakt een andere externe app (Crabble) in ontwikkeling het mogelijk om NFT’s te huren met functionaliteiten zoals abonnementen, seizoenskaarten, enzovoort. Dat opent een hele nieuwe markt voor rijke NFT’s. We werken ook samen met andere NFT-netwerken in het interchain (bijv. OmniFlix en Stargaze) om ze te kunnen programmeren op de Agoric-chain in Java.</p>
<h3 id="h3-Q520Hoe20heeft20u20de20gemeenschap20betrokken20bij20de20ontwikkeling20van20het20project20en20hoe20bouwt20u20een20sterke20gemeenschap20om20wereldwijd20te20groeien15092"><a name="Q5: Hoe heeft u de gemeenschap betrokken bij de ontwikkeling van het project? en hoe bouwt u een sterke gemeenschap om wereldwijd te groeien?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q5: Hoe heeft u de gemeenschap betrokken bij de ontwikkeling van het project? en hoe bouwt u een sterke gemeenschap om wereldwijd te groeien?</h3><p><strong>Dean</strong>: We werken actief samen met onze geweldige gemeenschap in verschillende regio’s, waaronder Turkije, Rusland, Indonesië en binnenkort ook in India en Argentinië. We hebben een nieuwe reeks artikelen op onze website die vragen beantwoorden zoals wat Agoric, BLD of IST is, momenteel beschikbaar in het Engels.</p>
<p>We hebben zojuist onze eerste bijeenkomst gehouden in Ankara, Turkije, waar meer dan 80 universiteitsstudenten aanwezig waren om meer te weten te komen over de voordelen van het bouwen met Agoric. We hebben ook samengewerkt met andere Cosmos chains om onze eerste bijeenkomst te organiseren in Bangalore, India, waar meer dan 150 crypto-bouwers bijeenkwamen om meer te leren over Cosmos en Agoric.<br><img src="https://gimg2.gateimg.com/image/article/17030493486.jpeg" alt=""><br>Tot slot breiden we uit naar Zuid-Amerika met onze eerste bijeenkomst in Buenos Aires in januari 2024!<br>Als je een van onze aankomende evenementen wilt bijwonen, abonneer je dan op onze evenementenkalender.<br><a href="https://lu.ma/agoric-events" rel="nofollow noopener noreferrer" target="_blank">https://lu.ma/agoric-events</a></p>
<p>Als je wilt helpen pleiten in een specifieke regio door meetups of workshops te organiseren, kun je contact opnemen in onze Discord-server: <a href="https://agoric.com/discord" rel="nofollow noopener noreferrer" target="_blank">https://agoric.com/discord</a></p>
<h3 id="h3-Q620De20totale20levering20van20de20BLDtoken20is20100674514720BLDmunten20Kunt20u20ons20vertellen20hoe20de20tokenverdeling20is20Wat20zijn20de20bestaande20manieren20die20u20aanbiedt20om20deze20token20te20krijgen357094"><a name="Q6: De totale levering van de $BLD-token is 1.006.745.147 BLD-munten. Kunt u ons vertellen hoe de tokenverdeling is? Wat zijn de bestaande manieren die u aanbiedt om deze token te krijgen?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q6: De totale levering van de $BLD-token is 1.006.745.147 BLD-munten. Kunt u ons vertellen hoe de tokenverdeling is? Wat zijn de bestaande manieren die u aanbiedt om deze token te krijgen?</h3><p><strong>Dean</strong>: Voor alle details over de economie, token distributie, enz. kunt u de economie pagina op de Agoric website bekijken: <a href="https://agoric.com/economy" rel="nofollow noopener noreferrer" target="_blank">https://agoric.com/economy</a> , en natuurlijk op de beurs. Je kunt BLD natuurlijk verwerven via Gate.io (en ook via andere DEXs en CEXs). Bedankt Gate.io voor het vermelden van BLD en het toegankelijk maken voor jullie bredere gemeenschap. We kijken uit naar veel nieuwe tokenhouders, ontwikkelaars en projecten van hier!</p>
<div class="blog-details-info"><br><div>Auteur:<strong> Rio Fu.</strong>, Gate.io Gemeenschap<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de mening van de onderzoeker en vormt geen enkele beleggingssuggestie.<br></em><div><em></em>Gate.io behoudt alle rechten voor dit artikel. Het opnieuw plaatsen van het artikel zal worden toegestaan op voorwaarde dat Gate.io wordt vermeld. In alle glen zal juridische actie worden ondernomen wegens auteursrechtinbreuk.<br></div><p></p><br></div></div></div>