Vad är Carthage och hur kan det optimera apputvecklingen?

Carthage är en beroendehanterare för iOS- och macOS-projekt som låter utvecklare integrera tredjepartsbibliotek i sina applikationer på ett enkelt och effektivt sätt. Till skillnad från andra verktyg som CocoaPods fokuserar Carthage på att vara minimalistiskt och icke-invasivt, vilket innebär att det inte ändrar projektets struktur och bara kräver en enkel textfil, en Cartfile, som listar beroendena. Det har gjort det till ett populärt val bland utvecklare som vill behålla kontrollen över sin projektuppsättning och samtidigt dra nytta av tredjepartsbibliotek och ramverk.

Carthage fungerar genom att bygga binära ramverk, som sedan kan integreras direkt i Xcode-projekt. Arbetssättet innebär att utvecklare kan dra nytta av snabbare byggtider och en mer strömlinjeformad utvecklingsprocess. Med Carthage kan beroenden enkelt läggas till, uppdateras och hanteras utan komplexa konfigurationsfiler eller oönskade ändringar i projektet. I gengäld läggs de byggda ramverken till i Xcode manuellt. Det gör Carthage till ett bra verktyg för den som vill ha en enkel men kraftfull lösning för beroendehantering i sina utvecklingsprojekt för iOS och macOS.

Carthage är en decentraliserad beroendehanterare för iOS- och macOS-projekt. Den hämtar och bygger tredjepartsbibliotek som ramverk, som utvecklaren sedan själv lägger till i sitt Xcode-projekt, utan att projektfilen ändras automatiskt. Det ger full kontroll över projektets struktur och kan ge snabbare byggtider, eftersom beroendena bara byggs när de uppdateras. Carthage används främst som ett enklare alternativ till CocoaPods, medan Swift Package Manager är Apples inbyggda lösning för pakethantering.

Mer om Carthage

Carthage är en beroendehanterare för iOS och macOS som erbjuder ett enkelt och flexibelt sätt att integrera tredjepartsbibliotek i projekt. Till skillnad från andra verktyg som ändrar projektuppsättningen automatiskt fokuserar Carthage på minimal uppsättning och ger utvecklare frihet att hantera sina projekt utan onödiga begränsningar.

Tekniskt fungerar Carthage genom att bygga binära ramverk från källkod, eller ladda ned färdigbyggda, vilket låter utvecklare inkludera dessa ramverk direkt i sina Xcode-projekt. Det innebär att Carthage inte ändrar projektfilerna utan i stället genererar en mapp, ”Carthage/Build”, där de kompilerade ramverken lagras. Arbetssättet ger utvecklare full kontroll över sin projektstruktur och sina beroenden.

Carthage stöder tre primära funktioner, som var och en erbjuder ett eget sätt att hantera beroenden:

  1. Bygga beroenden: Carthage kan automatiskt bygga alla beroenden som anges i en ”Cartfile”. Det låter utvecklare fokusera på sin egen kod medan Carthage sköter kompileringen av externa bibliotek. Funktionen är idealisk för projekt som kräver flera tredjepartsbibliotek.

  2. Uppdatera beroenden: Med ett enda kommando kan Carthage uppdatera alla beroenden till de nyaste versioner som uppfyller versionskraven i Cartfile. Det gör det enkelt att hålla biblioteken uppdaterade, inklusive säkerhetsrättningar, vilket är viktigt för att upprätthålla kompatibilitet och säkerhet.

  3. Integrera ramverk: Carthage genererar ramverk som utvecklaren själv lägger till i Xcode-projektet, typiskt under ”Frameworks, Libraries, and Embedded Content”. Det kräver ett manuellt steg men ger full insyn i exakt vilka bibliotek som ingår i projektet och gör det enkelt att dra nytta av nya funktioner och förbättringar i tredjepartsbibliotek.

En av de största styrkorna med Carthage är enkelheten och flexibiliteten. Genom att undvika automatiska projektändringar låter Carthage utvecklare behålla kontrollen över sina projekt. Det minskar risken för konflikter i projektfilen och gör det lättare att integrera nya beroenden utan att störa befintliga projektstrukturer.

Carthages förhållningssätt till beroendehantering sparar också tid i det dagliga arbetet. Genom att bara bygga beroenden när de läggs till eller uppdateras, och undvika onödiga projektändringar, minimerar Carthage den tid och de resurser som krävs för att underhålla ett projekt. Det gör det till ett bra verktyg för utvecklare som vill optimera sina arbetsflöden och fokusera på att leverera mjukvara av hög kvalitet.

I praktiken har Carthage haft en betydande inverkan på hur utvecklare hanterar beroenden i iOS- och macOS-projekt. Det har använts av både små och stora utvecklingsteam för att hålla sina projekt uppdaterade, säkra och lätta att underhålla. I dag har dock utvecklingen av Carthage avtagit betydligt, och de flesta bibliotek riktar sig nu i första hand till Swift Package Manager.

Sammanfattningsvis är Carthage ett verktyg som förenar enkelhet, flexibilitet och effektivitet i en lösning som gör beroendehanteringen mer transparent för både enskilda utvecklare och stora team. Den enkla uppsättningen och de minimala ingreppen i projektstrukturen har gjort det till ett användbart verktyg i apputveckling, där snabba och säkra integrationer är nödvändiga.

Vanliga frågor om Carthage

Vad är Carthage och hur fungerar det i praktiken?

Carthage är en decentraliserad beroendehanterare för iOS-, macOS-, tvOS- och watchOS-projekt skrivna i Swift och Objective-C. Det finns inget centralt paketregister. I stället pekar varje beroende direkt på ett Git-förråd, typiskt på GitHub.

Beroendena anges i en textfil med namnet Cartfile i projektets rotmapp. När kommandot carthage update körs hittar Carthage lämpliga versioner, hämtar källkoden till mappen Carthage/Checkouts och bygger varje bibliotek med Xcodes egna byggverktyg. De färdiga ramverken placeras i Carthage/Build.

Carthage ändrar inte Xcode-projektfilen. Utvecklaren lägger till de byggda ramverken under Frameworks, Libraries, and Embedded Content i det aktuella targetet. Det ger full kontroll över projektuppsättningen men kräver lite mer manuellt arbete än verktyg som integrerar automatiskt.

Hur installeras Carthage och hur läggs ett bibliotek till?

Carthage installeras oftast med Homebrew med kommandot brew install carthage. Alternativt kan ett installationspaket laddas ned från projektets releaser på GitHub.

Ett bibliotek läggs typiskt till i fyra steg:

  • Filen Cartfile skapas i projektets rotmapp med en rad som github "Alamofire/Alamofire" ~> 5.0.
  • Kommandot carthage update --use-xcframeworks --platform iOS hämtar och bygger biblioteket.
  • Det färdiga .xcframework från Carthage/Build dras in i Frameworks, Libraries, and Embedded Content i appens target.
  • För dynamiska ramverk väljs Embed & Sign.

Operatorn ~> innebär att nyare versioner godtas så länge huvudversionen är densamma. Biblioteket kan sedan användas i koden med import Alamofire.

Vad är skillnaden mellan Cartfile och Cartfile.resolved?

Cartfile beskriver vilka beroenden projektet behöver och vilka versionskrav de måste uppfylla, t.ex. ~> 5.0, >= 2.1 eller en specifik gren. Filen redigeras manuellt och uttrycker avsikten.

Cartfile.resolved genereras automatiskt och innehåller de exakta versioner eller commits som faktiskt valdes, även för beroendenas egna beroenden. Filen fungerar som ett lås, så att alla i ett team och varje byggserver får exakt samma kod.

Skillnaden syns i kommandona:

  • carthage update hittar de nyaste versioner som matchar Cartfile och skriver resultatet till Cartfile.resolved.
  • carthage bootstrap hämtar och bygger exakt de versioner som anges i Cartfile.resolved.

Båda filerna bör därför hållas i versionshanteringen. Beroenden som bara används under utvecklingen, som testbibliotek, kan placeras i Cartfile.private.

Hur bygger Carthage XCFrameworks och varför spelar det roll?

Tidigare byggde Carthage så kallade fat frameworks, där koden för fysiska enheter och simulatorn kombinerades till en fil med verktyget lipo. Det slutade fungera med Xcode 12, eftersom både enheter och simulatorer på Apple Silicon använder arkitekturen arm64, och samma arkitektur kan inte förekomma två gånger i ett fat framework.

Lösningen är XCFrameworks, som Apple introducerade med Xcode 11. Ett XCFramework är ett paket med en separat binär för varje plattform och variant, som iOS-enhet och iOS-simulator. Från Carthage 0.37 byggs XCFrameworks med flaggan --use-xcframeworks, t.ex. carthage bootstrap --use-xcframeworks.

Resultatet placeras som .xcframework-mappar i Carthage/Build. De läggs till direkt i appens target, och den tidigare byggfasen med carthage copy-frameworks behövs inte längre.

Vad är skillnaden mellan Carthage, CocoaPods och Swift Package Manager?

De tre verktygen löser samma uppgift, men på olika sätt:

  • Carthage är decentraliserat och hämtar beroenden direkt från de Git-förråd som anges i en Cartfile. Biblioteken byggs som binära ramverk, och Xcode-projektet ändras inte. Integrationen görs manuellt.
  • CocoaPods använder ett centralt biblioteksregister och en Podfile. Kommandot pod install skapar en arbetsyta och ändrar projektuppsättningen, så integrationen sker automatiskt men är mindre transparent. CocoaPods befinner sig nu i underhållsläge.
  • Swift Package Manager (SPM) är Apples eget verktyg och är inbyggt i Xcode. Paket läggs till direkt i Xcode eller beskrivs i en Package.swift, och ingen extra installation krävs.

Carthage är användbart när full kontroll över projektfilen och kortare byggtider önskas, eftersom beroendena bara byggs när de uppdateras. För nya projekt är SPM nu det mest använda valet, eftersom de flesta bibliotek stöder det.

Hur kan byggtiderna med Carthage hållas nere?

Eftersom Carthage som standard bygger beroenden från källkod kan det första bygget ta lång tid. Flera alternativ kan minska tiden:

  • --platform iOS begränsar bygget till de plattformar som projektet faktiskt använder.
  • --cache-builds hoppar över beroenden som redan har byggts i samma version, så att bara ändrade bibliotek byggs om.
  • Enskilda beroenden kan uppdateras separat, t.ex. med carthage update Alamofire, i stället för att alla uppdateras.
  • Många bibliotek tillhandahåller färdigbyggda ramverk i sina GitHub-releaser, som Carthage laddar ned automatiskt. SDK:er med sluten källkod kan anges med binary och en URL till en JSON-specifikation.

På byggservrar kan mappen Carthage/Build också cachas mellan körningar. Många team håller mappen utanför Git via .gitignore och återskapar den med carthage bootstrap.

Carthage för dummies

Carthage är ett verktyg som hjälper till att organisera och hantera de små byggstenar som appar består av, så kallade ”beroenden”. Föreställ dig att du bygger en app som behöver några färdiga delar som andra redan har skapat för att den ska fungera bättre. Carthage hjälper till att hämta och hålla reda på dessa delar, så att de inte behöver göras från grunden. Det fungerar lite som en bibliotekarie som håller reda på alla böcker som behövs till ett projekt, så att författaren kan fokusera på sin egen berättelse. Det gör det enklare och snabbare att utveckla appar, eftersom andras arbete kan återanvändas samtidigt som det säkerställs att allt passar ihop.

Lämna en kommentar