Sensommarens boktips

<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%2Fsensommarens-boktips%2F&amp;t=Sensommarens+boktips"    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=Sensommarens+boktips+-+https%3A%2F%2Fkvartal.se%2Fartiklar%2Fsensommarens-boktips%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%2Fsensommarens-boktips%2F"    target = "_blank"    class  = "li-link"    title  = "Dela på LinkedIn"><i class="ti-linkedin ui transparent"></i></a><a href    = "mailto:?subject=Sensommarens boktips&body=https://kvartal.se/artiklar/sensommarens-boktips/"   target  = "_blank"    class   = "pr-link"    title   = "E-posta"    onclick = ""><i class="ti-email ui transparent"></i></a><a href    = "https://kvartal.se/skriv-ut/180588/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> | 16 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%2Fsensommarens-boktips%2F&amp;t=Sensommarens+boktips"    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=Sensommarens+boktips+-+https%3A%2F%2Fkvartal.se%2Fartiklar%2Fsensommarens-boktips%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%2Fsensommarens-boktips%2F"    target = "_blank"    class  = "li-link"    title  = "Dela på LinkedIn"><i class="ti-linkedin ui transparent"></i></a><a href    = "mailto:?subject=Sensommarens boktips&body=https://kvartal.se/artiklar/sensommarens-boktips/"   target  = "_blank"    class   = "pr-link"    title   = "E-posta"    onclick = ""><i class="ti-email ui transparent"></i></a><a href    = "https://kvartal.se/skriv-ut/180588/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 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 8 min</span></a><a href   = "https://kvartal.se/skarmlasarvanlig/a8de8bea-78b3-4491-8e6e-da73f5974e50"    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-180588">  <div class="in-short-inner">    <span class="close_button close-in-short in-short-toggle" data-articleid = "180588"></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 ">
<h2><strong>Jonas A Erikssons boktips</strong></h2>
<p><strong>Skribenten och analytikern Jonas A Eriksson tipsar bland annat om Bret Easton Ellis <em>Skärvorna</em>, som utspelar sig i det vibrerande och dekadenta Los Angeles på 1980-talet.</strong></p>
</div>
<div class="rest-of-article ">
<p><em>Doom: The politics of catastrophe</em> (Penguin Press 2022)</p>
<p>Av<strong> Niall Ferguson<br />
</strong></p>
<p>Professorn i finanshistoria <strong>Niall Ferguson</strong> guidar läsaren genom mänsklighetens stora katastrofer. Här finns krig, härdsmältor och finanskriser, som vi själva skapat, men också naturkatastrofer, som vulkanutbrott och jordbävningar, där vi bara är offer. Här finns också kriser där människa och natur möts på ett olyckligt sätt – som vid pandemier. Här finns olyckor vi anat, grå noshörningar, och sådant vi över huvud taget inte kunnat föreställa oss – svarta svanar. Ferguson är inte nådig i sin kritik av det moderna, byråkratiserade samhällets (o)förmåga att hantera verkliga katastrofer. Han menar att vi inte har blivit bättre på att bemöta dem över tid – snarare tvärtom. I en tid då världen börjat glömma pandemin är boken en viktig påminnelse om vår sårbarhet.</p>
<p style="text-align: center;">*</p>
<p><em>Fursten</em> (Modernista 2019)</p>
<p>Av <strong>Niccolò Machiavelli</strong></p>
<p>Den ultimata boken om människans maktanspråk utspelar sig i Florens på 1500-talet. Boken är ett slags handbok för hur en ”god” furste bör agera och uppträda. <strong>Machiavelli</strong> skrev boken efter att han fråntagits befattningen som sekreterare i Florens utrikesstyrelse. Han hade i sin yrkesroll haft tillfälle att på nära håll studera flera av de ledande personligheterna inom europeisk politik. <em>Fursten</em> hjälper oss att bättre förstå hur ledare som <strong>Xi Jinping</strong>, <strong>Vladimir Putin</strong> och <strong>Donald Trump</strong> resonerar i en värld där geopolitik och geoekonomi åter blivit centrala drivkrafter. En klassiker jag läste första gången när jag gick i gymnasiet, men som känns mer aktuell än någonsin just nu.</p>
<p style="text-align: center;">*</p>
<p><em>Skärvorna</em> (Brombergs 2023)</p>
<p>Av <strong>Bret Easton Ellis</strong></p>
<p><em>Skärvorna</em> för läsaren tillbaka till ett USA som en gång rikligt skildrades i filmer – med ungdomar, sex, droger och seriemördare. Den amerikanske författaren <strong>Bret Easton Ellis</strong> skriver om det vibrerande och dekadenta Los Angeles där han själv växte upp i början av 1980-talet. Vi får följa en grupp välbärgade <em>high schoo</em>l-elever på väg in i vuxenvärlden. Äldre tonåringar med lite för mycket pengar och frihet och frånvarande föräldrar. I skuggorna av de fina villakvarteren som de vistas i rör sig seriemördare – på ett sätt som skulle vara omöjligt i dagens samhälle med digitala övervakningsverktyg och dna-databaser. Boken blandar fiktion och fakta på ett intressant sätt och bjuder på andrum i en tid av oavbrutet informationsflöde.</p>
<p style="text-align: center;"><img fetchpriority="high" decoding="async" class="aligncenter wp-image-184053 size-full" src="https://kvartal.se/wp-content/uploads/2025/07/Sensommarens-boktips_01_Mrs-Dalloway.jpg" alt="" width="815" height="1260" data-wp-pid="184053" srcset="https://kvartal.se/wp-content/uploads/2025/07/Sensommarens-boktips_01_Mrs-Dalloway.jpg 815w, https://kvartal.se/wp-content/uploads/2025/07/Sensommarens-boktips_01_Mrs-Dalloway-194x300.jpg 194w, https://kvartal.se/wp-content/uploads/2025/07/Sensommarens-boktips_01_Mrs-Dalloway-768x1187.jpg 768w, https://kvartal.se/wp-content/uploads/2025/07/Sensommarens-boktips_01_Mrs-Dalloway-600x928.jpg 600w" sizes="(max-width: 815px) 100vw, 815px" /></p>
<h2><strong>Yvonne Lefflers boktips</strong></h2>
<p><strong>Litteraturvetaren Yvonne Leffler rekommenderar bland annat en berättelse om mötet mellan två ensamma människor som av en slump träffas på en sake-bar i Tokyo.</strong></p>
<p><em>Araminta May</em> (1838)</p>
<p>Av <strong>Carl Jonas Love Almqvist </strong></p>
<p>Detta är ett exempel på när <strong>Almqvist</strong> är i högform som berättare. Denna korta brevroman handlar om grosshandlarsonen <strong>Fabian</strong> som mot sin vilja blir ivägskickad av sin far till Grönhamns prostgård för att hitta en lämplig fru. För att inte bli uttråkad på landet inleder han en brevväxling med sin kusin <strong>Henriette</strong> som är kvar i Stockholm.</p>
<p>Men brevväxlingen tar en oväntad vändning när Fabian får läsa om Henriettes nyfunna och charmerande engelska väninna, <strong>Araminta May</strong>. För läsaren övergår nu Fabians och Henriettes skämtsamma ordduell i en förförelse per korrespondens som överträffar flertalet av dagens dejtingprogram på TV.</p>
<p>Romanen finns tillgänglig på <a href="https://litteraturbanken.se/f%C3%B6rfattare/AlmqvistCJL/titlar/SamladeVerk8/sida/3/etext">Litteraturbanken</a>.</p>
<p style="text-align: center;">*</p>
<p><em>Mrs Dalloway</em> (1925) (ny översättning till svenska av <strong>Eva Åsefeldt</strong>, Bonniers 2025)</p>
<p>Av <strong>Virginia Woolf</strong></p>
<p>Romanen inleds en tidig sommarmorgonen 1923 med att <strong>Mrs Dalloway</strong> ger sig ut för att köpa blommor till kvällens fest som avslutar romanen. Händelserna skildras huvudsakligen ur hennes synvinkel men i inre monologer får läsaren också lära känna de personer som hon möter. Bland dem finns den man som hon nästan gifte sig med och som precis kommit hem från Indien, samt en krigstraumatiserad veteran och hans hustru.</p>
<p>Berättelsen skildrar hur individer både direkt och indirekt drabbas av krig, samtidigt som den beskriver ett samhälle som håller på att försvinna och ersättas av något annat. Med detta känns romanen oerhört aktuell. Därtill erbjuder den Londonbesökaren en vandringsguide. Det går nämligen än idag att gå i romanpersonernas fotspår längs välkända gator på väg till berömda sevärdheter och platser.</p>
<p style="text-align: center;">*</p>
<p><em>Senseis portfölj</em> (Bokförlaget Tranan 2021)</p>
<p>Av <strong>Hiromi Kawakami </strong></p>
<p>Det är en stillsam och engagerande berättelse om mötet mellan två ensamma människor som av en slump träffas på en sake-bar i Tokyo. Hon, <strong>Tsukiko</strong>, är 38 år och jobbar på kontor. Han, <strong>Sensei</strong>, är trettio år äldre och hennes före detta lärare i japanska. Förutom att dricka sake och äta sig igenom det japanska köket samtalar de och återuppväcker gemensamma minnen medan tiden går och årstiderna växlar. På barbesöken följer utflykter och en svampexkursion som stärker bandet mellan dem.</p>
<p>Detta är en finstämd berättelse om vänskap, kärlek och livet. Samtidigt som den påminner om filmen <em>Lost in translation</em> utmanar den våra invanda föreställningar om romantik och parrelationer.</p>
<p style="text-align: center;"><img decoding="async" class="aligncenter wp-image-184054 size-full" src="https://kvartal.se/wp-content/uploads/2025/07/Sensommarens-boktips_02_Glenn-Bech.jpg" alt="" width="815" height="1260" data-wp-pid="184054" srcset="https://kvartal.se/wp-content/uploads/2025/07/Sensommarens-boktips_02_Glenn-Bech.jpg 815w, https://kvartal.se/wp-content/uploads/2025/07/Sensommarens-boktips_02_Glenn-Bech-194x300.jpg 194w, https://kvartal.se/wp-content/uploads/2025/07/Sensommarens-boktips_02_Glenn-Bech-768x1187.jpg 768w, https://kvartal.se/wp-content/uploads/2025/07/Sensommarens-boktips_02_Glenn-Bech-600x928.jpg 600w" sizes="(max-width: 815px) 100vw, 815px" /></p>
<h2><strong>Johan Sjölanders boktips</strong></h2>
<p><strong>Johan Sjölander, verksamhetschef för socialdemokratiska tankesmedjan Tiden, tipsar om tre böcker som på olika sätt fångar vår samtid.</strong></p>
<p><em>Jag erkänner inte längre er auktoritet</em> (Ellerströms 2024)</p>
<p>Av <strong>Glenn Bech </strong></p>
<p>Den inledande dedikationen – ”till klasskampen” – kan möjligen skrämma bort någon. Det är synd. För denna rasande, bästsäljande danska poesi är politisk. Men i sin arga kompromisslöshet också mänskligt öppen och sökande, långt ifrån någon plakatpoesi.</p>
<p>Starkast är skildringarna av barndomen: <strong>Bechs</strong> minnen av sitt eget utanförskap som ung homosexuell på den danska landsbygden. Mest samtida är reflektionerna kring klass, identitet och politik, i relationen till arbetarmorsan, med sina cigg, sina åsikter, sin obegripliga lojalitet, och i författarens främlingskap inför den progressiva medelklass som aldrig riktig kan förstå.</p>
<p>Det finns en brutalism i språket, inte alltid vackert. Men det känns. Och det säger, på sitt sätt, mer om den moderna vänsterns våndor än hundra akademiska avhandlingar.</p>
<p style="text-align: center;">*</p>
<p><em>Bockfesten</em> (2000, svensk översättning Norstedts 2002)</p>
<p>Av <strong>Mario Vargas Llosa</strong></p>
<p>Nobelpristagaren <strong>Mario Vargas Llosa</strong> gick bort tidigare i år. Bara det är anledning nog att återvända till hans författarskap. <em>Bockfesten</em> från 2000 är dessutom en av hans bästa romaner och kusligt aktuell.</p>
<p>Det är en fiktiv men historiskt grundad skildring av diktatorn <strong>Rafael Trujillos</strong> sista tid vid makten i Dominikanska republiken. Men det är också en roman om maktens psykologi: om macholedaren som tar vad han vill ha, om alla de som gör hans styre möjligt genom den där märkligt mänskliga närmast masochistiska drivkraften att underkasta sig.</p>
<p>Miljön är karibisk. Värmen, dofterna, ljuden. Men temat är allmänt. Den starke mannen och hans hov är något vi känner igen i vår samtid, där auktoritära ledare reser sig i nya skepnader, från Washington, Ankara, Moskva. Och kanske ännu närmare än så.</p>
<p style="text-align: center;">*</p>
<p><em>Andromeda</em> (Norstedts 2022)</p>
<p>Av <strong>Therese Bohman</strong></p>
<p><em>Andromeda</em> berättar om den unga praktikanten <strong>Sofie</strong> och hennes svårdefinierade relation till den äldre förläggaren <strong>Gunnar</strong>, och gör det med ömhet och intellektuell skärpa. Den kom för några år sedan och om man missade är det klart värt att återkomma nu.</p>
<p>Hur ser en relation mellan en äldre manlig chef och hans unga kvinnliga protegé ut i en värld där makt granskas med nya ögon efter Metoo? Vilken roll spelar litteraturen i vår tid, i dragkampen mellan smak och försäljningssiffror? Hur samspelar klass, bildning och kultur i en samtid där alla begreppen blivit obekväma?</p>
<p>Jag la ifrån mig <em>Andromeda</em> med samma känsla som när jag första gången läste <em>Stoner</em> av <strong>John Williams</strong>. Det är ett väldigt gott betyg. Dessutom tyckte jag så mycket om huvudkaraktärerna och deras <strong>Don Quijote</strong>-lika fäktande med tidsandan. En fin bok.</p>
<p style="text-align: center;"><img decoding="async" class="aligncenter wp-image-184055 size-full" src="https://kvartal.se/wp-content/uploads/2025/07/Sensommarens-boktips_03_Den-sista-kastraten.jpg" alt="" width="815" height="1260" data-wp-pid="184055" srcset="https://kvartal.se/wp-content/uploads/2025/07/Sensommarens-boktips_03_Den-sista-kastraten.jpg 815w, https://kvartal.se/wp-content/uploads/2025/07/Sensommarens-boktips_03_Den-sista-kastraten-194x300.jpg 194w, https://kvartal.se/wp-content/uploads/2025/07/Sensommarens-boktips_03_Den-sista-kastraten-768x1187.jpg 768w, https://kvartal.se/wp-content/uploads/2025/07/Sensommarens-boktips_03_Den-sista-kastraten-600x928.jpg 600w" sizes="(max-width: 815px) 100vw, 815px" /></p>
<h2><strong>Ludvig Köhlers boktips</strong></h2>
<p><strong>Författaren Ludvig Köhler tipsar bland annat om en klassisk samling av mästerliga svenska prosadikter.</strong></p>
<p><em>Fiktioner</em> (1944, svensk översättning av <strong>Sun Axelsson</strong>, Bonniers 2007)</p>
<p>Av <strong>Jorge Luis Borges </strong></p>
<p>Buenos Aires-sonen <strong>Jorge Luis Borges</strong> (1899–1986) kändaste novellsamling har blivit en klassiker i den så kallade världslitteraturen (vilket oftast betecknar bättre litteratur som inte kommer från USA eller Europa) och är en bra inkörsport till den i sydamerikanska magiska realismen. Långt innan vi steg in i den digitala tidsåldern och fick all världens fakta (och ofakta) några knapptryck bort trollade Borges med fiktion och verklighet och skapade ett slags informativa sagor som rör sig fritt mellan deckargåta, sägen och någon gammal tidningsnotis man hittar på loftet i sommarstugan. Här finns en förtjusande thriller som utspelar sig bland begravningstorn i Indien, en grammatisk mordgåta i Paris och förstås den fiktive Lundateologen <strong>Nils Runeberg</strong> som tänker skriva om kristendomens historia.</p>
<p style="text-align: center;">*</p>
<p><em>Svenska prosadikter</em> (FIB:s lyrikklubb 1983)</p>
<p>Av <strong>Lars-Håkan Svensson </strong>och<strong> Lasse Söderberg</strong> (red.)</p>
<p>Denna utmärkta antologi räcker hela sommaren. Köp den om du ser den på en loppis eller i en boklåda! Prosadikten är sällan på vers men ändå mer som en dikt än som en prosatext. I svensk litteratur finns åtskilliga mästarprov på denna ädla korsning mellan högtflygande tankar och jordnära iakttagelser, inte sällan med undersköna beskrivningar av skog och mark. Här föreligger ett vackert urval av det allra bästa som har skrivits på det svenska språket, som exempelvis <strong>Gunnar Ekelöfs</strong> mystiska klassiker <em>Laokoon</em>, <strong>Tomas Tranströmers</strong> mästerverk <em>Namnet</em> och <strong>Lars Gustafssons</strong> filosofiska pärla <em>Episod</em>. Missa heller inte <strong>Jesper Svenbros</strong> underbara tolkning av fransmannen <strong>Francis Ponges</strong> <em>Potatisen</em>, den bästa texten som har skrivits om vår älskade knöl. Att skala och äta potatis blir sig aldrig likt.</p>
<p style="text-align: center;">*</p>
<p><em>Den sista kastraten</em> (Bonniers 2025)</p>
<p>Av <strong>Ellika Lagerlöf </strong></p>
<p>Årets hittills intressantaste bokdebut är denna originella novellsamling skriven av 00-talisten <strong>Ellika Lagerlöf</strong>, som rör sig nära helt vardagliga företeelser som ett dagis, ett fik, en barnkör, ett besök hos morföräldrarna eller ett arbetspass i hemtjänsten. Men i varje berättelse händer något långt utöver det vanliga. Verkligheten förvrängs och blir ruggigt synlig på ett sätt som känns både nytt och nästan obehagligt bekant. Ett barn tar kontroll över sitt liv som om det var vuxet, en dejt förvandlas till ett slags absurd affärsuppgörelse och en relation blir en vansinnig extremsport. Bäst är kanske novellen om hantverkaren <strong>Kjell</strong> som blir inmurad i en familjs villa och endast kan kommunicera med dem med sin mobiltelefon. Men det räcker gott och väl för att bli en oumbärlig familjemedlem.</p>
<div class="kv-blaffa kv-open-promo-box">
<div class="kv-blaffa-padding-cont">
<div class="kv-already-sub" style="position: relative;"><span>Redan prenumerant?</span> &nbsp; &nbsp;<span class="kv-blaffa-login-link"><u>Logga in här</u></span></div>
</div>
<div class="kv-blaffa-sub-part">
<div class="kv-blaffa-top-text">    </div>
<div class="kv-blaffa-padding-cont">
<div class="kv-blaffa-test-hd"  style="background-image: url('https://kvartal.se/wp-content/uploads/2024/09/rubrik-bg-1.png');">      <span>Du har läst en olåst<br />artikel från&nbsp;Kvartal</span>    </div>
<div class="kv-blaffa-test-subtext"><span style="font-style: normal; color: #fff;">Prenumerera för att få ta del av alla&nbsp;texter&nbsp;och&nbsp;poddar från Sveriges&nbsp;vassaste&nbsp;mediehus.</span>    </div>
<div class="blaffa-custom-html">
<ul class="kv-feature-list">
<li>Alla artiklar</li>
<li>Alla poddar</li>
<li>Kvartals app</li>
<li>Reklamfritt</li>
</ul></div>
<div class="blaffa-email-input">
<div class="blaffa-email-input-holder">        <input style       = ""                type        = "email"                class       = "kv-signup-email-input"                placeholder = "Fyll i din e-postadress" />      </div>
<div class="kv-blaffa-email-error"></div>
</p></div>
<div class="kv-become-a-sub-holder"><a class="kv-blaffa-btn" href="https://kvartal.se/prenumerera">Bli prenumerant idag<svg aria-hidden="true" class="ses-button-arrow tf-ti-arrow-right"><use href="#tf-ti-arrow-right"></use></svg></a>    </div>
</div>
<p><img decoding="async" src="https://kvartal.se/wp-content/themes/kvartal-v2/assets/img/klarna-logo.png" class="kv-klarna-logo" /></div>
<div class="kv-blaffa-padding-cont kv-blaffa-bottom-padding">
<div class="kv-blaffa-company-sub"></div>
</p></div>
</div>
<div class="author-byline">Ola Wong är Kvartals kulturredaktör, Kina-kännare och författare.
</div>
</div>
