Moderaternas kulturkrig har börjat

<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-89655"      class = "kv-pod-holder kv-player-light  lplo " data-sid="" data-eid="" data-pid="89655" data-acurl="aHR0cHM6Ly9tZWRpYS5wb2Quc3BhY2Uva3ZhcnRhbC9pbmxhc3RfbW9kZXJhdGVybmFzX2t1bHR1cmtyaWdfaGFyX2JvcmphdC5tcDM=" data-psurl="aHR0cHM6Ly9tZWRpYS5wb2Quc3BhY2Uva2p4ajYzeWRkZXEydmgvbW9kZXJhdGVybmFzLWt1bHR1cmtyaWctaGFyLWJvcmphdC5tcDM=">  <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%2Fhar-moderaternas-kulturkrig-borjat%2F&amp;t=Moderaternas+kulturkrig+har+b%C3%B6rjat"    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=Moderaternas+kulturkrig+har+b%C3%B6rjat+-+https%3A%2F%2Fkvartal.se%2Fartiklar%2Fhar-moderaternas-kulturkrig-borjat%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%2Fhar-moderaternas-kulturkrig-borjat%2F"    target = "_blank"    class  = "li-link"    title  = "Dela på LinkedIn"><i class="ti-linkedin ui transparent"></i></a><a href    = "mailto:?subject=Moderaternas kulturkrig har börjat&body=https://kvartal.se/artiklar/har-moderaternas-kulturkrig-borjat/"   target  = "_blank"    class   = "pr-link"    title   = "E-posta"    onclick = ""><i class="ti-email ui transparent"></i></a><a href    = "https://kvartal.se/skriv-ut/89655/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/89655/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/2024/07/Ola_lowres2.jpg');"></div><img class="author-print-img" src="https://kvartal.se/wp-content/uploads/2024/07/Ola_lowres2.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> | 11 mars 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%2Fhar-moderaternas-kulturkrig-borjat%2F&amp;t=Moderaternas+kulturkrig+har+b%C3%B6rjat"    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=Moderaternas+kulturkrig+har+b%C3%B6rjat+-+https%3A%2F%2Fkvartal.se%2Fartiklar%2Fhar-moderaternas-kulturkrig-borjat%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%2Fhar-moderaternas-kulturkrig-borjat%2F"    target = "_blank"    class  = "li-link"    title  = "Dela på LinkedIn"><i class="ti-linkedin ui transparent"></i></a><a href    = "mailto:?subject=Moderaternas kulturkrig har börjat&body=https://kvartal.se/artiklar/har-moderaternas-kulturkrig-borjat/"   target  = "_blank"    class   = "pr-link"    title   = "E-posta"    onclick = ""><i class="ti-email ui transparent"></i></a><a href    = "https://kvartal.se/skriv-ut/89655/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/89655/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/har-moderaternas-kulturkrig-borjat/?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 6 min</span></a><a href   = "https://kvartal.se/skarmlasarvanlig/89655"    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-89655">  <div class="in-short-inner">    <span class="close_button close-in-short in-short-toggle" data-articleid = "89655"></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 ">Kulturministern <strong>Parisa Liljestrands</strong> statssekreterare <strong>Karin Svanborg-Sjövall</strong> skrev nyligen en essä i <em><a href="https://www.axess.se/artiklar/dags-att-tanka-nytt/">Axess magasin</a> </em>med rubriken <em>Dags att tänka nytt i kulturpolitiken</em>.</p>
</div>
<div class="rest-of-article ">
<p>Essän kan läsas som ett stridsrop för ett uppbiffat kulturdepartement som ska utmana det rådande kulturradikala paradigmet. Hon efterlyser ett perspektiv som ”länge har ansetts föga salongsmässigt, nämligen att kultur inte bara är ett verktyg för provokation och för ifrågasättande. Utan också något som kan skapa sammanhållning, gemenskap och motståndskraft i ett samhälle som utsätts för olika typer av påfrestningar”. Men hur nytänkande är det egentligen? Det var trots allt <strong>Alice Bah Kuhnke</strong> (MP) som lade fram propositionen ”Kulturarvspolitik för ett Sverige som håller ihop” och mässade om armlängds avstånd, och det var den dåvarande borgerliga alliansen som röstade ja till den propositionen och anklagade Kuhnke för att inte leva upp till sistnämnda princip. För att vara övertydlig: Det är inte särskilt nytänkande att vilja använda kulturen och kulturarvet för att skapa sammanhållning – bägge sidor av politiken har velat det i många år nu. Man har bara olika åsikter om vilken sorts sammanhållning som kulturutövarna borde skapa.</p>
<h2>Om Europa är en hand så är Frankrike långfingret</h2>
<p>Statssekreteraren, som tidigare var vd för näringslivets tankesmedja Timbro, lyfter fram Frankrike i sin essä, vilket är lite udda. Vad man än kan säga om detta imponerande kulturland så är inte gemenskap ordet man brukar beskriva det med. Kanske för att det hela tiden varit bortom kulturdepartementets förmåga. Det hjälper inte att presidenter sedan <strong>François Mitterrands</strong> dagar lanserat program för att skapa sammanhållning – eller att ”fosterlandet hyllar sina stora män. Och kvinnor”, som Svanborg-Sjövall skriver gillande. Frankrike är präglat av kravaller och sarkastiska kulturkritiker ändå, från <strong>Focault</strong> till <strong>Hollebecque</strong>. Det omhuldade arvet från stora fritänkande filosofer har däremot format fransmännen i <em>un esprit critique</em>, som har samma effekt på sammanhållning och optimism som ett varmbad för en sockerbit.</p>
<p>Vad Frankrike odiskutabelt har däremot är statlig <a href="https://www.bruegel.org/comment/frances-institutional-system-favours-rebellion-against-its-leader">övercentraliserad</a> elefantiasis i politiken.</p>
<blockquote><p>Det verkligt intressanta är hur hon attackerar kultursamverkansmodellen.</p></blockquote>
<p>Svanborg-Sjövall kritiserar Miljöpartiet för att plötsligt låta som <em>laissez-faire</em>-förespråkare och menar att talet om armlängds avstånd har blivit en metod för att upprätthålla status quo.</p>
<p>Det finns en sanning i det, men det vore olyckligt om den borgerliga regeringen ger efter för den svenska ryggmärgsreflexen att följa Uppsala universitets tankehämmande devis ”Tänka fritt är stort men tänka rätt är större”. Alternativet är inte att försöka fostra en generation av nickedockor till den sittande regeringens samhällsvision, tendenser som Kuhnke fick kritik för (bland annat av undertecknad).</p>
<p>Karin Svanborg-Sjövall verkar hur som helst vilja vända blad från det hon dömer ut som borgerlig ”antipolitik”. Man får anta att hon syftar på <strong>Lena Adelsohn-Liljeroths</strong> (M) tid som kulturminister eller när den progressive <strong>Olov Lavesson</strong> var Moderaternas kultur- och HBTQ-politiske talesperson (Lavesson är idag kommunikationschef på Postkodslotteriet).</p>
<p>Det verkligt intressanta är hur Svanborg-Sjövall attackerar kultursamverkansmodellen. Den framställs som ett hinder för det i hennes ögon underdimensionerade kulturdepartementet i Stockholm.</p>
<p>Det var moderaten Adelsohn-Liljeroth, som en gång i tiden var med och genomdrev kultursamverkansmodellen. Staten gav därmed bort en stor del av sin makt att fördela resurser i kulturen till regionerna och lokala samarbeten. Syftet var att kulturen skulle komma närmare medborgarna. Vill Svanborg-Sjövall ersätta den med en ny och statlig kulturbyråkrati?  Den 24 mars har kulturrådet en samverkanskonferens och statssekreteraren ska hålla tal. Då blir det kanske tydligare för de inblandade vad hon menar med ”legitim demokratisk styrning” och att ”städa upp” i kulturbyråkratin, säger en källa till mig.</p>
<h2>Andra vägar för en friare, starkare kultur</h2>
<p>Om regeringen vill göra en bestående insats för en fri och stark kultur så finns det andra vägar att gå som inte nämns i essän. Börja med det utdömda systemet med marknadshyror, där staten leker marknad och svälter ut sin egen verksamhet i statligt ägda kulturfastigheter och museer.<sup>1</sup> Det senaste exemplet är hur musikverksamheten på Musikaliska, Sveriges äldsta konsertverksamhet, riskerar att läggas ner efter att Statens fastighetsverk chockhöjt hyrorna. Stockholm har blivit en musikscenernas katastrof, ingen storstad i Norden har så få spelställen för fria kulturutövare, skriver bland andra hovsångaren<strong> Anne Sofie von Otter</strong> och artisten <strong>Lisa Nilsson</strong> i ett upprop i Expressen.<sup>2</sup></p>
<p>Eller som dramatikern <strong>Stina Oscarson</strong> efterlyst: Värna billiga lokaler där artister kan skapa oavhängiga av politiker och mecenater – i stil med det myllrande ateljékollektivet Platform som har rivningskontrakt i Färgfabriken Beckers gamla lokaler på Liljeholmen i Stockholm. Marknadshyror och lokaler nämns dock inte i <em>Axess</em>-essän. Inte heller de ständigt växande HR-avdelningarna som har starkt bidragit till både att normalisera och förstärka en styrning med ideologiska förtecken på landets kulturbärande institutioner. Där sakkunskapen trängs ner och kan bli behandlad som ett särintresse.</p>
<p>Visst finns det ett behov av en kulturminister som inte är rädd för att tala om kostnader, eller om värdet av kultur – även den svenska. Det är talande att när <a href="https://www.gso.se/upptack/press/#/pressreleases/goeteborgs-symfoniker-saetter-klassisk-touch-paa-ordfoerandeskapet-i-eu-3229564">Göteborgssymfonikerna</a> ska gästspela i Bryssel i samband med det svenska ordförandeskapet för EU så kommer de inte att spela ett enda svenskkomponerat verk. Det låter som ett litet eko från tiden då <strong>Fredrik Reinfeldt</strong> (M) sade att ”Ursvenskt är bara barbariet”.</p>
<h2>Bildning handlar om att bli någon, inte något</h2>
<p>I ett litet språkområde som det svenska gör kulturpolitik det möjligt för landet att boxas över sin viktklass. Svanborg-Sjövall skriver optimistiskt att det ser ljust ut för ett mindre bidragsberoende kulturliv eftersom framtidens börshajar troligen kommer att vara kulturellt bevandrade. Frågan är hur det rimmar med en skola där kultur, och estetiska ämnen är nedmonterade.<sup>3</sup> Bildning, sägs det ibland, handlar om att bli någon, inte bara något. Bildning gör inte människan nödvändigtvis god eller lycklig, men ofta mer intressant.</p>
<p>Det är glädjande att Svanborg-Sjövall vill uppvärdera klassisk bildning och att hon vill se över utformningen av bidragsblanketter. Problemet med blanketterna är inte bara kryssrutorna för vilka värderingar som kulturprojektet ska stötta utan att staten återigen leker marknad. Kulturutövare ska helst veta exakt vilka som är målgrupp och hur den färdiga produkten ska se ut innan arbetet ens har börjat. Det uppmuntrar till produktion av förutsägbar kultur.</p>
<p>Regeringen borde också damma av begrepp som sakkunskap och kvalitet. Det vore mer nytänkande än statlig kulturpolitik för nationell sammanhållning.</p>
<p>Man kan dock notera att det var de gamla 68-radikalerna på läroverken som var den sista generationen som fick åtnjuta en klassisk bildning. Resultatet blev det Svanborg-Sjövall kritiserar: mer än ett halvt sekel av provokation och ifrågasättande från kulturvärlden.</p>
<div class="notes-wrapper"><a class="shadow-button noselect show-notes"  data-articleid="89655">  <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, Systemet med marknadshyror för kulturinstitutionerna har kritiserats sedan den statliga fastighetsreformen genomfördes 1993 och man har lappat och lagat i systemet utan att åtgärda grundproblemet. I oktober år 2000 publicerades rapporten ”Leka Marknad” skriven av <strong>Lena Svanberg</strong> vid ESO, Expertgruppen för studier i offentlig ekonomi. Rapporten innehöll omfattande kritik mot Statens fastighetsverk och den hyressättningsprincip som tillämpades för ändamålsfastigheter. Kritiken låg huvudsakligen i att marknadsekonomiska principer inte kunde användas för objekt där hyresgästen saknar alternativ och för vilka det därmed inte existerar någon marknad.  Till kritikerna hör numera även Olle Wästberg som var arkitekten bakom systemet, se: https://www.svt.se/kultur/marknadshyror-for-museerna-kritiseras-av-mannen-bakom-systemet</p>
<p>Debatten om hur musikverksamheten hotas på Musikaliska kan läsas om här: https://imusiken.se/2023/02/03/ska-statens-marknadshyror-tysta-musiken-i-musikaliska/ https://www.expressen.se/debatt/musikaliska-kvarteret&#8211;ar-hotat-av-byrakrater/</p>
<p>https://www.sfv.se/media/wksb2wzg/statens-fastighetsverk-%C3%A5rsredovisning-2021.pdf</p>
<p>2, https://www.expressen.se/debatt/musikaliska-kvarteret&#8211;ar-hotat-av-byrakrater/</p>
<p>3, Läsningen i svensk skola minskar drastiskt. 50 procent av eleverna i årskurs nio läser inte ens en sida sammanhängande facklitteratur på papper eller skärm en vanlig skoldag, 2007 var motsvarande siffra 33 procent. Den främsta orsaken till den minimala lästiden i skolan är att lärare upplever att det inte finns utrymme för läsning. Man känner press att träna eleverna inför allt som ska bedömas, exempelvis de nationella proven, rapporterar ämnesläraren och refererar till en studie som utförts av Mats Tegmark, lektor i pedagogiskt arbete, och hans kollegor vid Högskolan Dalarna. https://www.vilarare.se/amneslararen-svenska-sprak/lasinlarning/drastiskt-ras-for-lasningen-i-skolan/</p>
<p>Undervisningen i kultur och estetiska ämnen har minskat kraftigt i skolan. Praktisk-estetiska ämnen som bild fylls dessutom fyllts på alltmer med teoretiskt innehåll. https://www.vilarare.se/praktisk-estetiska-amnen/kursplaner/allt-fokus-pa-teori-slar-ut-elever/</p>
</div>
</div>
<div class="author-byline">Ola Wong är Kvartals kulturredaktör, Kina-kännare och författare.
</div>
</div>
