AI agents have become a normal part of my development workflow.

At first, I used them for small tasks: fixing a function, adding a test, cleaning up a README, or reviewing a small diff.

Over time, I started giving them larger chunks of work: reading an issue, making a plan, implementing the change, running tests, reviewing the result, and preparing a commit.

The productivity gain was real.

But while running a side project with increasingly agent-driven workflows, I started feeling a different kind of friction.

The more work I delegated to agents, the less visible the workflow became.

There is a big difference between “the agent is doing work” and “I understand and control how that work is happening.”

Automation Was Powerful, but the Flow Was Hard to See

A typical agent-assisted development routine often looks something like this:

plan → implement → review → commit → merge → deploy

But real project work is rarely that clean.

Sometimes review sends the work back to implementation. Sometimes I want to commit but not merge yet. Sometimes I need to check token usage between large steps.

The problem was that these flows were usually buried inside long prompts, terminal output, command history, and TUI sessions.

I often found myself asking:

• Which step is running now?
• Which steps already finished?
• Where did the workflow fail?
• What is supposed to happen next?
• Where should I intervene manually?

The more useful the automation became, the harder it became to see the shape of the automation. That was the starting point for “Circuit”.

What Is Circuit?

4 key features

Circuit is a desktop app I made for building and running visual workflows from Claude and Codex skills.

It reads skills from a local repository, such as:

.claude/skills/*/SKILL.md
.codex/skills/*/SKILL.md

1. Build Visual Skill Workflows

Then it lets you place those skills on a canvas, connect them with dependencies, and run the workflow from one place.

For example, you can build a flow like this:

planning → implementation → review → commit

If the routine changes, the graph can change with it:

planning → implementation → commit → review

If you need an extra check in the middle, you can add one:

planning → check-token → implementation → review → wrap-up

The goal is not just to run one skill. The goal is to turn repeated agent routines into visible, editable workflows.

2. Use Claude And Codex Together

One thing I wanted to avoid was designing Circuit around a single agent runtime.

In real projects, agent automation is already mixed. Some workflows may exist as Claude skills. Others may be managed as Codex skills. Even within the same project, different tasks may benefit from different models or execution environments.

Circuit does not treat Claude and Codex as competing tools.

It treats them as different execution capabilities that belong to the same local project.

The actual skill files stay where they already live. Circuit does not move them into a new format or force a separate abstraction on top of them. It reads the existing skill files, shows them on the canvas, and provides a visual layer for defining order and dependencies.

3. Track Execution State

Designing a workflow is only half of the problem.

The other half is understanding what happens while it runs.

When a workflow runs in Circuit, the canvas and run log show which skill is currently running, which steps have completed, and where a failure happened.

That matters because agent work can otherwise feel like a black box. A long-running agent session may be doing exactly what you asked, but if you cannot see the current step or failure point, you still have to reconstruct the state from logs and prompts.

Circuit is meant to reduce that friction.

4. Handle Loops

Not every workflow is a straight line.

Some routines need repetition. A failed review might go back to implementation. A validation step might repeat until a condition is satisfied. A long workflow may need a check or compact step before continuing.

Circuit allows workflows with loops, but it treats them carefully.

Because a cyclic graph can run indefinitely, Circuit warns before execution and asks for explicit confirmation. The important part is that the loop is visible on the canvas. You can see which skill will run again and adjust the workflow before starting it.

The loop is not hidden inside a prompt or command chain.

Closing Thought

As AI agents become more capable, we will spend less time writing every line of code by hand.

But we will spend more time designing how agents work.

That workflow deserves a real interface.

Circuit is a small step in that direction: a visual harness for skill-based AI agent workflows, built from the friction I felt while running my own side project.

You can meet the Circuit in here

GitHub - CIrcui-try/Circuit: Skill-Based AI Agent Harness Editor

Thanks for reading!

Managing URL redirections within SwiftUI applications often results in scattered, repetitive code, making maintenance cumbersome and error-prone.

Developers frequently face challenges in keeping redirection logic consistent and easily manageable across various parts of the app.

In this post, I’ll share how to achieve centralized URL management effortlessly using SwiftUI, making your applications cleaner and easier to maintain.

Quick promo 🔊

I’ve created a lightweight Swift package to simplify this process. If you’re interested, please check out the GitHub repo:

GitHub - enebin/ShopIt: One line, one tap. Redirect with ShopIt

The Problem with SwiftUI URL Redirection

Typically, developers handle URL redirection individually within views, often duplicating logic and cluttering the view layer.

This scattered approach means every button or interactive element that requires redirection must handle its own logic independently, leading to repetitive boilerplate and increased chances of errors.

Consider a button triggering a redirect;

@Environment(\.openURL) private var openURL
Button("Redirect") {
    openURL(schemeLink) { accepted in
        if !accepted {
            openURL(webLink) { accepted in
                if !accepted {
                    print("🚨 Unable to redirect to the web page")
                }
            }
        }
    }
}

This approach scatters URL management logic throughout the app, increasing complexity.

Introducing a Centralized Approach

My solution employs clearly defined abstractions (Redirectable) and reusable components (RedirectButton) that encapsulate the redirection logic into a single place.

This significantly simplifies implementation, boosts consistency, and eases future updates.

Core Components

1. Redirectable Protocol

Defines the necessary properties for redirection:

public protocol SchemeRedirectable {
   var schemeUrl: QueryableURL { get }
}
public protocol WebRedirectable {
   var webUrl: QueryableURL { get }
}

public protocol Redirectable: SchemeRedirectable & WebRedirectable {}

2. QueryableURL Struct

Manages URL creation with dynamic queries, ensuring safer and more flexible URL handling:

public struct QueryableURL {
    public let baseURL: URL
    public let queryBuilder: (String) -> [URLQueryItem]
    public func url(with keyword: String) -> URL? {
        guard var components = URLComponents(url: baseURL, resolvingAgainstBaseURL: false) else {
            return nil
        }
        
        let newQueryItems = queryBuilder(keyword)
        components.queryItems = (components.queryItems ?? []) + newQueryItems
        
        return components.url
    }
}

3. Redirector

The Redirector class handles URL redirection logic centrally, automatically managing scheme URLs with seamless fallback to web URLs:

public final class Redirector {
    public private(set) var openUrlAction: OpenURLAction?

    public func register(_ opener: OpenURLAction) { openUrlAction = opener }

    public func redirect(keyword: String, to redirection: some Redirectable) async throws {
        let primary = redirection.schemeUrl
        let fallback = redirection.webUrl
        
        do { try await openLink(using: primary, keyword: keyword) }
        catch { try await openLink(using: fallback, keyword: keyword) }
    }
}


private extension Redirector {
    func openLink(using queryable: QueryableURL, keyword: String) async throws {
        guard let url = queryable.url(with: keyword) else {
            throw Error.invalidURL
        }
        
        try await performOpenUrlAction(url)
    }
    
    func performOpenUrlAction(_ url: URL) async throws  {
        guard let openUrlAction else {
            throw Error.openUrlActionNotSet
        }
        
        return try await withCheckedThrowingContinuation { continuation in
            Task { @MainActor in
                openUrlAction(url) { accepted in
                    if accepted {
                        continuation.resume(returning: ())
                    } else {
                        continuation.resume(throwing: Error.cannotOpenURL)
                    }
                }
            }
        }
    }
}

Don’t forget to register openURL when use this. The reason it’s registered externally rather than declared directly here is because openURL must be called within the context of a SwiftUI View.

Also, you can add a flag such as redirectPriority to adjust the priority between web and scheme links according to your needs.

4. RedirectButton View

A reusable button component that encapsulates the redirection logic cleanly within the view layer:

public struct RedirectButton<Content, Redirection>: View
where Content: View, Redirection: Redirectable {
    @Environment(\.openURL) private var openURL

    private let content: () -> Content
    private let keyword: String
    private let redirection: Redirection
    
    public init(keyword: String, redirection: Redirection, @ViewBuilder content: @escaping () -> Content) {
        self.content = content
        self.keyword = keyword
        self.redirection = redirection
    }
    
    public var body: some View {
        Button(
            action: {
                Task {
                    do {
                        try await Redirector.shared.redirect(keyword: keyword, to: redirection)
                    }catch {
                        print("🚨 Error occurs: \(error.localizedDescription)")
                    }
                }
            },
            label: content
        )
        .task {
            if redirector.openUrlAction == nil {
                redirector.register(openURL)
            }
        }
    }
}

4. RedirectButton View

RedirectButton encapsulates URL redirection logic by leveraging the ShopitRedirector, simplifying its usage within the view layer:

public struct RedirectButton<Content, Redirection>: View
where Content: View, Redirection: Redirectable {
    @Environment(\.openURL) private var openURL

    private let content: () -> Content
    private let keyword: String
    private let redirection: Redirection

    public var body: some View {
        Button {
            Task { try await redirector.redirect(keyword: keyword, to: redirection) }
        } label: {
            content()
        }
        .task {
            if redirector.openUrlAction == nil {
                redirector.register(openURL)
            }
        }
    }
}

Practical Example: Google Search

With this structured approach, adding redirection buttons to your SwiftUI views becomes extremely straightforward and consistent:

public struct GoogleSearchRedirection: Redirectable {
    public let schemeUrl = QueryableURL(baseURL: URL(string: "google://search")!) { [URLQueryItem(name: "q", value: $0)] }
    public let webUrl = QueryableURL(baseURL: URL(string: "https://www.google.com/search")!) { [URLQueryItem(name: "q", value: $0)] }
}

RedirectButton(keyword: "iPhone", redirection: .googleSearch) {
    Text("Search iPhone on Google!")
}
.buttonStyle(.borderedProminent)

With this centralized structure, implementing new redirections becomes straightforward and error-resistant.

Conclusion

Centralizing URL redirections with SwiftUI reduces complexity, minimizes errors, and significantly improves app maintainability and scalability.

Integrate this approach into your next SwiftUI project for smoother, more efficient URL handling!

In today’s tech-savvy world, creating apps that understand human emotions is within reach. Facial expressions recognition, powered by Apple’s Core ML and Vision frameworks, allows your iOS apps to interpret users’ emotions from their facial cues.

This guide will take you step-by-step through building this innovative feature, making it easy to add emotional intelligence to your applications.

Whether you’re an experienced developer or a beginner, you’ll learn how to create more engaging and responsive apps with facial expressions recognition on iOS. Let’s get started!

Before that, I have already created a Swift Package that compresses the tedious process ahead, making it easy to use.

You can use the facial expression reconition with just a single line of code! It also fully supports UIImage, CGImage and SwiftUI’s Image. If you want to quickly utilize this feature, try using this package 😉

GitHub - enebin/Mentalist: Read face with a line of code 🎭

Step 1: Converting a .h5 file to a CoreML Model

To integrate facial expressions recognition into your iOS app, the first step is converting your Python-trained model (in .h5 format) to a CoreML model. Here’s how:

1. Set Up Environment:

• Install Python and the necessary libraries: coremltools and tensorflow or keras.

2. Load the h5 Model:

• Use TensorFlow or Keras to load your trained h5 model.
• In this post, we will the pre-trained weights(facial_expression_model_weights.h5) from Deepface which has 57% of accuracy with FER2013.

3. Convert to CoreML:

• Utilize coremltools to convert your h5 model, specifying input and output layers.

4. Save the CoreML Model:

• Save the converted model with a .mlmodel extension.

This part is slightly beyond the scope of iOS development. I have provided the code below that can be used here, so please review and run it yourself. By doing so, you will be able to obtain the CoreML model.

Step 2: Preprocessing and Handling Images

To effectively recognize facial expressions, it is crucial to preprocess the images. This step involves converting images to a suitable format and preparing them for analysis. Here’s how to do it on iOS using Swift:

1. Convert to Grayscale

• Grayscale images simplify the processing and reduce computational load. Use Core Image filters to convert the image to grayscale.

2. Resize Image

• Resize the image to a standard size (e.g., 48x48 pixels). This ensures uniformity and makes the model’s job easier.

3. Normalize Image

• Normalize the pixel values to a range suitable for the model (typically 0 to 1). This helps in improving the model’s accuracy.

4. Face Detection

• Detect faces within the image using Vision framework’s face detection capabilities.

5. Crop Faces

• Crop the detected face regions from the image for further analysis.

Here’s the Swift code implementing these steps:

Step 3: Passing the Image to CoreML for Analysis

Once the image is preprocessed, the next step is to pass it to your CoreML model for facial expression analysis.

This involves loading the CoreML model, detecting faces, preprocessing each face, and then using the model to analyze the emotions. Here’s how to do it:

1. Initialize the CoreML Model

• Load your CoreML model using the VNCoreMLModel class.

2. Detect Faces

• Use the FaceImageTool to detect faces in the input image.

3. Preprocess Each Face

• For each detected face, crop and preprocess the face image to prepare it for the model.

4. Perform Emotion Analysis

• Pass the preprocessed face image to the CoreML model for emotion analysis.
• Extract and interpret the results from the model’s output.

Here’s the Swift code implementing these steps:

Done!

All you need to do is create the MLCore and provide it with a picture of a person making a facial expression like:

let analysis = MLCore().analyze(uiImage: UIImage("some_face")?.cgImage)
print(analysis.map { $0.dominantEmotion })
// [happy, sad]

What is Prototype pattern?

The Prototype pattern is a creational design pattern that lets you copy existing objects without making your code dependent on their classes. It involves three key components:

Prototype Interface

This interface declares the methods for cloning itself. The interface ensures that all prototypes can be cloned interchangeably.

Concrete Prototypes

These are classes that implement the prototype interface and define the method to clone themselves. Each offers a different way of performing a cloning operation based on their internal states.

Client

An object that holds a reference to a prototype and delegates the cloning process to the prototype. The client can dynamically choose among different prototypes to clone, depending on the runtime requirements.

Why should we use it?

This pattern is useful for scenarios where object creation is costly or complex but a similar object already exists. It helps keep the system flexible and maintainable by enabling objects to produce their copies. This avoids coupling to the concrete classes of objects that need to be copied.

It follows the open/closed principle by allowing new object types to be introduced with minimal changes to the existing code.

Real World Examples

1. Document Management System

Imagine a system where documents can be created and edited. A user might want to make a copy of an existing document to use as a base for a new document without starting from scratch.

• Prototype Interface: DocumentPrototype
• Concrete Prototypes: TextDocument, SpreadsheetDocument
• Client: The application interface or document manager that creates duplicates of documents.

// Prototype Interface
protocol DocumentPrototype {
     func clone() -> DocumentPrototype
}

// Concrete Prototypes
class TextDocument: DocumentPrototype {
     var content: String
     
     init(content: String) {
         self.content = content
         }
     
     func clone() -> DocumentPrototype {
         return TextDocument(content: self.content)
         }
}
class SpreadsheetDocument: DocumentPrototype {
     var data: [[Int]]
     
     init(data: [[Int]]) {
         self.data = data
         }
     
     func clone() -> DocumentPrototype {
         return SpreadsheetDocument(data: self.data)
         }
}

// Client
class DocumentManager {
     private var documents: [DocumentPrototype] = []
     
     func addDocument(_ document: DocumentPrototype) {
         documents.append(document)
         }
     
     func cloneDocument(at index: Int) -> DocumentPrototype? {
         guard index < documents.count else { return nil }
         return documents[index].clone()
         }
}

// Usage
let textDoc = TextDocument(content: "Initial content")
let spreadsheet = SpreadsheetDocument(data: [[1, 2], [3, 4]])
let manager = DocumentManager()
manager.addDocument(textDoc)
manager.addDocument(spreadsheet)

if let clonedTextDoc = manager.cloneDocument(at: 0) as? TextDocument {
     print("Cloned Text Document Content: \(clonedTextDoc.content)")
}
if let clonedSheet = manager.cloneDocument(at: 1) as? SpreadsheetDocument {
     print("Cloned Spreadsheet Data: \(clonedSheet.data)")
}

2. Game Character Generation

In a game where new characters can be spawned based on existing ones — each with potentially unique attributes (like health, strength, etc.) — the Prototype pattern allows for easy character duplication with modifications.

• Prototype Interface: GameCharacter
• Concrete Prototypes: Hero, Villain
• Client: The game environment or character manager.

// Prototype Interface
protocol GameCharacter {
     func clone() -> GameCharacter
     var health: Int { get set }
}

// Concrete Prototypes
class Hero: GameCharacter {
     var health: Int
     
     init(health: Int) {
         self.health = health
         }
     
     func clone() -> GameCharacter {
         return Hero(health: self.health)
         }
}
class Villain: GameCharacter {
     var health: Int
     
     init(health: Int) {
         self.health = health
         }
     
     func clone() -> GameCharacter {
         return Villain(health: self.health)
         }
}

// Client
class GameEnvironment {
     private var characters: [GameCharacter] = []
     
     func addCharacter(_ character: GameCharacter) {
         characters.append(character)
         }
     
     func cloneCharacter(at index: Int) -> GameCharacter? {
         guard index < characters.count else { return nil }
         return characters[index].clone()
         }
}

// Usage
let hero = Hero(health: 100)
let villain = Villain(health: 150)
let game = GameEnvironment()
game.addCharacter(hero)
game.addCharacter(villain)

if let clonedHero = game.cloneCharacter(at: 0) {
     print("Cloned Hero Health: \(clonedHero.health)")
}
if let clonedVillain = game.cloneCharacter(at: 1) {
     print("Cloned Villain Health: \(clonedVillain.health)")
}

Prototype pattern - Wikipedia

What is Adpator pattern?

The Adapter pattern is a structural design pattern that allows objects with incompatible interfaces to work together by converting the interface of one class into an interface expected by the clients. It involves three key components.

Target Interface

This is the common interface that the client expects to work with. It defines the domain-specific operations which the client understands.

Adapter

This is the class that implements the target interface and wraps the adaptee. The adapter translates the interface of the adaptee class into an interface that the client expects.

Adaptee

This is the class that has the existing interface but needs adapting before the client can use it.

Why should we use it?

This pattern is useful in scenarios where you want to reuse existing classes that do not have interfaces that are compatible with the other parts of an application.

It helps keep the system flexible and maintainable by enabling classes with differing interfaces to communicate and work together, thereby promoting reusability and preventing changes to existing code while introducing new interface implementations. This is aligned with the open/closed principle of software design, which promotes extension but discourages modification.

Real World Example

1: Legacy Database Integration

Suppose you are working on a modern application that needs to integrate with a legacy system. The legacy system provides data in a format that the new system cannot directly consume.

• Target Interface: NewDatabase
• Adapter: LegacyDatabaseAdapter
• Adaptee: LegacyDatabase

protocol NewDatabase {
     func fetchData() -> [String]
}

class LegacyDatabase {
     func retrieveData() -> [String] {
         return ["Data1", "Data2", "Data3"]
         }
}

class LegacyDatabaseAdapter: NewDatabase {
     private let legacyDatabase: LegacyDatabase
     
     init(_ legacyDatabase: LegacyDatabase) {
         self.legacyDatabase = legacyDatabase
         }
     
     func fetchData() -> [String] {
         return legacyDatabase.retrieveData() // Adapting data retrieval
     }
}

// Client code
let legacyDB = LegacyDatabase()
let adapter = LegacyDatabaseAdapter(legacyDB)
let data = adapter.fetchData()

print(data)

2. Third-party API Integration

Imagine integrating a third-party library that logs detailed analytics but your application’s logging interface is not compatible with the library’s methods.

• Target Interface: ApplicationLogger
• Adapter: AnalyticsLoggerAdapter
• Adaptee: ThirdPartyAnalytics

protocol ApplicationLogger {
     func log(message: String)
}

class ThirdPartyAnalytics {
     func sendAnalyticsEvent(info: [String: Any]) {
         print("Analytics Event: \(info)")
     }
}

class AnalyticsLoggerAdapter: ApplicationLogger {
     private var analytics: ThirdPartyAnalytics
     
     init(analytics: ThirdPartyAnalytics) {
         self.analytics = analytics
     }
     
     func log(message: String) {
         analytics.sendAnalyticsEvent(info: ["event": message])
     }
}

// Client code
let analytics = ThirdPartyAnalytics()
let logger = AnalyticsLoggerAdapter(analytics: analytics)
logger.log(message: "User logged in")

Adapter pattern - Wikipedia

What is Factory pattern?

The Factory pattern is a creational design pattern that provides an interface for creating objects in a superclass, but allows subclasses to alter the type of objects that will be created. It involves three key components:

Factory Interface

A common interface for creating objects. This interface defines a method for creating objects, but it’s up to the concrete factory classes to specify which class to instantiate.

Concrete Factories

Implementations of the factory interface. Each concrete factory is responsible for creating objects of a specific type. These factories instantiate objects based on the logic and criteria they encapsulate.

Products

The objects being created. All products follow a common interface or abstract class, and the factory’s method returns an object of this type. However, the concrete class of the object instantiated by the factory method is determined by the concrete factory.

Why should we use it

This pattern is useful when the exact types and dependencies of the objects your code should work with are not known in advance or when you want to provide a way to extend and modify created objects without changing existing code.

It promotes loose coupling by reducing the dependency of client classes on concrete classes, adhering to the open/closed principle of software design by allowing the system to be easily extended with new types of objects.

Real World Examples

1. Document Management System

Imagine a document management application that supports different types of documents, such as Text Documents, Spreadsheets, and Presentations.

Each document type has its own properties and behaviors but shares common functionalities like save, edit, and render. Using the Factory pattern, we can streamline the creation of these documents while keeping our system flexible and scalable.

• Factory Interface: DocumentFactory
• Concrete Factories: TextDocumentFactory, SpreadsheetFactory, PresentationFactory
• Products: Document, TextDocument, Spreadsheet, Presentation

// Product Interface
protocol Document {
    func save()
    func edit()
    func render()
}

// Concrete Products
class TextDocument: Document {
    func save() { print("Saving TextDocument") }
    func edit() { print("Editing TextDocument") }
    func render() { print("Rendering TextDocument") }
}

class Spreadsheet: Document {
    func save() { print("Saving Spreadsheet") }
    func edit() { print("Editing Spreadsheet") }
    func render() { print("Rendering Spreadsheet") }
}

class Presentation: Document {
    func save() { print("Saving Presentation") }
    func edit() { print("Editing Presentation") }
    func render() { print("Rendering Presentation") }
}

// Factory Interface
protocol DocumentFactory {
    func createDocument() -> Document
}

// Concrete Factories
class TextDocumentFactory: DocumentFactory {
    func createDocument() -> Document {
        return TextDocument()
    }
}

class SpreadsheetFactory: DocumentFactory {
    func createDocument() -> Document {
        return Spreadsheet()
    }
}

class PresentationFactory: DocumentFactory {
    func createDocument() -> Document {
        return Presentation()
    }
}

// Client code
func clientCode(factory: DocumentFactory) {
    let document = factory.createDocument()
    document.edit()
    document.save()
    document.render()
}

// Usage
let textFactory = TextDocumentFactory()
clientCode(factory: textFactory)

let spreadsheetFactory = SpreadsheetFactory()
clientCode(factory: spreadsheetFactory)

let presentationFactory = PresentationFactory()
clientCode(factory: presentationFactory)

2. Payment Gateway Integration for an E-commerce Platform

Imagine an e-commerce platform that needs to integrate multiple payment gateways to process transactions. Different payment gateways (like PayPal, Stripe, and Square) have their unique APIs and integration processes.

Using the Factory pattern, the platform can simplify the integration process, making it easier to add or switch payment gateways without affecting the core payment processing logic.

• Factory Interface: PaymentGatewayFactory
• Concrete Factories: PayPalFactory, StripeFactory, SquareFactory
• Products: PaymentGateway, which defines the common interface for all payment operations.

// Product Interface
protocol PaymentGateway {
    func authenticate()
    func makePayment(amount: Double)
}

// Concrete Products
class PayPal: PaymentGateway {
    func authenticate() { print("Authenticating with PayPal") }
    func makePayment(amount: Double) { print("Paying \(amount) using PayPal") }
}

class Stripe: PaymentGateway {
    func authenticate() { print("Authenticating with Stripe") }
    func makePayment(amount: Double) { print("Paying \(amount) using Stripe") }
}

class Square: PaymentGateway {
    func authenticate() { print("Authenticating with Square") }
    func makePayment(amount: Double) { print("Paying \(amount) using Square") }
}

// Factory Interface
protocol PaymentGatewayFactory {
    func createPaymentGateway() -> PaymentGateway
}

// Concrete Factories
class PayPalFactory: PaymentGatewayFactory {
    func createPaymentGateway() -> PaymentGateway {
        return PayPal()
    }
}

class StripeFactory: PaymentGatewayFactory {
    func createPaymentGateway() -> PaymentGateway {
        return Stripe()
    }
}

class SquareFactory: PaymentGatewayFactory {
    func createPaymentGateway() -> PaymentGateway {
        return Square()
    }
}

// Client code
func processPayment(factory: PaymentGatewayFactory, amount: Double) {
    let paymentGateway = factory.createPaymentGateway()
    paymentGateway.authenticate()
    paymentGateway.makePayment(amount: amount)
}

// Usage
let amountToPay = 99.99
processPayment(factory: PayPalFactory(), amount: amountToPay)
processPayment(factory: StripeFactory(), amount: amountToPay)
processPayment(factory: SquareFactory(), amount: amountToPay)

Factory method pattern - Wikipedia

What is Builder pattern?

The Builder pattern is a design pattern that separates the construction of a complex object from its representation, allowing the same construction process to create different representations.

It involves four key components:

Builder Interface

A common interface for building parts of a complex object. It defines the steps needed to build the object.

Concrete Builders

Implementations of the builder interface, each constructing and assembling parts of the product differently.

Director

An object that knows how to compose a complex object using the builder interface. It controls the construction process.

Product

The complex object that is being built. The final product constructed by the concrete builders, often with varying representations.

Why should we use it?

This pattern is useful for scenarios where a system needs to create complex objects that are composed of many parts or require an elaborate construction process.

• It provides flexibility in the construction process, allowing the creation of various representations of a product using the same construction code.
• By decoupling the construction of a complex object from its representation, the Builder pattern enables more control over the construction process and supports the construction of complex composite objects.

Real World Examples

1. Ordering a Customized Computer

• Builder Interface: ComputerBuilder
• Concrete Builders: GamingComputerBuilder, OfficeComputerBuilder, GraphicDesignComputerBuilder
• Director: ComputerShop
• Product: Computer

// Builder Interface
protocol ComputerBuilder {
    func setCPU(_ cpu: String)
    func setGPU(_ gpu: String)
    func setMemory(_ memory: String)
    func build() -> Computer
}

// Concrete Builders
class GamingComputerBuilder: ComputerBuilder {
    private var computer = Computer()
    
    func setCPU(_ cpu: String) {
        computer.cpu = cpu
    }
    
    func setGPU(_ gpu: String) {
        computer.gpu = gpu
    }
    
    func setMemory(_ memory: String) {
        computer.memory = memory
    }
    
    func build() -> Computer {
        return computer
    }
}

// Similar implementations for OfficeComputerBuilder and GraphicDesignComputerBuilder...

// Product
class Computer {
    var cpu: String?
    var gpu: String?
    var memory: String?
    
    func describe() {
        print("Computer with CPU: \(cpu ?? "N/A"), GPU: \(gpu ?? "N/A"), Memory: \(memory ?? "N/A")")
    }
}

// Director
class ComputerShop {
    private var builder: ComputerBuilder?
    
    func constructGamingComputer(builder: ComputerBuilder) {
        self.builder = builder
        builder.setCPU("High-end CPU")
        builder.setGPU("High-end GPU")
        builder.setMemory("32GB")
    }
    
    // Similar methods for constructOfficeComputer and constructGraphicDesignComputer...
    
    func getComputer() -> Computer? {
        return builder?.build()
    }
}

// Usage
let shop = ComputerShop()
let gamingBuilder = GamingComputerBuilder()

shop.constructGamingComputer(builder: gamingBuilder)
let gamingComputer = shop.getComputer()
gamingComputer?.describe()
// Output: Computer with CPU: High-end CPU, GPU: High-end GPU, Memory: 32GB

• In this example, the ComputerBuilder protocol defines the steps necessary for building a computer.
• This approach allows customers to customize their computer with different components while the construction process is abstracted away by the builder pattern, making the system flexible and maintainable.

2. Building a User Profile in a Social Media App

• Builder Interface: UserProfileBuilder
• Concrete Builder: UserProfileConcreteBuilder
• Director: (In this simplified example, we’ll use the builder directly without a director)
• Product: UserProfile

// Product
class UserProfile {
    var username: String
    var biography: String?
    var location: String?
    var interests: [String] = []
    var profilePictureURL: String?
    
    init(username: String) {
        self.username = username
    }
    
    func describe() {
        print("UserProfile(username: \(username), biography: \(biography ?? "N/A"), location: \(location ?? "N/A"), interests: \(interests.joined(separator: ", ")), profilePictureURL: \(profilePictureURL ?? "N/A"))")
    }
}

// Builder Interface
protocol UserProfileBuilder {
    func setUsername(_ username: String) -> UserProfileBuilder
    func setBiography(_ biography: String) -> UserProfileBuilder
    func setLocation(_ location: String) -> UserProfileBuilder
    func setInterests(_ interests: [String]) -> UserProfileBuilder
    func setProfilePictureURL(_ url: String) -> UserProfileBuilder
    func build() -> UserProfile
}

// Concrete Builder
class UserProfileConcreteBuilder: UserProfileBuilder {
    private var userProfile = UserProfile(username: "")
    
    func reset() {
        userProfile = UserProfile(username: userProfile.username)
    }
    
    func setUsername(_ username: String) -> UserProfileBuilder {
        userProfile.username = username
        return self
    }
    
    func setBiography(_ biography: String) -> UserProfileBuilder {
        userProfile.biography = biography
        return self
    }
    
    func setLocation(_ location: String) -> UserProfileBuilder {
        userProfile.location = location
        return self
    }
    
    func setInterests(_ interests: [String]) -> UserProfileBuilder {
        userProfile.interests = interests
        return self
    }
    
    func setProfilePictureURL(_ url: String) -> UserProfileBuilder {
        userProfile.profilePictureURL = url
        return self
    }
    
    func build() -> UserProfile {
        return userProfile
    }
}

// Usage
let builder = UserProfileConcreteBuilder()
let userProfile = builder.setUsername("john_doe")
                            .setBiography("Love to travel and code.")
                            .setLocation("New York, USA")
                            .setInterests(["Coding", "Traveling", "Photography"])
                            .setProfilePictureURL("http://example.com/profile.jpg")
                            .build()

userProfile.describe()

• This example shows how the Builder pattern facilitates the creation of complex objects (like a user profile) step-by-step.
• The UserProfileConcreteBuilder allows optional properties to be set flexibly, making it easy to create a UserProfile with just the required details or with a fully detailed profile.
• This approach enhances code readability and maintainability, especially when creating objects with numerous attributes or when some attributes are optional.

Other usages

Many open sources or frameworks widely use this pattern, especially those involving complex object creation, configuration management, and user interface construction.

Here are a few notable examples:

1. SwiftUI

Text("Hello, World!")
    .font(.title)
    .padding()
    .background(Color.yellow)
    .cornerRadius(10)

Although not a direct implementation of the Builder pattern in the traditional sense, SwiftUI’s way of constructing views with modifiers resembles the Builder pattern’s step-by-step construction and method chaining.

2. Spring Boot (Java)

new SpringApplicationBuilder()
   .sources(Application.class)
   .bannerMode(Banner.Mode.OFF)
   .run(args);

Spring Boot, a popular open-source Java-based framework, uses the Builder pattern to configure and bootstrap the application in a fluent API style.

For instance, the SpringApplicationBuilder class allows for the fluent configuration of a Spring application.

3. .NET Core & Entity Framework Core

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
   modelBuilder.Entity<Student>()
   .Property(s => s.Name)
   .IsRequired();
}

Entity Framework Core uses the Builder pattern extensively for model configuration in its Fluent API. Developers define the model configuration in the OnModelCreating method using the ModelBuilder class.

• Builder
• Builder pattern - Wikipedia

What is Memento pattern?

The Memento pattern is a design pattern that allows an object to save its state to a memento and restore it to a previous state from a memento without revealing its implementation details.

It involves three key components

1. Originator

The object whose state needs to be saved and can be restored to a previous state.

2. Memento

An object that stores the state of the originator. It has two interfaces; Caretaker sees a narrow interface that allows it to store and retrieve the memento, while Originator sees a wide interface that allows it to access all the data necessary to restore the previous state.

3. Caretaker

An object that keeps the memento. The caretaker requests a save from the originator to capture the current state and uses the memento to bring the originator back to a previous state. However, it does not modify the memento itself.

Why should we use it?

It helps in keeping the history of an object’s state without exposing its internal structure, thus following the encapsulation principle.

This pattern is especially useful for implementing undo mechanisms or for saving and restoring the state of an object at a given point in time.

Real world example

1. Text Editor Undo Feature

• Originator: TextEditor
• Memento: EditorState
• Caretaker: History

// Originator
class TextEditor {
    private var content: String = ""
    
    func type(_ text: String) {
        content += text
    }
    
    func save() -> EditorState {
        return EditorState(content: content)
    }
    
    func restore(state: EditorState) {
        content = state.getContent()
    }
    
    func getContent() -> String {
        return content
    }
}

// Memento
class EditorState {
    private let content: String
    
    init(content: String) {
        self.content = content
    }
    
    func getContent() -> String {
        return content
    }
}

// Caretaker
class History {
    private var states = [EditorState]()
    
    func save(state: EditorState) {
        states.append(state)
    }
    
    func undo() -> EditorState? {
        return states.popLast()
    }
}

// Usage
let editor = TextEditor()
let history = History()
editor.type("First Sentence. ")
history.save(state: editor.save())
editor.type("Second Sentence. ")
history.save(state: editor.save())

// User decides to undo the last action
if let prevState = history.undo() {
    editor.restore(state: prevState)
}
print(editor.getContent())
// Output: First Sentence.

• This example demonstrates the Memento pattern applied in a text editor for an undo feature, where the TextEditor acts as the Originator, capable of saving its state (EditorState) and restoring it later.
• This setup allows the application to revert the text editor’s content to a previous state, encapsulating the complexities of state management and ensuring the editor’s internal structure is not exposed.

2. Game State Save and Load System

• Originator: GameLevel
• Memento: GameState
• Caretaker: SaveLoadManager

// Originator
class GameLevel {
    private var level: Int
    private var checkpoints: Int
    
    init(level: Int, checkpoints: Int) {
        self.level = level
        self.checkpoints = checkpoints
    }
    
    func play(newLevel: Int, newCheckpoints: Int) {
        level = newLevel
        checkpoints = newCheckpoints
    }
    
    func save() -> GameState {
        return GameState(level: level, checkpoints: checkpoints)
    }
    
    func restore(state: GameState) {
        level = state.getLevel()
        checkpoints = state.getCheckpoints()
    }
    
    func displayStatus() {
        print("Level: \(level), Checkpoints: \(checkpoints)")
    }
}

// Memento
class GameState {
    private var level: Int
    private var checkpoints: Int
    
    init(level: Int, checkpoints: Int) {
        self.level = level
        self.checkpoints = checkpoints
    }
    
    func getLevel() -> Int {
        return level
    }
    
    func getCheckpoints() -> Int {
        return checkpoints
    }
}

// Caretaker
class SaveLoadManager {
    private var saves = [GameState]()
    
    func save(state: GameState) {
        saves.append(state)
    }
    
    func load() -> GameState? {
        return saves.last
    }
}

// Usage
let game = GameLevel(level: 1, checkpoints: 5)
let manager = SaveLoadManager()

// Playing game…
game.play(newLevel: 2, newCheckpoints: 10)
manager.save(state: game.save())
// Further progress…
game.play(newLevel: 3, newCheckpoints: 20)
// Need to revert to the previous state
if let savedGame = manager.load() {
    game.restore(state: savedGame)
}

game.displayStatus()
// Output: Level: 2, Checkpoints: 10

• This example illustrates the Memento pattern in a gaming context, where the GameLevel acts as the Originator, capable of saving its current state (level and checkpoints) into a GameState (the Memento) and restoring from it.
• This system enables a save and load functionality, allowing players to save their progress and return to a saved state later, encapsulating the state saving logic while maintaining game level encapsulation.

• Memento pattern - Wikipedia
• Memento