I korthet
Brottsförebyggande rådets (Brå) rapport Misstänkta för brott bland personer med inrikes respektive utrikes bakgrund har väckt stort intresse och en hel del debatt. Det har gått nästan 16 år sedan en liknande undersökning publicerades, och brottsutvecklingen i landet – särskilt när det gäller våldsbrott och gängvälde – har gjort frågorna kring invandrade personers och deras barns brottslighet ytterst angelägna.
<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-50430"      class = "kv-pod-holder kv-player-light  lplo " data-sid="" data-eid="" data-pid="50430" data-acurl="aHR0cHM6Ly9tZWRpYS5wb2Quc3BhY2UvaW5sYXN0YXRleHRlci9kYWdzX2F0dF9lcmthbm5hX2RldF9zb2Npb2t1bHR1cmVsbGFfYXJ2ZXQubXAz" data-psurl="">  <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/mauricio-rojas/">Mauricio&nbsp;Rojas</a> | 8 september 2021<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%2Fdags-att-erkanna-det-sociokulturella-arvet%2F&amp;t=Dags+att+erk%C3%A4nna+det+sociokulturella+arvet"    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=Dags+att+erk%C3%A4nna+det+sociokulturella+arvet+-+https%3A%2F%2Fkvartal.se%2Fartiklar%2Fdags-att-erkanna-det-sociokulturella-arvet%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%2Fdags-att-erkanna-det-sociokulturella-arvet%2F"    target = "_blank"    class  = "li-link"    title  = "Dela på LinkedIn"><i class="ti-linkedin ui transparent"></i></a><a href    = "mailto:?subject=Dags att erkänna det sociokulturella arvet&body=https://kvartal.se/artiklar/dags-att-erkanna-det-sociokulturella-arvet/"   target  = "_blank"    class   = "pr-link"    title   = "E-posta"    onclick = ""><i class="ti-email ui transparent"></i></a><a href    = "https://kvartal.se/skriv-ut/50430/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/50430/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 author-section-external">  <div class="author-section-inner">    <div class="author-image-holder"><span class="icon-kvartal-hare"></span>    </div>    <div class="by-disclaimer-holder" style="color: #8a3a67">Eventuella åsikter och slutsatser i texten är skribentens egna.    </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%2Fdags-att-erkanna-det-sociokulturella-arvet%2F&amp;t=Dags+att+erk%C3%A4nna+det+sociokulturella+arvet"    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=Dags+att+erk%C3%A4nna+det+sociokulturella+arvet+-+https%3A%2F%2Fkvartal.se%2Fartiklar%2Fdags-att-erkanna-det-sociokulturella-arvet%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%2Fdags-att-erkanna-det-sociokulturella-arvet%2F"    target = "_blank"    class  = "li-link"    title  = "Dela på LinkedIn"><i class="ti-linkedin ui transparent"></i></a><a href    = "mailto:?subject=Dags att erkänna det sociokulturella arvet&body=https://kvartal.se/artiklar/dags-att-erkanna-det-sociokulturella-arvet/"   target  = "_blank"    class   = "pr-link"    title   = "E-posta"    onclick = ""><i class="ti-email ui transparent"></i></a><a href    = "https://kvartal.se/skriv-ut/50430/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/50430/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/dags-att-erkanna-det-sociokulturella-arvet/?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/50430"    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-50430">  <div class="in-short-inner">    <span class="close_button close-in-short in-short-toggle" data-articleid = "50430"></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 ">Brottsförebyggande rådets (Brå) <a href="https://www.bra.se/download/18.1f8c9903175f8b2aa70f6df/1630415991246/2021_9_Misstankta_for_brott_bland_personer_med_inrikes_respektive_utrikes_bakgrund.pdf">rapport</a> <em>Misstänkta för brott bland personer med inrikes respektive utrikes bakgrund</em> har väckt stort intresse och en hel del debatt. Det har gått nästan 16 år sedan en liknande undersökning publicerades, och brottsutvecklingen i landet – särskilt när det gäller våldsbrott och gängvälde – har gjort frågorna kring invandrade personers och deras barns brottslighet ytterst angelägna.</p>
</div>
<div class="rest-of-article ">
<p>Den nya rapporten bekräftar en hel del saker som vi redan visste från de två tidigare rapporterna som Brå gjort om ämnet (<em>Invandrares och invandrares barns </em><i>brottslighet</i> från 1996 och <em>Brottslighet bland personer födda i Sverige och i utlandet</em> från <a href="https://www.bra.se/download/18.cba82f7130f475a2f1800012697/1371914727881/2005_17_brottslighet_bland_personer_fodda_sverige_och_utlandet.pdf">2005</a>):</p>
<ul>
<li>Det finns en betydande överrepresentation av invandrade personer och deras barn bland de som misstänks för brott.</li>
<li>Överrepresentationen är särskilt stor vad gäller våldsbrott.</li>
<li>Denna överrepresentation minskar när vi beaktar olika demografiska och socioekonomiska aspekter, men försvinner inte.</li>
<li>Det finns mycket stora skillnader i både överrepresentation och brottstyper mellan personer med rötter i olika länder och regioner.</li>
<li>Brå har inte forskat och har därför ingen förklaring (bara “tänkbara faktorer”, som det står i senaste rapporten) till den signifikanta överrepresentationen som kvarstår efter att man kontrollerat för demografiska och socioekonomiska faktorer.</li>
</ul>
<p>Att Brå inte vidare har undersökt denna överrepresentation har en enkel förklaring; det har funnits ett bastant politiskt motstånd mot att söka svar som kunnat trotsa den under lång tid härskande politiska korrektheten i en så känslig fråga. Det är samma typ av kontraproduktivt motstånd och styrning av forskningen som statsvetarna <strong>Peter Esaiasson</strong> och <strong>Bo Rothstein</strong> uppmärksammade förra året angående ”släktbaserade nätverk som genom hot om våld och trakasserier ut­övar stor makt i invandrartäta förortsområden” (<a href="https://www.dn.se/debatt/forskningen-har-missat-de-kriminella-natverken/">DN-debatt, 12/9 2020</a>).</p>
<p>Rapportens stora, och mycket bekymmersamma, nyhet är att överrepresentationen för personer födda i Sverige med två utrikesfödda föräldrar är större än för invandrade personer. Så var det inte tidigare, som det konstaterades i studierna från 1996 och 2005.</p>
<h2>Närmade sig svenskarnas brottslighet</h2>
<p>Statistiken visade då ett tydligt “assimilationsmönster” i detta avseende, det vill säga en tendens till att de invandrades barnens brottslighet närmade sig “svenskarnas” (personer födda i Sverige med två inrikesfödda föräldrar) brottsbeteende.</p>
<p>I den senaste rapporten konstateras däremot följande: “En skillnad (gentemot tidigare studier; min anm.) är att andelen misstänkta bland inrikesfödda med två utrikesfödda föräldrar nu är något större än bland utrikesfödda. I den förra studien var det tvärtom.”</p>
<p>Uttrycket “något större” är tveksamt i detta sammanhang, särskilt vad gäller våldsbrott. Skillnaden i överrepresentationen mellan dessa två grupper angående dödligt våld är 48 procent, vad gäller rån är den 55 procent och 100 procent gällande inbrottsstöld i bostad. Detta efter att ålder, kön och socioekonomiska variabler kontrollerats för, annars hade skillnaderna varit 180 procent, 229 procent respektive 194 procent.</p>
<blockquote><p>Därför är det i hög grad missvisande att i detta sammanhang tala om invandrare eller om deras barn på ett generellt sätt.</p></blockquote>
<p>Det är viktigt att påpeka att på samma sätt som när det gäller invandrade personer misstänkta för brott, skiljer sig olika grupper av inrikesfödda med två utrikesfödda föräldrar mycket markant sinsemellan. Därför är det i hög grad missvisande att i detta sammanhang tala om invandrare eller om deras barn på ett generellt sätt. Om man tar brott mot liv och hälsa som exempel kan det konstateras att det finns grupper, som de med rötter i Öst-, Sydost- och Sydasien, som knappast avviker från normen för inrikesfödda med inrikesfödda föräldrar, men det finns andra grupper som överskrider denna norm sju, åtta eller nio gånger.</p>
<p>I en uppmärksammad <a href="https://www.dn.se/debatt/kulturarv-ligger-bakom-invandrarnas-brottslighet/">debattartikel</a> i DN från 12/12 2005 diskuterade jag eventuella orsaker till de skillnader i brottslig aktivitet som inte kunde förklaras av demografiska och socioekonomiska faktorer. Efter att ha förkastat vanligt förekommande förklaringar, som själva invandringssituationen och diskrimineringen, som borde påverka de flesta berörda grupperna på ett relativt likartat sätt, landade jag i följande hypotes:</p>
<p>“Den aspekt som ofrånkomligen måste beaktas för att kunna ge en förklaring till de frågor som ställs här handlar om invandrarnas sociokulturella arv. Det är bara olikheterna i detta arv som i kombination med andra allmänverkande faktorer – som utsatthet eller diskriminering – kan ge en mer tillfredsställande förklaring till såväl skillnaderna i brottsbelastningen som &#8217;specialiseringen&#8217; i vissa typer av brott. Ett sådant påstående har hittills varit mer eller mindre tabubelagt, men det är det enda sättet att verkligen både förstå och ta itu med en situation som är djupt otillfredsställande.”</p>
<h2>Anklagelser om rasism</h2>
<p>Dessa ord väckte ett ramaskri och diverse anklagelser om bland annat främlingsfientlighet och rasism. För att idag kunna förstå en sådan reaktion måste vi komma ihåg att detta inträffade innan man på allvar uppmärksammade förekomsten av företeelser som hedersförtrycket, klanväldet eller islamismen, som på ett så uppenbart sätt har med detta arv att göra.</p>
<blockquote><p>Det sociokulturella arvet är inte något statiskt eller entydigt.</p></blockquote>
<p>I den nu pågående debatten, inte minst efter den senaste Brå-rapportens publicering, har jag sett en kulturrelaterad argumentering som bekymrar mig. Inte för att det skulle vara fel att beakta invandrarnas sociokulturella arv i detta sammanhang, utan för att det kan göras på ett sätt som missar väsentliga sociala och kulturella processer, som är nödvändigt att ta hänsyn till för att verkligen kunna förstå och vända på en utveckling som med rätta väcker oro.</p>
<p>Det sociokulturella arvet är inte något statiskt eller entydigt. Som i en stor verktygslåda finns det i detta arv många olika verktyg, som beroende på omständigheterna kan aktiveras och forma nya reaktionsmönster inför nya utmaningar. Det handlar om en utvecklingsprocess, där människor prövar sina olika resurser, både materiella och kulturella, i syfte att hantera nya och ofta oväntade situationer. Livet i ett nytt land, som på ett radikalt sätt skiljer sig från hemlandet, erbjuder ett sådant scenario där anpassningsbehovet sätter våra invanda förhållningssätt under stress. Det kommer att ge upphov till olika anpassningsstrategier där mycket av det gamla måste förändras eller förkastas, ty grundligt annorlunda omständigheter fordrar det.</p>
<p>I flera intressanta studier (till exempel <em>Somalier i Minneapolis – En dynamisk affär</em>, 2006), belyser ekonomhistorikern <strong>Benny Carlson</strong> de uppseendeväckande olikheterna i anpassnings- eller integrationsstrategier som somalierna har utvecklat i Sverige i jämförelse med deras landsmän i USA och andra länder, beroende just på de olika förutsättningar och incitament som mottagarländerna erbjuder. Han skrev 2010:</p>
<p>“Somalierna utgör i dag den största gruppen asylsökande. Vid slutet av innevarande år beräknas antalet somalier, inklusive barn födda i Sverige, uppgå till omkring 50 000. Somalierna är samtidigt den invandrargrupp som har lägst andel sysselsatta – andelen i åldern 20-64 år har under hela 2000-talet legat under 30 procent – och lägst andel företagare. Svenska politiker och myndigheter står alltså inför en rejäl utmaning. Samtidigt visar det sig att somalier lyckats betydligt bättre med att etablera sig på arbetsmarknaden och starta företag i andra delar av världen. Det somaliska företagandet i England och USA är förhållandevis livligt och somalierna i USA har ungefär dubbelt så hög sysselsättning som sina landsmän i Sverige och övriga Norden.”</p>
<p>Det finns inga avgörande skillnader mellan de somalier som invandrade till Sverige och till de övriga länderna som Carlson har studerat, men deras integration blev radikalt annorlunda beroende på sammanhanget. Den gemensamma grunden har varit det somaliska arvet, men det arvet har vidareutvecklats och förändrats på mycket annorlunda sätt inför olika integrationskontexter.</p>
<h2>Olika utfall av integration</h2>
<p>En än mer dynamisk och mångskiftande anpassningsprocess gäller de unga med somaliskt påbrå. Det analyseras i en essä av Carlson, skriven tillsammans med <strong>Sarah Scuzzarello</strong> (”Young Somalis’ social identity in Sweden and Britain”, <em>Migration Studies</em>, december 2019), där unga somaliers anpassningstrategier i England och Sverige jämförs. I studien betonas att i bägge fallen handlar det om en öppen process, i vilken den sociala identiteten formas i relation till både mottagarsamhället och den egna gruppens medlemmar. Denna process har lett till märkbara skillnader i de analyserade fallen. I England utvecklas “a social identity that includes commonalities with Britain as well as a sense of minority group distinctiveness”. I Sverige däremot, har de unga somalierna dragit slutsatsen att “their ethnic identity and the majority society’s Swedish identity are incompatible”.</p>
<p>För hundra år sedan (1918–1920), i ett av sociologins mest omfattande (fem band) och banbrytande verk, <em>The Polish Peasant in Europe and America</em>, studerade <strong>William Thomas</strong> och <strong>Florian Znaniecki</strong> de polska immigranternas integration i USA. Deras slutsats var att det “polska Amerika” varken var polskt eller amerikanskt. Det var något nytt, en kreativ blandning av det polska arvet och integrationsvillkoren i USA. Särskilt i Chicago som, på samma sätt som tidigare hade hänt med svenskarna, blev en av de viktigaste “polska städerna” i världen. Det handlade om en fascinerande “process of becoming”, som de kallade det, en kreativ kombination av “social desintegration” och “reorganization”.</p>

<p>Senare forskning har bekräftat Thomas och Znanieckis insikter. Från klassiker som <em>The Uprooted</em> (1952) av Harvardprofessor <strong>Oscar Handin</strong> till den moderna litteraturen om det som kallas “mixed embeddedness”. Den refererar till enskilda migranters aktiva val av integrationsstrategier utifrån sina egna etniska och klassrelaterade resurser samt mottagarlandets “struktur av möjligheter” och de mellanliggande sociala nätverken, som tillsammans skapar det konkreta sammanhanget (”embeddedness”) inom vilket migrantens integrationsprocess och kulturanpassning utspelas.</p>
<h2>Kreativ process av anpassning</h2>
<p>Samma kreativa process, där individen, mottagarlandets särdrag och de nätverk som invandrarna skapar samspelar, har präglat olika integrationsprocesser i Sverige, från vallonerna på 1600-talet och estländarna efter andra världskriget till dagens invandrare från Afrika och Mellanöstern. Det var också så svenskarna blev amerikaner, men inte utan vidare.</p>
<p>En långsam process av kreativ anpassning skapade en svensk-amerikansk identitet och ett dynamiskt civilsamhälle, som formade den omistliga bron genom vilken tiotusentals svenskar kunde vandra mot ett nytt liv i <em>the land of the free</em>.</p>
<p>Det relevanta med dessa iakttagelser är att de ger en utgångspunkt för ett konstruktivt och handlingsinriktat förhållningssätt, i motsats till en essensialistisk och statisk syn på kulturen och det arv som invandrarna för med sig. Enligt detta statiska synsätt bär människorna på en kultur som de, i grunden, inte kan förändra. De är fångar av det arv av traditioner, värderingar och föreställningar i vilket de en gång formades, och så kommer deras barn och barnbarn att bli.</p>
<p>Denna påstådda kulturella oföränderlighet skulle göra det omöjligt för vissa invandrargrupper och deras ättlingar att anpassa sig till en väsensskild typ av samhälle och kultur. I vårt fall skulle det vara så för invandrare som kommer från förmoderna, kollektivistiska och klanpräglade samhällsmiljöer, som omöjligen skulle kunna anpassas på ett positivt sätt till vårt moderna, sekulariserade, individcentrerade och jämställda samhälle.</p>
<p>I ett sådant perspektiv kan en betydande invandring av människor som definieras som “oassimilerbara” enbart leda till kulturkollisioner och en dysfunktionell anpassning, som mynnar ut i framväxten av parallellsamhällen där invandrarnas konfliktalstrande annorlundahet frodas och härskar.</p>
<p>Denna dystra slutsats drogs redan på 1980-talet av den franska Nationella frontens ideologer. Invandrarna indelades i “assimilerbara” och “icke assimilerbara”. Detta resonemang ledde till två viktiga politiska slutsatser.</p>
<blockquote><p>Ett dynamiskt kulturperspektiv leder däremot till helt andra politiska slutsatser.</p></blockquote>
<p>För det första, att det var lönlöst att över huvud taget ha en integrationspolitik eftersom de oassimilerbara grupperna (främst muslimska invandrare från norra Afrika) inte kunde integreras medan de andra, de assimilerbara, skulle smälta in i det franska samhället på ett naturligt sätt.</p>
<p>För det andra, att den enda lösningen för att kunna hindra en allt djupare splittring av Frankrike och hotet mot den franska identiteten var att dessa icke assimilerbara grupper repatrierades eller återvandrade (i Nationella frontens våldsamma språkbruk hette det exempelvis “<em>extirper du corp national les immigrés inassimilables</em>” (”avlägsna från den nationella kroppen de oassimilerbara invandrarna”) och dylikt.</p>
<h2>Mot en fungerande integration</h2>
<p>Ett dynamiskt kulturperspektiv leder däremot till helt andra politiska slutsatser. Det går att åstadkomma kulturella förändringar i riktning mot en fungerande integration, men det kräver både kunskaper och handlingsvilja. Vi måste bekanta oss med de anpassningsprocesserna som olika invandrade grupper och deras barn är involverade i, särskilt under de livsvillkor som råder i utanförskapsområdena. Det är dessa villkor som kommer att mobilisera specifika beståndsdelar av invandrarnas sociokulturella arv och skapa nya förhållningssätt och solidariteter, som många gånger, inte minst bland de unga, utmanar gamla normer, blandar olika kulturella inflytanden och trotsar gränserna för de etniskt baserade nätverken som upprätthålls av en äldre generation.</p>
<p>I <em>Utanförskapets karta</em> från år <a href="https://www.liberalerna.se/nyheter/utanforskapets-karta">2004</a> beskrevs denna process där en specifik utanförskapskultur bildas på följande sätt:</p>
<p>”När livet för en majoritet av de som bor i ett område helt och hållet präglas av socioekonomiska villkor och kulturella referensramar som på ett radikalt sätt skiljer sig från samhället i övrigt omvandlas den individuella utsattheten till<br />
kollektiva processer med en egen dynamik. Dessa processer återverkar i sin tur på ett avgörande sätt individernas livsomständigheter, inte minst på sättet att både uppleva och hantera den egna utsattheten. Då uppstår kollektiva förhållningssätt samt gemensamma referenspunkter och värderingar som bildar grunden för en specifik kultur, en kultur som helt kretsar kring det utanförskap som alla delar med varandra och som präglar livets alla situationer. Detta leder till en process där utanförskapet i sig genererar mer utanförskap och där utanförskapets kultur går i arv till nya generationer, som i sin tur ser sina livschanser begränsas ännu mer av detta kulturella arv.”</p>
<p>Det är en sådan process som jag tror till stor del kan förklara den dåliga nyheten som senaste Brå-rapporten förmedlade angående brottslighetsutvecklingen bland de i Sverige födda barnen till invandrade föräldrar.</p>
<blockquote><p>”Vi kanske inte såg det komma” är Stefan Löfvens bevingade ord i sammanhanget.</p></blockquote>
<p>Det är utifrån en dynamisk syn på kulturen som vi kan närma oss och påverka det brokiga landskapet, präglat av olika typer av maffialiknande organisationer och subkulturer, som journalisten <strong>Lasse Wierup</strong> uppmärksammar i <em>Gangsterparadiset</em> (2020). Det handlar, enligt Wierups uppskattning, om ”totalt minst 350 kriminella konstellationer”. Dessa sträcker sig från en mer traditionell typ av klanstruktur, som den som så väl belystes i <strong>Johanna Bäckström Lernebys</strong> bok <em>Familjen</em> (2020), till blandade ”territoriella nätverk”, där gängtillhörigheten och anammande av en identitetsbärande gängkultur är det avgörande.</p>
<p>Brå:s senaste rapport har tolkats och kommer att tolkas på många olika sätt. Jag tolkar det som en utmaning till att våga känna och erkänna den svåra verkligheten som vi har att hantera efter decennier av självförvållad blindhet och handlingsförlamande strutspolitik.</p>
<p>”Vi kanske inte såg det komma” är <strong>Stefan Löfvens</strong> <a href="https://www.svtplay.se/video/30538590/30-minuter/30-minuter-avsnitt-9">bevingade ord</a> i sammanhanget. Uppriktigare hade varit att säga: ”Vi såg det inte komma för att vi inte ville se det komma”.</p>
<div class="author-byline">Mauricio Rojas är före detta riksdagledamot i Liberalerna och docent i ekonomisk historia vid Lunds universitet. Han är sedan augusti 2021 integrationspolitisk rådgivare för Liberalerna.
</div>
</div>
