Därför skjuts det så mycket i Sverige

<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%2Fforskare-darfor-skjuts-det-sa-mycket-i-sverige%2F&amp;t=D%C3%A4rf%C3%B6r+skjuts+det+s%C3%A5+mycket+i+Sverige"    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=D%C3%A4rf%C3%B6r+skjuts+det+s%C3%A5+mycket+i+Sverige+-+https%3A%2F%2Fkvartal.se%2Fartiklar%2Fforskare-darfor-skjuts-det-sa-mycket-i-sverige%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%2Fforskare-darfor-skjuts-det-sa-mycket-i-sverige%2F"    target = "_blank"    class  = "li-link"    title  = "Dela på LinkedIn"><i class="ti-linkedin ui transparent"></i></a><a href    = "mailto:?subject=Därför skjuts det så mycket i Sverige&body=https://kvartal.se/artiklar/forskare-darfor-skjuts-det-sa-mycket-i-sverige/"   target  = "_blank"    class   = "pr-link"    title   = "E-posta"    onclick = ""><i class="ti-email ui transparent"></i></a><a href    = "https://kvartal.se/skriv-ut/99564/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/99564/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/2024/07/Henrik_lowres2.jpg');"></div><img class="author-print-img" src="https://kvartal.se/wp-content/uploads/2024/07/Henrik_lowres2.jpg" style="display: none;">    </div>    <div class="by-disclaimer-holder" style="color: #8a3a67">Av <a href="https://kvartal.se/medverkande/henrik-hojer/">Henrik&nbsp;Höjer</a> | 29 juni 2023<div class="author-desc">Henrik Höjer är Kvartals vetenskapsredaktör. Han är även historiker och fö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%2Fforskare-darfor-skjuts-det-sa-mycket-i-sverige%2F&amp;t=D%C3%A4rf%C3%B6r+skjuts+det+s%C3%A5+mycket+i+Sverige"    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=D%C3%A4rf%C3%B6r+skjuts+det+s%C3%A5+mycket+i+Sverige+-+https%3A%2F%2Fkvartal.se%2Fartiklar%2Fforskare-darfor-skjuts-det-sa-mycket-i-sverige%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%2Fforskare-darfor-skjuts-det-sa-mycket-i-sverige%2F"    target = "_blank"    class  = "li-link"    title  = "Dela på LinkedIn"><i class="ti-linkedin ui transparent"></i></a><a href    = "mailto:?subject=Därför skjuts det så mycket i Sverige&body=https://kvartal.se/artiklar/forskare-darfor-skjuts-det-sa-mycket-i-sverige/"   target  = "_blank"    class   = "pr-link"    title   = "E-posta"    onclick = ""><i class="ti-email ui transparent"></i></a><a href    = "https://kvartal.se/skriv-ut/99564/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/99564/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 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/99564"    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-99564">  <div class="in-short-inner">    <span class="close_button close-in-short in-short-toggle" data-articleid = "99564"></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 ">
<h2>Manne Gerell, docent i kriminologi vid Malmö universitet: ”Sverige har agerat för sent”</h2>
</div>
<div class="rest-of-article ">
<p><strong>Varför är just Sverige så drabbat av sk</strong><strong>ottlossningar och skjutvapenvåld, enligt dig?</strong></p>
<p>Vet ej, men en delförklaring är nog att Sverige agerat för lite och för sent i att motverka de problem som växt fram.</p>
<p><strong>Hur ska vi bromsa utvecklingen?</strong></p>
<p>Vi behöver lagföra fler av dem som är involverade i våldet och förebygga att yngre förmågor ansluter sig.</p>
<figure id="attachment_100286" aria-describedby="caption-attachment-100286" style="width: 1024px" class="wp-caption alignnone"><img fetchpriority="high" decoding="async" class="wp-image-100286 size-full" src="https://kvartal.se/wp-content/uploads/2023/06/sdlo6BZiK56qiI-nl.jpg" alt="" width="1024" height="668" data-wp-pid="100286" srcset="https://kvartal.se/wp-content/uploads/2023/06/sdlo6BZiK56qiI-nl.jpg 1024w, https://kvartal.se/wp-content/uploads/2023/06/sdlo6BZiK56qiI-nl-600x391.jpg 600w, https://kvartal.se/wp-content/uploads/2023/06/sdlo6BZiK56qiI-nl-300x196.jpg 300w, https://kvartal.se/wp-content/uploads/2023/06/sdlo6BZiK56qiI-nl-768x501.jpg 768w" sizes="(max-width: 1024px) 100vw, 1024px" /><figcaption id="caption-attachment-100286" class="wp-caption-text">Manne Gerell. Foto: Johan Nilsson /TT</figcaption></figure>
<p><strong>Vilken typ av forskning bör man satsa på för att bättre förstå vad som sker?</strong></p>
<p>Jag tycker man bör satsa på forskning för att minska problemet, och då handlar det om att testa saker och göra ordentliga utvärderingar. Det som verkar fungera skalas upp, det som ej verkar fungera bör läggas ner eller justeras.</p>
<h2>Carina Gunnarson, docent i statsvetenskap och maffiaforskare: ”Pågår en maktkamp”</h2>
<p><strong>Varför är just Sverige så drabbat av sk</strong><strong>ottlossningar och skjutvapenvåld, enligt dig?</strong></p>
<p>Utan att vara kriminolog och utan att ha studerat gäng i Sverige, tror jag att det pågår en maktkamp mellan konkurrerande grupper. Ingen grupp är för stark eller kapabel att kontrollera de andra, och då tar man till våld. Det kan vara en följd av att polisen har gripit ledande personer vilket skapat maktvakuum, som olika aktörer nu försöker fylla. I Italien kan man se att under perioder då en viss grupp är dominant, till exempel Corleone-maffian, då minskar våldet och mikrokriminaliteten.</p>
<p>Detta indikerar att grupperna som nu strider om makten är svaga och omogna. De agerar snabbt och impulsivt och utsätter andra människor för risk. Ökat våld leder till fler polisinsatser, vilket stör deras verksamhet. Det skulle en erfaren och etablerad kriminell grupp inse och göra ansträngningar för att stävja. Till exempel genom att själv rensa bort impulsiva individer som skapar oreda och drar till sig uppmärksamhet från polisen. Det låter lite cyniskt, men titta på filmen <em>Gomorra</em>. Uppstickarna utmanar den äldre bossen, som dödar dem.</p>
<p><strong>Hur ska vi bromsa utvecklingen?</strong></p>
<p>Det krävs en kombination av åtgärder. På kort sikt handlar det förstås om att gripa dem som är skyldiga och skapa trygghet. Det är en polisiär uppgift. På medel- och längre sikt handlar det om insatser som redan idag diskuteras och som handlar om skola och socialtjänst och hur man fångar upp individer som är i riskzonen för rekrytering.</p>
<p>En sak som saknas i debatten i Sverige, och där man kan lära sig en del från andra länder, är att stärka samhällets goda krafter. Det handlar alltså inte bara om insatser som riktar in sig på dem som befinner sig i riskzonen, utan om att stärka dem som vill leva vanliga liv, de som sköter sig, arbetar och går i skolan. De måste känna att de kan vittna, gå till polisen och reagera på beteenden. Trots allt är det en liten minoritet som är kriminella. I Palermo har man jobbat mycket med att diskutera maffia i skolan, diskutera konstitutionen, sätta upp teaterpjäser, det vill säga att medvetandegöra elever om att maffia inte är bra. Det finns också organisationer som <em>Addiopizzo</em> och <em>Libera</em> som ger stöd till affärsmän som inte vill betala skyddspengar till maffian. Det är ett svårt arbete som syftar till värdeförändring som gör att maffians makt undermineras på sikt.</p>
<blockquote><p>Kan vi lära oss något här från andra länder som har liknande problem?</p></blockquote>
<p>Sedan har Italien haft flera uppmärksammade mord på politiker, domare, poliser och präster som kanske gjort det lättare att mobilisera den stora allmänheten, som efter morden på domarna Falcone och Borsellino 1992.</p>
<figure id="attachment_100264" aria-describedby="caption-attachment-100264" style="width: 1536px" class="wp-caption alignnone"><img decoding="async" class="wp-image-100264 size-full" src="https://kvartal.se/wp-content/uploads/2023/06/Carina_farg._MG_8361.jpg" alt="" width="1536" height="1920" data-wp-pid="100264" srcset="https://kvartal.se/wp-content/uploads/2023/06/Carina_farg._MG_8361.jpg 1536w, https://kvartal.se/wp-content/uploads/2023/06/Carina_farg._MG_8361-1229x1536.jpg 1229w, https://kvartal.se/wp-content/uploads/2023/06/Carina_farg._MG_8361-600x750.jpg 600w, https://kvartal.se/wp-content/uploads/2023/06/Carina_farg._MG_8361-240x300.jpg 240w, https://kvartal.se/wp-content/uploads/2023/06/Carina_farg._MG_8361-768x960.jpg 768w" sizes="(max-width: 1536px) 100vw, 1536px" /><figcaption id="caption-attachment-100264" class="wp-caption-text">Carina Gunnarson.</figcaption></figure>
<p><strong>Vilken typ av forskning bör man satsa på för att bättre förstå vad som sker?</strong></p>
<p>Det behövs bidrag från flera discipliner: jurister, ekonomer, statsvetare, sociologer, antropologer, historiker. Det handlar inte bara om att förstå problemen, utan att förbättra kunskapen om hur man motverkar att organiserad brottslighet. Det kan handla om att förutsättningslöst identifiera och dokumentera sårbarheter som utnyttjas av kriminella, till exempel när svenska välfärdssystem utnyttjas.</p>
<p>Hur gör man för att täppa till luckorna? Vilka kontrollsystem behöver vi för att undvika svinn ur statskassan? Vad kan vi göra för att göra förvaltningen mindre sårbar för inflytande och hot? Kan vi lära oss något här från andra länder som har liknande problem? Vilka misstag är det vi ska undvika? Jag tror att man måste titta förutsättningslöst på problemen, fältet är politiserat, och lösningarna ser olika ut beroende på var man är på vänster–höger-skalan.</p>
<h2>Diamant Salihu, journalist och författare, specialiserad på gängbrottslighet: ”En perfekt storm”</h2>
<p><strong>Varför är just Sverige så drabbat av skottlossningar och skjutvapenvåld, enligt dig?</strong></p>
<p>En perfekt storm av sociala problem i flera utanförskapsområden med hög andel som inte klarat gymnasiebehörighet, språkbrister som stärkt isoleringen, frånvaro av närpolis i en kritisk period i samband med omorganisationen, få utredare och usel uppklarning av skjutvapenvåld och därmed låg avskräckning.</p>
<blockquote><p>Identifiera barn i riskmiljö tidigt&#8230;</p></blockquote>
<p>Även avsaknad av starka maffiastrukturer som annars hade kunnat kontrollera den yngre generationen som tagit över i kaoset som varit. Konsekvensen av allt detta är en snabb normförskjutning och radikaliserad gängmiljö där allt yngre barn nu i brist på konsekvenstänk och meningsfull tillvaro söker samhörighet i gangsterlivet.</p>
<p><strong>Hur ska vi bromsa utvecklingen?</strong></p>
<p>Identifiera barn i riskmiljö tidigt och stärk vårdnadshavarna i deras föräldraskap, men också att komma in på arbetsmarknaden. Få bort de öppna drogscenerna, och klara upp fler av brotten med skjutvapenvåld.</p>
<figure id="attachment_100625" aria-describedby="caption-attachment-100625" style="width: 1240px" class="wp-caption alignnone"><img decoding="async" class="wp-image-100625 size-full" src="https://kvartal.se/wp-content/uploads/2023/06/Diamant-Salihu-forfattare_L-Image-Hero.png" alt="" width="1240" height="709" data-wp-pid="100625" srcset="https://kvartal.se/wp-content/uploads/2023/06/Diamant-Salihu-forfattare_L-Image-Hero.png 1240w, https://kvartal.se/wp-content/uploads/2023/06/Diamant-Salihu-forfattare_L-Image-Hero-600x343.png 600w, https://kvartal.se/wp-content/uploads/2023/06/Diamant-Salihu-forfattare_L-Image-Hero-300x172.png 300w, https://kvartal.se/wp-content/uploads/2023/06/Diamant-Salihu-forfattare_L-Image-Hero-768x439.png 768w" sizes="(max-width: 1240px) 100vw, 1240px" /><figcaption id="caption-attachment-100625" class="wp-caption-text">Diamant Salihu.</figcaption></figure>
<p><strong>Vilken typ av forskning bör man satsa på för att bättre förstå vad som sker?</strong></p>
<p>Om rekryteringen av barnsoldater och vad som lockar de unga in i gängmiljön. Och om effektiviteten av LVU-/LSU-placeringar i Sverige. Sant inhämta lärdomar från jämförbara länder.</p>
<h2>Felipe Estrada Dörner, professor i kriminologi vid Stockholms universitet: ”Svårförklarlig och paradoxal situation”</h2>
<p><strong>Varför är just Sverige så drabbat av sk</strong><strong>ottlossningar och skjutvapenvåld, enligt dig?</strong></p>
<p>Den senaste tidens våldsutveckling i Sverige är av flera skäl svårförklarlig och paradoxal. Utvecklingen av det icke-dödliga och det dödliga våldet har i ett historiskt perspektiv haft ett tydligt samband. Under 2000-talet har dock detta mönster blivit otydligt. Det skjutvapenrelaterade våldet, främst kopplat till unga män i kriminella nätverk, skiljer sig från den generella utvecklingen av ungdomsbrottslighet, och nedgången av ungdomsvåld i synnerhet. Utvecklingen av det skjutvapenrelaterade våldet utgör alltså inte ”toppen av ett isberg”. Det betyder att vi behöver mer specifika snarare än generella förklaringar.</p>
<blockquote><p>För att bättre kunna beskriva och förstå våldsutvecklingen krävs analyser av högkvalitativa data som spänner över såväl tid som rum.</p></blockquote>
<p>Det finns idag en uppsjö med ansatser som lyfter fram olika driftkrafter bakom våldsutvecklingen. Det handlar om förändringar i demografi, kriminalpolitik, narkotikamarknad, ekonomi, kultur, alkoholkonsumtion och rutinaktiviteter. Dessa förklaringar kan kopplas till teorier som rör social kontroll, resurser och tillfällesstruktur, vilka i sin tur har olika policyimplikationer. Till de senare hör faktorer som låg brottsuppklaring av grova våldsbrott i början av våldsvågen, vilket bidragit till hämndspiraler. Liksom uppenbarligen en rik vapentillgång och konkurrens om en oorganiserad narkotikamarknad som genererar stora vinster för kriminella aktörer.</p>
<div>
<dl id="attachment_99584">
<dt>
<p><figure style="width: 1920px" class="wp-caption alignnone"><img decoding="async" src="https://kvartal.se/wp-content/uploads/2023/06/Felipe-Estrada_01.jpg" alt="" width="1920" height="1280" data-wp-pid="99584" /><figcaption class="wp-caption-text">Felipe Estrada Dörner.</figcaption></figure></dt>
</dl>
</div>
<p><strong>Hur ska vi bromsa utvecklingen?</strong></p>
<p>Kortsiktigt på två sätt. Polisiärt är det förstås viktigt att klara upp de grova våldsbrott som skett och lagföra dem som skjutit, om inte annat av rättviseskäl. Viktigt för att bromsa utvecklingen är att vi arbetar förebyggande. Detta kan vi göra på kort sikt genom exempelvis program som fokuserad avskräckning (sluta skjut) och avhopparverksamhet. Viktigast i långa loppet är dock att vi behöver bromsa nyrekryteringen av unga män.</p>
<p>Detta kräver satsningar på familjer i behov av olika former av stöd, på skolan för att tidigt hjälpa dem som har svårt att hänga med, på fritid för att knyta band till andra vuxna och binda upp tid när man inte är i skolan samt stöd till unga vuxnas etablering på arbetsmarknaden. Garantier finns aldrig, men all denna verksamhet skapar en social kontroll som gör benägenheten att rekryteras mindre sannolik.</p>
<p><strong>Vilken typ av forskning bör man satsa på för att bättre förstå vad som sker?</strong></p>
<p>För att bättre kunna beskriva och förstå våldsutvecklingen krävs analyser av högkvalitativa data som spänner över såväl tid som rum. En sådan strategi kan hjälpa oss att kunna avgöra förklaringsvärdet hos olika mekanismer bakom våldsutvecklingen.</p>
<p>Sverige och flera europeiska länder har exempelvis utmärkta befolkningsregister som kan användas för att studera vilka individer som begår, intensifierar eller upphör begå våldsbrott under olika förhållanden. Sådana analyser har stor potential. Det är även viktigt att tydligare utvärdera polisens och andra myndigheters insatser. Idag läggs många politiska förslag som i bästa fall kommer att vara ineffektiva och i värsta fall kontraproduktiva. Även dessa bör självfallet utvärderas.</p>
<h2>Stefan Holgersson, polis och polisforskare vid Linköpings universitet: ”Polisen behöver bli bättre”</h2>
<p><strong>Varför är just Sverige så drabbat av sk</strong><strong>ottlossningar och skjutvapenvåld, enligt dig?</strong></p>
<p>Många aktörer har del i att situationen ser ut som den gör. I min forskning fokuserar jag på polisen och det går att konstatera att polisens sätt att agera och organisera sitt arbete inte har varit framgångsrikt. En vanlig förklaring till detta har varit att fenomenet är komplicerat och delvis nytt.</p>
<p>Polisens bristande effektivitet är emellertid en del av en större problembild som visar sig inom en rad betydligt mindre komplexa polisiära verksamhetsområden, vilket avspeglat sig i bland annat passkaos och långa svarstider på 114 14.</p>
<blockquote><p>Polismyndigheten har dock varit framgångsrik med att flytta fokus från polisens tillkortakommanden.</p></blockquote>
<p><strong>Hur ska vi bromsa utvecklingen?</strong></p>
<p>Det finns många faktorer som inte är kopplade till polisen, men polisen är en central aktör och det är därmed viktigt att Polismyndigheten använder tilldelade resurser på ett mer effektivt sätt. Polismyndigheten har dock varit framgångsrik med att flytta fokus från polisens tillkortakommanden. Det har hämmat utvecklingen av polisens verksamhet.</p>
<figure id="attachment_100661" aria-describedby="caption-attachment-100661" style="width: 2560px" class="wp-caption alignnone"><img decoding="async" class="wp-image-100661 size-full" src="https://kvartal.se/wp-content/uploads/2023/06/Stefan-Holgersson-20223-LiU-7575-scaled.jpg" alt="" width="2560" height="1709" data-wp-pid="100661" srcset="https://kvartal.se/wp-content/uploads/2023/06/Stefan-Holgersson-20223-LiU-7575-scaled.jpg 2560w, https://kvartal.se/wp-content/uploads/2023/06/Stefan-Holgersson-20223-LiU-7575-1536x1025.jpg 1536w, https://kvartal.se/wp-content/uploads/2023/06/Stefan-Holgersson-20223-LiU-7575-2048x1367.jpg 2048w, https://kvartal.se/wp-content/uploads/2023/06/Stefan-Holgersson-20223-LiU-7575-600x401.jpg 600w, https://kvartal.se/wp-content/uploads/2023/06/Stefan-Holgersson-20223-LiU-7575-300x200.jpg 300w, https://kvartal.se/wp-content/uploads/2023/06/Stefan-Holgersson-20223-LiU-7575-768x513.jpg 768w" sizes="(max-width: 2560px) 100vw, 2560px" /><figcaption id="caption-attachment-100661" class="wp-caption-text">Stefan Holgersson.</figcaption></figure>
<p><strong>Vilken typ av forskning bör man satsa på för att bättre förstå vad som sker?</strong></p>
<p>Eftersom jag främst forskar på polisens verksamhet har jag identifierat viktiga forskningsbehov när det gäller hur polisen kan bli en bättre fungerande organisation. Där är ett problem att forskare påverkas av att det kan få negativa konsekvenser att betona vissa problem.</p>
<h2>Sten Levander, professor emeritus i kriminologi: ”Vi har gått vilse”</h2>
<p><strong>Varför är just Sverige så drabbat av skottlossningar och skjutvapenvåld, enligt dig?</strong></p>
<p>Det måste vara kriminologiskt relevanta samhällsskillnader som skiljer ut oss från grannländerna. De tre följande är de viktigaste.</p>
<p>Straffrättsligt: Vi har en i världen unik straffrätt med behandling i fokus (bekräftat med Brottsbalken 1964), brottsförklaring via deterministiska sociala och strukturella mekanismer (ej personligt ansvar) och bortskrivning av huvudprincipen (behandling) med revisionen av Brottsbalken 1989. Vi har gått vilse.</p>
<blockquote><p>MC-gängen introducerade organiserad kriminalitet – och formulerade en attraktiv identitet som alternativ till villa-volvo-vovve.</p></blockquote>
<p>Praktiken: Vi väljer ordet ”barn” när vi pratar om ungdomskriminalitet. Vi borde ha, och hade, tvångsmetoder för sådana från 12 års ålder – och dessa kopplades till god psykiatri och fungerade. Efter 1965 habiliterar vi nästan ingen. Konsekvenser för brott saknas för dem under 18 års ålder – vad lär sig ungdomar som begår brott (som har belöningsvärde) när negativa konsekvenser saknas? MC-gängen introducerade organiserad kriminalitet – och formulerade en attraktiv identitet som alternativ till villa-volvo-vovve.</p>
<p>Segregationen: Socialisationsprocesserna misslyckas utan gemensam värdegrund, inte minst moralutvecklingen (bra normer och respekt för dessa). Den i vuxenlivet nödvändiga problemlösningsförmåga som skolan ska förmedla når inte många av de sårbara pojkarna. De blir permanent utanför.</p>
<figure id="attachment_100468" aria-describedby="caption-attachment-100468" style="width: 2560px" class="wp-caption alignnone"><img decoding="async" class="wp-image-100468 size-full" src="https://kvartal.se/wp-content/uploads/2023/06/193B4DFB-1205-4208-BDE0-9857B666D8EE-scaled.jpeg" alt="" width="2560" height="1707" data-wp-pid="100468" srcset="https://kvartal.se/wp-content/uploads/2023/06/193B4DFB-1205-4208-BDE0-9857B666D8EE-scaled.jpeg 2560w, https://kvartal.se/wp-content/uploads/2023/06/193B4DFB-1205-4208-BDE0-9857B666D8EE-1536x1024.jpeg 1536w, https://kvartal.se/wp-content/uploads/2023/06/193B4DFB-1205-4208-BDE0-9857B666D8EE-2048x1365.jpeg 2048w, https://kvartal.se/wp-content/uploads/2023/06/193B4DFB-1205-4208-BDE0-9857B666D8EE-600x400.jpeg 600w, https://kvartal.se/wp-content/uploads/2023/06/193B4DFB-1205-4208-BDE0-9857B666D8EE-300x200.jpeg 300w, https://kvartal.se/wp-content/uploads/2023/06/193B4DFB-1205-4208-BDE0-9857B666D8EE-768x512.jpeg 768w" sizes="(max-width: 2560px) 100vw, 2560px" /><figcaption id="caption-attachment-100468" class="wp-caption-text">Sten Levander. Foto: Per-Olof Wikström.</figcaption></figure>
<p><strong>Hur ska vi bromsa utvecklingen?</strong></p>
<p>Genom tidiga insatser för riskgrupper. Riskgruppsansatsen bör omfatta 10 procent av pojkarna i socialt dysfunktionella områden redan från konstaterad graviditet. Vid fyra års ålder kan vi identifiera problempojkarna (vanligen i dysfunktionella områden men inte alltid) – för dessa (5 procent) inleder man förebyggande arbete i vilket barn- såväl som vuxenpsykiatrin måste vara med. Trasiga pojkar har ofta trasiga föräldrar. Föräldraförmågan är viktig.</p>
<p>I tidig pubertet ändras hjärnan så att inlärning utan ansträngning i fortsättningen kräver motivation och ansträngning. Därmed blir behandling av sårbara pojkar i stort sett omöjlig. Med dålig självreglering (impuls- och affektkontroll) och avsaknad av moralstyrning ska fokus ligga på beteendekontroll, med tvång om det behövs, men med fortsatt fokus på utbildning och beteendeterapeutisk förbättring av självkontroll och moralstyrning. Brottslighet ska förhindras i botten såväl som från toppen. Svensk formalism tillåter inte innovativa metoder att inkapacitera gängledarna.</p>
<p><strong>Vilken typ av forskning bör man satsa på för att bättre förstå vad som sker?</strong></p>
<p>Vi vet vad vi behöver veta för att hantera det svenska gängproblemet, allt ovan kan verifieras i tusentals högklassiga vetenskapliga publikationer.</p>
<p>Kvartal ställer nu tre frågor till olika forskare och experter. Justitieminister <strong>Gunnar Strömmer</strong> har bjudit in forskare till ett möte i september som ska svara på samma frågor. Samtidigt kommer erbjudanden från olika politiska partier att svara på samma frågor. Man tror tydligen att man genom att ställa forskare mot forskare kan få stöd för de egna ideologibaserade lösningarna. Risken är att forskarna korrumperas. De vet mycket om riskfaktorer men alltför lite om orsaksfaktorer bakom brott. Bara genom att bryta orsakskedjor kan vi påverka brottsligheten.</p>
<p>År 1965 deklarerade dåvarande regering att individperspektivet (inklusive psykologi/psykiatri) saknade förklaringsvärde för brottsligheten. Orsakerna fanns på samhällsnivå, särskilt relaterade till klasskillnader. Det var och är fel. Orsaksforskning måste ges högsta prioritet, och avse teoretisk såväl som tillämpad sådan och utgå från att en-faktor-teorier tillhör historien. Brottskausaliteten är komplex.</p>
<h2>Ardavan Khoshnood, docent i akutsjukvård vid Lunds universitet: ”En okontrollerad invandring med dålig integration”</h2>
<p><strong>Varför är just Sverige så drabbat av skottlossningar och skjutvapenvåld, enligt dig?</strong></p>
<p>Det finns många orsaker. Vi har haft en lagstiftning som varit omodern. Det finns gott om skjutvapen. En stor del av dem som är involverade i det skjutvapenrelaterade våldet är personer med utländsk bakgrund. En okontrollerad invandring med dålig integrationsplanering från staten är ett tredje problem. Svenska politiker har länge valt att prioritera andra områden än just brottsförebyggande arbete, polis och kriminalvård.</p>
<blockquote><p>Nu behöver vi punktmarkera de mest kriminella och ta in dem för minsta brott.</p></blockquote>
<p>Idag ser vi resultatet av detta. En sista anledning menar jag är att Sverige eftersträvat ett samhälle utan hierarki vilket bidragit till stora problem som avsaknad av respekt för auktoriteter.</p>
<p><strong>Hur ska vi bromsa utvecklingen?</strong></p>
<p>Vi behöver två tydliga linjer. Repressiva åtgärder samt brottsförebyggande arbete. Sverige befinner sig i en sådan kollaps vad gäller den grova organiserade och oorganiserade brottsligheten inklusive våldsbrottslighet, att samhället måste gå in och bryta trenden. Nu behöver vi punktmarkera de mest kriminella och ta in dem för minsta brott. Vi behöver en lagstiftning som ger Åklagarmyndigheten och polisen långtgående befogenheter i kampen mot personer som bedöms vara livsstilskriminella och våldsbrottslingar. Genom att störa dessa individer så gott det går, kan vi kortsiktigt få kontroll över situationen. För att detta ska hålla i sig, behöver vi därefter långtgående brottsförebyggande åtgärder.</p>
<p>Vi måste ha resurser och tydliga riktlinjer för hur barn och ungdomar i riskzonen ska kunna identifieras. Vidare måste vi ha kontinuerlig tillgång till barn- och ungdomspsykiatrin, socialtjänsten, polisen och skolan. Det viktigaste är att stoppa nyrekryteringen och då är det i skolan vi ska börja.</p>
<p>Vad sägs om att starta ett nationell Centrum för Barnafrid som samordnar allt detta?</p>
<figure id="attachment_100553" aria-describedby="caption-attachment-100553" style="width: 1800px" class="wp-caption alignnone"><img decoding="async" class="wp-image-100553 size-full" src="https://kvartal.se/wp-content/uploads/2023/06/PPDEBATT36-20191104.jpg" alt="" width="1800" height="1083" data-wp-pid="100553" srcset="https://kvartal.se/wp-content/uploads/2023/06/PPDEBATT36-20191104.jpg 1800w, https://kvartal.se/wp-content/uploads/2023/06/PPDEBATT36-20191104-1536x924.jpg 1536w, https://kvartal.se/wp-content/uploads/2023/06/PPDEBATT36-20191104-600x361.jpg 600w, https://kvartal.se/wp-content/uploads/2023/06/PPDEBATT36-20191104-300x181.jpg 300w, https://kvartal.se/wp-content/uploads/2023/06/PPDEBATT36-20191104-768x462.jpg 768w" sizes="(max-width: 1800px) 100vw, 1800px" /><figcaption id="caption-attachment-100553" class="wp-caption-text">Ardavan Khoshnood. Foto: Patrick Persson.</figcaption></figure>
<p><strong>Vilken typ av forskning bör man satsa på för att bättre förstå vad som sker?</strong></p>
<p>Tre typer av forskning måste staten satsa på:</p>
<p>Vilka är gärningsmännen och vilka är offren? Vi behöver mer forskning på dessa individer för att förstå deras profil. Genom att förstå vilka eventuella karakteristika de har gemensamt kan vi på mer effektiva sätt gå in med åtgärder.</p>
<p>Hur vi ska identifiera och därefter hantera barn och ungdomar inom riskzonen är ett mycket viktigt ämne att forska på. Vi har brist på sådana studier i Sverige och måste via forskning kartlägga vilka resurser skolorna har idag, vilka resurser de behöver och hur det praktiska arbetet ska gå till.</p>
<p>Polisiärt arbete är den tredje typen av forskning vi måste satsa på. Hur kan polisen mest effektivt bekämpa den grova brottsligheten? På vilket sätt kan polisen använda underrättelser mest effektivt i sitt operativa arbete? Det finns en hel del forskning från anglosaxiska länder, men nästan ingenting i Sverige.</p>
<p><em>Kvartal har även skickat enkäten till Jerzy Sarnecki, Marie Torstensson Levander, Peter Esaiasson, Christoffer Carlsson, Amir Rostami, Per-Olof Wikström och Johannes Knutsson. De har inte svarat.</em></p>
<div class="author-byline">Henrik Höjer är Kvartals vetenskapsredaktör. Han är även historiker och författare.
</div>
</div>
