Den bästa läsningen är den onyttiga

<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-basta-lasningen-ar-den-onyttiga%2F&amp;t=Den+b%C3%A4sta+l%C3%A4sningen+%C3%A4r+den+onyttiga"    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+b%C3%A4sta+l%C3%A4sningen+%C3%A4r+den+onyttiga+-+https%3A%2F%2Fkvartal.se%2Fartiklar%2Fden-basta-lasningen-ar-den-onyttiga%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-basta-lasningen-ar-den-onyttiga%2F"    target = "_blank"    class  = "li-link"    title  = "Dela på LinkedIn"><i class="ti-linkedin ui transparent"></i></a><a href    = "mailto:?subject=Den bästa läsningen är den onyttiga&body=https://kvartal.se/artiklar/den-basta-lasningen-ar-den-onyttiga/"   target  = "_blank"    class   = "pr-link"    title   = "E-posta"    onclick = ""><i class="ti-email ui transparent"></i></a><a href    = "https://kvartal.se/skriv-ut/161377/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> | 26 december 2024<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-basta-lasningen-ar-den-onyttiga%2F&amp;t=Den+b%C3%A4sta+l%C3%A4sningen+%C3%A4r+den+onyttiga"    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+b%C3%A4sta+l%C3%A4sningen+%C3%A4r+den+onyttiga+-+https%3A%2F%2Fkvartal.se%2Fartiklar%2Fden-basta-lasningen-ar-den-onyttiga%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-basta-lasningen-ar-den-onyttiga%2F"    target = "_blank"    class  = "li-link"    title  = "Dela på LinkedIn"><i class="ti-linkedin ui transparent"></i></a><a href    = "mailto:?subject=Den bästa läsningen är den onyttiga&body=https://kvartal.se/artiklar/den-basta-lasningen-ar-den-onyttiga/"   target  = "_blank"    class   = "pr-link"    title   = "E-posta"    onclick = ""><i class="ti-email ui transparent"></i></a><a href    = "https://kvartal.se/skriv-ut/161377/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 6 min</span></a><a href   = "https://kvartal.se/skarmlasarvanlig/161377"    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-161377">  <div class="in-short-inner">    <span class="close_button close-in-short in-short-toggle" data-articleid = "161377"></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><!-- no json scripts to comment in the content -->
<div class="article-beginning ">Norges översättarförening hade i år en digital julkalender där varje lucka innehöll någon översättares favoritord. Som det japanska ordet <a href="https://oversetterforeningen.no/oversetterforeningens-adventskalender-2024/"><em>tsundoku</em></a>: Fenomenet att skaffa sig en massa böcker som man inte läser, och eventuellt låter bli liggande i staplar. En grundpelare för bokbranschen.</p>
</div>
<div class="rest-of-article ">
<p>Själv har jag under nästan hela 2024 haft boken <em>The coming wave – Technology, power and the 21st century&#8217;s greatest dilemma</em> av <strong>Mustafa Suleyman</strong> liggande bredvid sängen, en bok som typ ”alla” säger att man borde läsa eftersom den är oerhört viktig, fascinerande och dessutom välskriven. <em>The coming wave</em> är på <em>Foreign Policys</em> <a href="https://www.foreignaffairs.com/lists/best-books-2024?utm_campaign=tw&amp;utm_content=&amp;utm_medium=social&amp;utm_source=twitter">lista</a> över 2024 års bästa böcker och var även på <em>Financial Times</em> bästa affärsbokslista för 2023. Men nu är det ju så med rekommendationer och kanoner att de lika ofta skapar en mental blockering. En så viktig och inspirerande bok måste ju kräva en pigg hjärna, och en pigg hjärna&#8230; ja, den kanske uppenbarar sig nästa kväll?</p>
<p>För er som undrat över vad som styr principen för det brokiga urvalet av böcker till <a href="https://kvartal.se/ola-wongs-bokklubb/">Ola Wongs bokklubb</a> så har jag precis beskrivit en viktig sådan.</p>
<h2>Ett år med Ola Wongs Bokklubb</h2>
<p>Det känns länge sen nu, men det var i maj 2024 jag drog igång Kvartal Kulturs bokpodd. Sedan <a href="https://kvartal.se/artiklar/premiar-for-ola-wongs-bokklubb/">det första avsnittet</a>, om <em>Den siste teaterdirektören – berättelsen om Benny Fredriksson</em> (med <strong>Marika Lagercrantz</strong> och <strong>Fredrik Virtanen </strong>som gäster), har bokklubben fladdrat som en bipolär fjäril mellan ämnena. En höjdare var när terrorexperten <strong>Hans Brun</strong> pratade om sina möten med IRA-terrorister i avsnittet om <strong>Brendan</strong> <strong>Behans</strong> <em><a href="https://kvartal.se/artiklar/borstal-boy-och-terrorlitteratur/">Borstal boy</a>, </em>en irländsk författare som annars mest är känd för citatet<em> I am a drinker with a writing problem</em>. Sommarens hobbyprojekt blev <strong>Hans Nossacks</strong> <a href="https://kvartal.se/artiklar/undergangen-och-vittneslitteratur/"><em>Undergången</em></a> på tyska, engelska och svenska. Det resulterade i ett spännande samtal om krigets natur med strategiexperten <strong>Stefan Ring</strong> och dramatikern <strong>Stina Oscarson</strong>, hon såg ett humanistiskt mästerverk i denna strama skildring av brandbombningen av Hamburg 1943. ”<span class="s1">Jag vankade av och an på den förödda världens strand och jämrade mig: Åh Gud? Åh Gud.”</span> I oktober gästades podden av <strong>Edel Irén Lappin</strong> och <strong>Anna-Karin Wyndhamn</strong> och vi pratade om <strong>Lionel Shrivers</strong> svarta satir <a href="https://kvartal.se/artiklar/mania-och-woke-satir/"><em>Mania</em></a>.</p>
<p>Nyligen skickade en snäll läsare <strong>Faysa Idles</strong> <em>Ett ord för blod </em>till Kvartals chefredaktör <strong>Jörgen Huitfeldt</strong>, med en uppmaning om att läsa denna skakande berättelse från gängkrigets Sverige. Eftersom boken var avsedd för Jörgen så kastade jag mig över den som en fiskmås (om jag själv varit adressaten misstänker jag starkt att boken skulle ha hamnat i det dåliga samvetets <em>tsundoku</em>). Nu blir <em>Ett ord för blod</em> i stället temat för nästa avsnitt av bokklubben som sänds den 5 januari 2025.</p>
<p>Jag har under 2024 även lyckats recensera några nyttiga böcker som jag på förhand visste att jag borde läsa. Dit räknas <em>The age of unpeace: How connectivity causes conflict,</em> som blev artikeln <a href="https://kvartal.se/artiklar/leder-globaliseringen-till-krig/"><em>Leder globaliseringen till krig?</em></a> En av årets stora tankeväckare var <strong>Jonathan Haidts</strong> <em>The anxious generation.</em> Jag skrev om den i augusti i essän <a href="https://kvartal.se/artiklar/har-psykologkaren-svikit-generation-angest/"><em>Har psykologkårens svikit generation ångest?</em></a> Den har släppts på svenska sedan dess.</p>
<p><strong>Louis Menands</strong> strålande <em>The metaphysical club: A story of ideas in America</em> blev grundbas i min essä <em><a href="https://kvartal.se/artiklar/pragmatismens-dod/">Pragmatismens död</a>, </em>om <strong>Donald Trumps</strong> valseger.</p>
<p>En bok som definitivt hör till kategorin nyttig (men träig) fullkornskost är <strong>Steve Tsangs</strong> och <strong>Olivia Cheungs</strong> <em>The political thought of Xi Jinping, </em>som jag kommer att skriva om i artikelserien <em>Idéerna som skakar världen</em>.</p>
<blockquote><p>Jag har märkt att läslust handlar mycket om att lura hjärnan att tro att boken inte har någon bäring på något nyttigt.</p></blockquote>
<p>Den som fyller lägenheten med <em>tsundoku</em> inser förr eller senare att man i likhet med <strong>Xi Jinping</strong> måste börja göra utrensningar. Så man hittar en kandidat för pappersåtervinningen, drar ut boken och börjar bläddra – och då är man fast. En bok som är så onyttig att jag tycker att den kan slängas måste man ju bara läsa. Så var det med boken <a href="https://kvartal.se/artiklar/norska-larare-anklagades-for-rasism-nu-far-de-pris/"><em>Skifta skinn – en essä om främlingskap, kultur och rasism</em></a> av universitetslektorn <strong>Thomas Petersson</strong>. Jag fastnade för hans berättelse om hur nazister mobbade hans adopterade son på en prestigefylld högstadieskola i Stockholm (medan han själv blev anmäld för att ha talat om <strong>Astrid Lindgrens</strong> bruk av N-ordet under en lektion för vuxna studenter). Den visade på ett svenskt hyckleri och gav mig material för artikeln <a href="https://kvartal.se/artiklar/norska-larare-anklagades-for-rasism-nu-far-de-pris/"><em>Norska lärare anklagades för rasism – nu får de pris</em></a>, där jag jämför den svenska och norska synen på trygga rum. Peterssons bok åkte tillbaka in i tryggheten i bokhyllan, så klart.</p>
<p>Jag har märkt att läslust handlar mycket om att lura hjärnan till att tro att boken inte har någon bäring på något nyttigt. Under året kom en bok till redaktionen som jag direkt visste att den verkligen <em>inte</em> handlar om viktiga dagsaktuella frågor som jag har ett demokratiskt ansvar att sätta mig in i. <strong>C.S. Lewis</strong> <em>Den förkastade bilden – en introduktion till medeltidens och renässansens litteratur </em>var som en utandning med sänkta axlar. I den skriver han att för den som vill studera medeltidens litteratur är inga källor viktigare än Bibeln, <strong>Ovidius</strong> och <strong>Vergilius</strong>, ”men om dessa tre kommer jag inte att säga något alls. Många av mina läsare är redan bekanta med dem; de som inte vet det vet i alla fall att det är något de måste åtgärda”. Den uppmaningen var så stofilig att den kändes mer som ett förföriskt lockrop än ett krav. Vilket ledde till <a href="https://kvartal.se/artiklar/aeneiden-och-romarrikets-storverk/">bokklubbens senaste avsnitt</a>, där temat är just Vergilius <a href="https://kvartal.se/artiklar/aeneiden-och-romarrikets-storverk/"><em>Aeneiden</em></a>, med <strong>Victor Malm</strong> och <strong>Fredrik Sixtensson </strong>som gäster. Missa inte det!</p>
<h2>Bästa boken om dinosaurier, och andra fynd</h2>
<p>Många böcker kan jag inte ens med skohorn få in i någon kommentar om kultur- och samhällsutvecklingen. Med följd att jag inte nämner dem alls. En av årets toppar i den kategorin var <em>The rise and fall of the dinosaurs</em> av <strong>Steve Brusatte</strong> – en fascinerande läsning om dinosauriernas tidsålder och de revolutionerande forskningsgenombrott som skett under den senaste tiden. En annan sådan är <strong>Joseph Conrads</strong> <em>The nigger of the Narcissus, </em>om en dödssjuk svart sjöman som håller på att orsaka myteri på ett segelfartyg under 1800-talet. En av de bästa skildringarna av livet på havet i litteraturen.</p>
<p><strong>Mick Herrons</strong> brittiska spionroman <em>Slow horses</em> har blivit en välförtjänt hyllad tv-serie, men den är ännu bättre som bok.</p>
<p>Just nu läser jag <em>Föräldrarnas födelse</em>: <em>250 år av experter, släktingar och andra som lagt sig i </em>av <strong>Maja Larsson</strong>, som släpps i bokhandeln den 17 januari. Det skulle inte förvåna mig om den får Augustpriset, den förtjänar det.</p>
<p>Årets kärleksroman var <em>Kvinna sedd bakifrån</em> av <strong>Jesper Wung-Sung</strong>, som fick vara med på min lista över <a href="https://kvartal.se/artiklar/sommarens-hetaste-boktips-fran-kvartal-kultur/">Sommarens boktips</a>. Det gjorde också <strong>Han Songs</strong> fascinerande vårddystopi <em>Hospital, </em>som jag även skrev om i essän <em><a href="https://kvartal.se/artiklar/halsofascismens-pris/">Hälsofascismens pris</a>. </em></p>
<p>Nu har jag ambitionen att läsa <em>The coming wave</em> under mellandagarna, under tiden lär en hel den av den där AI-vågen han beskriver redan ha sköljt över mig och min <em>tsundoku</em>.</p>
<div class="author-byline">Ola Wong är Kvartals kulturredaktör, Kina-kännare och författare.
</div>
</div>
