# Swift Package Manager (SPM) & Modulli Arxitektura Masterclass
> **Holat:** 2026-yil, Swift 6.0, Xcode 16/27. Ushbu qo'llanma zamonaviy Apple ekotizimida monolit loyihalarni yuqori unumdorlikka ega modulli SPM arxitekturasiga o'tkazish, kompilyatsiya vaqtini (Build Performance) 10x–30x tezlashtirish, Swift 6 Strict Concurrency va `package` access level imkoniyatlarini to'liq ishga solish bo'yicha dunyo miqyosidagi (Apple, Airbnb, Uber, Point-Free) eng ilg'or amaliyotlarni qamrab oladi.
---
## 1. Kirish: Nega SPM Zamonaviy iOS Loyihalarining Yagona Standartiga Aylandi?
iOS dasturlash tarixida qaramliklarni boshqarish (dependency management) 3 ta katta davrni bosib o'tdi:
1. **Manual / Git Submodules davri (2008–2011):** Har bir `.framework` yoki `.a` binar fayli loyihaga qo'lda tortib kelingan, versiya to'qnashuvlari va header search paths azob bergan.
2. **CocoaPods & Carthage davri (2011–2020):** Ruby asosidagi CocoaPods uzoq yillar hukmronlik qildi, biroq `.xcworkspace` yaratib `.xcodeproj` fayliga yashirin o'zgartirishlar kiritishi, git merge conflictlar va podfile lock muammolari jamoaviy ishlashni sekinlashtirdi.
3. **Swift Package Manager (SPM) Davri (2020–Hozir):** Apple tomonidan rasmiy taqdim etilgan, Swift kompilyatoriga to'g'ridan-to'g'ri integratsiya qilingan, deklarativ `Package.swift` manifestiga ega birinchi darajali (first-class citizen) tizim.
| Xususiyat | 🔴 CocoaPods (Eski Standart) | 🟢 Swift Package Manager (Zamonaviy Standart) |
| :--- | :--- | :--- |
| **Integratsiya** | Tashqi Ruby dependency, `pod install` buyrug'i | Swift Compiler nativ qismi, qo'shimcha toolsiz |
| **Loyiha fayli** | `.xcodeproj` va `.xcworkspace` ni o'zgartiradi (Merge conflictlar) | **0 ta** `.xcodeproj` kodi, sof deklarativ `Package.swift` |
| **Cross-Platform** | Faqat Apple OS (iOS, macOS) | iOS, macOS, watchOS, visionOS, Linux, Windows, WASM |
| **Build tizimi** | Qo'shimcha og'ir Run Scripts build phaselar | To'g'ridan-to'g'ri Swift Build / llbuild |
| **Strict Concurrency** | Swift 6 Concurrency tekshiruvi qiyin | Swift 6 to'liq integratsiya (`.enableUpcomingFeature`) |
| **Plugins & Macros** | Cheklangan | Rasmiy `BuildToolPlugin`, `CommandPlugin`, Swift Macros |
Katta jamoalarda (10+ muhandis) monolit loyihani qismlarga bo'lmaslik quyidagi falokatlarga olib keladi:
- **Build vaqtining haddan tashqari sekinligi:** Bitta UI qatlamida o'zgartirilgan 1 qator kod butun ilovaning (barcha modellar va tarmoq qatlamlarining) qayta kompilyatsiyasiga sabab bo'ladi (Clean build 8–15 daqiqa, Incremental build 1.5–3 daqiqa).
- **Merge Conflicts:** Barcha muhandislar bitta ulkan `.xcodeproj` XML fayliga o'z fayllarini qo'shadi, natijada har kuni o'nlab ziddiyatlar kelib chiqadi.
- **Arxitektura alg'ov-dalg'ovligi (Spaghetti Code):** Chegara yo'qligi sababli, Login ekrani to'satdan Checkout ekrani modellariga to'g'ridan-to'g'ri murojaat qilaveradi.
**SPM yechimi:** Loyihani toza, yo'naltirilgan asiklik grafik (DAG — Directed Acyclic Graph) ko'rinishidagi modullarga ajratish.
---
## 1.1. Nima Uchun SPM Modul Qilinadi? (Project Level & Benchmark Tahlili)
Dasturchilar ko'pincha: *"Mening loyihamga ham SPM modul kerakmi yoki monolitda qolganim ma'qulmi?"* degan savolga duch kelishadi. Modullashtirish har doim ham bepul emas (ortiqcha boshlang'ich arxitektura vaqti talab qiladi). Shuning uchun loyiha darajasini to'g'ri baholash shart:
### Real Unumdorlik Ko'rsatkichlari (Benchmarks)
Quyidagi grafik 35 ta ekranga ega haqiqiy tijoriy iOS loyihasining **Monolit `.xcodeproj`** va **SPM Modulli Arxitektura**dagi solishtirma natijalarini ko'rsatadi:
---
## 2. Swift Package Anatomiyasi va Zamonaviy Manifest (Swift 6.0)
Har qanday Swift Package uning ildizida (root) joylashgan `Package.swift` deklarativ manifesti orqali boshqariladi.
```
MyPackage/
├── Package.swift # Paket manifesti (Arxitektura rejasi)
├── Package.resolved # Lock-file (Aniq commit hash va versiyalar)
├── Sources/ # Kod targetlari
│ ├── OrderFeature/ # Implementation
│ │ ├── OrderView.swift
│ │ └── OrderViewModel.swift
│ ├── OrderFeatureInterface/ # Sof Protocollar & DTO Modellar
│ │ └── OrderServiceProtocol.swift
│ └── DesignSystem/ # Resurslar va Umumiy UI
│ ├── Resources/ # Assets.xcassets, Fonts, Strings
│ └── Components/
└── Tests/ # Izolyatsiyalangan Unit Testlar
└── OrderFeatureTests/
```
### Swift 6.0 Production Manifest Namunalari
Keling, zamonaviy barcha talablarga javob beradigan `Package.swift` manifestini ko'rib chiqamiz:
```swift
// swift-tools-version: 6.0
// Yuqoridagi izoh majburiy: Swift 6.0 kompilyator sintaksisini ishga tushiradi
import PackageDescription
let package = Package(
name: "CoreDomain",
defaultLocalization: "en", // Resurslar va mahalliylashtirish uchun
platforms: [
.iOS(.v17),
.macOS(.v14)
],
products: [
// 1. Static kutubxona (Tavsiya etiladi - launch time optimallashtirilgan)
.library(
name: "OrderFeature",
targets: ["OrderFeature"]
),
// 2. Interfeys kutubxonasi (Boshqa modullar faqat shunga ulanadi)
.library(
name: "OrderFeatureInterface",
targets: ["OrderFeatureInterface"]
),
// 3. Umumiy dizayn tizimi
.library(
name: "DesignSystem",
targets: ["DesignSystem"]
)
],
dependencies: [
// Tashqi qaramliklar aniq versiya yoki major oraliq bilan
.package(url: "https://github.com/pointfreeco/swift-dependencies.git", from: "1.4.0"),
.package(url: "https://github.com/kean/Nuke.git", .upToNextMajor(from: "12.8.0"))
],
targets: [
// ── A. INTERFEYS TARGETI (Zero Dependencies) ──
.target(
name: "OrderFeatureInterface",
dependencies: [
.product(name: "Dependencies", package: "swift-dependencies")
],
swiftSettings: [
.enableUpcomingFeature("StrictConcurrency"),
.swiftLanguageMode(.v6)
]
),
// ── B. IMPLEMENTATSIYA TARGETI ──
.target(
name: "OrderFeature",
dependencies: [
"OrderFeatureInterface", // O'z interfeysiga ulanadi
"DesignSystem",
.product(name: "NukeUI", package: "Nuke")
],
resources: [
.process("Resources") // Assets.xcassets va lokalizatsiyani jamlash
],
swiftSettings: [
.enableUpcomingFeature("StrictConcurrency"),
.swiftLanguageMode(.v6)
]
),
// ── C. DESIGN SYSTEM TARGETI ──
.target(
name: "DesignSystem",
resources: [
.process("Resources")
]
),
// ── D. IZOLYATSIYALANGAN UNIT TEST ──
.testTarget(
name: "OrderFeatureTests",
dependencies: [
"OrderFeature"
]
)
]
)
```
---
## 3. Swift 6 va Yangi `package` Access Modifier (SE-0386)
Swift 5.9 ga qadar katta modulli paketlarda arxitekturaviy ziddiyat mavjud edi:
- **`internal`:** Faqat bitta target ichida ko'rinadi. Agar paket ichida `OrderFeature` va `OrderInternalKit` alohida target bo'lsa, `internal` funksiyalarni ikkinchi target chaqira olmas edi.
- **`public`:** Barcha targetlar ko'radi, ammo butun ilovaga (tashqi mijozlarga) ham ochilib ketadi. Natijada nozik yordamchi kodlar tashqariga chiqib, inkapsulyatsiya buzilar edi.
**SE-0386 (`package` Access Modifier):** Swift 5.9 va Swift 6 da yangi `package` kalit so'zi taqdim etildi. Bu modifikator belgilangan deklaratsiyani **aynan bitta SPM paketiga tegishli barcha targetlar uchun ochiq** qiladi, ammo paketdan tashqaridagi kod (masalan, asosiy ilova yoki boshqa paketlar) uni umuman ko'rmaydi!
### Amaliy Kod Namunasi: `package` Ishlatilishi
Tasavvur qiling, bizda bitta `CoreNetwork` paketi ichida `NetworkClient` va `AuthInterceptor` targetlari bor. `AuthInterceptor` faqat tarmoq so'rovlariga yashirin token qo'shishi kerak, lekin ilova UI qatlami bu interceptorni qo'lda chaqirmasligi shart:
```swift
// Sources/AuthInterceptor/InternalTokenManager.swift
package struct InternalTokenManager: Sendable {
package let secureToken: String
// "package init" bo'lgani sababli faqat shu paket targetlari chaqira oladi
package init(secureToken: String) {
self.secureToken = secureToken
}
package func generateHeader() -> [String: String] {
return ["Authorization": "Bearer \(secureToken)"]
}
}
```
```swift
// Sources/NetworkClient/APIClient.swift
import AuthInterceptor
public final class APIClient: Sendable {
public init() {}
public func sendRequest(endpoint: String) async throws {
// Shu paket ichidagi boshqa targetdan 'package' structini bemalol chaqiramiz:
let tokenManager = InternalTokenManager(secureToken: "xyz_secret")
let headers = tokenManager.generateHeader()
// So'rov yuborish logikasi...
}
}
```
> **Eslatma:** Agar asosiy ilovada `import AuthInterceptor` qilib `InternalTokenManager()` chaqirishga urinsangiz, Swift kompilyatori xatolik beradi:
> `'InternalTokenManager' is inaccessible due to 'package' protection level.`
> Bu paket ichki tafsilotlarini 100% germetik himoya qiladi!
---
## 4. Katta Loyihalarni Modullashtirish: Interface vs Implementation Pattern
Katta iOS ilovalarida (Uber, Airbnb, Spotify) modullashtirishning eng katta xatosi — bu **gorizontal chuqur qaramliklar zanjirini** hosil qilishdir (`FeatureA -> FeatureB -> FeatureC -> Core`). Bunday holatda eng quyi qatlamdagi 1 ta o'zgarish barcha yuqori qatlamlarni qayta kompilyatsiya qilishga majbur qiladi (Cascading Invalidation).
Buning oldini olish uchun **Interface / Implementation Separation** (Interfeys va Amalga Oshirishni Ajratish) patterni qo'llaniladi.
### Arxitektura Sxemasi
### Nega bu pattern kompilyatsiyani 10x-30x tezlashtiradi?
1. `OrderFeature` savatdagi mahsulotlarni bilishi kerak. Agar u to'g'ridan-to'g'ri `CartFeature`ga bog'lansa, har safar savat ekranining UI'si, ranglari yoki ichki funksiyasi o'zgarganda `OrderFeature` ham noldan qayta kompilyatsiya bo'ladi.
2. `OrderFeature` faqat `CartFeatureInterface` (sof protocol va oddiy structlar) ga bog'lansa, savat ekranining ichki kodlari kuniga 100 marta o'zgarsa ham, **OrderFeature keshdan olinadi va bir millisekund ham recompile bo'lmaydi!**
### Kod Namunasi: Interface va Implementation
```swift
// 1. MODUL: CartFeatureInterface (Target: CartFeatureInterface)
import Foundation
public struct CartItemDTO: Identifiable, Sendable, Codable {
public let id: UUID
public let title: String
public let price: Decimal
public init(id: UUID, title: String, price: Decimal) {
self.id = id
self.title = title
self.price = price
}
}
public protocol CartRepositoryProtocol: Sendable {
func getCurrentItems() async throws -> [CartItemDTO]
func clearCart() async throws
}
```
```swift
// 2. MODUL: OrderFeature (Target: OrderFeature)
import SwiftUI
import CartFeatureInterface // Faqat interfeys import qilinadi!
public struct OrderCheckoutView: View {
// Interfeys orqali qabul qilinadi (DIP - Dependency Inversion)
private let cartRepository: any CartRepositoryProtocol
@State private var items: [CartItemDTO] = []
public init(cartRepository: any CartRepositoryProtocol) {
self.cartRepository = cartRepository
}
public var body: some View {
List(items) { item in
HStack {
Text(item.title)
Spacer()
Text("\(item.price) so'm")
}
}
.task {
items = (try? await cartRepository.getCurrentItems()) ?? []
}
}
}
```
```swift
// 3. MODUL: CartFeature (Target: CartFeature - Implementation)
import Foundation
import CartFeatureInterface
public final class RealCartRepository: CartRepositoryProtocol {
public init() {}
public func getCurrentItems() async throws -> [CartItemDTO] {
// Murakkab CoreData, SQLite yoki Network so'rovlari
return [
CartItemDTO(id: UUID(), title: "iPhone 16 Pro", price: 14_500_000)
]
}
public func clearCart() async throws {
// Tozalash logikasi
}
}
```
Asosiy ilova (`EcommerceApp`) esa `AppContainer` ichida ularni bog'lab qo'yadi:
```swift
let cartRepo = RealCartRepository()
let orderView = OrderCheckoutView(cartRepository: cartRepo)
```
---
## 5. Build Performance Optimizatsiyasi: Static vs Dynamic Linking va Dyld Launch Time
Ko'pchilik dasturchilar "loyihamni 40 ta modulga bo'ldim, nega ilova sekin ishga tushyapti va build vaqti kamaymadi?" degan savolga duch kelishadi. Sababi — noto'g'ri linking va kompilyator mexanikasini tushunmaslikdir.
### 5.1. Static Library vs Dynamic Framework
| Ko'rsatkich | 🟢 Static Library (.a) | 🔴 Dynamic Framework (.dylib) |
| :--- | :--- | :--- |
| **Kompilyatsiya vaqti** | Juda tez (Module kesh) | Har biriga alohida dylib yig'iladi |
| **Final Link vaqti** | Biroz ko'proq linker yuki | Tezroq link bo'ladi |
| **App Cold Start (dyld)** | ⚡️ **Deyarli 0 ms** qo'shimcha yuk | 🔴 **Har bir dylib +15–20ms** kechikish |
| **Dead Code Stripping** | ✅ To'liq ishlaydi (Hajm kichrayadi) | ❌ Ishlatilmagan kod ham binar ichida qoladi |
| **Binary Size (IPA)** | Odatda ancha kichik | Katta (Dylib metadata va headerlar ko'p) |
| **Duplicate Symbols xavfi** | Ehtiyotkorlik talab etadi (Extensionlarda) | Izolyatsiya qilingan |
### Apple Rasmiy Dyld Tavsiyasi
Apple muhandislari WWDC sessiyalarida aniq ko'rsatgan:
- Ilovada **6 tadan ortiq Dynamic Framework bo'lmasligi kerak**.
- Har bir Dynamic Framework iOS tizimidagi dinamik linker (`dyld4`) tomonidan ilova ochilishida (pre-main vaqtida) xotiraga yuklanishi, sahifalarga xaritalanishi (mmap), rebase va bind qilinishi kerak.
- Agar sizda 30 ta dynamic framework bo'lsa, ilovangiz ochilishi **450–600 ms** kechikadi! Foydalanuvchi qora ekranni ko'rib turadi.
- **Xulosa:** Swift Package Manager'da `.library(name: "...", targets: ["..."])` deklaratsiyasida `type:` parametrini ko'rsatmang yoki uni `.static` qiling. SPM o'zi sukut bo'yicha uni eng maqbul static kutubxona sifatida link qiladi.
### 5.2. Diamond Dependency (Duplicate Symbols) Muammosi
Agar ilovangizda ikkita alohida Dynamic Framework (masalan, `WidgetExtension.framework` va `MainApp.framework`) bir xil static SPM kutubxonasiga bog'lansa:
- Static kutubxona kodi ikkala framework ichiga ham nusxalanadi (duplicate).
- Bu xotirani 2 marta band qiladi va runtime vaqtida `Class ... is implemented in both ... One of the two will be used.` ogohlantirishini chiqaradi.
**Yechim:** Agar biror modul ham App, ham Widget, ham boshqa App Extension tomonidan bir vaqtda ishlatilishi shart bo'lsa, faqatgina o'sha umumiy modulni `.library(name: "SharedKit", type: .dynamic, targets: ["SharedKit"])` deb dynamic qilib belgilang. Qolgan barcha featurelar static bo'lib qolishi shart!
---
## 6. Resurslar, Assetlar va Lokalizatsiya (`Bundle.module`)
SPM paydo bo'lgunga qadar, alohida kutubxonalarda rasm, rang yoki matn saqlash o'ta mashaqqatli edi. SPM 5.3 dan boshlab **Resurslarni avtomatik qo'llab-quvvatlash** tizimi kiritildi.
### 6.1. `.process` vs `.copy`
- `.process("Resources")`: **Tavsiya etiladi.** Xcode resurslarni platformaga moslab optimizatsiya qiladi (PNG rasmlarni siqadi, Asset Cataloglarni `.car` formatiga kompilyatsiya qiladi, `Strings` fayllarni binarizatsiya qiladi).
- `.copy("Data.json")`: Faylni hech qanday o'zgarishsiz, asl holicha paket ichiga nusxalaydi.
### 6.2. `Bundle.module` Ishlatilishi
SPM biror targetda `resources` qatorini ko'rsa, avtomatik tarzda `resource_bundle_accessor.swift` faylini generatsiya qiladi va unga `Bundle.module` xossasini kiritadi.
```swift
// Sources/DesignSystem/UIComponents/AppLogoView.swift
import SwiftUI
public struct AppLogoView: View {
public init() {}
public var body: some View {
// Image("logo") qilsangiz izlash Asosiy ilovadan ketadi va topolmaydi!
// Doimo Bundle.module ko'rsatilishi shart:
Image("CompanyLogo", bundle: .module)
.resizable()
.scaledToFit()
.frame(width: 120, height: 120)
.background(Color("BrandPrimaryColor", bundle: .module))
}
}
```
Lokalizatsiyalangan matnlar uchun:
```swift
Text("welcome_title", bundle: .module)
// Yoki Swift 6 zamonaviy String(localized:):
let message = String(localized: "checkout_success_message", bundle: .module)
```
---
## 7. Yopiq Kodli Kutubxonalar: `.binaryTarget` & XCFrameworks
Ko'pincha bank, to'lov tizimlari yoki maxfiy C++ algoritmlarining manba kodi ochiq bo'lmaydi. Ular `.xcframework` binar ko'rinishida beriladi. SPM ularni mukammal integratsiya qiladi.
### 7.1. Katta Kompaniyalar Nega Binar Tarqatadi?
- **Google Maps & Yandex MapKit:** 3D shahar xaritasi render dvijogi, Metal/Vulkan sharderlari va xususiy C++ algoritmlarini ochiqlamaslik (IP protection).
- **Google Mobile Ads (AdMob) & Meta Audience Network:** Reklama sohasida "Ad Fraud" (soxta bosishlar, bot trafik)ning oldini olish uchun yopiq token almashinuvi va telemetriya.
- **Stripe, PayPal & Bank SDK lari:** PCI-DSS xavfsizlik talablariga ko'ra karta tokenizatsiyasi va biometrik barmoq izi tekshiruvlarini yashirish.
- **B2B Litsenziyalash:** O'z intellektual modulingizni boshqa korxonalarga manba kodini bermasdan, shartnoma asosida pullik litsenziyalash.
### 7.2. XCFramework Yig'ish va Checksum Hisoblash:
Binary framework yaratishda quyidagi ikki flag muhim:
1. `BUILD_LIBRARY_FOR_DISTRIBUTION=YES` — Swift Module Stability'ni yoqadi (`.swiftinterface` hosil qilib, kelajakdagi Swift versiyalarida ham binar buzilmasligini kafolatlaydi).
2. `STRIP_STYLE=all` & `SEPARATE_STRIP=YES` — Barcha private va debug belgilarni qirqib tashlaydi.
Terminalda zip arxivining xavfsiz SHA256 nazorat summasi olinadi:
```bash
swift package compute-checksum PaymentCore-v3.4.0.xcframework.zip
# Natija: a1b2c3d4e5f67890abcdef1234567890abcdef1234567890abcdef1234567890
```
### 7.3. Manifestda Belgilash:
```swift
targets: [
// Masofaviy binar target
.binaryTarget(
name: "PaymentCoreBinary",
url: "https://cdn.mybank.uz/sdk/ios/PaymentCore-v3.4.0.xcframework.zip",
checksum: "a1b2c3d4e5f67890abcdef1234567890abcdef1234567890abcdef1234567890"
),
// Swift Wrapper (Qulay SwiftUI interfeysi beruvchi yengil modul)
.target(
name: "PaymentSDK",
dependencies: ["PaymentCoreBinary"]
)
]
```
> 💡 **Batafsil amaliyot:** Anti-debugging (`ptrace`), compile-time XOR string maskalash va Public Key SSL Pinning bo'yicha to'liq 4 qatlamli xavfsizlik arxitekturasi **[15. [Demo Hard] FinTech SuperApp](/ios-lessons/spm-fintech-superapp)** darsida to'liq amaliy kod bilan yoritilgan.
---
## 8. Swift Package Plugins & Swift Macros
SPM shunchaki qaramliklarni yuklovchi vosita emas, u to'liq kengaytiriladigan **Metaprogramming va Tooling platformasi**dir.
### 8.1. Build Tool Plugins (Kompilyatsiya vaqtida kod generatsiyasi)
Loyiha har safar yig'ilganda (Build), SwiftLint xatolarini tekshirishi yoki OpenAPI / Protobuf fayllaridan avtomat Swift kodini chiqarishi mumkin.
```swift
// Plugins/GenerateAPIPlugin/Plugin.swift
import PackagePlugin
@main
struct GenerateAPIPlugin: BuildToolPlugin {
func createBuildCommands(context: PluginContext, target: Target) async throws -> [Command] {
let generatorTool = try context.tool(named: "api-codegen")
let specFile = target.directory.appending(subpath: "openapi.yaml")
let outputFile = context.pluginWorkDirectory.appending(subpath: "GeneratedAPI.swift")
return [
.buildCommand(
displayName: "Generating Swift API from OpenAPI spec",
executable: generatorTool.path,
arguments: ["--input", specFile.string, "--output", outputFile.string],
inputFiles: [specFile],
outputFiles: [outputFile]
)
]
}
}
```
### 8.2. Swift 6 Macros Paketlari
Swift 5.9/6.0 dagi mashhur `@Observable`, `@FreelySendable` makrolari ham to'liq SPM package sifatida yaratiladi. Ular `CompilerPluginSupport` moduli va `swift-syntax` kutubxonasiga tayanadi.
---
## 9. Kompilyatsiya Diagnostikasi va Compiler Flaglar
Loyihangizdagi eng sekin kompilyatsiya bo'layotgan joylarni topish uchun quyidagi diagnostika bayroqlarini (flags) ishlating:
### 9.1. Sekin funksiyalar va ifodalarni topish
`Package.swift` ichida `swiftSettings` ga qo'shing yoki Xcode Build Settings da kiriting:
```swift
swiftSettings: [
// 100 millisekunddan ko'proq vaqt olgan ifodalar haqida ogohlantirish
.unsafeFlags([
"-Xfrontend", "-warn-long-expression-type-checking=100",
"-Xfrontend", "-warn-long-function-bodies=100"
], .when(configuration: .debug))
]
```
> **Muhim tajriba:** SwiftUI kodlarida `+` yoki murakkab ternar operatorlar bilan yozilgan ViewBuilder ifodalarida tipni aniqlash (Type Inference) kompilyatorni 5-10 sekundgacha qotirib qo'yishi mumkin! Aniq tiplarni ko'rsatish (`let title: String = ...`) bu vaqtni 100 barobarga qisqartiradi.
### 9.2. Build Timing Summary
Terminal orqali butun yig'ilish jarayonini sekundma-sekund tahlil qilish:
```bash
xcodebuild -scheme EcommerceApp -destination 'generic/platform=iOS' \
-showBuildTimingSummary build
```
Natija quyidagicha jadval ko'rinishida chiqadi:
```
CompileSwiftSources (OrderFeature) : 4.2s
CompileSwiftSources (CartFeature) : 3.1s
CompileSwiftSources (DesignSystem) : 1.8s
Ld (EcommerceApp) : 0.9s
Total Build Time : 10.0s (Avvalgi monolitda: 3m 42s)
```
---
## 10. Dunyo Tajribasi: Apple, Airbnb, Uber va Point-Free
### 10.1. Apple (Swift Open Source)
Apple kompaniyasi `swift-syntax`, `swift-testing` va `swift-format` kabi rasmiy vositalarini bitta monorepo ichida o'nlab alohida mikromodullarga ajratgan. Har bir sintaksis daraxti alohida target bo'lib, Swift 6 Concurrency tekshiruvidan to'liq o'tgan. Bu har bir parallel CPU yadrosiga alohida modulni berib, kompilyatsiyani parallelizatsiya qilish imkonini beradi.
### 10.2. Airbnb (40+ Feature Modules & Vertical Slicing)
Airbnb muhandislari monolitdan SPM ga o'tishda avvaliga hamma narsani gorizontal bo'lishgan (Core, Common, Utils). Natijada biror util o'zgarsa, hamma narsa qayta kompilyatsiya bo'lgan. Keyinchalik ular **Vertical Slicing** va **Interface/Impl** yondashuviga o'tib, har bir funksional imkoniyatni (Search, Booking, Messages) vertikal mustaqil paketga aylantirishgan. Natijada CI build vaqti 70% ga qisqargan.
### 10.3. Uber (RIBs va Dyld Halokati)
Uber ilovasi yuzlab Dynamic Frameworklarga bo'linganda, ilovaning ochilishi (Cold Launch) 5-6 sekundga cho'zilib ketgan. Ular butun infratuzilmani static kutubxonalar va SPM ga o'tkazib, ilova ishga tushish vaqtini 0.35 sekundga (sub-second) tushirishga muvaffaq bo'lishgan.
### 10.4. Point-Free (TCA Micro-Packages)
Stephen Celis va Brandon Williams `swift-composable-architecture` kutubxonasini o'nlab mayda paketlarga ajratgan: `CasePaths`, `CustomDump`, `Dependencies`, `Clocks`, `IdentifiedCollections`. Buning sharofati bilan testlarni ishga tushirishda og'ir UI kutubxonalari kompilyatsiya qilinmaydi va unit testlar 50-100 millisekundda yakunlanadi.
---
## 11. CI/CD va SPM Build Cache Strategiyasi
GitHub Actions, GitLab CI yoki Xcode Cloud'da tezkor build olish uchun SPM keshini to'g'ri boshqarish zarur:
```yaml
# GitHub Actions misoli
- name: Cache Swift PM Packages
uses: actions/cache@v4
with:
path: |
.build
~/Library/Caches/org.swift.swiftpm
~/Library/Developer/Xcode/DerivedData/**/SourcePackages
key: ${{ runner.os }}-spm-${{ hashFiles('**/Package.resolved') }}
restore-keys: |
${{ runner.os }}-spm-
```
`Package.resolved` faylining hashiga qarab kesh saqlansa, har bir commitda tashqi kutubxonalarni qayta internetdan yuklab olishga vaqt sarflanmaydi (har bir CI run'da 3–5 daqiqa tejaladi).
---
## 12. Xulosa: Senior Muhandisning 10 Oltin Qoidasi
1. **Monorepo afzal:** 50 ta alohida git repozitoriy emas, bitta repozitoriy ichida ko'p targetli SPM paketlari yarating.
2. **Interface va Implementation ajratilsin:** Har bir yirik feature uchun alohida `Interface` targeti oching va faqat protocollarga bog'laning.
3. **Static by default:** Ilova modullarini doimo static qilib qoldiring. Dyld launch vaqtini o'g'irlamang.
4. **`package` access levelidan foydalaning (SE-0386):** Hammasini `public` qilib yubormang.
5. **Swift 6 Strict Concurrency yoqing:** Barcha modullarda `.enableUpcomingFeature("StrictConcurrency")` orqali data racelardan xoli bo'ling.
6. **Resurslarni `Bundle.module` orqali chaqiring:** Hech qachon `Bundle.main` ga tayanmang.
7. **Explicit Type Annotation:** Murakkab ifodalarda doimo tiplarni aniq ko'rsating, kompilyator inference jarayonini sekinlashtirmang.
8. **Izolyatsiyalangan Micro-Applar:** Har bir feature uchun kichik executable target yoki preview ilova yarating, butun ilovani build qilmasdan tezkor ishlab chiqing.
9. **Keshdan unumli foydalaning:** CI runnerlarda `SourcePackages` papkasini to'liq keshlang.
10. **Doimiy profayling:** Har haftada `showBuildTimingSummary` orqali sekinlashgan modullarni aniqlab, qaramliklarni optimallashtiring.