I korthet
Nyligen var jag inbjuden till ett panelsamtal på Kulturhuset i Stockholm. Temat för kvällen var ”D*ckpics och Tinder – är romantiken död?”
<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-87080"      class = "kv-pod-holder kv-player-light  lplo " data-sid="" data-eid="" data-pid="87080" data-acurl="aHR0cHM6Ly9tZWRpYS5wb2Quc3BhY2Uva3ZhcnRhbC9pbmxhc3RfYXJfcm9tYW50aWtlbl92ZXJrbGlnZW5fZG9kLm1wMw==" data-psurl="aHR0cHM6Ly9tZWRpYS5wb2Quc3BhY2Uva2p4ajYzeWRkZXEydmgvYXItcm9tYW50aWtlbi12ZXJrbGlnZW4tZG9kXy5tcDM=">  <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/stefan-krakowski/">Stefan&nbsp;Krakowski </a> | 14 februari 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%2Far-romantiken-verkligen-dod%2F&amp;t=%C3%84r+romantiken+verkligen+d%C3%B6d%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=%C3%84r+romantiken+verkligen+d%C3%B6d%3F+-+https%3A%2F%2Fkvartal.se%2Fartiklar%2Far-romantiken-verkligen-dod%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%2Far-romantiken-verkligen-dod%2F"    target = "_blank"    class  = "li-link"    title  = "Dela på LinkedIn"><i class="ti-linkedin ui transparent"></i></a><a href    = "mailto:?subject=Är romantiken verkligen död?&body=https://kvartal.se/artiklar/ar-romantiken-verkligen-dod/"   target  = "_blank"    class   = "pr-link"    title   = "E-posta"    onclick = ""><i class="ti-email ui transparent"></i></a><a href    = "https://kvartal.se/skriv-ut/87080/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/87080/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%2Far-romantiken-verkligen-dod%2F&amp;t=%C3%84r+romantiken+verkligen+d%C3%B6d%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=%C3%84r+romantiken+verkligen+d%C3%B6d%3F+-+https%3A%2F%2Fkvartal.se%2Fartiklar%2Far-romantiken-verkligen-dod%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%2Far-romantiken-verkligen-dod%2F"    target = "_blank"    class  = "li-link"    title  = "Dela på LinkedIn"><i class="ti-linkedin ui transparent"></i></a><a href    = "mailto:?subject=Är romantiken verkligen död?&body=https://kvartal.se/artiklar/ar-romantiken-verkligen-dod/"   target  = "_blank"    class   = "pr-link"    title   = "E-posta"    onclick = ""><i class="ti-email ui transparent"></i></a><a href    = "https://kvartal.se/skriv-ut/87080/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/87080/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/ar-romantiken-verkligen-dod/?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/87080"    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-87080">  <div class="in-short-inner">    <span class="close_button close-in-short in-short-toggle" data-articleid = "87080"></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 ">Nyligen var jag inbjuden till ett panelsamtal på Kulturhuset i Stockholm. Temat för kvällen var ”<a href="https://www.youtube.com/watch?v=EmAJ3SoZ_zA">D*ckpics och Tinder – är romantiken död?</a>”</p>
</div>
<div class="rest-of-article ">
<p>Min första association när jag tänkte på romantik förr och nu var en bunt med brev som låg i ett vitrinskåp i mitt föräldrahem. Det var kärleksbrev som mina föräldrar hade skrivit till varandra efter att de båda hade kommit till Sverige som flyktingar. Min mamma hade knutit ett rött sidenband runt brevbunten och jag minns att hon brukade hänvisa till kärleksbreven när de grälade med varandra – som en påminnelse om hur pappa minsann hade trånat efter henne en gång i tiden.</p>
<p>Det tog lång tid efter deras död innan jag vågade lossa på sidenbandet, ta ut breven från kuverten och läsa deras korrespondens. Det kändes för privat, för intimt, helt enkelt. Men en dag tog jag mod till mig och började läsa breven med viss möda, eftersom de var skrivna med snirklig, och för mig nästintill oläslig handstil på polska.</p>
<h2>Intensiv brevväxling</h2>
<p>De började brevväxla i september 1945, några månader efter krigsslutet i Europa. Min pappa vårdades på ett konvalescenthem i Avesta. Han hade som ung, polsk löjtnant sårats under ett luftangrepp från de tyska störtbombarna. Min mamma bodde i Stockholm, inneboende hos en äldre dam på Östermalm, och var i färd med att påbörja sitt första arbete i det nya landet. De fick kontakt med varandra via en gemensam bekant som också kommit till Sverige som flykting och som vårdades på samma konvalescenthem som min pappa. Det skulle ta tre månader av intensiv brevväxling innan de träffades personligen för första gången, på en nyårsmiddag.</p>
<blockquote><p>Vi har allt mindre sex och allt fler lever idag ensamma.</p></blockquote>
<p>Så här skrev min pappa från konvalescenthemmet ett par dagar senare, den 3 januari 1946 (i min översättning):</p>
<p><em>Kära Ewa!</em></p>
<p><em>Kanske borde jag inte öppna mig så mycket när jag inte vet vad du känner för mig, jag har aldrig skrivit till en kvinna så ärligt och öppet som till dig. Allt du berättade för mig under våra sömnlösa nätter tänker jag på nu. Jag saknar dessa nätter något så oerhört, du fattas mig så hemskt mycket, jag längtar efter din sångröst, ditt silvriga skratt som låter som världens underbaraste musik, din kloka blick. Jag känner att jag skulle må så bra om jag var nära dig. Min största dröm är att träffa dig så fort som möjligt och krama dig för då tror jag att jag skulle bli den lyckligaste människan på jorden.</em></p>
<p>Min mamma svarade två dagar senare:</p>
<p><em>Samma dag som du åkte blev jag sjuk med 40 graders feber och mår fortfarande dåligt.</em></p>
<p><em>Hela dagarna låg jag ensam och våndades över att du inte kan vara här med mig och tänkte att du nog hellre skulle vilja sitta bredvid mig än i Avesta (förlåt om jag låter kaxig). Allt det där jag sa under den sista sömnlösa natten, var ärligt, jag skulle aldrig ljuga eller låtsas inför dig. Jag har fortfarande så fina minnen från nyårsnatten, de ömma kyssarna i allas närvaro vid bordet och våra ömsesidiga frierier. Jag vill tro att du är ärlig, även när du är berusad. Nu får det räcka för idag. Jag är mycket svag för febern gör mig helt utmattad och det är svårt att skriva.</em></p>
<p>Jag undrar vad mina föräldrar hade tyckt om dagens digitala form av uppvaktning om de fortfarande varit i livet. Kanske hade de ansett att den nya tekniken gjort oss cyniska, rastlösa, otåliga och rentav desillusionerade och att en anonym dejtingsida, en profil bland många andra, knappast kan leda till äkta kärlek.</p>
<p>Man kan fråga sig om vi överhuvudtaget är intresserade av seriösa, långvariga förhållanden, av partnerskap i nöd och lust?</p>
<h2>Sårbarhet och svaghet</h2>
<p>Vi har allt <a href="https://www.aftonbladet.se/relationer/a/gPpql5/bottenrekordet-nu-har-vi-mindre-sex-an-nagonsin">mindre sex</a> och allt fler <a href="https://fof.se/artikel/2014/10/ensamboendet-okar-i-hela-varlden-och-sverige-ligger-i-topp/">lever idag ensamma</a>. I USA är trenden att unga kvinnor vill undvika kärlek och romantik eftersom det ses som ett tecken på sårbarhet och svaghet. Man vill undvika det ansvar som en varaktig relation innebär, inte binda sig till en fast partner.</p>
<p>I min bok <em>Incel. Om ofrivilligt celibat och en mansroll i kris</em> (Bazar förlag 2020) beskriver jag de förändringar som skett de senaste årtiondena. Flickorna är nu bättre än pojkarna i samtliga ämnen i grundskolan och gymnasiet. Kvinnorna är i majoritet på i stort sett varje universitetsutbildning. Resultatet är att allt fler välutbildade kvinnor får allt färre män att välja bland – eftersom kvinnor i regel letar partner ”uppåt”.</p>
<p>Jag har länge varnat för följderna av att pojkar och män hamnar på efterkälken – för utan utbildning är man inte särskilt attraktiv på vare sig dejting- eller arbetsmarknaden. Då kan det vara lockande att ta sin tillflykt till internet där karismatiska ledargestalter vet hur man utnyttjar sårbara unga män som lever i ofrivillig ensamhet, och vilkas enda kontakter är med andra män i samma situation.</p>
<p><strong>Andrew Tate</strong> är ett högaktuellt exempel på detta. Tate, en före detta kickboxare som nu sitter häktad i Rumänien misstänkt för trafficking och våldtäkt, hade 4,5 miljoner följare på Instagram innan han blev utslängd därifrån, och från de flesta andra plattformar. Tate, som tycker om att posera framför sina sportbilar med en cigarr i munnen och en pistol i byxlinningen, anser att kvinnors plats är i hemmet, att de inte kan köra bil och att de är mannens egendom.</p>
<h2>Idol för många män</h2>
<p>Numera sprider han sitt toxiska budskap via den sociala plattformen <em>Rumble</em> som är populär bland personer på den politiska högerkanten. Andrew Tate är en idol för många män i alla åldrar, inklusive skolpojkar, som tycker att han är cool och befriande i sitt budskap. Det finns säkert många skäl till att en misogyn clown som Tate hyllas som en ikon på nätet. En av anledningarna är det pyrande missnöje och utanförskap som många män upplever, en känsla av att inte vara inkluderade. En annan anledning kan vara det mansförakt, eller rentav manshat, som en del anser sig vara utsatta för.</p>
<blockquote><p>De tilltagande könsklyftorna med divergerande politiska sympatier och ett mansöverskott utgör inte heller en god jordmån för romantik.</p></blockquote>
<p>När en krönikör på Aftonbladet <a href="https://www.aftonbladet.se/family/a/JQnkM4/ida-soderberg-varfor-stor-vi-oss-pa-sjuka-man">skriver</a>: ”Sjuka män provocerar mig. Kittlar min skamligaste sida. Den utan ordentlig empati” eller när sångerskan <strong>Zara Larsson</strong> <a href="https://www.svt.se/kultur/zara-larsson-kvinnohat-foder-manshat">hävdar</a> att manshat är fullt legitimt eftersom det är en reaktion på kvinnohat, så främjar det knappast förståelsen mellan könen. Kanske är gymnasieeleven <strong>Anton Schröder</strong> någonting på spåren när han i en <a href="https://www.svd.se/a/JQlgKj/anton-18-manshat-har-blivit-normaliserat-pa-tiktok">artikel</a> i Svenska Dagbladet lägger fram sin egen teori kring varför Andrew Tate har kunnat gå hem hos så många unga svenska killar:</p>
<p>”Jag tror att ett av problemen i nuläget är att manshat har blivit så pass normaliserat, exempelvis på Tiktok. Det är liksom okej för en tolvåring att säga &#8217;män är svin&#8217;, &#8217;män förstör allt&#8217; och sådana saker.&#8221;</p>
<p>Reaktioner skapar motreaktioner med en tilltagande polarisering mellan könen som resultat, en ilsken och oförsonlig debatt där den som skriker högst och oftast vinner. Men där de flesta åskådare överhuvudtaget inte känner igen sig.</p>
<h2>Men majoriteten tror på romantiken</h2>
<p>Så vad var mitt svar på frågan om romantikens eventuella död? Kanske att vi kommer att få se helt andra typer av förhållanden i framtiden, relationer där det inte kommer att finnas plats för konventionell romantik och där Tinder-dejter används som snabba genvägar när romantiken anses förlegad och alltför tidskrävande. De tilltagande könsklyftorna med divergerande politiska sympatier och ett <a href="https://fof.se/artikel/2015/6/nu-ar-mannen-fler-an-kvinnorna/">mansöverskott</a> utgör inte heller en god jordmån för romantik.</p>
<p>Samtidigt får dejtingprogram på tv, där bönder söker fruar och folk som gifter sig vid första ögonkastet, skyhöga tittarsiffror. Filmkomedier med romantiskt innehåll sägs vara på väg tillbaka, och inom litteraturen efterfrågas fortfarande feelgood och lyckliga slut.</p>
<p>Under panelsamtalet på Kulturhuset fick publiken i alla fall rösta om de ansåg att romantiken var död. Det är den inte, enligt majoriteten.</p>
<p>Så kanske finns det, trots allt, plats för romantik även i en digital tid.</p>
<div class="author-byline">Stefan Krakowski är psykiater, skribent och författare, aktuell med boken &#8221;Incel. Om ofrivilligt celibat och en mansroll i kris&#8221;.
</div>
</div>
