Trump har fel om
kinesiska studenter, men...

<div class="kv-article-audio-player">  <div class="kv-aap-listen">    <div class="kv-listen-left">      <span>        <i class="fas fa-headphones-alt"></i>      </span>    </div>    <div class="kv-aap-listen-right">Lyssna på texten    </div>  </div><div id    = "kv-pod-holder-181002"      class = "kv-pod-holder kv-player-light  lplo " data-sid="" data-eid="" data-tis="983" data-tin="1168" data-pid="181002" data-pty="SW5sw6RzdCBhcnRpa2VsIChLcsO2bmlrYSk=" data-pna="VHJ1bXAgaGFyIGZlbCBvbTxicj5raW5lc2lza2Egc3R1ZGVudGVyLCBtZW4uLi4=" data-acurl="aHR0cHM6Ly9tZWRpYS5wb2Quc3BhY2UvaW5sYXN0YXRleHRlci84LTM4LXRydW1wLWhhci1mZWwtb20ta2luZXNpc2thLXN0dWRlbnRlci1tZW4ubXAz" data-psurl="aHR0cHM6Ly9tZWRpYS5wb2Quc3BhY2Uva2p4ajYzeWRkZXEydmgvOC0zOC10cnVtcC1oYXItZmVsLW9tLWtpbmVzaXNrYS1zdHVkZW50ZXItbWVuLm1wMw==">  <div class="kv-pod-holder-inner">    Laddar <span class="blink-me">...</span>  </div></div>  <div class="kv-listen-subscribe">    <span>Följ Kvartals poddar:</span>    <a target="_blank" href="https://podcasts.apple.com/se/podcast/kvartal/id1447122576?mt=2">Apple</a>    |     <a target="_blank" href="https://open.spotify.com/show/6NsieE1iFLypikr3slKII0?si=ppaUJpA3R-mo8L9L4XgudA">Spotify</a>  </div></div><div class="kvartal-meta clearfix" style="color: ">Av <a href="https://kvartal.se/medverkande/magnus-fiskesjo/">Magnus&nbsp;Fiskesjö</a> | 15 juni 2025<div style="float: right;" class="social-top-wrapper closed no-comments"><div class="share-icons"><span class="share-outer"><a href="https://www.facebook.com/sharer.php?u=https%3A%2F%2Fkvartal.se%2Fartiklar%2Ftrump-har-fel-om-kinesiska-studenter-men%2F&amp;t=Trump+har+fel+om%3Cbr%3Ekinesiska+studenter%2C+men..."    target="_blank"    class="fb-link"    title="Dela på facebook"><i class="fa fa-facebook ui transparent"></i></a><a href   = "https://twitter.com/intent/tweet?text=Trump+har+fel+om%3Cbr%3Ekinesiska+studenter%2C+men...+-+https%3A%2F%2Fkvartal.se%2Fartiklar%2Ftrump-har-fel-om-kinesiska-studenter-men%2F"    target = "_blank"    class  = "tw-link"    title  = "Dela på X.com"><i class="exticon exticon-x-icon"></i></a></span><span class="share-inner"><a href   = "http://www.linkedin.com/shareArticle?mini=true&url=https%3A%2F%2Fkvartal.se%2Fartiklar%2Ftrump-har-fel-om-kinesiska-studenter-men%2F"    target = "_blank"    class  = "li-link"    title  = "Dela på LinkedIn"><i class="ti-linkedin ui transparent"></i></a><a href    = "mailto:?subject=Trump har fel om<br>kinesiska studenter, men...&body=https://kvartal.se/artiklar/trump-har-fel-om-kinesiska-studenter-men/"   target  = "_blank"    class   = "pr-link"    title   = "E-posta"    onclick = ""><i class="ti-email ui transparent"></i></a><a href    = "https://kvartal.se/skriv-ut/181002/utskrift"    target  = "_blank"    class   = "pr-link"    title   = "Skriv ut"    onclick = ""><i class="ti-printer ui transparent"></i></a></span><a href="#share" class="share-expand "    title="Visa fler delningsalternativ"><i class="fas fa-share-square ui transparent"></i></a></div></div></div><div class="kv-art-ext-sep"></div><div class="mobile-share clearfix" style="margin-top: -10px; margin-bottom: 20px;"><div class="share-icons"><span class="share-outer"><a href="https://www.facebook.com/sharer.php?u=https%3A%2F%2Fkvartal.se%2Fartiklar%2Ftrump-har-fel-om-kinesiska-studenter-men%2F&amp;t=Trump+har+fel+om%3Cbr%3Ekinesiska+studenter%2C+men..."    target="_blank"    class="fb-link"    title="Dela på facebook"><i class="fa fa-facebook ui transparent"></i></a><a href   = "https://twitter.com/intent/tweet?text=Trump+har+fel+om%3Cbr%3Ekinesiska+studenter%2C+men...+-+https%3A%2F%2Fkvartal.se%2Fartiklar%2Ftrump-har-fel-om-kinesiska-studenter-men%2F"    target = "_blank"    class  = "tw-link"    title  = "Dela på X.com"><i class="exticon exticon-x-icon"></i></a></span><span class="share-inner"><a href   = "http://www.linkedin.com/shareArticle?mini=true&url=https%3A%2F%2Fkvartal.se%2Fartiklar%2Ftrump-har-fel-om-kinesiska-studenter-men%2F"    target = "_blank"    class  = "li-link"    title  = "Dela på LinkedIn"><i class="ti-linkedin ui transparent"></i></a><a href    = "mailto:?subject=Trump har fel om<br>kinesiska studenter, men...&body=https://kvartal.se/artiklar/trump-har-fel-om-kinesiska-studenter-men/"   target  = "_blank"    class   = "pr-link"    title   = "E-posta"    onclick = ""><i class="ti-email ui transparent"></i></a><a href    = "https://kvartal.se/skriv-ut/181002/utskrift"    target  = "_blank"    class   = "pr-link"    title   = "Skriv ut"    onclick = ""><i class="ti-printer ui transparent"></i></a></span><a href="#share" class="share-expand "    title="Visa fler delningsalternativ"><i class="fas fa-share-square ui transparent"></i></a></div></div><div class="article-actions"><a href="/profile" class="kv-aa-profile"><svg aria-hidden="true">  <use href="#tf-ti-user"></use></svg><span>Profil</span></a><a class="listen" href="https://kvartal.se/artiklar/trump-har-fel-om-kinesiska-studenter-men/?inlast=1">  <i class="fas fa-headphones-alt"></i>  <span>Inlästa texter</span></a><a href="#nyhetsbrevet" onclick="newsletter()" class="newsletter"><i class="fas fa-paper-plane"></i><span>Nyhetsbrev</span></a><a class="reading-time" title="Ungefärlig lästid"><i class="far fa-clock ui"></i><span>Lästid 12 min</span></a><a href   = "https://kvartal.se/skarmlasarvanlig/46d031a3-497f-4d8c-a372-fd29e6fd7f59"    target = "_blank"    class  = "screen-reader-friendly"    title. = "Version som fungerar bättre med skärmläsarprogramvara">  <i class="fas fa-volume-up"></i>  <span>Skärmläsarvänlig</span></a></div><div class="in-short-wrapper closed" id="in-short-181002">  <div class="in-short-inner">    <span class="close_button close-in-short in-short-toggle" data-articleid = "181002"></span>    <i class="themify-icon-icon fas fa-align-left"></i>    <span class="in-short-heading">I korthet</span>    <hr class="in-short-divider" />    <div class="in-short-text">    </div>  </div></div><div class="article-beginning ">I slutet av maj utfärdade Donald Trumps utrikesministerium ett dramatiskt påbud, om att man nu ”aggressivt” ska dra in visum som redan getts till kineser med anknytning till det kinesiska Kommunistpartiet (det vill säga, det kinesiska samhällets aristokrati) eller som forskar på ”kritiska fält”. Man har också instruerat alla sina ambassader att pausa alla visumintervjuer, så att man först ska kunna kamma igenom vad de sökande skrivit på sociala media.<sup>1</sup></p>
</div>
<div class="rest-of-article ">
<p>Sedan har Trump, som en del av sina handelsförhandlingar med Kina, dragit tillbaka vad som verkade vara ett hot om att helt enkelt kasta ut alla kinesiska studenter från USA. Samtidigt fortsätter han prata om en strikt kontroll.</p>
<p>Som vanligt med Trump är hoten otydliga, men samtidigt både allvarliga och trovärdiga — ungefär som med hans inlindade hot mot Grönland och Kanada.</p>
<p>Mycket pekar på att all den nya osäkerheten kring utländska studenters status, särskilt i ljuset av de många utvisningar som gjorts även av besökare med giltiga visum och uppehållstillstånd, gör att många studenter från Kina, Indien och så vidare helt enkelt inte kommer att våga resa till USA.</p>
<p>En bidragande orsak till att Trump (tillfälligt?) backade är sannolikt att han inser att amerikanska universitet blivit djupt beroende av kinesiska studenter, som betalar dryga kursavgifter och därmed bidrar till USA:s ekonomi, handelsbalans, och inte minst landets renommé som ett globalt centrum för vetenskap och forskning – främst då genom det stora antalet kinesiska doktorander och forskare inom teknik och naturvetenskap. Det finns till och med enstaka laboratorier på amerikanska universitet där man talar kinesiska i stället för engelska, eftersom alla är kineser.</p>
<h2>Utrensning av kineser från universiteten?</h2>
<p>Trumpregeringen har inte heller förklarat hur kinesiska studenters anknytning till Kommunistpartiet ska bedömas. Kina är ju en enpartistat, där Kommunistpartiet har tentakler överallt. Räcker det då om en pappa är politruk? Och vilka forskningsfält rör det sig om? En inte vågad gissning är att det handlar särskilt om de många områden inom teknik, och särskilt militärteknik, där Kina redan utmanar USA.</p>
<p>Anklagelserna om att en del kineser är spioner, som stjäl från USA, är centrala i sammanhanget – och de stämmer faktiskt. En del är till och med låtsasstudenter, på specialuppdrag från den kinesiska militären. Något som pågått länge, på global front, och som vi också sett i Sverige.<sup>2</sup> Men samtidigt är många av de kinesiska studenterna duktiga unga människor som reser utomlands för att de vill ha mer frihet än hemma i Kina. Hur blir då några av dem spioner i Kommunistpartiets tjänst?</p>
<blockquote><p>En kinesisk student blev uppringd av sina föräldrar som satt hemma i lägenheten i Kina – med polisen bredvid.</p></blockquote>
<p>Till att börja med upptäcker många av dem snart nog att de övervakas också på sina nya campus, i utlandet – av samma gamla kinesiska myndigheter som på hemmaplan!</p>
<p>Det sker via personal på de kinesiska konsulaten utomlands, som ser till att de inordnas i hårt kontrollerade ”studentklubbar” på sina universitet i utlandet. På många lärosäten finns dessutom particeller, ofta med postdoktorer eller lärare av kinesiskt ursprung som medlemmar. Dessa particeller är dock hemliga.</p>
<p>På mitt universitet, Cornell University utanför New York, var det för ett tag sedan en kinesisk student som tröttnade på den officiella, och från konsulatet styrda, ”patriotiska” klubben för kinesiska studenter. Han berättade för en kompis att han ville inrätta en ny kinesisk studentklubb som enbart skulle vara social, vilket är högst rimligt eftersom studenter får ha vilka klubbar de vill på universitetet.</p>
<p>Men dagen efter ringde det på hans privata mobil. Det var från konsulatet: ”Vi hör att du planerar att ha en separat kinesisk studentklubb på Cornell. Låt bli det.” Och så blev det inget av.</p>
<p>I enstaka fall har dock modiga kinesiska studenter vågat protestera och demonstrera, och sedan dessutom vägrat hålla tyst även när de blir tillsagda av kinesiska statens ”övervakare”.</p>
<p>Ett dramatiskt sådant fall var vid Purdue University i delstaten Indiana, där en kinesisk student blev uppringd av sina föräldrar som satt hemma i lägenheten i Kina – med polisen bredvid. De berättade att polisen ville att deras son omedelbart skulle sluta upp med att hålla möten om uigurernas situation i Kina och liknande frågor, annars hotade polisen med påföljder. Men denne unge man gick i stället ut och berättade alltihop – och fick starkt stöd av universitetets rektor (före detta senatorn Mitch Daniels).<sup>3  </sup>På flera andra håll har modiga studenter som trakasserats av regimtrogna kinesiska medstudenter blivit djupt besvikna på universitetens ryggradslösa respons.<sup>4</sup></p>
<p>Studenter som protesterar riskerar samtidigt att aldrig kunna resa hem igen, och deras familjer kan få problem så som ofta sker med familjer till aktivister och flyktingar från Hongkong, uigurer eller andra dissidenter från Kina.</p>
<p>Många studenter tystnar förstås. De vet ju att den kinesiska regimen inte skyr några medel för att med våld och hot tysta all opposition, även utanför landets gränser.<sup>5</sup></p>
<h2>Akademin har valt att blunda för Kommunistpartiet</h2>
<p>Trots att allt detta länge varit känt har samtidigt de kinesiska konsulatens inblandning ofta tolererats av utländska universitetsledningar. Ibland beror det på lathet, men ibland tror de att ”det handlar ju om kineser, så de får väl ha kontakt med sina medborgare” – och så ser de mellan fingrarna med all den otillbörliga myndighetsinblandningen i universitetets inre liv.</p>
<p>Men när stora delar av studentkåren är från Kina kan hela atmosfären förpestas.</p>
<p>För att slippa konfronteras med denna obehagliga nya verklighet har en del naiva akademiker hävdat att det handlar om ”den kinesiska kulturen” – som om kinesiska studenter helt enkelt inte <em>vill</em> tycka saker offentligt. Därför är de så tysta i klassen! En närmast rasistisk teori, som förstås är fel; kinesiska studenter har åsikter. Det handlar inte om kultur, utan om Kinas politiska system, inklusive hur studenterna uppfostras från barnsben att tycka som de blir tillsagda att tycka.</p>
<p>På senare år har det dock blivit alltmer uppenbart, även för dem som varit naiva om Kina, vad de kinesiska myndigheterna och de styrda studentorganisationerna håller på med i utlandet.</p>
<p>På Columbia University i New York gick det så långt att universitetet såg sig nödgat att beordra den konsulatstyrda kinesiska klubbens upplösning. Mycket lite är känt om vad som egentligen hände bakom kulisserna. Min gissning är att det kinesiska konsulatets inblandning blev alltför aggressiv och därmed outhärdlig för universitetsledningen. Men de ville samtidigt inte öppet gå ut mot den kinesiska regimen eftersom det hade kunnat bli en offentlig skandal, det vill säga dålig PR.</p>
<p>Sådana motgångar bakom kulisserna har också inneburit en del förändringar i de kinesiska myndigheternas taktik framför kulisserna. Den strategiska handelsrelationen med USA är strategiskt viktig för kommunistregimen, så den får inte äventyras för mycket.</p>
<p>Tidigare uppmuntrade man sina studenter till öppet aggressiv nationalism. Det skreks slagord, revs sönder plakat, och det kastades ibland flaskor och liknande.</p>
<p>En kvinnlig professorskollega till mig på Cornell University fick ta emot dödshot via mejl för några år sedan när hon skulle visa en film om Tibet – inklusive ett mejl som yrkade på att ”Du borde få botox för din hjärna”. (Cornell genomförde sedan filmvisningen, men med en uniformerad polisman i salen.)</p>
<p>Men nu har regimen ändrat taktik. Inga flaskor kastas mot talare eller paneler. I stället försöker Peking, där man lyckats bygga upp ett beroendeförhållande, avstyra alla evenemang med negativ publicitet för Kina – ofta genom att man låtsas som om det skulle ”såra de kinesiska studenternas känslor” om man till exempel skulle tillåta ett föredrag om Kinas militära hot mot Taiwan, eller liknande.</p>
<p>På lärosäten där en riktigt ”vänskaplig” relation etablerats instrueras dessutom de kinesiska studenterna att rapportera sina egna lärare för ”anti-kinesiska” åsikter, så de råkar illa ut – något som redan skett till exempel i England.<sup>6</sup> Det är precis som hemma i Kina och går tillbaka på Mao-tiden, då barn fostrades till att tjalla på sina föräldrar.</p>
<p>Och om detta inte går instrueras de kinesiska studenterna att helt enkelt bojkotta evenemang eller kurser som tar upp Kina på ”fel” sätt. Jag har själv, liksom mina kollegor, stött på hur duktiga studenter först gärna velat vara med, men sedan mystiskt ”valt” att lämna kursen.</p>
<h2>Konsulatet dirigerar studenterna till att tysta regimkritiker</h2>
<p>När en amerikansk kongressledamot (nuvarande senatorn <strong>Elissa Slotkin</strong>) besökte Cornell för en tid sedan och höll föredrag på vårt centrum för <em>public policy</em> (där hälften av studenterna är kineser) frågade en uigurisk student hur hon såg på uigurernas situation. Slotkin började uttrycka sin sympati för dem. Men då hördes plötsligt ett kommando på kinesiska från ledaren för den kinesiska kontingenten i salen: ”Den som är patriot, ska gå nu.” Alla 40 i gruppen reste sig bums och avtågade demonstrativt. En del hånade vår uiguriska student när de gick förbi henne i bänkarna. Några nervösa administratörer föredrog dock efteråt att <em>fortfarande</em> tro att detta handlade om att deras betalande kinesiska studenter nu plötsligt ”uttryckte sina åsikter”!</p>
<p>Harvard och dess Kennedy School of Government hör till dem som varit allra mest underdåniga mot Kommunistpartiets Kina. Nyligen inbjöd de regimens ambassadör att hålla tal. Flera studenter reste sig upp under hans tal, den ena efter den andra, för att protestera mot regimens förtryck i Tibet och i Hong Kong. Den första attackerades och släpades brutalt bort – inte av Harvardpersonal utan av en kinesisk student som är son till en ledande partifunktionär hemma i Kina (det kan noteras att <strong>Xi Jinpings</strong> dotter har studerat på Harvard). Först vid den andra protestaktionen hade Harvard samlat sig. En universitetspolis ombad artigt den tibetanska studenten att lämna rummet. Sedan kom det värsta: Harvard bestraffade de båda studenterna som protesterade, men <em>inte</em> den unge mannen!<sup>7</sup></p>
<p>Många kinesiska studenter blir förstås påverkade när de isoleras inne i sin kinesiska bubbla, även när de befinner sig utanför Kina. Wechat och andra kinesiska digitala propagandaplattformar tillåts i västländer, trots att utländska motsvarigheter är förbjudna i Kina, och Wechat fungerar ofta som studenternas huvudsakliga kommunikationskanal. En del inspireras där till att visa sig duktiga när partistaten uppmanar dem att ”tala i Kinas sak”.</p>
<blockquote><p>Den kinesiska staten använder alltså sina egna studenter för att spionera.</p></blockquote>
<p>Och en del <em>tvingas</em> helt enkelt till att gå Pekings ärenden. Vi har sett flera tragiska fall där kinesiska studenter instruerats att bli spioner på riktigt, och sedan ertappats. I flera av dessa fall ter det sig uppenbart att det skett på instruktion från den kinesiska statens agenter.</p>
<p>Ta till exempel fysikdoktoranden i Minnesota som skaffade sig en kameradrönare och åkte iväg på egen hand för att filma en flottbas i Virginia, på andra sidan USA. Han greps sedan hans drönare fastnade i ett träd.<sup>8</sup> Jag vägrar tro att han hittade på en så korkad idé alldeles själv.</p>
<p>Eller flickan som stal från sitt universitetslabb vid ett Floridauniversitet och sedan gråtande medgav att det var på instruktion från en kinesisk man baserad utanför campus!<sup>9</sup></p>
<p>Hennes fall är extra intressant eftersom Peking sedan 2017 har sin nationella underrättelselag, med direkta föreskrifter om att alla kineser måste åtlyda befallningar att tjäna som spioner – och om de ertappas får de inte berätta hur det ligger till. Det gör att vi nog måste oroa oss för den här flickan i Florida, som ju öppet erkände att det var någon annans idé att hon skulle stjäla från labbet!</p>
<p>Den kinesiska staten använder alltså sina egna studenter för att spionera. Det vi sett hittills handlar med största säkerhet bara om toppen av ett isberg – vi vet att den kinesiska staten ägnar sig åt massivt spionage och stöld, jorden runt.<sup>10</sup></p>
<h2>Trump stärker partiets antivästliga argument</h2>
<p>Och nu reagerar alltså Trumpregeringen på detta och vill blockera eller hårdkontrollera kinesiska studenter. Bör vi applådera det?</p>
<p>Faktum är att ett amerikanskt och västerländskt uppvaknande om Kina och dess metoder har varit på gång sedan flera år. I USA finns idag en mycket större medvetenhet om problemen än för bara fem år sedan, inte minst bland folkvalda politiker i kongressen som genomfört flera bra åtgärder, exempelvis mot den kinesiska handeln med slavprodukter från det uiguriska folkmordet.</p>
<p>Men nu hotar alltså Trump med grova metoder vilka i likhet med rättslösheten och brutaliteten mot latinamerikanska papperslösa dels kommer att splittra USA, och dels skrämma bort många unga kineser, liksom många andra som en gång var vänligt inställda till USA, till demokratin och så vidare, men som nu kommer att sky det som pesten och till och med stärka den kinesiska regimen på kuppen.<sup>11</sup></p>
<p>Jag håller med demokraten i representanthuset, <strong>Raja Krishnamoorthi</strong>: Strängare kontroll behövs, men att slänga ut alla kineser bara för att de är kineser är kontraproduktivt.<sup>12</sup> De ogenomtänkta utfallen blir, även om man sedan tillfälligt backar från dem, ytterligare ett av många ideologiskt motiverade självmål från den sittande amerikanska regeringen.</p>
<p>Det får oss att glömma vems fel det egentligen är att så många på goda grunder börjat betrakta kinesiska studenter med misstänksamhet: Den kinesiska regimens, såklart.<strong> </strong></p>
<div class="notes-wrapper"><a class="shadow-button noselect show-notes"  data-articleid="181002">  <span class="button-inner-wrapper">    <span class="left-part">      <i class="ti-arrow-circle-down"></i>    </span>    <span class="right-part">      <span class="default-text">Se noter</span>      <span class="open-text">Visa mindre</span>    </span>  </span></a></p>
<div class="references">
<h3 id="noter" class="ref-heading" style="color: #000;;">Noter</h3>
<ol>
<li><a href="https://www.state.gov/releases/office-of-the-spokesperson/2025/05/new-visa-policies-put-america-first-not-china/"><em>New visa policies put America first, not China</em></a><em> (</em>Marco Rubio, U.S. Department of State, 28 maj 2025); <a href="https://www.nbcnews.com/news/us-news/trump-administrations-stops-new-student-visa-interviews-rcna209305"><em>Trump administration pauses new student visa interviews</em></a> (NBC, 27 maj 2025).</li>
<li><a href="https://www.aspi.org.au/report/picking-flowers-making-honey/"><em>Picking flowers, making honey: The Chinese military’s collaboration with foreign universities</em></a> (ASPI, 30 oktober 2018)<br />
Vad gäller Sverige, se till exempel: <a href="https://www.svt.se/nyheter/utrikes/kinesisk-militarforskning-pa-svenska-universitet"><em>Expert varnar: Kinesisk militärforskning på svenska universitet</em></a> (SVT, 24 september 2019) och <a href="https://www.affarsvarlden.se/artikel/jarfalla-vill-stoppa-miljardinvestering-kopplas-till-kinas-militar"><em>Järfälla vill stoppa miljardinvestering – kopplas till Kinas militär</em></a> (Jojje Olsson, Affärsvärlden, 7 april 2025)</li>
<li><a href="https://www.propublica.org/article/even-on-us-campuses-china-cracks-down-on-students-who-speak-out"><em>Even on US Campuses, China cracks down on students who speak out</em></a> (Sebastian Rotella, ProPublica, 30 november 2021)</li>
<li><a href="https://www.nationalreview.com/2023/05/after-pro-ccp-intimidation-arrest-students-warn-that-berklee-isnt-doing-enough-to-protect-chinese-community/"><em>After pro-CCP intimidation arrest, students warn that Berklee isn’t doing enough to protect Chinese community</em></a> (Jimmy Quinn, National Review, 16 maj 2023)</li>
<li>Den kinesiska polisens brutala metoder med försvinnanden, tortyr och tvångsbekännelser är väl kända (numera kopieras dess metoder till och med av kinesiska kriminella, som utövar utpressning mot kinesiska studenter. Se min artikel: <a href="https://kinamedia.se/2024/02/06/vag-av-cyber-kidnappningar-mot-kinesiska-studenter-i-utlandet/"><em>Våg av ’cyber-kidnappningar’ mot kinesiska studenter i utlandet</em></a> (Magnus Fiskesjö, Kina-Media, 6 februari 2024)</li>
<li><a href="https://unherd.com/2024/03/the-chinese-students-policing-britains-universities/"><em>The Chinese students policing Britain’s universities: Self-censoring academics live in terror</em></a> (Sam Dunning, UnHerd, 20 mars 2024)<br />
Och det har länge sett lika illa ut i andra europeiska länder, till exempel i Tyskland: <a href="https://www.theatlantic.com/international/archive/2019/07/chinas-influence-efforts-germanystudents/593689/"><em>The Chinese influence effort hiding in plain sight: Beijing uses student and professional associations to try to influence not just Chinese citizens abroad, but outsiders, too</em></a> (Didi Kirsten Tatlow, The Atlantic, 12 juli 2019).<br />
Liksom i Australien: <a href="https://www.hrw.org/report/2021/06/30/they-dont-understand-fear-we-have/how-chinas-long-reach-repression-undermines"><em>They don’t understand the fear we have:</em></a> <a href="https://www.hrw.org/report/2021/06/30/they-dont-understand-fear-we-have/how-chinas-long-reach-repression-undermines"><em>How China’s long reach of repression undermines academic freedom at Australia’s universities</em></a> (Human Rights Watch, 30 juni 2021)</li>
<li><a href="https://www.thefire.org/news/baffling-decision-harvard-excuses-violence-against-student-briefly-disrupting-chinese"><em>In baffling decision, Harvard excuses violence against student briefly disrupting Chinese diplomat’s speech</em></a> (Sarah McLaughlin, FIRE, 24 oktober 2024)<br />
Senare, vid sina ceremonier i maj 2025, valde Harvard märkligt nog att som en av huvudtalarna välja en kinesisk student som också ser ut att ha varit inblandad i denna groteska incident: <a href="https://buttondown.com/collectivestudy/archive/did-shared-humanity-harvard-speaker-help-suppress/"><em>Did ’shared humanity’ Harvard speaker help suppress 2024 campus protest?</em></a> (Collective Study, 3 juni 2025)<br />
Hon citerade Xi Jinping i sitt tal. Delar av partiaristokratin i Kina har länge varit stamkunder på Harvard. Se: <a href="https://buttondown.com/collectivestudy/archive/did-shared-humanity-harvard-speaker-help-suppress/"><em>When Harvard meets the party</em></a> (Desmond Shum, X, 1 juni 2025) och dessutom <a href="https://bitterwinter.org/jiang-yurongs-harvard-speech-and-the-ccps-soft-power-indoctrination/"><em>Jiang Yurong’s Harvard Speech and the CCP’s Soft Power Indoctrination</em></a>&#8221; (Kok Bayraq, Bitter Winter, 10 juni 2025).</li>
<li><a href="https://dronexl.co/2024/05/30/chinese-grad-student-espionage-drone-us-navy-shipyards/"><em>Chinese grad student charged with espionage for drone photos of US Navy Shipyards</em></a> (DroneXL, 30 maj 2024)</li>
<li><a href="https://www.wuft.org/fresh-take-florida/2024-05-24/uf-employee-students-implicated-in-illegal-plot-to-ship-drugs-toxins-to-china"><em>UF employee, students implicated in illegal plot to ship drugs, toxins to China</em></a> (University of Florida Television, 24 maj 2024)</li>
<li>Se not 2 ovan, och t.ex. BBC:s översikt: <a href="https://www.bbc.com/news/articles/cmm33rm32veo"><em>China’s spy threat is growing, but the West has struggled to keep up</em></a> (BBC News, 15 May 2024)<br />
Förutom industri- och ekonomiskt spionage jorden runt, kan man notera att kinesiska agenter flera gånger brutit sig in hos amerikanska myndigheter där de stulit personinformation för flera miljoner anställda. Man samlar dessutom på dna, jorden runt, se till exempel min artikel: <a href="https://kinamedia.se/2021/07/09/kina-dammsuger-omvarlden-pa-dna-och-ingen-vet-varfor/"><em>Kina dammsuger omvärlden på DNA och ingen vet varför</em></a> (Magnus Fiskesjö, KinaMedia, 9 juli 2021)</li>
<li><a href="https://chinadigitaltimes.net/2025/06/chinese-students-react-to-u-s-visa-restrictions-with-disappointment-and-dismay/"><em>Chinese students react to U.S. visa restrictions with disappointment and dismay</em></a> (China Digital Times, 3 juni 2025)</li>
<li><a href="https://www.politico.com/news/2025/06/01/china-student-visa-plan-krishnamoorthi-00379815"><em>China happy with restrictions on its students, lawmaker says</em></a> (Politico, 1 juni 2025)</li>
</ol>
</div>
</div>
<div class="author-byline">Magnus Fiskesjö är antropolog och Asienforskare vid Cornell University i USA.
</div>
</div>
