Ta höjd för modeorden

<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-171992"      class = "kv-pod-holder kv-player-light  lplo " data-sid="" data-eid="" data-pid="171992" data-pty="SW5sw6RzdCBhcnRpa2VsIChLcsO2bmlrYSk=" data-pna="VGEgaMO2amQgZsO2ciBtb2Rlb3JkZW4=" data-acurl="aHR0cHM6Ly9tZWRpYS5wb2Quc3BhY2UvaW5sYXN0YXRleHRlci84LTUzLXRhLWhvamQtZm9yLW1vZGVvcmRlbi5tcDM=" data-psurl="aHR0cHM6Ly9tZWRpYS5wb2Quc3BhY2Uva2p4ajYzeWRkZXEydmgvOC01My10YS1ob2pkLWZvci1tb2Rlb3JkZW4ubXAz">  <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/lars-melin/">Lars&nbsp;Melin</a> | 30 mars 2025<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%2Fta-hojd-for-modeorden%2F&amp;t=Ta+h%C3%B6jd+f%C3%B6r+modeorden"    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=Ta+h%C3%B6jd+f%C3%B6r+modeorden+-+https%3A%2F%2Fkvartal.se%2Fartiklar%2Fta-hojd-for-modeorden%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%2Fta-hojd-for-modeorden%2F"    target = "_blank"    class  = "li-link"    title  = "Dela på LinkedIn"><i class="ti-linkedin ui transparent"></i></a><a href    = "mailto:?subject=Ta höjd för modeorden&body=https://kvartal.se/artiklar/ta-hojd-for-modeorden/"   target  = "_blank"    class   = "pr-link"    title   = "E-posta"    onclick = ""><i class="ti-email ui transparent"></i></a><a href    = "https://kvartal.se/skriv-ut/171992/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%2Fta-hojd-for-modeorden%2F&amp;t=Ta+h%C3%B6jd+f%C3%B6r+modeorden"    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=Ta+h%C3%B6jd+f%C3%B6r+modeorden+-+https%3A%2F%2Fkvartal.se%2Fartiklar%2Fta-hojd-for-modeorden%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%2Fta-hojd-for-modeorden%2F"    target = "_blank"    class  = "li-link"    title  = "Dela på LinkedIn"><i class="ti-linkedin ui transparent"></i></a><a href    = "mailto:?subject=Ta höjd för modeorden&body=https://kvartal.se/artiklar/ta-hojd-for-modeorden/"   target  = "_blank"    class   = "pr-link"    title   = "E-posta"    onclick = ""><i class="ti-email ui transparent"></i></a><a href    = "https://kvartal.se/skriv-ut/171992/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/ta-hojd-for-modeorden/?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 12 min</span></a><a href   = "https://kvartal.se/skarmlasarvanlig/a603804b-483e-480d-97f4-512817cdef91"    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-171992">  <div class="in-short-inner">    <span class="close_button close-in-short in-short-toggle" data-articleid = "171992"></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 ">I ordens värld finns det vanliga ord som <em>att</em> och <em>det</em> (som är oerhört vanliga) och det finns ovanliga ord som <em>tripod</em> och <em>dessouer</em> (som nästan inte finns alls). Men så finns också ord som känns vanliga, till exempel <em>fokusera</em>, <em>kränka</em> och<em> ta höjd för</em>. De känns inte bara vanliga utan också moderna. Eller också känns de slitna och klyschiga. I varje fall är de språkliga frekvensfenomen. Men är det samma fenomen?</p>
</div>
<div class="rest-of-article ">
<p>Om vi undersöker hur vanliga dessa ord är och har varit (i <a href="https://spraakbanken.gu.se/">Språkbanken</a> från Göteborgs universitet) märker vi att folk blev mer och mer <em>kränkta</em> en bit in på detta millennium. Ordet ökade med över 500 procent på några år, fick en topp 2015  och är nu på återtåg. Ett modeord? Tveksamt. Var det inte snarare ett modebeteende? Ordets framgång berodde på att det lönade sig så bra att vara kränkt.</p>
<p><em>Fokusera</em> fick en ännu snabbare karriär mot slutet av 1900-talet, från optisk term till allmänord; vi blev fokuserade, vi fokuserade på och vi deltog i fokusgrupper. Och på den vägen är det. Ordets användning har inte dalat det minsta. Ordet fyllde tydligen en betydelselucka, för ingen kommer ihåg vad vi var innan vi var fokuserade. Om det är ett modeord så är det ordens <strong>Carola Häggkvist</strong>.</p>
<figure id="attachment_172569" aria-describedby="caption-attachment-172569" style="width: 1024px" class="wp-caption alignnone"><img fetchpriority="high" decoding="async" class="wp-image-172569 size-full" src="https://kvartal.se/wp-content/uploads/2025/03/Fokusera.jpg" alt="" width="1024" height="546" data-wp-pid="172569" srcset="https://kvartal.se/wp-content/uploads/2025/03/Fokusera.jpg 1024w, https://kvartal.se/wp-content/uploads/2025/03/Fokusera-300x160.jpg 300w, https://kvartal.se/wp-content/uploads/2025/03/Fokusera-768x410.jpg 768w, https://kvartal.se/wp-content/uploads/2025/03/Fokusera-600x320.jpg 600w" sizes="(max-width: 1024px) 100vw, 1024px" /><figcaption id="caption-attachment-172569" class="wp-caption-text"><em>Illustration Kvartal</em></figcaption></figure>
<p><em>Ta höjd för</em> kommer från segelflygarnas värld, men har nu en allmännare betydelse – förbereda sig för, vidta försiktighetsåtgärder och liknande. Och ordet används i alla sammanhang. Den nya betydelsen är inte purung, för jag observerade den för mer än ett kvartssekel sedan i managementspråk. Men den minnesgode kommer ihåg att det tidigare hette vara <em>proaktiv</em> och ännu tidigare <em>ha framförhållning</em>. Begreppet &#8221;förbereda sig&#8221; är tidlöst, men orden vi använder växlar med modet.</p>
<p>Ett rent modeord, alltså.</p>
<h2>Semantikens bananflugor i fokus</h2>
<p>Just i detta sammanhang kan det vara lämpligt att påpeka att det också finns modemorfem. Ett sådant är &#8211;<em>relaterat</em>. Det markerar ofta avsmak för något man ogillar: drogrelaterade brott, hedersrelaterat våld, stressrelaterade sjukdomar, klassrelaterad ohälsa. Vi talar inte om kärleksrelaterade förlovningar.</p>
<p>Tidigare har morfemet -ism stått på topplistan, också det starkt negativt. Snällism  användes av förespråkare för hårdare tag, vi hade <em>biologism</em> som används om dem som anser att män och kvinnor inte är helt lika, och vi hade <em>ekonomism</em>, flitigt brukat av dem som anser att politiker inte ska behöva besväras av futtigheter som reformers kostnadssida.</p>
<blockquote><p>Det mest spektakulära är ordet &#8221;klockrent&#8221; som bildar en klockkurva ­– nästan.</p></blockquote>
<p>Det finns många anledningar att följa modeordens utveckling. För en språkvetare är de en sorts semantikens bananflugor. De har en snabb livscykel, och de säger mycket om efter vilka principer ord skiftar betydelse och användningsfält. Men de säger också en del om dem som använder orden och om hur dessa upplever sin omvärld. Andra har en moralistisk syn på orden. För dem är modeord tecken på språklig slapphet. Kräsna stilister låter inte trendskapare välja ord åt sig. Framför allt är det språkmedvetna journalister som anstränger sig att undvika klichéer som lagen är en <em>tickande bomb</em>; ambulanser for<em> i skytteltrafik</em>; x <em>rasar</em> <em>mot</em> y och så vidare.</p>
<p>Mode är definitionsmässigt knutet till tidscykler. Många kommer ihåg när polotröja var modernt förra gången, eller när man kunde börja visa sig med skäggstubb. Med ord har det varit precis samma sak. Sedan det blev möjligt att mäta ords frekvenser har jag gjort flera punktkontroller. Det mest spektakulära är ordet &#8221;klockrent&#8221; som bildar en klockkurva ­– nästan.</p>
<figure id="attachment_172085" aria-describedby="caption-attachment-172085" style="width: 568px" class="wp-caption alignnone"><img decoding="async" class="wp-image-172085 size-full" src="https://kvartal.se/wp-content/uploads/2025/03/MELIN-graf.png" alt="" width="568" height="321" data-wp-pid="172085" srcset="https://kvartal.se/wp-content/uploads/2025/03/MELIN-graf.png 568w, https://kvartal.se/wp-content/uploads/2025/03/MELIN-graf-300x170.png 300w" sizes="(max-width: 568px) 100vw, 568px" /><figcaption id="caption-attachment-172085" class="wp-caption-text">Klockren kurva. Källa: Språkbanken vid Göteborgs universitet.</figcaption></figure>
<p>Från knappt en förekomst på en miljoner löpord år 1995 ökade det till drygt 8 år 2000. Sedan har det gått ner men planat ut på cirka 6. Det är inte ett modeord längre, men det är ett <em>modeord emeritus</em>. Cykeln varade cirka fem år från uppgång till avplanande, vilket gäller för flera ord, till exempel <em>leverera</em> och <em>förhållningssätt</em>.</p>
<h2>Modeordens ekologi</h2>
<p>Man kan bara spekulera i vad som händer under dessa fem år. Detta är min bild: Det spelar egentligen ingen roll varifrån ordet kommer. Ett modeord kan komma från Norrlands inre (som <em>strul</em>), från USA (som <em>junk</em>), från knarkarkvartar (som <em>flum</em>). Det viktiga är att det i egenskap av modeord föds i de fina kretsarna och i de riktigt fina styrelserummen. Jag har inte varit där och lyssnat själv, men spridningsvägarna tyder på att orden kommer högt uppifrån.</p>
<p>Och det är också en språksociologisk grundlag att det bara är prestigebärares språkbruk som förs vidare i beundrande imitation. Vi får alltså förutsätta att modeordet blivit modeord först då påläggskalvars känsliga öron uppfattat ordet på Den Store Mannens läppar. Sedan brukar hierarkisk företagsstruktur, KKK-svängen (= kurser, konferenser, konsulter) och tv-intervjuer göra resten.</p>
<p>Att använda ordet tidigt visar alltså på både trendkänslighet och lojalitet. Det ger klara pluspoäng i det sociala spelet, men när alla använder det klingar prestigen självklart av och språkliga influerare tittar sig omkring för att hitta något nytt. Vi vet att klockrent inte var först. Det ersatte ord som <em>sitter som en smäck</em>, <em>fint som snus</em>, som <em>hand i handske</em> och mycket annat som tappat lyskraft.</p>
<figure id="attachment_172570" aria-describedby="caption-attachment-172570" style="width: 1024px" class="wp-caption alignnone"><img decoding="async" class="wp-image-172570 size-full" src="https://kvartal.se/wp-content/uploads/2025/03/Klockrent.jpg" alt="" width="1024" height="546" data-wp-pid="172570" srcset="https://kvartal.se/wp-content/uploads/2025/03/Klockrent.jpg 1024w, https://kvartal.se/wp-content/uploads/2025/03/Klockrent-300x160.jpg 300w, https://kvartal.se/wp-content/uploads/2025/03/Klockrent-768x410.jpg 768w, https://kvartal.se/wp-content/uploads/2025/03/Klockrent-600x320.jpg 600w" sizes="(max-width: 1024px) 100vw, 1024px" /><figcaption id="caption-attachment-172570" class="wp-caption-text"><em>Illustration Kvartal</em></figcaption></figure>
<p>Modeorden är viktiga för en rookie som vill visa att han eller hon är på banan och för den gråhårige som vill markera att man inte får räkna ut honom eller henne riktigt ännu. Men det är fråga om tajming. Att tala om klockrena lösningar ger inga pluspoäng alls när alla säger så, snarare tvärt om. Man brukar säga att man ska ha samma strategi som för värdepapper; köp i början av uppgången och sälj strax före nedgången.</p>
<p>Nå, hur ser 2025 års modeord ut? Kanske så här i en dyster betraktelse:</p>
<p><em>Jag vill lyfta en modeordsrelaterad fråga: måste vi inte fasa ut tanken på nya hållbara modeord? Inga nya ord är virala, och även om man tar höjd för att några ord går under radarn och rundat reglerna så saknar vi helt enkelt verktyg för att göra skillnad, ta modeorden till en ny nivå, få momentum och putsa på våra varumärken. Språket verkar vara en toxisk plattform i stället för en hubb för nytt tänk. Kanske vänta på att den här resan är i hamn och ta det därifrån. Nej, här går en röd linje. Vi kan inte marinera frågan längre. Här gäller det att göra om och göra rätt.</em></p>
<p>Ja, betraktelsen är dyster därför att nästan alla dessa modeord har några år på nacken och att de därför inte faller inom den femårscykel som gällde tidigare. Vad har hänt? Stiltje bland modeorden eller betydligt längre cykler? Tråkigare?</p>
<h2>Ingen exakt vetenskap</h2>
<p>För säkerhets skull: modeord är ingen exakt vetenskap. De förekommer oftare i tal än skrift och blir därmed svårsökta. Och för skrift finns alltid en eftersläpning i databaserna.  Ännu värre: inget språköra är perfekt. Tursamt finns en del floskelspanare på nätet. Men, det är ingen rocket science.</p>
<p>Kanske ser vi det klarare om vi blickar tillbaka till äldre skeden.</p>
<p>I slutet av 1960-talet samlade den legendariske latinprofessorn <strong>Gerhard Bentz</strong> på sig ett ansenligt antal modeord som han skrev samman till detta prosastycke som publicerades i tidskriften <em>Språkvård</em> 1992:</p>
<p><em>Modeord är främst en omfattande satsning på den etablerade sektorn av ord och uttryck som i dag är inne och på gång, speciellt på språkfronten. Modeordens dominerande målsättning och motivation är att i klartext på nolltid och gräsrotsnivå realistiskt och seriöst följa upp och ta över de samhällstillvända aktiviteterna och projekten hos en enormt frustrerad socialgrupp av hundraprocentigt progressiv struktur. Till modeordens socialpsykologiska relevans hör alla gånger också chansen till prioriterad jämlikhet på kommunikationsplanet. Meningsfulla innovationer kollas upp och utvärderas inom referensramen. Slutligen så är upplevd kontroversiell problematik av global profil definitivt också en grej som kommer in i bilden, va.</em></p>
<p>Och en bit in på 1970-talet hade <strong>Birgitta Lindgren</strong> och <strong>Margareta Westman</strong> från Svenska språknämnden, som idag motsvarar Språkrådet, samlat på sig följande, som publicerades i tidskriften Språkvård 1992:</p>
<p><em>&#8211; Kan du tala om hur du upplever din skolsituation i dagens läge?</em></p>
<p><em>&#8211; Jag upplever min skolsituation som jävligt frustrerande, jag känner mig ruskigt alienerad. Eleverna sitter ju i en jättetaskig sits just nu.</em></p>
<p><em>&#8211; Tycker du att det kunde vara relevant att öppna en dialog med eleverna, t.ex. om skolans implicita målsättningsproblematik?</em></p>
<p><em>&#8211; Det tycker jag verkligen är en relevant frågeställning. Det finns verkligen utrymme för konkreta frågor av det här slaget.</em></p>
<p><em>&#8211; Tendensutvecklingen i dagens skolsituation går mot allt mindre homogena elevsammansättningar. Miljön funkar bara inte. Allt har gått snett på något vis. Jag upplever det som om dialogen manipuleras bort. Vi håller på att skapa en pseudodialog. Och det rimmar ruskigt dåligt med den samhälleliga tendensutvecklingen, som ju går mot en allt mer pluralistisk miljö.</em></p>
<p><em>&#8211; Vi jobbar just nu med en alternativ läroplan och vi skall ta fram ett helt målsättningspaket typ dialogpedagogik.</em></p>
<p><em>&#8211; Ja, vi måste prioritera dialektiken i undervisningssituationen. Jag upplever det som om den öppna dialogen helt enkelt blivit överkörd av utvecklingstendensen. Man kommer ingen vart om man inte sätter in skola och elever i sitt sammanhang.</em></p>
<p>Man tar inte fel på att båda texterna präglas av beteendevetenskap (frustration, målsättning, motivation) och proggkultur (alternativ, samhällstillvänd, progressiv). Den som levde under denna tid brukar få en nostalgikick av ena eller andra slaget.</p>
<p>Tidigt 1980-tal låter det helt annorlunda. Den här gången är det jag själv som samlat orden:</p>
<p><em>1980-talets ordfreaks har inte samma trendiga språkboom att luta sig mot när dom ska ta fram de ord som verkli­gen gäller. Om det är modeord som står på agendan, så har de inte tillräckligt på fötterna för att komma till skott med själva ordbiten. Det finns knappast några indika­tioner på möjliga modeord. Däremot finns det ett hårt tryck på att i slutändan få språket att gå runt trots en allvarlig och ganska strulig turbulens på språksi­dan. Språkköret har framtiden bakom sig, eller?</em></p>
<p>Här finns ord som <em>boom</em> och <em>gå runt</em> som antyder en <em>managementsfär</em> och ord som <em>ha på fötterna</em>, <em>ta fram</em>, <em>komma till skott</em> och <em>tryck</em> som verkar allmänt administrativa. Anglifieringen blir tydligare med <em>freak</em>, <em>trend</em> och <em>boom</em>.</p>
<p>Beteendevetenskapen och proggkulturen är helt borta. Något nytt har börjat, ekonomiskan eller, lite elakare, <em>corporate bullshit</em>.</p>
<p>Man kan bara spekulera i vad som startade utvecklingen. Kanske var det allemansfonder, löntagarfondsdebatten och de stigande börskurserna under 1980-talet och det ökande intresse för ekonomi/management som allt detta förde med sig.</p>
<h2>Management och portföljhantering</h2>
<p>Under 1980-talet utplånades beteendevetenskapen, men det var inte ekonomisk vetenskap som tog dess plats utan snarare det praktiska hantverket: management och portföljhantering. Men här får man göra en distinktion mellan ord och sak. Det var alldeles säkert så att allt fler talade om placeringar och om de företag som skulle generera framtida vinster, men det viktiga ur ett lingvistiskt perspektiv är att de trendkänsliga talade ”managementska”, nästan oavsett vad de talade om. Barnbarn kunde kallas emissioner, och man skrattade åt chefens skämt i hopp om <em>return of investment</em>. Att kunna dela taxi var ett <em>win win case</em>.</p>
<p>Vad tog över efter ekonomiskan? Vilken ordgenerande samhällssektor skulle kränga på sig ledartröjan, visa sin spjutspetskompetens eller helt enkelt lägga sig i framkant?</p>
<p>En bit in på 2000-talet skrev jag denna text med delvis annan klang:</p>
<p><em>Det är mycket uppförsbacke för modeorden bara av det enkla skälet att de har en tung ryggsäck att bära på.  Vi har dock ett starkt varumärke att förvalta och modeorden har en stark närvaro i vårt samhälle, och det är alltid en bonus. Men man måste brinna för saken och vara riktigt hungrig i ett så skarpt läge som detta. Nu är förhållningssättet till modeord bara förnamnet. Om man vill vara med på tåget ska orden ha ikonstatus. Annars kan man lika gärna fula ut sig med nån retrogrej</em>.</p>
<figure id="attachment_172571" aria-describedby="caption-attachment-172571" style="width: 1024px" class="wp-caption alignnone"><img decoding="async" class="wp-image-172571 size-full" src="https://kvartal.se/wp-content/uploads/2025/03/Varumarke.jpg" alt="" width="1024" height="546" data-wp-pid="172571" srcset="https://kvartal.se/wp-content/uploads/2025/03/Varumarke.jpg 1024w, https://kvartal.se/wp-content/uploads/2025/03/Varumarke-300x160.jpg 300w, https://kvartal.se/wp-content/uploads/2025/03/Varumarke-768x410.jpg 768w, https://kvartal.se/wp-content/uploads/2025/03/Varumarke-600x320.jpg 600w" sizes="(max-width: 1024px) 100vw, 1024px" /><figcaption id="caption-attachment-172571" class="wp-caption-text"><em>Illustration Kvartal</em></figcaption></figure>
<p>Visst finns det spår av ekonomiskan: <em>bonus</em> och <em>varumärke</em>. Men flertalet verkar handla om personlig karriär och mänskliga relationer. Vad som skiljer denna text från dagens, den dystra betraktelsen, är att orden verkligen var nya, det vill säga hade gjort snabba karriärer helt nyligen.</p>
<h2>Vad händer nu?</h2>
<p>Det som präglar dagens ord är att omsättningen är lägre, att vi inte har en dominant prestigedomän som proggkulturen eller värdepappershandeln, och att det verkar som gamla modeord blir moderna på nytt. För visst känner vi vagt igen <em>fasa ut</em>, <em>ny nivå</em>, <em>resa</em> (i betydelsen utveckling) och <em>verktyg</em> (i betydelsen administrativ åtgärd)? De har varit med förr.</p>
<p>Kanske är modeord inte hela lösningen för den som idag vill sticka ut språkligt, visa sig modern och allmänt framåt. Allt tyder på att det är något mer än bara orden. Så troligen är dagens språkliga statussymboler en sorts grungemode, eller det som på lingvistslang kallas inverterad prestige.</p>
<blockquote><p>För den som gillar normer är detta goda nyheter.</p></blockquote>
<p>Den 11 december 2024 hittade jag en ingress på DN Kultur: en skribent som aktualiserade &#8221;ett kunskapstapp som skrämmer skiten ur mig&#8221;. Samma dag fanns på SvD:s förstasida en puff för att &#8221;Googles chip klår en superdator&#8221;.<br />
&#8221;Klå&#8221; och &#8221;skrämma skiten ur&#8221;. Vulgosvenska? Nej, det handlar om så kallad inverterad prestige vilket innebär att den som skriver på DN Kultur och på SvD:s förstasida står över misstankar om bristande språklig kompetens och därför kan kosta på sig friheten att skriva ner sig, precis som grungerockstjärnan tar på sig trasiga jeans därför att alla vet att han skulle kunna sy sina jeans på Savile Row. Skribenten signalerar att han eller hon inte behöver bry sig om futtigheter som stilanpassning.</p>
<h2>Dom föll platt</h2>
<p>Detta språkliga grungemode har mognat fram genom att gamla etablerade slangord under lång tid tagit sig in i finrummet och i många fall blivit lika vanliga som, eller vanligare än <em>defaultorden</em>. Det gäller ordpar som upprörd/förbannad, ordna/fixa, studera/plugga, stödja/stötta och avskeda/sparka. Dessa stilbrott ger ungefär samma effekt som att använda bedagade modeord, sådana som den trendkänslige tidigare inte ville ta i med tång.</p>
<p>Inverterad prestige innebär två saker: 1. Normen måste vara allmänt accepterad och 2. Det ska vara självklart att skribenten är väl medveten om att han aktivt och av egen vilja skriver ner sig.</p>
<p>Och normen ligger verkligen fast i dag. Bara ett exempel. Under 2023 gjordes tunga framstötar med banerförare som Språkrådets chef <strong>Lena Lind Palicki</strong> och <em>Språktidningens</em> chefredaktör <strong>Anders Svensson</strong> för att ersätta <em>de/dem</em> med <em>dom</em>, en fråga som legat och bubblat i decennier. Det, eller snarare dom, föll platt och har minskat med 20 procent enligt <a href="https://tidningar.kb.se/search?q=dom&amp;searchGranularity=part">Svenska tidningar</a>. Vi har alltså starka språkliga stilnormer, och de som vill sticka ut språkligt kan testa gränser med gamla slangord och med modeord som borde vila i frid. Grunge bygger på normmedvetenhet.</p>
<p>För den som gillar normer är detta goda nyheter.</p>
<div class="author-byline">Lars Melin är docent i svenska som mest arbetat med språkpsykologiska frågor, men också populärvetenskaplig författare med inriktning på modernt språkbruk.
</div>
</div>
