V2F0IGlzIEdpdGNvaW4/

2022-08-21, 14:28

<p><img src="https://gimg2.gateimg.com/image/article/168862686611.jpeg" alt=""></p>
<h2 id="h2-TLDR589979"><a name="[TL;DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL;DR]</h2><p>Gitcoin is een crypto platform waar programmeurs en ontwikkelaars gecompenseerd kunnen worden voor hun inspanningen aan open-source software geschreven in verschillende programmeertalen.</p>
<p>Gebruikers kunnen ook het Gitcoin-platform gebruiken voor crowdfunding van bijdragende donateurs voor hun projectideeën.</p>
<p>Naast rechtstreekse gemeenschapsfinanciering gebruikt <a href="/price/gitcoin-gtc" target="_blank" class="blog_inner_link">Gitcoin</a> een uniek systeem dat bekend staat als kwadratische financiering om gemeenschapsfinancieringsinspanningen te koppelen om de ontwikkeling van de meest populaire projecten te versnellen.</p>
<p>Over het algemeen is Gitcoin een platform dat is ontworpen om de creatie van betekenisvolle, open-source projecten aan te moedigen, waarbij de belangen van donateurs en ontwikkelaars beter op elkaar worden afgestemd.</p>
<h2 id="h2-Introductie212064"><a name="Introductie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introductie</h2><p><img src="https://gimg2.gateimg.com/image/article/168862689612.png" alt=""><a href="/price/gitcoin-gtc" rel="nofollow noopener noreferrer" target="_blank">Gitcoin</a>.co</p>
<p>De cryptomarkt kent nooit een tekort aan altcoins, waar er dagelijks meer van worden gecreëerd. In deze smeltkroes van projecten en ideeën kan wat een bedrijf doet om zich te onderscheiden net zo interessant zijn als zijn producten - technologische innovatie, financiële decentralisatie of onderscheidende merkpositionering. Gitcoin (GTC) is een gedecentraliseerd cryptoplatform dat zich onderscheidt door te investeren in open-source projecten. De inheemse munt GTC wordt momenteel verhandeld tegen $3,24, met een handelsvolume van $11,49 miljoen en een marktkapitalisatie van $46 miljoen.</p>
<h2 id="h2-Wat20is20Gitcoin49473"><a name="Wat is Gitcoin?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wat is Gitcoin?</h2><p>Gitcoin is een crypto-platform dat in november 2017 is gelanceerd om samenwerking te bevorderen bij open-source softwareprojecten. Dit wordt bereikt door ontwikkelaars te motiveren met beloningsbetalingen en subsidies om ontwikkelingsprojecten op zich te nemen. Omdat open-source software gratis en open is, dragen veel ontwikkelaars eraan bij zonder of met weinig directe vergoeding. Gitcoin is echter een beloningssysteem geworden om ontwikkelaars te stimuleren die willen bijdragen aan betekenisvolle open-source softwaretoepassingen.</p>
<p>De belangrijkste niche en focus van het Gitcoin-platform zijn producten voor ‘openbare goederen’ die bedoeld zijn om iedereen ten goede te komen zonder noodzakelijkerwijs met elkaar te concurreren. Projecten met betrekking tot schone lucht, infrastructuur en privacy zijn voorbeelden van projecten voor openbare goederen. Het is opmerkelijk dat de meeste door Gitcoin gefinancierde projecten voor openbare goederen zich richten op blockchain binnen de <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> ecosysteem. Er zijn lopende projecten,</p>
<p>Gitcoin heeft tot doel getalenteerde ontwikkelaars aan te trekken door financiële prikkels te bieden om deel te nemen aan hackathons, beloningen en gefinancierde gemeenschapsbeurzen. Ontwikkelaars die aan een project willen werken, kunnen het indienen bij het Gitcoin-platform en financiering crowdsourcen van andere bijdragers, evenals deelnemen aan kwartaalmogelijkheden om financiering te verdienen via het innovatieve mechanisme dat bekend staat als kwadratische financiering.</p>
<h2 id="h2-FunctiesOpensource20gebruik20in20Gitcoin546231"><a name="Functies/Open-source gebruik in Gitcoin" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Functies/Open-source gebruik in Gitcoin</h2><h3 id="h3-Quadratische20financiering220672"><a name="Quadratische financiering" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Quadratische financiering</h3><p>Via een democratisch en eigendomsrechtelijk systeem dat bekend staat als kwadratische financiering, <a href="/price/gitcoin-gtc" rel="nofollow noopener noreferrer" target="_blank">Gitcoin crypto</a> Financiering is gericht op projecten van openbare goederen. Kwadratische financiering is een crowdfundingscampagne waarbij individuele donaties worden gekoppeld aan overeenkomstige bedragen aan financiering uit grotere fondsen die worden verstrekt door prominentere donateurs. In plaats van een 1:1-verhouding worden fondsen “gekoppeld” volgens een eigen formule. De formule is aangepast om projecten te belonen die meer steun van de gemeenschap krijgen. Als een subsidie bijvoorbeeld 100 individuele donaties van $1 USD ontvangt, zal deze meer aan gekoppelde fondsen ontvangen dan een subsidie die één donatie van $100 ontvangt.</p>
<h3 id="h3-Ontwikkelaarsubsidies561047"><a name="Ontwikkelaarsubsidies:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Ontwikkelaarsubsidies:</h3><p>Ontwikkelaars met een doel kunnen gebruikmaken van kwadratische financiering op het Gitcoin-platform om hun projecten te financieren. Gebruikers die hun subsidies indienen, moeten een duidelijke projecttitel en -beschrijving maken en aangeven of ze willen dat bijdragers geld doneren in een specifieke ERC-20-token (Gitcoin ondersteunt alle ERC-20-tokens). Gitcoin heeft meer dan $50 miljoen aan financiering verstrekt voor opensourceprojecten in de technologiesector en heeft ongeveer 50.000 financiers en bijna 250.000 ontwikkelaars geholpen. Met meer dan 300.000 ontwikkelaars die maandelijks de webdomein van Gitcoin bezoeken, is het platform actief en beroemd in de crypto-community.</p>
<h3 id="h3-Gitcoin20Beloningen558232"><a name="Gitcoin Beloningen:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Gitcoin Beloningen:</h3><p>Gitcoin stelt gebruikers in staat om ondersteuning van beschikbare ontwikkelaars op het Gitcoin-platform te crowdsourcen om specifieke technologische ontwikkelingskwesties te financieren. Een gebruiker zou een probleem op GitHub moeten maken en het probleem op Gitcoin moeten financieren (met vermelding van projectdetails, een voltooiingstermijn en andere verwachtingen of relevante informatie). De bijdragers kunnen een kort formulier indienen om hun interesse in het voltooien van het probleem kenbaar te maken. De beloningen kunnen toestemming vereisen, waarbij goedkeuring van de financier nodig is voordat er wordt begonnen met werken, of toestemmingloos zijn, waarbij iedereen op elk moment de beloning kan voltooien. Financiers kunnen op hun gemak werknemers kiezen, deadlines instellen en op elk moment annuleren met behulp van Gitcoin-beloningen.</p>
<h3 id="h3-Hackathons322696"><a name="Hackathons:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Hackathons:</h3><p>Dit zijn evenementen georganiseerd door Gitcoin, waar programmeurs samenkomen om in een korte periode een werkend softwareproject vanaf nul te proberen te maken. Deze competities kunnen worden ontworpen als een motiverende of vertrouwenopbouwende oefening in het belang van professionele interesse, of ze kunnen dienen als oefening.</p>
<h3 id="h3-Community20governance20via20Gitcoin20Token20GTC58454"><a name="Community governance via Gitcoin Token (GTC):" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Community governance via Gitcoin Token (GTC):</h3><p>Een DAO bestuurt Gitcoin en gebruikers kunnen deelnemen aan het platformbeheer door verschillende voorstellen voor te stellen en erover te stemmen met behulp van hun Gitcoin-tokens (GTC). Het platform gaat geleidelijk over naar volledige decentralisatie, waarbij de gemeenschap uiteindelijk al het platformbeheer overneemt. Het doel van de GTC-tokendistributie is om zowel vroege gebruikers van het Gitcoin-platform als toekomstige bijdragers te belonen. 15% van de GTC wordt met terugwerkende kracht gedistribueerd naar platformgebruikers, 35% naar bestaande belanghebbenden en 50% wordt gedistribueerd door Gitcoin’s DAO. De airdrops met terugwerkende kracht werden uitgedeeld aan vroege platformgebruikers die deelnamen aan activiteiten zoals het openen van een bounty, het indienen van werk voor een bounty, het openen van een beurs of bijdragen aan een subsidie, onder andere. De oprichters, investeerders, werknemers en strategische partners ontvingen het grootste deel van de GTC die onder belanghebbenden werd uitgedeeld. De GTC-tokens die zijn gereserveerd voor de Gitcoin DAO worden beheerd door een door de gemeenschap geleide schatkist. Ze worden in gelijke maandelijkse termijnen vrijgegeven totdat alle 50 miljoen GTC-tokens in mei 2023 zijn ontgrendeld.</p>
<h2 id="h2-Hoe20werkt20Gitcoin919817"><a name="Hoe werkt Gitcoin?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Hoe werkt Gitcoin?</h2><p>Gitcoin financiert op democratische wijze open-source projecten en zoekt manieren om bij te dragen aan de digitale ruimte, terwijl het zich houdt aan de kernwaarden van gedecentraliseerde financiën (Defi). Het platform bevordert op natuurlijke en praktische wijze relaties tussen financiers en ontwikkelaars, waarbij de hierboven genoemde technieken worden gebruikt om fondsen te verstrekken aan degenen die dat het meest verdienen.</p>
<p>Het platform vervult deze functies voornamelijk via Github, opgericht in 2008, en is sindsdien uitgegroeid tot een van de belangrijkste hostingplatforms op internet voor coderingsprojecten. In dit g dient Github echter als de primaire interface van Gitcoin, waar verschillende programma’s en projecten worden gehost om de doelstellingen van het cryptocurrency bedrijf te bereiken.<br><img src="https://gimg2.gateimg.com/image/article/168862697513.png" alt=""><br>github.com</p>
<h2 id="h2-Conclusie682840"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h2><p>Gitcoin neemt een ongekende aanpak, waarbij vertrouwd wordt op open-source projecten om het doel van volledige decentralisatie van het bedrijf te bereiken.</p>
<p>Hoewel de recente prijsprestaties van Gitcoin en GTC niet ongewoon zijn in de cryptowereld, is het nog steeds zorgwekkend. Desalniettemin heeft de aanpak van Gitcoin vanuit een breder perspectief het potentieel om de wereld van de cryptohandel in het algemeen te beïnvloeden en het maakt het mogelijk om te experimenteren met een breed scala aan intrigerende ideeën. Met de evolutie van de Metaverse en het grotere Web 3.0 kunnen innovatieve bedrijven zoals Gitcoin uiteindelijk de cryptowereld en het gedecentraliseerde web naar nieuwe hoogten van welvaart stuwen.</p>
<div class="blog-details-info"><br><div>Auteur: <strong>Mashell C.</strong>, Gate.io-onderzoeker<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 op dit artikel. Het opnieuw plaatsen van het artikel is 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>