Av Ola Wong | 3 juni 2023
I korthet
På Konstakademiens vägg i Stockholm står ett citat av den tjeckiske filosofen Vilém Flusser.
”Den som frågar efter vårt förflutna borde alltså framför allt gräva bland fabriksruiner. Den som frågar efter vår samtid, den borde framför allt kritisera de samtida fabrikerna. Och den som framkastar frågan om vår framtid, den frågar också efter framtidens fabrik.”
<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-97593"      class = "kv-pod-holder kv-player-light  lplo " data-sid="" data-eid="" data-pid="97593" data-acurl="aHR0cHM6Ly9tZWRpYS5wb2Quc3BhY2UvaW5sYXN0YXRleHRlci9mcmFtdGlkZW5faGFuZGxhcl9vbV90aWxsdmVya25pbmcubXAz" data-psurl="aHR0cHM6Ly9tZWRpYS5wb2Quc3BhY2Uva2p4ajYzeWRkZXEydmgvZnJhbXRpZGVuLWhhbmRsYXItb20tdGlsbHZlcmtuaW5nLm1wMw==">  <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: "><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%2Fframtiden-handlar-om-tillverkning%2F&amp;t=Framtiden+handlar+om+tillverkning"    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=Framtiden+handlar+om+tillverkning+-+https%3A%2F%2Fkvartal.se%2Fartiklar%2Fframtiden-handlar-om-tillverkning%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%2Fframtiden-handlar-om-tillverkning%2F"    target = "_blank"    class  = "li-link"    title  = "Dela på LinkedIn"><i class="ti-linkedin ui transparent"></i></a><a href    = "mailto:?subject=Framtiden handlar om tillverkning&body=https://kvartal.se/artiklar/framtiden-handlar-om-tillverkning/"   target  = "_blank"    class   = "pr-link"    title   = "E-posta"    onclick = ""><i class="ti-email ui transparent"></i></a><a href    = "https://kvartal.se/skriv-ut/97593/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/97593/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/2022/03/DSC_1185-1-scaled-e1646149873242.jpg');"></div><img class="author-print-img" src="https://kvartal.se/wp-content/uploads/2022/03/DSC_1185-1-scaled-e1646149873242.jpg" style="display: none;">    </div>    <div class="by-disclaimer-holder" style="color: #8a3a67">Av <a href="https://kvartal.se/medverkande/ola-wong/">Ola&nbsp;Wong</a> | 3 juni 2023<div class="author-desc">Ola Wong är Kvartals kulturredaktör, Kina-kännare och fö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%2Fframtiden-handlar-om-tillverkning%2F&amp;t=Framtiden+handlar+om+tillverkning"    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=Framtiden+handlar+om+tillverkning+-+https%3A%2F%2Fkvartal.se%2Fartiklar%2Fframtiden-handlar-om-tillverkning%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%2Fframtiden-handlar-om-tillverkning%2F"    target = "_blank"    class  = "li-link"    title  = "Dela på LinkedIn"><i class="ti-linkedin ui transparent"></i></a><a href    = "mailto:?subject=Framtiden handlar om tillverkning&body=https://kvartal.se/artiklar/framtiden-handlar-om-tillverkning/"   target  = "_blank"    class   = "pr-link"    title   = "E-posta"    onclick = ""><i class="ti-email ui transparent"></i></a><a href    = "https://kvartal.se/skriv-ut/97593/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/97593/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/framtiden-handlar-om-tillverkning/?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/97593"    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-97593">  <div class="in-short-inner">    <span class="close_button close-in-short in-short-toggle" data-articleid = "97593"></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 ">På Konstakademiens vägg i Stockholm står ett citat av den tjeckiske filosofen <strong>Vilém Flusser</strong>.</p>
<p><em>”Den som frågar efter vårt förflutna borde alltså framför allt gräva bland fabriksruiner. Den som frågar efter vår samtid, den borde framför allt kritisera de samtida fabrikerna. Och den som framkastar frågan om vår framtid, den frågar också efter framtidens fabrik.”</em></p>
</div>
<div class="rest-of-article ">
<p>Vid en första läsning kan citatet framstå som banalt, men det förmedlar en djup insikt. Jag är på vännerna i designduon Folkforms utställning <em>Den sista Masoniteskivan</em>.<sup>1</sup></p>
<p>Utställningen visar möbler som de producerat av de sista masonitskivorna som blev kvar innan fabriken i Rundvik monterades ner och skickades till Asien. Bredvid hänger fotografen <strong>Magnus Laupas</strong> bilder från fabriksruinerna, en patetiskt trotsig lapp: ”Vi flytt int”. För visst flyttade den. Och det är så vi lärt oss att det ska vara: gammal industri försvinner i solnedgången medan Sverige bemästrar framtidens teknologier. Globaliseringen gör att alla kan koncentrera sig på sina egna komparativa fördelar och lägga ut resten på omvärlden, i Europas fall betydde det att tillverkning flyttade till länder som Kina medan vi behöll det vi trodde var de saftigaste delarna: forskning och utveckling i produktcykelns början och fluffet på slutet, <em>branding</em>.</p>
<blockquote><p>Det enda problemet är att det är ett helvete att försöka tyda robotens kinesiska manual, berättar David.</p></blockquote>
<p>På utställningen träffar jag på en annan bekant, <strong>David Eriksson</strong>, grundare av hipstertechbolaget Teenage engineering som gör bärbara synthar och högtalare. Tidigare hade de större delen av sin tillverkning i Kina och Malaysia, men under senare år har de satt upp produktionslinor i Spanien och Tjeckien. Kostnadsläget är jämförbart numera genom automatisering. Robotarna har de köpt i Kina eller utvecklat själva från grunden. Det enda problemet är att det är ett helvete att försöka tyda robotens kinesiska manual, berättar David.</p>
<p>Han hade kunnat köpa en robot av ett europeiskt bolag, men då hade den kostat tre gånger så mycket och den skulle fortfarande vara gjord av komponenter från Kina. Peking siktar på att bli världsledande i robotteknologi till 2025 och satsar stenhårt på automatisering. Landet <a href="https://ifr.org/ifr-press-releases/news/china-overtakes-usa-in-robot-density">rapporteras</a> ha gått om Sverige räknat i industrirobotar per anställd i produktionen. David berättar att han har försökt att tillverka i Sverige men gett upp, det finns varken vilja eller kunskap här, menar han.</p>
<figure id="attachment_97609" aria-describedby="caption-attachment-97609" style="width: 1519px" class="wp-caption alignnone"><img fetchpriority="high" decoding="async" class="wp-image-97609 size-full" src="https://kvartal.se/wp-content/uploads/2023/06/Skarmavbild-2023-06-02-kl.-14.06.27.png" alt="" width="1519" height="949" data-wp-pid="97609" srcset="https://kvartal.se/wp-content/uploads/2023/06/Skarmavbild-2023-06-02-kl.-14.06.27.png 1519w, https://kvartal.se/wp-content/uploads/2023/06/Skarmavbild-2023-06-02-kl.-14.06.27-600x375.png 600w, https://kvartal.se/wp-content/uploads/2023/06/Skarmavbild-2023-06-02-kl.-14.06.27-300x187.png 300w, https://kvartal.se/wp-content/uploads/2023/06/Skarmavbild-2023-06-02-kl.-14.06.27-768x480.png 768w" sizes="(max-width: 1519px) 100vw, 1519px" /><figcaption id="caption-attachment-97609" class="wp-caption-text"><em>Kina har ökat kraftigt sin andel av världsekonomin, USA har upprätthållit sin position hyfsat väl medan Europas kurva går ner. Grafik: Kunskapsverket.</em></figcaption></figure>
<p>Det var inte så här globaliseringen såldes in till oss en gång i tiden: Europa i någon form av <em>managed decline</em> och Kina som exportör av teknologi och förädlade komponenter. Vad hände egentligen?</p>
<h2>Politiken vars namn inte får nämnas</h2>
<p>För liberala ledarskribenter finns en berättelse man kan ta till när politiker får fula tankar. Den heter <em>Varvskrisen</em>, eller<em> Stålverk 80</em>. Bägge handlar om misslyckade socialdemokratiska försök att skydda och styra industrier. Dessa pedagogiska exempel används fortfarande som argument mot industripolitik, exempelvis mot Hybrit och satsning på grönt stål i Norrland. Lärdomen är att staten är usel på att välja vinnare och ett lätt offer för särintressen; framtiden är stokastisk, den går inte att förutsäga, och därför borde utveckling lämnas åt marknaden.</p>
<blockquote><p>Denna doktrin byggde på antagandet att det råder ständig fred och att inga pandemier bryter ut.</p></blockquote>
<p>Argumenten och exemplen mot industripolitik är många, goda och välkända. Särskilt för utvecklingsländer har industripolitik och skydd av egna marknader utmålats som en väg till katastrof, som när <strong>Kenneth Kaunda</strong> försökte bygga bilfabriker i Zambias djungel på 60-talet. Världsbanken varnade 1993 att riktat statsstöd till industrier generellt sett inte fungerar och avrådde från metoderna. Ämnet blev så tabu att när den internationella valutafonden IMF 2019 släppte en <a href="https://www.imf.org/en/Publications/WP/Issues/2019/03/26/The-Return-of-the-Policy-That-Shall-Not-Be-Named-Principles-of-Industrial-Policy-46710">konträr artikel </a>kallades den kort och gott: <em>The return of the policy that shall not be named. </em>I stället fick vi frihandelsdoktrinen <em>Washington consensus, </em>där Sverige i handelspolitiken åtminstone ville vara bäst i klassen, vi blev frihandelstalibanerna i norr.</p>
<p>Denna doktrin byggde på antagandet att det råder ständig fred och att inga pandemier bryter ut.</p>
<p>Men det har hela tiden funnits en annan sida, med framgångsexempel som inte fått lika mycket uppmärksamhet, eller viftats bort som irrelevanta undantag – även om de skett inpå knuten, som Norges statligt framstyrda oljeserviceindustri.<sup>2</sup></p>
<p>Frihandelsdoktrinen sade att om länder som Kina i strid mot bättre vetande väljer att subventionera sina industrier och dumpa priser borde vi snarare tacka och ta emot de billiga varorna i stället för att kämpa emot.</p>
<h2>Metoden: Dumpa, döda marknaden och ta över</h2>
<p>Ta solpaneler som exempel. Tekniken utvecklades i USA som en del av landets rymdprogram och användes på Apollo 11:s resa till månen. Ordet <em>moonshot</em> används idag för våldsamt ambitiösa satsningar där staten spelar en styrande roll för att skapa nya industrier och hjälpa inhemska firmor att växa bortom landets nuvarande komparativa fördelar.</p>
<p>2010 beslutade Kina att solenergi är en<a href="https://ucigcc.org/wp-content/uploads/2022/06/Naughton2021_Industrial_Policy_in_China_CECHIMEX-All.pdf"> strategisk ny industri</a> tillsammans med områden som elbilar och nästa generationens IT.</p>
<p>Man hade redan upprättat <a href="https://www.itu.int/en/ITU-D/Cybersecurity/Documents/National_Strategies_Repository/China_2006.pdf">en detaljerad plan</a> för att begränsa Kinas behov av importerad teknologi och komma ikapp omvärlden i det man kallade ”strategiska framväxande sektorer”. Peking öppnade dammluckorna för en flod av subventioner, alldeles för många kinesiska entreprenörer flockades till solguldet. Det blev en bubbla, det blev överproduktion, det blev en våldsam konkurrens och utslagning, så långt stämde doktrinen, men solpaneler blev det. Så många att den europeiska liksom den amerikanska solpanelsindustrin slogs ut.</p>
<p>2013 införde EU <a href="https://ec.europa.eu/commission/presscorner/detail/en/IP_13_501">antidumpningsåtgärder</a>, trots motstånd från svenskt håll, men strafftullarna sattes mycket lägre än de 88 procent under marknadspris som Kina sålde solpaneler för. EU hoppades att det skulle leda till ”konstruktiva samtal” med Peking och rädda Europas innovativa bolag med 25 000 jobb inom sektorn.</p>
<p>Tio år senare dominerar Kina varje del av värdekedjan, från råvara till slutprodukt och står för 97 procent av världsproduktionen. De kinesiska bolag som överlevde gör inte bara de billigaste utan även de mest effektiva produkterna och kammar hem <a href="https://www.solarbeglobal.com/chinese-solar-enterprises-create-trillion-worth-solar-market/">miljardvinster</a>.</p>
<p>Kina har även den mest högciterade forskningen på solceller.</p>
<p>Kanske var resultatet ändå bra för Europa? Vi fick billig fossilfri energi medan Kina fick utsläpp och bortslösade skattepengar.</p>
<p>Men problemet är att Kina använt samma metod på område efter område: man dumpar, dödar marknader och tar över, samtidigt som man skyddar sina egna bolag. Det sker både i gamla smutsiga industrier och i nya teknologier som driver de globala megatrenderna grön omställning och digital samhällsomvandling. Den tidiga satsningen på elbilar har nu gjort att Kina gått om Japan som världens största bilexportör.</p>
<h2>Kinas processkunskap: handen och hjärnans styrka</h2>
<p>En av dem som skriver mest intressant om Kinas industri heter <strong>Dan Wang</strong>, och han utvecklar sina tankar i artikeln <em>China’s hidden tech revolution, </em>publicerad i tidskriften Foreign Affairs.</p>
<p>Wang menar att Kinas spektakulära framväxt inom avancerad teknologi beror i grunden på en otrolig kapacitet på att producera saker. Genombrott sker genom praktisk kunskap om tillverkning av avancerade produkter, man kan kalla det processkunskap. Detta har drivits av  landets gigantiska och skickliga arbetskraft i tillverkningsindustrin, som drar nytta av täta kluster av leverantörer och omfattande statsstöd.</p>
<p>Mellan 1998 och 2018 fick Ericssons främsta konkurrent Huawei motsvarande <a href="https://www.wsj.com/articles/state-support-helped-fuel-huaweis-global-rise-11577280736">75 miljarder dollar i statsstöd</a> – subventioner som utformades för att bjuda under och besegra konkurrenter. Det var i strid med Kinas löften till världshandelsorganisationen WTO. När Sverige till slut blockerade Huawei från 5G-utbyggnad av säkerhetsskäl reagerade Ericsson-chefen<a href="https://www.dn.se/ekonomi/sms-avslojar-ericssons-vd-pressade-regeringen-att-radda-huawei/"> <strong>Börje Ekholm</strong></a> genom att hota med att lämna landet om inte regeringen grep in och ändrade beslutet till Huaweis fördel. Det faktum att så många företag i Väst tjänar pengar på att göra affärer med Kina ger Kommunistpartiet starka lobbygrupper inom näringslivet.<sup>3</sup></p>
<h2>En tech-koloni är inte fri</h2>
<p>Kontroll över ny teknologi leder till teknologiska intressesfärer<em>.</em> Teknologiskt inflytande leder till geostrategiskt inflytande när länder och bolag som är beroende av Kina går partiets ärenden. Teknologi vinner krig. Under pandemin blev det tydligt att Europa och USA i en nödsituation inte ens klarar att producera enkla varor som skyddsutrustning åt sig själva och det uppstod halvledarbrist.</p>
<figure id="attachment_97610" aria-describedby="caption-attachment-97610" style="width: 1920px" class="wp-caption alignnone"><img decoding="async" class="wp-image-97610 size-full" src="https://kvartal.se/wp-content/uploads/2023/06/Folkform_Rundvik_2019_24.jpg" alt="" width="1920" height="1547" data-wp-pid="97610" srcset="https://kvartal.se/wp-content/uploads/2023/06/Folkform_Rundvik_2019_24.jpg 1920w, https://kvartal.se/wp-content/uploads/2023/06/Folkform_Rundvik_2019_24-1536x1238.jpg 1536w, https://kvartal.se/wp-content/uploads/2023/06/Folkform_Rundvik_2019_24-600x483.jpg 600w, https://kvartal.se/wp-content/uploads/2023/06/Folkform_Rundvik_2019_24-300x242.jpg 300w, https://kvartal.se/wp-content/uploads/2023/06/Folkform_Rundvik_2019_24-768x619.jpg 768w" sizes="(max-width: 1920px) 100vw, 1920px" /><figcaption id="caption-attachment-97610" class="wp-caption-text"><em>Europeisk industriolycka. Masonitefabriken i Rundvik.</em> <em>Foto: Magnus Laupa, ur boken Produktionsnoveller.</em></figcaption></figure>
<p>Och det är därför vi ser hur Väst svänger om frihandeln, ett skifte som började under president Trump. Han inledde sin presidenttid med att fördöma ”andra länder som gör våra produkter, stjäl våra bolag och förstör våra jobb”. Trumps<em> America first policy </em>utvecklades till en mer sofistikerad <em>National strategy for critical and emerging technologies</em> från oktober 2020. Det arbetet har fortsatt under Biden med hans <em>Build back better framework</em>, med subventioner till inhemsk produktion och exportkontroller för att trycka tillbaka Kina inom kritiskt avgörande teknikområden.</p>
<p>Europa ligger några år efter USA, <a href="https://www.wsj.com/articles/ai-china-to-dominate-u-s-europe-talks-802316cd">sade </a>statsminister<strong> Ulf Kristersson</strong> i samband med tekniktoppmötet mellan USA och EU som hölls i Luleå i veckan. Men Europa har på kort tid fått fram stora lagpaket som Akten om kritiska råvaror, Halvledarakten, EU:s planerade investeringsfond och det kommande förslaget på ny ekonomisk säkerhetspolitik, med bland annat exportrestriktioner. I Bryssel pågår en frenetisk produktion av färdplaner, strategier och agendor för innovation och europeisk industri. Utrikespolitiska institutet UI har i dagarna gett ut rapporten <a href="https://www.ui.se/butiken/uis-publikationer/ui-report/2023/controlling-critical-technology-in-an-age-of-geo-economics-actors-tools-and-scenarios/"><em>Controlling critical technology in an age of geoeconomics</em></a>, som ger en läsvärd genomgång i frågan.</p>
<p>Men det är också tydligt att Europa är splittrat om Kina medan det finns en samsyn i USA, varken demokrater eller republikaner lär återvända till frihandeln. Frankrikes <strong>Emmanuel Macron</strong> har understrukit betydelsen av strategisk autonomi för Europa vad gäller skydd av kritiskt avgörande teknologier. Men han har mött motstånd från frihandelsvänner, med länder som Sverige, Danmark och Tyskland, kända som ”<em>Stockholm eight</em>”. Samtidigt går Peking till motangrepp mot talet om <em>de-risking</em>. Kinesiska tjänstemän <a href="https://www.gmfus.org/news/watching-china-europe-may-2023">har varnat</a> sina europeiska kollegor för att närma sig USA. De uppges ha hotat att hindra exporten av teknologi för tillverkning av solenergi till Europa om EU går vidare med sina planer på exportkontroller av känslig teknologi.</p>
<h2>Taiwan: från grönsaker till halvledare</h2>
<p>Halvledare är ett typexempel på teknologi där Europa halkat långt efter och där man ser ett stort behov att motverka sårbara beroenden av utländska aktörer. Halvledare behövs för i stort sett alla våra apparater, från Iphone till avancerad sjukvård.</p>
<p>Idag producerar Taiwan över 90 procent av den mest avancerade typen av halvledare. Om de fabrikerna går upp i rök så golvas världsekonomin.</p>
<p>Man kallar det Taiwans ”kiselsköld”, som ska fungera som en typ av självmordsbälte som man hoppas ska avskräcka Kinas <strong>Xi Jinping</strong> från att invadera (och tvinga USA att hjälpa Taiwan ifall det sker).</p>
<p>Sverige är nu ordförandeland i EU och i april <a href="https://www.consilium.europa.eu/sv/press/press-releases/2023/04/18/chips-act-council-and-european-parliament-strike-provisional-deal/">presenterade energiminister <strong>Ebba Busch</strong> </a>vad hon kallar ”en verklig revolution för Europa”: en preliminär överenskommelse med EU-parlamentet om Halvledarakten, som siktar på att frigöra 43 miljarder euro i investeringar genom offentlig-privat partnerskap och dubbla blockets produktion av halvledare till 2030. Bryssel har lättat på reglerna mot statsstöd – medlemsstaterna kan nu, under vissa villkor, pumpa in statliga pengar för att anlägga fabriker. För att planen ska lyckas vill man locka ledande tillverkare, och då främst branschdominanten Taiwan Semiconductor Manufacturing Company (TSMC).</p>
<p>Men hur kommer det sig att vi har blivit totalt beroende av Taiwan?</p>
<p>År 1970 var Taiwans främsta komparativa fördel grönsaksodling. Bananer var den traditionella exportprodukten och någon elektronikindustri existerade inte. Enligt frihandelsdoktrinen borde Taiwan fortsatt med grönsaker och enkel tillverkning, inte något galet <em>moonshot. </em>Spola fram 20 år, till 1990, och grönsaker har försvunnit från handelsstatistiken medan elektronikindustrin dominerar. Taiwans regering lobbade USA:s halvledarbolag att ta emot landets forskare för att träna dem i tillverkningsprocessen, och man rekryterade <strong>Morris Chang</strong> från Intel, som åkte till Taiwan och byggde upp TSMC.</p>
<blockquote><p>Industripolitiken har inte bara skapat tillväxt och jobb åt Taiwan utan även säkerhet</p></blockquote>
<p>Staten var bolagets stora investerare redan från början och det hade inte existerat annars, mejlar <strong>Chris Miller</strong>, som har skrivit boken <em>Chip war – the fight for the world’s most critical technology</em>. Sedan dess har myndigheterna hjälpt industrin genom mer ortodox ekonomisk politik: skattelättnader, varsam reglering och en utbildningspolitik som ger en stadig ström av välutbildad ny arbetskraft.</p>
<p>Om Kina sätter Taiwan i blockad, vilket man övade på när USA:s dåvarande talman <strong>Nancy Pelosi</strong> besökte ön förra året, skulle det leda till omedelbar chockverkan på världsekonomin. Enligt en studie av Rhodium Group skulle det lågt räknat leda till störningar motsvarande 2000 miljarder dollar, och då räknar man inte in kostnader för internationella motåtgärder och andra sidoeffekter.</p>
<p>Industripolitiken har inte bara skapat tillväxt och jobb åt Taiwan utan även säkerhet och blivit en faktor för att Taiwan existerar som en i praktiken fri och självständig demokrati.</p>
<p>Den neoliberala fientligheten mot statlig inblandning är mer ideologiskt än empiriskt motiverad, skriver statsvetaren och nationalekonomen <strong>Francis Fukuyama</strong> i sin bok <em>Missnöjets tid: den liberala erans slut</em>.<sup>4</sup></p>
<p>Asiens ekonomiska mirakel, Sydkorea, Taiwan, Hongkong och Singapore liksom Japan och Tyskland före dem kännetecknas av en öppenhet inför handel genom export och hård konkurrens, men också en statlig industripolitik<em>.</em> Vägen till att bli rik och komma ikapp teknologiskt har gått genom en långsiktig satsning på inhemsk produktion av sofistikerade produkter.</p>
<h2>Tillverkning eller <em>managed decline</em></h2>
<p>Dan Wang menar att om man på allvar vill konkurrera med Kina om nya teknologier måste man lära sig att mobilisera arbetskraft och skapa industriella ekosystem för att kunna skala upp innovationer och bygga produkter bättre och mer effektivt. Som en ideologisk utgångspunkt behöver en ny industripolitik fokusera på arbetskraften och processkunskap snarare än vinstmarginaler.</p>
<p>Men nedvärderingen av tillverkning har gett Väst en dålig startposition.</p>
<p>Europas åldrande och dyra arbetskraft kan inte ersätta Kina eller konkurrera ut låglöneländer.</p>
<p>Vi ser inte slutet på globaliseringen, däremot verkar trenden gå mot en omdirigering av resurser till mindre riskabla platser: mer <em>friend-shoring</em>, och mer gemensamma satsningar från näringsliv och stat.</p>
<p>Kina har ett försprång på många sektorer som kan verka ointagligt. Den lättaste utvägen kommer alltid att vara fortsatt <em>managed decline. </em>Men tänk på hur Taiwans politiker måste ha känt det när de tittade på sina egna bananodlingar och jämförde med dåtidens USA?</p>
<p>Flusser hade rätt, frågan om vår framtid handlar om vad som är framtidens fabrik.</p>
<div class="notes-wrapper"><a class="shadow-button noselect show-notes"  data-articleid="97593">  <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>
<p>1, Utställningen visades april månad på Konstakademin i Stockholm. Den har blivit en del av formgivaren Anna Holmquists doktorsavhandling och har getts ut som bok <em>Produktionsnoveller</em> (Holmquist, 2023).</p>
<p>2, Norge använde aggressiv politik för att främja tillväxt i sin oljeserviceindustri från 1970- till mitten av 1990-talet. Resultatet blev att en ny högteknologisk och framgångsrik industri växte fram. Oljebolag ålades att gynna lokala firmor i sina upphandlingar och lagar infördes som tvingade oljebolag att utföra hälften av sin forskning och utveckling i Norge. Politiken kännetecknades av uthållighet, den varade i årtionden, och risktagande, fokus på teknologisk utveckling och uppmuntran av konkurrens på inhemska och internationella marknader. Se IMF Working paper: <em>The return of the policy that shall not be named</em>, sid 39 (Cherif, Hasanov, 2019).</p>
<p>3, Detta är ett citat från <em>Den dolda handen: hur Kinas kommunistiska parti underminerar västliga demokratier och omformar världen</em>, (Hamilton, Ohlberg 2021), sid 38: ”Det faktum att så många företag i Väst tjänar pengar på att göra affärer med Kina, eller hoppas på att göra det, ger KKP starka lobbygrupper inom näringslivet. Oftast räcker det med några diskreta antydningar från kinesiska tjänstemän om, hur väl en relation för att miljardärer och företagsgrupper ska sätta press på sina regeringar att inte stöta sig med Peking, denna taktik är känd som <em>yi shang bi zheng</em>, affärer som påtryckningsmedel mot regeringar.”</p>
<p>4, <em>Missnöjets tid – den liberala erans slut </em>(Fukuyama, 2022) sid 50.</p>
<p>&nbsp;</p>
</div>
</div>
<div class="author-byline">Ola Wong är Kvartals kulturredaktör, Kina-kännare och författare.
</div>
</div>
