I korthet
I december 2022 avpublicerade Skolverket och Specialpedagogiska skolmyndigheten (SPSM), plötsligt del tre i sin utbildningsmodul ”Strategier för undervisning och lärande.” Strax före avpubliceringen hade myndigheterna fått kritik på sociala medier för att ha förespråkat och spritt felaktigheter om inlärning och kognition (så kallade neuromyter).
<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-90131"      class = "kv-pod-holder kv-player-light  lplo " data-sid="" data-eid="" data-pid="90131" data-pty="SW5sw6RzdCBhcnRpa2VsIChTYW1ow6RsbGUp" data-pna="U2tvbHZlcmtldCBzcHJpZGVyIHVuZGVydmlzbmluZ3NteXRlcg==" data-acurl="aHR0cHM6Ly9tZWRpYS5wb2Quc3BhY2Uva3ZhcnRhbC9pbmxhc3Rfc2tvbHZlcmtldF9zcHJpZGVyX3VuZGVydmlzbmluZ3NteXRlci5tcDM=" data-psurl="aHR0cHM6Ly9tZWRpYS5wb2Quc3BhY2Uva2p4ajYzeWRkZXEydmgvc2tvbHZlcmtldC1zcHJpZGVyLXVuZGVydmlzbmluZ3NteXRlci5tcDM=">  <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> | 21 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-undervisningsmyter%2F&amp;t=Skolverket+sprider+undervisningsmyter"    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+sprider+undervisningsmyter+-+https%3A%2F%2Fkvartal.se%2Fartiklar%2Fskolverket-sprider-undervisningsmyter%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-undervisningsmyter%2F"    target = "_blank"    class  = "li-link"    title  = "Dela på LinkedIn"><i class="ti-linkedin ui transparent"></i></a><a href    = "mailto:?subject=Skolverket sprider undervisningsmyter&body=https://kvartal.se/artiklar/skolverket-sprider-undervisningsmyter/"   target  = "_blank"    class   = "pr-link"    title   = "E-posta"    onclick = ""><i class="ti-email ui transparent"></i></a><a href    = "https://kvartal.se/skriv-ut/90131/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%2Fskolverket-sprider-undervisningsmyter%2F&amp;t=Skolverket+sprider+undervisningsmyter"    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+sprider+undervisningsmyter+-+https%3A%2F%2Fkvartal.se%2Fartiklar%2Fskolverket-sprider-undervisningsmyter%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-undervisningsmyter%2F"    target = "_blank"    class  = "li-link"    title  = "Dela på LinkedIn"><i class="ti-linkedin ui transparent"></i></a><a href    = "mailto:?subject=Skolverket sprider undervisningsmyter&body=https://kvartal.se/artiklar/skolverket-sprider-undervisningsmyter/"   target  = "_blank"    class   = "pr-link"    title   = "E-posta"    onclick = ""><i class="ti-email ui transparent"></i></a><a href    = "https://kvartal.se/skriv-ut/90131/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/skolverket-sprider-undervisningsmyter/?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/90131"    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-90131">  <div class="in-short-inner">    <span class="close_button close-in-short in-short-toggle" data-articleid = "90131"></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 december 2022 avpublicerade Skolverket och Specialpedagogiska skolmyndigheten (SPSM), plötsligt del tre i sin utbildningsmodul ”Strategier för undervisning och lärande.” Strax före avpubliceringen hade myndigheterna fått kritik på sociala medier för att ha förespråkat och spritt felaktigheter om inlärning och kognition (så kallade neuromyter).</p>
</div>
<div class="rest-of-article ">
<p>Kritiken backades upp av pedagogikprofessor <strong>Anita Norlund</strong> och <strong>Magnus Levinsson</strong>, docent i pedagogiskt arbete. På Twitter skrev Anita Norlund: ”Myndigheten har ju flera gånger blivit uppmärksammad på att myten sprids av dess medarbetare.” Och vidare: ”En kollega kontaktade SPSM för drygt två år sedan och de ändrade då i sitt digitala material. Strax efter det hade vi ju ett samtal på scenen i Almedalen. Verkar trots det vara svårt att få bort myten.”</p>
<p>Skälet till att den kritiserade delen i undervisningsmodulen plötsligt plockades ner anges inte men på Skolverkets webbplats &#8221;Lärportalen&#8221; kan man läsa att myndigheterna har ”identifierat ett behov av att se över och revidera delar av den”.<sup>1</sup></p>
<p>Det var dock inget enstaka felskär som avpublicerades. De ovetenskapliga inslagen visar sig vid en närmare granskning inte alls bara vara några slarviga missar från skolmyndigheternas sida. Det är snarare toppen av ett isberg.</p>
<h2>Kunskaper om specialpedagogiska arbetssätt</h2>
<p>Det var på uppdrag av regeringen som skolmyndigheterna 2017 startade sin riksomfattande specialpedagogiska kompetensutvecklingssatsning: ”Specialpedagogik för lärande”. Satsningen riktar sig till förskolan, förskoleklassen, grundskolan, gymnasieskolan och vuxenutbildningen. Bakom den står Skolverket och SPSM.<sup>2</sup> Utbildningssatsningen ”syftar till att skolpersonal och lärare ska få insikter och kunskaper om specialpedagogiska arbetssätt, metoder och förhållningssätt i undervisningen” och ”fördjupad kunskap i att möta alla elevers olika behov”.</p>
<p>Materialet i utbildningen är öppet för alla och indelat i olika moduler med forskningsartiklar, filmer, ljudklipp och förslag på aktiviteter och diskussionsfrågor som deltagarna ska ta sig an genom ”kollegialt lärande” ute på skolorna. Utvalda pedagogikforskare från högskolor och universitet runt om i Sverige, tillsammans med Skolverket och SPSM, har tagit fram materialet i satsningen, som i dag har haft över 34 000 deltagare på skolor i Sverige.</p>
<p>Enligt uppdraget är det skolans elevgrupper med särskilda behov som undervisande lärare ska få specialpedagogisk kompetens att stötta. Det handlar om elever som av olika skäl har svårt att nå skolans kunskapsmål, elever i behov av specialpedagogiskt stöd, elever med neuropsykiatriska funktionsnedsättningar (NPF) som till exempel adhd eller autism.</p>
<p>Men redan 2018 fick skolmyndigheterna skarp kritik för att sprida ovetenskapliga teorier och ”driva en ideologiskt färgad agenda”. I ett upprört debattinlägg kritiserar ”Föräldranätverket Barn i Behov” skolmyndigheterna för bristande forskningsstöd och avsaknad av konkreta, specialpedagogiska metoder: ”NPF framställs indirekt som en relationsbrist och en idealiserad bild framträder av att verkligt kompetenta lärare bara genom sin relationsförmåga och sin lyhörda anpassning av undervisningen till varje elev, kan hjälpa alla elever att nå målen. Skolverkets bild saknar helt vetenskaplig grund. Vi bävar för de effekter Skolverkets kunskapsförnekande direktiv kommer att få ute på skolorna.”<sup>3</sup></p>
<p>Men kritiken viftades bort. ”Den specialpedagogiska satsningen bygger, tvärtemot vad debattörerna hävdar, på vetenskaplig grund”, skriver Skolverket i en svarsreplik utan att underbygga sitt resonemang.<sup>4</sup></p>
<p>Vi ska granska detta påstående närmare.</p>
<h2>Inspiration från inkluderande arkitektur</h2>
<p>Det pedagogiska ”ramverk” som man utgår ifrån i kompetensutvecklingen är <em>Universal design for learning</em> (UDL), utvecklat av den icke vinstdrivande organisationen Center for Applied Special Technology (CAST). UDL är inspirerad av universell design inom arkitekturen som handlar om att den fysiska miljön kan utformas inkluderande, så att individers funktionsvariationer inte blir ett hinder. Vad gäller arkitektur och fysisk miljö handlar det till exempel om att ge tillgång till hissar och ramper istället för trappor, erbjuda perronger med taktil information och liknande.</p>
<p>UDL förespråkar samma tankesätt inom undervisning och lärande; att skolor och lärare redan i förväg ska planera för och ”designa lärmiljöer” så att de blir tillgängliga för alla och på så sätt främjar alla barns och ungas lärande oavsett funktionsförmåga.<sup>5</sup> Enligt CAST har UDL stöd i forskning inom neurovetenskap, specialpedagogik och kognitiv psykologi. Man lyfter fram tre övergripande principer som man hävdar ska möta behoven hos alla elever, oavsett förmåga, funktionsnedsättning, ålder, kön eller kulturell eller språklig bakgrund. Läraren ska ”differentiera” undervisningsinnehåll och metoder i förväg för att “bidra till ett ökat engagemang och intresse” och ”tillgodose elevers varierande sätt att ta in och bearbeta information”.</p>
<blockquote><p>Författarna säger entydigt att det saknas vetenskapligt stöd för att individualisering har någon effektivitet i skolans arbete.</p></blockquote>
<p>Eleverna ska erbjudas olika alternativ i samband med redovisningar och examinationer<sup>6</sup>, göra självständiga val och få ”utöva inflytande i det egna lärandet”.<sup>7</sup> UDL förespråkar att individuella variationer ska vara normen i ett klassrum, inte undantaget. Att erbjuda en “differentierad lärmiljö” för att eleverna “är olika som lärande individer” är själva grundfilosofin i UDL.<sup>8</sup></p>
<h2>Individualisering och differentiering</h2>
<p>Medan <em>individualisering</em> handlar om att anpassa undervisningen efter en enskild elev, handlar <em>differentiering</em> istället om att erbjuda hela elevgruppen en mängd olika alternativ som planeras i förväg. Samtidigt är man noga med att betona lärandet som en gemensam process, men med varierade arbetssätt och uppgifter så att alla elever kan ”delta på egna villkor utifrån varierande förmågor och funktion.”<sup>9</sup></p>
<p>Man ska förstå differentieringen som ett led i skolans inkluderingsmodell: att läraren ska skapa lärmiljöer som är tillgängliga för alla, överallt och hela tiden ”utan att förmoda att en elevs ’lärandekarta’ (<em>map for learning</em>) är identisk med någon annans.”<sup>10</sup></p>
<p>Genom att använda ett annat begrepp, undkommer man smidigt all den forskning som visar att individualisering som metod inte gynnar lärandet. I en aktuell metastudie framkommer det att det saknas evidens för goda effekter av individualisering i undervisningen. Slutsatsen var entydig: de studier som fanns hade omfattande metodologiska problem som för små urval, avsaknad av adekvat kontrollgrupp och att man inte rapporterat data så att de gick att utvärdera. Utöver detta fanns det tydliga tecken på publikationsbias, det vill säga att man publicerar positiva resultat i väsentligt högre grad än negativa. Författarna säger entydigt att det saknas vetenskapligt stöd för att individualisering har någon effektivitet i skolans arbete.<sup>11</sup></p>
<p>Även om man inom UDL använder begreppet &#8221;differentiering&#8221; istället för &#8221;individualisering&#8221;, handlar båda metoderna om att innehåll, form och redovisningssätt ska anpassas efter eleverna och i det förstnämnda fallet – att individen själv ska få vara med och välja det som &#8221;passar denne bäst&#8221;. Här uppkommer ännu ett pedagogiskt dilemma.</p>
<p>Redan på 1980-talet fann man att högpresterande elever tenderar att välja alternativ som de redan är bra på, medan lågpresterande tenderar att undvika det som de behöver träna mer på för att komma ikapp.<sup>12</sup></p>
<p>Det räcker med att ta exemplet läsning för att inse att den elev som redan kämpar med läsningen kommer att välja bort detta moment om möjligheten ges. Eftersom vägen till läsning inte är lika lätt för dem som har en mager språkmiljö i hemmet blir effekterna av myndigheternas rekommendationer att de motverkar skolans lagfästa utjämningsuppdrag. Elevens valmöjlighet riskerar helt enkelt att bli ett undvikande av vad hon faktiskt behöver träna på. Därmed riskerar en sådan undervisning att snarare cementera och förstärka elevens bakgrund och klasstillhörighet – alltså motsatsen till skolans kompensatoriska uppdrag som finns angivet i skollagen.</p>
<h2>Repertoar av metoder</h2>
<p>I skolmyndigheternas utbildningsmaterial visar man upp exempel på hur lärare kan &#8221;differentiera&#8221; undervisningen genom att erbjuda en repertoar av metoder och redovisningssätt utifrån elevernas personliga preferenser.</p>
<p>I filmen &#8221;Varierade arbetssätt&#8221; ger en lärare instruktioner till sin klass:</p>
<p>– Antingen börjar man med att läsa i sin bok tillsammans i gruppen. Man kan också lyssna på boken på sin dator eller använda det digitala läromedlet som finns. När ni sedan gör själva redovisningen så kan ni använda presentationerna på era datorer eller så använder ni soundtrack. Ni kan göra en podd eller rapmusik eller nånting. Eller så kan ni göra det som en intervju. Det går också bra att spela upp det hela som en teater här framme. Eller om ni har något helt valfritt sätt. Det går jättebra att göra en ”Kahoot” eller en ”Mentimeter” eller så efteråt.</p>
<p>En av eleverna som intervjuas i utbildningsfilmen säger:</p>
<p>– Det är väldigt bra att vi får välja olika sätt att redovisa på för då kan man välja ett sätt som passar en själv bäst.</p>
<p>En annan elev säger:</p>
<p>– Jag tycker att det är skönt att man får välja det sätt man får arbeta på. Att inte lärarna bestämmer hur man ska arbeta. För alla kanske inte tycker om att arbeta på ett visst sätt och då finns det olika alternativ som man kan välja mellan.<sup>13</sup></p>
<p>UDL med sin &#8221;differentieringstanke&#8221; är alltså ett ramverk för planering, genomförande och utvärdering av undervisning som inte enbart berör elever i behov av särskilt stöd, utan omfattar alla elever.<sup>14</sup> Det specialpedagogiska uppdraget har således plötsligt vidgats till att gälla hela skolsituationen och alla elever i klassrummet, inte bara dem som behöver extra stöd på grund av funktionsvariation. Med en så omfattande satsning måste de rekommendationer som ges ha vetenskapligt stöd från teori till praktik inklusive effekterna av att införa dessa idéer.</p>
<p>Vi har undersökt hur forskningsläget för UDL ser ut.</p>
<h2>Inga studier av effekter på längre sikt</h2>
<p>I den vetenskapliga litteraturen hittar man flera studier gjorda på UDL. Effektstudierna är mycket få och inga studier finns av effekten på längre sikt. En viktig observation som gjorts i genomgången av litteraturen om UDL är att man måste läsa given information med kritiskt öga. Begrepp som kan låta fint (till exempel att metoden är elevorienterad) kan vid tillämpning ge oönskade negativa effekter på utfallet av undervisningen (sönderfallen pedagogisk grupprocess). I en korrelationsstudie visade det sig exempelvis att ju högre elever skattat ett elevorienterat arbetssätt, desto sämre var deras PISA-resultat i matematik.<sup>15</sup></p>
<p>Ett annat problem är att många av de granskade artiklarna har en mycket positiv beskrivning av UDL med slutsatser som stöder UDL – men utan att data presenteras som kan motivera det. Det problemet finns även inom andra områden när vetenskapliga data presenteras inom områden där vissa åsikter redan är starkt etablerade. Ett exempel från ett annat område är att när slutsatser från kliniska studier om cannabisolja som smärtbehandling beskrevs det i mycket positiva termer i media trots att egentliga effekter inte rapporterats i de vetenskapliga studierna.<sup>16</sup></p>
<blockquote><p>Flera forskare har uttryckt tveksamhet inför att rekommendera UDL eftersom evidensen är så svag.</p></blockquote>
<p>Det finns några större metastudier. I en av dessa som identifierade 18 studier där man studerat effektiviteten i UDL<sup>17</sup>, drogs den optimistiska slutsatsen att UDL är en effektiv utbildningsmetod för alla elever, samtidigt som man lakoniskt konstaterade att utbildningens resultat inte utvärderats i de studier man granskat. Studierna som inkluderats hade dessutom olika former för sin implementering av UDL, vilket gjorde det svårt med vidare jämförelser. Författarna till studien avslutar den med orden: ”Framtida forskning behövs för att ytterligare undersöka (UDL:s) inverkan på inlärningsprocessen, såväl som de primära och sekundära utbildningsresultaten som blir resultatet av dess genomförande.” Eller klarare uttryckt: Denna metastudie ger inga belägg för att en implementering av UDL främjar elevernas lärande och kunskapsutveckling på kort eller lång sikt.</p>
<p>Flera forskare har uttryckt tveksamhet inför att rekommendera UDL eftersom evidensen är så svag.<sup>18</sup> Slutsatsen som <strong>Michael P. A. Murphy</strong>, forskare vid Ottawa universitetet,<sup>19</sup> drar är rätt och slätt: ”Den enda evidensbaserade slutsatsen som kan dras om UDL är att ytterligare studier krävs, eftersom dess kärnpåståenden förblir obevisade. Institutioner på alla utbildningsnivåer bör visa stor försiktighet innan de ägnar betydande resurser åt implementering av UDL”.<sup>20</sup> Detta är en slutsats som även bekräftas av <strong>Guy Boysen</strong>, professor i psykologi.<sup>21</sup></p>
<h2>Omfamnat metoden trots svagt forskningsstöd</h2>
<p>I 20 år har man på olika sätt försökt bevisa UDL:s effektivitet utan att lyckas. Att så är fallet är skolmyndigheterna i Sverige också väl medvetna om. I Skolverkets egen forskningsöversikt ”Hälsa för lärande – lärande för hälsa” (2019) skriver man:</p>
<p>”UDL är ett relativt nytt område, särskilt i svensk kontext, och omfattningen är fortfarande begränsad vad gäller forskning om effekterna av UDL på barns och ungas lärande och skolprestationer samt på olika grupper av barn och unga, till exempel barn och unga med funktionsnedsättning.”<sup>22</sup></p>
<p>Det är i högsta grad uppseendeväckande att en statsfinansierad storsatsning inom skolväsendet inte grundas i vetenskapligt belagda och väl beprövade lärandemetoder. Trots vetskapen om det svaga forskningsstödet har alltså skolmyndigheterna i Sverige valt att omfamna UDL som en modell för ordinarie skolverksamhet med specialpedagogiskt perspektiv.</p>
<p><em>Universal design for learning</em> blir genom denna storsatsning ett redskap för en systemomvandling med starka ideologiska inslag, där svenska skolmyndigheter och de pedagogikforskare som anlitats blir drivande i en omfattande normförskjutning för skolans sätt att arbeta – för alla skolans elever.</p>
<p>I en uppföljande artikel kommer vi att skärskåda fler inslag i kompetensutvecklingen och återkoppla till den ifrågasatta och av myndigheterna hastigt avpublicerade moduldel, som vi nämnde inledningsvis. För det är inte bara så att kompetensutvecklingen i specialpedagogik har en lös vetenskaplig grund.</p>
<p>Skolmyndigheterna sprider även <a href="https://kvartal.se/artiklar/skolverket-sprider-neuromyter/">neuromyter</a>.</p>
<p><a href="#_ftnref1" name="_ftn1"></a></p>
<div class="notes-wrapper"><a class="shadow-button noselect show-notes"  data-articleid="90131">  <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>Strategier för undervisning och lärande. <a href="https://larportalen.skolverket.se/#/modul/4-specialpedagogik/Gymnasieskola/112-Strategier-for-undervisning-och-larande">https://larportalen.skolverket.se/#/modul/4-specialpedagogik/Gymnasieskola/112-Strategier-for-undervisning-och-larande</a></li>
<li><a href="https://www.skolverket.se/skolutveckling/kurser-och-utbildningar/specialpedagogik-for-larande-for-forskoleklass-grundskola-sameskola-och-sarskilda-ungdomshem">https://www.skolverket.se/skolutveckling/kurser-och-utbildningar/specialpedagogik-for-larande-for-forskoleklass-grundskola-sameskola-och-sarskilda-ungdomshem</a></li>
<li>”Skolverket blundar för det vi vet om NPF” <a href="https://www.svd.se/a/p6p6dE/skolverket-blundar-for-det-vi-vet-om-npf">https://www.svd.se/a/p6p6dE/skolverket-blundar-for-det-vi-vet-om-npf</a></li>
<li>Skolverket: Vi är öppna för dialog om kritiken <a href="https://www.svd.se/a/L01nmx/skolverket-vi-ar-oppna-for-dialog-om-kritiken">https://www.svd.se/a/L01nmx/skolverket-vi-ar-oppna-for-dialog-om-kritiken</a></li>
<li>Hälsa för lärande &#8211; lärande för hälsa. (Skolverket, 2019)  <a href="https://www.skolverket.se/getFile?file=4071">https://www.skolverket.se/getFile?file=4071</a> (s. 111-112)</li>
<li>Modul: Främja motivation, lärande och välbefinnande. Del 2: Möta variation i förmågor. Artikel: Pedagogiska konsekvenser och strategier vid en variation i förmågor <a href="https://larportalen.skolverket.se/LarportalenAPI/api-v2/document/path/larportalen/material/inriktningar/4-specialpedagogik/Gymnasieskola/117_Framja_motivation_larande_valbefinnande/del_02/Material/Flik/Del_02_MomentA/Artiklar/SP25_GY_02A_pedagogiska_strategier.docx">https://larportalen.skolverket.se/LarportalenAPI/api-v2/document/path/larportalen/material/inriktningar/4-specialpedagogik/Gymnasieskola/117_Framja_motivation_larande_valbefinnande/del_02/Material/Flik/Del_02_MomentA/Artiklar/SP25_GY_02A_pedagogiska_strategier.docx</a> (s. 3-4)</li>
<li>Modul: Inkludering och delaktighet. Del 3. Alla elevers inflytande över sitt eget lärande. <a href="https://larportalen.skolverket.se/#/modul/4-specialpedagogik/Gymnasieskola/128a_Inkludering_och_delaktighet/Del_03/">https://larportalen.skolverket.se/#/modul/4-specialpedagogik/Gymnasieskola/128a_Inkludering_och_delaktighet/Del_03/</a></li>
<li>Modul: Inkludering och delaktighet Del 4: Förbereda och planera för inkludering (s. 4) <a href="https://larportalen.skolverket.se/LarportalenAPI/api-v2/document/path/larportalen/material/inriktningar/4-specialpedagogik/Gymnasieskola/128a_Inkludering_och_delaktighet/Del_04/Material/Flik/Del_04_MomentA/Artiklar/SP121_F_1-9_Gy_vux_04A_01_inkludering_och_differentiering.docx">https://larportalen.skolverket.se/LarportalenAPI/api-v2/document/path/larportalen/material/inriktningar/4-specialpedagogik/Gymnasieskola/128a_Inkludering_och_delaktighet/Del_04/Material/Flik/Del_04_MomentA/Artiklar/SP121_F_1-9_Gy_vux_04A_01_inkludering_och_differentiering.docx</a></li>
<li>Modul: Inkludering och delaktighet. Del 4. Förbereda och planera för inkludering och differentiering <a href="https://larportalen.skolverket.se/#/modul/4-specialpedagogik/Gymnasieskola/128a_Inkludering_och_delaktighet/Del_04/">https://larportalen.skolverket.se/#/modul/4-specialpedagogik/Gymnasieskola/128a_Inkludering_och_delaktighet/Del_04/</a></li>
<li>Modul: Inkludering och delaktighet. Del 4: Förbereda och planera för inkludering. Artikel: Inkludering och  differentiering i undervisningen <a href="https://larportalen.skolverket.se/LarportalenAPI/api-v2/document/path/larportalen/material/inriktningar/4-specialpedagogik/Gymnasieskola/128a_Inkludering_och_delaktighet/Del_04/Material/Flik/Del_04_MomentA/Artiklar/SP121_F_1-9_Gy_vux_04A_01_inkludering_och_differentiering.docx">https://larportalen.skolverket.se/LarportalenAPI/api-v2/document/path/larportalen/material/inriktningar/4-specialpedagogik/Gymnasieskola/128a_Inkludering_och_delaktighet/Del_04/Material/Flik/Del_04_MomentA/Artiklar/SP121_F_1-9_Gy_vux_04A_01_inkludering_och_differentiering.docx</a>  (s. 2 och s. 4)</li>
<li>Ferrero M, Vadillo, MA, Leon SP, A valid evaluation of the theory of multiple intelligences is not yet possible: Problems of methodological quality for intervention studies, Intelligence 88, 2021</li>
<li>Richard E. Clark (1982) Antagonism Between Achievement and Enjoyment in ATI Studies, Educational Psychologist, 17:2, 92-101, DOI: 10.1080/0046152820952924</li>
<li>Modul: Tillgängligt lärande med digitala verktyg. Del 3: Erbjuda möjligheter att lära på olika sätt Film: Varierade arbetssätt. <a href="https://youtu.be/DJf4eGNoW80">https://youtu.be/DJf4eGNoW80</a></li>
<li>Modul: Delaktighet i lärmiljön. Del 4: Att anpassa undervisningen efter eleverna.  <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>  (s. 4)</li>
<li>Caro, D. 1-1., Lenkeit, J., &amp; Kyriakides, L.(2016). Teaching strategies and differential effectiveness across learning contexts: Evidence from PISA 2012. Studies in Educational Evaluation, 49, 30-41.</li>
<li>Filip Gedin, Sebastian Blomé, Moa Ponten, Maria Lalouni, Jens Fust, Andreé Raquette, Viktor Vadenmark Lundquist, William H. Thompson och Karin Jensen, Placebo Response and media attention in randomized clinical trials assessing cannabis-based therapies for pain: A systematic review and meta-analysis”, JAMA Network Open, online 28 november, 2022, doi: 10.1001/jamanetworkopen.2022.43848</li>
<li>Capp MJ (2017) The effectiveness of universal design for learning: A meta-analysis of literature between 2013 and 2016. International Journal of Inclusive Education 21(8): 791–807</li>
<li>Murphy, M. P. (2021). Belief without evidence? A policy research note on Universal Design for Learning. Policy Futures in Education, 19(1), 7–12.</li>
<li>Som 18</li>
<li>Som 18</li>
<li>Boysen, Guy. (2021). Lessons (Not) Learned: The Troubling Similarities Between Learning Styles and Universal Design for Learning. Scholarship of Teaching and Learning in Psychology. 10.1037/stl0000280.</li>
<li>“Hälsa för lärande – lärande för hälsa”. <a href="https://www.skolverket.se/getFile?file=4071">https://www.skolverket.se/getFile?file=4071</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 4 månader!
i 4 månader!
Ingen bindningstid
- Alla artiklar
- Alla poddar
- Kvartals app
- Reklamfritt
Till erbjudandet
