Skip to content

aflockofswifts/meetings

BranchesTags

Folders and files

NameName
Last commit message
Last commit date

Latest commit

 

History

561 Commits
2020
2020
 
 
2021
2021
 
 
2022
2022
 
 
2023
2023
 
 
2024
2024
 
 
2025
2025
 
 
images
images
 
 
materials
materials
 
 
.gitignore
.gitignore
 
 
README.md
README.md
 
 
summarize.md
summarize.md
 
 

Repository files navigation

A Flock of Swifts

Flock We are a group of people excited by the Swift language. We meet each Saturday morning to share and discuss Swift-related topics.

All people and all skill levels are welcome to join.
RSVP: https://www.meetup.com/A-Flock-of-Swifts/

Archives

2026.06.06

2026.05.30

2026.05.23

Mihaela's shares:

Image / Link Summary
Kiraa
Kiraa		 YouTube channel by Errol Brandt focused on practical, skeptical analysis of AI and technology for business decision-makers. The channel pushes back on AI hype, with videos about AI economics, cloud AI, Apple/ARM hardware, open source, token usage, and the Kiraa engine.
TileDown/tile-down
TileDown/tile-down		 A Swift static site generator called tiledown. It parses a constrained Markdown profile into typed tiles, then renders static HTML/CSS and optional browser JavaScript. It supports CommonMark/GFM basics, build-time math-to-SVG, charts, Mermaid, RSS, article PDFs, theming, and a local preview CLI.
mihaelamj/cupertino-desktop
mihaelamj/cupertino-desktop		 Early-stage native Apple-platform app for browsing Apple Developer documentation, Swift Evolution

Articles discussed:

Image / Link Summary
Monads are Easy
Monads are Easy		 Explains monads using a concrete warehouse/book-scanning analogy. The post frames a monad as something that can wrap a value and flatten nested containers via flatMap, then tests that idea against arrays, optionals, results, custom structs, and JSON.
Replacing Bash with Swift in an AI Harness
Replacing Bash with Swift in an AI Harness		 Describes replacing a Bash tool in an AI coding harness with embedded Swift via SwiftScript. The author argues this creates a more controlled runtime than shell execution, while still needing clear sandboxing boundaries for real security.
Protecting sensitive content when screen sharing and remote control are active
Protecting sensitive content when screen sharing and remote control are active		 Apple documentation on detecting active screen capture, mirroring, and remote-control sessions. It recommends using SwiftUI’s isSceneCaptured or UIKit’s sceneCaptureState to selectively redact sensitive content, notify users, or disable risky actions while balancing privacy with usability.
Hide SwiftUI Views from Screenshot
Hide SwiftUI Views from Screenshot		 Investigates how to hide specific SwiftUI views from screenshots and screen recordings without wrapping them in a secure text field. The post traces the approach through CALayer capture flags, SwiftUI renderer internals, privacySensitive(false), and private redaction reasons, with caveats about SPI and security limits.
Type-Driven Design in Swift: Better Money Formatting
Type-Driven Design in Swift: Better Money Formatting		 Argues for separating raw money values from formatted display values in Swift. The article uses currency and rounding examples to show why formatted strings should not feed calculations, then proposes domain-specific types to keep calculation data and UI presentation distinct.

Extending monads:

extension Sequence {
    func mapToSet<Transformed: Hashable, Failure: Error>(
        transform: (Element) throws(Failure) -> Transformed
    ) throws(Failure) -> Set<Transformed> {
        var accumulated = Set<Transformed>(minimumCapacity: underestimatedCount)
        for element in self {
            try accumulated.insert(transform(element))
        }
        return accumulated
    }
    func mapToCountedSet<Transformed, Failure: Error>(
        transform: (Element) throws(Failure) -> Transformed
    ) throws(Failure) -> [Transformed: Int] {
        var accumulated = [Transformed: Int](minimumCapacity: underestimatedCount)
        for element in self {
            try accumulated[transform(element), default: 0] += 1
        }
        return accumulated
    }
}

Articles discussed:

Article URL Description
A Feature Flags System in Swift https://livsycode.com/best-practices/a-feature-flags-system-in-swift/ Walks through building a type-safe, thread-safe feature flag system in Swift, including feature definitions, priority-based sources, local overrides, and an internal QA/developer toggle screen.
A floating card using safeAreaBar https://codakuma.com/floating-safe-area-bar/ Shows how to build a bottom-pinned floating SwiftUI card using safeAreaBar on iOS 26, with an iOS 18 fallback based on safeAreaInset, material blur, and gradients.
ContentUnavailableView in SwiftUI - Complete Guide With Examples https://www.sagarunagar.com/blog/contentunavailableview-swiftui/ A practical guide to SwiftUI’s ContentUnavailableView, covering empty states, failed searches, recovery actions, customization, accessibility, and common mistakes.
Cupertino v1.1.0: my Apple docs index was 30% lies and I didn't know https://aleahim.com/blog/cupertino-v1-1-0-poison-cleanup/ Describes debugging and cleaning a corrupted Apple documentation search index, including crawler poison cases, CDN/SPA failure modes, audit checks, and release-version lessons. 

### Using idiomatic views in SwiftUI to build a chat app:
```swift
@Observable
final class ViewModel {
    var items: [Item] = []
    var input = ""
    func send() {
        items.append(.init(title: input, isUser: true))
        items.append(.init(title: "Hello", isUser: false))
    }
}

struct V: View {
    var viewModel = ViewModel()
    var body: some View {
        List {
            ForEach(viewModel.items.reversed()) { item in
                let image = item.isUser ? "bubble.left" : "bubble.right"
                Label(item.title, systemImage: image)
                    .listRowSeparator(.hidden)
                    .padding(.horizontal, 20)
                    .containerRelativeFrame(.horizontal, alignment: item.isUser ? .leading : .trailing)
                    .scaleEffect(y: -1)

            }
        }
        .listStyle(.plain)
        .safeAreaBar(edge: .top) {
            HStack {
                @Bindable var binding = viewModel
                TextField("Send a message", text: $binding.input)
                    .frame(minHeight: 40)
                    .padding(.horizontal, 16)
                    .onSubmit(viewModel.send)
                    .glassEffect()
                Button {
                    viewModel.send()
                } label: {
                    Image(systemName: "arrow.up")
                        .font(.title.weight(.semibold))
                        .padding(6)
                        .tint(Color(uiColor: .systemBackground))
                }
                .glassEffect(.regular.tint(Color.accentColor).interactive(), in: Circle())
            }
            .padding(.horizontal, 16)
            .scaleEffect(y: -1)
        }
        .scaleEffect(y: -1)
    }
}

2026.05.16

Concurrency

< Swift 6.2 Swift 6.2+
struct, enum, func, class nonisolated @MainActor
actor isolated to actor isolated to actor
func synchronous() nonisolated(nonsending) nonisolated(nonsending)
func nonsynchronous() async nonisolated(sending) nonisolated(nonsending)
run in background nonisolated func f() async @concurrent func f() async

Executive Summary

This session focused heavily on Swift isolation, actor semantics, memory management, and SwiftUI state behavior. Participants discussed actor isolation control, async result support, ARC internals, and the practical realities of SwiftUI reevaluation. There was also discussion of zombie objects, pointer APIs, and classic software design patterns.

Swift Concurrency & Isolation

SwiftUI

Memory Management & Pointers

Apple Platform Development

Software Engineering

2026.05.09

Executive Summary

This session focused on Swift-based web tooling, Core Animation fundamentals, and developer infrastructure topics including Docker and Apple documentation workflows.

Participants shared resources related to static site generation, animation timing curves, and practical references for Core Animation behavior.

Josh ran a code-along where we used UICollectionView to power a large collection of items.

Swift Web & Static Site Generation

Apple Documentation & Developer Resources

Animation & Motion

Infrastructure & Tooling

2026.05.02

Executive Summary

This session explored creative tooling (including voice-controlled presentations and video generation), Swift networking evolution, and practical career development advice. There was also discussion around Core Animation, compositional layouts, and real-world app development. A recurring theme was focusing on building and refining real projects as a path to growth.

Job Interviews

Josh H. presented about interviewing and preparing for interviews.

Types of questions

  • Bio - provide additional context not just a repeat of the resume
  • Behavioral - prepare about experience you had where you made a mistake and how you overcame it
  • Technical Deep Dive - prepare something interesting and with sufficient depth
  • System Design
  • Practical
  • Knowledge (know the APIs)
  • Data structures and Algorith - Yes, you need this.
  • AI? How to use tooling effectively

Reasons for rejection

You should always do a post mortem of the interview.

  • Just not the right person for the job (it happens, move on)
  • They liked someone else better (maybe ask about positions in another dept if big company)
  • Behavioral (they didn't want to work with you)
  • Technical (you didn't have the skill)
  • Something else

Swift & Architecture

SwiftUI, UIKit & UI Development

Creative Tools & Media

Apps & Projects

Learning & Career Development

Miscellaneous

2026.04.25

Executive Summary

This session focused on SwiftUI patterns (notably .refreshable and task cancellation), growing interest in AI “agent skills” ecosystems, and security considerations in AI systems. There was also discussion around mentorship, career development, and practical engineering wisdom. Several reusable SwiftUI samples and concurrency patterns were shared.

SwiftUI & Concurrency

    struct ContentView: View {
        @State private var items = [1,2,3]
        @State private var isRefreshing = false

        var body: some View {
            NavigationStack {
                ScrollView {
                    VStack {
                        let _ = Self._printChanges()
                        let cells = ForEach(items, id: \.self) { item in
                            Label("List item number \(item)", systemImage: "star.fill")
                        }
                        if isRefreshing {
                            cells.redacted(reason: .placeholder)
                        } else {
                            cells
                        }
                    }
                }
                .refreshable {
                    isRefreshing = true
                    defer { isRefreshing = false }
                    let newItems = [4,5,6]
                    do {
                        for newItem in newItems {
                            items.append(newItem)
                            try await Task.sleep(for: .seconds(1))
                        }
                    } catch {
                        print(error)
                    }
                }
            }
        }
    }
  • Notable takeaway:
    • “defer {} always works” (practical pattern for state cleanup)

AI & Agent Skills

Data & Persistence

Apple Ecosystem

Learning & Media

Community & Mentorship

  • Swift mentorship program: https://www.swift.org/mentorship/

  • Discussion topics:

    • Mentorship opportunities
    • Interview preparation challenges
    • Balancing full-time work with career growth

Lil Finder Guy (Etsy) from Ed!

https://www.etsy.com/listing/4489125113/lil-finder-guy-magnetic-poseable-mini

2026.04.18

Executive Summary

This session blended discussion of conference talks (notably Deep Dish Swift), SwiftUI architecture challenges, and advanced state management patterns. A strong theme was the difficulty of animation and motion design in SwiftUI, along with ongoing friction around @StateObject, view lifecycle, and UIKit feature gaps. Participants also shared a large collection of Swift articles, architecture references, and tooling resources, alongside some accessibility considerations and AI knowledge tools.

Conferences & Talks

SwiftUI & State Management

Example: @StateObject Initialization Pattern

    struct V: View {
        @State var isOn = true
        var body: some View {
            A(viewModel: VM())
        }
    }

    public struct A: View {
        @StateObject var viewModel: VM
        public init(viewModel makeViewModel: @escaping @autoclosure () -> VM) {
            _viewModel = .init(wrappedValue: makeViewModel())
        }
        public var body: some View {
            Text(viewModel.name)
        }
    }

    public final class VM: ObservableObject {
        var name = "Josh"
        init() {
            print("expensive work")
        }
    }

Swift Architecture & Patterns

SwiftUI & UI Development

Foundation & System APIs

AI & Knowledge Tools

Miscellaneous

2026.04.11

Executive Summary

This session focused on modern Swift architecture patterns, emerging Apple ML tooling (MLX), and increasing overlap between Swift development and AI workflows. There was notable interest in coordinator-based navigation in SwiftUI, LLM tooling integration, and evolving Swift language features such as Codable redesign discussions.

SwiftUI & Architecture

Swift Evolution

Machine Learning & AI

Knowledge Systems & Tooling

Miscellaneous

2026.04.04

Summary

This session covered a wide range of Swift-adjacent topics, including SwiftUI animation techniques, concurrency discussions, and emerging graphics approaches like Gaussian splatting. Participants shared numerous high-quality resources spanning SwiftUI, Metal, system-level tools, retro computing, and Apple history. There was also discussion of development tooling, emulation environments, and cross-platform workflows.

Swift & SwiftUI

Concurrency

Graphics & Metal

Tools & Libraries

Apple Ecosystem & History

Development & Systems

Emulation & Retro Computing

App Release Announcement!

Ed developed a new protein visualizing Vision Pro app:

2026.03.28

Executive Summary

This session centered on upcoming Apple events (WWDC26), Swift evolution (including Swift 6.3 and networking discussions), and the growing intersection of Swift with AI agent tooling. There was also active discussion around concurrency primitives, AsyncStream use cases, and emerging libraries. Participants shared resources spanning accessibility tooling, long-running AI application design, and developer ecosystem events.

Apple Ecosystem & Events

Swift Evolution

Concurrency & Async Patterns

AI & Agent Tooling

Tooling & Issues

2026.03.21

You can now script the browser using Swift.

Concurrency Notes

Avoid Spacers

https://nerdyak.tech/development/2023/04/06/avoid-swiftui-spacers-in-stacks.html

Adding a timeout to an async function

  enum TimeoutError: Error {
    case timedOut
  }
  
  func withTimeout<T: Sendable>(_ duration: Duration, 
                                operation: @Sendable @escaping () async throws -> T) async throws -> T {
    try await withThrowingTaskGroup(of: T.self) { group in
  
      // Task 1: your actual work
      group.addTask {
        try await operation()
      }
  
      // Task 2: timeout
      group.addTask {
        try await Task.sleep(for: duration)
        throw TimeoutError.timedOut
      }
  
      let result = try await group.next()!
      group.cancelAll()
      return result
    }
  }

Copy-On-Write COW

Dicussed copy on write and how it preserves value semantics and isolation.

VisionPro App for Visualizing Proteins

Ed's VisionPro app is available for pre-order and shipping on April 1!

Understanding Lifetime

To prepare us to understand some of the new Swift Evolution proposals, Josh took us on a playground quick tour through:

  • consuming
  • consume
  • borrowing
  • copy
  • inout
  • mutating
  • sending
  struct V {
      var w: String
      init(w: String) {
          self.w = w
      }
      func make(_ x: consuming String) -> String {
          x.append("a")
          print(x)
          return consume x
      }
      func a(_ x: String) {
          var y = x
          y.append("a")
          print(y)
      }
      func b(_ x: borrowing String) {
          var y = copy x
          y.append("a")
          _ = x
      }
      func c(_ x: inout String) {
  
      }
      mutating func f() {
          w = ""
      }
      consuming func close() -> String {
          ""
      }
      func r(_ x: sending NSView) -> NSView {
          consume x
      }
  }
  
  let r = "a"
  let v = V(w: r)
  print(r)
  let s = "hello"
  v.a(s)
  v.make(r)
  print(r)

2026.03.14

Faster Grep

This has come up a few times. "rg" is a command line tool that works faster than awk and grep and automatically respects .git rules. It is open source (MIT) and written in Rust.

Model Agnostic Agent

APNs

Apple APN

https://developer.apple.com/documentation/storekit/implementing-promotional-offers-in-your-app

Apple: The First 50 Years

iTrace

Handwriting practice app from Alex!

iRelay

Send commands to an AI agent from iMessage from Mihaela!

How it works:

iPhone (iMessage) → Mac (iRelay daemon) → Claude Code → response → iMessage

Apple Neo

AI Agent Kanban Tool - Symphony

Chris Lattner and Modular

Brief history of LLVM. Modular and Mojo. LLVM for AI chips.

"People who ignore this [AI] will be left behind."

Differential Fuzzing

Pictures of Apple Silicon M1 Die

Aticles of Interest

2026.03.07

Memory Safety

Foundation Generable

Making reproducible outputs:

Model personalization

Tools: Git, VS Code, Worktrees

Metatopic: Learning

2026.02.28

2026-02-28 09:48:07 From Josh Homann to Everyone: https://www.youtube.com/watch?v=69Gw7aoWMMI

2026-02-28 09:53:15 From SWEET Institute to Everyone: What are is your opinion on server driven UI?

Dynamic Animator

Josh reminded us that dynamic animator is part of UIKit.

Mihaela reminds us that these things can be done with Core Animation.

  let spring = CASpringAnimation(keyPath: "position.y")
  spring.fromValue = layer.position.y
  spring.toValue = layer.position.y + 200
  
  
  spring.mass = 1.0
  spring.stiffness = 100
  spring.damping = 10
  spring.initialVelocity = 0
  
  
  spring.duration = spring.settlingDuration
  
  
  layer.add(spring, forKey: "springMove")
  layer.position.y += 200 // update model layer

Carlyn reminds us of other affordances in SwiftUI

A Google PM Vibe Codes Palantir

From Josh. Not really Swift related, but speaks to the idea of having a clear goals and specifying what you want a product to be.

Strings, Regex and Benchmarking

We looked at different implementations of string replacement. At first we thought Swift string was the winner but then Tobias noticed that the units were milliseconds instead of microseconds.

Related is the topic of "new" serialization.

RG is a fast version of Grep: https://github.com/BurntSushi/ripgrep

Alex reminds us that regular expressions can be hard.

Helpful for learning regex.

And a great WWDC video from Michael Ilseman

WendyOS

A Swift First embedded operating system (linux distro)

Cool conferences coming

2026.02.21

We talked a bunch about different AI tools and got an interesting demo from Tobias about a Mac app he wrote for keeping track of web articles.

Talked about using Codex and Claude with worktrees. It lets you try out a bunch of solutions in parallel.

Natural Language

Just for fun project by Carlyn to do proper title case for a given style guide.

Testing Shareplay

Ed wants to test his Vision Pro app without buying another Vision Pro.

The Popularity of Swift

This month, Swift is just ahead of COBOL at position 21.

Articles of Interest

Josh brought up some articles to read.

Copy-on-write pattern.

Building a toast component. Good interview topic because it gets to if you understand the view hierarchy.

More on Observable.

2026.02.14

Swift Arctic Conference

Frank was back from https://arcticonference.com which was a great conference. Not recorded but some of the speakers indicated that they would post their talks. One of those was ElementaryUI which Josh shared a link to.

AI, Engineering, and Industry Updates

Josh Homann shared:

Josh feels that the industry is at a major transition and early adopters will benefit.

Ed Arenberg shared:

Carlyn raised concerns about AI being over-hyped in a crypto-bro-style way. There are indications that it is having a significant negative impact on open-source projects.

Also,

Ray shared anecdotal experiences about AI being useful but not getting to a full solution. He also raised some concerns about "The Point Free Way"--a new skills constellation that has strict license requirements.

Bioinformatics and Protein Structures

Ed gave a demo of his VisionPro app that he has been building with Xcode 26.3 and claude code. It gives rich visualizations of large proteins and even unfolds them visually. It reads in proteins in pdb format shows them.

carlyn shared: - https://rothemundlab.caltech.edu

Ed Arenberg shared:

Josh Homann shared:

Discussion included: - Ribbon diagrams - PDB file structure and specification (~170 pages) - Protein visualization tools

Fonts

https://typeof.net/Iosevka/

Swift topic for next time

Alex shared:

https://github.com/swiftlang/swift-evolution/blob/main/proposals/0504-task-cancellation-shields.md

2026.02.07

AI, Tooling, and Agentic Coding

Swift, Performance, and Language Topics

Swift Ecosystem, Blogs, and Resources

2026.01.31

Swift Blog

Stanford CS193p

Continues to be useful. Interesting how course content has shifted over the years.

Other University Courses

SwiftUI*

Swift, Architecture, and App Design

Philosophy, Cognition, and AI

Security, Privacy, and Tooling

  • Discussion on risks of tools with email access
  • Recommendation to use a fully separate “burner computer” for sensitive experimentation
  • UTM (virtual machines on macOS)
    https://mac.getutm.app

Moltbook - A dicussion board for agents.

2026.01.24

Consciousness and AI

Josh shares that Anthropic's CEO talks about how AI is growing exponentially. That changes everything.

Some links from Ray:

Carlyn recommends “An Immense World” by Ed Yong

Josh hypothesises that language might not matter in a year's time.

Android and Swift

There is a post on the Swift blog:

https://www.swift.org/blog/exploring-the-swift-sdk-for-android/

Also,

Ralph

Small mini-projects that can fit into context that runs in a loop.

Figma and AI

2026.01.17

AI Tooling, Agents, and Codex

Swift Concurrency & Logging

  • Peter Wu raised a question about global actor lifecycle, and specifically:
    • Lifecycle of custom (unowned) executors owned by a global actor.

Logging

Josh noted that requiring an async context for clients wanting to use analytics is a high hurdle. Better off to just use locks / mutex and have synchronous method calls.

Cupertino & MCP Integration

  codex mcp add cupertino -- /usr/local/bin/cupertino serve

Hardware Hacking & Security

Haiku's from Ed (or possibly his AI)

    All speech is Haiku
    No other way to converse
    Words are poetic

    PR obsolete
    Just let AI fix it all
    No more code reviews

    Humans make Haiku
    AI just steals from people
    Creativity

    Zooming with AIs
    No more humans required
    Meetings so lonely

2026.01.10

Highlights & Discussion

  • The Pipe project was shared and discussed, including recent architectural changes (shared by Peter Wu):

    • Repository: https://github.com/PeterWu9/Pipe
    • Pipe is no longer an AsyncSequence.
    • Pipe now vends an AsyncStream.
    • Additional updates were pushed incorporating feedback from Josh Homann.

  • A concurrency observation was raised that async let does not always result in parallel execution in practice (noted by Peter Wu).

Articles to Read

AI and Robots

Skills! (via Josh Homann):

2025.01.03

Build times

We discusses using tuist to reduce build times by pre compiling.
Video shared by ChitaRanjan

Pipe

We reviewed the various implementations of pipe from last year and discussed how to iterate over the pipe:

public final class Pipe<Value: Sendable>: Sendable, AsyncSequence {
    public typealias Stream = AsyncStream<Element>
    public typealias AsyncIterator = Stream.AsyncIterator
    public typealias Element = Value
    private let lockedContinuations: Mutex<[UUID: Stream.Continuation]>
    private let replayCount: Int
    public init(replay: Int = 0) {
        replayCount = replay
        lockedContinuations = .init([:])
    }
    deinit {
        lockedContinuations.withLock { continuations in
            continuations.values.forEach { $0.finish() }
        }
    }
    public func send(_ value: Value) {
        lockedContinuations.withLock { continuations in
            continuations.values.forEach { $0.yield(value) }
        }
    }

    public func makeAsyncIterator() -> AsyncIterator {
        let (stream, continuation) = Stream.makeStream(of: Element.self,
                                                       bufferingPolicy: .bufferingNewest(replayCount))
        let id = UUID()
        continuation.onTermination = { [weak self] _ in
            self?.lockedContinuations.withLock { $0[id] = nil }
        }
        lockedContinuations.withLock { $0[id] = continuation }
        return stream.makeAsyncIterator()
    }
}

A sequence is just an iterator factory and a for loop is syntactic sugar for making an iterator and looping over it (async or not):

let pipe = Pipe<Int>()
let array = [1, 3, 5, 7, 9]

Task {
    for value in array { }
    var i = array.makeIterator()
    while let value = i.next() {

    }
    for await value in pipe {
        print(value)
    }
    var iterator = pipe.makeAsyncIterator()
    while let value = await iterator.next() {
        print(value)
    }
}

Context engineering

We discussed context engineering as outlined in this video and these notes We discussed how to refine the prompt from december to produce better code by not cluttering the context window:

About

Meeting minutes and learnings from the physical space meeting.

Resources

Readme
Activity
Custom properties

Stars

72 stars

Watchers

23 watching

Forks

3 forks
Report repository

Releases

No releases published

Packages

 
 
 

Contributors