Den här måste du läsa!

<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%2Fden-har-maste-du-lasa-sensomriga-boktips-fran-kvartal-kultur%2F&amp;t=Den+h%C3%A4r+m%C3%A5ste+du+l%C3%A4sa%21"    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=Den+h%C3%A4r+m%C3%A5ste+du+l%C3%A4sa%21+-+https%3A%2F%2Fkvartal.se%2Fartiklar%2Fden-har-maste-du-lasa-sensomriga-boktips-fran-kvartal-kultur%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%2Fden-har-maste-du-lasa-sensomriga-boktips-fran-kvartal-kultur%2F"    target = "_blank"    class  = "li-link"    title  = "Dela på LinkedIn"><i class="ti-linkedin ui transparent"></i></a><a href    = "mailto:?subject=Den här måste du läsa!&body=https://kvartal.se/artiklar/den-har-maste-du-lasa-sensomriga-boktips-fran-kvartal-kultur/"   target  = "_blank"    class   = "pr-link"    title   = "E-posta"    onclick = ""><i class="ti-email ui transparent"></i></a><a href    = "https://kvartal.se/skriv-ut/100163/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/100163/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> | 29 juli 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%2Fden-har-maste-du-lasa-sensomriga-boktips-fran-kvartal-kultur%2F&amp;t=Den+h%C3%A4r+m%C3%A5ste+du+l%C3%A4sa%21"    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=Den+h%C3%A4r+m%C3%A5ste+du+l%C3%A4sa%21+-+https%3A%2F%2Fkvartal.se%2Fartiklar%2Fden-har-maste-du-lasa-sensomriga-boktips-fran-kvartal-kultur%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%2Fden-har-maste-du-lasa-sensomriga-boktips-fran-kvartal-kultur%2F"    target = "_blank"    class  = "li-link"    title  = "Dela på LinkedIn"><i class="ti-linkedin ui transparent"></i></a><a href    = "mailto:?subject=Den här måste du läsa!&body=https://kvartal.se/artiklar/den-har-maste-du-lasa-sensomriga-boktips-fran-kvartal-kultur/"   target  = "_blank"    class   = "pr-link"    title   = "E-posta"    onclick = ""><i class="ti-email ui transparent"></i></a><a href    = "https://kvartal.se/skriv-ut/100163/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/100163/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 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 10 min</span></a><a href   = "https://kvartal.se/skarmlasarvanlig/100163"    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-100163">  <div class="in-short-inner">    <span class="close_button close-in-short in-short-toggle" data-articleid = "100163"></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  rest-hidden ">
<h3><strong>Carl-Axel Fall:</strong> Gäddan, ån, fjället</h3>
<h6><strong>Hans Lidman:</strong> <em>Gäddan som alltid högg</em> (LTs Förlag 1964)</h6>
</div>
<p><a class="shadow-button noselect article-read-more-btn las-mer-100163"  data-articleid="100163">  <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">Läs mer</span>      <span class="open-text">Visa mindre</span>    </span>  </span></a></p>
<div class="rest-of-article  hidden ">
<p>Det är snart femtio år sedan<strong> Hans Lidman</strong> gick bort, men han är ingalunda bortglömd. Lidman skrev om äventyr, natur och fiske. Ingen har varit lika produktiv i de ämnena som han. Ingen har heller varit lika bra.</p>
<p>Han kunde skriva både vackert och mörkt. Med ett rakt språk och en slags saklig mystik fångade han läsarna. <a href="https://hanslidman.se/">Böckerna</a> från hemtrakterna i Hälsingland är säkra kort.</p>
<h6><strong>Mikael Engström: </strong><em>Med korpen vid ån</em> (Rabén &amp; Sjögren 1992)</h6>
<p>Han har skrivit i svensk fiskepress sedan 1970-talet, hundratals artiklar och är en dramatiker av rang men även känd för sina barn- och ungdomsböcker.</p>
<p>I höst kommer <em>Den ofulländade fiskaren</em>, hett emotsedd. Engströms stil är rolig och ofta svart på en gång. Har du tur kan du kanske hitta exempelvis <em>Med korpen vid ån</em> på något antikvariat.</p>
<h6><strong>Owe Landström:</strong> <em>Där fiskestigen slutar</em> (Settern, 2014)</h6>
<p>Handlar om fiskaren och författaren <strong>Casten Lorange</strong> som levde ett flashigt Stockholmsliv, men som sommartid drogs till otillgängliga fjälltrakter. Den sista fiskesommaren slutade med att Lorange dog, utsvulten och trött. Landström, som bara skrivit denna bok, spekulerar intressant om detta liv.</p>
<p>Förordet är skrivet av <strong>Gunnar Westrin</strong>, en författare som med sina böcker lockat många upp på fjället.</p>
<p><em><a href="https://kvartal.se/medverkande/carl-axel-fall/">Carl-Axel Fall </a>är journalist och tidigare chefredaktör för Naturskyddsföreningens tidning Sveriges natur.</em></p>
<p style="text-align: center;">*</p>
<h3><strong>Caroline Lindblad</strong>: <em>Hjärnkirurgi, astroctyter, psykedelika</em></h3>
<h6><strong>Henry Marsh</strong>: <em>Do no harm – stories of life, death, and brain</em> surgery (St. Martin’s Press, 2014)</h6>
<p>”<em>If we operate there is no realistic chance of his getting back to an independent life</em>” utbrister <strong>Henry Marsh</strong> i kapitlet om traumatiska hjärnskador till en av sina yngre kollegor. Trots detta opereras patienten, men förgäves. Den unge cyklisten utan hjälm blir till slut organdonator, en reflektion av hur dyster prognosen för denna vanliga sjukdomsgrupp fortfarande är. Trots att Henry Marshs bok om neurokirurgi bitvis snuddar vid kliché beskriver den något som ligger ganska nära vardagen inom neurokirurgi, om än med en dråplig fond av brittisk offentlig sektor.</p>
<h6><strong>Ben Barres</strong>: <em>The autobiography of a transgender scientist</em> (The MIT Press, 2018)</h6>
<p>Min största vetenskapliga förebild är <strong>Ben Barres</strong>, vars forskargärning ägnades astrocyten, hjärnans stjärnformade och vanligaste cell. Märkligt nog så har intresset för astrocyter varit ganska ljumt historiskt och Barres har varit en av de viktigaste forskarna för att öka kunskapen runt denna mångfacetterade cell. Kort efter Barres alltför tidiga bortgång publicerades denna självbiografi som handlar om liv och vetenskap men även aktivism. Barres hade den unika erfarenheten att ha forskat både som kvinna och man, vilken gjorde honom till en debattör för kvinnors villkor.</p>
<h6><strong>Leonidas Aretakis:</strong><em> Extas i folkhemmet – Sveriges psykedeliska historia</em> (Natur och Kultur, 2022)</h6>
<p>Jag satt på ett slott i Danmark för ett år sedan och hörde dess ägare beskriva <em>ayahuasca</em> som sitt livs största upplevelse (slottsägaren hade precis fått barn, ska tilläggas). Ungefär samtidigt publicerades denna bok, som initialt irriterar mig ofantligt genom att använda anekdotiska rekreationella erfarenheter som existensberättigande för psykedelika inom sjukvården. Boken mognar dock till en mer balanserad och läsvärd skildring. Ackumulerad evidens kan förväntas bryta den dramatiska polarisering som finns mellan okritisk trippositivism och kategoriskt moraliserande till förmån för ett något torrare faktiskt vetande.</p>
<p><em><a href="https://kvartal.se/medverkande/caroline-lindblad/">Caroline Lindblad</a> är ST-läkare under utbildning till hjärnkirurg </em><em>vid</em><em> Akademiska sjukhuset Uppsala</em></p>
<p style="text-align: center;">*</p>
<h3><strong>Ola Wong</strong>: Boomers, ukrainsk krigsdagbok, Woolf</h3>
<h6><strong>Johanna Frid: </strong>Haralds mamma (Albert Bonniers förlag, 2023)</h6>
<p><em>”Jag låg på golvet igen, på min vanliga fäll som var alldeles för liten – gjorde de inte större får?”</em></p>
<p><strong>Suzanne Ostens</strong> generation höjde sina röster så att till slut var de det enda som kunde höras.</p>
<p><strong>Johanna Frids</strong> generation är ständigt kränkt över att tillvaron inte anpassar sig efter deras förväntningar. Kraschen är episk när de möts. Om <em>Haralds mamma </em>inte vinner Augustpriset är världen sjukt irriterande, vilket <strong>Johanna Frid</strong> helt klart instämmer i.</p>
<h6><strong>Andrej Kurkov</strong>: <em>Dagbok från en invasion </em>(Natur &amp; Kultur, 2023)</h6>
<p>Kriget kommer. Någon annans lägenhet blir familjens nya hem. Pilaffkryddor får sin nya plats i köket. Kurkov skriver lugnt som ett fikasamtal med en gammal klok vän om perioden från nyåret 2021 till sommaren 2022. Mycket handlar om att utmejsla kontrasten mellan ett livsbejakande, pumpaodlande Ukraina och den dödsdriftande grannen. Det ryska skräckexemplet visar hur farligt det är att låta offerrollen få vara grundstomme i ett nationellt identitetsbygge.</p>
<h6><strong>Virgina Woolf</strong>: <em>A Room of One&#8217;s own</em> (1929)</h6>
<p>Författaren <strong>Virgina Woolf</strong> går till biblioteket och läser böcker om vad den tidens kulturelit skriver om kvinnan: Hon är en löjlig, tafatt och underlägsen figur. Nu har de 100 år snart gått som Woolf förutsåg skulle behövas för att kvinnor skulle uppnå jämlikhet, och vad möter en besökare till dagens universitetsbibliotek? Det stående temat från dagens kulturelit är hur usla och odugliga män är, vilket alla som följt <strong>Åsa Beckman</strong> på DN Kultur genom åren vet (som ett exempel i mängden).</p>
<p>När denna klassiker diskuteras idag glöms ofta ett av textens kärnbudskap bort: Låt inte personlig bitterhet över orättvisor märkas i ditt verk! Perfektion uppnås när man är ärlig mot berättelsens personer och inte mot någon agenda. Dagens manosfär saknar inte arga motröster, men ingen är i närheten av Woolfs stilnivå.</p>
<p><em>Ola Wong är Kvartals Kulturredaktör. För fler boktips från Ola, se<a href="https://kvartal.se/artiklar/sommarens-boktips-fran-kvartal-kultur/"> Sommarens boktips</a> som publicerades i juni.</em></p>
<p style="text-align: center;">*</p>
<figure id="attachment_100186" aria-describedby="caption-attachment-100186" style="width: 972px" class="wp-caption alignnone"><img fetchpriority="high" decoding="async" class="wp-image-100186 size-full" src="https://kvartal.se/wp-content/uploads/2023/07/Tech-hare.png" alt="" width="972" height="972" data-wp-pid="100186" srcset="https://kvartal.se/wp-content/uploads/2023/07/Tech-hare.png 972w, https://kvartal.se/wp-content/uploads/2023/07/Tech-hare-600x600.png 600w, https://kvartal.se/wp-content/uploads/2023/07/Tech-hare-150x150.png 150w, https://kvartal.se/wp-content/uploads/2023/07/Tech-hare-300x300.png 300w, https://kvartal.se/wp-content/uploads/2023/07/Tech-hare-768x768.png 768w" sizes="(max-width: 972px) 100vw, 972px" /><figcaption id="caption-attachment-100186" class="wp-caption-text"><em>Läsning för innovativa. Illustration: AI/Midjourney</em></figcaption></figure>
<h3><strong>Viktor Öwall:</strong> Innovation! Konst! Zen!</h3>
<h6><strong>Jon Gertner</strong>:<em> The Idea Factory – Bell Labs and the Great Age of American Innovation </em>(Penguin books, 2012)</h6>
<p>Bell Labs är ikoniskt för alla som håller på med teknik och har bidragit till många upptäckter som förändrat vår värld. Bland de största enligt mig är transistorn och informationsteorin, men det finns så mycket mer. Boken beskriver inte bara upptäckterna utan även de fascinerande personerna bakom, som <strong>William Shockley </strong>och <strong>Claude Shannon</strong>. Den är förståelig även för icke teknik-nördar.</p>
<h6><strong>David Hockney</strong>: <em>Secret Knowledge – Rediscovering the lost techniques of the Old Masters</em> (Viking studio, 2001)</h6>
<p>Vid ett besök på National Gallery i London fångades <strong>David Hockney</strong> av det skifte inom konsten han uppmärksammade under renässansen. Realism och perspektiv tycktes genomgå en ganska abrupt förändring. I <em>Secret Knowledge</em> framför han tesen att konstnärer som <strong>Caravaggio</strong>, <strong>Velázquez</strong>, <strong>Holbein</strong> och <strong>Leonardo da Vinci</strong> använde speglar och linser för att skapa sina mästerverk. Kontroversiellt då och fascinerande läsning än idag!</p>
<h6><strong>Robert M. Pirsig</strong>: <em>Zen and the Art of Motorcycle Maintenance</em> (William Morrow and Company, 1974)</h6>
<p>Kvalité är ett begrepp vi diskuterar ofta inom universitetsvärlden, eller kanske snarare kvalitetssäkring. I dessa diskussioner har jag ofta refererat till denna klassiker från 1970-talet. Huvudpersonen/författaren ger sig ut på en motorcykeltur med sin son från Minneapolis till San Francisco och historien varvas med filosofiska diskussioner. Motorcyklar är i sammanhanget en bisak. En bok som lever kvar i mitt minne efter många år!</p>
<p><em>Viktor Öwall är professor i integrerade elektroniksystem och vicerektor för Lunds universitet. </em><em> </em></p>
<p style="text-align: center;">*<strong> </strong></p>
<h3><strong>Eva Haettner Aurelius: </strong>Två ryska soldater &amp; en misogyn drottning</h3>
<h6><em>Christina, Självbiografi och aforismer</em> (Natur och kultur 1957), eller <strong>Kristina</strong>: <em>Brev och skrifter</em>. (Svenska klassiker utg. av Svenska akademien, 2006)</h6>
<p>Drottningens misogyni är det psykologiskt mest intressanta draget i detta, tyvärr oavslutade, verk.</p>
<h6><strong>Ida Börjel</strong>: <em>Ringa hem</em>. (Ariel förlag, 2022)</h6>
<p>Ondskans uppriktighet. Telefonsamtal hem från ryska soldater i Ukrainakriget återgivna som dikter: fasaväckande. Förordet till boken <em>Ondskans uppriktighet</em>, är skrivet av författaren <strong>Sergej Lebedev </strong>och sätter in den ryska krigföringen i Ukraina i ett längre politiskt sammanhang.</p>
<h6><strong>Vasilij Grossman</strong>: <em>Liv och öde </em>(Historiska media, 2007)</h6>
<p>Det stora verket om slaget vid Stalingrad och det sovjetiska systemets lögner, angiveri och brutalitet, liksom om det nazistiska systemets fasor.</p>
<p><em>Eva Haettner Auerlius är professor i litteraturvetenskap vid Lunds universitet.</em></p>
<p style="text-align: center;">*<strong> </strong></p>
<h3><strong>Jonas A Eriksson:</strong> Teknikutveckling, långt liv &amp; svarta svanar</h3>
<h6><strong>Daron Acemoglu</strong> och <strong>Simon Johnson</strong>: <em>Power and Progress</em> (Public Affairs, 2023)</h6>
<p>Ekonomiprofessorerna <strong>Daron Acemoglu</strong> och <strong>Simon Johnson</strong> ger sig in i teknik och AI-debatten. Boken blickar tillbaka tusen år då människan har fått det mycket bättre, men framsteg för den stora massan har inte skett med automatik. Vad som är bra för techgiganter som <strong>Elon Musk</strong>, <strong>Bill Gates </strong>och <strong>Steve Jobs</strong> behöver inte nödvändigtvis vara bra för hela befolkningen.</p>
<h6><strong>Howard J. Luks</strong>: <em>Longevity Simplified</em> (KWE Publishing, 2022)</h6>
<p>Idrottsläkaren och ortopeden <strong>Howard J. Luks</strong> berättar vad vetenskapen säger om hur vi kan leva friska längre. Det handlar om att <em>vara i rörelse</em> så mycket det går, gärna i så där lagom takt, att undvika processad mat och att odla sociala kontakter. Som man gör på platser där människor lever mätbart längre, som Sardinien, Okinawa eller Markaryd för den delen.</p>
<h6><strong>Nassim Nicholas Taleb</strong>: <em>The Black Swan: The Impact of the Highly Improbable </em>(Random House, 2007)</h6>
<p>Beskriver hur människor hela tiden gör felaktiga riskbedömningar som bidrar till ekonomiska kriser och kan förvärra existentiella tillstånd som miljö-/klimatproblem och pandemier. En femton år gammal bok som är ständigt aktuell. Amazons grundare <strong>Jeff Bezos </strong>tvingar alla sina chefer att läsa boken. Jag intervjuade <a href="https://kvartal.se/artiklar/riskprofessor-svenskarna-som-sjalvmant-anpassat-sig-till-pandemin-kan-ha-raddat-tiotusentals-liv/"><strong>Taleb</strong></a> för ett par år sedan för Kvartal.</p>
<p><a href="https://kvartal.se/medverkande/jonas-a-eriksson/"><em>Jonas A Eriksson</em></a><em> är finansanalytiker och skribent för Kvartal. </em></p>
<p style="text-align: center;">*</p>
<figure id="attachment_100753" aria-describedby="caption-attachment-100753" style="width: 1024px" class="wp-caption alignnone"><img decoding="async" class="wp-image-100753 size-full" src="https://kvartal.se/wp-content/uploads/2023/07/bengt2023_black_ink_on_white_background_of_a_white_rabbit_court_96e866a4-5431-409a-a30b-853382533f3d.png" alt="" width="1024" height="1024" data-wp-pid="100753" srcset="https://kvartal.se/wp-content/uploads/2023/07/bengt2023_black_ink_on_white_background_of_a_white_rabbit_court_96e866a4-5431-409a-a30b-853382533f3d.png 1024w, https://kvartal.se/wp-content/uploads/2023/07/bengt2023_black_ink_on_white_background_of_a_white_rabbit_court_96e866a4-5431-409a-a30b-853382533f3d-600x600.png 600w, https://kvartal.se/wp-content/uploads/2023/07/bengt2023_black_ink_on_white_background_of_a_white_rabbit_court_96e866a4-5431-409a-a30b-853382533f3d-150x150.png 150w, https://kvartal.se/wp-content/uploads/2023/07/bengt2023_black_ink_on_white_background_of_a_white_rabbit_court_96e866a4-5431-409a-a30b-853382533f3d-300x300.png 300w, https://kvartal.se/wp-content/uploads/2023/07/bengt2023_black_ink_on_white_background_of_a_white_rabbit_court_96e866a4-5431-409a-a30b-853382533f3d-768x768.png 768w" sizes="(max-width: 1024px) 100vw, 1024px" /><figcaption id="caption-attachment-100753" class="wp-caption-text"><em>Så påverkar nätdejtandet romantiken. Oscar Swartz tipsar om böcker om sexualitet.. </em></figcaption></figure>
<h3><strong>Per-Arne Bodin</strong>: Sex i Ukraina, kavalleristflickan, sjön</h3>
<h6><strong>Oksana Zabuzjko</strong>: <em>Fältstudier i ukrainskt sex</em>. (Norstedts, nyutgåva 2022, Översättning: Irina Voltjanskaja)</h6>
<p>Ukrainsk kultroman från 1990-talet som är en rasande vidräkning med ryska imperiefasoner och ukrainska mäns machoideal. Boken är en lika ursinnig uppgörelse med de presumtiva åhörarna. Den utger sig för att vara ett föredrag om Ukraina hållet för en västerländsk publik, som inte förstår något av Ukrainas eller för den delen den ukrainska författarens villkor och egentligen inte vill förstå någonting. En bok om det moderna Ukraina och dess belägenhet.</p>
<h6><strong>Nadezjda Durova</strong>: Kavalleristflickans anteckningar: tilldragelse i Ryssland (Ruin, 2919, Översättning Nils Håkanson).</h6>
<p>Boken handlar om en ung rysk kvinna under 1800-talets första hälft som rymmer hemifrån, klär sig som man, tar värvning som soldat och är med i kriget mot <strong>Napoleon</strong>. <strong>Durova</strong> presenterar sin bok som en självbiografi, men som framgår i översättarens efterord är mycket i boken skruvad fiktion. Hennes mål med flykten är inte att bli krigshjälte utan att bli fri från sin mor och från kvinnorollen. Hon bokför framgångarna som soldat men ännu mer plågsamma eller pinsamma motgångar. Alla blir förvirrade över hennes genustillhörighet, till sist också läsaren genom flera byten av namn och användningen av olika grammatiska former.  Till och med att kalla henne <strong>Nadezjda</strong>, som var hennes dopnamn, känns fel för att inte tala om att skriva ”hon”. Tyvärr avbryter förlaget och översättaren berättelsen när den är som mest spännande. Skulle vara välkommet med en andra och utökad upplaga.</p>
<h6><strong>Sofia Andruchovytjs</strong>: <em>Amadoka </em>(2020)</h6>
<p>I romanen berättas om <strong>Bohdan</strong> som förlorat minnet efter att ha blivit sårad i Donetsk 2014 och hans hustru <strong>Romana</strong> som vill ge honom det tillbaka – men i själva verket, misstänker läsaren, berättar en påhittad historia för honom. Amadoka är namnet på en sjö som finns på gamla kartor över Ukraina, men i romanen får representera ett förlorat lyckorike. Nu får den, paradoxalt nog, en att tänka på översvämningen till följd av sprängningen av dammen i Nova Kachovka. Samtidigt är <strong>Sofia Andruchovytjs</strong> bok en generationsroman som tar sin början på 1930-talet och behandlar förhållandet mellan ukrainare och judar under tiden före och under andra världskriget, en av de svåraste frågorna i den ukrainska nutidshistorien. Romanen finns översatt till tyska och har nyligen tilldelats <em>Sholem Aleichem</em>&#8211;<em>priset</em>.</p>
<p><em><a href="https://kvartal.se/artiklar/bockerna-som-hjalper-dig-att-forsta-ryssland/">Per-Arne Bodin</a> är professor emeritus i slaviska språk med litterär inriktning vid Stockholms universitet.</em></p>
<p style="text-align: center;">*</p>
<h3><strong>Oscar Swartz</strong>: Dejting &amp; könsfakta</h3>
<h6><strong>Marie Bergström:</strong><em> Kärlekens nya lagar: Hur nätdejting förändrar våra relationer (Fri Tanke, 2023)</em></h6>
<p>Bergström undersöker nätdejting empiriskt. Speciellt ”ojämlikheten” mellan könen beläggs. Unga män får nästan aldrig napp. En orsak är heterosexualitetens hypergami, tendensen för kvinnor att dejta uppåt i ålder och status. Som sociolog ger Bergström inga ultimata förklaringar: Folk följer skript, roller, normer, uppfyller förväntningar. Frågan är ju varför. Nästa bok ger insikter!</p>
<h6><strong>David M. Buss</strong><em>: The Evolution of Desire: Strategies of Human Mating (Basic Books, 2016)</em></h6>
<p>Som examinerad genusvetare vet jag att den disciplinen är ideologisk och ofta skyr empiri. Den som vill förstå kön och sexualitet får vända sig åt annat håll. Data från undersökningar jorden runt visar att evolutionär psykologi har bra förklaringsvärde och ofta bjuder på dråplig igenkänningsfaktor.</p>
<h6><strong>Olga Ravn</strong><em>: Celestine </em>(Wahlström &amp; Widstrand, 2016)</h6>
<p>Kort gurlesk roman (”feministisk strömning med inslag av både gullighet och groteska element”). En ung lärarinna har ingen livsplan, är besatt av <strong>Celestine</strong> som levande murades in av sin familj, tullar på elevernas gömda sprit och åtrår unga kroppars utsöndringar. Nå, <strong>Olga Ravn</strong> är dansk! Skev läsning i en tid när kulturkvinnor vill att karlar uppvaktar sydländskt men torkar köksbord nordiskt.</p>
<p><em><a href="https://kvartal.se/medverkande/oscar-swartz/">Oscar Swartz </a>är ekonom, frihetlig skribent och it-entreprenör.</em></p>
<div class="author-byline">Ola Wong är Kvartals kulturredaktör, Kina-kännare och författare.
</div>
</div>
