Z2F0ZUxpdmUgQU1BIFJlY2FwLUJMT0NY

2024-03-29, 09:48

<p><img src="https://gimg2.gateimg.com/image/article/1711705703AMA1-3_Blog.jpg" alt=""></p>
<h2 id="h2-V120Kunt20u20een20overzicht20geven20van20waar20BLOCX20over20gaat20en20wat20de20visie20is245439"><a name="V1: Kunt u een overzicht geven van waar BLOCX. over gaat en wat de visie is?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>V1: Kunt u een overzicht geven van waar BLOCX. over gaat en wat de visie is?</h2><p>Iedereen begrijpt dat virusbescherming essentieel is voor computers, en veel virusbeschermingssoftwarepakketten bevatten functies zoals een wachtwoordkluis, VPN en veilige browser. Maar stel je nu voor dat je het allemaal op één plek hebt: externe toegang, Afterburner, AI, cloudservices en daarbovenop crypto-gerelateerde tools zoals Wallet, Swap en een gedistribueerde computing-marktplaats. Is dat niet alles wat je eigenlijk nodig hebt? Waarom zou je je druk maken met al die verschillende software als je weet dat je het allemaal van één bron kunt krijgen?</p>
<p>Dus je kunt zeggen dat BLOCX in het algemeen gaat over het leveren van alles aan jou op jouw gemak. Alle Web3- en Web2-tools onder één pakket.</p>
<h2 id="h2-Q220Wat20zijn20de20belangrijkste20functies20die20al20zijn20gentroduceerd20in20BLOCX20Desktop20en20wat20volgt20er134179"><a name="Q2: Wat zijn de belangrijkste functies die al zijn geïntroduceerd in BLOCX. Desktop, en wat volgt er?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q2: Wat zijn de belangrijkste functies die al zijn geïntroduceerd in BLOCX. Desktop, en wat volgt er?</h2><p>Onze BLOCX Desktop V1.0 is zojuist uitgebracht als een MVP voor gebruikers om een voorproefje te krijgen van wat er gaat komen. Alle belangrijke en belangrijke functies waren echter al inbegrepen. V1.0 bevatte een Malware-sectie, Apparaatgezondheid, Wachtwoordkluis en Niet-custodial Crypto-portemonnee.</p>
<p>Nu de grootste update in V1.2 die al op deze zondag zal worden uitgebracht, is Remote Access, waardoor mensen gemakkelijk toegang hebben tot hun andere apparaten. Een andere geweldige toevoeging is het AI-gedeelte, waar aanvankelijk een Crypto-gerelateerde ChatBOT zal worden toegevoegd in samenwerking met PAALAI. Dit is echter slechts één onderdeel van het AI-gedeelte, er zullen later meer functies worden toegevoegd, zoals Scam Detectors, Website Scanners en Contract Sniffers.</p>
<p>In het volledige pakket kunt u de Malware-sectie, de sectie Apparaatgezondheid met systeemoptimalisator, automatisch bijgewerkte stuurprogramma’s, afterburner, wachtwoordkluis, externe toegang, cloudservices, niet-bewaard crypto-portemonnee en gedistribueerde computing-marktplaats vinden.</p>
<h2 id="h2-Q320Het20BLOCXplatform20werkt20zonder20gegevensverzameling20en20maakt20rechtstreeks20verbinding20met20de20portefeuilles20van20gebruikers20Waarom20zon20aanpak20en20wat20zijn20precies20de20voordelen979124"><a name="Q3: Het BLOCX-platform werkt zonder gegevensverzameling en maakt rechtstreeks verbinding met de portefeuilles van gebruikers. Waarom zo’n aanpak en wat zijn precies de voordelen?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q3: Het BLOCX-platform werkt zonder gegevensverzameling en maakt rechtstreeks verbinding met de portefeuilles van gebruikers. Waarom zo’n aanpak en wat zijn precies de voordelen?</h2><p>Onze software, apps en oplossingen worden allemaal aangestuurd en verbonden via een portemonnee. In tegenstelling tot sommige software die u verplicht om een account te registreren en uw e-mailadres te verstrekken, is in ons g alleen de registratie van een portemonnee nodig. Dat betekent dat het account van de gebruiker hun portemonnee is en onze portemonnee 100% gedecentraliseerd is, zonder gegevensverzameling, en alles wordt opgeslagen aan de kant van de gebruiker. Dit is hoe ons ecosysteem werkt: alles is verbonden via de portemonnee. Dus als u wachtwoorden op uw apparaat heeft opgeslagen of crypto heeft overgedragen, is dit allemaal gekoppeld aan de portemonnee, die op zijn beurt wordt beschermd door een wachtwoord en pincode. Dus waarom is het voordelig, vraagt u zich af? Gegevens worden alleen gecontroleerd door de gebruiker, geen centrale autoriteit.</p>
<h2 id="h2-Q420Aan20welke20belangrijke20functionaliteiten20werkt20het20team20momenteel20en20wanneer20kunnen20we20verwachten20dat20deze20zaken20worden20vrijgegeven791453"><a name="Q4: Aan welke belangrijke functionaliteiten werkt het team momenteel en wanneer kunnen we verwachten dat deze zaken worden vrijgegeven?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q4: Aan welke belangrijke functionaliteiten werkt het team momenteel en wanneer kunnen we verwachten dat deze zaken worden vrijgegeven?</h2><p>Recente updates omvatten de release van BLOCX Desktop V1.2, met een Malware Sectie met Snelle, Volledige en Aangepaste Scan opties, Apparaat Gezondheid Sectie, Systeemoptimalisator, Wachtwoordkluis, Externe Toegang, een AI Sectie met een Crypto-gerelateerde ChatBOT en een Niet-Custodial Crypto Portemonnee. Dit alles zal worden uitgebracht op de aankomende zondag, 31 maart. Na deze release zal ons Desktop Team beginnen met werken aan een VPN.</p>
<p>Daarnaast werkt ons tweede team aan B.TXT, een gedecentraliseerde messenger aangedreven door masternodes die dienen als servers. De allereerste versie wordt naar verwachting over ongeveer 2 weken uitgebracht.</p>
<p>En ons derde team richt zich op de Distributed Computing Marketplace, of zoals wij het noemen, BLOCX.Marketplace. De geschatte releasedatum voor de MVP is rond 2-2.5 maanden.</p>
<p>Over het algemeen gebeurt er veel en om er meer over te weten te komen, raden we ten zeerste aan om onze sociale media kanalen te volgen en onze routekaart te controleren.</p>
<h2 id="h2-Q520Kun20je20ons20meer20vertellen20over20een20Gedistribueerde20Computing20Marketplace20en20wat20zal20worden20opgenomen20in20de20eerste20MVP809251"><a name="Q5: Kun je ons meer vertellen over een Gedistribueerde Computing Marketplace en wat zal worden opgenomen in de eerste MVP?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q5: Kun je ons meer vertellen over een Gedistribueerde Computing Marketplace en wat zal worden opgenomen in de eerste MVP?</h2><p>Wat zal de MVP bevatten:</p>
<ol>
<li>Een portaal om in te loggen met je BLOCX-portemonnee</li><li>De optie om je rekenkracht te vermelden</li><li>De optie om de rekenkracht van iemand anders te huren</li><li>Betaling in BLOCX</li><li>Aangepaste terminal</li><li>Een terminal installatiegids om je apparaat te vermelden en de rekenkracht van iemand anders te huren</li><li>Tijdregistratiemechanisme (betalen naar gebruik)</li><li>Back-upgegevens (Versleutelde Cloud)</li></ol>
<p>Onze eerste MVP zal regelmatige toegang tot computing power en machine learning omvatten. Met de latere toevoeging van een sjabloon voor rendering, kun je over het algemeen zeggen dat we de meeste aspecten hebben gedekt zodra het klaar is.</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 beleggingssuggestie.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Het opnieuw plaatsen van het artikel zal worden 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>