I korthet
Frågan är nu: förkommer cancelleringar vid svenska universitet? Jag hävdar att de förekommer och att de gör de i en oacceptabel omfattning. För att hävda detta använder jag mig av ett antal fall som uppfyller kraven som tidigare angivits för att kalla något en cancellering.
<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-85532"      class = "kv-pod-holder kv-player-light  lplo " data-sid="" data-eid="" data-pid="85532" data-acurl="aHR0cHM6Ly9tZWRpYS5wb2Quc3BhY2Uva3ZhcnRhbC9pbmxhc3RfY2FuY2Vsa3VsdHVyZW5fbGV2ZXJfZGVsXzIubXAz" data-psurl="aHR0cHM6Ly9tZWRpYS5wb2Quc3BhY2Uva2p4ajYzeWRkZXEydmgvY2FuY2Vsa3VsdHVyZW4tbGV2ZXItZGVsLTIubXAz">  <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/sten-widmalm/">Sten&nbsp;Widmalm</a> | 24 januari 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%2Fcancelkulturen-lever-del-2%2F&amp;t=Cancelkulturen+lever%2C+del+2"    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=Cancelkulturen+lever%2C+del+2+-+https%3A%2F%2Fkvartal.se%2Fartiklar%2Fcancelkulturen-lever-del-2%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%2Fcancelkulturen-lever-del-2%2F"    target = "_blank"    class  = "li-link"    title  = "Dela på LinkedIn"><i class="ti-linkedin ui transparent"></i></a><a href    = "mailto:?subject=Cancelkulturen lever, del 2&body=https://kvartal.se/artiklar/cancelkulturen-lever-del-2/"   target  = "_blank"    class   = "pr-link"    title   = "E-posta"    onclick = ""><i class="ti-email ui transparent"></i></a><a href    = "https://kvartal.se/skriv-ut/85532/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/85532/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 author-section-external">  <div class="author-section-inner">    <div class="author-image-holder"><span class="icon-kvartal-hare"></span>    </div>    <div class="by-disclaimer-holder" style="color: #8a3a67">Eventuella åsikter och slutsatser i texten är skribentens egna.    </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%2Fcancelkulturen-lever-del-2%2F&amp;t=Cancelkulturen+lever%2C+del+2"    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=Cancelkulturen+lever%2C+del+2+-+https%3A%2F%2Fkvartal.se%2Fartiklar%2Fcancelkulturen-lever-del-2%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%2Fcancelkulturen-lever-del-2%2F"    target = "_blank"    class  = "li-link"    title  = "Dela på LinkedIn"><i class="ti-linkedin ui transparent"></i></a><a href    = "mailto:?subject=Cancelkulturen lever, del 2&body=https://kvartal.se/artiklar/cancelkulturen-lever-del-2/"   target  = "_blank"    class   = "pr-link"    title   = "E-posta"    onclick = ""><i class="ti-email ui transparent"></i></a><a href    = "https://kvartal.se/skriv-ut/85532/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/85532/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/cancelkulturen-lever-del-2/?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 10 min</span></a><a href   = "https://kvartal.se/skarmlasarvanlig/85532"    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-85532">  <div class="in-short-inner">    <span class="close_button close-in-short in-short-toggle" data-articleid = "85532"></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 ">Frågan är nu: förkommer cancelleringar vid svenska universitet? Jag hävdar att de förekommer och att de gör de i en oacceptabel omfattning. För att hävda detta använder jag mig av ett antal fall som uppfyller kraven som <a href="https://kvartal.se/artiklar/cancelkulturen-lever-del-1/">tidigare</a> angivits för att kalla något en cancellering.</p>
</div>
<div class="rest-of-article ">
<p>Av utrymmesskäl kan inte alla detaljer i varje fall anges. Men angivna länkar går till mer detaljerade beskrivningar. Här bör även något om mörkertal sägas. Fallen med <strong>Inga-Lill </strong><a href="https://universitetslararen.se/2020/03/05/debatt-om-ordens-frihet-lockade-storpublik-i-uppsala/"><strong>Aronsson</strong></a> och <strong>Sara <a href="https://volante.se/bocker/hela-havet-stormar/">Kristoffersson</a> </strong>är de kanske mest kända just nu efter Kalla Faktas granskning. <span lang="SV">Men det var inte så att </span>Kalla Fakta <span lang="SV">bara fokuserade på </span>dessa fall för att det råder brist på cancelleringar. De togs upp främst på grund av att Aronsson och Kristoffersson var villiga att tala öppet om vad de utsatts för.</p>
<p>Under de senaste tio åren har jag kommit i kontakt med kolleger som blivit cancellerade men som inte gått vidare med sina fall för att få upprättelse eftersom de inte orkar eller vågar prata om vad som hänt. Man kan jämföra med situationen för individer som utsatts för andra slags brott. Därför syns inte alla fall. Men trots det så finns det fler cancelleringsfall än Kristoffersson och Aronsson som har blivit offentliga.</p>
<p><strong>Johan Grant</strong>, psykolog och lektor vid Lunds universitet, höll en kurs där ett moment som kallades externatet syftade till att studera gruppdynamik och till att, bland annat, diskutera ”feminint kodade ideal” och maskulinitet. Några studenter klagade på innehållet i kursen och på det sätt könsroller diskuterats. Det ledde till att <a href="https://psykologtidningen.se/2020/01/30/larare-sparkas-efter-studentprotester/">Grant sparkades</a> från programmet där hans kurs ingått.</p>
<blockquote><p>Studenter som hade valt att delta i kursen tog anstöt av bilderna som användes för att illustrera fenomenet.</p></blockquote>
<p><strong>Erik Ringmar</strong>, lektor i statskunskap vid Lunds universitet höll en kurs vars <a href="http://tidskriftenrespons.se/recension/universitetsdebatt-praglas-ofta-av-kulturkrigsretorik/">kurslitteraturlista</a> av logiska skäl inte kunde balanseras ur ett könsperspektiv. <a href="https://timbro.se/forlag/befria-universiteten-om-akademisk-frihet-och-statlig-styrning/">Ringmar</a> har länge varit känd som en person som inte gärna följer med strömmen i akademiska debatter. Men nu gick han tydligen för långt. Klagomålen mot honom gjorde till slut att han sade upp sig.</p>
<p>Ett liknande mönster upprepade sig för <strong>Germund Hesslow</strong>, professor i neurofysiologi vid Lunds universitet, som vid läkarprogrammet föreläste om ”arv och miljö” och  <a href="https://www.lundagard.se/2018/11/13/professorn-och-kontroverserna/">skillnader mellan män och kvinnor</a>. Hesslow <a href="https://www.dn.se/ledare/nathan-shachar-inkvisitionen-mot-professorn-i-lund-skadar-studenterna/">anmäldes av en student</a> som hävdade att hans agerande stred mot likabehandlingsplanerna vid universitetet. En diskrimineringsutredning genomfördes, på uppdrag av dåvarande dekan för medicinska fakulteten, <strong>Erik Renström</strong>. Utredningen, som i och för sig inte kunde klandra Hesslow för diskriminering, angav att det ändå fanns ”risk för diskriminering”. Som <a href="https://academicrightswatch.se/?p=3502">Academic Rights Watch (ARW) i Lund visar med citat från utredningen</a> så rekommenderas fakulteten att vidta ”de förebyggande och främjande åtgärder som skäligen kan krävas för att minska risken för diskriminering”. Att Hesslow förtalats och hängts ut var inte relevant i sammanhanget.</p>
<p>Dessa fall har alltså skett bara vid Lunds universitet där rektor Erik Renström främst är oroad för att en utredning om cancelkultur kan leda till ”en auktoritär syn, där man säger att studenterna bara ska hålla käft och lyssna på lärarna”.</p>
<p>Rör vi oss bara en liten bit sydväst från Lund så kan fallet med <strong>Mariah Larsson</strong>, professor i filmvetenskap, nämnas. Hon undervisade i en kurs i sexologi vid Malmö universitet om rasistiska sexuella stereotyper. Studenter som hade valt att delta i kursen tog anstöt av bilderna som användes för att illustrera fenomenet. Kursen hade redan kritiserats för att <a href="https://www.sydsvenskan.se/2021-03-16/jag-ska-formedla-kunskap-inte-skydda-studenter-fran-obehag">inte tillräckligt tillämpa normkritiska och postkoloniala perspektiv</a>. Nu anklagades Larsson för att vara rasist. Just detta exempel är unikt eftersom Larsson försvarades av rektorerna <strong>Kerstin Tham</strong> vid Malmös universitet, och Erik Renström vid Lunds universitet (<a href="https://www.lundagard.se/2021/03/23/braket-vid-malmo-universitet-rasism-och-akademisk-frihet/">Sydsvenskan, 23/3 2021</a>). Ett och ett halvt år före <strong>Mats Perssons</strong> förslag gjorde alltså Renström ett viktigt ställningstagande för den akademiska friheten – trots att till exempel dåvarande projektledare för World Pride i Malmö hotade med att bryta sitt samarbete med Malmö universitet på grund av kritik som riktats mot sexologiprogrammet.</p>
<p>Hela historien är rätt så komplicerad och har beskrivits under längre tid av ARW i Lund. Den handlar nämligen även om studenter som agerat för att få bort lärarna <strong>Aje Carlbom</strong> och <strong>Sara Johnsdotter</strong> från kursen. Carlbom har kritiserats för att hans skrifter citerats i ”högerpublikationer” (<a href="https://academicrightswatch.se/?p=4632">ARW, 14/5 2021</a>). Klagomål från studenterna om att detta skapat ”minoritetsstress och otrygghet” (<a href="https://www.sydsvenskan.se/2021-02-24/pa-vems-bekostnad-tar-man-sig-ratten-att-chockera-och-skada-med-rasism">Sydsvenskan 24/2 20231</a>) ledde till en utredning av en universitetsjurist vid Universitetskansliet vid Malmö universitet. Att läsa utredningen är nedslående.</p>
<h2>Inga allvarliga fel</h2>
<p>Inte för att föreläsarna kan anses ha begått några allvarliga fel. Det som är oroande och som framkommer är hur studenterna använder institutioner som ska skydda mot trakasserier för att trakassera enskilda lärare. Utredaren ställer sig dessutom bakom flera delar av kritiken och uppmanar ledningen att upplysa sig, ge kurser, dra upp nya ”riktlinjer och rutiner” och att genomlysa programmet för att upptäcka risker. Dessutom dras slutsatsen att ”vid alla nyanställningar bör högskolepedagogiska kurser om <em>inclusion</em> och <em>widening participation</em> samt normmedveten undervisning framhållas.”</p>
<p>Detta var några fall. Det finns tyvärr fler. Det har faktiskt hållit på så här i tilltagande omfattning ända sedan början av 2000-talet då statsvetaren <strong>Anders Westholm</strong> fick avgå som huvudsekreterare för den integrationspolitiska maktutredningen. Forskarkolleger hittade på att Westholm var rasist och sedan baktalade de honom för dåvarande integrationsministern <strong>Mona Sahlin</strong>. Forskare och företrädare för frivilligorganisationer från flera delar av Sverige anslöt till drevet mot Westholm. Det som hände är känt och väldokumenterat (Axess, 5/2004, <a href="http://tidskriftenrespons.se/artikel/de-integrationspolitiska-utredningarna-som-kulturkrig/">Respons 6/2019</a>, <a href="https://kvartal.se/artiklar/integrationsutredningen-revisited/">Kvartal 14/6 2022</a>).</p>
<p>Westholm fick avgå från utredaruppdraget på grund av lögner från akademiker som samvetslöst utnyttjade viktiga frågeområden som handlar om diskriminering för att sätta dit helt oskyldiga forskare. Fler fall? <strong>Fredrik Svenaeus</strong>, professor i filosofi vid Södertörns högskola, <a href="https://www.svd.se/a/mBl9Lq/jag-hade-passerat-en-grans-min-bok-var-inte-anstandig">utsattes för sådant som sker i en cancelkultur</a> när han skrev om metoo och könsidentitet. Bland annat agerade en kollega, en professor i genusvetenskap, för att hans inbjudan till en föreläsning i <a href="https://www.svd.se/a/Vb2RE3/med-genusprofessorns-mejl-borjar-skvallret-ga-inte">Berlin skulle dras tillbaka</a>.</p>
<p>Det är möjligt att hävda att idéhistorikern <strong>Tony Gustavsson</strong> som intervjuades i <a href="https://kvartal.se/artiklar/jag-kan-bega-akademisk-harakiri/">Fredagsintervjun</a> för ett år sedan, blev cancellerad när han skulle skriva Sverigedemokraternas vitbok. När <strong>Per Brinkemo</strong> och <strong>Johan Lundberg</strong> som redaktörer publicerade antologin <em>Klanen</em> och Brinkemo skrev <em>Mellan klan och stat</em>, så utsattes de för kritik med syftet att få dem <a href="https://www.expressen.se/ledare/patrik-kronqvist/anklagelserna-om-rasism-ar-befangda-asa-linderborg-/">cancellerade</a>. Deras arbeten beskrevs som <a href="https://www.aftonbladet.se/kultur/bokrecensioner/a/wE2284/ar-klansamhallet-ett-hot-mot-staten">rasistiska och främlingsfientlig</a>a. Brinkemos monografi påstods ha skrivits med <a href="https://www.expressen.se/kultur/bocker/med-koloniala-ogon/">koloniala ögon</a>.</p>
<h2>Att tiga ihjäl en publikation</h2>
<p>Cancelleringsförsöken har även omfattat <strong>Ivar Arpi</strong> och <strong>Anna-Karin Wyndhamn</strong> efter publiceringen av boken <em>Genusdoktrinen</em>. Genusforskare vid Stockholms universitet uppmanades att tiga ihjäl publikationen för att underminera deras plattform – utfrysning med andra ord. Detta <a href="https://ivararpi.substack.com/p/i-sverige-tigs-oliktankande-ihjal">agerande beskrivs av Ivar Arpi</a> som tar upp detta och flera fall som kan beskrivas som cancelleringar. Och på den vägen har det som sagt fortsatt. Det handlar ofta om anklagelser om rasism eller att någon anses ha misogyna åsikter. Men inte alltid.</p>
<p><strong>Magnus Ranstorp</strong>, docent vid Försvarshögskolan, och hans kolleger utsätts kontinuerligt för falska beskyllningar om islamofobi. Anklagelserna har förts fram till chefer och i sociala medier och har inbegripit anklagelser om att <a href="https://www.expressen.se/debatt/tro-och-solidaritet-kollaborerar--med-qatar-och-turkiet/">Ranstorp är spion</a> (Expressen 12/11 2021). Bland annat har företrädare för organisationen Socialdemokrater för tro och solidaritet och den socialdemokratiska föreningen Hjärta legat bakom kampanjerna. Ranstorp och flera av hans kolleger har även kritiserats för islamofobi i andra sammanhang. Under hösten 2022 publicerades ”European Islamophobia Report 2022”. Till den bidrog författare engagerade av Centrum för mångvetenskaplig forskning om rasism (CEMFOR) vid Uppsala universitet. Hela myndigheter, politiker och forskare i Sverige pekas där ut som verksamma i ett islamofobiskt nätverk – ett tydligt och väldokumenterat uttryck för en cancelkultur. Rapporten gavs ut av den Erdoğan-vänliga turkiska tankesmedjan Seta (<a href="https://doku.nu/2022/09/25/svenska-aktivister-som-gar-erdogans-arenden/">Sandelin, Doku, 25/10-22</a>).</p>
<blockquote><p>Den som inte vill rätta sig efter normgardisterna är rättslös, lovligt byte för mobbarna&#8230;</p></blockquote>
<p>Här handlar det om fall som fått stor uppmärksamhet i medier som knappast kan ha passerat förbi obemärkt för dem som i debatten hävdar att cancellering mot akademiker inte förekommer. För övrigt har cancelleringskampanjer där forskare pekas ut som spioner blivit vanligare. Utöver Ranstorp har liknande anklagelser riktats mot forskarna <strong>Sameh Egyptson</strong> (i sociala medier), <strong>Martin Kragh</strong> (<a href="https://www.aftonbladet.se/kultur/a/0E1nm6/martin-kragh-ar-ett-demokratiskt-problem">Aftonbladet, 21/2 2019</a>) och <strong><a href="https://www.svd.se/a/kEM4J9/klent-forsvar-for-det-fria-ordet" target="_blank" rel="noopener" data-saferedirecturl="https://www.google.com/url?q=https://www.svd.se/a/kEM4J9/klent-forsvar-for-det-fria-ordet&amp;source=gmail&amp;ust=1674570655660000&amp;usg=AOvVaw0oh4BaQ-Nt9EItmaX5nu57">Rouzbeh Parsi </a></strong>(<span lang="SV">bland annat i </span>sociala medier) när de uttryckt ståndpunkter som ogillats. Att någon säger något som väcker anstöt, eller till exempel låter bli att kritisera en regim är en sak. Men går det över till spionanklagelser så krävs det helt enkelt bevis.</p>
<p>I sammanhanget är det även värt att nämna att covidpandemin satte fart på hätska utfall i debatter som gav uttryck för en cancelkultur. Till exempel arbetade <a href="https://sverigesradio.se/artikel/dold-facebookgrupp-forsoker-paverka-svenska-intressen-utomlands">Media Watchdogs of Sweden</a> (Mewas) i Sverige just med strategin att cancellera meningsmotståndare. Genom samverkan i en sluten Facebookgrupp genomfördes kampanjer mot forskare och tjänstemän i förvaltningen som bland annat fick barnläkaren och <a href="https://www.svd.se/a/X8r6oW/efter-covidhatet-vill-ha-tillbaka-mitt-gamla-liv">professorn <strong>Jonas Ludvigsson</strong></a> att sluta forska om covid.</p>
<p>Här kan nämnas att under covidpandemin, och efter att attackerna mot Ludvigsson blev ett uppmärksammat problem så skrev Demker “Att akademisk frihet som princip skrivs in i högskolelagen är brådskande menar regeringen, och den bedömningen är vi nog många som kan skriva under på. Debatten om covid-19 och politiska åtgärder i medicinska frågor har blivit så hätsk att forskare säger sig nu sluta med forskning om ett visst område.” (<a href="https://humfakdekan.blogg.gu.se/2021/02/26/akademisk-frihet-far-skydd-men-regeringens-kontrollmani-kunde-vi-vara-utan/" target="_blank" rel="noopener" data-saferedirecturl="https://www.google.com/url?q=https://humfakdekan.blogg.gu.se/tag/kollegialitet/&amp;source=gmail&amp;ust=1674554643282000&amp;usg=AOvVaw1J_pjfBfiTYoLCAJY9TrGr">26/2 2021, Dekanblogg</a>) Två år och ett regeringsskifte senare så har Demker bytt ståndpunkt. Den som nu säger att det finns en cancelkultur är ”högerpopulist”.</p>
<p>Det finns tyvärr fler exempel på cancelleringar inom akademin. Men av utrymmesskäl måste det få räcka nu. Jag kan inte bedöma hur pass utbrett fenomenet är. Men utgår vi från definitionen av cancellering och cancelkultur som här har angivits, så existerar fenomenet i Sverige. Och debatten om fenomenet omfattar avsevärt fler än bara fallen Aronsson och Kristoffersson. Exemplen som här tas upp är tillräckligt många och graverande för att motivera att Persson bör göra en undersökning. Det räcker egentligen bara med några enstaka fall av cancelleringar inom akademin för att utgöra ett allvarligt problem.</p>
<p>Att individer blir cancellerade, och när kolleger och chefer då reflexmässigt ställer sig på åklagarens sida, kan släcka ner den akademiska friheten för alla. Det räcker ju med endast ett fall som Kristoffersson eller Aronsson för att alla i organisationen ska nås av budskapet: den som inte vill rätta sig efter normgardisterna är rättslös, lovligt byte för mobbarna och de anklagade kommer att få ett hårt straff. Detta är också en form av normstyrning i förvaltningen. Oavsett vad till exempel <strong>Åsa Arping</strong> säger så förmår uppenbarligen inte universitet och högskolor att reformera sig själva för att stoppa sådana företeelser.</p>
<p>Så vem ska då ta tag i problemet?</p>
<h2>Aktörer med vänsterextrema sympatier</h2>
<p>Men hur är det med motiven då? Just nu kan vi se att cancelleringar bland annat drivs fram av aktörer med tydliga vänsterextrema sympatier, de som företräder identitetspolitiska rörelser, ”avkolonisering” och kritiska studier – det som <em>New Discourses</em> beskriver som <a href="https://newdiscourses.com/about/">“Critical Social Justice”</a>-rörelsen. Deras grundläggande gemensamma teoretiska bas innehåller tydliga arv från marxismen. Och det är från sådana håll som protesterna mot Perssons planerade undersökning är som starkast. Det är inte förvånande att fenomenet beskrivs i <em>Social Justice Encyclopedia</em> som att det har <a href="https://newdiscourses.com/tftw-cancel-culture/">maoistiska övertoner</a>. Lögner, de offentliga uthängningarna, utfrysningar och det verbala bespottandet spelar en viktig roll. Men här bör man tillägga att fenomenen i sig inte bör kategoriseras som <em>enbart</em> vänsterfenomen.</p>
<blockquote><p>Vill vi bekämpa cancelkulturen så måste vi alla, helst samtidigt, vara beredda att lägga ifrån oss det vapnet snarast. Alla vinner på det.</p></blockquote>
<p>Antisemitismen har historiskt bedrivits via cancelleringskampanjer i en stark cancelkultur. Extremhögern har anammat strategin mot feminister, invandrare och muslimer i synnerhet. Miljörörelsen drar i samma riktning med sina ”name and shame”-kampanjer. Religiösa extremister attackerar dem som försvarar sekularismen och tryckfriheten med falska anklagelser om fobier och rasism. Anledningen till att vänstern och identitetspolitiska aktörer (om dessa förenklande benämningar kan tillåtas) reagerar kraftigt just nu, är att deras hegemoniska position (för att tala med <strong>Antonio Gramsci</strong>) i akademin och förvaltningen ifrågasätts. Det är inte för att cancelkulturen inte existerar.</p>
<p>Men i akademin har vi ett gemensamt intresse att bekämpa företeelsen. Den fungerar ju som kemisk krigföring och tar kål på alla till slut. Vill vi bekämpa cancelkulturen så måste vi alla, helst samtidigt, vara beredda att lägga ifrån oss det vapnet snarast. Alla vinner på det. Det måste ersättas av ett kontrakt om att bedriva dialoger på rationell grund där de sakliga argumenten får stå i fokus. Detta är ingen lätt sak. Jag tror att inom akademin kommer företeelsen att vara kvar länge. Och det kommer då att leda till att universiteten och högskolorna förlorar mycket av sin legitimitet.</p>
<p><a href="https://www.regeringen.se/pressmeddelanden/2023/01/uka-ska-gora-fallstudier-om-akademisk-frihet/#:~:text=Regeringen%20ger%20Universitetskanslers%C3%A4mbetet%20(UK%C3%84)%20i,fritt%20kunskapss%C3%B6kande%20och%20fri%20kunskapsspridning.">Regeringen</a> har nu givit Universitetskanslerämbetet (UKÄ) i uppdrag att göra ”fallstudier om akademisk frihet”. Det kan bli en början på förändring i rätt riktning mot större öppenhet och som kan komma att minska förekomsten av cancelleringar.</p>
<p>Men <a href="https://kvartal.se/artiklar/ett-forskarsamhalle-som-blundar/">mycket </a>mer <a href="https://www.dn.se/debatt/byrakrati-och-etikregelverk-kvaver-den-fria-forskningen/">återstår </a>att <a href="https://www.dn.se/debatt/staten-ger-forskningsanslag-med-ena-handen-och-tar-tillbaka-med-den-andra/">göra</a> för Persson om han ska kunna återupprätta den akademiska friheten i Sverige.</p>
<div class="author-byline">Sten Widmalm är professor i statsvetenskap vid Uppsala universitet och forskar om demokrati och konflikter i jämförande perspektiv.
</div>
</div>
