Av Ola Wong | 24 juni 2023
I korthet
Lapo Lappin: Sanning, självutlämnande & kulturkrasch
Axel Burénius: Persona (Fri tanke, 2023)
Ger en närmare inblick i belarusiska Nobelpristagaren Svetlana Aleksijevitj verk. Aleksijevitj blev känd för sina råa, ocensurerade intervjuböcker om krig och katastrofer. Men när Burénius studerar materialet närmare hittar han sprickor i hjältebilden av en Sovjetisk dissident som skildrar verkligheten. Burénius bestämmer sig då för att utföra intervjuer i Aleksijevitjs stil med ukrainska flyktingar i Sverige – men är hans metoder lika tvivelaktiga?
<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%2Fsommarens-boktips-fran-kvartal-kultur%2F&amp;t=Sommarens+boktips+fr%C3%A5n+Kvartal+Kultur"    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=Sommarens+boktips+fr%C3%A5n+Kvartal+Kultur+-+https%3A%2F%2Fkvartal.se%2Fartiklar%2Fsommarens-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%2Fsommarens-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=Sommarens boktips från Kvartal Kultur&body=https://kvartal.se/artiklar/sommarens-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/99502/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/99502/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> | 24 juni 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%2Fsommarens-boktips-fran-kvartal-kultur%2F&amp;t=Sommarens+boktips+fr%C3%A5n+Kvartal+Kultur"    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=Sommarens+boktips+fr%C3%A5n+Kvartal+Kultur+-+https%3A%2F%2Fkvartal.se%2Fartiklar%2Fsommarens-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%2Fsommarens-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=Sommarens boktips från Kvartal Kultur&body=https://kvartal.se/artiklar/sommarens-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/99502/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/99502/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 11 min</span></a><a href   = "https://kvartal.se/skarmlasarvanlig/99502"    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-99502">  <div class="in-short-inner">    <span class="close_button close-in-short in-short-toggle" data-articleid = "99502"></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 ">
<h3>Lapo Lappin: Sanning, självutlämnande &amp; kulturkrasch</h3>
<h6><strong>Axel Burénius</strong>: <em>Persona</em> (Fri tanke, 2023)</h6>
<p>Ger en närmare inblick i belarusiska Nobelpristagaren <strong>Svetlana Aleksijevitj </strong>verk. Aleksijevitj blev känd för sina råa, ocensurerade intervjuböcker om krig och katastrofer. Men när <strong>Burénius</strong> studerar materialet närmare hittar han sprickor i hjältebilden av en Sovjetisk dissident som skildrar verkligheten. Burénius bestämmer sig då för att utföra intervjuer i Aleksijevitjs stil med ukrainska flyktingar i Sverige – men är hans metoder lika tvivelaktiga?</p>
</div>
<div class="rest-of-article ">
<h6><em>Mary Karrs: The Art of the Memoir (Harper Collins, 2016)</em></h6>
<p>Det självbiografiska, självutlämnande skrivandet har varit hett debatterat på kultursidorna under våren, med inlägg om<strong> Karl-Ove Knausgård</strong>,<strong> Hanna Hellquist</strong> och <strong>Alex Schulman</strong>. Litteraturprofessorn <strong>Mary Karrs </strong><em>The Art of the Memoir</em> (2016) vrider och vänder på ämnet efter att ha läst några tusen självbiografier och själv ha skrivit den bästsäljande självbiografin <em>The Liars Club.</em> Boken är dels en introduktion till de stora mästarna i den självbiografiska genren, dels en praktisk instruktionsbok i hur man skriver memoarer. Karr tacklar alla de jobbiga frågorna: Blir man kvitt trauman genom att skriva om dem? Vad har man för moraliskt ansvar gentemot människor man skriver om?  Och hur mycket får man hitta på?</p>
<p>(Karrs svar: Ingenting.)</p>
<h6><em>Heinrich Heine: Om religionens och filosofins historia i Tyskland (Ruin, 2022)</em></h6>
<p>Den torra titeln till trots är detta en enormt underhållande bok. Heines essä har pekats ut som en avgörande inspiration för filosofen <strong>Friedrich Nietzsche</strong>. Heines bitande satir är ett stilistiskt mästerverk, men utgör också ett tidsdokument över en civilisation som kollapsar under sin egen vikt. Här i en lysande nyöversättning av<strong> Staffan Vahlquist</strong>.</p>
<p><em><a href="https://kvartal.se/medverkande/lapo-lappin/">Lapo Lappin</a> är skribent för Kvartal Kultur. </em></p>
<p style="text-align: center;">*</p>
<h3>Marika Lagercrantz: Antidepp, klassresa &amp; en skåning</h3>
<h6><em>Michael Houellebecq: Serotonin (Albert Bonniers förlag, 2019, översättning Sara Gordan)</em></h6>
<p>Huvudpersonen heter <strong>Florent-Claude</strong> och är en agronom och byråkrat som till vardags utreder det europeiska jordbruksstödets konsekvenser. Därtill är han deprimerad och trött på sin flickvän. I ett försök att bryta tristessen flyr han till den franska landsbygden, och möter en värld som ödelagts av globaliseringen och den moderna jordbrukspolitiken. Det enda som håller honom flytande är 10 milligram Captorix om dagen, som dock gör honom gradvis mer impotent.</p>
<p>Trots ett visst motstånd i början läste jag den här med stor glädje och jag bär den med mig nu när sommaren är här och jag blickar ur över åkrarna och funderar över svenskt jordbruk.</p>
<h6><em>Edouard Louis: Att förändras: en metod (Wahlström &amp; Widstrand, 2022, översättning Marianne Tufvesson).</em></h6>
<p>Jag läste den i ett andetag och nu har vänner och familj läst och diskuterat den sedan dess. Författaren återvänder till sin ungdom och beskriver sin resa från fattigdom och misär till där han befinner sig idag som en av Europas mest framgångsrika författare. Han talar dels till sin far, vars värld han föraktar och vill lämna, dels till sin ungdomsvän Elena, som hjälpte honom att göra denna osannolika klassresa. Kanske ber han dem om ursäkt för att han utnyttjade dem, kanske inte.</p>
<h6><em>Maria Maunsbach: Lucky Lada och jag (Natur &amp; Kultur Allmänlitteratur, 2022)</em></h6>
<p>Huvudpersonen <strong>Freja Morgenstjerne</strong> är strax över 30, barnlös och singel, och återvänder till barndomens Höör över jul. Freja, som är en lätt parodi på författaren själv, har bestämt sig för att skriva sin egen version av <strong>Fritiof Nilsson Piratens</strong> skånska nationalepos <em>Bombi Bitt och jag</em>. De har något gemensamt tycker hon: ”Han en icke litterär författare, jag en knullförfattare.”</p>
<p>I stället för hans karnevaliska klimax på Kiviks marknad ska Freja gå på hemvändarkväll på Höörs nöjespalats Lucky Lada, Ladan kallat. Hon sitter hemma hos sin sedan länge frånskilda mor och textar kompisar från förr. För varje person, en ny historia. Mellan varven drar bokens sidekick, morsan, anekdoter på bred skånska. Maria Maunsbach är så rolig att jag då och då skrattar högt. Befäster hon myten om den jovialiske skåningen? Ja och nej. Men med kvinnor i huvudrollen, det gör skillnad.</p>
<p><em>Marika Lagercrantz är skådespelare och inläsare för Kvartal.</em></p>
<p style="text-align: center;">*</p>
<figure id="attachment_99699" aria-describedby="caption-attachment-99699" style="width: 972px" class="wp-caption alignnone"><img fetchpriority="high" decoding="async" class="wp-image-99699 size-full" src="https://kvartal.se/wp-content/uploads/2023/06/Bengt2023_illustration_style_black_ink_on_white_background_of_a_d85a3f97-c9b2-4271-99f8-3778e1af2e17.png" alt="" width="972" height="972" data-wp-pid="99699" srcset="https://kvartal.se/wp-content/uploads/2023/06/Bengt2023_illustration_style_black_ink_on_white_background_of_a_d85a3f97-c9b2-4271-99f8-3778e1af2e17.png 972w, https://kvartal.se/wp-content/uploads/2023/06/Bengt2023_illustration_style_black_ink_on_white_background_of_a_d85a3f97-c9b2-4271-99f8-3778e1af2e17-600x600.png 600w, https://kvartal.se/wp-content/uploads/2023/06/Bengt2023_illustration_style_black_ink_on_white_background_of_a_d85a3f97-c9b2-4271-99f8-3778e1af2e17-150x150.png 150w, https://kvartal.se/wp-content/uploads/2023/06/Bengt2023_illustration_style_black_ink_on_white_background_of_a_d85a3f97-c9b2-4271-99f8-3778e1af2e17-300x300.png 300w, https://kvartal.se/wp-content/uploads/2023/06/Bengt2023_illustration_style_black_ink_on_white_background_of_a_d85a3f97-c9b2-4271-99f8-3778e1af2e17-768x768.png 768w" sizes="(max-width: 972px) 100vw, 972px" /><figcaption id="caption-attachment-99699" class="wp-caption-text"><em>Lästips för fåtöljstrategen</em>. Illustration: AI/Midjourney</figcaption></figure>
<h3>Stefan Ring: Kriget, Bulldogen och den besegrades blick</h3>
<h6><strong>Carl von Clausewitz</strong>, <em>Om kriget</em> (Bonniers, 1991)</h6>
<p>I den tid vi lever i, där krig i Europa på nytt blivit en del av vardagen, är förståelsen av krigets natur och karaktär en inte oviktig kunskap. Den som formulerat de djupaste tankarna om dessa frågor är den preussiske generalen <strong>Carl von Clausewitz</strong>. Klassisk är hans analys: ”… krig är bara en fortsättning på politiken med andra medel.”</p>
<h6><strong>Alan Brooke:</strong> <em>War Diaries – 1939–1945</em> (Weidenfield &amp; Nicolson, 2001)</h6>
<p>Hur är det att vara närmaste militär rådgivare till en ytterst drivande person som ofta lägger sig i detaljer och som inte alltid har lätt att lyssna till andra. Alan Brooke ger en unik inblick i sin dagbok som han skrev för sin hustru. ”<strong>Churchill</strong> är den värste person jag någonsin arbetat med, men vi skulle inte klara oss utan honom.”</p>
<h6><strong>André Beaufre</strong>: <em>The Suez Expedition 1956</em> (Frederick A. Praeger, 1969)</h6>
<p>Den franske generalen <strong>André Beufre</strong> fick under sin karriär uppleva många franska nederlag. Tysklands seger 1940, kriget i Indo-Kina och Algeriet-revolten<span style="color: #ff0000;"><span style="color: #000000;">.</span></span> Dessutom var han chef för den franska militärstyrkan vid den misslyckade expeditionen mot Egypten 1956. Från den besegrades perspektiv gör han en tänkvärd analys som gäller även idag.</p>
<p><em><a href="https://kvartal.se/medverkande/stefan-ring/">Stefan Ring</a> är tidigare huvudlärare i strategi vid Försvarshögskolan.</em></p>
<p style="text-align: center;">*</p>
<h3>Åsa Nilsonne: Minnen, äckel &amp; mänsklighetens historia</h3>
<h6><strong>Julia Korkman</strong>: <em>Minnets makt, berättelser från rättssalen</em> (Schildts Söderströms, 2022)</h6>
<p>Vi lever alla med våra minnen, delvis styrs vi av dem. Men hur tillförlitliga är de? Här är en bok av en minnesforskare och rättspsykolog som kan ge oss användbara insikter om vad vi minns, hur och varför.En bättre förståelse för vårt dynamiska minne kan underlätta stort i vardagen.</p>
<h6><strong>Patrik Lindenfors</strong>: <em>Äckel: smitta, synd, samhälle</em> (Ordfront, 2023)</h6>
<p>Kan en känsla som äckel ha en politisk dimension? Ja, säger evolutionsforskaren Patrik Lindenfors. Han ger oss en kvalificerad och underhållande guidning i äcklets biologi och sociologi. Och dess betydelse för vår moral. Jag kan nästan garantera läsaren nya oväntade idéer och perspektiv.</p>
<h6><strong>David Graeber</strong> och <strong>David Wengrow</strong>: <em>Början på allt: en ny historia om mänskligheten </em>(Volante, 2022)</h6>
<p>Här kommer ett radikalt nytt perspektiv på mänsklighetens historia. Den tidiga människan var, enligt författarna, mer kreativ, mer demokratisk och mer flexibel än vi brukar anta. Här ges även utrymme för<span style="color: #0000ff;"><strong> </strong></span>innovationer som troligen skapades av kvinnor – vem tror ni exempelvis upptäckte att det går att baka bröd? En optimistisk och väl underbyggd bok, lång men läsvärd!</p>
<p><em><a href="https://kvartal.se/medverkande/sa-nilsonne/">Åsa Nilsonne</a> är psykiater och professor emeritus i medicinsk psykologi vid Karolinska Institutet i Stockholm.</em></p>
<p style="text-align: center;">*</p>
<h3>Lars Anell: Europa, euron &amp; EU</h3>
<h6><strong>Tony Judt</strong>: <em>Postwar – A History of Europe since 1945</em> (William Heinemann, 2005).</h6>
<p>Boken handlar inte i första hand om EU, men den ger en magnifik beskrivning av den miljö i vilken organisationen föddes och utvecklades. Under lång tid kunde ledande politiker från de sex länder som grundade organisationen arbeta utan att den hamnade på den politiska dagordningen. En av EU:s grundare, <strong>Paul Henri Spaak</strong>, tyckte att detta var förutsättningen för ett gott resultat.</p>
<h6><strong>Ashoka Mody</strong>: <em>Euro Tragedy. A Drama in Nine Acts</em> (Oxford University Press, 2018).</h6>
<p>Det var en länge närd dröm inom Europas politiska elit som gick i uppfyllelse när euron blev en gemensam valuta för flertalet medlemsländer. Den är nu ett politiskt faktum som till varje pris måste räddas. I omvärlden är bedömningen av valutasamarbetet negativ. Vad man än tycker är det nödvändigt att ta del av Modys massiva studie.</p>
<h6><strong>Andrew Moravcsik</strong>: <em>The Choice for Europé </em>(Cornell University Press,1998).</h6>
<p>Det är tillåtet att invända mot Moravcsiks tes att den europeiska integrationsprocessen drevs att nationalstaters snäva realpolitiska intressen – men det är en bra bok också för den som inte håller med. Kanske särskilt för den som inte gör det. Innehåller också en utmärkt översikt över vad som har hänt, från Messina till Maastricht.</p>
<p><em><a href="https://kvartal.se/medverkande/lars-anell/">Lars Anell</a> är Sveriges tidigare ambassadör till EU och WTO.</em></p>
<p style="text-align: center;">*</p>
<p>&nbsp;</p>
<figure id="attachment_99702" aria-describedby="caption-attachment-99702" style="width: 972px" class="wp-caption alignnone"><img decoding="async" class="wp-image-99702 size-full" src="https://kvartal.se/wp-content/uploads/2023/06/Kok-Bengt2023_black_ink_on_white_background_of_a_white_rabbit_cooki_237cd3c5-e039-48ea-b246-90537ec2a3c6.png" alt="" width="972" height="972" data-wp-pid="99702" srcset="https://kvartal.se/wp-content/uploads/2023/06/Kok-Bengt2023_black_ink_on_white_background_of_a_white_rabbit_cooki_237cd3c5-e039-48ea-b246-90537ec2a3c6.png 972w, https://kvartal.se/wp-content/uploads/2023/06/Kok-Bengt2023_black_ink_on_white_background_of_a_white_rabbit_cooki_237cd3c5-e039-48ea-b246-90537ec2a3c6-600x600.png 600w, https://kvartal.se/wp-content/uploads/2023/06/Kok-Bengt2023_black_ink_on_white_background_of_a_white_rabbit_cooki_237cd3c5-e039-48ea-b246-90537ec2a3c6-150x150.png 150w, https://kvartal.se/wp-content/uploads/2023/06/Kok-Bengt2023_black_ink_on_white_background_of_a_white_rabbit_cooki_237cd3c5-e039-48ea-b246-90537ec2a3c6-300x300.png 300w, https://kvartal.se/wp-content/uploads/2023/06/Kok-Bengt2023_black_ink_on_white_background_of_a_white_rabbit_cooki_237cd3c5-e039-48ea-b246-90537ec2a3c6-768x768.png 768w" sizes="(max-width: 972px) 100vw, 972px" /><figcaption id="caption-attachment-99702" class="wp-caption-text"><em>En bra kokbok är också en instruktion i hur man ska förhålla sig till mat, skriver Anna Axfors. Illustration: AI/Midjourney.</em></figcaption></figure>
<h3>Anna Axfors: Poesi, män, mat</h3>
<h6><strong>Henrik Bromander</strong>, <em>Bara en kram</em> (Atlas, 2017)</h6>
<p>I den här romanen får vi komma in i huvudet på en metoo-man, feministen <strong>Jens Svanström </strong>som först är en <em>nobody</em> i en småstad för att sedan flytta till Göteborg och lära sig alla sociala och kulturella koder som behövs för att ta sig ända upp till posten som chefredaktör på en trendig nöjestidning. Men sedan tar det stopp. Vad han gjort för fel förstår varken vi eller han, men hela stan pratar om det.</p>
<blockquote><p>Boken som fick mig att börja äta kött efter femton år som vegetarian,</p></blockquote>
<h6><strong>Lotta Lundgren</strong>, <em>Tio lektioner i matlagning </em>(Wahlström &amp; Widstrand, 2013)</h6>
<p>Boken som fick mig att börja äta kött efter femton år som vegetarian, eftersom jag inte stod ut med att inte veta hur köttrecepten smakade.</p>
<p>Som alla bra kokböcker är denna också en instruktion i hur man ska förhålla sig till mat, bete sig i köket och vilka redskap man behöver. Mitt exemplar är flottigt, det står precis vid spisen eftersom jag när jag står där alltid vill påminnas om att matlagning är en konst.</p>
<h6><strong>Ola Julén</strong>, <em>Orissa</em> (Nirstedt/Litteratur, 2019. Utgiven första gången 1999)</h6>
<p>Poeten <strong>Ola Julén</strong> skriver smärtsamt med bara en rad på varje sida; som om han sliter ut sitt hjärta gång på gång. ”Flätor tycker jag är fint”, kan det låta, och ”Jag längtar tillbaka till Indien”. Han var ett namn i poesikretsar på 90-talet men dog 2013, och fick något av ett postumt genombrott i och med nyutgivningen av <em>Orissa</em> hos det lilla förlaget Nirstedt/Litteratur. De har även publicerat andra, tidigare outgivna, verk av Julén, som är lika läsvärda.</p>
<p><em><a href="https://kvartal.se/medverkande/anna-axfors/">Anna Axfors</a> är skribent för Kvartal Kultur.</em></p>
<p style="text-align: center;">*</p>
<h3>Patrik Wahlén: Hitlers finansiärer, räntor &amp; svensk finanslegend</h3>
<h6><strong>Éric Vuillard</strong>: Dagordningen (Lind &amp; Co, 2021, översättare: Lotta Riad)</h6>
<p>Denna historiska roman gör fängslande och insiktsfulla nedslag vid avgörande ögonblick inför andra världskriget. Boken inleds med att <strong>Hitler</strong> övertygar <strong>Krupp</strong>, <strong>von Opel</strong>, <strong>Siemens</strong> och ytterligare 21 industrimän att rädda nazistpartiet från ekonomisk kris. Tankeväckande och intensiv läsning om moral och makt.</p>
<h6><strong>Edward Chancellor: </strong><em>The Price of Time: The Real Story of Interest</em> (Atlantic Monthly Press, 2022)</h6>
<p>En fascinerande och högaktuell bok som utforskar räntans historia och betydelse. <strong>Chancellor</strong> argumenterar för att låga räntor inte bara skapar prisbubblor utan också i stor utsträckning är<span style="color: #0000ff;"><strong> </strong></span>ansvariga för svag ekonomisk tillväxt, ökande ojämlikhet, zombieföretag, höga skuldnivåer och pensionskriserna som har drabbat västvärlden de senaste åren.</p>
<h6><strong>Mats Hallvarsson, Gustaf Douglas:</strong> <em>Med blicken på stigen</em><strong> (</strong>Albert Bonniers förlag, 2016, nyutgåva 2023)</h6>
<p><strong>Gustaf Douglas </strong>berättar öppenhjärtigt om en mörk uppväxt och sina egna utmaningar. Efter att ha blivit avskedad som vd i Dagens Nyheter-koncernen startade han egna framgångsrika företag som Securitas, Assa Abloy och Latour. Han delar med sig av sina erfarenheter och insikter från näringslivets och politikens värld, samtidigt som han betonar vikten av humanism och ödmjukhet inför livets utmaningar.</p>
<p><em>Patrik Wahlén är entreprenör och styrelseordförande i investmentbolaget Volati [och investerare i Kvartal].</em></p>
<p style="text-align: center;">*</p>
<figure id="attachment_99703" aria-describedby="caption-attachment-99703" style="width: 972px" class="wp-caption alignnone"><img decoding="async" class="wp-image-99703 size-full" src="https://kvartal.se/wp-content/uploads/2023/06/Bengt2023_black_ink_on_white_background_of_a_white_rabbit_in_re_85312ec0-f7d7-497c-a02a-497cf83cdb0e.png" alt="" width="972" height="972" data-wp-pid="99703" srcset="https://kvartal.se/wp-content/uploads/2023/06/Bengt2023_black_ink_on_white_background_of_a_white_rabbit_in_re_85312ec0-f7d7-497c-a02a-497cf83cdb0e.png 972w, https://kvartal.se/wp-content/uploads/2023/06/Bengt2023_black_ink_on_white_background_of_a_white_rabbit_in_re_85312ec0-f7d7-497c-a02a-497cf83cdb0e-600x600.png 600w, https://kvartal.se/wp-content/uploads/2023/06/Bengt2023_black_ink_on_white_background_of_a_white_rabbit_in_re_85312ec0-f7d7-497c-a02a-497cf83cdb0e-150x150.png 150w, https://kvartal.se/wp-content/uploads/2023/06/Bengt2023_black_ink_on_white_background_of_a_white_rabbit_in_re_85312ec0-f7d7-497c-a02a-497cf83cdb0e-300x300.png 300w, https://kvartal.se/wp-content/uploads/2023/06/Bengt2023_black_ink_on_white_background_of_a_white_rabbit_in_re_85312ec0-f7d7-497c-a02a-497cf83cdb0e-768x768.png 768w" sizes="(max-width: 972px) 100vw, 972px" /><figcaption id="caption-attachment-99703" class="wp-caption-text"><em>Johan Lundberg tipsar om en roman där 1490-talets Florens skildras så levande att den nutida resenären kan använda den för att orientera sig. Illustration: AI/Midjourney.</em></figcaption></figure>
<h3>Johan Lundberg: Tre klassiker</h3>
<h6><strong>Walter Scott</strong>: <em>Waverley</em> (1814)</h6>
<p>Sommaren lämpar sig väl för riktigt långa romaner – av det slag som erbjuds av 1800-talsrealismen. <strong>Walter Scott</strong> är ju känd som skapare av den historiska romanen – vilket skedde med <em>Waverley</em>. Den utspelar sig i Skottland 1745, vid den tid då Storbritannien besegrade de skotska klanerna, och frossar i storslagna tablåer över en förlorad värld av slottsmiddagar med hovnarrar, excentriska klanledare och gaeliska barder.</p>
<h6><strong>Honoré de Balzac</strong>: <em>Förlorade illusioner</em> (1846)</h6>
<p>Även Balzacs roman <em>Förlorade illusioner</em>, i år aktuell  som spelfilm, handlar om förlust, men i hans fall är det ett agrart och aristokratiskt Frankrike som ersatts av en modern värld av giriga borgerliga uppkomlingar. Romanens spelplats är tidnings- och förlagsbranschen – vilken i Balzacs tappning befolkas av unga (Napoleonliknande) män som inte tvekar att gå över lik för att nå berömmelse.</p>
<h6><strong>George Eliot: </strong><em>Romola</em> (1863)</h6>
<p>En på många sätt modern värld gestaltas även i <strong>George Eliots</strong> förhållandevis bortglömda roman <em>Romola</em> som utspelar sig i 1490-talets Florens. Det är en stad så levande skildrad – med dåtida kändisar som <strong>Machiavelli</strong> och <strong>Savonarola</strong> – att den nutida Florens-resenären kan använda romanen för att orientera sig både historiskt och geografiskt.</p>
<p>Samtliga romaner torde för svenska läsare vara enklast att tillägna sig i engelska Penguin Classics-utgåvor.</p>
<p><em><a href="https://kvartal.se/medverkande/johan-lundberg/">Johan Lundberg</a> är litteraturvetare. </em></p>
<p style="text-align: center;">*</p>
<h3><strong>Ola Wong: Otrohet, övervakning, desinformation</strong></h3>
<h6><strong>Somerseth Maugham</strong>: <em>The painted veil</em> (Penguin books, 1925).</h6>
<p>Vissa romaner är som att skära i en bakelse, ett krispigt knäpp när marsipanlocket brister, den motståndslösa glidningen genom intrikat fyllning för att sluta i ett – Tock! – botten bryts och silvergaffeln träffar benporslinet. Denna berättelse om otrohet och hämnd i kolonialtidens Hongkong är just så. Alla som undrar varför kineser fortfarande pratar om 100 år av förödmjukelse kan studera de brittiska huvudpersonernas attityd mot lokalbefolkningen.</p>
<h6><strong>Josh Chin, Liza Lin: </strong><em>Surveillance state</em> (St. Martin’s, 2022)</h6>
<p>Innan <strong>Anna Dahlberg </strong>blev statssekreterare åt <strong>Ulf Kristersson</strong> skrev hon på <a href="https://www.expressen.se/ledare/anna-dahlberg/sverige-maste-bli-ett--overvakningssamhalle/">Expressens ledarsida</a> att Sverige måste skapa ett övervakningssamhälle. I så fall rekommenderas läsning av detta mästerliga reportage, för i denna liksom många andra frågor håller Kinas kommunistparti upp en skrattspegel för vår framtid. Kommunistpartiet har byggt upp världens mest avancerade och utbyggda övervakningssystem som ger signaler vad folket vill och vilka som är ett hot för regimen, ibland innan de själva vet om det. Målet är att överkomma diktaturens informationsproblem – att den inte får feedback genom medier och väljare.</p>
<h6><strong>Thomas Rid: </strong><em>Active measures </em>(Farrar, Straus &amp; Giroux, 2020)</h6>
<p>Om de inte hade pressfrihet skulle vi ha varit tvungna att uppfinna den åt dem, säger en av bokens många fascinerande aktörer – en gammal KGB-chef för desinformationsarbete. Alla som är intresserade av politik och medier bör läsa denna skildring av den politiska krigföringens dolda historia. Det går att slita sönder fiendens samhälle genom en mix av fakta, fejk och förvirring, men desinformationens monster slukar även sin egen upphovsman – något som nu illustreras i Putins Ryssland. När tron på fakta undergrävs återstår bara känslor och stamtänkande, och den rationella debatten kortsluts, postmodernismen och Focault var som hand i handske för KGB.</p>
<p><em>Senare i juli kommer fler tips från Kvartal Kultur. Ha en skön sommar, önskar<a href="https://kvartal.se/medverkande/ola-wong/"> Ola Wong</a>.</em></p>
<div class="author-byline">Ola Wong är Kvartals kulturredaktör, Kina-kännare och författare.
</div>
</div>
