VRGZ

Parallelizing Work with AI

2026-03-05T00:00:00+00:00

I've been wanting to try parallelizing tasks with my AI workflow for a while. I felt it was an essential skill, and one I hadn't developed yet.

At the same time, I didn't want to mess around with the workflow I use on Coneko</a>, which is very reliable.

So I'm taking advantage of being in a bit of a waiting period for user feedback and data on Coneko</a> to prototype my new project. And since it's just a POC, I can experiment with things. Parallelization in particular.

What I knew at this point was that I needed to use git worktree</code>, and launch multiple terminals with Claude Code from these worktrees. Once again, the key is to organize everything upfront. We always come back to this with AI: always think and prepare before any implementation.

In practice, what I did was ask Perplexity how this is typically organized. Then brainstorm with Claude Desktop on how it would translate to my prototype for parallelizing tasks.

The takeaway is that some tasks must be sequential, due to dependencies. That's the common foundation for the tasks that follow. And the reunification task at the end.

The other key element is that before implementing, we first need to create the specifications for all tasks. Why? Because they'll adjust to each other as the design evolves.

Now we can start implementing. First, the preparatory tasks, sequentially. Then, we create the worktrees, and finally we can ask our AI squad to work in parallel.

Personally, I couldn't stay in front of my screen and approve each command because I had errands to run. So I launched it with --dangerously-skip-permissions</code> (aka YOLO mode. At your own risk). But by the time I was ready to head out, it was already done 😅.

When I got back, I launched the final reunification task, and apart from a few bugs related to a somewhat shady scraping API I'm using for the prototype, it worked perfectly.

So, to summarize, what I learned is:


Once again, it's all about upfront preparation.</li>
Some tasks are necessarily sequential.</li>
You need to write the specifications for ALL tasks before getting started.</li>
</ul>
Did you learn something? I hope so. I certainly did.</p>


My AI Workflow
2026-02-10T00:00:00+00:00
A few months ago, I posted on LinkedIn</a> that basically Vibe Coding is crap, and that I hated the experience. But I also said that paradoxically, I'd love to one day find an effective way to code with AI.</p>
When I tried vibe coding last year, my problem was that I had my project, I'd set it up, then I'd ask myself what the next task was (based on a Kanban board, or TODOs in the code), and I'd prompt Claude Code to do the task, then I'd review it, and occasionally ask it to write tests if the logic was sensitive. If I spotted anomalies, I'd prompt it to fix them. Then when I was satisfied, I'd commit. I had a specs file that was there from the start, that I'd sometimes forget about, which drifted over time from the actual state of the project.
So in a way, maybe it wasn't vibe coding that was the problem, it was me not knowing how to do it yet.
So what changed? First, I prefer to call it an AI workflow.</p>
BMAD Method</h2>
Some time ago, Benjamin Code (french YTer)</a> in a video</a> talked about his new AI workflow, the BMAD Method</a>. A method with a setup of agents, commands, and tools.
To summarize, it involves designing a project in depth, scrum-style, with multiple agents each having their own role (product owner, UX designer, marketing, QA, etc.). Each agent goes through several brainstorming workshops to gather requirements, set up specs, define personas, and much more. Each workshop produces a document that's used by the next agent.</p>
I tested this method on a really basic project. An interval timer for sports. I spent almost a week switching from one agent to another, doing brainstorming workshops, and waiting for Claude usage cooldowns (I was on a Pro subscription at the time).</p>
I wasn't convinced. There were way too many workshops, too many generated documents. It exhausted me. Zero fun.
It was heavy and tedious BUT... also very enriching.
Because I have to admit, I was forced to think more deeply about the project's design, better prepare it upfront, and ultimately understand it better before even starting to code.
I realized that the key was perhaps in the design and the workflow after all.</p>
Harper Reed Workflow</h2>
A few weeks ago, during my daily tech watch, I came across a video about an article</a> that proposes an AI workflow with only 4 very simple prompts, generating just 3 markdown files: the project spec, the implementation plan, and the verification checklist. With an emphasis on an iteration loop that's almost always the same: read the docs, understand the goal, understand the project, the current step, read the code, write the code, build the project, fix errors, write and run tests, fix errors, if everything's good update the docs, move to the next step.</p>
And that changed everything. Because this time, I spent only one afternoon brainstorming and one day implementing a functional and relatively complete MVP. And it was really fun to watch my project come to life step by step and so quickly.</p>
I now have a simple, relatively lightweight, easily reusable method, and I have enough confidence in what's been produced.
The fun part is watching the project progress on its own, one commit after another. At the end I type "Continue" and off it goes again. It's surprisingly satisfying.</p>
Post-greenfield</h2>
Now the workflow is done, I have my MVP, it works. And now what? How do I add a feature without breaking my workflow?
That's where I felt a bit without a safety net. The base workflow doesn't account for this — it was ideal for a "greenfield" project, meaning starting from a blank page, but now that the project exists, what do you do?</p>
I tried prompting what I need. It can work for some cases, but I now know it's not effective to work that way. I'd like to keep this workflow but for adding to or modifying what already exists.
Do I grow the existing files? Do I start fresh with new files? Is there a risk of breaking everything?</p>
So I went back to brainstorm with Claude, and we set up a workflow for this post-greenfield phase. Keeping the same iteration loop, control, and documentation updates.
Basically, we keep the specs file we had before, but now it becomes our reference for understanding the project's context. And we now have our 3 feature-specific files: specs/plan/todo.</p>
It works reasonably well, but not everything is sorted out yet regarding the instructions I need to put in claude.md from project to project. Same with the location of these post-greenfield files, but that'll come with experience. I still need to make the whole thing robust, but the essentials are there, and it works. I'll update this article when I've solved this problem.</p>
Conclusion</h2>
What I take away from all this is the importance of thorough brainstorming before starting a project, producing implementation documents that are simple but dense with information, and setting up an implementation loop that includes tests and documentation updates at every step.</p>
In the end, where just a few weeks ago I had a lot of frustration letting AI take too much responsibility in my projects, now I get real satisfaction from watching my git repo progress on its own, commit after commit. And ultimately, I'm doing what I love most about this job: finding solutions to problems.</p>
I believe I've unlocked a new skill: coding effectively with AI.
I have a backlog of ideas and projects as long as my arm that I couldn't get through — I feel like I'm going to be able to change that in the coming months.</p>


Filter unique elements from a Sequence
2025-08-28T00:00:00+00:00
extension</span> Sequence</span> where</span> Element</span>:</span> Hashable</span> {</span></span>
    func</span> unique</span>()</span> -></span> [</span>Element</span>] {</span></span>
        var</span> seen:</span> Set</span><</span>Element</span>></span> =</span> []</span></span>
        return</span> filter</span> { seen.</span>insert</span>(</span>$0</span>).inserted }</span></span>
    }</span></span>
}</span></span></code></pre>


Masking in SwiftUI
2025-08-26T00:00:00+00:00
LinearGradient</span>(</span></span>
    gradient</span>:</span> Gradient</span>(</span>colors</span>: [.pink, .indigo]),</span></span>
    startPoint</span>: .leading,</span></span>
    endPoint</span>: .trailing</span></span>
)</span></span>
.</span>frame</span>(</span>width</span>:</span> 70</span>, </span>height</span>:</span> 70</span>)</span></span>
.</span>mask</span> {</span></span>
    Image</span>(</span>systemName</span>:</span> "</span>circle.hexagonpath</span>"</span>)</span></span>
    .</span>resizable</span>()</span></span>
    .</span>frame</span>(</span>width</span>:</span> 70</span>, </span>height</span>:</span> 70</span>)</span></span>
}</span></span></code></pre>Result:</h2>
</p>


Realm with Swift 6 Async Await and Actor-Based Concurrency
2025-05-15T00:00:00+00:00
</p>
At the company where I work, we’re increasingly using async/await and aiming to migrate the project to Swift 6 to take advantage of the new concurrency checks.
Migrating an entire codebase to Swift 6 all at once isn’t feasible for a project of this size and complexity.</p>
The chosen strategy is to break down this monolith into smaller local SPM modules. Several modules have already been implemented, but since they are mostly UI-related, migrating them to Swift 6 had minimal impact.
To deepen our understanding of the topic, we decided that the next module to migrate would be the Database module.</p>
RealmSwift</h2>
We’ve been using RealmSwift</a> for data persistence since almost the beginning of the project. However, there are cases where the data doesn’t match expectations, or we try to access it from the wrong thread — which, in the worst-case scenario, can lead to a runtime crash.
By default, everything runs on the main thread due to a lack of proper thread management, and when issues arise, we simply force execution on the main thread. Needless to say, this isn’t ideal and needs to be addressed.</p>
Fortunately, a recent update to RealmSwift makes it compatible with Swift 6.</p>
The first step is updating RealmSwift to a version compatible with Swift 6.
There are two releases that add Swift 6 support: v10.54.0</a> and v20.0.0</a>.
One key difference is that version 20.0.0 removes Atlas Sync support, and it’s no longer necessary to explicitly specify the actor when opening a Realm instance.</p>
The plan</h2>
</p>

Create a dedicated actor</li>
Make Realm asynchronous and thread-safe</li>
Generic abstraction layer to work with Realm objects</li>
First model and DAO using the abstraction layer</li>
Use the DAO</li>
</ol>
 Extra:</strong> Asynchronous observation of Realm data
 </p>
DatabaseActor</h2>
Let’s start by creating a dedicated actor that will allow us to safely read from and write to the database with regard to concurrency.</p>
@globalActor public actor</span> DatabaseActor</span>:</span> GlobalActor</span> {</span></span>
  public static let</span> shared </span>=</span> DatabaseActor</span>()</span></span>
}</span></span></code></pre>
This actor will be very useful from this point on.</p>
Async and thread-safe wrapper for Realm</h3>
Now we’ll create a wrapper around Realm using an actor (@DatabaseActor</code>) and the Sendable</code> protocol. This will allow us to expose asynchronous read/write operations while ensuring safe concurrent access.</p>
import</span> RealmSwift</span></span>
</span>
public final class</span> AsyncRealm</span>:</span> Sendable</span> {</span></span>
  private let</span> configuration: Realm.Configuration</span></span>
  </span></span>
  public init</span>(</span>configuration</span>: Realm.Configuration </span>=</span> .defaultConfiguration) {</span></span>
    self</span>.configuration</span> =</span> configuration</span></span>
  }</span></span>
  </span></span>
  @DatabaseActor</span></span>
  public func</span> openRealm</span>()</span> async throws -></span> Realm {</span></span>
    try await</span> Realm.</span>open</span>(</span>configuration</span>: configuration)</span></span>
  }</span></span>
  </span></span>
  @DatabaseActor</span></span>
  public func</span> write</span>(</span>_</span> block</span>: </span>@escaping</span> (Realm)</span> throws -></span> Void</span>)</span> async throws</span> {</span></span>
    let</span> realm </span>= try await</span> openRealm</span>()</span></span>
    try await</span> realm.</span>asyncWrite</span> {</span></span>
      try</span> block</span>(realm)</span></span>
    }</span></span>
  }</span></span>
  </span></span>
  @DatabaseActor</span></span>
  public func</span> read</span><</span>T</span>:</span> Object</span>>(</span>_</span> block</span>: </span>@escaping</span> (Realm)</span> throws -></span> T)</span> async throws -></span> T {</span></span>
    let</span> realm </span>= try await</span> openRealm</span>()</span></span>
    return try</span> block</span>(realm)</span></span>
  }</span></span>
  </span></span>
  @DatabaseActor</span></span>
  public func</span> readMany</span><</span>T</span>:</span> Object</span>>(</span>_</span> block</span>: (Realm)</span> throws -></span> Results<T>)</span> async throws -></span> Results<T> {</span></span>
    let</span> realm </span>= try await</span> openRealm</span>()</span></span>
    return try</span> block</span>(realm)</span></span>
  }</span></span>
}</span></span></code></pre>
Note that each read and write method is annotated with the @DatabaseActor</code> attribute. This indicates that the method must be executed on that specific actor.</p>
Another important detail is that the AsyncRealm</code> class itself is not confined to the @DatabaseActor</code>; only the methods are. This allows the class to be used and instantiated in any context without requiring execution on the actor.
The configuration property, being private and immutable, can safely be accessed both during initialization and inside isolated methods. To ensure safe use across concurrent contexts, the class conforms to the Sendable</code> protocol.</p>
Abstraction Layer</h3>
The abstraction layer mainly exposes asynchronous and thread-safe operations to interact with Realm, relying on our dedicated AsyncRealm</code> wrapper.</p>
Thanks to this architecture, it’s possible to create a generic interface that acts as a bridge between Realm and our DAOs, allowing us to perform common operations (CRUD) safely and reusably, regardless of the model type.</p>
And of course, all of this runs on our @DatabaseActor</code>.</p>
public final class</span> DatabaseService</span>:</span> Sendable</span> {</span></span>
  private static let</span> schemaVersion:</span> UInt64</span> =</span> 1</span></span>
  private let</span> database: AsyncRealm </span>=</span> AsyncRealm</span>()</span></span>
  public static let</span> shared: DatabaseService </span>=</span> DatabaseService</span>()</span></span>
  </span></span>
  private init</span>() { }</span></span>
}</span></span>
</span>
@DatabaseActor</span></span>
extension</span> DatabaseService</span> {</span></span>
  public func</span> save</span><</span>T</span>:</span> Object</span>>(</span>_</span> object</span>: T)</span> async throws</span> {</span></span>
    try await</span> database.</span>write</span> { realm </span>in</span></span>
      realm.</span>add</span>(object, </span>update</span>: .all)</span></span>
    }</span></span>
  }</span></span>
  public func</span> find</span><</span>T</span>:</span> Object</span>>(</span>type</span>: T.</span>Type</span>, </span>id</span>: </span>String</span>)</span> async throws -></span> T {</span></span>
    try await</span> database.</span>read</span> { realm </span>in</span></span>
      guard let</span> object </span>=</span> realm.</span>object</span>(</span>ofType</span>: type, </span>forPrimaryKey</span>: id)</span></span>
      else</span> {</span> throw</span> RealmError.unresolved }</span></span>
      </span></span>
      return</span> object</span></span>
    }</span></span>
  }</span></span>
</span>
// Other CRUD methods</span></span>
}</span></span></code></pre>Appointment Use Case</h3>
Great, we now have all the pieces needed to perform various database operations. Let’s define our model and its DAO.
We’ll use an example of an appointment object:</p>
AppointmentModel</h4>
This is a typical Realm object with a primary key, a title, and a date.</p>
import</span> RealmSwift</span></span>
</span>
public final class</span> AppointmentModel</span>:</span> Object</span> {</span></span>
  @Persisted</span>(primaryKey</span>:</span> true</span>)</span> public var</span> id:</span> String</span> =</span> UUID</span>().uuidString</span></span>
  @Persisted public var</span> title:</span> String</span>?</span></span>
  @Persisted public var</span> date: Date</span>?</span></span>
}</span></span></code></pre>AppointmentDAO</h4>
The DAO naturally relies on DatabaseService</code> to handle appointment-related operations: creating, reading, updating, canceling, and listing.</p>
All these operations are, again, confined to @DatabaseActor</code>, ensuring thread-safe access.</p>
import</span> RealmSwift</span></span>
</span>
public final class</span> AppointmentDAO</span>:</span> Sendable</span> {</span></span>
  private let</span> databaseService: DatabaseService</span></span>
  </span></span>
  public init</span>(</span>databaseService</span>: DatabaseService) {</span></span>
    self</span>.databaseService</span> =</span> databaseService</span></span>
  }</span></span>
  </span></span>
  @DatabaseActor</span></span>
  public func</span> getAllAppointments</span>()</span> async -></span> [AppointmentModel] {</span></span>
    do</span> {</span></span>
      let</span> results </span>= try await</span> databaseService.</span>findAll</span>(</span>type</span>: AppointmentModel.</span>self</span>)</span></span>
      return</span> Array</span>(results)</span></span>
    }</span> catch</span> {</span></span>
      // Error handling</span></span>
      return</span> []</span></span>
    }</span></span>
  }</span></span>
  </span></span>
  @DatabaseActor</span></span>
  public func</span> getAppointment</span>(</span>id</span>: </span>String</span>)</span> async -></span> AppointmentModel</span>?</span> {</span></span>
    do</span> {</span></span>
      return try await</span> databaseService.</span>find</span>(</span>type</span>: AppointmentModel.</span>self</span>, </span>id</span>: id)</span></span>
    }</span> catch</span> {</span></span>
      // Error handling</span></span>
      return</span> nil</span></span>
    }</span></span>
  }</span></span>
  </span></span>
  @DatabaseActor</span></span>
  public func</span> saveAppointment</span>(</span>model</span>: AppointmentModel)</span> async</span> {</span></span>
    do</span> {</span></span>
      try await</span> databaseService.</span>save</span>(model)</span></span>
    }</span> catch</span> {</span></span>
      // Error handling</span></span>
    }</span></span>
  }</span></span>
  </span></span>
  @DatabaseActor</span></span>
  public func</span> cancelAppointment</span>(</span>id</span>: </span>String</span>)</span> async</span> {</span></span>
    do</span> {</span></span>
      try await</span> databaseService.</span>delete</span>(</span>type</span>: AppointmentModel.</span>self</span>, </span>id</span>: id)</span></span>
    }</span> catch</span> {</span></span>
      // Error handling</span></span>
    }</span></span>
  }</span></span>
}</span></span></code></pre>DAO usage</h4>
Now that we have our AppointmentDAO</code>, how do we use it?
Most use cases will require accessing the data outside our dedicated actor — for example, from a SwiftUI view, which runs on the MainActor</code>.</p>
So how do we bridge the two?</p>
Actually, there’s not much to it: Swift takes care of actor isolation behind the scenes — just call the async method with await</code>, and the system ensures safe execution on the correct actor.</p>
struct</span> AppointmentsView</span>:</span> View</span> {</span></span>
</span>
  private let</span> dao </span>=</span> AppointmentDAO</span>(</span></span>
    databaseService</span>: DatabaseService.shared</span></span>
  )</span></span>
</span>
  @State private var</span> appointments: [AppointmentModel]</span> =</span> []</span></span>
</span>
  var</span> body:</span> some</span> View {</span></span>
    List</span>(appointments) { appointment </span>in</span></span>
      VStack</span> {</span></span>
        Text</span>(appointment.title)</span></span>
        Text</span>(appointment.date)</span></span>
      }</span></span>
    }</span></span>
    .</span>onAppear</span> {</span></span>
      Task</span> {</span> @MainActor in</span></span>
        self</span>.appointments</span> = await</span> dao.</span>getAllAppointments</span>()</span></span>
      }</span></span>
    }</span></span>
  }</span></span>
}</span></span></code></pre>
Here, getAllAppointments()</code> from the DAO will execute on DatabaseActor</code>, even though it’s called from a Task</code> running on the @MainActor</code>.</p>
The result is then safely assigned to appointments.</p>

[!NOTE] Note</strong></p>
In the Task</code>, the @MainActor</code> annotation is explicitly specified as an example, but it’s not necessary here since the calling context is already on the @MainActor</code> (via SwiftUI).</p>
Still, it’s a good practice to make the intent clear, even if it’s not strictly required in this case.</p>
</blockquote>
Asynchronous Observation of Realm Data</h2>
Realm allows observing changes to objects, collections, or individual properties.
When an observation is created, Realm returns a NotificationToken</code> to manage its lifecycle. You can stop the observation at any time by invalidating this token.</p>
With Swift 6 compatibility, Realm now supports asynchronous observation of objects or collections using async/await</code>, and allows isolating those observations on a dedicated actor to ensure thread safety.</p>
let</span> token: NotificationToken </span>= await</span> appointments.</span>observe</span>(</span>on</span>: DatabaseActor.shared) { actor, changes </span>in</span></span>
  switch</span> changes {</span></span>
  case</span> .</span>initial</span>(</span>let</span> collection)</span>:</span></span>
  // Query has finished running and dogs can not be used without blocking</span></span>
  case let</span> .</span>update</span>(collection, deletions, insertions, modifications)</span>:</span></span>
  // This case is hit:</span></span>
  // - after the token is initialized</span></span>
  // - when the name property of an object in the collection is modified</span></span>
  // - when an element is inserted or removed from the collection.</span></span>
  // This block is not triggered:</span></span>
  // - when a value other than name is modified on one of the elements.</span></span>
  case</span> .</span>error</span>:</span></span>
  // Can no longer happen but is left for backwards compatiblity</span></span>
  }</span></span>
}</span></span></code></pre>AsynStream</h3>
To perform async/await-based observation, we can use AsyncStream</code>.
AsyncStream</code> is an asynchronous sequence that uses a continuation to yield new elements on demand.</p>
Example</strong></p>
func</span> streamOfValues</span>()</span> -></span> AsyncStream<</span>Value</span>> {</span></span>
  return</span> AsyncStream</span> { continuation </span>in</span></span>
    // Something happen</span></span>
    continuation.</span>yield</span>(newValue)</span></span>
    // Everything is done</span></span>
    continuation.</span>finish</span>()</span></span>
  }</span></span>
}</span></span>
</span>
// Usage</span></span>
for await</span> value </span>in</span> streamOfValues</span>() {</span></span>
  // Update something with the updated value</span></span>
}</span></span></code></pre>
(I love AsyncStream</code>, it's so elegant and easy to use)</p>
Let’s add an observation method to our DAO that combines AsyncStream</code> with Realm’s observe</code> to listen to data changes:</p>
public final class</span> AppointmentDAO</span>:</span> Sendable</span> {</span></span>
  @DatabaseActor</span></span>
  private var</span> notificationToken: NotificationToken</span>?</span></span>
  @DatabaseActor</span></span>
  private var</span> continuation: AsyncStream<[AppointmentModel]>.Continuation</span>?</span></span>
</span>
  deinit</span> {</span></span>
    continuation</span>?</span>.</span>finish</span>()</span></span>
    notificationToken</span>?</span>.</span>invalidate</span>()</span></span>
  }</span></span>
  </span></span>
  // Other DAO methods...</span></span>
  </span></span>
  public func</span> observeAppointments</span>()</span> -></span> AsyncStream<[AppointmentModel]> {</span></span>
    return</span> AsyncStream</span> { continuation </span>in</span></span>
      Task</span> {</span> @DatabaseActor in</span></span>
        do</span> {</span></span>
          self</span>.continuation</span> =</span> continuation</span></span>
          let</span> results </span>= try await</span> databaseService.</span>findAll</span>(</span>type</span>: AppointmentModel.</span>self</span>)</span></span>
          </span></span>
          // Start observation</span></span>
          notificationToken </span>= await</span> results.</span>observe</span>(</span>on</span>: DatabaseActor.shared) { actor, changes </span>in</span></span>
            switch</span> changes {</span></span>
            case let</span> .</span>update</span>(collection, deletions, insertions, modifications)</span>:</span></span>
              continuation.</span>yield</span>(</span>Array</span>(collection))</span></span>
            case</span> .</span>initial</span>(</span>let</span> collection)</span>:</span></span>
              continuation.</span>yield</span>(</span>Array</span>(collection))</span></span>
            case</span> .</span>error</span>(</span>let</span> error)</span>:</span></span>
              // Handle error</span></span>
              continuation.</span>finish</span>()</span></span>
            }</span></span>
          }</span></span>
        }</span> catch</span> {</span></span>
          // Handle error</span></span>
        }</span></span>
      }</span></span>
    }</span></span>
  }</span></span>
}</span></span></code></pre>
Note that we retain instances of both the notificationToken</code> and the continuation</code> inside the class to properly stop the observation when the DAO instance is deinitialized.
This prevents memory leaks and ensures the asynchronous stream completes cleanly.</p>
Now we can use this elsewhere, like in a View, for example.</p>
struct</span> AppointmentsView</span>:</span> View</span> {</span></span>
</span>
  private let</span> dao </span>=</span> AppointmentDAO</span>(</span></span>
    databaseService</span>: DatabaseService.shared</span></span>
  )</span></span>
  </span></span>
  @State private var</span> appointments: [AppointmentModel]</span> =</span> []</span></span>
  </span></span>
  var</span> body:</span> some</span> View {</span></span>
    List</span>(appointments) { appointment </span>in</span></span>
      VStack</span> {</span></span>
        Text</span>(appointment.title)</span></span>
        Text</span>(appointment.date)</span></span>
      }</span></span>
    }</span></span>
    .</span>onAppear</span> { </span></span>
      observeAppointments</span>()</span></span>
    }</span></span>
  }</span></span>
  </span></span>
  private func</span> observeAppointments</span>() {</span></span>
    Task</span> {</span> @MainActor in</span></span>
      for await</span> freshAppointments </span>in</span> dao.</span>observeAppointments</span>() {</span></span>
        self</span>.appointments</span> =</span> freshAppointments</span></span>
      }</span></span>
    }</span></span>
  }</span></span>
}</span></span></code></pre>Conclusion</h2>
And there we go. With this setup, we’ve established a scalable and safe way to handle database access in Swift 6. This foundation makes it much easier to reason about concurrency, avoid threading issues, and observe data reactively using modern Swift paradigms.</p>


Syncing Your App's Data Across User Devices with iCloud
2025-05-13T00:00:00+00:00
Choosing Your iCloud Synchronization Method</h2>
iCloud offers different technologies depending on the type and amount of data you need to sync.</p>

Key-Value Store (NSUbiquitousKeyValueStore):</strong> This is suitable for small amounts of simple data</strong>, such as user preferences or game states. It acts like a dictionary that syncs automatically.</li>
CloudKit:</strong> This is designed for more complex or structured data</strong>. It provides a full database system in the cloud with features like queries, subscriptions, and the ability to share data. SwiftData uses CloudKit for its built-in syncing.</li>
</ul>
Choose the appropriate method based on your app's specific needs</strong>. The Key-Value Store is simpler but has significant limitations, while CloudKit is more powerful but also more complex.</p>
Step-by-Step Guide to Setting Up iCloud Sync</h2>
Regardless of the method you choose, you generally need to configure your Xcode project first.</p>

Enable the iCloud Capability:</strong> Go to the Signing & Capabilities settings for your app's target in Xcode. Add the iCloud capability.</li>
Select the Specific iCloud Service:</strong> Within the iCloud capability options, select either Key-Value Store</strong> or CloudKit</strong>.

If you select CloudKit, you will need to press + to add a new CloudKit container or select an existing one. This container isolates your app's databases on the iCloud servers. SwiftData usually infers the container from your Entitlements.plist</code>.</li>
</ul>
</li>
For CloudKit (and SwiftData), add Background Modes:</strong> Add the Background Modes capability. Check the "Remote Notifications"</strong> checkbox from its options. This allows your app to receive silent notifications from CloudKit about new changes on the server.</li>
</ol>
That's the core configuration complete</strong>.</p>
Working with Specific iCloud Technologies</h2>
Once configured, you'll interact with iCloud using the specific APIs.</p>
Using the Key-Value Store:</strong></p>

Access the default store using NSUbiquitousKeyValueStore.default</code>.</li>
Set values using set(_:forKey:)</code>.</li>
Explicitly request a sync using synchronize()</code>.</li>
You can observe changes coming from iCloud by adding an observer for the NSUbiquitousKeyValueStore.didChangeExternallyNotification</code>.</li>
</ul>
Using CloudKit:</strong></p>

Interact with the database using CKContainer</code>, CKDatabase</code> (e.g., privateCloudDatabase</code> for personal data), and CKRecord</code>.</li>
You can save records by creating a CKRecord</code> with a record type and fields, then saving it to a database.</li>
You can set up subscriptions to be notified of changes.</li>
</ul>

[!WARNING] Important</strong></p>

Testing:</strong> Although you can try testing in the simulator, it rarely works well</strong>. It is much better to test on a real device</strong>, preferably with multiple iCloud accounts to test synchronization.</li>
Developer Account:</strong> The iCloud capability requires an active Apple Developer account with admin permissions</strong>.</li>
Key-Value Store Limitations:</strong> Be aware of the strict limitations: 1 MB total storage, 1024 keys maximum, and 1 KB per value</strong>. It is not suitable for large or relational data.</li>
CloudKit Schema Requirements (especially for SwiftData):</strong> CloudKit has specific requirements for your data models.

You cannot use @Attribute(.unique)</code></strong> on properties you want to sync. CloudKit is unable to enforce unique property options because it synchronizes changes concurrently.</li>
All properties must either have default values or be marked as optional</strong>, alongside their initializer.</li>
All relationships must be marked optional</strong>. This is because iCloud servers don't guarantee atomic processing of relationship changes.</li>
Delete rules like .deny</code> are not supported for relationships.</li>
</ul>
</li>
Asynchronous Access:</strong> Access to the iCloud container can be asynchronous</strong>.</li>
Permissions:</strong> Ensure your app has the correct capabilities and authorizations</strong>; otherwise, accessing the container will fail.</li>
Error Handling:</strong> Implement appropriate error handling when accessing iCloud data.</li>
Sensitive Data:</strong> Avoid storing sensitive data</strong> unless it is encrypted before being stored in iCloud.</li>
Performance:</strong> Use background threads for CloudKit operations</strong> to avoid blocking your app's main thread.</li>
CloudKit Schema Changes:</strong> CloudKit schemas are additive only</strong> after they have been promoted to production. You cannot delete model types or change existing attributes.</li>
</ul>
</blockquote>
Conclusion</h2>
Synchronizing your app's data across a user's devices enhances the user experience by making their content consistently available. iCloud provides different technologies like the Key-Value Store for simple preferences and CloudKit for more complex data. SwiftData leverages CloudKit to offer an easy, integrated sync solution. By following the necessary setup steps in Xcode and adhering to the specific requirements of each technology, particularly the model schema constraints for CloudKit and SwiftData, you can successfully implement iCloud synchronization in your application.
Remember to test thoroughly on real devices!</p>


Adding/Subtracting from a Date
2025-01-01T00:00:00+00:00
extension</span> Date</span> {</span></span>
    /// Adds the specified time components to this date</span></span>
    func</span> add</span>(</span>years</span>: </span>Int</span> =</span> 0</span>, </span>months</span>: </span>Int</span> =</span> 0</span>, </span>days</span>: </span>Int</span> =</span> 0</span>, </span>hours</span>: </span>Int</span> =</span> 0</span>, </span>minutes</span>: </span>Int</span> =</span> 0</span>, </span>seconds</span>: </span>Int</span> =</span> 0</span>)</span> -></span> Date</span>?</span> {</span></span>
        let</span> components </span>=</span> DateComponents</span>(</span>year</span>: years, </span>month</span>: months, </span>day</span>: days, </span>hour</span>: hours, </span>minute</span>: minutes, </span>second</span>: seconds)</span></span>
        return</span> Calendar.current.</span>date</span>(</span>byAdding</span>: components, </span>to</span>:</span> self</span>)</span></span>
    }</span></span>
</span>
    /// Subtracts the specified components from this date</span></span>
    func</span> subtract</span>(</span>years</span>: </span>Int</span> =</span> 0</span>, </span>months</span>: </span>Int</span> =</span> 0</span>, </span>days</span>: </span>Int</span> =</span> 0</span>, </span>hours</span>: </span>Int</span> =</span> 0</span>, </span>minutes</span>: </span>Int</span> =</span> 0</span>, </span>seconds</span>: </span>Int</span> =</span> 0</span>)</span> -></span> Date</span>?</span> {</span></span>
        return</span> add</span>(</span>years</span>:</span> -</span>years, </span>months</span>:</span> -</span>months, </span>days</span>:</span> -</span>days, </span>hours</span>:</span> -</span>hours, </span>minutes</span>:</span> -</span>minutes, </span>seconds</span>:</span> -</span>seconds)</span></span>
    }</span></span>
}</span></span></code></pre>
Usage:</strong></p>
// Add one year and a half to the current Date: </span></span>
Date</span>().</span>add</span>(</span>years</span>:</span> 1</span>, </span>months</span>:</span> 6</span>)</span></span>
</span>
// Add 30 seconds to the current Date:</span></span>
Date</span>().</span>add</span>(</span>seconds</span>:</span> 30</span>)</span></span>
</span>
// Substract 10 minutes from now:</span></span>
Date</span>().</span>add</span>(</span>minutes</span>:</span> -10</span>)</span></span>
// or</span></span>
Date</span>().</span>sustract</span>(</span>minutes</span>:</span> 10</span>)</span></span></code></pre>


Simple ScrollView Wrapper
2025-01-01T00:00:00+00:00
extension</span> View</span> {</span></span>
  func</span> scrollable</span>()</span> -> some</span> View {</span></span>
    ScrollView</span> {</span></span>
      self</span></span>
    }</span></span>
  }</span></span>
}</span></span></code></pre>
Usage:</strong></p>
SomeView</span> {</span></span>
  // ...</span></span>
}</span></span>
.</span>scrollable</span>()</span></span></code></pre>


Swift Package dependencies declaration
2025-01-01T00:00:00+00:00
dependencies</span>:</span> [</span></span>
.</span>package</span>(</span>url</span>:</span> "</span>https://github.com/author/repo-name.git</span>"</span>, </span>from</span>:</span> "</span>x.x.x</span>"</span>),</span></span>
],</span></span>
targets</span>:</span> [</span></span>
	.</span>target</span>(</span></span>
		name</span>:</span> "</span>MyCurrentApp</span>"</span>,</span></span>
		dependencies</span>: [</span></span>
    </span></span>
      // `name` = Packages.swift > products > .library > name > "LibraryName"</span></span>
      // `package` = package name in url `/repo-name.git`</span></span>
			.</span>product</span>(</span>name</span>:</span> "</span>LibraryName</span>"</span>, </span>package</span>:</span> "</span>repo-name</span>"</span>),</span></span>
      </span></span>
		],</span></span>
	)</span></span>
]</span></span></code></pre>


Web - Create your own HTML Custom component
2024-12-04T00:00:00+00:00
Custom Elements provide a standardized approach to creating reusable components without relying on specific frameworks.</p>
To create your own HTML Element it's actually very simple.</p>

First we need to define a JavaScript class that extends HTMLElement</code>:</li>
</ol>
class</span> MyElement</span> extends</span> HTMLElement</span> {</span></span>
  constructor</span>() {</span></span>
    super</span>();</span></span>
    // Component initialization</span></span>
  }</span></span>
</span>
  connectedCallback</span>() {</span></span>
    // The component is added to the DOM</span></span>
    this</span>.innerHTML</span> =</span> `<h1>My custom element</h1>`</span>;</span></span>
  }</span></span>
}</span></span></code></pre>

Then register the Custom Element with the browser:</li>
</ol>
customElements.</span>define</span>(</span>'</span>my-element</span>'</span>, MyElement);</span></span></code></pre>
That's it, now you can use it:</p>
<</span>my-element</span>></</span>my-element</span>></span></span></code></pre>

[!NOTE] Important points to note:</strong></p>

The name of the Custom Element must contain a hyphen (-) to avoid conflicts with native HTML elements.</li>
Use the constructor to initialize the element’s state and connectedCallback() to add content or event listeners.</li>
You can use the Shadow DOM to encapsulate the style and structure of your component.</li>
</ul>
</blockquote>


Vapor Swift - Bearer Authentication
2024-12-02T00:00:00+00:00
Setting Up Models</h2>
To get started, we will define two models: User as a Fluent Model and Token, which represents a bearer token. The User model will handle user credentials, while the Token model will manage authentication tokens.</p>
Defining the User Model</h3>
The User model represents a user in our application. It conforms to Model for database interactions and Content for Codable support.</p>
import</span> Vapor</span></span>
import</span> Fluent</span></span>
</span>
final class</span> User</span>:</span> Model</span>, </span>Content</span>, </span>@unchecked</span> Sendable</span> {</span></span>
    static let</span> schema </span>=</span> "</span>users</span>"</span></span>
    </span></span>
    @ID</span>(key</span>:</span> .id)</span></span>
    var</span> id: UUID</span>?</span></span>
    </span></span>
    @Field</span>(key</span>:</span> "</span>username</span>"</span>)</span></span>
    var</span> username:</span> String</span></span>
    </span></span>
    @Field</span>(key</span>:</span> "</span>passwordHash</span>"</span>)</span></span>
    var</span> passwordHash:</span> String</span></span>
    </span></span>
    init</span>() {}</span></span>
    </span></span>
    init</span>(</span>id</span>: UUID</span>? =</span> nil</span>, </span>username</span>: </span>String</span>, </span>passwordHash</span>: </span>String</span>) {</span></span>
        self</span>.id</span> =</span> id</span></span>
        self</span>.username</span> =</span> username</span></span>
        self</span>.passwordHash</span> =</span> passwordHash</span></span>
    }</span></span>
}</span></span></code></pre>

[!NOTE]
The @unchecked Sendable</code> attribute is necessary for compatibility with Swift 6. For more details, see the Vapor blog post on Sendable</a>.</p>
</blockquote>
Making User Conform to ModelAuthenticatable</h3>
To enable user authentication, we need to implement ModelAuthenticatable.</p>
extension</span> User</span>:</span> ModelAuthenticatable</span> {</span></span>
    static let</span> usernameKey </span>=</span> \User.$username</span></span>
    static let</span> passwordHashKey </span>=</span> \User.$passwordHash</span></span>
    </span></span>
    func</span> verify</span>(</span>password</span>: </span>String</span>)</span> throws -></span> Bool</span> {</span></span>
        try</span> Bcrypt.</span>verify</span>(password, </span>created</span>:</span> self</span>.passwordHash)</span></span>
    }</span></span>
}</span></span></code></pre>Defining the Token Model</h3>
The Token model will manage authentication tokens for users, allowing them to authenticate using bearer tokens.</p>
import</span> Fluent</span></span>
import</span> Vapor</span></span>
</span>
final class</span> Token</span>:</span> Model</span>, </span>Content</span>, </span>@unchecked</span> Sendable</span> {</span></span>
    static let</span> schema </span>=</span> "</span>tokens</span>"</span></span>
    </span></span>
    @ID</span>(key</span>:</span> .id)</span></span>
    var</span> id: UUID</span>?</span></span>
    </span></span>
    @Field</span>(key</span>:</span> "</span>value</span>"</span>)</span></span>
    var</span> value:</span> String</span></span>
    </span></span>
    @Parent</span>(key</span>:</span> "</span>userID</span>"</span>)</span></span>
    var</span> user: User</span></span>
    </span></span>
    @Field</span>(key</span>:</span> "</span>expiresAt</span>"</span>)</span></span>
    var</span> expiresAt: Date</span>?</span></span>
    </span></span>
    init</span>() {}</span></span>
    </span></span>
    init</span>(</span>id</span>: UUID</span>? =</span> nil</span>, </span>value</span>: </span>String</span>, </span>userID</span>: UUID, </span>expiresAt</span>: Date</span>? =</span> nil</span>) {</span></span>
        self</span>.id</span> =</span> id</span></span>
        self</span>.</span>value</span> =</span> value</span></span>
        self</span>.$user.id</span> =</span> userID</span></span>
        self</span>.expiresAt</span> =</span> expiresAt</span></span>
    }</span></span>
}</span></span></code></pre>Adding Migrations</h2>
To persist these models in the database, create migrations for both User and Token.</p>
User Migration</strong></p>
import</span> Fluent</span></span>
</span>
extension</span> User</span> {</span></span>
    struct</span> Migration</span>:</span> AsyncMigration</span> {</span></span>
        func</span> prepare</span>(</span>on</span> database</span>: Database)</span> async throws</span> {</span></span>
            try await</span> database.</span>schema</span>(User.schema)</span></span>
                .</span>id</span>()</span></span>
                .</span>field</span>(</span>"</span>username</span>"</span>, .string, .required)</span></span>
                .</span>field</span>(</span>"</span>passwordHash</span>"</span>, .string, .required)</span></span>
                .</span>unique</span>(</span>on</span>:</span> "</span>username</span>"</span>)</span></span>
                .</span>create</span>()</span></span>
        }</span></span>
        </span></span>
        func</span> revert</span>(</span>on</span> database</span>: Database)</span> async throws</span> {</span></span>
            try await</span> database.</span>schema</span>(User.schema).</span>delete</span>()</span></span>
        }</span></span>
    }</span></span>
}</span></span></code></pre>
Token Migration</strong></p>
extension</span> Token</span> {</span></span>
    struct</span> Migration</span>:</span> AsyncMigration</span> {</span></span>
        func</span> prepare</span>(</span>on</span> database</span>: Database)</span> async throws</span> {</span></span>
            try await</span> database.</span>schema</span>(Token.schema)</span></span>
                .</span>id</span>()</span></span>
                .</span>field</span>(</span>"</span>value</span>"</span>, .string, .required)</span></span>
                .</span>field</span>(</span>"</span>userID</span>"</span>, .uuid, .required, .</span>references</span>(User.schema, .id))</span></span>
                .</span>field</span>(</span>"</span>expiresAt</span>"</span>, .datetime)</span></span>
                .</span>unique</span>(</span>on</span>:</span> "</span>value</span>"</span>)</span></span>
                .</span>create</span>()</span></span>
        }</span></span>
        </span></span>
        func</span> revert</span>(</span>on</span> database</span>: Database)</span> async throws</span> {</span></span>
            try await</span> database.</span>schema</span>(Token.schema).</span>delete</span>()</span></span>
        }</span></span>
    }</span></span>
}</span></span></code></pre>Registering Migrations</h3>
Add the migrations to your application configuration:</p>
public func</span> configure</span>(</span>_</span> app</span>: Application)</span> throws</span> {</span></span>
    // Register migrations</span></span>
    app.migrations.</span>add</span>(User.</span>Migration</span>())</span></span>
    app.migrations.</span>add</span>(Token.</span>Migration</span>())</span></span>
    </span></span>
    // Additional setup...</span></span>
}</span></span></code></pre>Authentication Controller</h2>
The AuthController handles user authentication and token generation.</p>
import</span> Fluent</span></span>
import</span> Vapor</span></span>
</span>
struct</span> AuthController</span>:</span> RouteCollection</span> {</span></span>
    func</span> boot</span>(</span>routes</span>: RoutesBuilder)</span> throws</span> {</span></span>
        let</span> auth </span>=</span> routes.</span>grouped</span>(</span>"</span>auth</span>"</span>)</span></span>
        auth.</span>post</span>(</span>"</span>login</span>"</span>, </span>use</span>: login)</span></span>
    }</span></span>
    </span></span>
    @Sendable</span></span>
    func</span> login</span>(</span>req</span>: Request)</span> async throws -></span> TokenResponse {</span></span>
        let</span> loginData </span>= try</span> req.content.</span>decode</span>(UserDataRequest.</span>self</span>)</span></span>
        </span></span>
        // Find user by username</span></span>
        guard let</span> user </span>= try await</span> User.</span>query</span>(</span>on</span>: req.db)</span></span>
            .</span>filter</span>(\.$username </span>==</span> loginData.username)</span></span>
            .</span>first</span>()</span></span>
        else</span> {</span></span>
            throw</span> Abort</span>(.unauthorized, </span>reason</span>:</span> "</span>Invalid username or password.</span>"</span>)</span></span>
        }</span></span>
        </span></span>
        // Verify password</span></span>
        guard try</span> user.</span>verify</span>(</span>password</span>: loginData.password)</span> else</span> {</span></span>
            throw</span> Abort</span>(.unauthorized, </span>reason</span>:</span> "</span>Invalid username or password.</span>"</span>)</span></span>
        }</span></span>
        </span></span>
        // Generate and store token</span></span>
        let</span> tokenString </span>=</span> UUID</span>().uuidString</span></span>
        let</span> token </span>=</span> Token</span>(</span>value</span>: tokenString, </span>userID</span>:</span> try</span> user.</span>requireID</span>())</span></span>
        try await</span> token.</span>save</span>(</span>on</span>: req.db)</span></span>
        </span></span>
        return</span> TokenResponse</span>(</span>token</span>: tokenString)</span></span>
    }</span></span>
}</span></span>
</span>
struct</span> TokenResponse</span>:</span> Content</span> {</span></span>
    let</span> token:</span> String</span></span>
}</span></span>
</span>
struct</span> UserDataRequest</span>:</span> Content</span> {</span></span>
    let</span> username:</span> String</span></span>
    let</span> password:</span> String</span></span>
}</span></span></code></pre>Signup route to register users</h3>
The signup route allows new users to register by providing a username and password. Here’s how the implementation works:</p>
struct</span> AuthController</span>:</span> RouteCollection</span> {</span></span>
  // ...</span></span>
  </span></span>
  @Sendable</span></span>
  func</span> signup</span>(</span>req</span>: Request)</span> async throws -></span> HTTPStatus {</span></span>
    // Decode signup request</span></span>
    let</span> signupData </span>= try</span> req.content.</span>decode</span>(UserDataRequest.</span>self</span>)</span></span>
    </span></span>
    // Check if username already exists</span></span>
    let</span> existingUser </span>= try await</span> User.</span>query</span>(</span>on</span>: req.db)</span></span>
      .</span>filter</span>(\.$username </span>==</span> signupData.username)</span></span>
      .</span>first</span>()</span></span>
    </span></span>
    guard</span> existingUser </span>==</span> nil</span> else</span> {</span></span>
      throw</span> Abort</span>(.conflict, </span>reason</span>:</span> "</span>Username already exists</span>"</span>)</span></span>
    }</span></span>
    </span></span>
    // Create new user with hashed password</span></span>
    let</span> passwordHash </span>= try</span> Bcrypt.</span>hash</span>(signupData.password)</span></span>
    let</span> user </span>=</span> User</span>(</span>username</span>: signupData.username, </span>passwordHash</span>: passwordHash)</span></span>
    </span></span>
    // Save user to database</span></span>
    try await</span> user.</span>save</span>(</span>on</span>: req.db)</span></span>
    </span></span>
    // Return successful response</span></span>
    return</span> .created</span></span>
  }</span></span>
}</span></span></code></pre>Bearer Authentication Middleware</h2>
The middleware verifies the provided token in the Authorization header.</p>
struct</span> AuthController</span>:</span> RouteCollection</span> {</span></span>
    // Other methods...</span></span>
    </span></span>
    @Sendable</span></span>
    func</span> signup</span>(</span>req</span>: Request)</span> async throws -></span> HTTPStatus {</span></span>
        // Decode the signup request payload</span></span>
        let</span> signupData </span>= try</span> req.content.</span>decode</span>(UserDataRequest.</span>self</span>)</span></span>
        </span></span>
        // Validate the request data (e.g., non-empty username and password)</span></span>
        guard !</span>signupData.username.</span>isEmpty</span>, </span>!</span>signupData.password.</span>isEmpty</span> else</span> {</span></span>
            throw</span> Abort</span>(.badRequest, </span>reason</span>:</span> "</span>Username and password must not be empty.</span>"</span>)</span></span>
        }</span></span>
        </span></span>
        // Check if the username already exists in the database</span></span>
        let</span> existingUser </span>= try await</span> User.</span>query</span>(</span>on</span>: req.db)</span></span>
            .</span>filter</span>(\.$username </span>==</span> signupData.username)</span></span>
            .</span>first</span>()</span></span>
        </span></span>
        guard</span> existingUser </span>==</span> nil</span> else</span> {</span></span>
            throw</span> Abort</span>(.conflict, </span>reason</span>:</span> "</span>Username already exists.</span>"</span>)</span></span>
        }</span></span>
        </span></span>
        // Hash the password before storing it</span></span>
        let</span> passwordHash </span>= try</span> Bcrypt.</span>hash</span>(signupData.password)</span></span>
        let</span> user </span>=</span> User</span>(</span>username</span>: signupData.username, </span>passwordHash</span>: passwordHash)</span></span>
        </span></span>
        // Save the new user to the database</span></span>
        try await</span> user.</span>save</span>(</span>on</span>: req.db)</span></span>
        </span></span>
        // Respond with a 201 Created status</span></span>
        return</span> .created</span></span>
    }</span></span>
}</span></span></code></pre>Protecting Endpoints</h2>
Use the BearerAuthenticator middleware to protect routes that require authentication.</p>
func</span> routes</span>(</span>_</span> app</span>: Application)</span> throws</span> {</span></span>
    let</span> authController </span>=</span> AuthController</span>()</span></span>
    try</span> app.</span>register</span>(</span>collection</span>: authController)</span></span>
    </span></span>
    let</span> protected </span>=</span> app.</span>grouped</span>(</span>BearerAuthenticator</span>())</span></span>
    protected.</span>get</span>(</span>"</span>profile</span>"</span>, </span>use</span>: userProfile)</span></span>
}</span></span>
</span>
func</span> userProfile</span>(</span>req</span>: Request)</span> async throws -></span> User.Public {</span></span>
    let</span> user </span>= try</span> req.auth.</span>require</span>(User.</span>self</span>)</span></span>
    return</span> user.</span>convertToPublic</span>()</span></span>
}</span></span>
</span>
extension</span> User</span> {</span></span>
    struct</span> Public</span>:</span> Content</span> {</span></span>
        let</span> id: UUID</span>?</span></span>
        let</span> username:</span> String</span></span>
    }</span></span>
</span>
    func</span> convertToPublic</span>()</span> -></span> Public {</span></span>
        Public</span>(</span>id</span>:</span> self</span>.id, </span>username</span>:</span> self</span>.username)</span></span>
    }</span></span>
}</span></span></code></pre>Testing the Application</h2>
Here’s how to test the /auth/signup</code> and /auth/login</code> endpoints, as well as protected routes like /profile</code>.</p>
Create a User</h3>
Send a POST request to /auth/signup</code> with the following payload:</p>
curl</span> --location</span> '</span>localhost:8080/auth/signup</span>'</span> \</span></span>
--data</span> '</span>{</span></span>
    "username": "admin",</span></span>
    "password": "p@ssw0rd"</span></span>
}</span>'</span></span></code></pre>

Expected Response</strong></p>
Status Code: 201 Created</p>
</blockquote>
Obtain a Token</h3>
Send a POST request to /auth/login</code> with the following JSON payload:</p>
curl</span> --location</span> '</span>localhost:8080/auth/login</span>'</span> \</span></span>
--data</span> '</span>{</span></span>
    "username": "admin",</span></span>
    "password": "p@ssw0rd"</span></span>
}</span>'</span></span></code></pre>

Expected Response</strong></p>

Status Code: 200 OK</li>
Body:</li>
</ul>
</blockquote>
{</span></span>
    "</span>token</span>"</span>:</span> "</span>generated_token</span>"</span></span>
}</span></span></code></pre>Access a Protected Route</h3>
Use the token from the previous step to access a protected route, such as /profile</code>. Send a GET request with the Authorization header:</p>
curl</span> --location</span> '</span>localhost:8080/profile</span>'</span> \</span></span>
--header</span> '</span>Authorization: Bearer •••••••••••••••••••••</span>'</span></span></code></pre>

Expected Response</strong></p>

Status Code: 200 OK</li>
Body:</li>
</ul>
</blockquote>
{</span></span>
    "</span>id</span>"</span>:</span> "</span>FA7816E9-F837-4C36-B2DC-1F002BDA209C</span>"</span>,</span></span>
    "</span>username</span>"</span>:</span> "</span>admin2</span>"</span></span>
}</span></span></code></pre>Additional Notes for Testing:</h3>

Validation Errors: Test scenarios where invalid or incomplete data is submitted (e.g., missing username or password).</li>
Conflict Handling: Attempt to register a user with a username that already exists to verify the 409 Conflict response.</li>
Token Expiration: If token expiration is implemented, ensure expired tokens are rejected when accessing protected routes.</li>
</ul>
These steps ensure that both registration and authentication flows are working as expected.</p>
Enhancements</h2>

Password Security: Always hash passwords using a strong algorithm like Bcrypt.</li>
Token Management: Use JWT for more scalable authentication systems.</li>
Token Expiration: Ensure tokens have a clear expiry policy.</li>
Error Handling: Expand error handling and input validation to meet your application’s needs.</li>
</ul>


HTML Favicon sizes
2024-12-01T00:00:00+00:00
<!-- For all browsers --></span></span>
<</span>link</span> rel</span>=</span>"</span>icon</span>"</span> type</span>=</span>"</span>image/png</span>"</span> sizes</span>=</span>"</span>32x32</span>"</span> href</span>=</span>"</span>favicon-32x32.png</span>"</span>></span></span>
<</span>link</span> rel</span>=</span>"</span>icon</span>"</span> type</span>=</span>"</span>image/png</span>"</span> sizes</span>=</span>"</span>16x16</span>"</span> href</span>=</span>"</span>favicon-16x16.png</span>"</span>></span></span>
</span>
<!-- For Google and Android --></span></span>
<</span>link</span> rel</span>=</span>"</span>icon</span>"</span> type</span>=</span>"</span>image/png</span>"</span> sizes</span>=</span>"</span>48x48</span>"</span> href</span>=</span>"</span>favicon-48x48.png</span>"</span>></span></span>
<</span>link</span> rel</span>=</span>"</span>icon</span>"</span> type</span>=</span>"</span>image/png</span>"</span> sizes</span>=</span>"</span>192x192</span>"</span> href</span>=</span>"</span>favicon-192x192.png</span>"</span>></span></span>
</span>
<!-- For iPad --></span></span>
<</span>link</span> rel</span>=</span>"</span>apple-touch-icon</span>"</span> type</span>=</span>"</span>image/png</span>"</span> sizes</span>=</span>"</span>167x167</span>"</span> href</span>=</span>"</span>favicon-167x167.png</span>"</span>></span></span>
<!-- For iPhone --></span></span>
<</span>link</span> rel</span>=</span>"</span>apple-touch-icon</span>"</span> type</span>=</span>"</span>image/png</span>"</span> sizes</span>=</span>"</span>180x180</span>"</span> href</span>=</span>"</span>favicon-180x180.png</span>"</span>></span></span></code></pre>
Source</a></p>

VRGZ

Parallelizing Work with AI

My AI Workflow

Filter unique elements from a Sequence

Masking in SwiftUI

Result:</h2> </p>

Realm with Swift 6 Async Await and Actor-Based Concurrency

Appointment Use Case</h3> Great, we now have all the pieces needed to perform various database operations. Let’s define our model and its DAO. We’ll use an example of an appointment object:</p>

Conclusion</h2> And there we go. With this setup, we’ve established a scalable and safe way to handle database access in Swift 6. This foundation makes it much easier to reason about concurrency, avoid threading issues, and observe data reactively using modern Swift paradigms.</p>

Syncing Your App's Data Across User Devices with iCloud

Adding/Subtracting from a Date

Simple ScrollView Wrapper

Swift Package dependencies declaration

Web - Create your own HTML Custom component

Vapor Swift - Bearer Authentication

Setting Up Models</h2> To get started, we will define two models: User as a Fluent Model and Token, which represents a bearer token. The User model will handle user credentials, while the Token model will manage authentication tokens.</p>

Defining the User Model</h3> The User model represents a user in our application. It conforms to Model for database interactions and Content for Codable support.</p>

Testing the Application</h2> Here’s how to test the /auth/signup</code> and /auth/login</code> endpoints, as well as protected routes like /profile</code>.</p>

HTML Favicon sizes

Result:</h2>
</p>

Appointment Use Case</h3>
Great, we now have all the pieces needed to perform various database operations. Let’s define our model and its DAO. We’ll use an example of an appointment object:</p>

Conclusion</h2>
And there we go. With this setup, we’ve established a scalable and safe way to handle database access in Swift 6. This foundation makes it much easier to reason about concurrency, avoid threading issues, and observe data reactively using modern Swift paradigms.</p>

Setting Up Models</h2>
To get started, we will define two models: User as a Fluent Model and Token, which represents a bearer token. The User model will handle user credentials, while the Token model will manage authentication tokens.</p>

Testing the Application</h2>
Here’s how to test the `/auth/signup</code> and /auth/login</code> endpoints, as well as protected routes like /profile</code>.</p>`