I korthet
I decennier har kriminologiprofessorn Jerzy Sarnecki varit en motståndare till längre fängelsestraff. Argumenten har i huvudsak varit två: skärpta straff har liten avskräckande effekt, och vistelse i fängelse gör sällan förbrytaren till en bättre människa. Detta är helt korrekt – men däremot har Sarnecki återkommande förtigit eller förminskat effekten av inkapacitering, det vill säga inlåsning som förhindrar den dömde att fortsätta begå brott.
<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-23993"      class = "kv-pod-holder kv-player-light  lplo " data-sid="" data-eid="" data-pid="23993" data-acurl="aHR0cHM6Ly9tZWRpYS5wb2Quc3BhY2UvaW5sYXN0YXRleHRlci9mb3JtaW5za2FfaW50ZV9hbGx2YXJldC5tcDM=" 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/fredrik-karrholm/">Fredrik&nbsp;Kärrholm</a> | 6 oktober 2020<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%2Fforminska-inte-allvaret%2F&amp;t=F%C3%B6rminska+inte+allvaret"    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=F%C3%B6rminska+inte+allvaret+-+https%3A%2F%2Fkvartal.se%2Fartiklar%2Fforminska-inte-allvaret%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%2Fforminska-inte-allvaret%2F"    target = "_blank"    class  = "li-link"    title  = "Dela på LinkedIn"><i class="ti-linkedin ui transparent"></i></a><a href    = "mailto:?subject=Förminska inte allvaret&body=https://kvartal.se/artiklar/forminska-inte-allvaret/"   target  = "_blank"    class   = "pr-link"    title   = "E-posta"    onclick = ""><i class="ti-email ui transparent"></i></a><a href    = "https://kvartal.se/skriv-ut/23993/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/23993/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%2Fforminska-inte-allvaret%2F&amp;t=F%C3%B6rminska+inte+allvaret"    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=F%C3%B6rminska+inte+allvaret+-+https%3A%2F%2Fkvartal.se%2Fartiklar%2Fforminska-inte-allvaret%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%2Fforminska-inte-allvaret%2F"    target = "_blank"    class  = "li-link"    title  = "Dela på LinkedIn"><i class="ti-linkedin ui transparent"></i></a><a href    = "mailto:?subject=Förminska inte allvaret&body=https://kvartal.se/artiklar/forminska-inte-allvaret/"   target  = "_blank"    class   = "pr-link"    title   = "E-posta"    onclick = ""><i class="ti-email ui transparent"></i></a><a href    = "https://kvartal.se/skriv-ut/23993/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/23993/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/forminska-inte-allvaret/?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 14 min</span></a><a href   = "https://kvartal.se/skarmlasarvanlig/23993"    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-23993">  <div class="in-short-inner">    <span class="close_button close-in-short in-short-toggle" data-articleid = "23993"></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 decennier har kriminologiprofessorn Jerzy Sarnecki varit en motståndare till längre fängelsestraff. Argumenten har i huvudsak varit två: skärpta straff har liten avskräckande effekt, och vistelse i fängelse gör sällan förbrytaren till en bättre människa. Detta är helt korrekt – men däremot har Sarnecki återkommande förtigit eller förminskat effekten av inkapacitering, det vill säga inlåsning som förhindrar den dömde att fortsätta begå brott.</p>
</div>
<div class="rest-of-article ">
<p>I otaliga debattartiklar och intervjuer har Sarnecki förkunnat att hårdare straff är en ineffektiv eller olämplig metod för att minska brottsligheten. Hans sätt att resonera och skriva har resulterat i många kategoriska rubriker, till exempel:</p>
<p>”Längre straff ger inte färre brott” (<a href="https://www.dn.se/arkiv/inrikes/langre-straff-ger-inte-farre-brott/">Dagens Nyheter, 11/10 2004</a>)</p>
<p>”Hårdare tag ger inte färre brott” (<a href="https://www.svd.se/hardare-tag-ger-inte-farre-brott">Svenska Dagbladet, 6/3 2010</a>)</p>
<p>”Skärpta straff fel metod att minska brottsligheten” (<a href="https://www.dn.se/debatt/skarpta-straff-fel-metod-att-minska-brottsligheten/#:~:text=DN%20Debatt.%20%E2%80%9DSk%C3%A4rpta%20straff%20fel%20metod%20att%20minska%20brottsligheten%E2%80%9D&amp;text=Om%20hon%20f%C3%A5r%20sin%20vilja,i%20brott%20ska%20straffas%20h%C3%A5rdare.">Dagens Nyheter, 8/4 2013</a>)</p>
<p>Budskapet till allmänheten och politiker har varit tydligt: skärpta straff är populism. När Sarnecki nyligen publicerade en artikel i Kvartal med rubriken ”Inlåsning minskar brottsligheten” var det därför många som reagerade med viss förvåning. Inklusive undertecknad.</p>
<h2>Två skäl till inkapacitering</h2>
<p>I artikeln förordar Sarnecki inlåsning när det gäller yngre personer som begår många eller grova brott. Detta är klokt av två skäl: Fängslandet förhindrar dem att begå ytterligare brott, och längre fängelsestraff innebär vid frisläppandet en högre ålder. Det senare minskar generellt individers brottsbenägenhet, främst på grund av hjärnans utveckling, sänkta testosteronnivåer och förändrad social kontext. Därmed resulterar en längre tids inlåsning av unga förbrytare i en positiv nettoeffekt.</p>
<blockquote><p>Av kriminella ungdomar som i dag döms till sluten ungdomsvård fortsätter nio av tio att begå brott.</p></blockquote>
<p>I en intervju i Expressen (<a href="https://www.expressen.se/nyheter/kriminologen-las-in-de-17-ariga-mordarna-lange/">16/9 2020</a>) konkretiserar Sarnecki tankegångarna. Han menar att det inte är tillräckligt att en 17-åring som har begått ett gängmord låses in i blott tre år. En 17-åring som har deltagit i ett planerat mord måste i stället låsas in i tio år, menar Sarnecki. Här har han helt rätt.</p>
<p>Unga grovt kriminella är farliga individer som i de flesta fall är oförbätterliga. Av kriminella ungdomar som idag döms till sluten ungdomsvård fortsätter nio av tio att begå brott.<sup>1</sup> Det som krävs är därför inkapacitering under lång tid.</p>
<p>Ändå har Sarnecki tidigare argumenterat emot varje form av inlåsning. I en debattartikel i Dagens Nyheter (<a href="https://www.dn.se/debatt/repliker/politiker-mer-intresserade-av-straff-an-av-minskad-brottslighet/">30/1 2018</a>) skrev han exempelvis – ihop med fem andra kriminologiprofessorer – att ”forskningen visar att inlåsning av unga är kontraproduktivt”.</p>
<p>Även om Sarnecki tycks ha ändrat uppfattning om inlåsning av grovt kriminella ungdomar är han fortfarande skeptisk till fler och längre fängelsestraff generellt. Han förklarar att effekterna av inkapaciteringen inte ska överskattas och anlägger även ett samhällsekonomiskt perspektiv.</p>
<h2>Starka evidens för straff</h2>
<p>Tvärtemot vad Sarnecki påstår är evidensen som sammanlänkar högre straff med lägre brottslighet mycket stark. Det kan noteras att studier som bevisar detta ofta är utförda av nationalekonomer. Anledningen är att nationalekonomer lägger mycket tid på att lära sig metoder för att dra statistiska slutsatser från icke-randomiserade data, vilket är nödvändigt för att kunna utvärdera effekter av straff.</p>
<p>Det är nämligen av etiska skäl sällan möjligt att genomföra kontrollerade experiment med straff. Det vore till exempel djupt orättvist att dömda i Göteborg skulle få dubbelt så långa fängelsestraff som dömda i Stockholm för att sedan jämföra utfallet. Av denna anledning är det komplicerat att utvärdera effekter av höjda straff. En observerad korrelation säger inte nödvändigtvis något om orsakssamband.</p>
<p>Den som ska studera effekterna av straffrättsreformer och förklara orsakssamband i komplicerade frågor kring kriminalitet behöver därför lära sig statistiska metoder som gör att man kan utnyttja den variation som finns i verkligheten.<sup>2</sup> Det är något som nationalekonomer, med utbildning inom fältet ekonometri, oftast kan bättre än de som är verksamma i andra samhällsvetenskaper.</p>
<blockquote><p>Därför, menar jag, behövs fler poliser, en utvecklad polisverksamhet, förbättrat vittnesskydd och ändringar i rättegångsbalken.</p></blockquote>
<p>Effekten av hårdare straff är studerad i bland annat Nederländerna, Italien och Danmark.<sup>3</sup> Mest studerad är dock straff- och brottsutvecklingen i USA. Totalt sett har brottsligheten i Förenta staterna halverats sedan 1990-talets början. Våldsbrott har minskat med över 50 procent.<sup>4</sup> Steven Levitt, amerikansk professor i nationalekonomi, har beräknat att den ökade inlåsningen av kriminella i USA kan förklara en tredjedel av den minskade brottsligheten.<sup>5</sup> Andra studier anger siffror mellan 10 och 27 procent.<sup>6</sup> För en motsvarande effekt i Sverige räcker dock inte de straffskärpningar som Sarnecki nu något överraskande föreslår. Det krävs mer.</p>
<p>Sarnecki påpekar även behovet av högre uppklaring av brott. Det är riktigt att en förutsättning för att skärpta straff ska ha en effekt är att fängelsedomar också utdöms. Därför, menar jag, behövs fler poliser, en utvecklad polisverksamhet, förbättrat vittnesskydd och ändringar i rättegångsbalken. Någon revolutionerande förbättring är dock inte sannolik. I internationell jämförelse är svensk polis relativt duglig. Samtidigt sätter rättssäkerheten gränser, vilket är bra. Skuld måste alltid bevisas utom rimligt tvivel.</p>
<h2>Fängelse lönsamt</h2>
<p>Icke desto mindre resulterade idogt arbete av polis och åklagare i 62 000 domslut förra året. Av dessa medförde dock endast 10 900 fängelse, och det genomsnittliga fängelsestraffet var 11 månader.<sup>7</sup> Antalet domslut med fängelse och straffens längd behöver öka kraftigt.</p>
<blockquote><p>Varje brottsaktiv individ som kan fängslas innebär således en ekonomisk besparing, utöver minskat mänskligt lidande.</p></blockquote>
<p>Varje fängelsedygn är förvisso kostsamt, men det är ingen naturlag att Sverige ska ha världens dyraste fängelsesystem.<sup>8</sup> Det borde vara fullt möjligt att mer än halvera kostnaderna, till samma nivå som exempelvis Tyskland. Dessutom är det viktigt att komma ihåg att en fängelseplats syns i statsbudgeten, men samhällsbesparingen som uteblivna brott utgör är en osynlig pluspost. En nationalekonomisk beräkning har visat att varje gängkriminell under en 15-årsperiod kostar uppskattningsvis 23 miljoner kronor.<sup>9</sup> Det senare motsvarar kostnaden för fängelse i 20 år.</p>
<p>Varje brottsaktiv individ som kan fängslas innebär således en ekonomisk besparing, utöver minskat mänskligt lidande.</p>
<p>Sarneckis artikel i Kvartal inleds med att påminna läsaren om förekomsten av rån av värdetransporter och banker på 1990-talet. Sarnecki skriver att många av dessa dåd var ”mycket brutala” och nämner det tragiska extremfallet med morden på polismännen i Malexander 1999. Denna historiska tillbakablick görs för att poängtera behov av kunskap och långsiktighet, men samtidigt relativiseras den rådande brottssituationen. Medvetet eller omedvetet ger Sarnecki läsaren intrycket av att saker och ting inte är mycket värre idag än förr.</p>
<h2>Allvaret förminskas</h2>
<p>Ett diagram i artikeln visar också att det dödliga våldet är på ungefär samma nivå i dag som i början på 1990-talet. Ett faktum Sarnecki tidigare många gånger påpekat. Denna typ av statistik – som sammanblandar olika typer av dödligt våld – är emellertid vilseledande. För att förstå dagens problem med gängkriminalitet behöver olika typer av mord särskiljas.</p>
<blockquote><p>Gangstermorden utgör en omedelbar allmänfara. Till och med 30 september i år har det inträffat 270 skjutningar.</p></blockquote>
<p>Det har blivit vanligare med kriminella som hänsynslöst skjuter varandra på gator och torg i Sverige. Samtidigt har det blivit mindre vanligt att alkoholister och narkomaner har ihjäl varandra. Likaså har det tragiska och dödliga partnervåldet minskat. Detta gör sammantaget att den totala statistiken av dödligt våld döljer ökningen av gangstermorden. (En ytterligare faktor är medicinska framsteg.)</p>
<p>Det är således inte rimligt att räkna samman dessa mordkategorier. Gangstermorden utgör en omedelbar allmänfara. Till och med 30 september i år har det inträffat 270 skjutningar. Medborgare som haft oturen att befinna sig i närheten har dödats, skadats eller skrämts. Hänsynslösheten är total vid dessa brutala våldsdåd. Denna typ av brottslighet saknar motsvarighet i jämförbara länder och motstycke i vår egen historia.</p>
<p>Förvisso har kriminella uppgörelser förekommit tidigare i Sverige, men aldrig i denna omfattning. I det stora nordiska MC-kriget mellan Hells Angels och Bandidos, som varade mel­lan 1994 och 1997, dödades tolv individer.<sup>10</sup> Det kan jämföras med över tusen skottlossningar – med ett hundratal döda – under motsvarande antal år i slutet av 2010-talet.<sup>11</sup></p>
<h2>Allt fler utsatta för brott</h2>
<p>Skottlossningarna – liksom bombattentaten – är dessutom bara den yttersta formen av ett större problem med gangstervåld. Fler kriminella är mer våldsamma, och som en följd av detta vågar färre medborgare anmäla eller vittna. Brottsligheten har blivit både grövre och mer utbredd. Brott drabbar fler och brottsligheten har totalt sett blivit mer skadlig.<sup>12</sup> Brottsförebyggande rådets undersökningar visar att allt fler i Sverige utsatts för brott de senaste åren.<sup>13</sup></p>
<blockquote><p>I en nationell kartläggning 2018 identifierades totalt 12 768 personer i olika typer av kriminella nätverk.</p></blockquote>
<p>I en radiodebatt med undertecknad i P1 förra veckan (<a href="https://sverigesradio.se/artikel/7565851">1/10 2020</a>) sa Sarnecki dessutom att ”det här problemet rör väldigt små grupper individer” samt att brotten begås av ”mycket små grupper”. Det stämmer inte. I en nationell kartläggning 2018 identifierades totalt 12 768 personer i olika typer av kriminella nätverk.<sup>14</sup> Denna siffra är dessutom lågt räknad, sett till att dessa personer i många ärenden har medmisstänkta som inte räknats med.</p>
<p>Tillkommer gör även ”svansarna”, det vill säga pojkar som aspirerar på att ingå i gängen. Dessa gangstrar är tydligt närvarande i utsatta områden och påverkar vardagen för nästan alla människor som lever där. I dessa områden bor över fem procent av Sveriges befolkning.</p>
<h2>Kultur och invandring</h2>
<p>Sarnecki skriver i sin artikel att kultur påverkar brottsligheten. Det är något som svenska kriminologer fram till nu varit notoriskt ointresserade av att vilja diskutera, åtminstone i det offentliga samtalet. Sarnecki redogör dock utan omsvep för hur subkulturer kan vara brottsalstrande på grund av normer och värderingar som avviker från majoritetskulturen.</p>
<p>I min nya bok <em>Gangstervåld</em> (Fri tanke 2020) förklarar jag detta mer ingående, hur problemet med gängkriminalitet främst beror på en gangsterkultur som uppstått i utsatta områden. Denna subkultur har blivit känd för den bredare allmänheten genom de så kallade gangsterrapparna som på senare tid fått alltmer uppmärksamhet. Det handlar om en destruktiv kultur som uppmuntrar till konflikt, kränkthet, hämnd, våld och brott. Detta i motsats till det välordnade samhällets ideal om samförstånd, tolerans, rationalitet, vänlighet, hårt arbete och laglydnad.</p>
<blockquote><p>Det förtjänar att påminnas om att det till nyligen varit kontroversiellt att påtala sambandet mellan migration och brottslighet.</p></blockquote>
<p>Sarnecki förklarar att kriminella subkulturer ofta uppstår i fattiga invandrartäta områden.<sup>15</sup> På motsvarande sätt kan gangsterkulturen i Sverige förklaras av utanförskapsområden som är en konsekvens av omfattande invandring. Inom kriminologin kallas denna typ av områden för <em>zones in transition</em> eller – på svenska – socialt desorganiserade områden.<sup>16</sup> Det är bra att dessa samband nu klargörs i den svenska debatten. Betydelsefullt var även att statsminister Stefan Löfven i SVT Aktuellt (<a href="https://www.svt.se/nyheter/inrikes/lofven-ser-sociala-spanningar">9/9 2020</a>), veckan före Sarneckis artikel, medgav kopplingen mellan brottslighet och migration – något Löfven dittills inte velat påtala.</p>
<p>Det förtjänar att påminnas om att det till nyligen varit kontroversiellt att påtala sambandet mellan migration och brottslighet. Detta resulterade inte sällan i anklagelser om rasism. Somliga har fått sina karriärer förstörda. Det intoleranta stämningsläget gällande frågan har inte minst Sarnecki själv bidragit till. Inför riksdagsvalet 2018 skrev han att det var ”skrämselpropaganda” att resonera om invandring och brottslighet (SVT Opinion, <a href="https://www.svt.se/opinion/article12024918.svt">20/1 2017</a>). Nu tycks Sarnecki ha omvärderat denna sin hållning, men utan att motivera varför.</p>
<p>Sarnecki fortsätter dock att hävda att det i grunden handlar om socioekonomiska faktorer. I P1 (<a href="https://sverigesradio.se/artikel/7565851">1/10 2020</a>) sa Sarnecki att uppkomsten av brottsalstrande subkulturer främst beror på ”socioekonomiska förhållanden”. Sarnecki har ofta framhållit inkomstskillnader och ekonomisk ojämlikhet för att förklara brottsligheten. I en debattartikel i Dagens Nyheter (<a href="https://www.dn.se/debatt/okad-invandring-leder-inte-till-okat-antal-brott/">26/8 2016</a>) skrev Sarnecki: ”Det är den relativa fattigdomen, alltså klyftan mellan de levnadsförhållanden de fattigaste (hos oss ofta, men inte alltid, invandrare) och genomsnittsbefolkningen lever under, som traditionellt har visat sig kunna förklara stora delar av skillnader i brottslighet.”</p>
<h2>Klyftor förklarar inte brottslighet</h2>
<p>Sarnecki har fel när han påstår detta, att ”klyftor” förklarar brottslighet. Det samband som kan identifieras mellan fattigdom och brottslighet handlar om korrelation, <em>inte</em> kausalitet. En svensk studie från 2013 fann att den socioekonomiska utsattheten i boendeområdet korrelerade (det vill säga samvarierade) med risk för kriminalitet. Denna effekt försvann dock helt när hänsyn togs till individspecifika egenskaper, som till exempel utbildning och familjära riskfaktorer såsom genetik.<sup>17</sup></p>
<blockquote><p>Sysselsättning och ekonomi har också utvecklats positivt i flera utanförskapsområden under 2000-talet, samtidigt som gängkriminalitet och dödligt våld har ökat.</p></blockquote>
<p>Sysselsättning och ekonomi har också utvecklats positivt i flera utanförskapsområden under 2000-talet, samtidigt som gängkriminalitet och dödligt våld har ökat. Ett exempel är Rinkeby. År 1997 hade 33 procent av invånarna i området jobb. År 2015 var motsvarande andel 50 procent.<sup>18</sup> Under samma tid har organiserad brottslighet och grovt våld ökat i området.</p>
<p>Gangstervåldet är också ett mindre problem i andra länder med större ekonomisk ojämlikhet än i Sverige, till exempel Storbritannien, Estland och Tyskland.<sup>19</sup> Det är mer än tio gånger så vanligt att män mellan 15 och 29 år mördas med skjutvapen i Sverige än i Tyskland<sup>20</sup>, trots att förbundsrepubliken har större inkomstskillnader och en mindre omfattande socialpolitik.</p>
<p>Anledningen till att en kriminell subkultur vuxit sig så stark i invandrartäta förorter och stadsdelar i Sverige är bristande integration och kulturellt utanförskap – vilket handlar om betydligt mer än arbete och ekonomi.</p>
<h2>Behovet av rättvisa</h2>
<p>Sarneckis artikel är typisk för svensk kriminologi i och med avsaknaden av brottsofferperspektiv. Ordet brottsoffer nämns inte en enda gång i den långa artikeln. Inte heller upprättelse eller rättvisa.</p>
<p>Det kan också noteras att Sarnecki skriver påföljd, inte straff. Termen straff implicerar <em>vedergällning</em> – att återställa en moralisk jämvikt genom att straffa den som begått brott och ge brottsoffer upprättelse. Det handlar om retributiv rättvisa grundad i naturrätt, något som i princip helt saknar företrädare bland svenska kriminologer. Den klassiska västerländska och individualistiska idétraditionen är likaså svag inom kriminologin, som är mer influerad av olika former av kollektivistiska perspektiv.</p>
<blockquote><p>I den bredare kriminalpolitiska debatten har etiska frågor om rätt och fel under lång tid haft en undanskymd roll.</p></blockquote>
<p>I den bredare kriminalpolitiska debatten har etiska frågor om rätt och fel under lång tid haft en undanskymd roll. Även när termen straff används åsyftas ofta en påföljd som instrument för kollektiv samhällsnytta, snarare än en ett medel för att skipa rättvisa för den enskilda människan. Debatten om straff har i Sverige mer handlat om vad som anses <em>fungera</em> än vad som är rättvist.</p>
<p>Otvivelaktigt fungerar hårdare straff, men hårdare straff behövs framför allt av <em>rättviseskäl</em>. Under alla mina år som polis har jag aldrig träffat ett brottsoffer som inte önskat att gärningsmannen får sona för sitt brott. Upprättelse är ett behov lika mänskligt som kärlek, gemenskap och respekt. Utgångspunkten för svensk kriminalpolitik bör därför i högre grad ta hänsyn till det allmänna rättsmedvetandet. Det handlar ytterst om ett demokratiskt förhållningssätt.</p>
<p>Det finns flera anledningar för Sarnecki att idka självkritik. Folkvalda gör också klokt i att selektera bland dem man lyssnar till inom detta skrå.</p>
<div class="notes-wrapper"><a class="shadow-button noselect show-notes"  data-articleid="23993">  <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>Statens institutionsstyrelse (2017). <em>Betydelse av öppenhet under in­ situationstiden för ungdomar dömda till sluten ungdomsvård. Hur påverkas vardagen vid institutionen och återfall i brott?</em> Rapport 2017:8.</li>
<li>Angrist, J. D., &amp; Pischke, J. S. (2010). The credibility revolution in empirical economics: How better research design is taking the con out of econometrics. <em>Journal of economic perspectives</em>, 24(2), 3–30</li>
<li>Se t.ex. Barbarino, A., &amp; Mastrobuoni, G. (2014). The incapacitation effect of incarceration: Evidence from several Italian collective pardons. <em>American Economic Journal: Economic Policy</em>, 6(1), 1–37.</li>
<li>Roeder, O. K., Eisen, L. B., Bowling, J., Stiglitz, J. E., &amp; Chettiar, I. M. (2015). <em>What caused the crime decline?</em> Brennancenter For Justice. Tillgänglig: https://www.brennancenter.org/our-work/research-reports/what-caused-crime-decline</li>
<li>Levitt, S. D. (2004). Understanding why crime fell in the 1990s: Four factors that explain the decline and six that do not. <em>Journal of Economic perspectives</em>, 18(1), 163–190.</li>
<li>Newburn, T. (2018). <em>Criminology: A very short introduction</em>. Oxford: Oxford University Press.</li>
<li>Brottsförebyggande rådet (2020). <em>Kriminalstatistik: Personer lagförda för brott 2019</em>. Brottsförebyggande rådets hemsida. Till­gänglig: https://www.bra.se/statistik/kriminalstatistik/personer-lagforda-for-brott.html</li>
<li>Dobbie, W., Grönqvist, H., Niknami, S., Palme, M., &amp; Priks, M. (2018). The intergenerational effects of parental incarceration (No. w24186).<em> National Bureau of Economic Research.</em></li>
<li>Lundmark-Nilsson, E &amp; Nilsson, I. (2012). <em>Vänd dem inte ryggen: socioekonomisk analys av destruktiva subkulturer</em>. Fryshuset.</li>
<li>Nylén, L. (2000). Det stora nordiska MC-kriget. I: Nordiska polisidrottsförbundet (red.),<em> Nordisk kriminalkrönika 2000</em>. Västra Frölunda: Nordiska polisidrottsförbundet.</li>
<li>Polismyndigheten (2020).<em> Sprängningar och skjutningar – polisens arbete</em>. Polismyndighetens hemsida. Tillgänglig: https://polisen.se/om-polisen/polisens-arbete/sprangningar-och-skjutningar</li>
<li>Kärrholm, F., Neyroud, P., &amp; Smaaland, J. (2020). Designing the Swedish Crime Harm Index: an Evidence-Based Strategy. <em>Cambridge Journal of Evidence-Based Policing</em> (2020).</li>
<li>Brottsförebyggande rådet (2019). <em>Nationella trygghetsundersökningen 2019.</em> Rapport 2019:11.</li>
<li>Rostami, A., Mondani, H., Carlsson, C., Sturup, J., Sarnecki, J., &amp; Edlin, C. (2018). <em>Våldsbejakande extremism och organiserad brottslighet i Sverige</em>. Institutet för framtidsstudier.</li>
<li>Cohen, A. K. (1955): <em>Delinquent Boys: The Culture of the Gang</em>. Glencoe: Free Press</li>
<li>Shaw, C. R. &amp; McKay, H. D. (1942): <em>Juvenile Delinquency and Urban Areas: A Study of Rates of Delinquents in Relation to Differential Characteristics of Local Communities in American Cities.</em> Chicago: University of Chicago Press.</li>
<li>Sariaslan, A., Långström, N., D’onofrio, B., Hallqvist, J., Franck, J., &amp; Lichtenstein, P. (2013). The impact of neighbourhood deprivation on adolescent violent criminality and substance misuse: a longi­tudinal, quasi-experimental study of the total Swedish population. <em>International journal of epidemiology</em>, 42(4), 1057–1066.</li>
<li>Örstadius (2017). <em>Lyft för utsatta områden – fler i arbete och mindre ohälsa</em>. I Dagens Nyheter, den 15 februari 2017. Tillgänglig: https://www.dn.se/nyheter/sverige/lyft-for-utsatta-omraden-fler-i-arbete-och-mindre-ohalsa/</li>
<li>Ekonomifakta (2020). <em>Ginikoefficient – internationellt</em>. Tillgäng­lig: https://www.ekonomifakta.se/Fakta/Arbetsmarknad/Loner/ Ginikoefficient&#8212;internationellt</li>
<li>Sturup, J., Rostami, A., Mondani, H., Gerell, M., Sarnecki, J., &amp; Edling, C. (2019). Increased gun violence among young males in Sweden: a Descriptive National Survey and International Compa­rison. <em>European Journal on Criminal Policy and Research</em>, 25(4), 365–378.</li>
</ol>
</div>
</div>
<div class="author-byline">Fredrik Kärrholm är kriminolog, författare och tidigare polis.
</div>
</div>
