Svartmålningen av Västs historia hjälper Putin

<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-90311"      class = "kv-pod-holder kv-player-light  lplo " data-sid="" data-eid="" data-tis="" data-tin="" data-pid="90311" data-pty="SW5sw6RzdCBhcnRpa2VsIChLdWx0dXIp" data-pna="U3ZhcnRtw6VsbmluZ2VuIGF2IFbDpHN0cyBoaXN0b3JpYSBoasOkbHBlciBQdXRpbg==" data-acurl="aHR0cHM6Ly9tZWRpYS5wb2Quc3BhY2Uva3ZhcnRhbC9pbmxhc3Rfc3ZhcnRtYWxuaW5nZW5fYXZfdmFzdHNfaGlzdG9yaWFfaGphbHBlcl9wdXRpbi5tcDM=" data-psurl="aHR0cHM6Ly9tZWRpYS5wb2Quc3BhY2Uva2p4ajYzeWRkZXEydmgvc3ZhcnRtYWxuaW5nZW4tYXYtdmFzdHMtaGlzdG9yaWEtaGphbHBlci1wdXRpbi5tcDM=">  <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/johan-berglund/">Johan&nbsp;Berglund</a> | 18 mars 2023<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%2Fsvartmalning-av-vasts-historia-hjalper-putin%2F&amp;t=Svartm%C3%A5lningen+av+V%C3%A4sts+historia+hj%C3%A4lper+Putin"    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=Svartm%C3%A5lningen+av+V%C3%A4sts+historia+hj%C3%A4lper+Putin+-+https%3A%2F%2Fkvartal.se%2Fartiklar%2Fsvartmalning-av-vasts-historia-hjalper-putin%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%2Fsvartmalning-av-vasts-historia-hjalper-putin%2F"    target = "_blank"    class  = "li-link"    title  = "Dela på LinkedIn"><i class="ti-linkedin ui transparent"></i></a><a href    = "mailto:?subject=Svartmålningen av Västs historia hjälper Putin&body=https://kvartal.se/artiklar/svartmalning-av-vasts-historia-hjalper-putin/"   target  = "_blank"    class   = "pr-link"    title   = "E-posta"    onclick = ""><i class="ti-email ui transparent"></i></a><a href    = "https://kvartal.se/skriv-ut/90311/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%2Fsvartmalning-av-vasts-historia-hjalper-putin%2F&amp;t=Svartm%C3%A5lningen+av+V%C3%A4sts+historia+hj%C3%A4lper+Putin"    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=Svartm%C3%A5lningen+av+V%C3%A4sts+historia+hj%C3%A4lper+Putin+-+https%3A%2F%2Fkvartal.se%2Fartiklar%2Fsvartmalning-av-vasts-historia-hjalper-putin%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%2Fsvartmalning-av-vasts-historia-hjalper-putin%2F"    target = "_blank"    class  = "li-link"    title  = "Dela på LinkedIn"><i class="ti-linkedin ui transparent"></i></a><a href    = "mailto:?subject=Svartmålningen av Västs historia hjälper Putin&body=https://kvartal.se/artiklar/svartmalning-av-vasts-historia-hjalper-putin/"   target  = "_blank"    class   = "pr-link"    title   = "E-posta"    onclick = ""><i class="ti-email ui transparent"></i></a><a href    = "https://kvartal.se/skriv-ut/90311/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/svartmalning-av-vasts-historia-hjalper-putin/?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 9 min</span></a><a href   = "https://kvartal.se/skarmlasarvanlig/2ee8ece5-0995-43bc-92f4-1d3faf02abc6"    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-90311">  <div class="in-short-inner">    <span class="close_button close-in-short in-short-toggle" data-articleid = "90311"></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 ">Vikten av att kunna sin historia har demonstrerats av kriget i Ukraina. <strong>Vladimir Putin</strong> har motiverat angreppskriget med en hemkokt, förvriden historieskrivning om de båda nationernas enhet med rötterna i det gamla Kievrus.</p>
</div>
<div class="rest-of-article ">
<p>Det förefaller tydligt att Putin själv är övertygad om den egna historieskrivningen, och att denna har ett betydande förklaringsvärde till varför invasionen ägde rum. Av detta följer behovet för Ukraina – och alla som sluter upp bakom landets frihetskamp – att kunna bemöta Putins argument. Det får sägas vara av närmast existentiell betydelse; en dimension av kriget bortom slagfältet. Så har också skett.</p>
<p>Här i Kvartal har till exempel Östeuropakännaren <strong>Kristian Gerne</strong>r redovisat de halvsanningar och förbiseenden som präglar Putins resonemang.<sup>1</sup> För många i Väst har kriget, tvärtemot den ryska avsikten, lett till ökat intresse och kunskap om Ukrainas långa historia – i all sin komplexitet, tragik och egenart.</p>
<h2>Började USA:s historia med de första slavarna?</h2>
<p>Historieskrivningen som slagfält är mer aktuell än på länge, även på närmare håll. En våg av kritik och fundamental omskrivning av den egna historien sköljer över västerlandet. Det gäller i synnerhet i de två länder som varit avgörande för den existerande världsordningen<sup>2 </sup>och mycket av självbilden i det vi kallar ”Väst”, nämligen Storbritannien och USA. Det finns anledning att betrakta denna omtolkning av historien inte bara som perifera identitetspolitiska fejder, utan som fenomen av geopolitisk betydelse.</p>
<blockquote><p>Landets födelse var därmed ingenting att fira, utan snarare att sörja.</p></blockquote>
<p>Här kanske någon invänder att det vore bättre att helt lämna historieskrivningen till akademin. Har vi inte kommit förbi stadiet då nationell historieskrivning var en statsangelägenhet? Sägs det inte ofta att problemet för många konfliktdrabbade regioner är ”för mycket historia”?  Det ligger en del i detta. Men kanske är det att underskatta historien som politiskt vapen i vår tid. Med målmedveten politisk historieskrivning kan en motståndare tvingas på defensiven, demoraliseras, och se sina internationella allianser brytas upp.</p>
<p>Det kan vara värt att titta närmare på några illustrativa exempel från den pågående anglosaxiska historiestriden. Dess epicentrum finns i USA och detta lands alldeles särskilda relation till frågor om ras och hudfärg.</p>
<p>Tidningshuset <em>New York Times</em> inledde 2019 artikelserien <em>The 1619 Project – A New Origin Story,</em> en kampanj för att börja räkna USA:s grundande inte till 1776 utan till 1619, då de första afrikanska slavarna ska ha anlänt till Virginia.<sup>3</sup> Den amerikanska revolutionen och dess frihetshjältar var i själva verket, enligt artikelserien, inriktade på att säkra framtiden för slaveriet i Amerika. Slaveri och vit makt var det dominerande temat i USA:s historia. Landets födelse var därmed ingenting att fira, utan snarare att sörja. Även <strong>Abraham Lincoln</strong> – presidenten som till slut avskaffade slaveriet – borde enligt projektet ses som en representant för rasförtryck, inte för befrielse.</p>
<p>Artikelserien väckte kritik från specialister på amerikansk historia, som ansåg att den ”ersatte historisk förståelse med ideologi”.<sup>4</sup> Likväl fick den ett enormt inflytande. När kravaller svepte över USA som en reaktion på <strong>George Floyds </strong>död 2020 blev tusentals monument, inte bara av slaveriförespråkare, måltavlor.  Bland annat angreps flera statyer över nationalsymboler och presidenter som George Washington, U.S. Grant och Theodore Roosevelt. Kravallerna kallades i tidningar för ”the 1619 riots”. Kanske var det oundvikligt i dagens mycket polariserade amerikanska samhälle, att även historien skulle politiseras.</p>
<h2>Historien som vapen för att förändra</h2>
<p>Kritikerna framhåller att den nya historieskrivningen är ensidig, saknar nyanser, och frångår vetenskapsidealet om känslomässig distans. Historikern<strong> Philip Magness</strong> framhåller att författarna i ena stunden presenterar 1619-projektet som ett verk av saklig vetenskap, och i den andra som aktivism för politisk förändring.<sup>5</sup> Målsättningen tycks ofta vara att skapa skuldkänslor hos dagens majoritetsbefolkning. USA:s födelse ska ses som ett syndafall, snarare än en process av frigörelse och liberalism. (Det senare förvisso inte heller någon värdeneutral beskrivning.) Vad blir resultatet om ett lands hela självbild, berättelse om sig själv och dess samlande symboler utmålas som ondskefulla?</p>
<p>I Storbritannien har den amerikanska trenden snabbt fått fäste. Bland statyerna som attackerats finns även Winston Churchill, fram till nyligen kanske den främste symbolen av alla för den kämpande demokratin och för den brittiska nationen över huvud taget – men nu utpekad som, först och främst, en rasist.<sup>6</sup></p>
<p>Teologiprofessorn vid universitet i Oxford, <strong>Nigel Biggar</strong>, fick uppleva samma fenomen när han lanserade forskningsprojektet <em>Ethics and Empire</em>, för att undersöka hur imperier har uppfattats i moraliskt hänseende genom historien. En utgångspunkt var att imperier (från det kinesiska för mer än två tusen år sedan till de osmanska och europeiska relativt nyligen) kan tänkas ha positiva såväl som negativa egenskaper, att bedömas i varje enskilt fall. En proteststorm som omfattande studenter och lärare vid universitetet, så småningom med internationell uppbackning, ledde till att Biggars partner som forskningsledare lämnade sin post och att Biggar själv utmålades som rasist i brittiska medier.<sup>7</sup> Tanken att det skulle kunna finnas positiva saker att säga om historiska imperier ansågs helt enkelt inte acceptabel.</p>
<h2>Ensidig bild av vit skuld</h2>
<p>Det mest slående, som Biggar påpekar i en nyss utkommen bok, <em>Colonialism – A Moral Reckoning</em>, var aktivisternas ensidiga fokus på europeiska imperier till exempel i fråga om slaveriet (där de uppskattningsvis mellan 11 och 17 miljoner människor som omfattades av den arabiska slavhandeln sällan kommer på tal).<sup>8</sup> Kampanjerna riktas uteslutande mot västvärlden, och i förlängningen mot den världsordning som Väst gett upphov till. En uppenbar vanföreställning är att slaveri skulle vara en västerländsk företeelse, som därför skulle motivera en unik västerländsk (vit) skuld.</p>
<p>Fallet med det brittiska imperiet borde vara nog för att ge en mer nyanserad bild. Å ena sidan den långvariga handeln med slavar köpta i Afrika till de amerikanska kolonierna. Å andra sidan att britterna, efter en moralisk väckelse i början av 1800-talet, ägnade en stor del av sitt våldskapital i form av <em>Royal Navy,</em> till att stoppa den internationella slavhandeln (även om slaveriet fortgick i stor skala i de brittiska kolonierna fram till förbudet 1833. I bland annat det Osmanska riket förekom slavhandel in på 1900-talet). Två procent av Storbritanniens nationalinkomst ägnades åt att stoppa internationell slavhandel  årligen under en period av sextio år – sannolikt den dyraste internationella kampanj med moraliska förtecken som någonsin skett.</p>
<p>Biggars bok skrevs på uppmaning av Londonförlaget Bloomsbury och skulle ha kommit ut häromåret. Förlaget svängde dock efter vad som förefaller ha varit interna påtryckningar från anställda, som tycks ha upplevt obehag över bokens innehåll. Publiceringen sköts upp, och ett annat förlag tog över.<sup>9</sup> Försök att cancellera obekväma röster är naturligtvis bekymmersamma, oavsett på vilken sida av debatten det sker.</p>
<h2>Marxist-leninister tror att de inte kan vara imperialister</h2>
<p>Den ideologiskt färgade antikolonialismen riskerar, enligt Biggar, att spela i händerna på auktoritära stormakter, som inte sällan själva drivs av en nyimperialistisk agenda. Han pekar särskilt på Kina och Ryssland. Att underminera självförtroendet i västländerna, och skapa intern opinion mot de mest grundläggande delarna av dessa länders identitet och internationella status, är metoder som begagnades flitigt under det kalla kriget. Ideologiskt drivna aktivister inom akademin, djupt marinerade i marxistisk samhällssyn, var i det sammanhanget användbara spelpjäser. Mönstret går igen i våra dagar, även om den traditionella marxismen efterträtts av så kallade postkoloniala studier, med <strong>Michel Foucault</strong>, <strong>Frantz Fanon</strong> och <strong>Edward Said</strong> som lärofäder. Gemensamt för dem är en tendens till relativism ifråga om historisk sanning. Eftersom världen enligt dessa teoretiker struktureras genom maktutövning, är sanningen vadhelst som den antikoloniala kampen kräver.</p>
<p>Såväl Kina som Ryssland utnyttjar, enligt Biggar, dessa metoder för att långsiktigt underminera sammanhållning och självförtroende hos sina fiender. Dessutom kan anklagelser mot västländernas koloniala arv utnyttjas för att på det viset slå ifrån sig kritik mot politiskt förtryck och övergrepp mot de mänskliga rättigheterna. Det kan också underlätta i konkurrensen om inflytande och marknader i exempelvis Afrika.</p>
<p>Det kinesiska kommunistpartiet bygger en del av sitt existensberättigande på historien om nationellt motstånd mot imperialism från Väst och Japan. Att det kan ha funnits imperialistiska inslag även i det kinesiska nationsbyggandet talas det mindre om. I det marxist-leninistiska tankegodset är det närmast per definition så att länder utanför Väst inte kan göra sig skyldiga till rasism eller imperialism. Det tycks alltså finnas en geopolitisk dimension bakom striden om historieskrivning.</p>
<p>Vad som står på spel, menar Biggar, är inte bara pedantiska frågor om förfluten tid, utan vår egen självbild och ställning i världspolitiken. Målet för attackerna är inte bara västländerna, utan i förlängningen den regelbaserade världsordningen. Dess universella anspråk och normer kan lättare ogiltigförklaras om dess västerländska ursprung höljs i misstankar.</p>
<h2>Låt inte vetenskapsmannen Carl von Linné bli värsta rasisten</h2>
<p>Kanske är Sverige inte i stormens öga på samma sätt som stormakterna.  Men ekon av den amerikanska debatten har märkts i det plötsligt uppflammande intresset för den svenska kolonin Saint Barthélemy<sup>10</sup> i Västindien, en handelsplats där även slavar köptes och såldes. Ett tydligare exempel på synbarligen politiskt influerad historieskrivning var Uppsala universitets upptäckt av att svenska vikingar kanske i själva verket var muslimer,<sup>11</sup> en nyhet som snabbt blev viral både i Sverige och internationellt – innan den så småningom ifrågasattes.<sup>12</sup> Den fram till nyligen så uppburne <strong>Carl von Linné </strong>blev i samband med Black Lives Matter-rörelsen utpekad som ”en av världshistoriens centrala, mest inflytelserika och viktigaste rasistiska ideologer”<sup>13</sup> – och hans staty i Lund vandaliserades.<sup>14</sup></p>
<blockquote><p>Slutsatsen blir därför: känn din historia.</p></blockquote>
<p>Vad är slutsatsen? Det finns naturligtvis inget alternativ för demokratiska stater till att låta diskussionen om historieskrivning och historisk skuld fortgå. Kritisk debatt är en del av ett öppet samhälle. För tydlighetens skull: Det finns ingenting konstigt i att undersöka hur Linnés verk kan ha påverkat senare tiders socialdarwinism och rasbiologi. Men samtidigt vore det naivt att inte se de potentiella riskerna i trenden med ideologiserad historieskrivning. Alla öppna samhällen bör ha beredskap för att ompröva sin historia. (Rysslands lagstiftning om plikten att ”försvara historisk sanning” och ”skydda minnet av det stora patriotiska kriget är förstås exempel på motsatsen.<sup>15</sup>) Men en del av de exempel som beskrivits ovan ger snarare intryck av förstörelselusta än vetenskaplig metod. Där den politiserade historieskrivningen breder ut sig, där försvinner utrymmet för nyans, kontext och eftertanke.</p>
<p>En medvetenhet om hur historierevisionism används i politiska syften kan stärka vårt psykologiska försvar mot yttre påverkan. Slutsatsen blir därför: känn din historia. Det är av mer än akademisk betydelse. Som författaren <strong>George Orwell</strong> sammanfattade saken i boken <em>1984</em>: ”Den som kontrollerar det förflutna kontrollerar framtiden; den som kontrollerar nutiden kontrollerar det förflutna”.<sup>16</sup></p>
<p><a href="#_ftnref1" name="_ftn1"></a></p>
<div class="notes-wrapper"><a class="shadow-button noselect show-notes"  data-articleid="90311">  <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>
<p>1, https://kvartal.se/artiklar/fakta-om-putins-ansprak-pa-ukraina/</p>
<p>2, Enkelt uttryckt: global frihandel, demokrati som norm, och de regelsättande internationella samarbetsorgan som uppstod under 1800-talet och efter andra världskrigets slut.</p>
<p>3, <a href="https://www.aier.org/article/the-1619-project-a-critique/amp/">https://www.americanrevolutioninstitute.org/fatal-flaw-of-the-1619-project-curriculum/</a></p>
<p>4, https://www.nytimes.com/2019/12/20/magazine/we-respond-to-the-historians-who-critiqued-the-1619-project.html</p>
<p>5, https://www.independent.org/news/article.asp?id=14101</p>
<p>6, https://www.spectator.co.uk/article/was-winston-churchill-a-racist-a-look-at-the-evidence/</p>
<p>7, https://compactmag.com/article/anatomy-of-a-book-cancellation</p>
<p>8, https://quillette.com/2023/02/06/colonialism-and-its-discontents/</p>
<p>9, https://compactmag.com/article/anatomy-of-a-book-cancellation</p>
<p>10, https://www.dagensarena.se/essa/den-svenska-slavhamnen/</p>
<p>11, https://www.aftonbladet.se/nyheter/a/Ow1eA/ovantade-fyndet&#8211;vikingar-kan-ha-akallat-allah-som-en-bon</p>
<p>12, https://sverigesradio.se/artikel/6801335</p>
<p>13, https://www.aftonbladet.se/kultur/a/WbwrbK/med-carl-von-linne-foddes-den-moderna-rasismen</p>
<p>14, https://www.sydsvenskan.se/2020-06-23/klotter-pa-linnestatyn-vid-stadsbiblioteket</p>
<p>15, https://warontherocks.com/2023/03/imposing-the-past-putins-war-for-history/</p>
<p>16, https://www.thoughtco.com/what-does-that-quote-mean-archaeology-172300</p>
</div>
</div>
<div class="author-byline">
<div dir="auto">Johan Berglund arbetar på UD och ingår i projektgruppen för &#8221;Gustav Vasas intåg i Stockholm”. Denna text är skriven i egenskap av privatperson.</div>
</div>
</div>
