Z2F0ZUxpdmUgQU1BIFJlY2FwLVNlaQ==

<p><img src="https://gimg2.gateimg.com/image/article/1698283358Blog.jpg" alt=""></p>
<h2 id="h2-Dimmi20di20pi20sul20tuo20background590317"><a name="Dimmi di più sul tuo background" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Dimmi di più sul tuo background</h2><p><strong>Phillip (Marketing &amp; Growth Lead di Sei)</strong><br>Il mio viaggio nel regno <a href="/web3" target="_blank" class="blog_inner_link">Web3</a> è iniziato unendomi a un team fondatore su <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a>, dove ho svolto un ruolo fondamentale come Responsabile Marketing &amp; Crescita. Le mie responsabilità includevano orchestrare lo sviluppo di un’infrastruttura cross-chain su misura sia per le catene compatibili con EVM &amp; Non-EVM.</p>
<p>Basandomi su quella esperienza, successivamente mi sono unito a Trader Joe, concentrandomi sul supporto della loro strategia di lancio sul mercato per gli sforzi di espansione multichain del DEX, implementandolo su Arbitrum e <a href="/price/bnb-bnb" rel="nofollow noopener noreferrer" target="_blank">BNB</a> catena da un punto di vista di marketing. Nel mio attuale ruolo presso Sei Labs, indosso il cappello di Marketing and Growth Lead, canalizzando la mia esperienza per amplificare la crescita dell’ecosistema ed evolvere la nostra presenza di mercato.</p>
<h2 id="h2-Cosa2020Sei544844"><a name="Cosa è Sei?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Cosa è Sei?</h2><p><strong>Phillip (Marketing &amp; Growth Lead di Sei)</strong><br>Sei è una blockchain Layer 1 open-source e senza autorizzazioni, progettata specificamente in risposta al caso d’uso fondamentale delle blockchain, ovvero la capacità di scambiare asset digitali. Con il continuo aumento degli asset digitali - dagli NFT e dagli asset di gioco al DeFi - aumenta anche la domanda di blockchain ad alte prestazioni. Rispondendo a questa richiesta, Sei è progettata per essere la destinazione ideale per applicazioni ad alta performance e con la migliore esperienza utente in Web3.</p>
<p>Con questo in mente, Sei è stato costruito con un’enfasi sulla velocità, le prestazioni e l’innovazione tecnologica. Vanta uno dei tempi di finalità più veloci di qualsiasi blockchain, potenzialmente una maggiore capacità rispetto al massimo teorico di qualsiasi Rollup costruito su gate. <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a>, e bassa latenza, tutto grazie al suo utilizzo di tecnologie all’avanguardia. Queste includono l’elaborazione parallela, la finalità istantanea dei blocchi e i meccanismi innovativi per una propagazione e un’elaborazione efficienti dei blocchi.</p>
<h2 id="h2-Storia20di20come20Sei20ha20iniziato808701"><a name="Storia di come Sei ha iniziato?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Storia di come Sei ha iniziato?</h2><p><strong>Phillip (Responsabile Marketing e Crescita di Sei)</strong><br>L’inizio di Sei può essere fatto risalire alle intuizioni acquisite dalle esperienze diverse del nostro team nelle industrie tecnologiche e finanziarie. Un momento cruciale è avvenuto quando i nostri co-fondatori, Jay, hanno lavorato come ingegnere iniziale presso Robinhood. Lì, ha discernato significativi sfide legate alla mancanza di trasparenza negli scambi centralizzati. Tali rivelazioni hanno sottolineato l’importanza primordiale della decentralizzazione e evidenziato il ruolo cruciale del trading e dello scambio di asset digitali nel mondo della blockchain.</p>
<p>Riconoscendo che molti delle piattaforme esistenti spesso trascurano questi aspetti fondamentali e mancano della capacità di scalare, i nostri fondatori si sono uniti nel 2021 con la visione di creare una piattaforma decentralizzata che riflettesse l’etica delle piattaforme incentrate sull’utente come Robinhood. Questa ambizione condivisa è naturalmente passata allo sviluppo di Sei, una blockchain open-source di Layer 1 a uso generale.</p>
<p>Progettato specificamente per il trading e lo scambio efficiente di una vasta gamma di asset digitali, Sei si impegna a combinare le virtù della decentralizzazione con un’esperienza utente all’altezza delle piattaforme Web2 di alto livello.</p>
<h2 id="h2-Descrivi20Sei20come20ottimizzato20per20il20trading20e20lo20scambio20di20asset20digitali20perch20ottimizzare20solo20per20quel20caso20duso249812"><a name="Descrivi Sei come ottimizzato per il trading e lo scambio di asset digitali, perché ottimizzare solo per quel caso d’uso?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Descrivi Sei come ottimizzato per il trading e lo scambio di asset digitali, perché ottimizzare solo per quel caso d’uso?</h2><p><strong>Phillip (Marketing&amp;Growth Lead di Sei)</strong><br>Lo scambio di asset è il caso d’uso più fondamentale delle blockchain. Che si tratti di token, NFT o asset in-game, la funzione di scambio è vitale per l’esperienza dell’utente. Concentrandoci sull’ottimizzazione di questo caso d’uso, ci siamo assicurati che Sei possa offrire una prestazione superiore per queste funzioni principali, garantendo un’esperienza di trading più efficiente e senza interruzioni. Bisogna partire dall’esperienza dell’utente e lavorare all’indietro verso la tecnologia.</p>
<h2 id="h2-Dove20vedi20il20trading20dirigersi20nei20prossimi20anni516876"><a name="Dove vedi il trading dirigersi nei prossimi anni?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Dove vedi il trading dirigersi nei prossimi anni?</h2><p><strong>Phillip (Responsabile Marketing e Sviluppo di Sei)</strong><br>Con la crescita continua del Web3 e la crescente diffusione degli asset digitali, la necessità di scambiare questi asset continuerà a crescere. La pressione regolamentare sugli scambi centralizzati è probabile che aumenti ulteriormente il volume e l’attività on-chain. Con il continuare di questo trend, Sei punta a guidare l’evoluzione, fornendo un’infrastruttura robusta in grado di soddisfare le esigenze della prossima generazione di piattaforme di trading on-chain.</p>
<h2 id="h2-Qual2020la20visione20per20Sei20Cosa20succede20se20avete20successo189443"><a name="Qual è la visione per Sei? Cosa succede se avete successo?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Qual è la visione per Sei? Cosa succede se avete successo?</h2><p><strong>Phillip (Marketing &amp; Growth Lead di Sei)</strong><br>La nostra visione per Sei è quella di stabilirlo come la piattaforma Layer 1 predefinita per tutti i trading on-chain. In caso di successo, qualsiasi app di trading, che sia un DEX DeFi, un marketplace NFT o una piattaforma di gioco, funzionerà meglio su Sei rispetto a qualsiasi altro Layer 1, grazie alle nostre ottimizzazioni specializzate. Se Sei avrà successo, il compromesso di essere decentralizzato non esisterà più, i DEX e le app di trading potranno operare quasi ESATTAMENTE come i prodotti Web2.</p>
<h2 id="h2-Oltre20a20DeFi20ci20sono20altri20tipi20di20app20nellecosistema20Sei748460"><a name="Oltre a DeFi, ci sono altri tipi di app nell’ecosistema Sei?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Oltre a DeFi, ci sono altri tipi di app nell’ecosistema Sei?</h2><p><strong>Phillip（Marketing&amp;Growth Lead of Sei）</strong><br>Mentre DeFi è una parte fondamentale dell’ecosistema Sei, non è l’unico focus. L’infrastruttura di Sei è ottimizzata per avere un’eccellente performance per tutte le applicazioni di scambio. Questo include i mercati NFT, le economie dei giochi, le app di social trading e altro ancora. L’infrastruttura unica di Sei lo rende ideale per una vasta gamma di applicazioni nel mondo delle criptovalute.</p>
<h2 id="h2-Perch20hai20deciso20di20costruire20Sei20come20Layer20120e20non20come20Layer202513973"><a name="Perché hai deciso di costruire Sei come Layer 1 e non come Layer 2?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Perché hai deciso di costruire Sei come Layer 1 e non come Layer 2?</h2><p><strong>Phillip（Marketing&amp;Growth Lead of Sei）</strong><br>La scelta di costruire Sei come soluzione Layer 1 è stata una decisione strategica ancorata al nostro obiettivo di affrontare in modo olistico le esigenze specializzate delle applicazioni di trading, che comprendono velocità, throughput, affidabilità e la sfida del frontrunning.</p>
<p>Mentre le soluzioni di Layer 2 sono stratificate su reti preesistenti, una blockchain di Layer 1 su misura ci consente di curare meticolosamente un ambiente di trading ottimizzato fin dalle sue fondamenta. Questo approccio fondamentale consente a Sei di affrontare direttamente e correggere le limitazioni intrinseche che hanno vincolato molte infrastrutture esistenti, soprattutto in termini di throughput e scalabilità.</p>
<h2 id="h2-Come20hai20pensato20alle20decisioni20di20design20e20ai20compromessi20mentre20stavi20costruendo20Sei206063"><a name="Come hai pensato alle decisioni di design e ai compromessi mentre stavi costruendo Sei?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Come hai pensato alle decisioni di design e ai compromessi mentre stavi costruendo Sei?</h2><p><strong>Phillip (Marketing &amp; Growth Lead di Sei)</strong><br>Nel costruire Sei, abbiamo dato la priorità all’ottimizzazione dell’esperienza utente per le app di trading, garantendo che il trading potesse essere fatto in modo rapido, efficiente e sicuro. Date le esigenze particolari di tali applicazioni, abbiamo affrontato il “trilemma dell’Exchange”, cercando di trovare un equilibrio tra scalabilità, decentralizzazione ed efficienza del capitale. Al centro della nostra filosofia di design c’era la convinzione che lo scambio di asset digitali sia un caso d’uso fondamentale per la tecnologia blockchain. Pertanto, i nostri sforzi sono stati indirizzati verso la creazione di un’infrastruttura su misura per il trading ad alta velocità e ad alta volumetria.</p>
<h2 id="h2-Come20si20confronta20questo20con20altri20Layer20120come20Solana20Sui20e20Aptos882585"><a name="Come si confronta questo con altri Layer 1 come Solana, Sui e Aptos?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Come si confronta questo con altri Layer 1 come Solana, Sui e Aptos?</h2><p><strong>Phillip (Marketing &amp; Growth Lead di Sei)</strong><br>Nel design e nell’approccio tecnico, Sei si differenzia dalle altre Layer 1 come Solana, Sui e gate. <a href="/price/aptos-apt" rel="nofollow noopener noreferrer" target="_blank">Aptos</a>. Concentrandosi sulle esigenze uniche delle applicazioni di trading, Sei ha raggiunto un tempo di finalità leader del settore di circa 390 ms.</p>
<p>In particolare, Sei sfrutta due nuovi sviluppi nella ricerca sul consenso per offrire il consenso Twin-Turbo, che accelera significativamente la velocità di elaborazione della catena, e la parallelizzazione integrata, che ottimizza i costi delle transazioni e amplifica la throughput.</p>
<p>Per amplificare l’esperienza dello sviluppatore, Sei sta lavorando attivamente per introdurre il supporto multi-lingua. Mentre altre piattaforme di Livello 1 possiedono le proprie caratteristiche, le scelte di design meticolose di Sei lo posizionano come un’infrastruttura ottimale per le applicazioni di trading.</p>
<h2 id="h2-Per20i20nostri20ascoltatori20qual2020il20modo20migliore20per20entrare20in20contatto20con20Sei20e20restare20aggiornati280266"><a name="Per i nostri ascoltatori, qual è il modo migliore per entrare in contatto con Sei e restare aggiornati?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Per i nostri ascoltatori, qual è il modo migliore per entrare in contatto con Sei e restare aggiornati?</h2><p><strong>Phillip (Marketing&amp;Growth Lead di Sei)</strong><br>Ci sono diversi modi per essere coinvolti con Sei. Se sei un programmatore o un costruttore, ti invitiamo a unirti alle numerose squadre che stanno già costruendo sull’ecosistema Sei. Puoi anche esplorare le app e i partner nell’Ecosistema Sei o approfondire i dettagli delle innovazioni tecnologiche di Sei nel whitepaper ufficiale.</p>
<p>Per i membri della comunità, incoraggiamo vivamente a partecipare al nostro Programma Ambasciatori Internazionali Marino, un’iniziativa appositamente curata per favorire e accelerare la crescita all’interno della comunità Sei. Il programma offre un’opportunità unica di coinvolgimento, contributo e collaborazione con una comunità diversificata, consentendo anche di accedere a una ricchezza di risorse e opportunità per migliorare la comprensione e l’interesse nel mondo della blockchain e del trading di asset digitali.</p>
<div class="blog-details-info"><br><div>Autore: <strong> GateLive </strong>, Team 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. La ripubblicazione dell'articolo sarà consentita 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>