DEV Community: Anis Ali Khan

Tutorial 38: 🚀 Using NSCache and Disk Caching to Optimize Performance

Anis Ali Khan — Sat, 26 Apr 2025 20:57:30 +0000

(Or How to Launch Your App Performance into Orbit)

⸻

🌟 Introduction

Imagine you’re running a Mission Control app for astronauts 🚀 —
You don’t want slowdowns when they need critical mission photos, data logs, or the coordinates to Mars! 🌎➡️🪐

Today, we’ll learn how to boost your app’s speed with NSCache and Disk Caching, because even astronauts don’t have time for lag. 😎

We’ll build a Mission Control Gallery 🛰️ — an app that:
• Loads space images from a server
• Uses NSCache to keep recently viewed images fast
• Falls back to Disk Cache if needed
• Only downloads when absolutely necessary (because internet on Mars is spotty)

Ready? Let’s fire up the engines! 🚀🔥

⸻

🧰 What You’ll Learn

• What NSCache is (and why it’s cooler than a basic dictionary)
• How to implement in-memory caching 🧠
• How to implement disk caching 💾
• Best practices for caching like a pro

⸻

🛠 Project Setup: Mission Control Gallery

Open Xcode.
Create a new SwiftUI App.
Name it MissionControlGallery.
Choose Swift and SwiftUI.

⸻

🛰️ Setting Up Our Caching Service

Let’s create a CacheManager that uses both NSCache and Disk Storage.

import Foundation
import UIKit

class CacheManager {
    static let shared = CacheManager()
    private init() {}

    private let memoryCache = NSCache<NSString, UIImage>()

    private var diskCacheURL: URL? {
        FileManager.default.urls(for: .cachesDirectory, in: .userDomainMask).first
    }

    func saveToCache(image: UIImage, key: String) {
        memoryCache.setObject(image, forKey: key as NSString)

        guard let url = diskCacheURL?.appendingPathComponent(key) else { return }
        if let data = image.jpegData(compressionQuality: 1.0) {
            try? data.write(to: url)
        }
    }

    func loadFromCache(key: String) -> UIImage? {
        if let image = memoryCache.object(forKey: key as NSString) {
            print("🚀 Loaded from memory!")
            return image
        }

        guard let url = diskCacheURL?.appendingPathComponent(key),
              let data = try? Data(contentsOf: url),
              let image = UIImage(data: data) else { return nil }

        print("🛰️ Loaded from disk!")
        memoryCache.setObject(image, forKey: key as NSString)
        return image
    }

    func clearCache() {
        memoryCache.removeAllObjects()
        if let url = diskCacheURL {
            try? FileManager.default.removeItem(at: url)
            try? FileManager.default.createDirectory(at: url, withIntermediateDirectories: true)
        }
    }
}

⸻

🖼 Creating the Mission Gallery View

Let’s set up a SwiftUI view to show our images.

import SwiftUI

struct MissionGalleryView: View {
    let imageURLs = [
        "https://upload.wikimedia.org/wikipedia/commons/9/97/The_Earth_seen_from_Apollo_17.jpg",
        "https://upload.wikimedia.org/wikipedia/commons/3/3d/Hubble_Space_Telescope.jpg",
        "https://upload.wikimedia.org/wikipedia/commons/1/11/Mars_Valles_Marineris.jpeg"
    ]

    @State private var images: [UIImage?] = []

    var body: some View {
        NavigationView {
            ScrollView {
                VStack {
                    ForEach(images.indices, id: \.self) { index in
                        if let image = images[index] {
                            Image(uiImage: image)
                                .resizable()
                                .scaledToFit()
                                .frame(height: 250)
                                .cornerRadius(10)
                                .shadow(radius: 5)
                                .padding()
                        } else {
                            ProgressView()
                                .frame(height: 250)
                                .padding()
                        }
                    }
                }
            }
            .navigationTitle("Mission Control 🚀")
            .onAppear(perform: loadImages)
        }
    }

    func loadImages() {
        images = Array(repeating: nil, count: imageURLs.count)
        for (index, urlString) in imageURLs.enumerated() {
            loadImage(from: urlString) { image in
                DispatchQueue.main.async {
                    images[index] = image
                }
            }
        }
    }

    func loadImage(from urlString: String, completion: @escaping (UIImage?) -> Void) {
        let key = urlString.sha256()

        if let cachedImage = CacheManager.shared.loadFromCache(key: key) {
            completion(cachedImage)
            return
        }

        guard let url = URL(string: urlString) else {
            completion(nil)
            return
        }

        URLSession.shared.dataTask(with: url) { data, _, _ in
            guard let data = data,
                  let image = UIImage(data: data) else {
                completion(nil)
                return
            }
            CacheManager.shared.saveToCache(image: image, key: key)
            completion(image)
        }.resume()
    }
}

⸻

🔒 A Quick Utility for Safe Filenames

We need to create a “safe” file name for each image URL (like a hash).

import CryptoKit

extension String {
    func sha256() -> String {
        let inputData = Data(self.utf8)
        let hashed = SHA256.hash(data: inputData)
        return hashed.compactMap { String(format: "%02x", $0) }.joined()
    }
}

CryptoKit makes it super easy to hash things safely! 🚀

⸻

⚡ Common Mistakes to Avoid

Mistake Solution
Not clearing old cache Clean disk cache occasionally
Overloading memory Only cache what’s necessary!
Using huge images without compression Compress them for faster loads
Ignoring threading Always update the UI on main thread!

⸻

🎯 Why NSCache Rocks

• Auto-Evicts: When memory gets tight, it automatically purges old stuff!
• Thread-Safe: No need to write weird dispatch queues.
• Better than Dictionary: Because dictionaries don’t auto-clean. 😬

⸻

🎉 Final Words

Congratulations, Mission Commander! 🧑‍🚀
You now know how to supercharge your app’s performance with smart caching strategies!

You can use these techniques to:
• Build image-heavy apps 📸
• Cache API responses 📈
• Store video thumbnails 🎥
• Make your apps feel buttery smooth 🧈✨

Caching isn’t just an optimization; it’s a superpower! 💥

⸻

🌌 Code Boldly. Cache Smart. 🚀

⸻

Would you also like a bonus challenge section that adds cache expiration policies or a way to clear cache manually inside the app? 🔥
It would turn this tutorial into an intergalactic-level beginner-to-intermediate Swift project! 🚀🛸
(Just say the word!)

Tutorial 37: 📂 Handling File Storage with FileManager in iOS

Anis Ali Khan — Sat, 26 Apr 2025 20:47:19 +0000

(Or How to Save a Bunch of Silly Memes Like a Pro)

⸻

🚀 Introduction

Ever wanted to save a secret stash of memes 🐸 or maybe a collection of ancient pizza receipts 🍕🧾 inside your app?
Today, we’re diving into FileManager — your friendly neighborhood hero that lets you create, read, update, and delete files and folders on an iOS device!

We’ll build a Meme Vault app 🏦 — a silly (but powerful!) little app that lets users:
• Save memes (images) to the app’s storage
• List saved memes
• Delete memes
• Feel like a hacker of hilariousness

Ready? Let’s meme-ify your coding skills! 😎

⸻

🧰 What You’ll Learn

• Basics of FileManager
• How to save files locally
• How to list files in a directory
• How to delete files
• Common pitfalls (and how to avoid looking like a noob 🙃)

⸻

🛠 Project Setup: Meme Vault

Open Xcode.
Create a new SwiftUI App.
Name it MemeVault.
Choose Swift and SwiftUI as usual.

Tip: You can also follow along in a Playground if you just wanna vibe and test.

⸻

🧹 Setting up FileManager Helper

Let’s create a neat little class called FileManagerService that will handle all the messy file stuff for us.

import Foundation
import SwiftUI

class FileManagerService {
    static let shared = FileManagerService()
    private init() {}

    let folderName = "SavedMemes"

    private var folderURL: URL? {
        do {
            let documentsURL = try FileManager.default.url(
                for: .documentDirectory,
                in: .userDomainMask,
                appropriateFor: nil,
                create: false
            )
            return documentsURL.appendingPathComponent(folderName)
        } catch {
            print("⚠️ Error getting documents directory: \(error)")
            return nil
        }
    }

    func createFolderIfNeeded() {
        guard let url = folderURL else { return }
        if !FileManager.default.fileExists(atPath: url.path) {
            do {
                try FileManager.default.createDirectory(at: url, withIntermediateDirectories: true)
                print("✅ Folder created!")
            } catch {
                print("⚠️ Error creating folder: \(error)")
            }
        }
    }

    func saveImage(image: UIImage, name: String) {
        createFolderIfNeeded()
        guard let url = folderURL?.appendingPathComponent(name),
              let data = image.jpegData(compressionQuality: 1.0) else { return }
        do {
            try data.write(to: url)
            print("✅ Meme saved!")
        } catch {
            print("⚠️ Error saving meme: \(error)")
        }
    }

    func getImages() -> [UIImage] {
        var images: [UIImage] = []
        guard let url = folderURL else { return [] }

        do {
            let fileURLs = try FileManager.default.contentsOfDirectory(at: url, includingPropertiesForKeys: nil)
            for fileURL in fileURLs {
                if let data = try? Data(contentsOf: fileURL),
                   let image = UIImage(data: data) {
                    images.append(image)
                }
            }
        } catch {
            print("⚠️ Error listing memes: \(error)")
        }
        return images
    }

    func deleteImage(name: String) {
        guard let url = folderURL?.appendingPathComponent(name) else { return }
        do {
            try FileManager.default.removeItem(at: url)
            print("🗑️ Meme deleted!")
        } catch {
            print("⚠️ Error deleting meme: \(error)")
        }
    }
}

⸻

🖼 MemeVaultView: Upload, List, and Delete

Let’s hook up a simple SwiftUI view:

import SwiftUI

struct MemeVaultView: View {
    @State private var memes: [UIImage] = []
    @State private var selectedImage: UIImage?
    @State private var showImagePicker = false

    var body: some View {
        NavigationView {
            VStack {
                if memes.isEmpty {
                    Text("No memes yet. Add one! 🎨")
                        .padding()
                } else {
                    ScrollView {
                        ForEach(memes.indices, id: \.self) { index in
                            Image(uiImage: memes[index])
                                .resizable()
                                .scaledToFit()
                                .frame(height: 200)
                                .padding()
                                .onLongPressGesture {
                                    deleteMeme(at: index)
                                }
                        }
                    }
                }

                Button(action: { showImagePicker = true }) {
                    Text("Add Meme ➕")
                        .padding()
                        .background(Color.blue)
                        .foregroundColor(.white)
                        .cornerRadius(8)
                }
                .padding()
            }
            .navigationTitle("Meme Vault 🏦")
            .onAppear(perform: loadMemes)
            .sheet(isPresented: $showImagePicker, content: {
                ImagePicker(selectedImage: $selectedImage, didFinishPicking: saveMeme)
            })
        }
    }

    private func loadMemes() {
        memes = FileManagerService.shared.getImages()
    }

    private func saveMeme() {
        guard let selected = selectedImage else { return }
        let fileName = "meme_\(UUID().uuidString.prefix(6)).jpg"
        FileManagerService.shared.saveImage(image: selected, name: fileName)
        loadMemes()
    }

    private func deleteMeme(at index: Int) {
        let fileName = "meme_\(index).jpg"
        FileManagerService.shared.deleteImage(name: fileName)
        loadMemes()
    }
}

struct MemeVaultView_Previews: PreviewProvider {
    static var previews: some View {
        MemeVaultView()
    }
}

⸻

📸 Quick ImagePicker Setup

You’ll need a simple ImagePicker. Here’s a quick one:

import SwiftUI
import UIKit

struct ImagePicker: UIViewControllerRepresentable {
    @Binding var selectedImage: UIImage?
    var didFinishPicking: () -> Void

    func makeCoordinator() -> Coordinator {
        Coordinator(self)
    }

    class Coordinator: NSObject, UINavigationControllerDelegate, UIImagePickerControllerDelegate {
        let parent: ImagePicker
        init(_ parent: ImagePicker) {
            self.parent = parent
        }

        func imagePickerController(_ picker: UIImagePickerController, didFinishPickingMediaWithInfo info: [UIImagePickerController.InfoKey : Any]) {
            if let image = info[.originalImage] as? UIImage {
                parent.selectedImage = image
                parent.didFinishPicking()
            }
            picker.dismiss(animated: true)
        }

        func imagePickerControllerDidCancel(_ picker: UIImagePickerController) {
            picker.dismiss(animated: true)
        }
    }

    func makeUIViewController(context: Context) -> UIImagePickerController {
        let picker = UIImagePickerController()
        picker.delegate = context.coordinator
        return picker
    }

    func updateUIViewController(_ uiViewController: UIImagePickerController, context: Context) {}
}

⸻

⚡ Common Mistakes to Avoid

Mistake Solution
Saving files outside the Documents directory Always use .documentDirectory
Forgetting to create folders before writing Always check and create!
Using weird file formats Stick to .jpg, .png, .txt, etc.
Not handling errors At least print them out! 🚨

⸻

🎉 Final Words

Congrats! You now know how to store, read, and delete files in iOS like a true meme lord 👑.
You could totally adapt this knowledge to:
• Save app settings
• Store offline data
• Build a personal diary app
• Hide secret pizza recipes 🍕🧪

The filesystem is your oyster 🦪.

Next challenge: Add folders by categories like “Dank Memes”, “Wholesome”, “Dark Humor”, etc.! 🌟

⸻

🌈 Code On and Meme Away!

⸻

Would you like me to also create a bonus challenge section where users can extend the app (like adding folders for categories)? 🚀
It would make it even more fun if you want to turn it into a full beginner project!

Tutorial 36: Integrating Firebase Firestore for Realtime Data Sync 🚀

Anis Ali Khan — Sat, 26 Apr 2025 20:38:15 +0000

*Featuring: SnackAttack - Realtime Snack Voting App 🍪🍩🍕

Welcome, fearless developer! 🧙‍♂️✨ Today we dive into the exciting world of Firebase Firestore — Google's magic cloud database for realtime data sync!

And we won't just talk — we'll build an epic app: SnackAttack 🍿 — a real-time snack voting app where users battle it out over which snack rules supreme! 🥇🍕

📚 What You'll Learn

What is Firebase Firestore?
Setting up Firebase in your iOS project
Creating, updating, and listening to realtime data
Building a voting app with SwiftUI + Firestore

🔥 What Is Firestore?

NoSQL cloud database by Google 🌎
Realtime updates — changes show up instantly without refresh ⚡
Offline support — keeps working even when you lose signal! 📶
Cross-platform — mobile, web, and server ready 🚀

Perfect for any app that needs live data flying around! 🛫

🛠 Project Setup

Create a new Xcode project (App template).
Install Firebase SDK via Swift Package Manager:
- URL: https://github.com/firebase/firebase-ios-sdk
Set up a Firebase project:
- Go to Firebase Console
- Create a new project.
- Add an iOS app (get your GoogleService-Info.plist).
- Download and drag GoogleService-Info.plist into Xcode.
Configure Firebase in your app:

import Firebase

@main
struct SnackAttackApp: App {
    init() {
        FirebaseApp.configure()
    }

    var body: some Scene {
        WindowGroup {
            ContentView()
        }
    }
}

🍩 Designing the SnackAttack Database

In Firestore, we'll have a collection called snacks:

Field	Type	Description
name	String	Name of the snack
votes	Int	Number of votes

Each snack is a document. Simple. Fast. Delicious. 🍩

✨ SwiftUI + Firestore Snack Voting App

import SwiftUI
import FirebaseFirestore
import FirebaseFirestoreSwift

struct Snack: Identifiable, Codable {
    @DocumentID var id: String?
    var name: String
    var votes: Int
}

class SnackViewModel: ObservableObject {
    @Published var snacks = [Snack]()
    private var db = Firestore.firestore()

    init() {
        fetchData()
    }

    func fetchData() {
        db.collection("snacks").order(by: "votes", descending: true)
            .addSnapshotListener { (querySnapshot, error) in
                guard let documents = querySnapshot?.documents else {
                    print("😱 No documents: \(error?.localizedDescription ?? "unknown error")")
                    return
                }
                self.snacks = documents.compactMap { document -> Snack? in
                    try? document.data(as: Snack.self)
                }
            }
    }

    func addSnack(name: String) {
        do {
            _ = try db.collection("snacks").addDocument(from: Snack(name: name, votes: 0))
        } catch {
            print("😱 Error adding snack: \(error.localizedDescription)")
        }
    }

    func vote(for snack: Snack) {
        if let id = snack.id {
            db.collection("snacks").document(id).updateData([
                "votes": snack.votes + 1
            ])
        }
    }
}

struct ContentView: View {
    @StateObject private var viewModel = SnackViewModel()
    @State private var newSnackName = ""

    var body: some View {
        NavigationView {
            VStack {
                HStack {
                    TextField("New Snack", text: $newSnackName)
                        .textFieldStyle(RoundedBorderTextFieldStyle())
                    Button(action: {
                        viewModel.addSnack(name: newSnackName)
                        newSnackName = ""
                    }) {
                        Text("Add 🍪")
                            .padding(.horizontal)
                    }
                }
                .padding()

                List(viewModel.snacks) { snack in
                    HStack {
                        Text(snack.name)
                        Spacer()
                        Text("\(snack.votes) 🍴")
                        Button(action: {
                            viewModel.vote(for: snack)
                        }) {
                            Text("Vote ✅")
                        }
                    }
                }
            }
            .navigationTitle("SnackAttack 🍕")
        }
    }
}

⚡ How Realtime Sync Works

Add a snack ➡️ Instantly shows for everyone.
Vote for a snack ➡️ Instant update across all devices.
New users see live leaderboard without manual refreshes.

Magic? Almost. 😎

🧠 Pro Tips for Firestore

Security Rules: Lock down your database! Don’t leave it open to everyone. 🔒
Indexes: Firestore automatically creates indexes but optimize when needed for performance.
Batch Writes: Bundle multiple updates in one request.
Offline Support: Firestore caches data — amazing for mobile!

🎯 Stretch Challenges for SnackAttack

Add snack categories (Sweet 🍩, Savory 🍕, Healthy 🥗).
Show snack pictures with Firebase Storage.
Sort by most recently added snacks.
Add user authentication to track who voted.

Congratulations, Realtime Rockstar! 🌟

You built a cloud-connected, real-time updating app that syncs delicious snack battles across the globe. 🌍🍕

Keep coding, keep shipping, and remember: the snack must go on! 🚀🍪🍩🍕

Let me know if you want a bonus follow-up tutorial where we add user login with Firebase Authentication so voters can only vote once! 🎯🎟️

Tutorial 35: Using CloudKit for Cloud-Based Data Storage 🚀

Anis Ali Khan — Sat, 26 Apr 2025 20:31:28 +0000

Featuring: DreamCatcher - A Dream Diary App in the Cloud ☁️🌙

Welcome, visionary developer! 🧙‍♀️✨ Today we're diving into the mystical world of CloudKit, Apple's magical portal for cloud-based data storage.

And we won't just theorize — we're building an app called DreamCatcher: a place for users to log their dreams 🌙 and access them across all their devices — iPhone, iPad, and Mac. 📱💻🎯

📚 What You'll Learn

What is CloudKit and why it's awesome
Setting up a CloudKit-backed app
Saving, fetching, and deleting records in iCloud
Building a Dream Diary with SwiftUI 🌟

☁️ Why Use CloudKit?

FREE tiers generous enough for small apps 💸
Syncs automatically across devices 🌎
Built into iOS — no extra accounts needed 🎟
Secure and Private — thanks to Apple 🔒

Basically: It’s like giving your app superpowers...for free. 🦸‍♀️

🛠 Project Setup

Create a new App project in Xcode.
Check ✅ "Use Core Data" (we’ll add CloudKit magic to it later).
Go to Signing & Capabilities:
- Add Capability: iCloud
- Enable CloudKit
- Ensure Background Modes ➡️ Remote Notifications is checked (optional for push updates).
In your project settings under iCloud, make sure your containers are configured properly. (iCloud.com.yourapp.identifier)

✨ Modeling Dreams with Core Data + CloudKit

In your .xcdatamodeld file:

Add an Entity: Dream
Add Attributes:
- title: String
- details: String
- timestamp: Date

Click the Entity ➡️ Check "Use CloudKit".

CloudKit will now automatically sync this entity behind the scenes! 🛸

🖥 SwiftUI UI for DreamCatcher

import SwiftUI
import CoreData

struct ContentView: View {
    @Environment(\.managedObjectContext) private var viewContext
    @FetchRequest(
        sortDescriptors: [NSSortDescriptor(keyPath: \Dream.timestamp, ascending: false)],
        animation: .default)
    private var dreams: FetchedResults<Dream>

    @State private var dreamTitle = ""
    @State private var dreamDetails = ""

    var body: some View {
        NavigationView {
            VStack {
                TextField("Dream Title", text: $dreamTitle)
                    .textFieldStyle(RoundedBorderTextFieldStyle())
                    .padding()

                TextEditor(text: $dreamDetails)
                    .frame(height: 150)
                    .overlay(RoundedRectangle(cornerRadius: 10).stroke(Color.gray))

                Button(action: saveDream) {
                    Text("Save Dream ✨")
                        .padding()
                        .frame(maxWidth: .infinity)
                        .background(Color.blue)
                        .foregroundColor(.white)
                        .cornerRadius(10)
                }
                .padding()

                List {
                    ForEach(dreams) { dream in
                        VStack(alignment: .leading) {
                            Text(dream.title ?? "Untitled Dream")
                                .font(.headline)
                            Text(dream.details ?? "")
                                .font(.subheadline)
                                .foregroundColor(.secondary)
                            Text("\(dream.timestamp ?? Date(), formatter: dateFormatter)")
                                .font(.caption)
                                .foregroundColor(.gray)
                        }
                    }
                    .onDelete(perform: deleteDreams)
                }
            }
            .navigationTitle("🌙 DreamCatcher")
        }
    }

    private func saveDream() {
        withAnimation {
            let newDream = Dream(context: viewContext)
            newDream.title = dreamTitle
            newDream.details = dreamDetails
            newDream.timestamp = Date()

            do {
                try viewContext.save()
                dreamTitle = ""
                dreamDetails = ""
            } catch {
                print("😱 Failed to save dream: \(error.localizedDescription)")
            }
        }
    }

    private func deleteDreams(offsets: IndexSet) {
        withAnimation {
            offsets.map { dreams[$0] }.forEach(viewContext.delete)
            do {
                try viewContext.save()
            } catch {
                print("😱 Failed to delete dream: \(error.localizedDescription)")
            }
        }
    }
}

private let dateFormatter: DateFormatter = {
    let formatter = DateFormatter()
    formatter.dateStyle = .short
    formatter.timeStyle = .short
    return formatter
}()

⚡ How Syncing Happens

Save a new Dream? ➡️ Core Data automatically pushes it to iCloud ☁️
Open the app on another device ➡️ Dreams sync down! 📲✨

You barely have to lift a finger. Magic! 🎩

🧠 Pro Tips for CloudKit

Network Errors: Always be ready to handle failures gracefully (retry later if the network is bad).
Background Sync: Core Data + CloudKit sync even when the app is suspended.
Conflict Handling: Core Data merges changes smartly, but complex apps should plan conflict resolution strategies.
User Privacy: Users can revoke iCloud access at any time — design your app to degrade gracefully.

🎯 Challenges for DreamCatcher 2.0

Add Dream Categories (Nightmare, Adventure, Flying Dreams!) 🎭
Support Dream Ratings ⭐️
Build a Timeline View 📈
Add Apple Pencil support for sketching dreams ✏️
Push Notifications for "Dream Streaks" 🔔

Congratulations, Cloud Conqueror! ☁️👑

You’ve built a cloud-synced app that can travel across devices with zero extra servers, zero extra backend work, and 100% SwiftUI magic.

Dream big, dream often, and keep coding! 🚀🌙✨

Let me know if you'd also like a bonus tutorial where we extend DreamCatcher with CloudKit sharing — so users can send their dreams to friends! 📩💭

Tutorial 34: Working with SQLite and Third-Party Databases in iOS 🚀

Anis Ali Khan — Sat, 26 Apr 2025 20:19:53 +0000

Featuring: Fart Button 2: Farts on the Map 🌍💨

Welcome back, master developer! 🧙‍♂️✨ Today we're pushing our skills even further:

SQLite
Third-party database libraries
MapKit integration

All wrapped inside the beautifully absurd Fart Button App, now upgraded to log and map every fart around the world! 🌍🎺💥

📚 What You'll Learn

Setting up SQLite manually
Using a third-party wrapper (like GRDB or SQLite.swift)
Saving and querying custom data
Displaying fart locations on a map 🌎💨

🛠 Project Setup

Create a new Xcode project.
Add MapKit.
Install SQLite.swift (or GRDB.swift) using Swift Package Manager:
- URL: https://github.com/stephencelis/SQLite.swift

💾 Why Use SQLite?

Blazing fast 🚀
Lightweight 📦
Cross-platform 🌎
Great for apps that don't need full Core Data complexity

You can even inspect your database manually with any SQLite viewer!

💨 Designing the Fart Table

We'll store:

Column	Type	Description
id	Int	Primary Key
soundName	String	The fart sound filename
latitude	Double	Fart GPS latitude
longitude	Double	Fart GPS longitude
timestamp	Date	When it happened

Epic. 🌋

✨ Creating the Fart Database

import SQLite
import MapKit

class FartDatabase {
    static let shared = FartDatabase()
    private var db: Connection?

    let farts = Table("farts")
    let id = Expression<Int64>("id")
    let soundName = Expression<String>("soundName")
    let latitude = Expression<Double>("latitude")
    let longitude = Expression<Double>("longitude")
    let timestamp = Expression<Date>("timestamp")

    private init() {
        do {
            let documentDirectory = try FileManager.default.url(
                for: .documentDirectory,
                in: .userDomainMask,
                appropriateFor: nil,
                create: true
            )
            let fileUrl = documentDirectory.appendingPathComponent("farts").appendingPathExtension("sqlite3")
            db = try Connection(fileUrl.path)

            try db?.run(farts.create(ifNotExists: true) { table in
                table.column(id, primaryKey: true)
                table.column(soundName)
                table.column(latitude)
                table.column(longitude)
                table.column(timestamp)
            })
            print("📦 Database ready!")
        } catch {
            print("😱 Database error: \(error)")
        }
    }

    func addFart(sound: String, coordinate: CLLocationCoordinate2D) {
        let insert = farts.insert(
            soundName <- sound,
            latitude <- coordinate.latitude,
            longitude <- coordinate.longitude,
            timestamp <- Date()
        )
        do {
            try db?.run(insert)
            print("💨 Fart saved!")
        } catch {
            print("😱 Failed to insert fart: \(error)")
        }
    }

    func getAllFarts() -> [(sound: String, location: CLLocationCoordinate2D)] {
        var fartList = [(sound: String, location: CLLocationCoordinate2D)]()
        do {
            for fart in try db!.prepare(farts) {
                let location = CLLocationCoordinate2D(
                    latitude: fart[latitude],
                    longitude: fart[longitude]
                )
                fartList.append((sound: fart[soundName], location: location))
            }
        } catch {
            print("😱 Failed to fetch farts: \(error)")
        }
        return fartList
    }
}

🗺 Building the MapKit UI

import SwiftUI
import MapKit

struct ContentView: View {
    @State private var region = MKCoordinateRegion(
        center: CLLocationCoordinate2D(latitude: 37.7749, longitude: -122.4194),
        span: MKCoordinateSpan(latitudeDelta: 0.1, longitudeDelta: 0.1)
    )
    @State private var farts: [(sound: String, location: CLLocationCoordinate2D)] = []

    var body: some View {
        VStack {
            Map(coordinateRegion: $region, annotationItems: farts, annotationContent: { fart in
                MapMarker(coordinate: fart.location, tint: .green)
            })
            .edgesIgnoringSafeArea(.all)

            Button(action: recordFart) {
                Text("💨 Drop a Fart 💨")
                    .font(.title)
                    .padding()
                    .background(Color.green)
                    .foregroundColor(.white)
                    .cornerRadius(10)
            }
            .padding()
        }
        .onAppear(perform: loadFarts)
    }

    private func recordFart() {
        let randomOffset = Double.random(in: -0.02...0.02)
        let newCoordinate = CLLocationCoordinate2D(
            latitude: region.center.latitude + randomOffset,
            longitude: region.center.longitude + randomOffset
        )
        FartDatabase.shared.addFart(sound: "RandomFart.mp3", coordinate: newCoordinate)
        loadFarts()
    }

    private func loadFarts() {
        farts = FartDatabase.shared.getAllFarts()
    }
}

Boom. Now every fart is plotted on a map. Historical. 😂

🧠 Key Concepts You Used

SQLite database setup 📦
Creating and managing tables 🛠
Saving records 💾
Querying data 🧹
MapKit for visualizing 🌍
SwiftUI for fun interactions 🧡

🎯 Challenges to Try

Add fart categories (Epic, Squeaky, Ninja).
Allow fart playback when tapping a pin. 🎧
Show a list of recent farts below the map.
Save user preferences for fart sounds!
Animate fart explosions when a marker is tapped. 💥

You've built the Fart Mapping Revolution! 💨🗺👑

Not only can you save local data with SQLite — you can now map the gaseous trail of glory across the globe. 🌍💚

Keep coding, keep laughing, and keep shipping hilarious apps! 🚀💨

Tutorial 33: Advanced Core Data - Relationships, Fetch Requests, and Performance 🚀

Anis Ali Khan — Sat, 26 Apr 2025 20:10:43 +0000

Featuring: The Fart Button Universe Expanded 🌌💨

Welcome back, brave developer! 🧙‍♂️✨ If you thought saving farts was magical, get ready — today, we're supercharging the Fart Button App with relationships, advanced fetch requests, and performance tips.

We're building not just a fart database — but a whole fart multiverse. 🌌💥

📚 What You'll Learn

How to model relationships in Core Data
How to write advanced FetchRequests
Performance tips to keep your app speedy 💨💨

🛠 New Plan: Fart Categories

Our new app idea:

Different types of farts belong to Categories.
A Category (e.g., "Epic", "Squeaky", "Stealth Mode") has many Farts.
Each Fart belongs to one Category.

In Core Data lingo: One-to-Many Relationship.

💾 Updating the Data Model

Open Model.xcdatamodeld:

Add a new Entity ➡️ Name it Category.
Add attributes to Category:
- name: String
Update Fart:
- Add a Relationship:
  - Name: category
  - Destination: Category
  - Type: To One
In Category, add a Relationship:
- Name: farts
- Destination: Fart
- Type: To Many
Set inverse relationships:
- category ⬅️➡️ farts

Congrats! You just taught Core Data that farts are social beings. 🎓

🖥 Updated Fart Button UI

import SwiftUI
import CoreData

struct ContentView: View {
    @Environment(\.managedObjectContext) private var viewContext

    @FetchRequest(
        entity: Category.entity(),
        sortDescriptors: [NSSortDescriptor(keyPath: \Category.name, ascending: true)]
    ) private var categories: FetchedResults<Category>

    var body: some View {
        NavigationView {
            List {
                ForEach(categories) { category in
                    Section(header: Text(category.name ?? "Unknown Category")) {
                        ForEach(category.fartsArray) { fart in
                            Text(fart.soundName ?? "Mystery Fart")
                        }
                    }
                }
            }
            .navigationTitle("💨 Fart Archive 💨")
            .toolbar {
                ToolbarItem(placement: .navigationBarTrailing) {
                    Button(action: addSampleData) {
                        Label("Add Sample", systemImage: "plus")
                    }
                }
            }
        }
    }

    private func addSampleData() {
        let newCategory = Category(context: viewContext)
        newCategory.name = "Epic Farts"

        let fart1 = Fart(context: viewContext)
        fart1.soundName = "MegaBlast.mp3"
        fart1.timestamp = Date()
        fart1.category = newCategory

        let fart2 = Fart(context: viewContext)
        fart2.soundName = "AtomicFart.mp3"
        fart2.timestamp = Date()
        fart2.category = newCategory

        do {
            try viewContext.save()
        } catch {
            print("😱 Failed to save sample data: \(error.localizedDescription)")
        }
    }
}

extension Category {
    var fartsArray: [Fart] {
        let set = farts as? Set<Fart> ?? []
        return set.sorted { $0.timestamp ?? Date() < $1.timestamp ?? Date() }
    }
}

Boom. You now have categorized farts. Elite developer status unlocked. 🏆

🎯 Advanced Fetching: Only Epic Farts, Please

Want to get only farts from "Epic Farts" category? 🔥

func fetchEpicFarts() -> [Fart] {
    let request: NSFetchRequest<Fart> = Fart.fetchRequest()
    request.predicate = NSPredicate(format: "category.name == %@", "Epic Farts")
    request.sortDescriptors = [NSSortDescriptor(keyPath: \Fart.timestamp, ascending: true)]

    do {
        return try viewContext.fetch(request)
    } catch {
        print("😱 Error fetching epic farts: \(error.localizedDescription)")
        return []
    }
}

With this, your app filters the legendary explosions from the mundane ones. 🎺💥

⚡️ Core Data Performance Tips

Batch Size: Large datasets? Use fetchBatchSize to avoid loading too much into memory.

request.fetchBatchSize = 20

Faulting: Core Data lazy-loads objects — don’t worry if you see a "fault" — it's good for performance!
Background Contexts: For heavy operations (e.g., importing thousands of farts), use a background context so your UI doesn't freeze. 🧊
Indexes: Set Indexes on frequently queried fields like timestamp or soundName!

🧹 Cleaning Up: Deleting a Category

Want to delete a Category (and maybe all its farts)?

func deleteCategory(_ category: Category) {
    viewContext.delete(category)

    do {
        try viewContext.save()
    } catch {
        print("😱 Failed to delete category: \(error.localizedDescription)")
    }
}

Easy peasy. (And surprisingly sad if you're attached to your farts.) 😢

🎇 Final Challenge: Stretch Goals

Create Custom Category Icons (💥 vs 🥷)
Allow renaming Categories
Sort Categories based on number of farts (MOST FARTS WINS! 🏆)
Add audio playback when tapping a fart 🎧

Congratulations, Core Data Wizard! 🧙‍♀️💨

You just leveled up your Fart Button App into a relational database masterpiece. Your ancestors would be proud.

Until next time — stay classy, and keep coding! 💨👑

Tutorial 32: Core Data Basics - Storing Structured Data Locally 🚀

Anis Ali Khan — Sat, 26 Apr 2025 19:51:14 +0000

Featuring: The Legendary Fart Button App 💨

Welcome, brave coder! 🧙‍♂️✨ Today we're going to embark on an epic quest: learning Core Data — Apple's magical framework for storing structured data locally on iOS devices.

And yes, we're doing it with the world-changing Fart Button App. Because learning is better with farts. 💥

📚 What You'll Learn

What is Core Data?
Setting up Core Data in a project
Creating a simple Fart entity
Saving, fetching, and deleting data
Building a simple UI to interact with it

🤔 What Is Core Data?

Core Data is Apple's solution for managing an object graph — basically, storing and retrieving your app's data 🧠.

Think of it like:

User taps a button ➡️ Save a fart to the database 💨
User opens the app again ➡️ Fart history still there 📜

Without Core Data, your app would forget every beautiful fart pressed. 😢

🛠 Setting Up Core Data

Create a new Xcode project.
- Template: App
- Make sure you check "Use Core Data" ✅
Xcode auto-generates some Core Data boilerplate!
- Persistence.swift
- Model.xcdatamodeld

This is where the magic happens! 🪄

💨 Creating the Fart Entity

In Model.xcdatamodeld:

Click the + ➡️ Add Entity ➡️ Name it Fart.
Add an attribute:
- Name: soundName
- Type: String
Add another attribute (optional):
- Name: timestamp
- Type: Date

Now you have a database table ready to store farts. Historic. 🎺

🖥 Let's Build the Fart Button UI

import SwiftUI
import CoreData

struct ContentView: View {
    @Environment(\.managedObjectContext) private var viewContext
    @FetchRequest(
        sortDescriptors: [NSSortDescriptor(keyPath: \Fart.timestamp, ascending: true)],
        animation: .default)
    private var farts: FetchedResults<Fart>

    var body: some View {
        VStack(spacing: 20) {
            Button(action: addFart) {
                Text("💨 Fart Button 💨")
                    .font(.largeTitle)
                    .padding()
                    .background(Color.green)
                    .cornerRadius(12)
                    .foregroundColor(.white)
            }

            List {
                ForEach(farts) { fart in
                    Text(fart.soundName ?? "Unknown Fart")
                }
                .onDelete(perform: deleteFarts)
            }
        }
        .padding()
    }

    private func addFart() {
        withAnimation {
            let newFart = Fart(context: viewContext)
            newFart.soundName = "ClassicFart.mp3"
            newFart.timestamp = Date()

            do {
                try viewContext.save()
            } catch {
                print("😱 Failed to save fart: \(error.localizedDescription)")
            }
        }
    }

    private func deleteFarts(offsets: IndexSet) {
        withAnimation {
            offsets.map { farts[$0] }.forEach(viewContext.delete)

            do {
                try viewContext.save()
            } catch {
                print("😱 Failed to delete fart: \(error.localizedDescription)")
            }
        }
    }
}

Boom. You now have a functional fart database. 🎉

🧠 How It All Works

@Environment(\.managedObjectContext) gives access to Core Data's magical save powers.
@FetchRequest automatically listens to changes and updates the UI.
addFart() creates a new Fart entity and saves it.
deleteFarts() removes farts from history. (Pour one out. 🍻)

🧹 Pro Tips for Core Data

Always save after creating, updating, or deleting.
Use @FetchRequest smartly to drive your UI updates automatically.
Think about relationships (e.g., maybe a Fart Category later...💭).
Don't forget to handle errors gracefully.

🎯 Final Thoughts

You just built a Core Data powered app. And not just any app — a Fart Button that saves history for future generations to admire. 🏆

Next steps:

Add custom fart sounds
Add categories ("Loud", "Silent", "Squeaky") 🧩
Build a Leaderboard ("Most Farts in a Day") 🥇

The possibilities are endless... and endlessly hilarious.

Keep coding and stay classy! 💨👑

🔐 Mastering Secure API Design: A Comprehensive Guide

Anis Ali Khan — Sat, 26 Apr 2025 05:27:29 +0000

Background

In today's interconnected digital landscape, APIs (Application Programming Interfaces) serve as the backbone of modern applications, enabling seamless communication between diverse systems. However, with great power comes great responsibility. Ensuring the security of APIs is paramount to protect sensitive data and maintain the integrity of applications.

This comprehensive guide delves deep into the intricacies of secure API design, exploring best practices, common pitfalls, and real-world case studies to equip you with the knowledge to build robust and secure APIs.

🧠 Understanding API Security Fundamentals

🔍 What is API Security?

API security encompasses the strategies and practices implemented to protect APIs from malicious attacks, ensuring that only authorized users can access and manipulate data. It involves authentication, authorization, encryption, and monitoring to safeguard the API ecosystem.

🛡️ Importance of API Security

Data Protection: APIs often handle sensitive information, making them prime targets for data breaches.
System Integrity: Compromised APIs can lead to unauthorized access, data manipulation, or system downtime.
Compliance: Adhering to security standards is essential for regulatory compliance (e.g., GDPR, HIPAA).

🏗️ Designing Secure APIs: Best Practices

1. Authentication and Authorization

Use Strong Authentication Mechanisms: Implement OAuth 2.0 or JWT (JSON Web Tokens) for secure authentication.
Role-Based Access Control (RBAC): Assign permissions based on user roles to restrict access to sensitive endpoints.

2. Input Validation and Output Encoding

Sanitize Inputs: Validate all incoming data to prevent injection attacks.
Encode Outputs: Ensure that data returned by the API is properly encoded to prevent cross-site scripting (XSS) attacks.

3. Rate Limiting and Throttling

Prevent Abuse: Implement rate limiting to control the number of requests a client can make in a given timeframe.
Protect Resources: Throttling helps in managing traffic and preventing denial-of-service (DoS) attacks.

4. Secure Data Transmission

Use HTTPS: Encrypt data in transit using HTTPS to prevent eavesdropping.
TLS Protocols: Employ the latest Transport Layer Security (TLS) protocols for enhanced security.

5. Error Handling

Avoid Detailed Error Messages: Provide generic error responses to prevent information leakage.
Log Errors Securely: Maintain detailed logs for internal use without exposing sensitive information.

🚫 Common API Security Pitfalls (Anti-Patterns)

❌ 1. Exposing Sensitive Data

Returning unnecessary data in API responses can lead to data exposure.

❌ 2. Inadequate Authentication

Relying solely on API keys without additional authentication layers can be risky.

❌ 3. Lack of Input Validation

Failing to validate inputs can open doors to injection attacks.

❌ 4. Improper Error Handling

Detailed error messages can provide attackers with valuable information about the system.

📚 Real-World Case Studies

🏦 Case Study 1: Financial API Breach

Scenario: A financial institution exposed sensitive customer data due to inadequate authentication mechanisms.
Lesson Learned: Implementing multi-factor authentication and strict access controls is crucial.

🛍️ Case Study 2: E-commerce API Exploit

Scenario: An e-commerce platform suffered a data breach through an unprotected API endpoint.
Lesson Learned: Regular security audits and endpoint protection are essential.

🛠️ Tools and Resources for API Security

APIsec University: Free, hands-on API security training, covering API penetration testing and OWASP API Top 10 vulnerabilities.
freeCodeCamp: Comprehensive courses on securing API servers, including best practices for CORS, error handling, and rate limiting.
Security Journey: Features free OWASP Top 10 API Security Risks Training, focusing on real-world scenarios and mitigation strategies.
Skillsoft: Course on API Clean and Secure Coding, covering secure development practices.
Curity: Detailed course on API security and authorization best practices.

🧩 Integrating Security into the API Development Lifecycle

🔄 Secure Development Lifecycle (SDL)

Design Phase: Incorporate security requirements and threat modeling.
Development Phase: Adhere to secure coding practices and conduct code reviews.
Testing Phase: Perform security testing, including penetration testing and vulnerability scanning.
Deployment Phase: Ensure secure configurations and monitor for anomalies.

📈 Future Trends in API Security

Zero Trust Architecture: Adopting a security model that requires strict identity verification for every person and device.
AI and Machine Learning: Utilizing AI for anomaly detection and predictive threat analysis.
API Security Standards: Emergence of standardized protocols and frameworks for API security.

🎯 Conclusion

Securing APIs is not a one-time task but an ongoing process that requires vigilance, regular updates, and adherence to best practices.

By understanding the fundamentals, avoiding common pitfalls, and leveraging available resources, developers can build APIs that are not only functional but also secure.

📌 Additional Resources

By integrating these practices and continuously educating yourself, you can stay ahead in the ever-evolving landscape of API security. 🚀

🛡️ Why It's Crucial to Protect Your API Keys and API Tokens

Anis Ali Khan — Sat, 26 Apr 2025 05:02:55 +0000

APIs are the bloodstream of modern software. But with great connectivity comes great responsibility. Your API keys and API tokens are like passwords — if they leak, bad things happen. Let's explore why protecting them is critical, with real-world horror stories 👻, smart protection patterns 💡, and dangerous anti-patterns ⚠️.

🔥 Real-World API Key Horror Stories

1. OpenAI API Key Leaks

Incident: Developers building AI apps sometimes hardcoded their OpenAI API keys into their client-side JavaScript. Once deployed, those keys became public.
Impact: Attackers abused those keys to rack up thousands of dollars in usage fees, generating text and images nonstop.
Example: Some OpenAI customers reported surprise bills exceeding $10,000+ after keys were stolen and used to generate massive volumes of text with GPT models.

2. AWS Access Key Leak on GitHub

Incident: A developer accidentally committed AWS access keys to a public GitHub repo.
Impact: Within minutes, bots scanning GitHub detected the keys. Attackers spun up hundreds of EC2 instances for crypto mining.
Example: One AWS customer got a bill of $50,000+ within a single weekend before they noticed the breach.

3. Cloudflare API Token Abuse

Incident: A leaked Cloudflare API token allowed an attacker to modify DNS records.
Impact: The attacker redirected domain traffic to a phishing site.
Example: Companies experienced downtime and customer trust loss because their website was pointing to malicious pages.

🤖 Why API Keys Are So Dangerous When Leaked

They bypass authentication: If someone has the key, it's as good as being you.
They can be abused at scale: APIs don't always have request limits.
They are often tied to billing: Abuse can cost real money.
They grant admin access: Many keys aren't scoped down to minimum permissions.

💡 Best Practices (Patterns) for Protecting API Keys

🔒 1. Never store API keys in client-side code

Solution: Use a backend server to call APIs securely.

🔒 2. Use environment variables

Solution: Store keys in .env files (never commit .env files) and load them securely in your app.

🔒 3. Rotate API keys regularly

Solution: Set up key rotation schedules (monthly/quarterly) and automate it if possible.

🔒 4. Use fine-grained permissions

Solution: Grant the minimum permissions needed (principle of least privilege).

🔒 5. Set up usage quotas and billing alerts

Solution: Configure alerts to detect sudden spikes.

🔒 6. Audit and monitor key usage

Solution: Regularly review API logs for unusual behavior.

🔒 7. Use secrets management tools

Solution: Use tools like AWS Secrets Manager, HashiCorp Vault, or Azure Key Vault.

⚠️ Dangerous Anti-Patterns to Avoid

❌ 1. Hardcoding API keys in source code

Especially client-side (JavaScript, iOS, Android apps).

❌ 2. Uploading secrets to GitHub without protection

Even in private repos, leaks can happen.

❌ 3. Using the same API key across environments

Dev, test, staging, production — each should have isolated keys.

❌ 4. Assigning full admin rights to every API key

Reduces ability to contain damage.

❌ 5. Failing to monitor or alert on API key usage

Blindness = high risk.

🔧 Quick Checklist Before Going Live

Step	Done?
No hardcoded API keys?	✅ / ❌
Keys stored securely (env vars / secrets manager)?	✅ / ❌
Keys are scoped to minimum required permissions?	✅ / ❌
Billing alerts configured?	✅ / ❌
Logging and monitoring active?	✅ / ❌
Rotation schedule set?	✅ / ❌

🌟 Final Thoughts

Think of your API keys as house keys 🏠. Would you leave them taped to your front door? 🤔

Protecting your API keys isn't just a good idea — it's critical to your business's security, reputation, and financial health. Stay safe out there!

✨ Bonus Tip: Detect Leaks Early

Use GitHub secret scanning or tools like Gitleaks to catch accidental commits before they go public! ⚡️

🧠 Kubernetes Learning Path (in VS Code)

Anis Ali Khan — Sat, 26 Apr 2025 03:11:57 +0000

1. Set Up Your Environment

Install VS Code
Install Extensions:
- Kubernetes Extension
- YAML Extension
- Docker Extension
- Helm Extension
Install Minikube or Kind
Install kubectl (Kubernetes CLI)

2. Kubernetes Basics (Hands-On)

Core concepts:
- Pods
- Deployments
- Services
- ConfigMaps
- Secrets
Mini-projects:
- Deploy a simple Hello World app
- Expose it via a Service
VS Code tips:
- Use YAML templates
- Use Kubernetes extension view to manage resources

3. Intermediate Kubernetes

Learn:
- Volumes & Persistent Storage
- Probes (liveness, readiness)
- Namespaces
- Resource limits/requests
Projects:
- App with PersistentVolumeClaim (PVC)
- Add readiness/liveness probes
VS Code tips:
- Use custom YAML snippets

4. Helm Charts

Install Helm CLI
Learn:
- Charts
- Packaging and deploying apps
Projects:
- Convert deployment to a Helm chart
VS Code tips:
- Helm extension for better template editing

5. Advanced Topics

Explore:
- Ingress Controllers
- Network Policies
- RBAC
- Custom Resources (CRDs)
- Operators (bonus)
Projects:
- Set up TLS Ingress with cert-manager
- Write a simple CRD

6. Real World: CI/CD & GitOps

Set up GitHub Actions to deploy to Kubernetes
Explore ArgoCD or FluxCD
Projects:
- Git push triggers auto-deployment

🗺️ Visual Summary

Stage	Focus	Tools/Extensions	Project
Setup	Environment	VS Code, kubectl, Minikube/Kind	Connect to cluster
Beginner	Core Kubernetes Objects	Kubernetes Extension, YAML Extension	Deploy Hello World
Intermediate	Storage, Probes, Namespaces	Kubernetes Extension, Docker Extension	Persistent App Deployment
Helm	App Templating	Helm Extension	Helmify your App
Advanced	Networking, RBAC, CRDs	Kubernetes Extension	TLS Ingress Route
Real World	CI/CD, GitOps	GitHub Actions	Auto Deploy on Push

Bonus Tips

Practice kubectl in VS Code terminal
Install K9s for quick resource browsing
Use Kind for multi-node local clusters

Happy Shipping! 🚀

Appanomics: The Yen and Outs of Publishing on the App Store 💴📱

Anis Ali Khan — Thu, 03 Apr 2025 14:04:14 +0000

📱 Apple App Store にアプリを公開するには、Apple Developer Program に登録する必要があります。登録費用は年間 99 米ドルです。

🏢 企業向けの高度な機能が必要な場合は、Apple Developer Enterprise Program（年間 299 米ドル）を検討できます。ただし、これは社内向けの配布専用であり、一般公開はできません。

🔍 その他の考慮すべき費用：

• 🛠 アプリ開発ツール： Xcode は無料ですが、サードパーティのライブラリやサービスが必要になる場合があります。

• 💻 Mac ハードウェア：アプリを開発・提出するには Mac が必要です。

• 🧪 アプリのテスト： TestFlight や実機テストサービスを利用する場合は追加費用がかかることがあります。

• 🎨 アプリのデザインと開発：開発者やデザイナーを雇う場合、その費用が発生します。

• 💰 アプリ内課金とサブスクリプション： Apple は収益の 15〜30% を手数料として受け取ります。

✨

Tutorial 31: 📱 UserDefaults and Keychain - Storing Small Amounts of Data Securely

Anis Ali Khan — Wed, 02 Apr 2025 20:41:35 +0000

Build a Secure Notes iPhone App

🔐 In this tutorial, you’ll learn how to securely store small amounts of data using UserDefaults and Keychain in Swift. We’ll build a Secure Notes app where users can create simple text notes, with the option to store them securely using Face ID / Touch ID authentication.

⸻

📖 Table of Contents

📌 Introduction
🛠 Project Setup
💾 Storing Data with UserDefaults
🔐 Storing Secure Data in Keychain
🎨 Creating the UI
📲 Implementing Face ID Authentication
🚀 Running & Testing the App
🔗 Conclusion & Next Steps

⸻

📌 Introduction

iOS provides two main ways to store small amounts of data securely:
• UserDefaults: Ideal for storing non-sensitive data like user preferences.
• Keychain: Used for storing sensitive data like passwords, API keys, or private notes.

In this tutorial, we’ll build Secure Notes, a minimalist note-taking app where:
✅ Normal notes are stored in UserDefaults*
✅ Secure notes are stored in **Keychain, requiring Face ID / Touch ID to access

⸻

🛠 Project Setup

1️⃣ Create a New Xcode Project

Open Xcode and select “Create a new Xcode project”
Choose App, then click Next
Set the following: • Product Name: SecureNotes • Interface: SwiftUI • Language: Swift
Click Next, choose a location, and click Create.

2️⃣ Enable Face ID (for later)

In Xcode, go to Signing & Capabilities
Click + Capability → Keychain Sharing
Click + Capability → Face ID

⸻

💾 Storing Data with UserDefaults

We’ll first store simple notes using UserDefaults.

1️⃣ Create a Model for Notes

Create a new Swift file: Note.swift

import Foundation

struct Note: Identifiable, Codable {
    var id: UUID = UUID()
    var text: String
    var isSecure: Bool
}

2️⃣ Create a UserDefaults Helper

Create a new Swift file: UserDefaultsManager.swift

import Foundation

class UserDefaultsManager {
    private let key = "savedNotes"

    func saveNotes(_ notes: [Note]) {
        if let encoded = try? JSONEncoder().encode(notes) {
            UserDefaults.standard.set(encoded, forKey: key)
        }
    }

    func loadNotes() -> [Note] {
        if let savedData = UserDefaults.standard.data(forKey: key),
           let decoded = try? JSONDecoder().decode([Note].self, from: savedData) {
            return decoded
        }
        return []
    }
}

⸻

🔐 Storing Secure Data in Keychain

Since Keychain doesn’t support Swift’s Codable directly, we’ll write a wrapper.

1️⃣ Create a Keychain Helper

Create a new Swift file: KeychainManager.swift

import Security
import Foundation

class KeychainManager {
    static let shared = KeychainManager()

    func save(_ note: Note) {
        let key = note.id.uuidString
        guard let data = try? JSONEncoder().encode(note) else { return }

        let query: [String: Any] = [
            kSecClass as String: kSecClassGenericPassword,
            kSecAttrAccount as String: key,
            kSecValueData as String: data
        ]
        SecItemAdd(query as CFDictionary, nil)
    }

    func load(id: UUID) -> Note? {
        let key = id.uuidString
        let query: [String: Any] = [
            kSecClass as String: kSecClassGenericPassword,
            kSecAttrAccount as String: key,
            kSecReturnData as String: true,
            kSecMatchLimit as String: kSecMatchLimitOne
        ]

        var dataTypeRef: AnyObject?
        if SecItemCopyMatching(query as CFDictionary, &dataTypeRef) == errSecSuccess,
           let data = dataTypeRef as? Data,
           let note = try? JSONDecoder().decode(Note.self, from: data) {
            return note
        }
        return nil
    }
}

⸻

🎨 Creating the UI

Create a simple SwiftUI interface.

1️⃣ Create the Notes List

Modify ContentView.swift

import SwiftUI

struct ContentView: View {
    @State private var notes: [Note] = UserDefaultsManager().loadNotes()
    @State private var newText: String = ""

    var body: some View {
        NavigationView {
            VStack {
                TextField("Enter your note", text: $newText)
                    .textFieldStyle(RoundedBorderTextFieldStyle())
                    .padding()

                Button("Save Note") {
                    let note = Note(text: newText, isSecure: false)
                    notes.append(note)
                    UserDefaultsManager().saveNotes(notes)
                    newText = ""
                }
                .buttonStyle(.borderedProminent)

                List(notes) { note in
                    Text(note.text)
                }
            }
            .navigationTitle("Secure Notes")
        }
    }
}

⸻

📲 Implementing Face ID Authentication

Add LocalAuthentication to ContentView.swift

import LocalAuthentication

func authenticateUser(completion: @escaping (Bool) -> Void) {
    let context = LAContext()
    var error: NSError?

    if context.canEvaluatePolicy(.deviceOwnerAuthenticationWithBiometrics, error: &error) {
        context.evaluatePolicy(.deviceOwnerAuthenticationWithBiometrics, localizedReason: "Access Secure Notes") { success, _ in
            DispatchQueue.main.async {
                completion(success)
            }
        }
    } else {
        completion(false)
    }
}

Use Face ID before loading secure notes:

Button("Load Secure Note") {
    authenticateUser { success in
        if success {
            if let secureNote = KeychainManager.shared.load(id: someUUID) {
                print("Secure Note:", secureNote.text)
            }
        }
    }
}

⸻

🚀 Running & Testing the App

✅ Run on a real device to test Face ID / Touch ID.
✅ Save regular notes → Restart the app → Check if they persist.
✅ Save a secure note → Restart → Authenticate with Face ID → Retrieve it.

⸻

🔗 Conclusion & Next Steps

🎉 Congratulations! You’ve built Secure Notes, learning:
✅ How to use UserDefaults for non-sensitive data
✅ How to use Keychain for secure storage
✅ How to authenticate users with Face ID / Touch ID

📌 Next Steps:
• Add a delete note feature.
• Support multiple secure notes.
• Implement Dark Mode UI improvements.

🚀 Happy Coding! 🚀