Filmen som visar hur sociala medier dödar demokratin

<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-184921"      class = "kv-pod-holder kv-player-light  lplo " data-sid="" data-eid="" data-tis="323" data-tin="475" data-pid="184921" data-pty="SW5sw6RzdCBhcnRpa2VsIChLdWx0dXIp" data-pna="RmlsbWVuIHNvbSB2aXNhciBodXIgc29jaWFsYSBtZWRpZXIgZMO2ZGFyIGRlbW9rcmF0aW4=" data-acurl="aHR0cHM6Ly9tZWRpYS5wb2Quc3BhY2UvaW5sYXN0YXRleHRlci9maWxtZW4tc29tLXZpc2FyLWh1ci1zb2NpYWxhLW1lZGllci1kb2Rhci1kZW1va3JhdGluLm1wMw==" data-psurl="aHR0cHM6Ly9tZWRpYS5wb2Quc3BhY2Uva2p4ajYzeWRkZXEydmgvZmlsbWVuLXNvbS12aXNhci1odXItc29jaWFsYS1tZWRpZXItZG9kYXItZGVtb2tyYXRpbi5tcDM=">  <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%2Ffilmen-som-visar-hur-sociala-medier-dodar-demokratin%2F&amp;t=Filmen+som+visar+hur+sociala+medier+d%C3%B6dar+demokratin"    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=Filmen+som+visar+hur+sociala+medier+d%C3%B6dar+demokratin+-+https%3A%2F%2Fkvartal.se%2Fartiklar%2Ffilmen-som-visar-hur-sociala-medier-dodar-demokratin%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%2Ffilmen-som-visar-hur-sociala-medier-dodar-demokratin%2F"    target = "_blank"    class  = "li-link"    title  = "Dela på LinkedIn"><i class="ti-linkedin ui transparent"></i></a><a href    = "mailto:?subject=Filmen som visar hur sociala medier dödar demokratin&body=https://kvartal.se/artiklar/filmen-som-visar-hur-sociala-medier-dodar-demokratin/"   target  = "_blank"    class   = "pr-link"    title   = "E-posta"    onclick = ""><i class="ti-email ui transparent"></i></a><a href    = "https://kvartal.se/skriv-ut/184921/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="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> | 15 augusti 2025<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%2Ffilmen-som-visar-hur-sociala-medier-dodar-demokratin%2F&amp;t=Filmen+som+visar+hur+sociala+medier+d%C3%B6dar+demokratin"    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=Filmen+som+visar+hur+sociala+medier+d%C3%B6dar+demokratin+-+https%3A%2F%2Fkvartal.se%2Fartiklar%2Ffilmen-som-visar-hur-sociala-medier-dodar-demokratin%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%2Ffilmen-som-visar-hur-sociala-medier-dodar-demokratin%2F"    target = "_blank"    class  = "li-link"    title  = "Dela på LinkedIn"><i class="ti-linkedin ui transparent"></i></a><a href    = "mailto:?subject=Filmen som visar hur sociala medier dödar demokratin&body=https://kvartal.se/artiklar/filmen-som-visar-hur-sociala-medier-dodar-demokratin/"   target  = "_blank"    class   = "pr-link"    title   = "E-posta"    onclick = ""><i class="ti-email ui transparent"></i></a><a href    = "https://kvartal.se/skriv-ut/184921/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/filmen-som-visar-hur-sociala-medier-dodar-demokratin/?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 3 min</span></a><a href   = "https://kvartal.se/skarmlasarvanlig/a0d481e3-31b1-411e-b308-63db113497d8"    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-184921">  <div class="in-short-inner">    <span class="close_button close-in-short in-short-toggle" data-articleid = "184921"></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 ">I sommar har <a href="https://kvartal.se/artiklar/sag-nej-till-smartphonelivet/"><strong>Anna Axfors</strong></a> och <strong><a href="https://kvartal.se/artiklar/barnen-lever-med-digitala-rovdjur/">Anna-Karin Wyndhamn</a> </strong>skrivit om böcker och tv-serier som visar hur nätlivet påverkar mental hälsa och mående. Själv såg jag nyligen covidwesternfilmen <em>Eddington</em>.</p>
</div>
<div class="rest-of-article ">
<p>Första halvan av <em>Eddington</em> visar på ett briljant och underhållande sätt hur sociala medier, SoMe, kortsluter demokratin. Den andra halvan av filmen slarvas tyvärr bort i ett ironiskt splatter – regissören <strong>Ari Aster</strong> lyckas inte riktigt dra historien i land. Men första halvan är som sagt genial.</p>
<p>I Eddington, en håla i New Mexicos öken, möter vi den sympatiske och lätt grånade sheriffen <strong>Jim Cross</strong>, spelad av <strong>Joaquin Phoenix</strong>. Pandemin och Black Lives Matter-rörelsen rullar in över USA och Cross reagerar över nedstängningspolitiken – vad hände med medmänsklighet och sunt förnuft? Det finns ju inte ens covid i Eddington, muttrar han. Kollegorna på polisstationen börjar splittras i rastänkande. Ett mystiskt techbolag vill anlägga ett jättelikt datacenter som kommer att sluka vatten från lokalbefolkningen. Sheriffen blir så arg att han ställer upp i borgmästarvalet och utmanar stadens starke man, spelad av den fantastiske <strong>Pedro Pascal</strong>. Men om motståndaren är en pedofil och agent för <strong>Bill Gates</strong> och ”den djupa staten”, då blir våld den rimliga lösningen. Cross asfalterar vägen till undergången med arga inlägg på sociala medier: ”Få mig inte att tänka, lägg bara upp det!” säger han efter ett sällsynt uppvarvat personangrepp på den sittande borgmästaren. En svärmor som spammar konspirationsteorier går från att vara en jobbig närvaro i huset till att bli andlig vägledare.</p>
<h2>Den farliga nätmänniskan</h2>
<p><em>Eddington</em> driver även med en annan utgåva av nätmänniskan – de vita woke-ungdomarna i Black Lives Matter-rörelsen, de som kritiserar vithet genom att skrika på mediernas och verklighetens torg så att ingen annan kan höras.</p>
<p>Vid middagsbordet börjar en tonåring förklara varför vithet är ett så fruktansvärt problem. Hans pappa sitter först tyst och frågar sedan: ”Är du efterbliven? Du är vit!” Undrar hur många sådana samtal som skedde i verkligheten de åren.</p>
<p>En av de sorgligaste scenerna visar hur sheriffen och hans fru ligger med ryggen mot varandra i sängen och finner svaren på äktenskapets tystnad i det blå ljuset från surfmobilen. Verkliga problem och fullt rimlig samhällskritik löses gradvis upp i skenvärldens narrativ. Filmen visar hur demokratins medborgare förvandlas till <em>homo interneticus</em>, som jag <a href="https://kvartal.se/artiklar/historien-kommer-att-ge-biden-upprattelse/">skrivit om tidigare</a>: en varelse som ser nätet som den verkliga verkligheten, som driver i tid och rum med sin indignation, respektlös och misstänksam mot gamla auktoriteter, förvirrad av flödet av upphetsade ansikten och det uppskruvade vansinne som krigar om uppmärksamheten. När stadens nya elit samlas för att inviga datacentret på slutet är det svärmor som håller högtidstalet, verkligheten har försvunnit från det offentliga rummet.</p>
<blockquote><p>Vi kommer att behöva ge upp sociala medier eller demokratin i sin nuvarande form.</p></blockquote>
<p>Det är talande att det är insinuationer om påstådd inblandning i och mörkläggning av <strong>Epstein</strong>-affären som skapat mest problem för <strong>Donald Trump</strong>, och inte presidentens skandaler i närtid som ligger i öppen dager: korrumperingen av styret, stormningen av Kapitolium, och så vidare.</p>
<p>Som väntat med en film som vågar vända på perspektiven och slå åt olika håll har <em>Eddington</em> sågats av recensenter, bland annat av <a href="https://www.theguardian.com/film/2025/may/16/eddington-review-ari-asters-tedious-covid-western-masks-drama-and-mutes-his-stars"><em>The Guardian</em></a> och <a href="https://www.newyorker.com/magazine/2025/07/28/eddington-movie-review"><em>New Yorker</em></a>, sistnämnda kritiserar den för att visa världen ur den sociopatiske vite sheriffens perspektiv, men det säger nog mer om recensenterna.</p>
<p>Framför allt illustrerar filmen hur sociala medier och demokrati inte verkar vara kompatibla. Det är en slutsats jag själv alltmer börjar luta åt. Vi kommer att behöva ge upp sociala medier eller demokratin i sin nuvarande form. Själv vet jag vilken av de två som jag föredrar.</p>
<p>PS. Om du är i Stockholm så visas <em>Eddington</em> på mysiga bio Aspen i Aspudden under augusti månad.</p>
<div class="author-byline">Ola Wong är Kvartals kulturredaktör, Kina-kännare och författare.
</div>
</div>
