Q2hhdEdQVCBBSSBoZWVmdCBpbnZsb2VkIG9wIGRlIGdlem9uZGhlaWRzem9yZywgc3RpamdlbmRlIHByaWp6ZW4gdHJlZmZlbiBBbWVyaWthbmVuLCBDaGluYSdzIGhlcnZlcmRlbGluZ3NiZWxlaWQgaGVlZnQgaW52bG9lZCBvcCB2YXN0Z29lZG9udHdpa2tlbGFhcnM=

2023-01-19, 07:33

<p><img src="https://gimg2.gateimg.com/image/article/1674113338热点.jpg" alt=""></p>
<p>Zoals we eerder hebben gezien, zijn mondiale gebeurtenissen en de cryptowereld vaak met elkaar verweven. Deze week is geen uitzondering, met een aantal belangrijke ontwikkelingen die de cryptogemeenschap beïnvloeden.</p>
<h2 id="h2-Snelle20Blikken577957"><a name="Snelle Blikken" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Snelle Blikken</h2><ol>
<li>SEC v. Winklevoss twins | Crypto</li><li>Hoe ChatGPT de gezondheidszorg beïnvloedt | AI</li><li>Stijgende prijzen raken Amerikanen | Inflatie</li><li>BOJ verdedigt renteplafond, impliceert geen veranderingen onder Kuroda | Transacties</li><li>De impact van de nieuwste Chinese beleidsmaatregelen op de vastgoedontwikkelaars van het land | Vastgoed</li></ol>
<h2 id="h2-Cryptokoningen20in20tumult874765"><a name="Crypto-koningen in tumult" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto-koningen in tumult</h2><p>De Winklevoss-tweeling, Cameron en Tyler, hebben het de laatste tijd niet gemakkelijk. Na een periode van succes met de prijs van <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> en hun eigen roem, hebben ze nu te maken met dalende cryptoprijzen, ontevreden klanten en het gevoel dat ze mogelijk een fout hebben gemaakt. Als reactie hebben ze publiekelijk kritiek geuit op Barry Silbert, een mede-digitale valuta ondernemer en voormalig partner, en de Securities and Exchange Commission (SEC), die onlangs hun bedrijf, Gemini Trust Co., heeft aangeklaagd.</p>
<p>Cameron en Tyler hebben Silbert beschuldigd van hebzucht, roekeloosheid en boekhoudfraude en hebben ook kritiek geuit op de SEC als ‘super suf’ en politiek gemotiveerd. Andere cryptoleiders geven ook anderen de schuld van de huidige stand van de markt, maar de afleidingen van de Winklevoss zijn bijzonder opvallend gezien hun eerdere beweringen van veiligheid en regulering.</p>
<h2 id="h2-ChatGPT20AI20verrast20onderzoekers20door20het20halen20van20het20medisch20examen20waarmee20de20weg20wordt20vrijgemaakt20voor20een20nieuw20tijdperk20in20de20gezondheidszorg104499"><a name="ChatGPT AI verrast onderzoekers door het halen van het medisch examen, waarmee de weg wordt vrijgemaakt voor een nieuw tijdperk in de gezondheidszorg" class="reference-link"></a><span class="header-link octicon octicon-link"></span>ChatGPT AI verrast onderzoekers door het halen van het medisch examen, waarmee de weg wordt vrijgemaakt voor een nieuw tijdperk in de gezondheidszorg</h2><p>ChatGPT, het krachtige generatieve AI-model, heeft zojuist geschiedenis geschreven door alle drie delen van het Amerikaanse Medisch Licentie-examen met succes af te ronden. Deze spannende doorbraak, uitgevoerd door de innovatieve zorg-start-up Ansible Health, is een duidelijke indicatie van het potentieel van ChatGPT om klinische diagnoses en beslissingen in het medische veld te revolutioneren.</p>
<p>Maar voordat je te enthousiast wordt, is het belangrijk om op te merken dat ChatGPT niet is getraind op medische gegevenssets en niet is ontworpen om medisch advies te geven. De vroege resultaten zijn echter veelbelovend en de mogelijkheden zijn eindeloos. Stel je voor dat ChatGPT medische professionals helpt bij het geven van uitleg aan patiënten en zelfs taken van huisartsen overneemt, zoals welzijnscontroles.</p>
<p>Maar maak je geen zorgen, medische professionals zullen niet worden vervangen door AI. Het is nog in een vroeg stadium en het wordt niet verwacht dat AI-modellen binnenkort patiënten autonoom kunnen diagnosticeren.</p>
<h2 id="h2-Stijgende20prijzen20treffen20Amerikanen20Nieuwe20enqute20onthult20alles485929"><a name="Stijgende prijzen treffen Amerikanen: Nieuwe enquête onthult alles" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Stijgende prijzen treffen Amerikanen: Nieuwe enquête onthult alles</h2><p>Een nieuwe enquête van Morning Consult onthult dat de algehele consumentenbestedingen in december een klap kregen, met een verbijsterende daling van 4,3% ten opzichte van de vorige maand. Dat is geen goed nieuws voor economische groei, vooral wanneer een groeiend aantal Amerikanen meer uitgeeft dan ze verdienen. Maar, wanhoop nog niet, shoppers worden creatief en maken compromissen. Zo snijden huishoudens bijvoorbeeld in restaurantuitgaven om de stijgende voedselprijzen thuis te kunnen bekostigen.</p>
<p>Maar het zijn niet alleen de mensen met een lager inkomen die de druk voelen, zelfs de welvarender Amerikanen voelen de knijp. 28% van degenen die minder dan $50.000 verdienen, zei dat de kosten in december hoger waren dan hun inkomen, een grote stijging ten opzichte van 21% vorig jaar. Stijgende prijzen, met name voor voedsel en onderdak, treffen iedereen hard. Dit is slechts één gegevenspunt, maar er wordt verwacht dat er later vandaag meer gegevens over de detailhandelsverkopen aan het einde van 2022 worden vrijgegeven.</p>
<h2 id="h2-De20vastberadenheid20van20de20BOJ20om20de20opbrengstlimiet20te20verdedigen20duidt20op20geen20grote20monetaire20beleidswijzigingen20onder20Kuroda312661"><a name="De vastberadenheid van de BOJ om de opbrengstlimiet te verdedigen, duidt op geen grote monetaire beleidswijzigingen onder Kuroda." class="reference-link"></a><span class="header-link octicon octicon-link"></span>De vastberadenheid van de BOJ om de opbrengstlimiet te verdedigen, duidt op geen grote monetaire beleidswijzigingen onder Kuroda.</h2><p>De Bank of Japan heeft besloten om zijn ultralage rentetarieven en obligatierenteplafond te handhaven, in plaats van zijn massale stimuleringsprogramma af te bouwen zoals de markt verwachtte. Deze stap zorgde ervoor dat de yen tegen andere valuta kelderde en de obligatierendementen het meest in decennia daalden, omdat beleggers hun weddenschappen ongedaan maakten die ze hadden gemaakt in anticipatie op het feit dat de centrale bank haar rentebeleid zou herzien.</p>
<p>Governor Haruhiko Kuroda heeft een nieuw wapen gesmeed om te voorkomen dat de langetermijnrentes te veel stijgen, wat sommige analisten opvatten als een teken dat hij geen grote beleidswijzigingen zal doorvoeren tijdens de resterende maanden van zijn termijn.</p>
<h2 id="h2-Chinas20nieuwe20tijdperk20van20herverdeling20de20impact20op20de20vastgoedontwikkelaars20van20het20land604054"><a name="China’s nieuwe tijdperk van herverdeling: de impact op de vastgoedontwikkelaars van het land" class="reference-link"></a><span class="header-link octicon octicon-link"></span>China’s nieuwe tijdperk van herverdeling: de impact op de vastgoedontwikkelaars van het land</h2><p>Veel van het rijkste en machtigste titanen van het land, zoals Hui Ka Yan, voorzitter van China Evergrande Group, zien hun fortuinen dalen en hun politieke invloed afnemen.</p>
<p>Hui, die ooit de op één na rijkste persoon in Azië was met een nettowaarde van $42 miljard, heeft nu zijn fortuin zien slinken tot slechts $3 miljard. Maar dat is niet alles, hij is ook verwijderd uit de elite Chinese People’s Political Consultative Conference (CPPCC), een exclusieve groep bestaande uit overheidsfunctionarissen en grote zakenmensen.</p>
<p>Hui staat hierin niet alleen, aangezien veel andere vastgoedmagnaten zoals Hui Wing Mau van Shimao Group Holdings Ltd., Zhang Li van Guangzhou R&amp;F Properties Co. en Hoi Kin Hong van Powerlong Real Estate Holdings Ltd. ook geen deel meer uitmaken van de CPPCC.</p>
<p>Deze verandering in houding ten opzichte van vastgoedontwikkelaars is een weerspiegeling van de drive van president Xi Jinping naar ‘gemeenschappelijke welvaart’ om de rijkdom te herverdelen en de schuld in de vastgoedsector te beteugelen, wat gevolgen heeft voor banken, trustbedrijven en huiseigenaren. Als gevolg hiervan hebben de vijf rijkste vastgoedmagnaten van China in de afgelopen twee jaar gezamenlijk $65 miljard verloren.</p>
<p>Het is het vermelden waard dat de rol van de CPPCC lijkt op een erebeloning die wordt toegekend aan zakenmensen die bijdragen leveren aan het land, dus het is helemaal niet verrassend dat vastgoedmagnaten die problemen veroorzaakten in de vastgoedsector met hun overmatige hefboomwerking niet op de lijst staan. Het is zeker een moeilijke tijd voor de vastgoedontwikkelaars van China, maar het zal interessant zijn om te zien hoe deze herschikking op de lange termijn uitpakt.</p>
<p><a href="https://www.gate.io/activities/crypto-news-carnival#/ &quot;![](https://gimg2.gateimg.com/blog/166564757626299037220221013-155242.png" rel="nofollow noopener noreferrer" target="_blank"><img src="https://gimg2.gateimg.com/blog/166564757626299037220221013-155242.png" alt=""></a>”)</p>
<div class="blog-details-info"><br><div>Auteur:<strong> Peter L.</strong>, Gate.io-onderzoeker<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de mening van de onderzoeker en vormt geen beleggingsadvies.<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 schending van het auteursrecht.<br></div><p></p><br></div></div></div>