Qml0Y29pbiBXaGl0ZXBhcGVyIGluIEV2ZXJ5IEFwcGxlIENvbXB1dGVy

2023-04-27, 08:21

<p><img src="https://gimg2.gateimg.com/blog/1679447253155655279redian.jpeg" alt=""></p>
<h2 id="h2-TL20DR332916"><a name="[TL; DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL; DR]</h2><p>Elke MacOs-computer die sinds 2008 is verzonden, bevat een verborgen whitepaper van Nakamoto.</p>
<p>De <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Het manifest document had als voorbeeld van een PDF voor testdoeleinden opgenomen kunnen zijn in de Apple-computer.</p>
<p>Je kunt het BTC-witboek openen met behulp van de Finder op de MacOs.</p>
<h2 id="h2-Introductie347490"><a name="Introductie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introductie</h2><p>De aanwezigheid van de <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Het witboek op elke Apple-computer heeft veel mensen in verwarring gebracht en daar zijn verschillende redenen voor. Daarom kunnen alle eigenaren van Apple-computers het witboek op hun eigen pc’s raadplegen. In dit artikel zullen we de mogelijke redenen bespreken waarom dit zo is. <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> whitepaper staat op elke Apple-computer en hoe je er toegang toe kunt krijgen.</p>
<h2 id="h2-Apple20computers20hebben202020Bitcoin2020whitepaper20geschreven20door20Satoshi20Nakamoto530085"><a name="Apple computers hebben   Bitcoin  whitepaper geschreven door Satoshi Nakamoto" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Apple computers hebben <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> whitepaper geschreven door Satoshi Nakamoto</h2><p>De wereld is verrast door het feit dat elke kopie van macOS die sinds 2018 is geleverd, de <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> whitepaper, getiteld “ <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a>: Een Peer-to-Peer elektronisch geldsysteem, geschreven <a href="https://www.gate.io/learn/articles/who-is-satoshi-nakamoto/286" target="_blank">door Satoshi Nakamoto</a> Andy Baio, een ontwikkelaar en schrijver van waxy.org, stuitte per ongeluk op het whitepaper toen hij een probleem wilde oplossen met zijn computer.</p>
<p>Baio bevestigde die informatie op zijn blog waar hij schreef: “Terwijl ik vandaag probeerde mijn printer te repareren, ontdekte ik dat een PDF-kopie van Satoshi Nakamoto’s BTC whitepaper blijkbaar is meegeleverd met elke kopie van macOS sinds Mojave in 2018. Ik heb meer dan een dozijn Mac-gebruikende vrienden gevraagd om dit te bevestigen en het was er voor iedereen.”</p>
<p><img src="https://gimg2.gateimg.com/image/article/16825834681521682583245_.pic.jpg" alt=""><a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> whitepaper op Mac - Mcrumours</p>
<p>De afbeelding hierboven toont een <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> whitepaper op Mac, die voor iedereen toegankelijk is. Volgens de beschikbare informatie kan iedereen met een Mac met macOS Mojave of een latere versie toegang krijgen tot die whitepaper op zijn/haar computer. Iedereen met macOS 10.14 of later moet het document openen in Voorvertoning.</p>
<p>Echter was Baio niet de eerste persoon om de te ontdekken <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> whitepaper in de Apple-computer. Er waren al vragen in een Apple-community in 2021, waarin werd gevraagd naar de aanwezigheid van het document in macOS.</p>
<p>Ook ontdekte Joshua Dickens, een Twitter-gebruiker en voormalig ontwerper van Apple-producten, de <a href="https://www.gate.io/learn/articles/who-is-satoshi-nakamoto/286" target="_blank">Bitcoin whitepaper</a> op MacOS in 2020. Hoewel hij erover getweet heeft, namen veel Twitter-gebruikers het probleem niet serieus.</p>
<p>Tegelijkertijd ontdekte Dickens ook een foto gemaakt door Thomas Hawk genaamd Warning Alarm . Hawk nam de foto in 2008 op Treasure Island in San Francisco.</p>
<p><img src="https://gimg2.gateimg.com/image/article/16825835111531682583261_.pic_hd.jpg" alt=""><br>Waarschuwingssysteem - Waxy</p>
<h2 id="h2-Waarom20heeft20Apple20de202020Bitcoin2020whitepaper20op20de20computer930339"><a name="Waarom heeft Apple de   Bitcoin  whitepaper op de computer?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Waarom heeft Apple de <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> whitepaper op de computer?</h2><p>Er zijn verschillende mogelijke redenen waarom Apple de <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> whitepaper in haar computers. Bijvoorbeeld, Apple heeft het mogelijk als een voorbeeld in de computer gebruikt. In dit verband zei Baio dat de <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Het whitepaper zou gebruikt kunnen zijn als een voorbeelddocument voor de Virtuele Scanner in het macOS Image Capture hulpprogramma.</p>
<p>Lees ook: <a href="https://www.gate.io/learn/articles/what-is-a-crypto-whitepaper-and-how-to-analyze-it/421" target="_blank">Wat is een Crypto Whitepaper en hoe het te analyseren?</a></p>
<p>Andere mensen geloven dat de <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Het whitepaper werd als een paasei in de computer opgenomen. Dit komt omdat Apple een geschiedenis heeft van het toevoegen van paaseieren zoals ‘Star Wars’ en ‘Lord of the Rings’ in zijn producten. Bijvoorbeeld in zijn Macintosh-besturingssysteem voegde het speelbare versies van Pong, Snake en Tetris toe.</p>
<p>De whitepaper had als grap in de computer kunnen worden opgenomen door een “ <a href="/price/secret-scrt" rel="nofollow noopener noreferrer" target="_blank">Geheim</a> <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> maxi”, die mogelijk bij Apple heeft gewerkt. Als alternatief kan het zijn opgenomen als een meerbladige PDF om de computer te testen.</p>
<p>Baio schreef op zijn blog: “De bestandsnaam is “simpledoc.pdf” en het is slechts 184 KB. Misschien was het gewoon een handig, lichtgewicht meerbladig PDF-bestand voor testdoeleinden, nooit bedoeld om door eindgebruikers te worden gezien.”</p>
<p>Apple had ook kunnen opnemen <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> whitepaper op zijn computer omdat het de oudste crypto is <a href="https://www.gate.io/bitwiki/detail/61/white-paper" target="_blank">witboek in bestaan</a>.</p>
<p>De opname van het whitepaper in de Apple-computer is verrassend gezien het feit dat voormalig directeur van de App Store, Philip Shoemaker, openlijk zijn wantrouwen heeft geuit voor <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> die hij een Ponzi-regeling noemde.</p>
<p>Apple toonde ook zijn harde standpunt tegenover cryptocurrencies toen het een App Store-vergoeding van 30% introduceerde voor crypto-apps waar ontwikkelaars tegen protesteerden. Onlangs toonde Tim Cook, CEO van Apple, echter een meegaand standpunt ten opzichte van cryptocurrencies. Hij gaf zelfs aan dat hij enkele cryptocurrencies bezit.</p>
<h2 id="h2-Hoe20toegang20te20krijgen20tot202020Bitcoin2020whitepaper20op20Apple20computer204353"><a name="Hoe toegang te krijgen tot   Bitcoin  whitepaper op Apple computer" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Hoe toegang te krijgen tot <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> whitepaper op Apple computer</h2><p>MacOS heeft een <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> whitepaper waar u toegang toe kunt krijgen. Ten eerste kunt u het document vinden via Finder. Zo doe je dat: Navigeer naar Macintosh HD -&gt; Systeem -&gt; Bibliotheek -&gt; Afbeelding vastleggen -&gt; Apparaten, open vervolgens de Inhoud -&gt; Hulpmiddelenmap. De titel van de whitepaper op de computer is simpledoc.pdf.”</p>
<p>Als alternatief moeten Mac-gebruikers mogelijk de volgende opdracht typen in de terminal:</p>
<p>open//Bibliotheek/ImageCapture/Apparaten/VirtualScanner.app/Inhoud/Resources/simpledoc.pdf</p>
<h2 id="h2-Conclusie652961"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h2><p>Elke macOS die sinds 2018 is verzonden, heeft een <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> whitepaper. De exacte reden voor het opnemen van de whitepaper is niet bekend, hoewel sommige mensen speculeren dat het is opgenomen als een voorbeeld PDF-document of dat het is toegevoegd als een Paasei. Er zijn verschillende manieren waarop u er toegang toe kunt krijgen op uw computer, afhankelijk van de versie.</p>
<h3 id="h3-Waarom20is202020Bitcoin2020whitepaper20op20Mac974705"><a name="Waarom is   Bitcoin  whitepaper op Mac?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Waarom is <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> whitepaper op Mac?</h3><p>Apple had de <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> whitepaper op Mac als een voorbeeld PDF-document of als een Paasei. Het had het kunnen bevatten aangezien het de eerste cryptocurrency whitepaper was die werd gemaakt.</p>
<h3 id="h3-Hoe20kan20ik20toegang20krijgen20tot20de20whitepaper20op20Mac441855"><a name="Hoe kan ik toegang krijgen tot de whitepaper op Mac?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Hoe kan ik toegang krijgen tot de whitepaper op Mac?</h3><p>Je kunt de toegang krijgen <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> whitepaper op Mac gebruiken op twee manieren. U kunt het document vinden via Finder. Hier is hoe u het doet: Navigeer naar Macintosh HD -&gt; Systeem -&gt; Bibliotheek -&gt; Afbeelding vastleggen -&gt; Apparaten, open vervolgens de map Inhoud -&gt; Bronnen. Als alternatief moeten Mac-gebruikers mogelijk het commando typen in de terminal: open /  / Library / ImageCapture / Devices / VirtualScanner.app / Contents / Resources / simpledoc.pdf</p>
<h3 id="h3-Wie20is20de20eigenaar20van20de202020Bitcoin2020whitepaper252367"><a name="Wie is de eigenaar van de   Bitcoin  whitepaper?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wie is de eigenaar van de <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> whitepaper?</h3><p>De pseudonieme persoon genaamd Satoshi Nakamoto is eigenaar van de <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> whitepaper, gelanceerd in oktober 2008. Het is echter niet duidelijk of Satoshi Nakamoto een individu is of een groep mensen die het whitepaper hebben gemaakt en <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a>.</p>
<h3 id="h3-Waarom20is20de202020Bitcoin2020Waarom20is20het20whitepaper20belangrijk260406"><a name="Waarom is de   Bitcoin  Waarom is het whitepaper belangrijk?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Waarom is de <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Waarom is het whitepaper belangrijk?</h3><p>De <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Het whitepaper, geschreven door Satoshi Nakamoto, is erg belangrijk omdat het de oorspronkelijke gedachte achter cryptocurrencies bevat. Het beschrijft de tekortkomingen van het legacy Electronic geld en hoe <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> kan ze overwinnen.</p>
<div class="blog-details-info"><br><div>Auteur: Mashell C., onderzoeker bij Gate.io<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de opvattingen 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 opnieuw te plaatsen op voorwaarde dat Gate.io wordt vermeld. In alle glen zal juridische actie worden ondernomen wegens schending van het auteursrecht.<br></div><p></p><br></div></div></div>