Av Ola Wong | 20 maj 2023
I korthet
Det påstås ibland att öppenhet skapar sympati, om vi bara öppnar gränser så minskar risken för konflikt. Det är inte helt sant: vårtorna syns tydligare när man står ansikte mot ansikte med ett annat samhällssystem.
<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-96155"      class = "kv-pod-holder kv-player-light  lplo " data-sid="" data-eid="" data-pid="96155" data-acurl="aHR0cHM6Ly9tZWRpYS5wb2Quc3BhY2UvaW5sYXN0YXRleHRlci9taW5uZW5fZnJhbl9ldHRfb3BwbmFyZV9raW5hLm1wMw==" data-psurl="aHR0cHM6Ly9tZWRpYS5wb2Quc3BhY2Uva2p4ajYzeWRkZXEydmgvbWlubmVuLWZyYW4tZXR0LW9wcG5hcmUta2luYS5tcDM=">  <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: "><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%2Fminnen-fran-ett-oppnare-kina%2F&amp;t=Minnen+fr%C3%A5n+ett+%C3%B6ppnare+Kina"    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=Minnen+fr%C3%A5n+ett+%C3%B6ppnare+Kina+-+https%3A%2F%2Fkvartal.se%2Fartiklar%2Fminnen-fran-ett-oppnare-kina%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%2Fminnen-fran-ett-oppnare-kina%2F"    target = "_blank"    class  = "li-link"    title  = "Dela på LinkedIn"><i class="ti-linkedin ui transparent"></i></a><a href    = "mailto:?subject=Minnen från ett öppnare Kina&body=https://kvartal.se/artiklar/minnen-fran-ett-oppnare-kina/"   target  = "_blank"    class   = "pr-link"    title   = "E-posta"    onclick = ""><i class="ti-email ui transparent"></i></a><a href    = "https://kvartal.se/skriv-ut/96155/utskrift"    target  = "_blank"    class   = "pr-link"    title   = "Skriv ut"    onclick = ""><i class="ti-printer ui transparent"></i></a><a href   = "https://kvartal.se/skriv-ut/96155/pdf"    target = "_blank"    class  = "pr-link"    title  = "Ladda ner artikeln som PDF"><i class="fas fa-file-pdf 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="author-section ">  <div class="author-section-inner">    <div class="author-image-holder"><div class="author-image" style="background-image: url('https://kvartal.se/wp-content/uploads/2022/03/DSC_1185-1-scaled-e1646149873242.jpg');"></div><img class="author-print-img" src="https://kvartal.se/wp-content/uploads/2022/03/DSC_1185-1-scaled-e1646149873242.jpg" style="display: none;">    </div>    <div class="by-disclaimer-holder" style="color: #8a3a67">Av <a href="https://kvartal.se/medverkande/ola-wong/">Ola&nbsp;Wong</a> | 20 maj 2023<div class="author-desc">Ola Wong är Kvartals kulturredaktör, Kina-kännare och författare.
</div>    </div>  </div></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%2Fminnen-fran-ett-oppnare-kina%2F&amp;t=Minnen+fr%C3%A5n+ett+%C3%B6ppnare+Kina"    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=Minnen+fr%C3%A5n+ett+%C3%B6ppnare+Kina+-+https%3A%2F%2Fkvartal.se%2Fartiklar%2Fminnen-fran-ett-oppnare-kina%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%2Fminnen-fran-ett-oppnare-kina%2F"    target = "_blank"    class  = "li-link"    title  = "Dela på LinkedIn"><i class="ti-linkedin ui transparent"></i></a><a href    = "mailto:?subject=Minnen från ett öppnare Kina&body=https://kvartal.se/artiklar/minnen-fran-ett-oppnare-kina/"   target  = "_blank"    class   = "pr-link"    title   = "E-posta"    onclick = ""><i class="ti-email ui transparent"></i></a><a href    = "https://kvartal.se/skriv-ut/96155/utskrift"    target  = "_blank"    class   = "pr-link"    title   = "Skriv ut"    onclick = ""><i class="ti-printer ui transparent"></i></a><a href   = "https://kvartal.se/skriv-ut/96155/pdf"    target = "_blank"    class  = "pr-link"    title  = "Ladda ner artikeln som PDF"><i class="fas fa-file-pdf 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/minnen-fran-ett-oppnare-kina/?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 8 min</span></a><a href   = "https://kvartal.se/skarmlasarvanlig/96155"    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-96155">  <div class="in-short-inner">    <span class="close_button close-in-short in-short-toggle" data-articleid = "96155"></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 ">Det påstås ibland att öppenhet skapar sympati, om vi bara öppnar gränser så minskar risken för konflikt. Det är inte helt sant: vårtorna syns tydligare när man står ansikte mot ansikte med ett annat samhällssystem.</p>
</div>
<div class="rest-of-article ">
<h2>USA:s farliga splittring</h2>
<p>År 1991 reste en ung och begåvad kinesisk statsvetare vid namn <strong>Wang Huning</strong> till USA, inbjuden på ett sex månader långt stipendium. Väst stod på höjden av sin makt, historien hade tagit slut och teorin var att kineser skulle återvända hem och sprida demokratin och den fria marknadens budskap. En hel del gjorde det. Men det Wang såg var ett USA som var på väg att rivas ner i en malström av kriser. Han såg ett skum av motsättningar mellan rika och fattiga, kapitalister som skor sig på och ibland ersätter det allmänna, vita och svarta, individen mot familjen och gruppen, rotlösheten. Allt flödade ur samma problemkälla: den<a href="https://www.palladiummag.com/2021/10/11/the-triumph-and-terror-of-wang-huning/"> radikala individualismen</a> som är kärnan i det amerikanska projektet.</p>
<p>Ungdomen saknade etik, mål och disciplin och deras föräldrar, själva skolade sedan barnsben till att bli självständiga individer, var för själviska för att satsa på barnens utbildning som östasiater gör. Amerikanen framstod som en ensam nihilist. Wang skrev om detta i sin bok <em>Meiguo fandui Meiguo,</em> USA mot USA, en bok som verkligen borde få en bra översättning. Han återvände till Kina som en ledande motståndare till liberala politiska reformer. Kommunistpartiets ledning upptäckte den auktoritära talangen och han plockades upp som kommunistpartiets chefsideolog.</p>
<p>Wang är idag inne på sin tredje generalsekreterare och är fortfarande medlem av politbyråns ständiga utskott. Han har pekats ut som mannen bakom Xi Jinpings stora idéprojekt. Satsningar som Den kinesiska drömmen, Gemensamt välstånd och Xi Jinpings tänkande har det gemensamt att de försöker motverka de tendenser Wang såg i USA.</p>
<h2>Det totalitära hotet</h2>
<p><strong>Matt Pottinger</strong> åkte till Taiwan 1997 som ung journalist för att studera kinesiska. Det var året efter att de första riktiga valen genomfördes på Taiwan. Ön visade att det går att kombinera kinesisk kultur med demokrati och mänskliga rättigheter. Därefter reste han till Folkrepubliken Kina som korrespondent för den amerikanska tidningen Wall Street Journal. Men i stället för att som många andra västerlänningar bländas av tillväxten återvände han till USA för att varna för kommunistpartiets ambitioner för världen. Pottinger blev sedermera rådgivare åt president Trump och en viktig aktör bakom den hårdare synen på Kina och inte minst den sociala medietjänsten Tiktok som numera präglar Washington. Öppenhet skapade inte sympati hos någon av herrarna, men det är svårt att förneka att bägge har vissa poänger.</p>
<blockquote><p>Böckerna andas en sorg över denna förlorade era.</p></blockquote>
<p>Två aktuella böcker från gamla Kina-korrespondenter visar på sanningen i att den som har inblick kan utveckla en djupare förståelse om än inte sympati för ett samhällssystem. SR:s <strong>Hanna Sahlberg</strong> har kommit ut med boken <em>Den osynliga muren: rapport från mitt misslyckade försök att bli kines.</em> <strong>Tania Branigan</strong>, brittiska The Guardians tidigare korrespondent i Peking är aktuell med boken <em>Rött Minne – minnas och glömma kulturrevolutionen i Kina</em> (översättning: Peter Samuelsson).</p>
<p>Bägge bygger på arbete från en tid då Kina var betydligt öppnare för journalister att jobba i jämfört med idag. Böckerna andas en sorg över denna förlorade era. Sahlberg skriver: ”Mina kinesiska journalistkollegor var lika unga som jag. Åren före sommar-OS i Beijing, kunde kinesiska journalister ännu resa över hela Kina och rapportera om korruption, avslöja miljöskandaler, intervjua fattiga som tvingats bort från sina hem av stora byggherrar. Vi var övertygade om att ett annat Kina var möjligt, att fri journalistik kunde göra skillnad och att vår generation skulle få uppleva ett öppnare och bättre samhälle.” Tjugo år senare nås hon av en videohälsning från de tidigare journalistkollegorna. Nu har de bytt yrken. De skrålar en sång som låter som ett slags dödsruna:</p>
<p>”<em>Du vet inte hur mycket mitt hjärta älskar det här landet. Jag hatar det inte, klagar inte på det och förbannar det inte</em><em>. Jag vill bara ha en röst.<br />
Lyssna på hur det var:<br />
Jag jobbade på en tidning, den hette Nanfang Zhoumo &#8230;”</em></p>
<p>Sahlberg är en personlig vän och jag ska inte försöka göra en recension av hennes bok, andra får uttala sig om den är bra eller dålig. Men det är ingen slump att <em>minnet</em> och historieskrivning är ett så viktigt tema i böcker från tidigare Kina-korrar, som den tidigare BBC-korrespondenten <strong>Louisa Lims</strong> hyllade bok <em>T</em><em>he People&#8217;s Republic of Amnesia</em> (om massakern vid Himmelska fridens torg 1989) eller min egen <em>Pekingsyndromet</em>, som kom ut 2014.</p>
<p>Redan inom ett halvår efter att Xi tagit makten varnade han partiet för faran med ”historisk nihilism”, att avvika från den officiella historieskrivningen. Det pekades ut som ett existentiellt hot mot partiet (för mer om det, se min essä<a href="https://kvartal.se/artiklar/partiet-styr-kinas-historia-for-att-kontrollera-framtiden/"> <em>Kommunistpartiet styr Kinas historia för att kontrollera framtiden</em></a>). Det kan vid en första anblick verka löjligt att regimen i Peking skulle kunna äventyras av historiens gengångare och berättelser. En ekonomisk och militär jätte uppstöttad av världens största och mest avancerade säkerhetsapparat riktad mot den egna befolkningen. Men Tania Branigan inser en sak: Tänk om han har rätt!?</p>
<h2>När våld blir sanning</h2>
<p>Branigans bok skildrar möten med offer, förövare och utövare av den stora kulturrevolutionen, då <strong>Mao Zedong</strong> kastade Kina i kaos och kommunistpartiet utförde ett mordförsök på den kinesiska kulturen och moralen. Xi Jinpings far förföljdes brutalt och Xi själv visades upp offentligt och drogs i vanära, samtidigt som han indoktrinerades till att dyrka Mao. Detta verkar ha blivit lärdomen för Xi: så här går politiken till. ”Våld är sanning” är ett slagord från den tiden.</p>
<p>Boken inleds med ett citat av Mao som sätter fingret på vad Xi Jinping siktar på: ”Dessa två saker [Taiwan och kulturrevolutionen] är inte avslutade och arvet efter dem måste föras vidare till nästa generation. Hur man gör? Om inte med fredliga medel, så med våld.” Nu bär kinesiska grundskoleelever omkring böcker med Xi på omslaget och studerar Xi Jinpings tankar.</p>
<p>”Även om arvet efter kulturrevolutionen är mer relevant – mer uppenbart – än någonsin, skulle den här boken inte ha kunnat skrivas om jag börjat på den idag”, konstaterar Branigan.</p>
<p>Men Branigan märker att intervjupersoner gradvis slutar att ställa upp, arkiven stängs. Vittnesmålen i boken tillhör en annan epok – inte de tio år då kulturrevolutionen ägde rum, utan en tid då människor, i alla fall några få, hade utrymmena att dela med sig av dem.</p>
<blockquote><p>Det enda man kan göra som journalist är att nedteckna minnen.</p></blockquote>
<p>”När en individs eller ett folks minne inte finns kvar blir sorgen som återstår ett bottenlöst svart hål”, skriver <strong>Ai Weiwei</strong>  i sina ytterst läsvärda memoarer <em>Tusen år av glädje och sorg</em> som kom ut på Albert Bonniers förlag förra året. Att vägra glömma skänker därför ny verklighet åt livet. Senaste gången jag stötte på Tania Branigan var när ovannämnde Ai Weiwei höll hov för utländska och kinesiska journalister och kulturarbetare i Peking 2010. En scen som idag framstår som närmast otrolig, på samma sätt som att det faktiskt fanns en tid då någon som <strong>Gui Minhai</strong> kunde driva ett regimkritiskt förlag i Hongkong, och att omvärlden lät sig luras av kommunistpartiets löften om att låta Hongkong behålla sina friheter. Kort därefter greps Ai Weiwei, han gick i exil och partiet gör sitt bästa för att han liksom Gui Minhai ska bli bortglömd. Det enda man kan göra som journalist är att nedteckna vad som har hänt, och det har Branigan gjort med förtjänst.</p>
<p>Det fanns en tid då det låg i partiledningens intresse att låta folk prata högt om kulturrevolutionens övergrepp. Det legitimerade omsvängningen till dagens marknadsleninism och klassklyftor. Det kom fram så kallad ”ärrlitteratur”, och filmer och konstnärer bearbetade landets traumatiska närtid med filmer som <em>Farväl min konkubin</em>.</p>
<p>Men den tiden är förbi och nu har den officiella partihistoriken radikalt kortat ner avsnittet om kulturrevolutionen och avlägsnat partiets kritiska domslut över epoken från 1981. Den tidigare ledaren <strong>Deng Xiaopings</strong> varning om risken med att lägga makten i en enda persons händer har försvunnit ur historiska texter av uppenbara orsaker. Personkulten är tillbaka. Wang Hunings typ av tänkande vann, inte för att det är rätt utan för att partiet kontrollerar militären och medierna. Men den som inte lär sig av historien är dömd att upprepa sin egen variant av den. Inte i form av kaos där fabriker stänger ner för kampmöten mot ledningen. Men i kulturrevolutionens grundläggande totalitära ambition: att omvandla nationen till en sluten organism som lojalt förenar sina tankar med ledaren.</p>
<h2>Allt färre med erfarenhet från fältet</h2>
<p>När nu Sverige och Europa yrvaket vaknar upp inför varningar från sådana som Matt Pottinger, så behövs människor med insikt från fältet i Kina. Den första december är det tänkt att Sverige ska ha en granskningsmekanism för utländska investeringar på plats. Den ska hanteras av Inspektionen för strategiska produkter, ISP, som kommer att behöva utöka sin personal dramatiskt, berättar <strong>Oscar Almén</strong>, forskare vid Totalförsvarets forskningsinstitut, FOI. Han säger att det innebär problem när den politiska situationen i Kina gör att det kommer färre utlänningar med praktisk erfarenhet från landet.</p>
<p>En hel del av dem som var i Kina under den öppnare eran har skaffat sig familjeband och ekonomiska intressen som gör att de håller tyst, andra har börjat sympatisera med partiet. Nollcovidpolitiken innebar att utlänningar (och även en hel del kineser) flytt landet. I slutet av april vidgade Kina sin redan drakoniska spionlag till att omfatta ”dokument och data” som är länkade till nationell säkerhet och nationella intressen. Resultatet har blivit ytterligare osäkerhet för utländska journalister, akademiker och affärsmän eftersom det mesta kan betraktas som känslig information i Kina.</p>
<p>Det är en tragedi att insikten minskar. Inte minst för att det kan leda till att fördomar om Kina befästs, och klarsyn – kritisk såväl som positiv – grumlas.</p>
<div class="author-byline">Ola Wong är Kvartals kulturredaktör, Kina-kännare och författare.
</div>
</div>
