Av Ola Wong | 30 september 2021
I korthet
Sveriges museers ordförande Niklas Cserhalmi ser sig tvingad att drämma i med grundlagen för att argumentera varför museerna inte ska göra det som står på deras skylt. För Östasiatiska museet är det Östasien, för Naturhistoriska är det naturhistoria. Ursäkta om jag blir tjatig, men det kan vara värt att påminna sig om det ibland. Cserhalmi invänder då att grundlagen säger att ”det allmänna” ska verka för värderingar som delaktighet, jämlikhet, hållbar utveckling och demokrati, och det ska museerna göra oavsett vad som står på skylten.
<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-52085"      class = "kv-pod-holder kv-player-light  lplo " data-sid="" data-eid="" data-pid="52085" data-acurl="aHR0cHM6Ly9tZWRpYS5wb2Quc3BhY2UvaW5sYXN0YXRleHRlci9oYXJfaHVtYW5pc21lbl9ibGl2aXRfZGVuX255ZV92aXRlX21hbm5lbi5tcDM=" data-psurl="">  <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-humanismen-blivit-den-nya-vita-mannen%2F&amp;t=Har+humanismen+blivit+den+nye+vite+mannen%3F"    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=Har+humanismen+blivit+den+nye+vite+mannen%3F+-+https%3A%2F%2Fkvartal.se%2Fartiklar%2Fhar-humanismen-blivit-den-nya-vita-mannen%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-humanismen-blivit-den-nya-vita-mannen%2F"    target = "_blank"    class  = "li-link"    title  = "Dela på LinkedIn"><i class="ti-linkedin ui transparent"></i></a><a href    = "mailto:?subject=Har humanismen blivit den nye vite mannen?&body=https://kvartal.se/artiklar/har-humanismen-blivit-den-nya-vita-mannen/"   target  = "_blank"    class   = "pr-link"    title   = "E-posta"    onclick = ""><i class="ti-email ui transparent"></i></a><a href    = "https://kvartal.se/skriv-ut/52085/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/52085/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> | 30 september 2021<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-humanismen-blivit-den-nya-vita-mannen%2F&amp;t=Har+humanismen+blivit+den+nye+vite+mannen%3F"    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=Har+humanismen+blivit+den+nye+vite+mannen%3F+-+https%3A%2F%2Fkvartal.se%2Fartiklar%2Fhar-humanismen-blivit-den-nya-vita-mannen%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-humanismen-blivit-den-nya-vita-mannen%2F"    target = "_blank"    class  = "li-link"    title  = "Dela på LinkedIn"><i class="ti-linkedin ui transparent"></i></a><a href    = "mailto:?subject=Har humanismen blivit den nye vite mannen?&body=https://kvartal.se/artiklar/har-humanismen-blivit-den-nya-vita-mannen/"   target  = "_blank"    class   = "pr-link"    title   = "E-posta"    onclick = ""><i class="ti-email ui transparent"></i></a><a href    = "https://kvartal.se/skriv-ut/52085/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/52085/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-humanismen-blivit-den-nya-vita-mannen/?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 11 min</span></a><a href   = "https://kvartal.se/skarmlasarvanlig/52085"    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-52085">  <div class="in-short-inner">    <span class="close_button close-in-short in-short-toggle" data-articleid = "52085"></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 ">Sveriges museers ordförande <strong>Niklas Cserhalmi</strong> ser sig tvingad att <a href="https://kvartal.se/artiklar/replik-wong-har-fel-om-museerna/">drämma i med grundlagen</a> för att argumentera varför museerna inte ska göra det som står på deras skylt. För Östasiatiska museet är det Östasien, för Naturhistoriska är det naturhistoria. Ursäkta om jag blir tjatig, men det kan vara värt att påminna sig om det ibland. Cserhalmi invänder då att grundlagen säger att ”det allmänna” ska verka för värderingar som delaktighet, jämlikhet, hållbar utveckling och demokrati, och det ska museerna göra oavsett vad som står på skylten.</p>
</div>
<div class="rest-of-article ">
<p>Världskulturmuseerna, där Östasiatiska och Etnografiska ingår, satsar exempelvis på projektet <em>Demokrati finns inte – vi gör den</em>! Det ska peppa ungdomar till engagemang för vårt statsskick och har beviljats stöd av Riksantikvarieämbetet, mejlar<strong> Helen Arfvidsson</strong>, intendent för globala frågor på Världskulturmuseerna.</p>
<p>I april hade personalen därför en workshop där den skulle diskutera vilka föremål i samlingarna som var demokratiska och odemokratiska. Kinesisk stenålderskruka? Ja &#8230; kom den till genom votering? Mötet slutade i en uppgiven förvirring, berättar en deltagare.</p>

<h2><strong>I strid med den akademiska friheten</strong></h2>
<p>Men om man lägger absurda konsekvenser åt sidan så är det ytterst oroväckande om regeringsformen nu kan används som ett medel för att styra in museer och universitet i en förutbestämd riktning med hjälp av en vagt definierad värdegrund som kan omtolkas litet hur som helst. Det hamnar ju i strid med idén om akademisk frihet och förutsättningslös, fri forskning.</p>
<p>De där värderingarna som Cserhalmi listar ur <a href="https://www.riksdagen.se/sv/dokument-lagar/dokument/svensk-forfattningssamling/kungorelse-1974152-om-beslutad-ny-regeringsform_sfs-1974-152">regeringsformen </a>kommer till stor del ur den revidering av grundlagen som klubbades igenom utan större offentlig debatt 2010. Man kan ju tolka det som just den typ av hundvissla jag talar om i krönikan <a href="https://kvartal.se/artiklar/ar-talet-om-modiga-museer-en-hundvissla/"><em>Är talet om modiga museer en hundvissla?</em></a></p>
<blockquote><p>Kan man forska om kastsamhället i Indien utan att fördöma det?</p></blockquote>
<p>Moderna grundlagar i allmänhet <em>inskränker </em>statens maktutövning och <em>garanterar </em>individens rättigheter. Till exempel används den amerikanska konstitutionens första tillägg som en garant för att statsanställda akademiker har yttrandefrihet, samvetsfrihet, och forskningsfrihet, mejlar <strong>Pär Cassel</strong>, docent i modern kinesisk historia vid University of Michigan. USA har förvisso problem.<sup>1</sup> Men hur högt i taket blir det då i Sverige, där nästan alla inom akademin är offentligt anställda och där forskningsfriheten inte har något motsvarande starkt konstitutionellt skydd?</p>
<p>Kan man forska om kastsamhället i Indien utan att fördöma det? Hur gör man med målkonflikter, som motsättningen mellan ursprungsfolks rättigheter och ekonomisk utveckling. Kan Sverige nå klimatmålet om samebyar får säga nej till koboltgruvor och vindkraftsparker?<sup>2</sup> Vågar anställda i det offentliga ställa jobbiga frågor om de riskerar att få grundlagen i huvudet?</p>
<p>Det är inte heller uppenbart varför just portalparagrafen som Cserhalmi nämner ska styra museernas inriktning. Det är väl i så fall snarare andra kapitlet 18 paragrafen om ”utbildning och forskning”, där det står vagt och föga betryggande att ”forskningens frihet är skyddad enligt bestämmelser som meddelas i lag.” Om man nu ska dra in regeringsformen i diskussionen (vilket man alltså inte bör göra).</p>
<h2>För att vara modig måste man riskera något</h2>
<p>Det är sorgligt att Cserhalmi och många andra museitjänstemän låter mer och mer som tjänstemän och aktivister än som ämnesexperter. Museerna, likt Östasiatiska, skapades och drevs länge av eldsjälar med ett passionerat intresse för just det som stod på museets skylt – var är de nu?</p>
<figure id="attachment_52279" aria-describedby="caption-attachment-52279" style="width: 860px" class="wp-caption alignnone"><img fetchpriority="high" decoding="async" class="wp-image-52279 size-full" src="https://kvartal.se/wp-content/uploads/2021/09/0937.0023-1.jpg" alt="Familj i Kashgar, Xinjiang. Foto John Törnqvist/Svenska missionsförbundet. Etnografiska museets arkiv" width="860" height="800" data-wp-pid="52279" srcset="https://kvartal.se/wp-content/uploads/2021/09/0937.0023-1.jpg 860w, https://kvartal.se/wp-content/uploads/2021/09/0937.0023-1-600x558.jpg 600w, https://kvartal.se/wp-content/uploads/2021/09/0937.0023-1-300x279.jpg 300w, https://kvartal.se/wp-content/uploads/2021/09/0937.0023-1-768x714.jpg 768w" sizes="(max-width: 860px) 100vw, 860px" /><figcaption id="caption-attachment-52279" class="wp-caption-text"><em>Familj i Kashgar, 1900-talets början</em>. Foto John Törnqvist/Etnografiska museets arkiv</figcaption></figure>
<p>Det är bra att vi är eniga om att Xinjiang är ett värdigt ämne i en tid av kulturellt folkmord. Men Cserhalmi missförstår mig. Jag menar inte att museerna <em>ska </em>vara mötesplatser för opinionsbildning och samhällsförändring. Jag menar att de <em>kan </em>vara det och att Xinjiang vore ett lämpligt tema för just Världskulturmuseerna, eftersom de har expertis och stora mängder därifrån i sina samlingar. Östasiatiskas tidigare chef Magnus Fiskesjö är för övrigt medförfattare till den skakande rapporten ”Uyghur women in China’s genocide” som beskriver hur uiguriska kvinnor våldtas i lägren och pressas till abort, steriliseringar eller äktenskap med han-kinesiska män.<sup>3</sup></p>
<p>En utställning om Xinjiang hade varit modig på riktigt, för museet skulle ha riskerat något. Det hade lett till hot från kommunistpartiets företrädare och riskerat samarbeten i Kina. Den skulle kunna skapa beröringsskräck från bolag med exponering mot Kina.</p>
<blockquote><p>Humanismen lär att människan har ett okränkbart värde och är fri och inte styrd av ödet eller mörka strukturer.</p></blockquote>
<p>Vilket leder mig till en annan problematisk punkt i Cserhalmis vision för Sveriges museer, nämligen att institutionerna bör kapitalisera på sitt höga förtroende hos allmänheten genom samarbeten med företag som vill ha åtkomst till museernas status som trovärdiga avsändare.<sup>4 </sup>Tänk en utställning med elbilar sponsrad av en kinesisk biltillverkare med verksamhet i Göteborg Att just det om något är ett recept för utslätad politisk medhårstrykning verkar ha gått honom förbi, likaså hur det kompromissar med museets grundtanke.</p>
<h2>Humanism i stället för gummiparagrafer</h2>
<p>Museerna är en produkt av humanismen. Tanken att människan har möjligheter och frihet att utvecklas moraliskt, estetiskt och intellektuellt och därigenom förverkliga sin mänsklighet. Humanismen lär att människan har ett okränkbart värde och är fri och inte styrd av ödet eller mörka strukturer. Den låter inte dogmer, prästerskap eller varumärken diktera vad som är sant eller falskt.<sup>5</sup></p>
<p>Vad är det som säger att ett museum inte gör ett bättre jobb vad gäller att sprida demokratiska värderingar just genom att hålla fast vid sitt kärnuppdrag? Kunskap är trots allt en förutsättning för kritiskt tänkande och meningsfull debatt. Det som vetenskapsfilosofen <strong>Karl Popper</strong> beskriver som den fria världens främsta tillgång i boken <em>Det öppna samhället och dess fiender</em>. Att de postmoderna i årtionden ägnar så mycket energi åt att först dekonstruera och sedan ta över museerna beror alltså inte enbart på att de erbjuder något så sällsynt för kulturvetare som fasta budgetar och anställningar.</p>
<h2>Kommunistpartiet och wokes</h2>
<p>Idag är det demokratiska öppna samhällets främsta yttre fiende den totalitära vision som Kinas kommunistparti står för. Men en av hennes främsta <em>inre</em> fiender är det som <strong>Helen Pluckrose</strong> och <strong>James Lindsay</strong> skildrar i boken <em>Cynical theories: How activist scholarship made everything about race, gender, and identity—and why this harms everybody</em>.</p>
<p>Tidskriften The Economist drar paralleller mellan wokeaktivismen idag, med sina versioner av trosbekännelser och blasfemilagar, och den konfessionella staten som liberaler kämpade mot under 1700- och 1800-talen.<sup>6</sup> Den som gav Europa inkvisitionen och indexet över förbjudna böcker. Samtidigt tyder forskning inom psykologi och ekonomi under senare årtionden på att människan långt ifrån är den förnuftsstyrda rationella varelse som upplysningstänkarna hoppades på.<sup>7 </sup>Stamlojalitet trumfar lätt fakta och vetenskap, oavsett om det handlar om Qanon eller queerteori. Men det är ingen ursäkt för att avfärda den fria tanken, för då kommer till slut enbart propagandan att återstå.</p>
<h2>Från postkolonial till posthumanism</h2>
<p>Rationell öppen debatt blir omöjlig för den som är skolad till att avfärda den som ett riggat maktspel och dela in tillvaron i ett intersektionellt kastsystem, där den med flest offerpoäng hamnar högst medan övriga ska hålla käft och dekonstrueras. Den logiska slutpositionen blir då att se människan som problemet gentemot den förtryckta naturen, och bli en anti- eller posthumanist.<sup>8</sup></p>
<blockquote><p>”Hur bör jag till exempel förhålla mig etiskt då jag diskuterar fuktens agens, eller silverfisken?”</p></blockquote>
<p>Ett exempel på sistnämnda är avhandlingen <em>Det mer-än-mänskliga museet </em>som den 24 september lades fram av museologen <strong>Caroline Owman</strong> vid Umeå universitet. Under postmodernismens första våg kritiserades museerna som elitistiska monument över förtryck där <em>den vite mannen</em> var norm.<sup>9</sup> Men Owman anser att problemet är att museerna är skapade med <em>människan </em>som norm. Detta gör museet till en antropo­cen­trisk institu­tion: en verksamhet som sätter människan i cen­trum. Med grundtankar hämtade ur modernitetens världsbild kan museet enligt Owman inte ge de kognitiva ramar eller svar som hon på något dunkelt sätt eftersträvar för klimatkrisen (Owman menar att hon med hjälp av ”miljö­hu­ma­nistiska och posthumanistiska teorier utfors­kar <em>mer­än­mänskliga</em> aspekter av mu­seet bå­de som ett resultat av och en motkraft till museets be­varandedrömmar”). I stället för att tänka och lära sig något uppmanar Owman besökarna till att lyssna, luk­ta och känna efter! Hon frågar sig: ”Hur bör jag till exempel förhålla mig etiskt då jag diskuterar fuktens agens, eller silverfisken?”</p>
<p>Det är för mig oklart hur det ska påverka kinesiska kolkraftverk.</p>
<p>Umeå universitet presenterar Owmans avhandling med den tidstypiska rubriken: ”Hur kan museer bli bättre på att spegla samtiden”.<sup>10</sup></p>
<h2>Sverige är föga öppet för pluralitet</h2>
<p>Men vad blir det av med det som står på museets skylt när fokuset hamnar på samtiden? Han som sålde sin själ till djävulen kan ge svaret. <strong>Harro Siegels</strong> ovärderliga marionetter från uppsättningen <em>Faust</em>, kanske 1900-talets allra främsta, togs till Sverige av hans lärjunge <strong>Michael Meschke</strong> på 1950-talet och införlivades i Marionettmuseet (de syns i Bergmans film <em>Fanny och Alexander</em>). Museet utsågs till Årets museum i Europa år 1990. Sedan donerade Meschke samlingen med 4 000 föremål till staten år 2011. Donationsavtalet säger att staten ska garantera dels sakkunnig hantering av samlingarna, dels deras tillgänglighet för allmänheten, men detta sker alltså inte. De ligger efter bildandet av Scenkonstmuseet i stort sett allihop bortglömda på statens lager i Tumba.</p>
<p>På en fråga i riksdagen om vad staten avser att göra för att leva upp till donationsavtalet svarar kulturminister <strong>Amanda Lind</strong> (MP) med att hänvisa till principen om armlängds avstånd.<sup>11</sup></p>
<blockquote><p>När Faust inser att ingen kunskap lärt honom leva, förnekar han all den kunskapen och träder in på icke accepterade, dunkla vägar, alkemins, magins, självbedrägeriets.</p></blockquote>
<p>I förtvivlan har 90-årige Meschke nu sammanställt ett kompendium om Marionettmuseet för att åtminstone efterlämna en kunskapsbank om mening och innehåll med donationerna. Han uttrycker där en djup insikt i betydelsen av, men också faran, av att vara en fritt tänkande humanist i Sverige:</p>
<p>”För övrigt har jag alltid gjort rätt saker vid fel tidpunkt och på fel plats. Fel tidpunkt i meningen att de sällan sammanföll med modets vindar, med vad som var inne att spela (exempel: att 1971, när alla skrek på revolution visa Büchners sansade <em>Dantons död)</em>. Fel plats i den allmänna meningen att finnas i Sverige, ett land utan traditioner på området och föga öppet för pluralitet och avvikelse från givna normer, annat än demagogiskt.”</p>
<p>Meschkes analys av Faust har också ett budskap som kan appliceras på denna debatt. Först inhämtar Faust all kunskap enligt den till övermänniskoidealet gränsande europeiska humanistiska traditionen, sedan, när han inser att ingen kunskap lärt honom leva, förnekar han all den kunskapen och träder in på icke accepterade, dunkla vägar, alkemins, magins, självbedrägeriets. Uttrycker inte detta att den västerländska människan havererar?</p>
<p>&nbsp;</p>
<div class="notes-wrapper"><a class="shadow-button noselect show-notes"  data-articleid="52085">  <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, Exempel på hur debatten kan föras i USA:</p>
<blockquote class="wp-embedded-content" data-lazy data-secret="1tCJjIzAhQ">
<p><a href="https://www.thefire.org/research/publications/fire-guides/fires-guide-to-first-year-orientation-and-thought-reform-on-campus/fires-guide-to-first-year-orientation-and-thought-reform-on-campus-full-text/">FIRE&#8217;s Guide to First-Year Orientation and Thought Reform on Campus — Full Text</a></p>
</blockquote>
<p><iframe class="wp-embedded-content" sandbox="allow-scripts" security="restricted" style="position: absolute; clip: rect(1px, 1px, 1px, 1px);" title="&#8220;FIRE&#8217;s Guide to First-Year Orientation and Thought Reform on Campus — Full Text&#8221; &#8212; FIRE" src="https://www.thefire.org/research/publications/fire-guides/fires-guide-to-first-year-orientation-and-thought-reform-on-campus/fires-guide-to-first-year-orientation-and-thought-reform-on-campus-full-text/embed/#?secret=1tCJjIzAhQ" data-lazy data-secret="1tCJjIzAhQ" width="600" height="338" frameborder="0" marginwidth="0" marginheight="0" scrolling="no"></iframe></p>
<p>För mer om diskussionen till det första tillägget se till exempel: https://www.aaup.org/our-work/protecting-academic-freedom/academic-freedom-and-first-amendment-2007</p>
<p>2, Se till exempel: <a href="https://www.sametinget.se/vindkraftpolicy">https://www.sametinget.se/vindkraftpolicy</a> <a href="https://www.sametinget.se/160718">https://www.sametinget.se/160718 </a> Se även som exempel: https://www.dn.se/nyheter/jonas-froberg-det-ar-sveriges-kanske-viktigaste-rattsfall/ eller <a href="https://sverigesradio.se/artikel/6996938">https://sverigesradio.se/artikel/6996938</a></p>
<p>3, Se: https://digitalcommons.usf.edu/cgi/viewcontent.cgi?article=1834&amp;context=gsp</p>
<p>4, Niklas Cserhamlis vision går att läsa här: https://www.sverigesmuseer.se/nyheter/2021/05/vi-ger-ordet-till-sveriges-museers-nya-ordforande-niklas-cserhalmi/ ”Om museerna når dit, att vi har samhällets mandat att vara katalysatorer för svåra och angelägna samtal så har vi vunnit mycket. Vi blir då mer attraktiva som samarbetsparter för det offentliga, för civilsamhället, för näringslivet med flera och den attraktiviteten kan vi omsätta i ökad offentlig och annan finansiering. Det som samarbetsparterna vill ha är åtkomst till museernas status som trovärdiga avsändare av angelägna budskap”</p>
<p>5, Definition av humanism som filosofi: ne.se/uppslagsverk/encyklopedi/l%C3%A5ng/humanism-(etiskt-estetiskt-f%C3%B6rh%C3%A5llningss%C3%A4tt)</p>
<p>6, Se https://www.economist.com/briefing/2021/09/04/left-wing-activists-are-using-old-tactics-in-a-new-assault-on-liberalism</p>
<p>7,  Som den liberale filosofen John Stuart Mill (1806–1873) uttryckte det i boken <em>On Liberty</em>, “The peculiar evil of silencing the expression of an opinion is, that it is robbing the human race; posterity as well as the existing generation, those who dissent from the opinion, still more than those who hold it. If the opinion is right, they are deprived of the opportunity of exchanging error for truth: if wrong, they lose, what is almost as great a benefit, the clearer perception and livelier impression of truth, produced by its collision with error.” Om dagens mer uppgivna diskussion kring förnuftsbaserat tänkande, se exempelvis The Economists recension av Steven Pinkers aktuella bok <em>Rationality</em>: https://www.economist.com/books-and-arts/steven-pinkers-new-defence-of-reason-is-impassioned-but-flawed/21804960</p>
<p>8, För översikt om posthumanism, se <a href="https://oxfordre.com/communication/view/10.1093/acrefore/9780190228613.001.0001/acrefore-9780190228613-e-627">https://oxfordre.com/communication/view/10.1093/acrefore/9780190228613.001.0001/acrefore-9780190228613-e-627</a> eller: <a href="https://en.wikipedia.org/wiki/Posthumanism"> https://en.wikipedia.org/wiki/Posthumanism</a> <a href="https://en.wikipedia.org/wiki/Posthumanism">https://en.wikipedia.org/wiki/Posthumanism</a> Ett utskott på den posthumanistiska grenen är rörelsen för den frivilliga utrotningsrörelsen av mänskligheten som Jakob Rudenstrand skildrade i Kvartal kultur (24 september 2019).</p>
<blockquote class="wp-embedded-content" data-lazy data-secret="mFRv7ktkq1">
<p><a href="https://kvartal.se/artiklar/de-vill-att-inga-barn-ska-fodas/">De vill att inga barn ska födas</a></p>
</blockquote>
<p><iframe class="wp-embedded-content" sandbox="allow-scripts" security="restricted" style="position: absolute; clip: rect(1px, 1px, 1px, 1px);" title="&#8221;De vill att inga barn ska födas&#8221; &#8212; Kvartal" src="https://kvartal.se/artiklar/de-vill-att-inga-barn-ska-fodas/embed/#?secret=mFRv7ktkq1" data-lazy data-secret="mFRv7ktkq1" width="600" height="338" frameborder="0" marginwidth="0" marginheight="0" scrolling="no"></iframe></p>
<p>&nbsp;</p>
<p>9, Se <em>Keeping their marbles</em>, Tiffany Jenkins (Oxford university press, 2016) sid 170 ff. Om den nya museologin i Sverige från insidan rekommenderas Riksantikvarieämbetets skrift ”Museiforskning – en översikt” av Anna Laine. Kan läsas här: https://www.diva-portal.org/smash/get/diva2:1251923/FULLTEXT01.pdf</p>
<p>10, Se: https://www.expertsvar.se/pressmeddelanden/hur-kan-museer-bli-battre-pa-att-spegla-samtiden/</p>
<p>Carolin Owmans avhandling kan ses här: https://www.diva-portal.org/smash/record.jsf?pid=diva2%3A1589328&amp;dswid=-9024</p>
<p>11, Barbro Westerholm (L) ställde frågan om marionettmuseets fortlevnad i riksdagen 2019 (2018/19:191). Kulturminister Amanda Linds svar var: ”En viktig utgångspunkt är att regeringen varken kan eller bör lägga sig i specifika utställningar på våra museer och hur de är utformade. Ett museum visar alltid ett urval av sina samlingar och vilka föremål som visas för tillfället varierar över tid. Statens musikverk och Scenkonstmuseet har ett brett uppdrag som innefattar teaterns, dansens och musikens kulturarv. Museet har en samling på ca 50 000 föremål, där marionettsamlingarna är en del. Marionettsamlingarna i dess helhet går att beställa fram från magasinen och en del av samlingarna visas även i den nuvarande utställningen på Scenkonstmuseet. Det kan därmed konstateras att samlingarna är tillgängliga för allmänheten. Myndigheten har också ansvaret för att ha tillgång till den sakkunskap som krävs för samlingarnas förvaltning. Regeringen följer kontinuerligt på en övergripande nivå hur myndigheten och museet arbetar med sina samlingar och sina övriga instruktionsenliga uppgifter.”</p>
<p>Se: https://www.riksdagen.se/sv/dokument-lagar/dokument/skriftlig-fraga/marionettmuseets-fortlevnad_H611191</p>
<p>&nbsp;</p>
</div>
</div>
<div class="author-byline">Ola Wong är Kvartals kulturredaktör, Kina-kännare och författare.
</div>
</div>
