När mjukvaran skapar sin egen verklighet

Mjukvara ljuger sällan av illvilja, men desto oftare av förenkling. Under ytan arbetar program med modeller, antaganden och genvägar som ibland förvandlas till små fiktioner: GPS:en som insisterar på att en avstängd väg fortfarande är öppen, rekommendationssystem som tror att vi är någon vi slutade vara för flera år sedan, ekonomiprogram som följer regler som sedan länge ändrats. Dessa tysta avvikelser formar vår vardag mer än vi anar. När systemen vi litar på börjar skapa sina egna versioner av verkligheten uppstår en ny sorts sanning — en digital, självsäker och ibland envist felaktig.

När antaganden blir fakta

Program försöker tämja verkligheten genom att förenkla den, men ibland stelnar deras förenklingar till något som liknar sanningar. Det sker gradvis. Ett system hittar ett mönster, gör en gissning och behandlar den sedan som en regel. Människor har en intuitiv känsla för när något inte längre stämmer, men mjukvara saknar den varningsklockan. Därför kan ett program fortsätta leva i en tidigare version av världen, som om historiken vore mer pålitlig än nuet. Det är just här som den märkliga logiken uppstår: en digital övertygelse som ingen längre håller i handen, men som ändå styr beteenden.

Hur en approximation blir ett faktum

Många system arbetar inte med verkligheten direkt utan med modeller av den. Ett navigationsprogram bygger sina rutter på statistiska antaganden om trafik. Ett rekommendationssystem tolkar spridda datapunkter som om de vore en heltäckande biografi om dig. Så länge modellerna är hyfsat nära sanningen fungerar allt fint, men när de glider börjar problemen växa.

Det börjar ofta harmlöst. Du följer samma pendlingsväg i två veckor och plötsligt antar programmet att detta är din livslånga vana. Ett analysverktyg hittar ett slumpmässigt mönster i datan och låter det därefter styra automatiska beslut. Med tiden växer sådana små snedsteg till strukturer som påverkar hela system.

• Ett tidigt antagande kan påverka alla följande beslut
• Ett program kan förstärka sina egna gissningar vid varje uppdatering
• Regelmotorer låser lätt fast sig vid premisser som ingen längre minns ursprunget till

När programmet vägrar släppa taget

Det märkliga är hur envist mjukvara kan hålla fast vid sina gamla föreställningar. System är byggda för stabilitet, och stabilitet innebär också att tidigare slutsatser får en nästan helig status. Du byter adress men systemet utgår från den gamla. Du ändrar dina vanor, men programmet följer den version av dig som det en gång registrerade. För mjukvaran är det enklare att fortsätta tro än att ompröva.

Många av dessa felaktiga antaganden uppstår i mötet mellan utvecklares förenklingar och användares oregelbundna beteenden. Ett värde sparas i en cache och glöms bort. En tumregel definieras i en regelmotor och blir kvar trots att världen ändrats. Lager efter lager byggs en intern verklighet som rullar vidare som ett eget litet kosmos. Den är logisk inifrån men allt mer skev utifrån sett, och den är samtidigt helt avgörande för hur vi rör oss genom vår digitala vardag.

Systemens envisa minnen

Mjukvara glömmer aldrig på det sätt som människor gör. Den glömmer selektivt, slarvigt eller inte alls. Därför kan föråldrad information leva kvar som sediment i ett system, lager på lager, tills ingen längre vet vilket som är sant och vilket som bara är kvar av gammal vana. I denna märkliga logik uppstår en form av digitalt minne som inte är byggt för att förstå förändring utan för att bevara stabilitet. Det gör systemen robusta, men också märkligt envisa. Ett system kan låtsas känna dig bättre än du själv gör, eftersom det baserar allt på historik du kanske inte längre identifierar dig med.

Gamla spår som styr nya beslut

När ett program sparar värden för att vara effektivt är det egentligen bara en form av förenkling: det försöker undvika att räkna ut allt från början varje gång. Samtidigt skapar dessa sparade spår ett slags vardaglig determinism. När du väl har klickat, sökt, köpt eller gått på ett visst sätt formar det programmets bild av dig långt efter att du ändrat kurs.

För utvecklare är detta en praktisk kompromiss. För användare är det oftast osynligt – tills något går fel. Ett onlinesystem fortsätter att föreslå en prenumeration du avslutade för månader sedan. Ett bokningsprogram erbjuder dig resor från en stad du inte längre bor i. Ett vårdsystem är helt övertygat om att du fortfarande har ett behov du inte haft på åratal. Allt detta bygger på små, envisa minnen som ingen rensat ut.

• Gamla värden lagras för snabbhet men blir ofta kvar för länge
• System antar att historik är mer pålitligt än nuvarande beteende
• Uppdateringar sker sällan heltäckande och gamla data läcker igenom

När minnena blir till interna sanningar

Det mest intressanta är hur systemen själva börjar uppfatta sina gamla värden som absoluta sanningar. När ett system väl har byggt sin interna logik kring viss data blir uppdateringar både riskabla och dyra. Därför lämnas mycket orört. Det som från början var en praktisk genväg blir till en intern lag, och den lagen fortsätter styra allt som händer därefter.

Problemet är att mjukvara saknar förmågan att känna igen kontext. Den kan se att du ändrat något, men inte alltid förstå hur ändringen påverkar helheten. Ett nytt telefonnummer registreras, men kopplas inte till alla delar av systemet. En adress uppdateras, men gamla kopior lever vidare i andra moduler. Ett beteende förändras, men modellen som styr rekommendationer är fortfarande kalibrerad efter den du var i fjol.

Det är här de envisa minnena skapar sina mest oväntade konsekvenser. De binder fast dig i systemets egen bild av dig, även när du försöker ta dig ur den. Det blir en sorts digital determinism, där historik får mer tyngd än nutid. Vi märker det bara när våra liv rör sig snabbare än programmens logik.

Den tysta friktionen mellan kod och verklighet

Det finns en särskild sorts gnissel som uppstår när mjukvara försöker beskriva världen men världen vägrar bete sig lika snyggt som koden förväntar sig. Denna friktion märks sällan i stora dramatiska krascher, utan i små vardagliga skevheter: en felaktig faktura som smiter igenom, ett formulär som inte accepterar en ovanlig stavning, ett schema som inte begriper att människor ibland gör undantag. Mjukvara är byggd för mönster, men verkligheten är full av undantag, och dessa undantag skapar ett slags ständigt motstånd i systemens logik. Det är tyst, men konstant.

När världen inte passar modellen

Varje program bygger på en modell av hur något förväntas fungera. I den modellen finns både strukturer och antaganden. Problemet är att modeller alltid är förenklingar, och verkligheten skyr förenklingar lika mycket som vatten skyr en trasig dammlucka. När verklighetens variationer väller in uppstår missljud. Ett namn med fler mellanslag än systemet räknat med. En adress som inte följer standard. Ett beteende som avviker från de statistiska förväntningarna.

Många system reagerar antingen genom att helt ignorera avvikelsen eller försöka pressa den in i en form som inte är gjord för den. De tillåter bara det som modellen kan hantera, och allt annat betraktas som fel. För användaren känns det som att ramla ned i en osynlig reva mellan sina faktiska omständigheter och den digitala version som systemet tycker är rimlig.

• När modeller inte uppdateras i takt med verkligheten uppstår systematiska fel
• Avvikande beteenden tolkas ofta som misstag istället för variation
• Små undantag kan få oproportionerligt stora effekter i automatiserade system

Den långsamma erosionen av förtroende

Faran med denna friktion är inte att systemen kraschar, utan att de långsamt förlorar vår tillit. När ett program gång på gång misstolkar vår situation börjar vi anpassa oss efter det, snarare än tvärtom. Vi skriver om våra namn för att passa formulären. Vi väljer alternativ som inte stämmer, bara för att komma vidare. Vi lever i den digitala versionen av oss själva eftersom den riktiga versionen inte ryms i systemets tänkta form.

Det är här friktionen blir som tydligast: inte i en teknisk mening, utan i en mänsklig. Programmen drar åt ett håll, världen åt ett annat, och vi tvingas fungera som översättare mellan dem. Ju mer digital vardagen blir, desto mer tid ägnar vi åt att passa in i modellernas ramar istället för att systemen anpassar sig till våra faktiska liv.

Denna spänning försvinner inte av sig själv. Den är inbyggd i all mjukvara som försöker fånga något levande och flyktigt i en logisk form. Men just i den spänningen finns också fröet till bättre design: när utvecklare ser friktionen kan de också börja forma system som lyssnar mer än de antar, system som kan ändra sig när världen gör det.