Kulturhuset gav barnen en lektion i vuxenvärldens hyckleri

<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-165452"      class = "kv-pod-holder kv-player-light  lplo " data-sid="" data-eid="" data-pid="165452" data-pty="SW5sw6RzdCBhcnRpa2VsIChLdWx0dXIp" data-pna="S3VsdHVyaHVzZXQgZ2F2IGJhcm5lbiBlbiBsZWt0aW9uIGkgdnV4ZW52w6RybGRlbnMgaHlja2xlcmk=" data-acurl="aHR0cHM6Ly9tZWRpYS5wb2Quc3BhY2UvaW5sYXN0YXRleHRlci82LTA1LWt1bHR1cmh1c2V0LWdhdi1iYXJuZW4tZW4tbGVrdGlvbi1pLXZ1eGVudmFybGRlbnMtaHlja2xlcmkubXAz" data-psurl="aHR0cHM6Ly9tZWRpYS5wb2Quc3BhY2Uva2p4ajYzeWRkZXEydmgvNi0wNS1rdWx0dXJodXNldC1nYXYtYmFybmVuLWVuLWxla3Rpb24taS12dXhlbnZhcmxkZW5zLWh5Y2tsZXJpLm1wMw==">  <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/makode-linde/">Makode&nbsp;Linde</a> | 1 februari 2025<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%2Fkulturhuset-gav-barnen-en-lektion-i-vuxenvarldens-hyckleri%2F&amp;t=Kulturhuset+gav+barnen+en+lektion+i+vuxenv%C3%A4rldens+hyckleri"    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=Kulturhuset+gav+barnen+en+lektion+i+vuxenv%C3%A4rldens+hyckleri+-+https%3A%2F%2Fkvartal.se%2Fartiklar%2Fkulturhuset-gav-barnen-en-lektion-i-vuxenvarldens-hyckleri%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%2Fkulturhuset-gav-barnen-en-lektion-i-vuxenvarldens-hyckleri%2F"    target = "_blank"    class  = "li-link"    title  = "Dela på LinkedIn"><i class="ti-linkedin ui transparent"></i></a><a href    = "mailto:?subject=Kulturhuset gav barnen en lektion i vuxenvärldens hyckleri&body=https://kvartal.se/artiklar/kulturhuset-gav-barnen-en-lektion-i-vuxenvarldens-hyckleri/"   target  = "_blank"    class   = "pr-link"    title   = "E-posta"    onclick = ""><i class="ti-email ui transparent"></i></a><a href    = "https://kvartal.se/skriv-ut/165452/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%2Fkulturhuset-gav-barnen-en-lektion-i-vuxenvarldens-hyckleri%2F&amp;t=Kulturhuset+gav+barnen+en+lektion+i+vuxenv%C3%A4rldens+hyckleri"    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=Kulturhuset+gav+barnen+en+lektion+i+vuxenv%C3%A4rldens+hyckleri+-+https%3A%2F%2Fkvartal.se%2Fartiklar%2Fkulturhuset-gav-barnen-en-lektion-i-vuxenvarldens-hyckleri%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%2Fkulturhuset-gav-barnen-en-lektion-i-vuxenvarldens-hyckleri%2F"    target = "_blank"    class  = "li-link"    title  = "Dela på LinkedIn"><i class="ti-linkedin ui transparent"></i></a><a href    = "mailto:?subject=Kulturhuset gav barnen en lektion i vuxenvärldens hyckleri&body=https://kvartal.se/artiklar/kulturhuset-gav-barnen-en-lektion-i-vuxenvarldens-hyckleri/"   target  = "_blank"    class   = "pr-link"    title   = "E-posta"    onclick = ""><i class="ti-email ui transparent"></i></a><a href    = "https://kvartal.se/skriv-ut/165452/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/kulturhuset-gav-barnen-en-lektion-i-vuxenvarldens-hyckleri/?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 7 min</span></a><a href   = "https://kvartal.se/skarmlasarvanlig/19f55f03-7e1b-4b4b-8f14-5bbb94901cbf"    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-165452">  <div class="in-short-inner">    <span class="close_button close-in-short in-short-toggle" data-articleid = "165452"></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 ">Observationen ”att olyckor inträffar” är varken ny eller originell. Snarare är det en allmänmänsklig erfarenhet. Ibland, när Olyckan är framme, har man tur i oturen och kan lära sig något. Nyckelordet är ”ibland”, eftersom det inte är självklart att den olycksdrabbade haft möjlighet att destillera fram någon slags visdom, bortom den personliga tragedin.</p>
</div>
<div class="rest-of-article ">
<h2>Konsten som abstraherad erfarenhet</h2>
<p>Viljan att dra lärdom ur ett trauma måste ses som en optimistisk och konstruktiv attityd. Men precis som med många självhjälpsmetoder passar den inte alla och blir direkt toxisk när den som överlevt krig, övergrepp eller sjukdom förväntas att ha lärt sig något. Som om en viss typ av livsvisdom exklusivt kan uppnås genom lidandet, och som om varje trauma kom färdigförpackat med livsvisdom och ett permanent säte i en expertpanel.</p>
<p>Mördade spädbarn lär oss ingenting.</p>
<p>Ingenting vi inte redan vet.</p>
<figure id="attachment_165461" aria-describedby="caption-attachment-165461" style="width: 2045px" class="wp-caption alignnone"><img fetchpriority="high" decoding="async" class="wp-image-165461 size-full" src="https://kvartal.se/wp-content/uploads/2025/02/Adolf-Hitlers-tavla-1.jpg" alt="" width="2045" height="1485" data-wp-pid="165461" srcset="https://kvartal.se/wp-content/uploads/2025/02/Adolf-Hitlers-tavla-1.jpg 2045w, https://kvartal.se/wp-content/uploads/2025/02/Adolf-Hitlers-tavla-1-300x218.jpg 300w, https://kvartal.se/wp-content/uploads/2025/02/Adolf-Hitlers-tavla-1-768x558.jpg 768w, https://kvartal.se/wp-content/uploads/2025/02/Adolf-Hitlers-tavla-1-1536x1115.jpg 1536w, https://kvartal.se/wp-content/uploads/2025/02/Adolf-Hitlers-tavla-1-600x436.jpg 600w" sizes="(max-width: 2045px) 100vw, 2045px" /><figcaption id="caption-attachment-165461" class="wp-caption-text"><em>Bild: Wikimedia commons. </em></figcaption></figure>
<p>Om du lyckas extrahera en guldkant ur din egen tragedi är du redan en vinnare! Vissa upplevelser är för komplexa, eller personliga, för att kunna kokas ned till en generaliserad och delbar insikt, eller ens något konkret. En sådan erfarenhet riskerar att förvisas till vårt undermedvetna och fortleva i det abstrakta. Här i det abstrakta lever jag och många artister huvuddelen av våra liv, och denna abstraherade verklighet kan ofta kännas verkligare och mer påtaglig än den så kallade verkliga verkligheten. En av konsternas många krafter är dess förmåga att navigera det abstrakta och genom en alkemisk process omvandla det till någonting mer konkret.</p>
<p>Här uppenbarar sig en parallell mellan konst och terapi. Lite av båda skulle nog göra dig gott. Oavsett om du gör det för din egen skull, på institution eller inom ramarna för någon slags aktivism kan delandet i sig upprätta en telepatisk länk mellan dina egna abstrakta världar och andras. Och det är här det börjar bli intressant.</p>
<p>Tänk bara på med vilken kirurgisk precision en sång kan fånga dina innersta känslor, och därefter leva sitt eget liv inom dig tills dagen du dör.</p>
<p>Du kan aldrig vara säker på om versionen i dig är korrekt, eller om du tolkat låten exakt så som artisten avsett, men det spelar heller ingen roll för hur avgörande låten är för dig eller vilken betydelse den har för någon annan.</p>
<p>Det står dig fritt att fylla dina upplevelser, eller ett verk, med precis så mycket meningsfullhet (eller meningslöshet) du behagar. Förmågan till empati är rimligtvis medfödd, i alla fall hos däggdjur. Detta till trots kan den inte tas för givet. Slår du på nyheterna eller går ut på gatan kan du snabbt konstatera att världen är fylld av empatistörda individer.</p>
<h2>Den farliga rädslan för nazistkonst</h2>
<p>Då mänsklig ondska ges ett ansikte drabbas jag av en misstanke att något gått riktigt fel. Någonstans på vägen måste det ha slagit slint för att få dig att bli så här. Det måste finnas en förklaring?</p>
<p>Vilka trauman har varit formativa för dig och din världssyn?</p>
<p>Jag påminns om ett klipp på nätet som visar hur tårfyllda och chockerade tyskar lämnar biografsalongen efter en visning av <em>Schindler’s list </em>(1994). Vi får anta att majoriteten av alla tyskar vid denna tidpunkt var väl medvetna om sin historia. Trots det är det tydligt att filmen tillförde något, utöver det som historiebokens blurb om ”6 miljoner judar” lyckas förmedla.</p>
<blockquote><p>Om elevmålningarna från Husby visats i Berlin hade verksamheten stängts ned permanent, utan diskussion.</p></blockquote>
<p>Det krävs inget geni för att förstå varför tyskarna kriminaliserat nazism. Inte för att det går att lagstifta bort varken åsikter eller dumhet, så lagen är, <em>surprise</em>&#8211;<em>surprise</em>, helt verkningslös. Nu för tiden hatar tyskar i stället araber. Minsta form av Israelkritik ses här som direkt antisemitism, och de institutioner och konstnärer som yttrat sympati för Palestina har cancellerats och fått kulturstöd indragna. Om elevmålningarna <a href="https://kvartal.se/artiklar/kulturhuset-censurerade-konstverk-med-israelkritik-och-afrikaner/">från Husby</a> visats i Berlin hade verksamheten stängts ned permanent, utan diskussion.</p>
<p>Rädslan för nazistkonst gör mer skada än nytta.</p>
<p>Vad är ens nazistkonst?</p>
<p>Är det konst gjord av, för eller om nazister?</p>
<p>För mig känns hela frågeställningen superlöjlig, och jag har svårt att förstå exakt vilken typ av skada som skulle kunna uppstå om jag mot förmodan skulle exponeras för denna farliga nazistkonst. Hur farlig kan en bild vara?</p>
<p><strong>Dick Bengtssons</strong> (förmodat icke-nazistiska?) svastikor hänger på Moderna museet. Vit makt-sympatisörer sitter i riksdagen, och en vit skräckslagen kulturkvinna i Husby oroar sig för vad som kommer att hända med barnen om de utsätts för konst som tar avstånd från det pågående folkmordet i Gaza och ockupationen av Palestina.</p>
<p>Gränserna mellan politik, konst och terapi blir bara suddigare. Mina egna erfarenheter av rasism är något jag haft förmånen att få dela med mig av. Offentligt, genom min konst, och privat med likasinnade inom mitt <em>community</em>.</p>
<p>Jag älskar min lilla stödgrupp av queera, autistiska svartskallar från 80-talets Södermalm, men jag skulle inte kalla det ett <em>community</em>. Snarare är det en exklusiv liten klubb, som uppstått på grund av yttre omständigheter bortom vår kontroll.</p>
<h2>Dan Park och varför konsten inte måste hålla sig inom lagen</h2>
<p>Förra veckan, då jag av Kvartal ombads att skriva om de censurerade barnen på Husbys kulturhus, förstod jag att jag tvångsanslutits till en ny liten klubb. Det har gått ett decennium sedan jag själv censurerades av en vit, livrädd kulturhuschef och anklagades för att skapa rasistisk konst. <em>(2016 uppstod konflikt mellan Makode Linde och Kulturhuset Stadsteatern kring namnvalet på hans utställning Negerkungens återkomst. reds. anm.)</em> Samma vita kulturmakthavare som storsint bjudit in mig att skapa en efterlängtad och välbehövd utställning med postkolonialt tema visade sig snabbt vara oförmögen att ens på ytlig nivå förstå ämnets komplexitet, eller de maktstrukturer som landets kulturinstitutioner och han själv var en del av.</p>
<p>Här finns gott om lågt hängande frukt, så jag ber om överseende medan jag betar av några självklarheter.</p>
<p>Situationen belyser behovet av ökad mångfald på statens kulturinstitutioner. Viljan att belysa ämnen som ligger utanför ens kompetensområde är antagligen av godo, men kommer ofta med en outtalad förväntan om att presentera ”rätt” sorts sentiment, vilket kan ses som ett förtryck i sig. Gäsp.</p>
<p><strong>Lars Nittves</strong> <a href="https://kvartal.se/artiklar/kulturhuset-censurerade-konstverk-med-israelkritik-och-afrikaner/">uttalande</a> om hur konsten måste hålla sig inom lagens gränser känns i bästa fall naivt, i värsta fall världsfrånvänt. Lagar är inte neutrala. De speglar maktstrukturer och kulturella normer.</p>
<blockquote><p>Huruvida något är konst, aktivism, terapi eller terrorism kan vara svårt att avgöra.</p></blockquote>
<p>På <a href="http://voiceproject.org/">voiceproject.org</a> går det att läsa om konstnärer runt om i världen som fängslats eller lever i exil som konsekvens av sin konst. Allas favorit <strong>Dan Park </strong>är så vitt jag vet landets mest fängslade konstnär. Folk verkar överlag tycka att det är rimligt, med motiveringen att han är nazist.</p>
<p>Park är många saker, men nazist är inte en av dem.</p>
<p>Konstnärlig process är vild och oförutsägbar. Huruvida något är konst, aktivism, terapi eller terrorism kan vara svårt att avgöra. Särskilt som betraktare, men även som konstnär. Den begåvade landskapsmålaren <strong>Adolf Hitler</strong> antogs tyvärr aldrig av konstakademien i Wien. Jag är övertygad om att hans målningar var ibland det bästa han gjort. Spekulationerna kring hur världen hade kunnat se ut om han fått ge utlopp för sin kreativitet förblir ett tankeexperiment.</p>
<p>Om något, tror jag, bör vi uppmuntra nazister att göra mer konst! Utan att vara någon expert på nazister eller vad de sysslar med (nazistprylar, gissningsvis) vågar jag påstå att det är bättre om de gör konst än att de sitter i riksdagen.</p>
<p>– Men barnen då? Vad hände med barnen?</p>
<p>– Vilka barn syftar du på?</p>
<p>Eleverna i Husby fick, olyckan till trots, en chans att lära sig hur världen faktiskt funkar. De hypotetiskt överkänsliga barnen, som till varje pris måste skyddas från samtidskonst, lever vidare och frodas på landets kulturinstitutioner.</p>
<p>Och har de inte dött av tristess så lever de än idag.</p>
<figure id="attachment_165462" aria-describedby="caption-attachment-165462" style="width: 402px" class="wp-caption alignnone"><img decoding="async" class="wp-image-165462 size-full" src="https://kvartal.se/wp-content/uploads/2025/02/1.png" alt="" width="402" height="380" data-wp-pid="165462" srcset="https://kvartal.se/wp-content/uploads/2025/02/1.png 402w, https://kvartal.se/wp-content/uploads/2025/02/1-300x284.png 300w" sizes="(max-width: 402px) 100vw, 402px" /><figcaption id="caption-attachment-165462" class="wp-caption-text"><em>Bild: Wikimedia commons. </em></figcaption></figure>
<div class="author-byline">Makode Linde är konstnär och musiker bosatt i Berlin.
</div>
</div>
