I korthet
I den förra artikeln visade vi att skolmyndigheternas nationella kompetensutvecklingssatsning ”Specialpedagogik för lärande” som pågått sedan 2017 och nått över 34 000 deltagare på skolor runt om i Sverige har en lös vetenskaplig underbyggnad. Universal design for learning (UDL) – det pedagogiska “ramverk” som man propagerar för – brister i vetenskaplighet, något som både anlitade forskare och skolmyndigheter haft full vetskap om.
<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-90141"      class = "kv-pod-holder kv-player-light  lplo " data-sid="" data-eid="" data-pid="90141" data-acurl="aHR0cHM6Ly9tZWRpYS5wb2Quc3BhY2Uva3ZhcnRhbC9pbmxhc3Rfc2tvbHZlcmtldF9icnl0ZXJfbW90X3Nrb2xsYWdlbi5tcDM=" data-psurl="aHR0cHM6Ly9tZWRpYS5wb2Quc3BhY2Uva2p4ajYzeWRkZXEydmgvc2tvbHZlcmtldC1icnl0ZXItbW90LXNrb2xsYWdlbi5tcDM=">  <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/martin-ingvar/">Martin&nbsp;Ingvar</a> och <a href="https://kvartal.se/medverkande/filippa-mannerheim/">Filippa&nbsp;Mannerheim</a> | 22 mars 2023<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%2Fskolverket-sprider-neuromyter%2F&amp;t=Skolverket+bryter+mot+skollagen"    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=Skolverket+bryter+mot+skollagen+-+https%3A%2F%2Fkvartal.se%2Fartiklar%2Fskolverket-sprider-neuromyter%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%2Fskolverket-sprider-neuromyter%2F"    target = "_blank"    class  = "li-link"    title  = "Dela på LinkedIn"><i class="ti-linkedin ui transparent"></i></a><a href    = "mailto:?subject=Skolverket bryter mot skollagen&body=https://kvartal.se/artiklar/skolverket-sprider-neuromyter/"   target  = "_blank"    class   = "pr-link"    title   = "E-posta"    onclick = ""><i class="ti-email ui transparent"></i></a><a href    = "https://kvartal.se/skriv-ut/90141/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/90141/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="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%2Fskolverket-sprider-neuromyter%2F&amp;t=Skolverket+bryter+mot+skollagen"    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=Skolverket+bryter+mot+skollagen+-+https%3A%2F%2Fkvartal.se%2Fartiklar%2Fskolverket-sprider-neuromyter%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%2Fskolverket-sprider-neuromyter%2F"    target = "_blank"    class  = "li-link"    title  = "Dela på LinkedIn"><i class="ti-linkedin ui transparent"></i></a><a href    = "mailto:?subject=Skolverket bryter mot skollagen&body=https://kvartal.se/artiklar/skolverket-sprider-neuromyter/"   target  = "_blank"    class   = "pr-link"    title   = "E-posta"    onclick = ""><i class="ti-email ui transparent"></i></a><a href    = "https://kvartal.se/skriv-ut/90141/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/90141/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/skolverket-sprider-neuromyter/?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 13 min</span></a><a href   = "https://kvartal.se/skarmlasarvanlig/90141"    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-90141">  <div class="in-short-inner">    <span class="close_button close-in-short in-short-toggle" data-articleid = "90141"></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 <a href="https://kvartal.se/artiklar/skolverket-sprider-undervisningsmyter/">den förra artikeln</a> visade vi att skolmyndigheternas nationella kompetensutvecklingssatsning ”Specialpedagogik för lärande” som pågått sedan 2017 och nått över 34 000 deltagare på skolor runt om i Sverige har en lös vetenskaplig underbyggnad. <em>Universal design for learning</em> (UDL) – det pedagogiska “ramverk” som man propagerar för – brister i <a href="https://kvartal.se/wp-content/uploads/2023/03/IMG_3787.mov">vetenskaplighet</a>, något som både anlitade forskare och skolmyndigheter haft full vetskap om.</p>
</div>
<div class="rest-of-article ">
<p>Och trots att det ursprungliga uppdraget handlade om en kompetensökning i skolan för att bättre möta barn med NPF-diagnoser, har skolmyndigheterna och de forskare de anlitat, låtit uppdraget svälla med ambitionen att förändra skolans hela undervisningsmodell. I den här delen ska vi gå djupare in på det. Och även beskriva UDL:s problematiska koppling till neuromyter.</p>
<p>– Jag som elev tycker att man kan visa sina kunskaper på olika sätt på den här skolan. Inom matte och NO har vi väldigt bra lärare som kan anpassa liksom hur man lär sig… Jag själv lär mig bäst… eller så här, till exempel prov då vill jag hellre göra muntligt än skriftligt och det tar dom hänsyn till.<sup>1</sup></p>
<p>Citatet kommer från en intervjuad elev i en av utbildningsfilmerna i kompetensutvecklingen.</p>
<p>Idén om att vi människor lär oss saker på olika sätt och därför är i behov av en öppen ”undervisningsdesign” med olika valmöjligheter efter vad som ”passar just mig” dyker upp i olika sammanhang – i olika skepnader. Man pratar om människors olika ”lärstilar”, ”lärandeprofiler”, ”olika sätt att lära”, att ”lärandet är unikt” och att vi därför har olika behov.</p>
<p>Lärstilsbegreppet introducerades av professor <strong>Howard Gardner</strong> som först utvidgade begreppet ”intelligens” till sju domäner utan skarp avgränsning.<sup>2 3</sup> Gardner framförde kritik av det traditionella intelligensbegreppet som sades inriktas på västliga kulturers fokus på matematiska/logiska förmågor, inriktning på kunskapsmål som går att testa och att också utmana dem som det går bra för.<sup>4</sup> Istället utvidgade han intelligensbegreppet till andra domäner.</p>
<h2>Ingen lyckas replikera studierna</h2>
<p>Men när andra försökte replikera hans fynd, lyckades ingen verifiera hans påståenden om multipla intelligenser, alltså själva idén om olika lärstilar. På kritiken svarade Gardner helt uppseendeväckande att hela idén med multipla intelligenser inte är utformad för att låta sig utvärderas.<sup>5</sup> Således behöver dessa idéer värderas efter vilka resultat man når när de tillämpas. Då blir det problem.</p>
<blockquote><p>Att lärstilar är en neuromyt är idag väl belagt inom den akademiska världen.</p></blockquote>
<p>Det saknas med andra ord vetenskapligt stöd för att vissa lär sig mer effektivt genom att se (visuell lärstil), andra genom att höra (auditiv lärstil) och en del genom att känna och röra (kinestetisk lärstil). Idén om att vi människor har olika lärstilar är en så kallad neuromyt. Den är attraktiv, välspridd och synnerligen svårdödad. Men det saknas evidens för den. Visserligen kan vi människor ha olika <em>preferenser</em> för hur vi föredrar att lära oss saker men hjärnans grundkonstruktion och funktion är densamma för alla.</p>
<p>”Children are more alike than different in terms of how they think and learn” hävdar <strong>Daniel. T. Willingham</strong><sup>6</sup>, professor i psykologi och en av världens främsta forskare med inriktning på lärande och minne. Han är en av många som i böcker, texter och intervjuer om och om igen redogjort för varför lärstilar saknar evidens.<sup>7</sup> Trots våra olika tycken, egenskaper, personligheter, styrkor och svagheter är vi alltså mer lika varandra i hur vi bäst lär oss saker än vi själva tror. Dessutom skulle det knappast finns någon logik i att man som lärare bara skulle välja att utveckla en elevs starka sidor, eftersom en av skolans viktigaste uppgifter är att träna eleverna mångsidigt.</p>
<p>Det gör att den differentieringsmodell i helklass som presenteras via UDL och den specialpedagogiska kompetensutvecklingen är tveksam och i värsta fall kan leda till att elever “låses fast” i sina vanor. Om en elev föredrar att “lyssna eller se in kunskaperna”, snarare än att läsa sig till dem (för att läsningen upplevs svår), ligger det ju nära till hands för läraren att tänka att eleven har ett “behov” av detta, när det i själva verket försämrar lärandet för eleven.</p>
<h2>Myten om olika lärstilar</h2>
<p>Att lärstilar är en neuromyt är idag väl belagt inom den akademiska världen. Men det är inte för inte som den kallas för ”The biggest myth in education”.<sup>8</sup> För trots att Skolverket skyndsamt plockade ned den kritiserade moduldelen, där de på flera ställen propagerade för myten om lärstilar, återfinner vi den ändå på gång på gång i deras material till skolorna.</p>
<p><em>Universal design for learning</em> har nämligen en nära koppling till – för att inte säga – <em>bygger</em> sin idé om “differentiering” på – myten om att vi människor lär oss saker på helt unika sätt. Skolmyndigheternas lösning på detta blir att avpublicera delar av materialet när de blir påkomna och “rensa” det från avslöjande formuleringar om lärstilar. Man “putsar till” språket, man plockar bort delar i moduler, man ersätter och skriver om forskningsartiklar.</p>
<p>Ändå finns mycket kvar i materialet till skolorna på “Lärportalen”.</p>
<p>Vi listar här en rad exempel där myten om lärstilar förs fram i skolmyndigheternas kompetensutveckling. Det finns fler exempel än de vi tar upp här. (Kursiveringarna är våra):</p>
<ul>
<li>I filmen ”Introduktion till UDL – Universal Design for Learning” säger <strong>Jennifer Levine</strong>, en av grundarna av UDL: ”All human beings are different in multiple ways and all human beings <em>learn in different ways</em>.”<sup>9</sup></li>
<li>I modulen Inkludering och skolans praktik kan vi läsa att: “Lärande sker på olika sätt för olika elever och därför bör de erbjudas en variation av sätt att lära och visa sin kunskap på.”/…/ “Syftet med den här delen är att ge ökade kunskaper i att utveckla och variera undervisningen utifrån att <em>elever lär sig på olika sätt</em>/…/”<sup>10</sup></li>
<li>I ”Tillgängligt lärande med digitala verktyg” står det i en forskningsartikel att ”/…/eleverna behöver erbjudas en varierande undervisning som bygger på att <em>eleverna lär på olika sätt</em>/…/”<sup>11</sup> och vidare: ”Det innebär att när nytt stoff eller ny information skall introduceras för en grupp, behöver presentationen bygga på elevernas olika sätt att lära och att ta till sig information.”<sup>12</sup></li>
<li>I en av utbildningsfilmerna säger speakerrösten att ”<em>Alla elever är unika och lär på olika sätt</em>/…/<sup>13</sup></li>
<li>I artikeln ”Tillgänglig undervisning för alla elever” får vi möta samma formulering som i den del som skolmyndigheterna plockade ner efter att den ifrågasatts: ”<em>Samtidigt är lärandet unikt och hur vi lär är lika unikt som våra fingeravtryck</em> vilket är något vi behöver vara medvetna om och förhålla oss till för möjligheten att skapa en tillgänglig undervisning för alla elever.”<sup>14</sup></li>
<li>I samma artikel hävdar man att lärstilsmyten är sann: ”Om det faktiskt inte finns en majoritet av elever som lär på ett likadant sätt och om varje klassrum istället innehåller en mångfald av elever som tar in och bearbetar information <em>på olika sätt</em>, hur kan vi då differentiera undervisningen för att möjliggöra och tillgängliggöra lärandet för alla elever?”<sup>15</sup></li>
</ul>
<figure id="attachment_90557" aria-describedby="caption-attachment-90557" style="width: 916px" class="wp-caption alignnone"><img fetchpriority="high" decoding="async" class="wp-image-90557 size-full" src="https://kvartal.se/wp-content/uploads/2023/03/Skarmdump-pa-bild-ur-Specialpedagogik-for-larande.png" alt="" width="916" height="580" data-wp-pid="90557" srcset="https://kvartal.se/wp-content/uploads/2023/03/Skarmdump-pa-bild-ur-Specialpedagogik-for-larande.png 916w, https://kvartal.se/wp-content/uploads/2023/03/Skarmdump-pa-bild-ur-Specialpedagogik-for-larande-600x380.png 600w, https://kvartal.se/wp-content/uploads/2023/03/Skarmdump-pa-bild-ur-Specialpedagogik-for-larande-300x190.png 300w, https://kvartal.se/wp-content/uploads/2023/03/Skarmdump-pa-bild-ur-Specialpedagogik-for-larande-768x486.png 768w" sizes="(max-width: 916px) 100vw, 916px" /><figcaption id="caption-attachment-90557" class="wp-caption-text">En slarvigt korrekturläst sida där neuromyten ”lärstilar” förespråkas i skolmyndigheternas storsatsning ”Specialpedagogik för lärande”.<sup>16</sup></figcaption></figure>
<ul>
<li>I forskningsartikeln “Att anpassa undervisningen efter eleverna” kan vi läsa att: “En grundläggande idé med Universal Design for Learning (UDL) är att <em>alla elever lär sig på olika sätt</em> och att variation i lärandet ska vara utgångspunkten.”<sup>17</sup></li>
<li>I en reviderad modul finns en idag borttagen forskningsartikel där elevers “<em>olika lärandeprofiler</em>” nämns och man hänvisar till en lektionsplanering som ska ”anpassas till alla elever, oavsett deras <em>individuella sätt att lära</em>”. ”På så sätt kan eleven handledas i en form som passar henne/honom bäst med hänsynstagande till individens <em>olika sätt att lära sig</em>, arbetsrytm, intresse och färdighet.”<sup>18</sup></li>
<li>I UDL:s egen guide med riktlinjer som översatts från engelska till svenska (Högskolan Kristianstad, 2020) lyfts elevers olika ”lärstilar” fram utifrån elevers audio-, visuella-, audiovisuella- eller kinestetiska inlärningskanaler:</li>
</ul>
<p>”Vissa elever lär sig bäst genom att lyssna medan andra behöver läsa för att förstå. Ytterligare några behöver både lyssna och läsa medan andra behöver göra saker i praktiken för att information ska kunna omvandlas till kunskap. Med andra ord är lärandet unikt. Det handlar dock inte bara om hur eleven tar in information via till exempel audio-, visuell-, audiovisuell- eller kinestetiska inlärningskanaler, utan också om förmågan att generalisera och överföra kunskap från en situation till en annan. Möjligheten till detta ökar när undervisningen differentieras eftersom differentierad undervisning erbjuder elever olika vägar till lärande.”<sup>19</sup></p>
<h2>Återkommer i olika skepnader</h2>
<p>Professor <strong>Anita Norlund</strong> och docent <strong>Magnus Levinsson</strong> vittnar om att de vid ett flertal tillfällen genom åren påtalat för skolmyndigheterna att idén om lärstilar är en neuromyt och att denna idé därför inte bör legitimeras av en myndighet – men utan resultat. Begreppet korrigeras för stunden men återkommer sedan i olika skepnader, med ändrade formuleringar på skolmyndigheternas webbplatser och i material riktat mot skolor.</p>
<p>”Problemet löses inte med nya begrepp. ’Olika sätt att lära’ är lika problematiskt. Vi påtalade även det 2019 (om jag minns rätt) och har gjort det i fler sammanhang senare, men det verkar vara en idé som man vill hålla fast vid”, konstaterar docent Magnus Levinsson.<sup>20</sup></p>
<p>Enligt skollagen ska undervisningen vila på vetenskaplig grund och beprövad erfarenhet. ”Specialpedagogik för lärande” vilar inte på en sådan grund, och har hittills spritt neuromyten om lärstilar till 34 000 deltagare ute på skolor och förskolor. Man propagerar för en “differentierad” undervisning i helklass, där elever ska få vara med och bestämma vad och hur de ska lära sig, med vilka verktyg och metoder och hur de ska visa upp sitt kunnande, trots att det saknas forskningsstöd för en sådan undervisningsmodell.</p>
<p>Förutom det svaga forskningsstödet finns det pedagogiska frågetecken kring praktiken av UDL. Hur ska läraren göra bedömningen av vilken elev som behöver vad i ett klassrum på 25–30 elever? Skolmyndigheternas svar på frågan är att det är eleven själv som vet hur hon lär och därför ska få valmöjligheter. Skolmyndigheterna rekommenderar alltså lärare att lämna över detta viktiga pedagogiska avgörande – åt barnet självt.</p>
<p>I skolmyndigheternas satsning har specialpedagogik förvandlats till vackra värderingar om ”individens rätt att uppleva sig inkluderad och delaktig”, ”delta och lära sig på sina egna villkor”, få ”inflytande över sitt eget lärande”, ”känna välbefinnande, engagemang och motivation”.</p>
<blockquote><p>Är Sveriges medborgare och folkvalda politiker medvetna om detta genomgripande men ovetenskapliga paradigmskifte skolmyndigheterna försöker driva igenom i svensk skola?</p></blockquote>
<p>Istället för konkreta specialpedagogiska metoder för lärande, lyfter man vikten av lärarens ”relationskompetens” och förmåga att ”skapa en tillgänglig lärmiljö för alla”, förmåga att ”se mångfalden elever och elevvariation som en tillgång” och ”utforma en undervisning som möter varje elev där den befinner sig”. Det är vackra värderingar som är svåra att ha någon invändning mot. Men de handfasta metoderna lyser med sin frånvaro.</p>
<p>I ett nyligt tillägg till regleringsbrevet ville regeringen ha konkret stödmaterial för hur skolans arbete ska konkretiseras inom området. När uppdraget redovisades i februari 2023 var det ett hopkok av tidigare material och avsaknaden av konkretion var tydlig.<sup>21</sup> Barn med särskilda behov – just den grupp man säger sig vilja nå – löper stor risk att “differentieras bort” från möjligheten till progression i lärandet. Man stänger helt enkelt ute dem från en gedigen skolgång.</p>
<h2>Bryter mot skollagen</h2>
<p>Vår slutsats efter att ha granskat utbildningsmaterialet är att skolmyndigheterna gemensamt bryter mot två skrivningar i skollagen §4 och §5 som säger att skolan ska ha “en strävan/…/att uppväga skillnader i barnens och elevernas förutsättningar att tillgodogöra sig utbildningen” respektive “Utbildningen ska vila på vetenskaplig grund och beprövad erfarenhet”.</p>
<p>”Specialpedagogik för lärande” pågår just nu som en nationell kompetensutveckling. Den riktar sig till skolledare, elevhälsa och lärare i syfte att ge dem stöd i arbetet med skolans mest utsatta elevgrupper – de som av olika skäl behöver mer stöd i sitt lärande än ordinarie undervisning kan ge. Som utgångspunkt är det lovvärt.</p>
<p>Men som vi påvisat är det ramverk och de metoder man rekommenderar skolorna att använda, baserat på en teori vars praktik saknar effektstudier vad gäller elevers skolprestationer och effekterna vad gäller utjämningsuppdraget. Myndigheterna och de forskare de anlitat förespråkar en teori som inte har prövats på ett vetenskapligt sätt och som av internationellt erkända forskare beskrivs som abstrakt, med metoder som är svåra för en ensam lärare att operationalisera i ett klassrum med 20–30 elever.</p>
<p>UDL bygger dessutom ursprungligen på idén om “lärstilar” – en neuromyt som man från svenskt skolmyndighets- och forskarhåll låtit florera vilt i det material man skapat och spritt till skolorna, trots otaliga påpekanden från andra forskare. Och trots att det ursprungliga uppdraget var riktat mot en kompetensökning i skolan för att bättre möta barn med NPF-diagnoser, har man låtit uppdraget glida mot ambitionen att förändra skolans hela undervisningsmodell med “differentierad undervisning” som honnörsord.</p>
<p>Vår granskning avslutas nu med en öppen fråga: Är Sveriges medborgare och folkvalda politiker medvetna om detta genomgripande men ovetenskapliga paradigmskifte skolmyndigheterna försöker driva igenom i svensk skola?<a href="#_ftnref1" name="_ftn1"></a></p>
<div class="notes-wrapper"><a class="shadow-button noselect show-notes"  data-articleid="90141">  <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>
<ol>
<li>Modul: Tillgängligt lärande med digitala verktyg. Del 1: Tillgänglig undervisning för alla elever. Film: Tillgängligt lärande på Rålambshovsskolan (årskurs 4-9+gy) <a href="https://youtu.be/kWn_RNEqiVw">https://youtu.be/kWn_RNEqiVw</a></li>
<li>Frames of Mind, H. Gardner, 1983</li>
<li>Intelligence Reframed, H. Gardner, 1999</li>
<li>D Halbertsam, The best and the Brightest, 1972</li>
<li>H. Gardner, On failing to grasp the core of MI theory: A response to Visser et al, Intelligence, 34 (2006), pp. 503-505, https//:doi.org/10.1016/j.intell.2006.04.002</li>
<li>Willingham T, Why students don’t like school, s. 147.</li>
<li>Ask the Cognitive Scientist: Do Visual, Auditory, and Kinesthetic Learners Need Visual, Auditory, and Kinesthetic Instruction? <a href="https://www.aft.org/ae/summer2005/willingham">https://www.aft.org/ae/summer2005/willingham</a></li>
<li>Se t.ex. <a href="https://medschoolinsiders.com/study-strategies/learning-styles-myth/">https://medschoolinsiders.com/study-strategies/learning-styles-myth/</a></li>
<li>Introduktion till UDL – Universal Design for Learning <a href="https://larportalen.skolverket.se/%23/search/Universal%20Design%20for%20Learning"> </a><a href="https://youtu.be/MTX_faaKY18">https://youtu.be/MTX_faaKY18</a></li>
<li>Modul: Inkludering och skolans praktik. Del 4. Sinne och variation i undervisning och lärande. <a href="https://larportalen.skolverket.se/#/modul/4-specialpedagogik/Grundskola/130_Inkludering_och_skolans_praktik/del_04/">https://larportalen.skolverket.se/#/modul/4-specialpedagogik/Grundskola/130_Inkludering_och_skolans_praktik/del_04/</a></li>
<li>Modul: Tillgängligt lärande med digitala verktyg. Del 3: Artikel: Att erbjuda elever möjlighet att ta till sig kunskaper på olika sätt Av: Daniel Östlund, Högskolan Kristianstad (s. 1). <a href="https://utbildningar.skolverket.se/documents/16536071/0/Del+3+%E2%80%93+Artikel.pdf/4c34ca6d-7f3e-1917-9aa5-10c5cd5688a2?t=1624866794282">https://utbildningar.skolverket.se/documents/16536071/0/Del+3+%E2%80%93+Artikel.pdf/4c34ca6d-7f3e-1917-9aa5-10c5cd5688a2?t=1624866794282</a></li>
<li>Modul: Tillgängligt lärande med digitala verktyg. Del 3: Artikel: Att erbjuda elever möjlighet att ta till sig kunskaper på olika sätt Av: Daniel Östlund, Högskolan Kristianstad (s. 2) <a href="https://utbildningar.skolverket.se/documents/16536071/0/Del+3+%E2%80%93+Artikel.pdf/4c34ca6d-7f3e-1917-9aa5-10c5cd5688a2?t=1624866794282">https://utbildningar.skolverket.se/documents/16536071/0/Del+3+%E2%80%93+Artikel.pdf/4c34ca6d-7f3e-1917-9aa5-10c5cd5688a2?t=1624866794282</a></li>
<li>”Tillgängligt lärande med digitala verktyg”. <a href="https://youtu.be/4R1uzE-XHnE">https://youtu.be/4R1uzE-XHnE</a></li>
<li>Modul: Tillgängligt lärande med digitala verktyg. Del 1: Tillgänglig undervisning för alla elever <a href="https://utbildningar.skolverket.se/documents/16536071/0/Del+1+-+Artikel.pdf/7f7485ce-e908-9cb6-490a-0b6335efe15d?t=1624866795956">https://utbildningar.skolverket.se/documents/16536071/0/Del+1+-+Artikel.pdf/7f7485ce-e908-9cb6-490a-0b6335efe15d?t=1624866795956</a>  (s. 3)</li>
<li>Modul: Tillgängligt lärande med digitala verktyg Del 1: Tillgänglig undervisning för alla elever <a href="https://utbildningar.skolverket.se/documents/16536071/0/Del+1+-+Artikel.pdf/7f7485ce-e908-9cb6-490a-0b6335efe15d?t=1624866795956">https://utbildningar.skolverket.se/documents/16536071/0/Del+1+-+Artikel.pdf/7f7485ce-e908-9cb6-490a-0b6335efe15d?t=1624866795956</a>  (s. 3-4).</li>
<li>Modul: Tillgängligt lärande med digitala verktyg. Del 1: Tillgänglig undervisning för alla elever. <a href="https://utbildningar.skolverket.se/documents/16536071/0/Del+1+-+Artikel.pdf/7f7485ce-e908-9cb6-490a-0b6335efe15d?t=1624866795956">https://utbildningar.skolverket.se/documents/16536071/0/Del+1+-+Artikel.pdf/7f7485ce-e908-9cb6-490a-0b6335efe15d?t=1624866795956</a></li>
<li>Modul: Delaktighet i lärmiljön Del 4: Att anpassa undervisningen efter eleverna. (s. 2)<a href="https://larportalen.skolverket.se/LarportalenAPI/api-v2/document/path/larportalen/material/inriktningar/4-specialpedagogik/Grundskola/125_Delaktighet_i_larmiljon/del_04/Material/Flik/Del_04_MomentA/Artiklar/SP125_1-9_04_A_01_anpassa_undervisningen.docx">https://larportalen.skolverket.se/LarportalenAPI/api-v2/document/path/larportalen/material/inriktningar/4-specialpedagogik/Grundskola/125_Delaktighet_i_larmiljon/del_04/Material/Flik/Del_04_MomentA/Artiklar/SP125_1-9_04_A_01_anpassa_undervisningen.docx</a></li>
<li>Modul: Inkludering och delaktighet – uppmärksamhet, samspel och kommunikation Del 8: Förbereda och planera för inkludering <a href="https://larportalen.skolverket.se/LarportalenAPI/api-v2/document/name/P03WCPLAR099898">https://larportalen.skolverket.se/LarportalenAPI/api-v2/document/name/P03WCPLAR099898</a>  (s. 3, 5 och 6)</li>
<li>Universal Design for Learning – svensk översättning textversion. (Översättningen är utförd vid Högskolan Kristianstad 2020) <a href="https://udlguidelines.cast.org/binaries/content/assets/udlguidelines/udlg-v2-2/udl-text-version-swedish.pdf">https://udlguidelines.cast.org/binaries/content/assets/udlguidelines/udlg-v2-2/udl-text-version-swedish.pdf</a></li>
<li><a href="https://twitter.com/DrLevinsson/status/1593997610742087681?s=20&amp;t=bXflSRwXn_vlXFFCeDQhNg">https://twitter.com/DrLevinsson/status/1593997610742087681?s=20&amp;t=bXflSRwXn_vlXFFCeDQhNg</a></li>
<li>Redovisning av regeringsuppdrag att ta fram stödmaterial för utredning av en elevs behov av särskilt stöd, 2023 <a href="https://www.skolverket.se/getFile?file=11110">https://www.skolverket.se/getFile?file=11110</a></li>
</ol>
</div>
</div>
<div class="author-byline">Martin Ingvar är hjärnforskare och professor i integrativ medicin vid Karolinska Institutet.</p>
<p>Filippa Mannerheim är lärare och journalist.
</p></div>
</div>

Redan prenumerant? Logga in här
Just nu:
Testa gratis
i 3 månader
i 3 månader
Ingen bindningstid
- Alla artiklar
- Alla poddar
- Kvartals app
- Reklamfritt
Till erbjudandet
