Av Ola Wong | 11 december 2023
I korthet
Yaser som går i tredje årskursen på naturvetenskapsprogrammet på S:t Botvids gymnasieskola i Botkyrka säger något som många tycker borde vara uppenbart: ”Det är ett problem om du inte kan prata ren svenska trots att du är uppvuxen här.” Han tror att förortssvenskan är på väg att förändra hur majoritetsbefolkningen pratar.
Men bland flera tunga språkauktoriteter är det han säger kontroversiellt, mer om dem senare.
<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-116615"      class = "kv-pod-holder kv-player-light  lplo " data-sid="" data-eid="" data-pid="116615" data-acurl="aHR0cHM6Ly9tZWRpYS5wb2Quc3BhY2Uva3ZhcnRhbC82LTQxLWhvdGV0LW1vdC1kZXQtc3ZlbnNrYS1zcHJha2V0Lm1wMw==" data-psurl="aHR0cHM6Ly9tZWRpYS5wb2Quc3BhY2Uva2p4ajYzeWRkZXEydmgvNi00MS1ob3RldC1tb3QtZGV0LXN2ZW5za2Etc3ByYWtldC5tcDM=">  <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%2Fhotet-mot-det-svenska-spraket%2F&amp;t=Hotet+mot+det+svenska+spr%C3%A5ket"    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=Hotet+mot+det+svenska+spr%C3%A5ket+-+https%3A%2F%2Fkvartal.se%2Fartiklar%2Fhotet-mot-det-svenska-spraket%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%2Fhotet-mot-det-svenska-spraket%2F"    target = "_blank"    class  = "li-link"    title  = "Dela på LinkedIn"><i class="ti-linkedin ui transparent"></i></a><a href    = "mailto:?subject=Hotet mot det svenska språket&body=https://kvartal.se/artiklar/hotet-mot-det-svenska-spraket/"   target  = "_blank"    class   = "pr-link"    title   = "E-posta"    onclick = ""><i class="ti-email ui transparent"></i></a><a href    = "https://kvartal.se/skriv-ut/116615/utskrift"    target  = "_blank"    class   = "pr-link"    title   = "Skriv ut"    onclick = ""><i class="ti-printer ui transparent"></i></a><a href   = "https://kvartal.se/skriv-ut/116615/pdf"    target = "_blank"    class  = "pr-link"    title  = "Ladda ner artikeln som PDF"><i class="fas fa-file-pdf 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/2022/03/DSC_1185-1-scaled-e1646149873242.jpg');"></div><img class="author-print-img" src="https://kvartal.se/wp-content/uploads/2022/03/DSC_1185-1-scaled-e1646149873242.jpg" style="display: none;">    </div>    <div class="by-disclaimer-holder" style="color: #8a3a67">Av <a href="https://kvartal.se/medverkande/ola-wong/">Ola&nbsp;Wong</a> | 11 december 2023<div class="author-desc">Ola Wong är Kvartals kulturredaktör, Kina-kännare och författare.
</div>    </div>  </div></div><div class="mobile-share clearfix" style="margin-top: -10px; margin-bottom: 20px;"><div class="share-icons"><span class="share-outer"><a href="https://www.facebook.com/sharer.php?u=https%3A%2F%2Fkvartal.se%2Fartiklar%2Fhotet-mot-det-svenska-spraket%2F&amp;t=Hotet+mot+det+svenska+spr%C3%A5ket"    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=Hotet+mot+det+svenska+spr%C3%A5ket+-+https%3A%2F%2Fkvartal.se%2Fartiklar%2Fhotet-mot-det-svenska-spraket%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%2Fhotet-mot-det-svenska-spraket%2F"    target = "_blank"    class  = "li-link"    title  = "Dela på LinkedIn"><i class="ti-linkedin ui transparent"></i></a><a href    = "mailto:?subject=Hotet mot det svenska språket&body=https://kvartal.se/artiklar/hotet-mot-det-svenska-spraket/"   target  = "_blank"    class   = "pr-link"    title   = "E-posta"    onclick = ""><i class="ti-email ui transparent"></i></a><a href    = "https://kvartal.se/skriv-ut/116615/utskrift"    target  = "_blank"    class   = "pr-link"    title   = "Skriv ut"    onclick = ""><i class="ti-printer ui transparent"></i></a><a href   = "https://kvartal.se/skriv-ut/116615/pdf"    target = "_blank"    class  = "pr-link"    title  = "Ladda ner artikeln som PDF"><i class="fas fa-file-pdf 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/hotet-mot-det-svenska-spraket/?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/116615"    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-116615">  <div class="in-short-inner">    <span class="close_button close-in-short in-short-toggle" data-articleid = "116615"></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 "><strong>Yaser</strong> som går i tredje årskursen på naturvetenskapsprogrammet på S:t Botvids gymnasieskola i Botkyrka säger något som många tycker borde vara uppenbart: ”Det är ett problem om du inte kan prata ren svenska trots att du är uppvuxen här.” Han tror att förortssvenskan är på väg att förändra hur majoritetsbefolkningen pratar.</p>
<p>Men bland flera tunga språkauktoriteter är det han säger kontroversiellt, mer om dem senare.</p>
</div>
<div class="rest-of-article ">
<p>Både Yaser och klasskamraten <strong>Firel</strong> som jag möter är ambitiösa ungdomar och har siktet inställt på att bli läkare, men de bor i en förort som ofta avbildas i skuggor från blåljus. Botkyrka blev 2010 den första kommunen i Sverige där en majoritet av invånarna har utländsk bakgrund. Det är en bild av framtiden – ett språkutsatt område.</p>
<p>Numera har runt 40 procent av invånarna som är i åldrarna 6–19 år utländsk bakgrund och de allra flesta av dem är andragenerationare, det vill säga de är födda i landet med två utrikes födda föräldrar.<sup>1</sup></p>
<blockquote><p>Den traditionella svenska ”sjungande” språkmelodin är på väg ner även bland yngre som är inhemskt födda.</p></blockquote>
<p>Svenska språket är i delar av landet ett minoritetsspråk, och möjligheterna att lära sig svenska är begränsade eftersom det knappt finns personer med svenska som modersmål i området. Det har kommit larm om förskolor där över hälften av barnen som börjar skolan har samma nivå på sin svenska som nyanlända barn, trots att de är födda i Sverige.<sup>2</sup> I PISA-testet från 2023 har Sverige fått en kunskapskollaps i läsförståelse. En betydande del av eleverna saknar tillräckliga kunskaper i det svenska språket. De får starta sina yrkesliv i en orättvis uppförsbacke.</p>
<p>En av många chockerande aspekter av våldsvågen är språket i avlyssnade samtal och chattar: som här från en förundersökning av ett mordförsök i Uppsala:</p>
<p><em>”Säg lak driver du eller de va fint när du tog cashen köpte bil åt cashen när de kmr o göra rätt ifrån sig du babblar en massa va man stå bakom de du gjorde din lilla fitta va man lan.”</em></p>
<figure id="attachment_116630" aria-describedby="caption-attachment-116630" style="width: 1509px" class="wp-caption alignnone"><img fetchpriority="high" decoding="async" class="wp-image-116630 size-full" src="https://kvartal.se/wp-content/uploads/2023/12/Chatt-polisen.jpg" alt="" width="1509" height="972" data-wp-pid="116630" srcset="https://kvartal.se/wp-content/uploads/2023/12/Chatt-polisen.jpg 1509w, https://kvartal.se/wp-content/uploads/2023/12/Chatt-polisen-600x386.jpg 600w, https://kvartal.se/wp-content/uploads/2023/12/Chatt-polisen-300x193.jpg 300w, https://kvartal.se/wp-content/uploads/2023/12/Chatt-polisen-768x495.jpg 768w" sizes="(max-width: 1509px) 100vw, 1509px" /><figcaption id="caption-attachment-116630" class="wp-caption-text"><em>Källa: Polisen.</em></figcaption></figure>
<p>Resultatet blir att det har uppstått en kreolsvenska, ett fattigt språk med rak ordföljd och lånord från arabiska, somaliska och turkiska. I utsatta områden använder både lärare och föräldrar färre ord och mindre komplexa meningar.</p>
<p>Men ortensvenskan sprider sig även till majoritetssvenska barn och unga, mejlar <strong>Tobias Hübinette</strong>, docent samt lärare och forskare i interkulturella studier vid Karlstads universitet.</p>
<p>Det behövs mer forskning i frågan, men för en person som rör sig ute borde det vara uppenbart att den traditionella svenska ”sjungande” språkmelodin är på väg ner även<span style="color: #0000ff;"><strong> </strong></span>bland yngre som är inhemskt födda.</p>
<p>Ett framträdande drag i förortssvenskan är en särskild talrytm och språkmelodi. Uttalet beskrivs som staccatoartat, alltså ”stötigt”. Den är en konsekvens av att längdskillnaden mellan långa och korta stavelser reduceras. Språkmelodin kännetecknas av förlängda slutstavelser kombinerat med stigande tonhöjd. Sje-ljudet uttalas starkt på ett arabiskt sätt, till exempel i ord som <em>skön</em>.<sup>3</sup></p>
<p>Ett annat språkligt drag som kännetecknar förortssvenska är att använda så kallad rak ordföljd: <em>nu jag fattar </em>i stället för <em>nu fattar jag</em>.<strong> </strong></p>
<h2>Eller hur du gillar den här rubrik?</h2>
<p>Även för den som anstränger sig för att tala standardsvenska kan det vara svårt att medvetet få bort sådana språkliga fel.</p>
<p>Gymnasieläraren och skoldebattören <strong>Therese Rosengren</strong> som är aktuell med boken <em>De otillräkneliga</em> säger att hon inte arbetar aktivt med elevernas talspråk. Energin går åt till att kämpa med saker som att sätta stor bokstav och punkt och ta sig igenom innehållet som de ska lära sig.</p>
<p>Rosengren ser chattspråket som det största hotet mot svenskan. Det blir allt sämre ställt med grundläggande saker som att skriva ”jag” och inte ”ja”. På hennes innerstadsskola i Stockholm gäller de problemen för både<span style="color: #0000ff;"><strong> </strong></span>eleverna med invandrar- och svensk bakgrund.</p>
<p>Yaser, som är troende muslim, och Firel stör sig på alla svordomar i ortensvenskan. Det skulle vara omöjligt att prata så på arabiska, säger Firel.</p>
<p>Vad ska göras då? Både Yaser och Firel framhåller vikten av bra lärare som korrigerar språkfel som ”igår jag gick på bio”.</p>
<p>Firel berättar om en lärare som var jättesträng. ”Hon var verkligen noggrann med att vi skulle lära oss korrekt svenska. Samtidigt fick vi analysera raptexter, för vi skulle förstå det också. Alla lärare borde vara så.”</p>
<p>Men tar man tunnelbanan från Botkyrka i änden av röda linjen mot centrala huvudstaden och går upp på Söders höjder till Ersta konferens vackra 1800-talsbyggnad med strålande utsikt över Stockholms inlopp så kunde man torsdagen den 7 december höra ett annorlunda budskap. Där har språkauktoriteter samlats för Språkpolitikens dag, arrangerad<span style="color: #0000ff;"><strong> </strong></span>av Isof, myndigheten med ansvar för språkvård. Årets tema är flerspråkighet och ingen här nämner betydelsen av stränga lärare som rättar dålig svenska. Flera har i stället ett budskap om att förändra Sverige så att majoritetssvenskarna blir mer toleranta för bristande eller ingen svenska.</p>
<div class="page" title="Page 1">
<div class="section">
<div class="layoutArea">
<div class="column">
<h2>Flerspråkighet var ordet på Språkpolitikens dag</h2>
</div>
</div>
</div>
</div>
<p>En skillnad blir uppenbar jämfört med eleverna i Botkyrka. Språkvetareliten är kritvit. Ingen ifrågasätter deras akademiska meriter, men känslan blir ändå lite märklig – som om 98 män och två kvinnor hade samlats för att diskutera jämställdhetspolitik.</p>
<p>Inleder gör Språkrådets dynamiska nya avdelningschef <strong>Lena Lind Palicki </strong>som konstaterar att det pratas kanske 200 språk i Sverige idag, ändå råder en enspråkighetsnorm. Språklagen talar om skyldighet att ge tillgång till språk, även andra sådana än svenskan och de officiella minoritetsspråken som nämns vid namn i språklagen.</p>
<blockquote><p>Majoritetsbefolkningen behöver genomgå ett jättejobb.</p></blockquote>
<p><strong>Ellen Bijvoet</strong>, forskare på Isof, inleder programpunkten om hur man skapar en bra flerspråkighetspolitik. Hon säger att det behövs ett jättejobb med majoritetsbefolkningens attityder. Det finns ett enspråkigt tänk i Sverige. ”Den självbilden behöver punkteras.”</p>
<p>Men vad gör man då när det moderna informationssamhället förutsätter ett gemensamt och standardiserat språk? I rapporten <em>God svenska – vägen till arbete för utrikes födda </em>från tankesmedjan SNS pekar 87 procent av 800 intervjuade rekryterare ut bristande kunskaper i det svenska språket som ett problem för att anställa personer födda utanför Norden.<sup>4</sup></p>
<p>Ellen Bijvoet menar att en väg framåt är att medvetandehöja rekryterare om fördomar mot folk med brytning.</p>
<p>Kanske kan flerspråkighetspolitik göra så att Sverige åter kan bli ett föregångsland i världen, hoppas en annan panelist.</p>
<p>Språk borde bli en ny diskrimineringsgrund, säger en tredje.</p>
<p>Språkvetarna har traditionellt sett sin roll som deskriptiv, att forska om hur språket förändras. ”Om man har anlagt något normativt perspektiv så har det varit att samhället måste bli mer accepterande”, säger professor <strong>Fanny Forsberg Lundell </strong>som medverkade på Språkpolitikens dag och debatterade om språkkrav.</p>
<p>Ellen Bijvoet och språkforskaren <strong>Karin Senter</strong> skriver i en artikel om attityder till förortssvenska att ”En slags språklig främlingsrädsla växte fram under 1980-talet: Det uttrycktes en oro för att förortssvenskan kunde ta sig in i ’etniska svenska hem’ och hota ’den riktiga svenskan’”.<sup>5</sup></p>
<p>Det är alltså svenskarnas oro som är problemet. De som tycker att staccatosvenskan är ful eller ogillar förändringen ska problematiseras som smygrasister. Majoritetsbefolkningen behöver genomgå ett jättejobb, som Bijvoet säger. Själva förändringen har man antingen bagatelliserat eller välkomnat. Det kan också vara en möjlig förklaring till att det finns så lite forskning om hur majoritetssvenskan påverkas av invandringen.<sup>6</sup></p>
<p>Den senaste trenden är i stället att prata om superdiversitet. Det handlar om ställen som Malmö, där två tredjedelar av dem mellan 5 och 19 år har migrationsbakgrund. En stor del av eleverna har så dålig svenska att de enbart kan få betyget E, rapporterar Sydsvenskan. Lösningen, som docenten i socialt arbete <strong>Erica Righards</strong> förespråkar, är att tillåta andra språk i undervisningen, metoden kallas transspråkande.<sup>7</sup></p>
<p>Det skriver hon i en ny rapport till Tillväxtkommissionen som ska användas som underlag i kommunstyrelsens utvecklingsarbete för Sveriges tredje största stad.</p>
<p>Men kanske börjar den attityden nå vägs ände, åtminstone i de största riksdagspartierna. Sedan 2009 har Sverige en språklag som säger att samhällets gemensamma språk är svenska och att<span style="color: #0000ff;"><strong> </strong></span>alla ska ha tillgång till det, men den har ”inte alls upprätthållits”, säger<strong> Lawen Redar</strong> som har skrivit Socialdemokraternas nya arbetsrapport <em>Ökad samhällsgemenskap genom att vi delar ett gemensamt språk</em>. ”Vi har inte ens skyddat det svenska språket i skolan eller välfärden.” Hon passar även på att ge en känga till Engelska skolan. ”Borde inte svenskan genomsyra den svenska skolan?” Det finns forskning som visar att svenska elever som går i skolan på engelska blir sämre på mer avancerad svenska.<sup>8</sup></p>
<p>Frågan är också hur verklighetsförankrat det är att uppmana lärare till att utnyttja elevernas modersmål som resurs i klassrummet. Hur gör man det när det finns 25 olika modersmål i klassen? Många av eleverna är inte bra på föräldrarnas språk heller.</p>
<p>Tidigare har man ofta sagt att de som pratar ortensvenska har två språk, slang och formell svenska, som de kan växla mellan. Därför bör slangen inte betraktas som ett problem. Så var det kanske tidigare, när lärarna var infödda svenskar och segregationen inte var så stark. Men i takt med att infödda svenska lärare pensionerar sig och barnen i övrigt utsätts för så lite standardsvenska kan det bli svårare för vissa att växla. Då faller det argumentet, menar Fanny Forsberg Lundell.</p>
<h2>Det avreglerade språket</h2>
<p>Själv har jag länge stört mig på att det finns ett hyckleri när samhället sänder budskapet att alla sätt att prata är lika bra. Resultatet blir en outtalad diskriminering – där de som fattar galoppen pratar ”fint” i mötet med samhället (som Firal uttrycker det) medan de som inte kan läsa mellan raderna förlorar.</p>
<p>Det känns ärligare och rättvisare om samhället tydligt visar vad som är korrekt. Är det kanske läge att damma av rikssvenskan?</p>
<p>Den talade rikssvenskan växte fram kring sekelskiftet i början av 1900-talet i samband med demokratiseringen. En av skolans viktigaste uppgifter var att få barnen att tala ”ren svenska” utan påfallande drag från sin landsbygds- eller stadsdialekt. I samband med läsinlärningen fick man ljuda bokstäver och ord och syftet var att underlätta läsinlärningen genom att utgå från standardiserat språk.</p>
<p>”Jag som är född 1950 fick göra språkövningar, så att vi inte sa <em>reev</em> utan räv”, säger <strong>Olle Josephson</strong>, tidigare chef för Språkrådet.</p>
<p>Termen rikssvenska övergavs av språkvetarna på 60-talet och ersattes med standardsvenska.</p>
<p>Då skiftade språkpolitiken fokus till att kritisera riksspråket som förtryck. Det avreglerade språket tog över.</p>
<p>Olle Josephson tror inte på att återinföra rikssvenskan: ”Vinsten med det vore noll”, säger han.</p>
<p>I en av sina många språkspalter i SvD varnar Josephson för maktperspektiv och språkligt förtryck när vissa sätt att prata klassas som fula.<sup>9</sup></p>
<p>På telefon säger han att han tror att svenskan inte ändras mer än möjligen marginellt av invandrarsvenskan.</p>
<p>Yaser berättar om att en gång fick klassen se en gammal dokumentär med rapparen<strong> Dogge Doggelito</strong> som pratade om varför det var så bra med slang och orten. Men idag växer SD, säger han. ”Innan var det <em>shoo</em> och <em>jalla</em>, men nu vill man få bort det främmande.” Yaser ser det som rasism. Han och Firel är eniga om att de kommer att ha en brytning av förortssvenska oavsett hur mycket de än anstränger sig. ”Det ska inte vara något man ser ner på”, säger de.</p>
<p>Sverige har utan någon större diskussion satt språket i kris, och flera språkauktoriteter verkar mer intresserade av att teoretisera förfallet än att värna god svenska. Någon enkel räddning finns inte. Mer avreglering är knappast vägen framåt. Visst kan man vilja medvetandehöja rekryterare, men att försöka hindra dem från att välja bort sökande med svagt språk är som att förbjuda vatten från att rinna neråt.</p>
<p>I länder som Kina, Frankrike och Storbritannien finns tydliga riksspråk att förhålla sig till. Som det står på Wikipedia-sidan för <em>received pronunciation, </em>den brittiska engelskans standard: ”A <em>model accent</em> <em>is necessary for learners to aim at.</em>”</p>
<p>Samtidigt vill väl ingen idag att man ska förbjuda skånska på radion. Ett öppet samhälle censurerar inte kulturuttryck som hiphop. Men själv undrar jag om inte ett tydligt och starkare fokus på rikssvenska i skola och samhälle hade varit en krycka för en fallande svenska.</p>
<p>På lördag kommer <strong>Luay Mohageb </strong>med del två i Kvartal Kulturs artikelserie <em>Det hotade svenska språket</em>.</p>
<p style="text-align: center;">*</p>
<p>Vad tänker du om tillståndet för det svenska språket? Berätta gärna, jag läser alla mejl: ola.wong@kvartal.se</p>
<div class="notes-wrapper"><a class="shadow-button noselect show-notes"  data-articleid="116615">  <span class="button-inner-wrapper">    <span class="left-part">      <i class="ti-arrow-circle-down"></i>    </span>    <span class="right-part">      <span class="default-text">Se noter</span>      <span class="open-text">Visa mindre</span>    </span>  </span></a></p>
<div class="references">
<h3 id="noter" class="ref-heading" style="color: #000;;">Noter</h3>
<p>1, Mejl från Tobias Hübinette den 29 november. Räknar man in dem som är blandade/mixade – det vill säga som är inrikes födda med en inrikes och en utrikes född förälder – så har numera runt 40 procent av invånarna som är cirka 6–19 år gamla utländsk bakgrund och de allra flesta av dem är andragenerationare, det vill säga de är födda i landet med två utrikes födda föräldrar.</p>
<p>2, https://www.dn.se/sthlm/bristande-svenska-hos-personal-problem-i-forskolan/</p>
<p>3, https://www.isof.se/lar-dig-mer/kunskapsbanker/lar-dig-mer-om-svenska-spraket/forortssvenska</p>
<p style="font-weight: 400;">(se till exempel <a href="https://tobiashubinette.wordpress.com/2021/02/02/ny-sprakvetenskaplig-studie-om-ortensvenskan" data-saferedirecturl="https://www.google.com/url?q=https://tobiashubinette.wordpress.com/2021/02/02/ny-sprakvetenskaplig-studie-om-ortensvenskan&amp;source=gmail&amp;ust=1702117170539000&amp;usg=AOvVaw0NkkzOh-L1lW8aC7UEoY7M">https://tobiashubinette.wordpress.com/2021/02/02/ny-sprakvetenskaplig-studie-om-ortensvenskan</a>).</p>
<p style="font-weight: 400;">4, https://www.sns.se/artiklar/god-svenska-vagen-till-arbete-for-utrikes-fodda/ När rekryterarna fick se filmer ökade sannolikheten för sökande att gå vidare med 150 procent om den muntliga språkförmågan gick från den lägsta till den högsta nivån.</p>
<p>5, Bijvoet och Senter, 2021: <em>Förortsförankrat tal – ett inifrån- och ett utifrånperspektiv, </em>sid 177<em>.</em> https://www.diva-portal.org/smash/record.jsf?pid=diva2%3A1533907&amp;dswid=-9380</p>
<p>6, Jag har inför denna artikel kontaktat akademieledamoten och  professorn vid Institutionen för nordiska språk vid Stockholms universitet Tomas Riad, samt språkforskarna Henning Årman och Karin Senter. De har fått frågan vad forskningen säger om huruvida språket och språkmelodin förändras i riktning mot ”invandrarsvenska” bland infödda ungdomar. Riad skriver att han tror att en del intonationsdrag som ytterst har sitt ursprung i språkblandning och andraspråkstal har tagit sig in i visst ungdomstal, men att det är oklart hur generellt detta kan ha skett. Senter mejlar. ”När det gäller språket i övrigt, ex. grammatiska konstruktioner, uttal och språkmelodi, finns det, såvitt jag vet, ingen forskning på huruvida förortsförankrat tal påverkat majoritetssvenskan hos unga.” Hon hänvisar till Henning Årman.</p>
<p>Årman säger att frågan faller mellan stolarna och att det är inget han själv studerat.</p>
<p>Tobias Hübinette nämner en <a href="https://tobiashubinette.wordpress.com/2021/02/02/ny-sprakvetenskaplig-studie-om-ortensvenskan/">studie av Nathan Young</a> som är knuten till Centrum för tvåspråkighetsforskning vid Stockholms universitet. Hübinette skriver:</p>
<p>”Det är verkligen inte vanligt att svenska forskare operationaliserar ras och inte ens de som forskar om invandrare och minoriteter och det ska ’så klart’ därför till en engelsman att göra det och närmare bestämt en engelsk språkvetare &#8230;</p>
<p>Youngs studie har främst fokus på språkrytm och specifikt på det staccato-aktiga sätt att tala svenska på som just den s k ’Rinkebysvenskan’, ’ortensvenskan’, ’blattesvenskan’ eller kreolsvenskan ofta anses utmärkas av och som också hörs inom hiphop-musiken, och han finner då följande något förenklat: De vita arbetarna i Stor-Stockholm talar fortfarande en sociolekt som emanerar från det gamla s k Ekensnacket och som är minst påverkat av den s k ’Rinkebysvenskan’, ’ortensvenskan’, ’blattesvenskan’ eller kreolsvenskan medan de högutbildade höginkomsttagande stockholmarnas sätt att tala svenska på kan vara påverkat av den icke-vita och proletära s k ’Rinkebysvenskan’.”</p>
<p>7, https://www.sydsvenskan.se/2022-12-27/forskare-vill-se-fler-sprak-i-undervisningen-pa-malmos-skolor</p>
<p>8, https://www.svd.se/a/J197Om/mina-7-punkter-om-svenska-spraket-haller-du-med</p>
<p>9, https://www.svd.se/a/1Bgznq/sa-avgors-vad-som-ar-ratt-och-fel-i-svenskan</p>
</div>
</div>
<div class="author-byline">Ola Wong är Kvartals kulturredaktör, Kina-kännare och författare.
</div>
</div>
