Så många kan inte ha fel om X

<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-160721"      class = "kv-pod-holder kv-player-light  lplo " data-sid="" data-eid="" data-tis="2625" data-tin="2856" data-pid="160721" data-pty="SW5sw6RzdCBhcnRpa2VsIChTYW1ow6RsbGUp" data-pna="U8OlIG3DpW5nYSBrYW4gaW50ZSBoYSBmZWwgb20gWA==" data-acurl="aHR0cHM6Ly9tZWRpYS5wb2Quc3BhY2UvaW5sYXN0YXRleHRlci8xOS01NC1zYS1tYW5nYS1rYW4taW50ZS1oYS1mZWwtb20teC5tcDM=" data-psurl="aHR0cHM6Ly9tZWRpYS5wb2Quc3BhY2Uva2p4ajYzeWRkZXEydmgvMTktNTQtc2EtbWFuZ2Eta2FuLWludGUtaGEtZmVsLW9tLXgubXAz">  <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/ashkan-fardost/">Ashkan&nbsp;Fardost</a> | 16 december 2024<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%2Fsa-manga-kan-inte-ha-fel-om-x%2F&amp;t=S%C3%A5+m%C3%A5nga+kan+inte+ha+fel+om+X"    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=S%C3%A5+m%C3%A5nga+kan+inte+ha+fel+om+X+-+https%3A%2F%2Fkvartal.se%2Fartiklar%2Fsa-manga-kan-inte-ha-fel-om-x%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%2Fsa-manga-kan-inte-ha-fel-om-x%2F"    target = "_blank"    class  = "li-link"    title  = "Dela på LinkedIn"><i class="ti-linkedin ui transparent"></i></a><a href    = "mailto:?subject=Så många kan inte ha fel om X&body=https://kvartal.se/artiklar/sa-manga-kan-inte-ha-fel-om-x/"   target  = "_blank"    class   = "pr-link"    title   = "E-posta"    onclick = ""><i class="ti-email ui transparent"></i></a><a href    = "https://kvartal.se/skriv-ut/160721/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="kv-art-ext-sep"></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%2Fsa-manga-kan-inte-ha-fel-om-x%2F&amp;t=S%C3%A5+m%C3%A5nga+kan+inte+ha+fel+om+X"    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=S%C3%A5+m%C3%A5nga+kan+inte+ha+fel+om+X+-+https%3A%2F%2Fkvartal.se%2Fartiklar%2Fsa-manga-kan-inte-ha-fel-om-x%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%2Fsa-manga-kan-inte-ha-fel-om-x%2F"    target = "_blank"    class  = "li-link"    title  = "Dela på LinkedIn"><i class="ti-linkedin ui transparent"></i></a><a href    = "mailto:?subject=Så många kan inte ha fel om X&body=https://kvartal.se/artiklar/sa-manga-kan-inte-ha-fel-om-x/"   target  = "_blank"    class   = "pr-link"    title   = "E-posta"    onclick = ""><i class="ti-email ui transparent"></i></a><a href    = "https://kvartal.se/skriv-ut/160721/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 class="listen" href="https://kvartal.se/artiklar/sa-manga-kan-inte-ha-fel-om-x/?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 26 min</span></a><a href   = "https://kvartal.se/skarmlasarvanlig/bc43a3ff-c72a-4ee9-9bce-686afdc68895"    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-160721">  <div class="in-short-inner">    <span class="close_button close-in-short in-short-toggle" data-articleid = "160721"></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 ">Hotet. Demokratin är hotad. Varningen har upprepats i landets största medier många gånger det här året. Bland annat i <a href="https://www.dn.se/kultur/asa-wikforss-darfor-ar-sd-trollen-ett-hot-mot-demokratin/">DN</a>, <a href="https://www.dn.se/kultur/asa-wikforss-det-kan-vara-sa-att-trumpvaljarna-helt-enkelt-inte-bryr-sig-om-demokratin/">DN</a>, <a href="https://www.dn.se/kultur/bjorn-wiman-var-tids-tragedi-ar-den-bottenlosa-dumheten/">DN</a>, <a href="https://www.dn.se/kultur/bjorn-wiman-nu-vet-du-exakt-vad-du-skulle-ha-gjort-nar-fascismen-kom-forra-gangen/">DN</a>, <a href="https://www.dn.se/varlden/experter-finns-risk-for-nytt-sjatte-januari/">DN</a>, <a href="https://www.dn.se/kultur/sofia-nasstrom-public-service-ar-viktigare-an-nagonsin-for-demokratin/">DN</a>, <a href="https://www.dn.se/ledare/isobel-hadley-kamptz-nej-trump-vann-inte-for-att-kamala-harris-var-for-woke/">DN</a>, <a href="https://www.aftonbladet.se/kultur/a/73B8J9/karin-pettersson-om-usa-valet-oligarkerna-och-trump-fascismen">Aftonbladet</a>, <a href="https://www.aftonbladet.se/kultur/a/0VWOxM/qanon-och-konspirationsteorier-viktiga-i-usa-valet">Aftonbladet</a>, <a href="https://www.aftonbladet.se/kultur/a/Rz4rJd/donlad-trumps-valseger-kommenteras-av-karin-pettersson">Aftonbladet</a>, <a href="https://www.expressen.se/kronikorer/mats-larsson/trumps-hemliga-vapen-som-han-vagrar-anvanda/">Expressen</a> och <a href="https://www.gp.se/debatt/musk-ska-inte-effektivisera-han-ska-ge-trump-oinskrankt-makt.6a20377d-4985-4c08-82a3-6517b42c3a2f">Göteborgs-Posten</a>.</p>
</div>
<div class="rest-of-article ">
<p>Skribenterna är oroliga att vi väljare röstar fel. Eftersom vi lider av sanningsbrist. Därför är de fria och oberoende medierna, som skilja på sanningen från lögnen, demokratins garant. Desinformationen, algoritmerna och internet är de ständigt återkommande bovarna. Det vore därför olyckligt om sanningens självutnämnda väktare, även kända som de ”seriösa nyhetsmedierna”, baserade denna varning på osanningar. Speciellt om osanningarna letat sig in i väktarnas flöden via algoritmer på internet.</p>
<p>Texten du läser ämnar skildra just denna sorts tragikomedi.</p>
<p>De traditionella mediernas tynande monopol på sanningen gör sig sällan påmind genom rubriker och avslöjanden av bombastisk karaktär. För det mesta sker det långsamt och obemärkt i det gråa och tysta mellanrummet som är allas vår banala vardag. Men då och då höjer en och annan på ögonbrynen. Litegrann. Kan det som står i tidningen verkligen vara sant? Men när flera andra medier också rapporterat samma sak, vilket ofta är fallet, så tenderar ögonbrynen att landa i lättnad.</p>
<p>Så många kan ju inte ha fel. Samtidigt. Om samma sak.</p>
<h2>Sanningen, november 2024</h2>
<p><strong>Donald Trump</strong> vann. Valrörelsen är över sedan flera veckor. Analyserna haglar ännu in, även i de svenska medierna. En återkommande karaktär i analyserna är <strong>Elon Musk</strong>, som anslöt sig till Trumps valkampanj dagen efter mordförsöket i Pennsylvania i somras. Med sina över 200 miljoner följare på X, en plattform som han dessutom äger, har mångmiljardären Musk bidragit med både finanser och en opinionsbildning som saknar motstycke. Han och entreprenören <strong>Vivek Ramaswamy</strong> har också fått en roll i Trumps administration, där de ska leda den rådgivande kommissionen “Department of Government Efficiency”. Uppgiften är att krympa statens storlek, utgifter och underskott. Därmed är det ett demokratiskt friskhetstecken att Elon Musk ständigt återkommer i medias rapportering. Det nya styret måste granskas. Allt annat vore konstigt.</p>
<p>I Dagens Nyheter <a href="https://www.dn.se/kultur/jakob-ohlsson-x-faktorn-har-blivit-ett-globalt-sakerhetshot/">skriver</a> den politiska konsulten och digitala kommunikationsexperten <strong>Jakob Ohlsson</strong> att X bygger ”ett system som garanterar Musks tweets en exponering för så gott som alla användare”. I Dagens Industri låter mediastrategen <strong>Brit Stakston</strong> <a href="https://www.di.se/debatt/foretag-bor-se-upp-nar-musk-tar-x-in-i-extremismens-varld/">meddela</a> att ”Musk använder sin makt &#8230; till att hands-on förändra algoritmerna i favör för sin politiska hållning och de frågor han vill belysa”. Samma Brit Stakston är även underlaget i en <a href="https://www.expressen.se/sport/fotboll/anklagelsen-efter-flykten-hatmaskin/">intervju</a> med Expressen, när <strong>Mattias Tengblad</strong> skriver att ”oavsett om du följer Elon Musk eller inte så kommer du att exponeras för ägarens personliga åsikter. Det ser algoritmer till”.</p>
<p>Reportrar utan gränsers ordförande <strong>Erik Larsson</strong> <a href="https://www.reportrarutangranser.se/manadskronika-november-elons-tvattomat-for-propaganda/">misstänker i sin månadskrönika</a> att ”antingen tweekade X algoritmerna, eller så såg vi en historisk invasion av fascister”, som anledning till den dominans i flödena som Elon Musk och hans ”likasinnade” hade inför det amerikanska valet. Återigen i <a href="https://www.dn.se/kultur/linus-larsson-musk-lar-gora-x-till-trumpregeringens-propagandamaskin/">Dagens Nyheter</a> får vi lära oss, denna gång av tidningens teknikredaktör <strong>Linus Larsson</strong>, att ”Det [Elon Musks konto, reds. anm.] pushas hela tiden av algoritmen, som är under hans kontroll”.</p>
<p>En slående detalj är att det endast är Linus som hänvisar till en källa i samband med sitt påstående. En källa vi så småningom återkommer till. Det flerfaldigt förekommande påståendet om algoritmerna verkar i övrigt vara en allmänt etablerad sanning: Elon Musk manipulerar algoritmerna bakom en av världens största sociala plattformar för egen politisk vinning.</p>
<h2>Algoritmen</h2>
<p>På X <a href="https://blog.x.com/engineering/en_us/topics/open-source/2023/twitter-recommendation-algorithm">exponeras du för alla inlägg</a> främst genom plattformens två huvudflöden: Following och For You. I Following-flödet ser du enbart inlägg, reposts och svar från konton som du följer. I For You-flödet blir du däremot serverad ungefär 1 500 inlägg, där 50 procent av inläggen kommer från konton du inte följer. Det är här algoritmerna påverkar som mest och kan missbrukas för avsiktlig manipulation av den globala politiska diskussionen.</p>
<p>Algoritmerna <a href="https://github.com/twitter/">finns publicerade</a> som öppen källkod för allmän beskådning och granskning sedan mars 2023. Där kan man se hur algoritmerna samlar in och rangordnar inläggen innan de serveras i For You-flödet. Kureringen påverkas av en rad olika faktorer. Ett inlägg fångas exempelvis upp i mycket högre grad om det har likes och reposts, medan en bild eller video inte ger lika stark effekt. Förekomst av svordomar, okända ord och språk eller för många hashtags ger negativ effekt, och så vidare.</p>
<p>Efter insamling rangordnas inläggen. På tekniskt språk heter det att ”rangordningen skapas av algoritmer som med maskininlärning och avancerade statistiska beräkningar förutspår hur en användare kommer interagera med ett inlägg, utifrån användarens och likasinnades tidigare interaktioner på plattformen”.</p>
<p>På vardagsspråk heter det artificiell intelligens. Det är med andra ord en AI-modell som förutspår hur användaren kommer interagera med inläggen. På samma sätt som Chat GPT förutspår vilka bokstäver den ska spotta ur sig för att skapa illusionen av ett chattande orakel. Det kan den göra för att maskinen ”tränats” (därav begreppet maskininlärning) på hutlösa mängder data som fem miljarder människor spottat ur sig på internet. Visserligen är det bara en minoritet av alla online som faktiskt genererar innehåll. De flesta andra är bara konsumenter. Men eftersom vi människor är hopplösa härmapor så räcker det med att ha data på några ynka procent. Sedan kan man förutspå vad alla andra tycker, tänker och gillar med en så pass hög träffsäkerhet att alla unika snöflingor till individer därute inte ens kan tro sina ögon.</p>
<blockquote><p>Om X gör ändringar i koden kommer det således inte synas i realtid.</p></blockquote>
<p>Alla inlägg och interaktioner från X:s över 500 miljoner användare räcker alltså gott och väl för att koka ihop en AI-modell som med enkelhet förutspår hur de flesta användare kommer att reagera på ett inlägg. Förutspår algoritmerna att du kommer skriva ett svar på ett inlägg så får inlägget pluspoäng och åker uppåt i turordningen. En like eller repost utan svar ger färre pluspoäng. Om de förutspår att du kommer anmäla inlägget för regelbrott så blir det många minuspoäng och således en plats långt ner i For You-flödet. Och så vidare.</p>
<p>Allt ovan går att utröna utifrån den öppna källkoden.</p>
<p>Det finns massa godsaker att hämta för den som verkligen vill maximera sin exponering på plattformen. Både hur algoritmerna samlar in, rangordnar och serverar inlägg till For You-flödet, men även koden som tränar AI-modellen. Vad som inte går att utröna är hur AI-modellen kommer fram till förutsägelserna. Det skulle kräva att vi får tillgång till rådatan som modellen har tränats på, så att vi på egen hand kan generera en likvärdig modell. Att rådatan skulle offentliggöras är ytterst osannolikt, då det skulle innebära ett enormt integritetsbrott gentemot de hundratals miljoner vilkas data modellen är tränad på. Detta är även den digitala transparensens stora Akilleshäl i allmänhet. Värt att nämna är också att den publicerade koden inte är kopplad till ”produktionskoden”, det vill säga den kod som faktiskt körs på plattformen. Om X gör ändringar i koden kommer det således inte synas i realtid. De enda ändringar i koden vi kan se, från och med då de publicerade koden, är när X bemödar sig med att själva uppdatera den offentliga koden efter eget tycke.</p>
<p>Av den kod som går att ta del av finns det dock inget som tyder på att inläggen i For You-flödet samlas in eller rankas utifrån vare sig  ideologiskt innehåll eller avsändarens identitet och politiska vridning. Algoritmerna är snarare en spegel som reflekterar vad användarna på plattformen tenderar att spendera sin tid och uppmärksamhet på.</p>
<p>Kan det dock vara så att en hemlig grupp av ingenjörer som jobbar direkt under Elon Musk har tränat AI-modellen på ett sätt som gynnar Elon Musk och hans politiska agenda?</p>
<p>Där dess förutsägelser påverkar algoritmernas insamlings- och rangordningsprocess till en så pass hög grad att algoritmerna inte ens behöver vara programmerade till att vara vinklande? Eller är det en helt annan kod som egentligen används på plattformen sedan Musk tog över? Och är det därför det inte finns något misstänkt i den öppna källkoden? Inte en total omöjlighet.</p>
<p>Men än så länge finns det inga trovärdiga belägg för sådana typer av konspirationer.</p>
<h2>Kavalkaden, september 2024</h2>
<p>Två månader tidigare. Den amerikanska valrörelsen är i full gång. Likaså de västerländska mediernas rapportering. Elon Musk är <a href="https://x.com/elonmusk/status/1812256998588662068?lang=en">officiellt</a> ansluten till Donald Trumps valkampanj sedan två månader.</p>
<p>Dagens Industri <a href="https://www.di.se/nyheter/experten-om-musks-politiska-engagemang-tror-det-kommer-att-sluta-illa/">publicerar</a> ett telegram från TT som hävdar: ”Enligt flera rapporter i amerikanska medier har han [Elon Musk, reds. anm.] sett till att plattformens [X, reds. anm.] algoritmer synliggör hans inlägg för i stort sett alla användare.” Några dagar senare följer <a href="https://www.svd.se/a/wgvG0n/musk-ger-sig-in-i-valrorelsen-otrolig-makt">Svenska Dagbladet</a>, <a href="https://www.aftonbladet.se/nyheter/a/zA4JQ4/musk-ger-sig-in-i-valrorelsen-otrolig-makt">Aftonbladet</a>, <a href="https://www.gp.se/nyheter/varlden/musk-ger-sig-in-i-valrorelsen-otrolig-makt.a4f9aa8d-5099-51e6-87d3-098c0c33d924">Göteborgs-Posten</a> och flera andra svenska medier efter och publicerar telegrammet. Är det nu den allmänna sanningen etablerades? När ett TT-telegram med rubriken ”Musk ger sig in i valrörelsen” i förbifarten lite flyktigt nämnde att Musk manipulerat algoritmerna till sin personliga fördel? Vi kan bara spekulera. Det vi vet är att om två månader kommer folk repetera påståendet i de stora seriösa medierna. Utan att bemöda sig med att styrka det.</p>
<p>Sociala medier är potentiella maktfaktorer som knappt går att greppa utifrån de traditionella mediernas skala och logik. Enligt  FN:s <a href="https://www.undp.org/super-year-elections">utvecklingsprogram UNDP</a> är det 3,7 miljarder människor som har möjlighet att gå till en valurna och delta i ett demokratiskt val detta “supervalår”, som det heter. De <a href="https://x.com/XData/status/1769826435576037702">över 500 miljoner</a> aktiva användarna per månad på X representerar således över 13 procent av världens röstunderlag. Därför är det ytterst allvarligt om ägaren Elon Musk manipulerar algoritmerna för egen vinning. Just av den anledningen är det extra allvarligt när flertalet seriösa medier inte hänvisar till trovärdiga källor i samband med en så pass allvarlig anklagelse.</p>
<p>Sanningen låter sig ändå etableras i svenska medier: Elon Musk, som stödjer presidentkandidat Donald Trump, har avsiktligt riggat algoritmerna till sin fördel på en av världens största sociala plattformar för politisk diskussion. Enligt ”flera rapporter” i amerikansk media. Vilka rapporter behöver läsarna inte veta.</p>
<p>Flera amerikanska medier kan ju inte ha fel. Samtidigt. Om samma sak.</p>
<h2>Flaggan, senare i september 2024</h2>
<p>Valrörelsen är ännu i full gång. Dagens Nyheter publicerade aldrig TT:s telegram. I stället publicerar självaste chefredaktören <strong>Peter Wolodarski</strong> en <a href="https://www.dn.se/ledare/peter-wolodarski-elon-musk-manipulerar-x-for-att-stimulera-sitt-eget-superego/">egen text</a> på temat Musk och de manipulerade algoritmerna i tidningen. Textens första halva består av vad som bäst kan beskrivas som ett utdrag från boken <em>Character limit</em>, fast översatt på svenska. Boken som Wolodarski refererar till har precis släppts och är skriven av <em>New York Times</em>-journalisterna <strong>Kate Conger</strong> och <strong>Ryan Mac</strong>. Wolodarski berättar: ”Och snart var frågan avgjord, så som husse önskade. För att tillfredsställa Twitterägaren fick ingenjörerna skriva en särskild kod, ‘author_is_elon’, som instruerade systemet att prioritera inlägg från just avsändaren Elon Musk.” Inte ens svensk filmindustri hade kunnat regissera en så fjantig cyberthriller. Men för en och annan medborgare kan passagen låta tämligen övertygande som bevisföring. Värt att nämna i sammanhanget är att författarna hänvisar till en extern källa för att styrka delar av det händelseförloppet. Samma källa som DN-kollegan Linus Larsson hänvisar till senare i november.</p>
<p>Källan vi så småningom kommer att återkomma till.</p>
<p>När den sanningsetablerande telegramkavalkaden går av stapeln har den öppna källkoden varit publicerad i över ett och ett halvt år. Av de över 86 000 personer som hittills interagerat med koden (av bokmärkningar och ”forks” på plattformen GitHub att bedöma) så verkar ingen ha kunnat identifiera de snuttar av kod som bevisar att plattformen är riggad. Någon på TT, eller de svenska mediehusen som valde att återpublicera telegrammet, eller Wolodarski som själv spridit påståendet i en egen text, måste rimligtvis ha granskat koden och visat armén av 86 000 kodnördar var skåpet ska stå.</p>
<p>Alternativt har de kommit över pålitliga dokument eller haft tillgång till olika källor på insidan som avslöjat att den publicerade öppna källkoden är en cynisk skenmanöver och att riggningen är dold i AI-modellen. Medieaktörerna har gjort ingetdera. Det enda som bär upp telegrammets påstående om riggade algoritmer är den inledande satsen: ”enligt flera rapporter i amerikanska medier”. Och chefredaktören hänvisar tryggt till sina <em>New York Times</em>-kollegor bakom boken <em>Character limit</em>.</p>
<figure id="attachment_160735" aria-describedby="caption-attachment-160735" style="width: 2560px" class="wp-caption alignnone"><img fetchpriority="high" decoding="async" class="wp-image-160735 size-full" src="https://kvartal.se/wp-content/uploads/2024/12/sdlTl9d3uvf7k8-scaled.jpg" alt="kvartal" width="2560" height="1764" data-wp-pid="160735" srcset="https://kvartal.se/wp-content/uploads/2024/12/sdlTl9d3uvf7k8-scaled.jpg 2560w, https://kvartal.se/wp-content/uploads/2024/12/sdlTl9d3uvf7k8-300x207.jpg 300w, https://kvartal.se/wp-content/uploads/2024/12/sdlTl9d3uvf7k8-768x529.jpg 768w, https://kvartal.se/wp-content/uploads/2024/12/sdlTl9d3uvf7k8-1536x1059.jpg 1536w, https://kvartal.se/wp-content/uploads/2024/12/sdlTl9d3uvf7k8-2048x1411.jpg 2048w, https://kvartal.se/wp-content/uploads/2024/12/sdlTl9d3uvf7k8-600x413.jpg 600w" sizes="(max-width: 2560px) 100vw, 2560px" /><figcaption id="caption-attachment-160735" class="wp-caption-text">Elon Musk. Foto: Kirsty Wigglesworth/TT</figcaption></figure>
<p>Dock verkar Wolodarski ha haft bråttom när han läste boken. För han glömmer nämna den lilla detaljen att ingenjörerna faktiskt hittade ett underliggande fel i algoritmerna. Felet hindrade många inlägg från att överhuvudtaget plockas upp av algoritmerna och visas för icke-följare. Det gällde inte bara Musks konto utan även en handfull andra stora konton med många följare. En annan kritisk detalj i boken råkar chefredaktören också utelämna: Musk instruerade aldrig ingenjörerna att skriva en särskild kod som prioriterar hans inlägg. Ingenjörerna som upptäckte det underliggande felet saknade en lösning på problemet och slängde därför ihop en snabb silvertejpslösning för att ”lugna ner Musk”. Boken landar dock bara några meningar senare i slutsatsen att “Miljardären hade till slut byggt sin alldeles egna ekokammare”.</p>
<p>Helt utan att härleda påståendet till någon konkret information.</p>
<p>Det går med enkelhet att hitta <a href="https://github.com/twitter/the-algorithm/blob/7f90d0ca342b928b479b512ec51ac2c3821f5922/home-mixer/server/src/main/scala/com/twitter/home_mixer/functional_component/decorator/HomeTweetTypePredicates.scala%23L225">”author_is_elon”</a> i den öppna källkoden. Det går även att hitta <a href="https://github.com/twitter/the-algorithm/blob/7f90d0ca342b928b479b512ec51ac2c3821f5922/home-mixer/server/src/main/scala/com/twitter/home_mixer/functional_component/decorator/HomeTweetTypePredicates.scala%23L236">”author_is_democrat”</a> och <a href="https://github.com/twitter/the-algorithm/blob/7f90d0ca342b928b479b512ec51ac2c3821f5922/home-mixer/server/src/main/scala/com/twitter/home_mixer/functional_component/decorator/HomeTweetTypePredicates.scala%23L242">”author_is_republican”</a>. På ytan kan det verka som ett upplägg där Elon Musk och högerkonton premieras på bekostnad av vänsterkonton. Gräver man dock vidare i koden upptäcker man en ganska odramatisk förklaring; dessa ”flaggor” har som funktion att mäta antalet inlägg från dessa kategorier av konton som serverats till användarna. Av koden att bedöma är det alltså en säkerhetsmekanism, som indikerar om justeringar av den komplexa sammansättningen algoritmer råkar gynna vissa kategorier av konton framför andra. Detta går stick i stäv med bokens narrativ kring ”author_is_elon” och att det skulle vara en ”speciell kod” skriven med syftet att premiera Elon Musks inlägg. För i källkoden är ju syftet att övervaka statistiken för konton som tillhör USAs två styrande partier och Elons konto som är det med flest följare. Samt alla andra användare med stort inflytande, varför även flaggan <a href="https://github.com/twitter/the-algorithm/blob/7f90d0ca342b928b479b512ec51ac2c3821f5922/home-mixer/server/src/main/scala/com/twitter/home_mixer/functional_component/decorator/HomeTweetTypePredicates.scala%23L230">“author_is_power_user”</a> går att finna i koden. En fullt rimlig kategorisering för att i grova drag upptäcka algoritmisk vinkling i olika riktningar.</p>
<blockquote><p>I uppenbar frustration raderar Elon Musk sitt inlägg och tar sitt privatjet tillbaka till kontoret.</p></blockquote>
<p>Detta <a href="https://github.com/twitter/the-algorithm/issues/236">upptäckte användarna</a> på GitHub samma dag som koden publicerades för allmänheten. Vilket en användare på dåvarande Twitter ställde som <a href="https://x.com/mahdi/status/1641908668240216068">en direkt fråga</a> till Elon Musk och hans anställda samma kväll under en livesändning och frågestund på Spaces. Men de efterföljande diskussionerna och konspirationsteorierna verkar ha spridit sig i en tillräckligt stor utsträckning. I alla fall tillräckligt stor för att två <em>New York Times</em>-journalister ska sprida det falska påståendet om Musks avsiktliga manipulation av algoritmerna för egen vinning genom sin bok. Ett falskt påstående som även plockas upp av chefredaktören för en av Sveriges största tidningar.</p>
<p>Men så många kan ju inte ha fel. Samtidigt. Om samma sak.</p>
<h2>Källan, februari 2023</h2>
<p>Ett och ett halvt år kvar till det amerikanska valet. Flera amerikanska medier, bland annat <em><a href="https://www.washingtonpost.com/technology/2023/02/16/elon-musk-twitter/">Washington Post</a></em>, <em><a href="https://www.rollingstone.com/culture/culture-news/elon-musk-engineers-twitter-engagement-1234680113/">Rolling Stone</a></em>, <em><a href="https://fortune.com/2023/02/15/elon-musk-tweets-boost-joe-biden-super-bowl/">Fortune</a></em>, <em><a href="https://nypost.com/2024/02/14/business/ex-twitter-engineer-says-musk-wrongly-fired-him-over-leaks-to-media-book/">New York Post</a></em> och <em><a href="https://www.theatlantic.com/technology/archive/2023/02/elon-musk-twitter-ethics-algorithm-biases/673110/">The Atlantic</a></em>, rapporterar om det spektakulära händelseförloppet:</p>
<p>Elon Musk har publicerat ett inlägg på X där han hejar på Philadelphia Eagles under pågående Super Bowl en söndag. President <strong>Joe Biden</strong> publicerar också ett inlägg (från det officiella presidentkontot @potus) till stöd för samma lag i samma veva. Biden får hela 29 miljoner visningar. Musk bara nio miljoner. I uppenbar frustration raderar Elon Musk sitt inlägg och tar sitt privatjet tillbaka till kontoret. Väl på plats beordrar han ingenjörerna att rigga plattformens algoritmer – från och med nu så ska alla användare se hans inlägg först och mest.</p>
<p>Källan är <a href="https://www.platformer.news/yes-elon-musk-created-a-special-system/">en artikel</a> i <em>Platformer</em>, ett nyhetsbrev från <strong>Zoë Schiffer</strong> och <strong>Casey Newton</strong>, som två dagar efter matchen publicerar texten under rubriken ”Yes, Elon Musk created a special system for showing you all his tweets first”. Nyhetsbrevets grundare Casey var tidigare på <em>The Verge</em>, <em>CNET</em> och <em>San Francisco Chronicle</em>. Även Zoë hade ett förflutet på <em>The Verge</em> för att sedan bli chefredaktör på <em>Platformer</em>.</p>
<p>Artikeln inleder med att den är baserad på intervjuer med personer som ”haft kännedom” om de aktuella händelserna, samt “dokument som erhållits av författarna”. Att källorna är anonyma gör förstås trovärdigheten svårare att bedöma, men det är förståeligt då en av källorna sägs fortfarande arbeta på företaget. Denna källa står dock för det enda citatet i hela artikeln, som i det allra sista stycket menar att Elon Musk ”inte vill allas bästa” eftersom ”han vill att användarna på X endast ska höra hans röst”. De andra källorna får vi varken veta något mer om eller höra något ifrån, då det ingen annanstans i texten finns något citat som styrker författarnas version av händelseförloppet. Dokumenten som stöder artikeln får läsaren inte heller se ett spår av. Varken utdrag, skärmdumpar eller hänvisningar som kunde ha styrkt något av vad som påstås i artikeln.</p>
<p>Författarna etablerar tidigt i texten att Elon Musk raderade inlägget ”i uppenbar frustration”. Insinuationen blir att en lättkränkt Elon Musk raderar ett inlägg om en fotbollsmatch i ren och skär avundsjuka för att en sittande president fått fler visningar. Denna premiss är nödvändig för att logiken i författarnas version av händelseförloppet ska gå ihop. Därför är det olyckligt att vi inte får ta del av något underlag som styrker författarnas vetskap om denna ”uppenbara frustration”. Samma kväll raderade Elon Musk <a href="https://www.snopes.com/fact-check/elon-musk-eagles-tweet/?ref=platformer.news">ett till inlägg</a> om samma match, efter att laget han hejade på förlorade. Något som författarna inte nämner någonstans i artikeln.</p>
<p>En annan intressant detalj som artikeln inte nämner är en serie inlägg som Musk publicerade <a href="https://x.com/elonmusk/status/1624660886572126209">kvällen innan</a> det omtalade händelseförloppet. Där redogör han för olika utmaningar som de anställda jobbat med under dagen för att lösa. Bland annat en ändring i hur algoritmerna straffar användarnas synlighet utifrån hur ofta de blivit blockerade. Tidigare så utgick algoritmerna från det absoluta antalet gånger ett konto blivit blockerat. Aktivister missbrukade detta genom att gå ihop i stora grupper och skapa “blocklistor”, med målet att i stor skala blockera konton vars åsikter de inte gillade. Den som hamnade på en välorganiserad meningsmotståndares “blocklista” riskerade således en oproportionerligt minskad exponering – det vill säga gentemot alla andra på plattformen som inte blockat personen.</p>
<blockquote><p>Att Musk flög tillbaka till Twitters huvudkontor och beordrade någon sorts förändring av algoritmerna råder det dock ingen tvekan om.</p></blockquote>
<p>Det var också ett problem för stora konton i allmänhet, eftersom fler följare innebär potentiellt fler som blockerar en. Algoritmerna skulle numera i stället utgå ifrån hur många som blockerat dig relativt antalet följare du har. Och bara några dagar innan matchen hade Elon Musk tydligen uttryckt en tydlig skepsis kring algoritmerna för sina ingenjörer och rådgivare. Under mötet, enligt ”källor med direkt vetskap”, ska han ha sagt att ”detta är löjligt. Jag har över 100 miljoner följare och jag får bara tiotusentals visningar”.</p>
<p>Om källorna talar sanning så tyder även detta på ett missnöje med hur algoritmerna fungerar i allmänhet, snarare än att det rör sig om en lättkränkt narcissist som fullständigt tappat kontrollen på grund av antalet visningar för ett inlägg. Lyckligtvis är det inte du och jag som behöver lita på källorna i det här fallet. Det är nämligen artikelförfattarna själva som <a href="https://www.platformer.news/elon-musk-fires-a-top-twitter-engineer/">rapporterar detta</a> i sitt egna nyhetsbrev, bara fem dagar tidigare. Vi kan bara utgå ifrån att de själva litar på sina egna texter.</p>
<p>Att Musk flög tillbaka till Twitters huvudkontor och beordrade någon sorts förändring av algoritmerna råder det dock ingen tvekan om; alla som öppnade appen på måndagen dagen efter matchen kunde notera att Elon Musks inlägg hade letat sig in överallt i väldigt mångas flöden. Något Musk själv bekräftade när han dels publicerade <a href="https://x.com/elonmusk/status/1625368108461613057?ref=platformer.news">en satirisk meme</a> som respons på situationen, och dels när han <a href="https://x.com/elonmusk/status/1625407245218648065?ref=platformer.news">kommenterade</a> att algoritmen håller på att justeras.</p>
<h2>Algoritmerna</h2>
<p>Enligt artikelförfattarna är det Musk som beordrar ingenjörerna att rigga algoritmerna så att alla användare ska se hans inlägg först och mest. Först i rubriken ”Yes, Elon Musk created a special system for showing you all his tweets first”, sedan direkt i ingressen: “Twitter’s CEO ordered major changes to the algorithm”. Lite senare ändrar de sin formulering och det heter i stället att ”ingenjörerna byggde ett system som skulle lyfta Musks inlägg på en nivå som saknade motstycke”. Hur ska de ha det? Och hur kan de dra slutsatsen att det faktiskt var Musk som beordrade riggningen trots allt? Detta påminner oroande mycket om skildringen i <em>Character limit</em> av <em>New York Times</em>-journalisterna, där ingenjörerna modifierar algoritmerna på eget bevåg för att ”lugna ner Musk”. Detta med införandet av kodsnutten ”author_is_elon” som garanterar gudomligt herravälde. Men även i boken är det Elon Musk som ligger bakom riggningen, bara några rader senare. Utan att läsaren får veta hur författarna kommit fram till det, av det dittills presenterade underlaget. Och den magiska kodsnutten nämns inte i artikeln. Alls. Har inte deras källor ”haft kännedom” om denna kritiska detalj i konspirationens kärna?</p>
<p>Något som tyder på att de inblandade källorna haft väldigt lite kännedom om något väsentligt överhuvudtaget, är att händelseförloppet utspelas två veckor innan algoritmerna ska släppas som öppen källkod. En öppen källkod som måste vara en monumental konspiration till skenmanöver för att dessa utsagor överhuvudtaget ska gå ihop. Källor med kännedom bör ha plockat upp en och annan ledtråd om att en sådan skenmanöver är i görningen. Inte minst två veckor innan sjösättning.</p>
<p>Det enda som alla inblandade källor verkar ha kännedom om är att Elon Musk har riggat algoritmerna så att alla användare ska se hans inlägg först och mest. Så olyckligt att vi aldrig får veta hur eller varför de besitter denna kännedom.</p>
<p>Man kan rimligen anta att en person som lyckats som uppstickare i både bank-, bil- och rymdbranschen, tre branscher som är notoriskt svåra att bryta sig in i för övrigt, måste besitta åtminstone normalgradens nivå av strategiskt tänkande när det gäller tekniskt affärstänk. Det krävs ingen doktorsexamen i nätverksvetenskap för att inse den omgående förödande effekten för ett socialt nätverk om man riggar dess algoritmer till en enda persons fördel. Dessutom förefaller det vara en drastisk åtgärd när man redan har flest användare på hela plattformen, och användaren på andraplats bara har lite mer än hälften så många följare – det är <strong>Barack Obama</strong>.</p>
<p>Kan det ha varit generella brister kring algoritmen som var startskottet för det spektakulära händelseförloppet, som kanske inte var så spektakulärt trots allt? Kan en enklare förklaring vara att det ligger i en relativt nybliven ägares intresse att veta varför ett konto med tre gånger fler följare får färre visningar för ett inlägg om samma ämne som publicerats ungefär samtidigt? Eller varför det största kontot med över hundra miljoner följare bara får några tiotusentals visningar på sina inlägg?</p>
<p>För mig som spenderat några år av mitt yrkesliv på ett företag som byggde sociala nätverk med miljontals användare världen över så är det en fullt legitim frågeställning. Det utesluter förstås inte att Elon Musk kan ha varit avundsjuk på presidenten och hans många fler miljoner visningar också. Men att det skulle vara katalysatorn låter tämligen extraordinärt. Med det sagt så var <a href="https://x.com/POTUS/status/1624931580962656261?lang=en">presidentens inlägg</a> monumentalt mycket roligare och påhittigt. Att det fick stor spridning och ett högt antal visningar i sig är föga förvånande.</p>
<p>Det finns en rätt så odramatisk men tekniskt grundad förklaring till varför Elon Musks inlägg plötsligt tog över allas flöden den där måndagen. En stor digital plattform med miljontals användare består av enorma mängder datorkod. Om vi tar Spotify som exempel så handlar det om 60 miljoner rader datorkod , vilket i runda slängar motsvarar mängden text i 600 böcker. Koden har dessutom utvecklats under lång tid av väldigt många olika personer. Därmed finns det inte en enstaka person som har koll på hur hela plattformen fungerar. Man kan till och med ramla över snuttar av kod som ingen på företaget förstår sig på överhuvudtaget, eftersom det skrevs för länge sedan av någon som inte längre jobbar kvar. Och ju längre bakåt i tiden kodsnutten skrevs, desto större sannolikhet att det är en viktig komponent i plattformens kärna. Dechiffreringen kan stundtals bli väldigt plågsam, vilket också är varför man inte vill att endast en person ska ha vetskap om någon aspekt av koden. Därmed är också sannolikheten väldigt låg för att &#8221;hemliga snuttar kod” skulle vara gömda här och var. Speciellt när det rör sig om kärnfunktioner.</p>
<p>En digital social plattform som X/Twitter är inget undantag från denna hisnande komplexitet. Vid alla justeringar och modifikationer av plattformen finns det därför en risk för att utfallet inte blir som tänkt. Inte minst när det gäller sammansättningen av algoritmer som ska styra och filtrera innehållet i allas flöden. En tillsynes liten justering på en plats i systemet kan leda till en tsunami av kedjeeffekter någon annanstans. Eftersom det är ett digitalt socialt nätverk finns också risken att effekterna blir starkare ju fler följare ett konto har.</p>
<p>Som den där måndagen.</p>
<p>Inom ett par dygn så var Elon Musks bisarrt frekventa närvaro i allas flöden över. <a href="https://x.com/elonmusk/status/1626520156469092353">Enligt honom själv</a> berodde spektaklet på en bugg där algoritmerna började lyfta fram svaren på inlägg i lika stor utsträckning som det initiala inlägget. Om det stämmer så är det inte konstigt att buggens effekter förstärktes avsevärt mycket mer för det i särklass största kontot, jämfört med de andra kontona. Speciellt när kontot ägs av en notoriskt aktiv ”twittrare” som frekvent svarar på folks inlägg.</p>
<p>Kanske flaggningen “author_is_elon” inte var så dum ändå.</p>
<h2>Osanningen</h2>
<p>Magnaten och numera en nyckelspelare i den blivande presidentens administration äger inte bara en av världens största sociala plattformar. Han manipulerar dessutom algoritmerna för egen politisk vinning. Det har flera skribenter i flera av Sveriges största nyhetsmedier sagt under månaden som gått.</p>
<p>Källan visade sig i huvudsak vara en nästan två år gammal artikel i ett nyhetsbrev. Trots dess flerfaldiga uppenbara tillkortakommanden blev artikeln genast citerad av en mängd etablerade medier världen över. Sökmotorernas algoritmer som premierar länkar av välrenommerade mediehus högt ökade således artikelns och nyhetsbrevets synlighet drastiskt bland sökresultaten. Det i sin tur ledde till att ännu fler medier och andra sidor länkade till artikeln, vilket ökade artikelns synlighet ännu mer, och så vidare. När skribenterna i Sverige två år senare gör sina analyser och profetior om valet och demokratin och gör en sökning för att läsa om algoritmerna på X, så blir de algoritmiskt serverade en radda av texter från utlandet som påstår att Musk manipulerar X:s algoritmer till sin fördel. Om inte från utlandet så fick de den inhemska kavalkaden av TT-telegram serverade i stället. Eller texten från chefredaktören på en av landets största tidningar, som valde att fokusera på det något alternativa “author_is_elon”-spåret. I praktiken blev nog skribenterna serverade en rejäl och salig blandning av alltihopa.</p>
<p>Så många runtom hela världen kan ju verkligen inte ha fel. Samtidigt. Om samma sak.</p>
<p>Allt detta sker under ett sedan länge pågående medieklimat där traditionella etablerade medier regelbundet varnat oss medborgare: demokratin är under ett allvarligt hot från desinformationen, algoritmerna och internet. Underförstått är att de seriösa mediernas hegemoni över sanningen är demokratins enda väg ut ur helvetet. Samma seriösa medier som det vattnas i munnarna på när det exempelvis nalkas rubriker om onda techbaroner som cyniskt manipulerar plattformsalgoritmer. Till den grad att deras källkritiska körtlar imploderar av upphetsning, och osanningar hejdlöst börjar sippra ut åt alla håll och kanter. Samma typ av osanningar vars rimlighet balanserar på ett rangel av retoriska trollkonster och kräver mental gymnastik på olympisk nivå. Samma typ av osanningar som de mödosamt vill skydda oss ifrån.</p>
<p>För demokratins skull.</p>
<h2>Från tryckpressen till algoritmen</h2>
<p>Många medborgare i liberala demokratier funderar säkert på frågan om desinformation, algoritmer och internet innebär början på slutet för demokratin. Det gör även jag. De traditionella medierna är till syvende och sist sprungna ur tryckpressen. Som bransch har de uppstått som en naturlig och nödvändig efterföljd av <strong>Gutenbergs</strong> innovation på 1400-talet. Det underliggande problemet med all sorts massproduktion, speciellt när den standardiserats och blivit allmänt utspridd och tillgänglig, är att det alltid finns en inneboende risk för att det produceras en massa skräp. Att förlagens uppkomst sammanfaller med tryckpressen är därför ingen slump, då tryckt text är det första som människan lyckas massproducera i stor skala. Förlag som agerar på en rättvis och fri mediemarknad blir således en organisk motkraft mot ett överflöd av undermåliga produkter.</p>
<p>Branschen som helhet behöll därmed sitt existensberättigande i flera århundraden av denna mycket konkreta anledning. För musikförlagen, som först sålde tryckta noter och sedan fonogram i och med skivpressen, innebar det att skilja artister med talang från mediokra posörer. För nyhetsbolagen innebar det så småningom att filtrera bort lögn och irrelevans från det sanna och relevanta.</p>
<blockquote><p>I den digitala miljön blir trovärdigheten den ultimata valutan.</p></blockquote>
<p>Den mekaniska och linjära tryckpressen är dock inte längre det dominerande informationsmediet i världen. Världen upphör därför att vara mekanisk och linjär. Med internet som det dominerande informationsmediet befinner vi oss numera i en miljö som är präglat av ett organiskt kaos; allting händer överallt samtidigt hela tiden. Så blir det när information strömmar mellan fem miljarder hjärnor och femton miljarder ting som är sammankopplade dygnet runt över hela jordklotet. Med varsin digital informationspress i fickan kan dessutom vem som helst producera bilder, filmer, musik, böcker, intervjuer, samtal, texter, och allt som hör till.</p>
<p>Resultatet blir mer brus, informationsöverflöd och mediokert skräp än vi någonsin skådat.</p>
<p>Därför är det inte musikförlagen som sitter högst i hierarkin. Det är de musikalgoritmer som filtrerar, identifierar och presenterar relevant musik till relevant person vid relevant tillfälle.</p>
<p>Därför är det inte bokförlagen som sitter högst i hierarkin. Det är de bokalgoritmer som presenterar relevant bok till relevant person vid relevant tillfälle.</p>
<p>Därför kommer tidningsförlagen heller inte sitta högst upp i sanningens hierarki. Det blir de sanningsalgoritmer som presenterar relevant sanning till relevant person vid relevant tillfälle.</p>
<p>I den digitala miljön blir trovärdigheten den ultimata valutan. Både för människorna och algoritmerna. Mediokert arbete kommer inte premieras av algoritmerna. Mediokra algoritmer kommer inte premieras av människorna. Vare sig det handlar om musik, litteratur, journalistik eller politik. Och allt annat. Därför får de algoritmer som presenterar en radikalt ärlig reflektion av verkligheten för användarna högst trovärdighet i längden. Detsamma gäller oss människor. Efter över ett århundrade där falsk trovärdighet och fabricerad uppmärksamhet kunnat köpas med pengar, så tror jag internet har skapat ett obeskrivligt starkt växande sug efter trovärdighet som är äkta och inte köpt. Trovärdig betyder dock varken god, snäll eller moralisk. Inte demokratisk för den delen heller. Och jag tror det är precis här mycket av friktionen uppstår, mellan det mekaniska och linjära förflutna och det organiska och kaotiska nuet. Som i alla nätverk bestående av människor kommer en liten minoritet överglänsa majoriteten. Talang är trots allt inte demokratiskt fördelad. Ärlighet kommer därför att löna sig, mer än någonsin.</p>
<p>Inte minst för den som aspirerar på att förmedla den bästa möjliga presentationen av sanningen.</p>
<p>Jag tror inte att demokratin är på väg att förstöras. Jag tror bara att den är på väg att bli väldigt, väldigt annorlunda. Vägen dit kommer att vara lika smärtsam som spännande. Historikern <strong>Carroll Quigley</strong> myntade i sin bok <em>The evolution of civilizations</em> från 1961 begreppet ”cultural lag”, efter observationen att kulturen i ett samhälle tenderar att lagga efter teknologin med flera generationer.</p>
<p>Därför tror jag att även de traditionella mediehusen kommer inneha ett högt förtroende bland väsentliga andelar av befolkningen i en lång tid framöver. Samtidigt som de sakta men säkert tappar sin faktiska relevans; det ser teknologins oförlåtande frammarsch till. De traditionella mediernas tynande sanningsmonopol är således inte självförvållat. Tvärtom så tror jag inte det spelar någon roll, i det stora hela, hur de traditionella medierna agerar i den tumultartade övergången mellan två informationsteknologiska paradigm. Deras ständiga alarmism kommer aldrig återbringa den mediala hegemoni som på den kulturella tidsaxeln ännu verkar råda. Det blir snarare bara en allt mer betryggande snuttefilt för dem som inte vågar kliva ut och acceptera det nya. Ett falskt eko om en svunnen världs återkomst.</p>
<p>Men till syvende och sist kommer många ha fel. Samtidigt. Om samma sak.</p>
<p>Det ser teknologins oförlåtande frammarsch också till.</p>
<div class="author-byline">Ashkan Fardost har ett förflutet som doktor i kemi, artist på Armada Music och produktchef på Soundtrap. Idag föreläser han världen runt om teknologins effekter på människan, näringslivet och samhället.
</div>
</div>
