Z2F0ZUxpdmUgQU1BIFJlY2FwLVNlaQ==

2023-10-26, 01:27

<p><img src="https://gimg2.gateimg.com/image/article/1698283358Blog.jpg" alt=""></p>
<h2 id="h2-Vertel20me20meer20over20je20achtergrond421759"><a name="Vertel me meer over je achtergrond" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Vertel me meer over je achtergrond</h2><p><strong>Phillip (Marketing &amp; Growth Lead of Sei)</strong><br>Mijn reis in het Web3-realm begon door lid te worden van een oprichtingsteam op <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a>, waar ik een sleutelrol speelde als Hoofd Marketing &amp; Groei. Mijn verantwoordelijkheden omvatten het regisseren van de ontwikkeling van cross-chain infrastructuur die is afgestemd op zowel EVM- als niet-EVM-compatibele chains.</p>
<p>Met die ervaring op zak ben ik vervolgens bij Trader Joe gaan werken, waarbij ik me richtte op het ondersteunen van hun go-to-market-strategie voor de uitbreidingsinspanningen van de multiketen van de DEX, en deze implementeerde op Arbitrum en <a href="/price/bnb-bnb" rel="nofollow noopener noreferrer" target="_blank">BNB</a> keten vanuit een marketingperspectief. In mijn huidige rol bij Sei Labs draag ik de pet van Marketing en Growth Lead, waarbij ik mijn expertise inzet om de groei van het ecosysteem te versterken en onze marktaanwezigheid te laten evolueren.</p>
<h2 id="h2-Wat20is20Sei645040"><a name="Wat is Sei?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wat is Sei?</h2><p><strong>Phillip（Marketing&amp;Growth Lead of Sei）</strong><br>Sei is een open-source, toestemmingloze Layer 1 blockchain, specifiek ontworpen als reactie op het fundamentele gebruik van blockchains, namelijk het vermogen om digitale activa uit te wisselen. Naarmate digitale activa - van NFT’s en gamingactiva tot DeFi - blijven groeien, neemt ook de vraag naar zeer presterende blockchains toe. Als antwoord op deze oproep is Sei op maat gemaakt om de ideale bestemming te zijn voor applicaties met een hoge prestaties en een topgebruikerservaring in Web3.</p>
<p>Met dit in gedachten is Sei gebouwd met de nadruk op snelheid, prestaties en technologische innovatie. Het heeft een van de snelste tijden tot finaliteit van alle blockchains, een potentieel hogere doorvoer dan het theoretische maximum van elke Rollup waarop is gebouwd <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a>, en lage latentie, dit alles dankzij het gebruik van geavanceerde technologieën. Deze omvatten parallelle verwerking, directe blokfinaliteit en nieuwe mechanismen voor efficiënte blokpropagatie en -verwerking.</p>
<h2 id="h2-Verhaal20over20hoe20Sei20begon942234"><a name="Verhaal over hoe Sei begon?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Verhaal over hoe Sei begon?</h2><p><strong>Phillip (Marketing &amp; Growth Lead van Sei)</strong><br>De oprichting van Sei kan worden herleid tot inzichten die zijn opgedaan uit de diverse ervaringen van ons team in de technologie- en financiële sector. Een cruciaal moment deed zich voor toen onze medeoprichters, Jay, werkten als een vroege ingenieur bij Robinhood. Daar onderscheidde hij aanzienlijke uitdagingen die verband hielden met het gebrek aan transparantie in gecentraliseerde beurzen. Dergelijke onthullingen benadrukten het cruciale belang van decentralisatie en benadrukten de cruciale rol van handel en de uitwisseling van digitale activa in het blockchain-realm.</p>
<p>Erkennend dat veel bestaande platforms vaak deze kernaspecten over het hoofd zagen en niet in staat waren om op te schalen, bundelden onze oprichters hun krachten in 2021 met een visie om een gedecentraliseerd platform te creëren dat het ethos zou weerspiegelen van gebruikerscentrische platforms zoals Robinhood. Deze gedeelde ambitie leidde natuurlijk tot de ontwikkeling van Sei, een open-source, algemeen doel Layer 1 blockchain.</p>
<p>Speciaal ontworpen voor de efficiënte handel en uitwisseling van een breed scala aan digitale activa, streeft Sei ernaar de deugden van decentralisatie te combineren met een gebruikerservaring die gelijk staat aan topklasse Web2-platforms.</p>
<h2 id="h2-Je20beschrijft20Sei20als20geoptimaliseerd20voor20handel20en20de20uitwisseling20van20digitale20activa20waarom20alleen20optimaliseren20voor20dat20gebruik251899"><a name="Je beschrijft Sei als geoptimaliseerd voor handel en de uitwisseling van digitale activa, waarom alleen optimaliseren voor dat gebruik?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Je beschrijft Sei als geoptimaliseerd voor handel en de uitwisseling van digitale activa, waarom alleen optimaliseren voor dat gebruik?</h2><p><strong>Phillip（Marketing&amp;Growth Lead of Sei）</strong><br>De uitwisseling van activa is het meest fundamentele gebruiksscenario van blockchains. Of het nu gaat om tokens, NFT’s of in-game activa, de uitwisselingsfunctie is essentieel voor de gebruikerservaring. Door ons te richten op optimalisatie voor dit gebruiksscenario, hebben we ervoor gezorgd dat Sei een superieure prestatie kan leveren voor deze kernfuncties, wat leidt tot een efficiëntere en naadlozere handelservaring. Je moet beginnen met de gebruikerservaring en terugwerken naar de technologie.</p>
<h2 id="h2-Waar20zie20je20de20handel20de20komende20jaren20naartoe20gaan794705"><a name="Waar zie je de handel de komende jaren naartoe gaan?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Waar zie je de handel de komende jaren naartoe gaan?</h2><p><strong>Phillip（Marketing&amp;Growth Lead of Sei）</strong><br>Met de voortdurende groei van <a href="/web3" target="_blank" class="blog_inner_link">Web3</a> en de toenemende verspreiding van digitale activa, zal de behoefte aan het uitwisselen van deze activa alleen maar blijven groeien. Reguleringsdruk op gecentraliseerde beurzen zal waarschijnlijk de handelsvolumes en activiteiten on-chain verder stimuleren. Terwijl deze trend zich voortzet, streeft Sei ernaar om de evolutie te leiden en een robuuste infrastructuur te bieden die kan voldoen aan de eisen van de volgende generatie on-chain handelsplatforms.</p>
<h2 id="h2-Wat20is20de20visie20voor20Sei20Wat20gebeurt20er20als20je20succesvol20bent738541"><a name="Wat is de visie voor Sei? Wat gebeurt er als je succesvol bent?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wat is de visie voor Sei? Wat gebeurt er als je succesvol bent?</h2><p><strong>Phillip (Marketing &amp; Growth Lead van Sei)</strong><br>Onze visie voor Sei is om het als het standaard Layer 1-platform voor alle on-chain trading te vestigen. Bij succes zal elke handels-app, of het nu een DeFi DEX, een NFT-marktplaats of een gamingplatform is, beter werken op Sei dan op welke andere Layer 1 dan ook, dankzij onze gespecialiseerde optimalisaties. Als Sei succesvol is, bestaat het compromis van gedecentraliseerd zijn niet langer, DEXs en handels-apps kunnen bijna PRECIES zoals Web2-producten werken.</p>
<h2 id="h2-Naast20DeFi20zijn20er20nog20andere20soorten20apps20in20het20Seiecosysteem331213"><a name="Naast DeFi, zijn er nog andere soorten apps in het Sei-ecosysteem?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Naast DeFi, zijn er nog andere soorten apps in het Sei-ecosysteem?</h2><p><strong>Phillip (Marketing &amp; Growth Lead of Sei)</strong><br>Hoewel DeFi een belangrijk onderdeel is van het Sei-ecosysteem, is het niet de enige focus. De infrastructuur van Sei is geoptimaliseerd om uitstekend te presteren voor alle uitwisselingstoepassingen. Dit omvat NFT-marktplaatsen, gaming-economieën, sociale handels-apps en meer. De unieke infrastructuur van Sei maakt het ideaal voor een breed scala aan toepassingen binnen de cryptowereld.</p>
<h2 id="h2-Waarom20heb20je20besloten20om20Sei20als20een20Layer20120te20bouwen20en20niet20als20een20Layer202237548"><a name="Waarom heb je besloten om Sei als een Layer 1 te bouwen en niet als een Layer 2?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Waarom heb je besloten om Sei als een Layer 1 te bouwen en niet als een Layer 2?</h2><p><strong>Phillip（Marketing&amp;Growth Lead of Sei）</strong><br>Het besluit om Sei als een Layer 1-oplossing te bouwen was een strategische beslissing die gebaseerd was op ons streven om op holistische wijze tegemoet te komen aan de gespecialiseerde eisen van handelsapplicaties, waaronder snelheid, doorvoer, betrouwbaarheid en de uitdaging van front-running.</p>
<p>Terwijl Layer 2-oplossingen bovenop bestaande netwerken zijn opgebouwd, stelt een op maat gemaakte Layer 1 blockchain ons in staat om een geoptimaliseerde handelsomgeving nauwgezet samen te stellen vanaf de basis. Deze fundamentele aanpak stelt Sei in staat om rechtstreeks de intrinsieke beperkingen aan te pakken en te verhelpen die veel bestaande infrastructuren hebben beperkt, vooral op het gebied van doorvoer en schaalbaarheid.</p>
<h2 id="h2-Hoe20dacht20u20na20over20ontwerpbeslissingen20en20afwegingen20bij20het20bouwen20van20Gateio424692"><a name="Hoe dacht u na over ontwerpbeslissingen en afwegingen bij het bouwen van Gate.io?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Hoe dacht u na over ontwerpbeslissingen en afwegingen bij het bouwen van Gate.io?</h2><p><strong>Phillip（Marketing&amp;Growth Lead of Sei）</strong><br>Bij het bouwen van Sei hebben we prioriteit gegeven aan het optimaliseren van de gebruikerservaring voor handels-apps, zodat handel snel, efficiënt en veilig kan worden gedaan. Gezien de specifieke eisen van dergelijke toepassingen, worstelden we met het ‘Exchange Trilemma’ en streefden we naar een evenwicht tussen schaalbaarheid, decentralisatie en kapitaalefficiëntie. Centraal in onze ontwerpfilosofie stond de overtuiging dat de uitwisseling van digitale activa een hoeksteen is van het gebruik van blockchain-technologie. Daarom waren onze inspanningen gericht op het bieden van een infrastructuur op maat voor snelle en volumineuze handel.</p>
<h2 id="h2-Hoe20verhoudt20dit20zich20tot20andere20Layer201s20zoals20Solana20Sui20en20Aptos258444"><a name="Hoe verhoudt dit zich tot andere Layer 1’s zoals Solana, Sui en Aptos?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Hoe verhoudt dit zich tot andere Layer 1’s zoals Solana, Sui en Aptos?</h2><p><strong>Phillip（Marketing&amp;Growth Lead of Sei）</strong><br>Sei verschilt in zijn ontwerp en technische aanpak van andere Layer 1’s zoals Solana, Sui, en gate. <a href="/price/aptos-apt" rel="nofollow noopener noreferrer" target="_blank">Aptos</a>. Met de nadruk op de unieke behoeften van handelstoepassingen heeft Sei een toonaangevende tijd tot voltooiing van ongeveer 390 ms bereikt.</p>
<p>Sei maakt gebruik van twee nieuwe ontwikkelingen in consensusonderzoek om Twin-Turbo consensus te bieden, waardoor de verwerkingssnelheid van de ketting aanzienlijk wordt versneld, en de ingebouwde parallelisatie, die transactiekosten optimaliseert en throughput versterkt.</p>
<p>Om de ontwikkelaarservaring te versterken, werkt Sei actief aan het introduceren van ondersteuning voor meerdere talen. Terwijl andere Layer 1-platforms hun eigen kenmerken hebben, positioneren de zorgvuldige ontwerpkeuzes van Sei het als een optimale infrastructuur voor handelstoepassingen.</p>
<h2 id="h2-Voor20onze20luisteraars20wat20is20de20beste20manier20om20betrokken20te20raken20bij20Sei20en20op20de20hoogte20te20blijven779778"><a name="Voor onze luisteraars, wat is de beste manier om betrokken te raken bij Sei en op de hoogte te blijven?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Voor onze luisteraars, wat is de beste manier om betrokken te raken bij Sei en op de hoogte te blijven?</h2><p><strong>Phillip（Marketing&amp;Growth Lead of Sei）</strong><br>Er zijn verschillende manieren om betrokken te raken bij Sei. Als je een ontwikkelaar of een bouwer bent, nodigen we je uit om je aan te sluiten bij de talloze teams die al bezig zijn met het bouwen van het Sei-ecosysteem. Je kunt ook de apps en partners in het Sei-ecosysteem verkennen of je verdiepen in de details van de technologische innovaties van Sei in de officiële whitepaper.</p>
<p>Voor communityleden moedigen we u ten zeerste aan om deel te nemen aan ons Marines International Ambassador Programma, een speciaal samengesteld initiatief dat is ontworpen om groei binnen de Sei-community te bevorderen en te versnellen. Het programma biedt een unieke kans om betrokken te raken, bij te dragen en samen te werken met een diverse gemeenschap, terwijl u ook toegang krijgt tot een schat aan hulpbronnen en mogelijkheden om uw begrip en betrokkenheid bij de wereld van blockchain en digitale activahandel te verbeteren.</p>
<div class="blog-details-info"><br><div>Auteur:<strong> GateLive</strong>, Gate.io Team<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de standpunten van de onderzoeker en vormt geen enkele beleggingsaanbeveling.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Het is toegestaan om het artikel te herpubliceren mits Gate.io als bron wordt vermeld. In alle glen zullen juridische stappen worden ondernomen bij inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div>