Så gick det till när nätet var ungt

<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-96606"      class = "kv-pod-holder kv-player-light  lplo " data-sid="" data-eid="" data-pid="96606" data-pty="SW5sw6RzdCBhcnRpa2VsIChTYW1ow6RsbGUp" data-pna="U8OlIGdpY2sgZGV0IHRpbGwgbsOkciBuw6R0ZXQgdmFyIHVuZ3Q=" data-acurl="aHR0cHM6Ly9tZWRpYS5wb2Quc3BhY2UvaW5sYXN0YXRleHRlci9zYV9naWNrX2RldF90aWxsX25hcl9uYXRldF92YXJfdW5ndC5tcDM=" data-psurl="aHR0cHM6Ly9tZWRpYS5wb2Quc3BhY2Uva2p4ajYzeWRkZXEydmgvc2EtZ2ljay1kZXQtdGlsbC1uYXItbmF0ZXQtdmFyLXVuZ3QubXAz">  <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: "><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-gick-det-till-nar-natet-var-ungt%2F&amp;t=S%C3%A5+gick+det+till+n%C3%A4r+n%C3%A4tet+var+ungt"    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+gick+det+till+n%C3%A4r+n%C3%A4tet+var+ungt+-+https%3A%2F%2Fkvartal.se%2Fartiklar%2Fsa-gick-det-till-nar-natet-var-ungt%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-gick-det-till-nar-natet-var-ungt%2F"    target = "_blank"    class  = "li-link"    title  = "Dela på LinkedIn"><i class="ti-linkedin ui transparent"></i></a><a href    = "mailto:?subject=Så gick det till när nätet var ungt&body=https://kvartal.se/artiklar/sa-gick-det-till-nar-natet-var-ungt/"   target  = "_blank"    class   = "pr-link"    title   = "E-posta"    onclick = ""><i class="ti-email ui transparent"></i></a><a href    = "https://kvartal.se/skriv-ut/96606/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/Henrik_lowres2.jpg');"></div><img class="author-print-img" src="https://kvartal.se/wp-content/uploads/2024/07/Henrik_lowres2.jpg" style="display: none;">    </div>    <div class="by-disclaimer-holder" style="color: #8a3a67">Av <a href="https://kvartal.se/medverkande/henrik-hojer/">Henrik&nbsp;Höjer</a> | 26 maj 2023<div class="author-desc">Henrik Höjer är Kvartals vetenskapsredaktör. Han är även historiker och fö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%2Fsa-gick-det-till-nar-natet-var-ungt%2F&amp;t=S%C3%A5+gick+det+till+n%C3%A4r+n%C3%A4tet+var+ungt"    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+gick+det+till+n%C3%A4r+n%C3%A4tet+var+ungt+-+https%3A%2F%2Fkvartal.se%2Fartiklar%2Fsa-gick-det-till-nar-natet-var-ungt%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-gick-det-till-nar-natet-var-ungt%2F"    target = "_blank"    class  = "li-link"    title  = "Dela på LinkedIn"><i class="ti-linkedin ui transparent"></i></a><a href    = "mailto:?subject=Så gick det till när nätet var ungt&body=https://kvartal.se/artiklar/sa-gick-det-till-nar-natet-var-ungt/"   target  = "_blank"    class   = "pr-link"    title   = "E-posta"    onclick = ""><i class="ti-email ui transparent"></i></a><a href    = "https://kvartal.se/skriv-ut/96606/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-gick-det-till-nar-natet-var-ungt/?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 10 min</span></a><a href   = "https://kvartal.se/skarmlasarvanlig/96606"    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-96606">  <div class="in-short-inner">    <span class="close_button close-in-short in-short-toggle" data-articleid = "96606"></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 ">Många kommer ihåg den socialdemokratiska kommunikationsministern <strong>Ines Uusman</strong>. Våren 1996 ska hon ha sagt något om att ”internet är en fluga som kanske blåser förbi” i en intervju i Svenska Dagbladet. Eller gjorde hon det? Nja, <a href="https://internetmuseum.se/tidslinjen/internet-ar-en-fluga/">inte riktigt.</a></p>
</div>
<div class="rest-of-article ">
<p>Men svenska journalister började uppmärksamma den nya tekniken långt tidigare än så. Runt 1990 börjar små notiser om internet dyka upp allt oftare. ”I USA slogs 6 000 datorer ut när en datamask spred sig i datanätet Internet” kunde man läsa i kvällstidningen Idag våren 1990. Datormaskar förekom en del i medierna kring 1990 i samband med internet. De var vanliga, enligt Expressen: ”De finns över hela världen och ställer till förtret och oreda, förstör disketter etc.” Dessa kunde förekomma i ”det övergripande Internet-nätet” som användes av försvaret och för militära forskningsprogram.</p>
<p>I sådana mindre notiser nämndes internet, och det är oklart hur mycket folk förstod av den nya tekniken.</p>
<h2>Revolution på gång</h2>
<p>I september 1992 kunde man i Dagens Nyheter läsa en av de första riktigt informativa och längre texterna om internets potential under rubriken: ”Biblioteket skickar boken hem i datorn.” Nu är det revolution på gång, visste <strong>Sven Lindqvist</strong> att berätta. Ett globalt elektroniskt bibliotek var på väg att inrättas: ”Under de senaste tre fyra åren <span style="color: #000000;">har </span>de akademiska nätverken för datakommunikation byggts ut i mycket snabb takt.” Hundratals datorer inom universitetsvärlden över hela världen hade förbundits med varandra: ”Man kan skicka elektronisk post, delta i konferenser, läsa varandras anslagstavlor, föra över dokument och program.”</p>
<p>Dessa datornätverk hade olika namn men samlingsnamnet var ”Internet”, fick läsaren veta. Detta nätverk har växt fram spontant, nästan anarkistiskt, berättade Sven Lindqvist. Varje användare hade en egen adress – här syftar han på e-postadressen – och man kunde skicka meddelanden till hela grupper samtidigt. Allt fler ansluter sig nu, hösten 1992, till dessa nätverk. I framtiden kan man alltså söka upp en bok eller en artikel och få den i sin dator i samma ögonblick som den sänds. En bra spaning.</p>
<blockquote><p>Internet – en ”global superautostrada för data”&#8230;</p></blockquote>
<p>Även i Svenska Dagbladet kunde man läsa om detta ”Internet” samma höst, där man kunde nå 200 000 datorer inom ett par timmar.</p>
<p>Tonen i dessa tidiga artiklar är överlag positiv – tekniken går framåt och kan hjälpa oss.</p>
<p>Hösten 1993 hade Svenska Dagbladet en större artikel med vinjetten ”Databaser” – rubriken var ”Med en dator och ett modem kan du busa över hela världen”. Helsidesartikeln berättade om hur datorer nu kunde koppas ihop som en elektronisk mötesplats – ”en kombination av brevlåda, telefonsvarare, rundabordskonferens och programbibliotek”. Detta skedde genom något som kallades BBS – <em>Bulletin Board System</em>, ett slags elektronisk anslagstavla som är bortglömd idag.</p>
<h2>Moralister kontra cyberpunkare</h2>
<p>Det räckte med en dator och ett modem för att kunna spela datorspel med någon i Australien, diskutera miljöproblem eller ”sprida obehagliga åsikter till moralisternas förtret”. Man kunde använda nätet till att få nyheter från Tibet, spela rollspel, lyssna på ny techno, intervjua cyberpunkförfattare eller ge <strong>Bill Clinton</strong> goda råd.</p>
<p>Man kunde även komma i kontakt med just Internet – en ”global superautostrada för data” och skicka elektronisk post över hela världen. Internet hade, enligt artikeln i Svenska Dagbladet, 15 miljoner användare år 1993. Visst fanns det hot – i form av virus, piratkopior, barnporr och rasistpropaganda. Men det var endast några få procent som sysslade med sådant, försäkrade artikelförfattaren <strong>Anna Lundevall</strong>.</p>
<p>Samma år kunde man läsa i Dagens Nyheter om <em>cyberpunkare</em> (under vinjetten ”Cyberdebatten går vidare”). På nätet möttes nu miljontals människor i massor av diskussionsgrupper kring CP-relaterade ämnen (”CP=cyberpunk”). Det kunde handla om nätetikett, cyberspace eller äventyrsspel.</p>
<blockquote><p>Nätet var framtiden, och framtiden var ljus.</p></blockquote>
<p>För yngre läsare kan man påminna om att nätet inte kunde hantera filmer på denna tid, och bara att ladda upp bilder kunde ta tid. Sociala medier fanns inte heller. Man klickade sig i regel fram mellan olika hemsidor. Nätet var alltså till stora delar texter på hemsidor med länkar till andra hemsidor. Och att kunna skicka e-post till hela världen. Sekundsnabbt! Det var långt till Tiktok och Instagram, om man säger så.</p>
<p>I stället tog cyberpunkaren stor plats i rapporteringen. ”Cyberpunkaren kan beskrivas som en informationsanarkist. Han eller hon använder tekniken för att träffa folk elektroniskt, på Internet eller in den vildvuxna floran av elektroniska anslagstavlor (BBS-er)”, kunde man läsa. Via de nya kommunikationerna och genom kablar och skärmar spreds information, och där föddes nya kulturer och nya idéer. Folk från hela jorden träffades i dessa nya digitala gemenskaper – en ”datoriserad textvärld”. I framtiden, kunde man läsa, ”kan kommandoraderna ersättas med grafiska gränssnitt, där man också ser varandra” – den gamla framtidsdrömmen om bildtelefonen kunde alltså rymmas i fantasierna om nätets framtid.</p>
<p>Nätet var framtiden, och framtiden var ljus. I en artikel i Dagens Nyheter från samma år kunde man läsa: ”Nätet är det perfekta demokratiska instrumentet!”</p>
<h2>Allt från porr till kärlek</h2>
<p>I andra texter från tidigt 1990-tal kunde man läsa obegripligheter som att ”framtiden blir hård som chips”, att man kunde korsa Atlanten på ett par sekunder på Internet och liknande. Någon varnade för att digitala bilder kan manipuleras – man kunde nu inte längre lita på att en nyhetssändning i tv var äkta, påpekade<strong> Per Eriksson</strong> vid Konstfack i en intervju i Dagens Nyheter den 9 maj 1993.</p>
<p>Andra återkommande varningar var att det förekom porr på internet.</p>
<p>Men även kärleken kunde vara digital. År 1994 kunde man läsa ett reportage om par som träffats på nätet. De trodde att man öppnade sig mer på nätet, varvid ljuv musik kunde uppstå. ”Så kan det gå när datorn är på”, sammanfattade rubriken i Arbetet Nyheterna i september 1994.</p>
<p>Tonen på internet är rå men hjärtlig, försäkrade Dagens Nyheters <strong>Patrik Hadenius</strong> i en tvåsidig artikel med rubriken ”Internet, ett språk för hela världen” i november 1994. Han påpekade dock att internet var svårt att använda och dessutom relativt dyrt. Men detta skulle snart vara avhjälpt, allt enklare hjälpprogram var i antågande och konkurrensen pressade ned priserna hos telefonbolagen.</p>
<p>Åren därpå snarast exploderar det av artiklar om internet i svensk press, och allt fler började ta del av tekniken. Själv fick jag min första e-postadress våren 1996 och jag minns att jag ”surfade” på internet i slutet av 1995. Det gick väldigt långsamt, kommer jag ihåg. Den som vill veta mer om nätets historia mer kan med fördel läsa om det på <a href="https://internetmuseum.se/">Internetmuseum</a>.</p>
<p>Tonen var överlag hoppfull och teknikentusiastisk i de texter man kan hitta via Kungliga bibliotekets <a href="https://tidningar.kb.se/?q=internet">sökmotor</a>. Sociala medier, smartphones, trådlösa uppkopplingar och <em>fake news</em> skrevs det dock mindre om.</p>
<h2>Teknik som kan missbrukas</h2>
<p>En av dem som bevakade internet i början av 1990-talet var Patrik Hadenius. Då var han vetenskapsredaktör på Dagens Nyheter, sedan blev han teknikredaktör och efter hand chefredaktör på Forskning &amp; Framsteg. Idag är han förlagschef på Norstedts. Vi träffas i förlagets anrika lokaler på Riddarholmen, och börjar samtalet om dagens digitala utmaningar.</p>
<p>– Jag är inte så orolig inför AI, säger han. AI kommer inte att bli medvetet och ta över världen. Däremot är det ett kraftfullt verktyg. Som säkert kan missbrukas och användas på sätt vi inte gillar. Till exempel göra <em>deep fake</em>. Men det finns inga som helst tecken på att AI ska vara skapande. Den kan däremot dammsuga nätet på information och sätta ihop ett meningsfullt resultat.</p>
<p><strong>Använder du själv AI?</strong></p>
<p>– Ja, men jag är väldigt skeptisk till den data jag får ut. Det blir knas ibland – men det ser snyggt ut! Den har däremot ett enormt självförtroende.</p>
<p><strong>Har du några exempel på vad du använder AI till?</strong></p>
<p>– Jag använder den till översättningar och för att få inspiration. Man kan använda ChatGPT som ett bollplank. Den är även bra på att skriva kortare texter, åtminstone språkligt. Så i dagsläget &#8230; ja, kul! Men inte så bra innehållsligt – än.</p>
<figure id="attachment_96609" aria-describedby="caption-attachment-96609" style="width: 1440px" class="wp-caption alignnone"><img fetchpriority="high" decoding="async" class="wp-image-96609 size-full" src="https://kvartal.se/wp-content/uploads/2023/05/Patrik-Hadenius-portratt.jpg" alt="kvartal" width="1440" height="1920" data-wp-pid="96609" srcset="https://kvartal.se/wp-content/uploads/2023/05/Patrik-Hadenius-portratt.jpg 1440w, https://kvartal.se/wp-content/uploads/2023/05/Patrik-Hadenius-portratt-1152x1536.jpg 1152w, https://kvartal.se/wp-content/uploads/2023/05/Patrik-Hadenius-portratt-600x800.jpg 600w, https://kvartal.se/wp-content/uploads/2023/05/Patrik-Hadenius-portratt-225x300.jpg 225w, https://kvartal.se/wp-content/uploads/2023/05/Patrik-Hadenius-portratt-768x1024.jpg 768w" sizes="(max-width: 1440px) 100vw, 1440px" /><figcaption id="caption-attachment-96609" class="wp-caption-text">Patrik Hadenius, förlagschef på Norstedts.</figcaption></figure>
<p><strong>Du är intresserad av teknik. Vad minns du av tiden då internet slog igenom?</strong></p>
<p>– Jag var tidigt ute, en <em>early adopter</em>. Jag läste på KTH och fick en e-post redan 1985. Jag minns att jag blev <em>mindblown</em> när jag var i USA runt 1990 och kunde logga in på en random dator och hitta min egen e-post. Wow!</p>
<p><strong> När surfade du på nätet första gången?</strong></p>
<p>– Det var nog redan på 1980-talet. Då var nätet något mycket snävt och litet. En subkultur för rollspel och liknande.</p>
<p><strong>Minns du ordet cyberpunk? Det ordet förekom ofta i pressen i början av 1990-talet. Vad betydde det?</strong></p>
<p>– Ingenting! Det var bara en oemotståndlig kombination av ord. Ett buzzword. Det var liberalismens eller libertarianernas stora tid, murar hade välts, gränser skulle rivas – och det nya nätet vävdes in i denna berättelse.</p>
<p><strong>Vad minns du mer av dessa år?</strong></p>
<p>– Att det vi skrev var 90 procent ren folkbildning. Typ, så här funkar det! Det var väldigt få texter som handlade om vad internet kunde betyda för samhällsutvecklingen och liknande. Idag är det nästan tvärtom. Väldigt få förklarar vad generativ AI egentligen är, medan vi har massor av tyckande av allt ifrån fysiker till filosofer. Men var är ingenjörerna i debatten? Jag saknar deras synpunkter.</p>
<p><strong>Vad sades det mer när nätet var ungt? </strong></p>
<p>– Man hade stor tilltro till tekniken, till det fria ordet. Informationen skulle vara fri, tidningar lade ut massor av material gratis, ordet affärsmodell existerade knappt vad gällde nätpubliceringar. Det var en helt annan tid.</p>
<p><strong>Idag är tongångarna långt mer dystra, nätet förknippas inte sällan med filterbubblor, desinformation, demokratins undergång, skärmberoende och liknande – kommer du ihåg några negativa tankegångar?</strong></p>
<p>– Det pratades en del om risken för att jobb skulle förloras. Så är det ju nästan alltid vid stora teknikskiften. Folk skulle behöva omskola sig. Så det fanns en viss skepsis – men den var liten. Teknikoptimismen dominerade. Det är i alla fall min bild.</p>
<blockquote><p>Teknik är och förblir ett verktyg.</p></blockquote>
<p><strong>Tidsandan var ju också optimistisk på 1990-talet, var det den som smittade av sig? </strong></p>
<p>– Jag tror att det finns en svensk tradition eller kultur som är progressivt teknikpositiv. Tekniken är rationell, den har ingen klass, inget kön – den kan hjälpa oss. Teknik har varit arbetarrörelsen och kvinnorna till hjälp och så vidare. Vi har haft goda erfarenheter av teknik. Det är min gissning. Allt negativt med nätet har ju kommit de senaste fem-tio åren, eller hur?</p>
<p><strong>Kan det vara så att den negativa synen på nätet idag smittat av sig på de dystopiska tongångarna kring AI?</strong></p>
<p>– Ja, det är nog samma andas barn – men det hänger även ihop med att AI kan vara ett destruktivt redskap för den som vill världen illa. Men tidsandan spelar så klart in. Världen är lite mörkare idag. Då, på 1990-talet, ökade demokratin globalt och fler länder blev fria från förtryck. Internets genombrott fick draghjälp av tidsandan.</p>
<p><strong>Minns du något som vi idag skulle tycka var knasigt i internets barndom?</strong></p>
<p>– Ja, övertron på tekniken. Att tekniken <em>i sig</em> är lösningen. Teknik är och förblir ett verktyg. Ofta glömmer man att det är vi människor som använder tekniken. Till både bra och dåliga saker.</p>
<p><strong>Vad tänker du om debatten om AI idag? </strong></p>
<p>– Det är intressant – och bra! – att så många lyfter blicken från skärmen och diskuterar tekniken och dess konsekvenser mer övergripande. På 1990-talet var debatten överlag väldigt teknisk och instrumentell. Idag är det snarast tvärtom. Inte så många sätter sig in i tekniken och försöker förstå den i detalj.</p>
<p><strong>Kommer det som skrivs idag att åldras med värdighet, tror du? </strong></p>
<p>– Det tror jag inte. Jag skulle gissa att det mesta vi oroar oss för idag är helt fel. Däremot kommer det att hända helt andra saker som ingen idag kan förutspå eller förstå. På 1990-talet förutsåg till exempel ingen sociala medier och vilken tyngd och potential som finns i dessa. Ingen fattade kraften i att en president kan twittra! Jag läste i alla fall ingen sådan artikel på 1990-talet.</p>
<p><strong>Och din egen bransch, bokbranschen – hur har den klarat digitaliseringen? </strong></p>
<p>– Bättre än medierna skulle jag säga. Vi släppte inte iväg saker gratis, som medierna gjorde.</p>
<p><strong>Kommer AI att kunna skriva bra romaner som skulle kunna få ett Nobelpris? </strong></p>
<p>– Frågan är nog felställd (skratt)! Om du ställer frågan om en bra författare kan skriva en fantastisk roman med hjälp av AI – så är svaret definitivt ja. Men glöm inte att det är människan som skapar både AI och romanen. Vad har generativ AI tränats på? Jo, de samlade texter som människor skapat på nätet. Men det behövs alltid en människa för att skapa och förnya detta arv. Där finns kreativiteten.</p>
<p><strong>Du låter inte så oroad? </strong></p>
<p>– Nä, men sån är ju min inställning till det mesta!</p>
<div class="author-byline">Henrik Höjer är Kvartals vetenskapsredaktör. Han är även historiker och författare.
</div>
</div>
