iOS Development on Ivan: Thinking

Technology is not enough

Mon, 20 Apr 2026 16:47:31 -0700

Either you know that software can be art, and often should be, or you think what I’m talking about here is akin to astrology. One thing I learned long ago is that people who prioritize design, UI, and UX in the software they prefer can empathize with and understand the choices made by people who prioritize other factors (e.g. raw feature count, or the ability to tinker with their software at the system level, or software being free-of-charge). But it doesn’t work the other way: most people who prioritize other things can’t fathom why anyone cares deeply about design/UI/UX because they don’t perceive it. Thus they chalk up iOS and native Mac-app enthusiasm to being hypnotized by marketing.

Moving along on Ready Time relaunch

Wed, 15 Apr 2026 22:33:19 -0700

Posted on r/SideProject. Had a little hiccup since my original post was filtered by reddit’s spam filter (boo!), but re-submitted a day later with fewer links in the post. I’d also been dormant on reddit for a while, so it may have smelled like spam with the initial post.
- Found out there’s an app by the name of ReadyBy with the same concept. After checking it out, it reinforces that I think my change from subscription to one-time premium upgrade makes sense (ReadyBy is a subscription model).
Published blog post about how Ready Time saved the day when wife went into labor. This has been a long time coming. Finally buckled down to write this thing out.
Submitted to Indie App Catalog.
Shared with some friends who’ve been giving me some feedback on the app.
Been warming up my profile on Indie Hackers.

It's like gonna have like this tab

Tue, 14 Apr 2026 11:30:37 -0700

Kids and Vibe Coding:

It’s easy for us to spot the issues. However, the bit that’s surprised me, though, is that they are…aware of it? Even as a 9 year old. Is this a potential byproduct of growing up in the digital age? They know it doesn’t feel right, and they can’t really say why yet, they just know it feels off.

That’s hardly surprising, as design and user experience are things that take years and years to develop.

Ready Time

Tue, 07 Apr 2026 16:32:03 -0700

We’re always underestimating how long things take:

mornings with a kid
catching a flight
getting out the door for dinner

It always feels like there’s enough time until suddenly there isn’t.

Ready Time works backward from your deadline. You add your steps: shower, pack lunch, get the kid dressed, drive. Then you set when you need to be done. It calculates when to start each step and sends you a notification when it’s time.

Getting Ready for Ready Time

Mon, 30 Mar 2026 20:53:39 -0700

Ready Time is the rebranded name for Little Countdown. Domain: check. Website: check. App update: almost.

Time Lock, New Premium Feature

Wed, 14 Jan 2026 06:11:12 +0000

Sometimes you need a task to happen at a specific time. Maybe you need to leave for the airport at exactly 3:00 PM, or you have a hard deadline to be at a meeting at 10:00 AM. Little Countdown normally schedules all your tasks backward from your deadline, but that doesn’t work when one task needs to happen at a fixed time.

Time Lock lets you set a fixed start time for any Task in your Countdown. When you lock a task to a specific time, Little Countdown schedules the rest of your timeline around it:

Development login credentials in Xcode

Mon, 24 Apr 2023 12:08:51 -0400

Danijela Vrzan posted a very cool solution to streamlining entering login credentials in Xcode and the iOS Simulator using breakpoints. I’ll admit that I probably haven’t fully unlocked the full potential of Xcode breakpoints in my development workflow.

If you’re an app developer, no doubt you’ve run into the case where you’re tediously typing in your auth username and passwords every time you rebuild/relaunch the Simulator. It gets old pretty quickly when you’re trying to quickly make updates or fix a bug in your app.

iOS Developer Resources

Tue, 04 Oct 2022 23:58:18 -0400

Developer News and Community

If I could give any advice to all new iOS developers, it’s that they should keep up with the ever-changing iOS ecosystem. Apple pushes out a new version of iOS every year, so it’s important (and exciting!) to keep up with the latest going on in the world of iOS Developmenet. I like to keep my ears on the ground with these resources.

SwiftUI: Link phone numbers, emails, URLs in Text without Markdown

Tue, 20 Sep 2022 17:54:51 -0400

SwiftUI provides an easy way to link URLs and emails inside of a Text view using AttributedString’s markdown initializer:

let text = "Jenny's at 867-5309."
    + " Email her at jenny@tutone.net."
    + " Find out more: https://en.wikipedia.org/wiki/867-5309/Jenny"

VStack {
    Text(try! AttributedString(markdown: text))
}

However, this has a few shortcomings:

the phone number isn’t linked/tappable
we may not want all the markdown rendering: bullets (*) and brackets ([]) in the text may end up rendering with unexpected results

We can use NSDataDetector instead to help us construct our own AttributedString that can detect phone numbers and also prevent the user from accidentally injecting markdown:

CoreData: All that is left to us is honor

Tue, 07 Jun 2022 17:08:51 -0700

My life for Aiur

How to do?

Add -com.apple.CoreData.ConcurrencyDebug 1 to your Xcode launch arguments.
Execute some non-thread safe CoreData code.
Crash, but at least you’ll still have your dignity.

iPhone Upgrade Program vs Buying, Trade In

Sat, 05 Dec 2020 17:22:26 -0700

Every year, when Apple makes its big announcement about the new iPhone being the most amazing device ever, you’re wondering whether you should upgrade or not. You consider whether the new features are worth it or whether you want a better camera or a better battery life.

Maybe your iPhone’s becoming gruelingly slow because you’re 3 years behind. Or maybe you can tell that your battery life is incrementally dying away with each night’s recharge.

Swift: Immutable Struct Singleton Initialization

Fri, 29 May 2020 11:10:01 -0700

How can you initialize a struct singleton that has dependencies? You likely chose to use a struct because you’re trying to reduce state and keep things immutable in your code. You’re also likely wanting to use the singleton pattern for a shared service or model in your project.

I’m a fan of keeping things immutable if possible, and I default to structs and lets before using classes, or vars.

One place I’ll use this pattern is when making services that depend on an external API like so:

Fastlane: Downloading AppStore Metadata

Thu, 28 May 2020 10:38:01 -0700

Just like we use git to be able to audit changes to our code over time, doing so with our app’s AppStore metadata lets us keep an eye on changes made to our AppStore page as well.

The first step in getting more control of our metadata is by having it live in our project’s repository. Keeping a copy of our metadata in git lets us keep track of changes to our app’s description, keywords, and even screenshots over time.

Swift: Converting String to Date

Wed, 20 May 2020 12:20:01 -0700

When consuming an API response, we’ll often see an ISO 8601 formatted date String like this:

2020-04-20T16:20:42+02:00

As a String, it’s not really useful for us, as it’s not really something you want to show your users. We may want to be able to extract just the hour, calculate the time interval between this date and others, or just format it in a way that’s more meaningful for the user. To do that, we can convert the String to a Date object.

Horizontal Stack Content Hugging

Tue, 19 May 2020 11:14:01 -0700

In your iOS app, you’ve got a Horizontal Stack with subviews layed out like so:

override func viewDidLoad() {
    super.viewDidLoad()
    
    let loveLabel = UILabel()
    loveLabel.text = "LOVE"
    loveLabel.backgroundColor = .systemRed
    
    let kissesLabel = UILabel()
    kissesLabel.text = "Kisses"
    kissesLabel.backgroundColor = .systemYellow
    
    let xoxoLabel = UILabel()
    xoxoLabel.text = "XOXO"
    xoxoLabel.backgroundColor = .systemBlue
    
    let stack = UIStackView(arrangedSubviews: [
        loveLabel,
        kissesLabel,
        xoxoLabel,
    ])
    stack.translatesAutoresizingMaskIntoConstraints = false
    stack.axis = .horizontal
    stack.spacing = 4
    
    view.addSubview(stack)
    
    NSLayoutConstraint.activate([
        stack.centerXAnchor.constraint(equalTo: view.centerXAnchor),
        stack.centerYAnchor.constraint(equalTo: view.centerYAnchor),
        stack.leftAnchor.constraint(equalToSystemSpacingAfter: view.leftAnchor, multiplier: 1),
        view.rightAnchor.constraint(equalToSystemSpacingAfter: stack.rightAnchor, multiplier: 1),
    ])
}

Hmm, a bit too much LOVE

But what if you really want is to see less of that LOVE and more of those Kisses?

Adding an Instructional Overlay for first time users to your app in iOS

Sat, 16 May 2020 13:04:01 -0700

Sometimes called Coachmarks, a Wizard, or an Onboarding Flow, this common UX pattern is used to guide first time users to an app on its features in your UI.

Here’s a quick and simple way to implement this pattern:

private func buildButton(with title: String) -> UIButton {
    let button = UIButton(type: .system)
    button.backgroundColor = .systemOrange
    button.setTitle(title, for: .normal)
    return button
}

override func viewDidLoad() {
    super.viewDidLoad()
    
    let buttonText = "Put me in coach!"
    
    let button = buildButton(with: buttonText)
    button.translatesAutoresizingMaskIntoConstraints = false
    
    let overlay = UIView(frame: .zero)
    overlay.translatesAutoresizingMaskIntoConstraints = false
    overlay.backgroundColor = UIColor.black.withAlphaComponent(0.5)
    
    let coachButton = buildButton(with: buttonText)
    coachButton.translatesAutoresizingMaskIntoConstraints = false
    coachButton.isUserInteractionEnabled = false
    
    let coachLabel = UILabel(frame: .zero)
    coachLabel.translatesAutoresizingMaskIntoConstraints = false
    coachLabel.textColor = .white
    coachLabel.text = "Get player in the game"

    view.addSubview(button)
    view.addSubview(overlay)
    view.addSubview(coachButton)
    view.addSubview(coachLabel)
    
    NSLayoutConstraint.activate([
        button.centerXAnchor.constraint(equalTo: self.view.centerXAnchor),
        button.centerYAnchor.constraint(equalTo: self.view.centerYAnchor),
        
        coachButton.centerXAnchor.constraint(equalTo: button.centerXAnchor),
        coachButton.centerYAnchor.constraint(equalTo: button.centerYAnchor),
        
        coachLabel.centerXAnchor.constraint(equalTo: coachButton.centerXAnchor),
        coachLabel.centerYAnchor.constraint(equalTo: coachButton.bottomAnchor, constant: 20),

        overlay.topAnchor.constraint(equalTo: self.view.topAnchor),
        overlay.bottomAnchor.constraint(equalTo: self.view.bottomAnchor),
        overlay.leftAnchor.constraint(equalTo: self.view.leftAnchor),
        overlay.rightAnchor.constraint(equalTo: self.view.rightAnchor),
    ])
}

The idea here is that you have a duplicate button on top of a semi-transparent overlay. We use Auto Layout to constrain coachButton to the real button, and we also disable isUserInteractionEnabled since we don’t actually want the user to be able to select it in this flow.

Bitrise: Mobile CI Service

Thu, 06 Jun 2019 19:53:01 -0700

With the small iOS team at Hipmunk, having to maintain a box to run Xcode Server would have been costly in terms of:

Buying hardware
Upgrading/maintaining the hardware
Keeping the OS/software up to date

Furthermore, we’d have to find a separate solution for our Android team and gain expertise on maintaining their CI as well.

We ended up deciding to use Bitrise, a continuous integration and delivery service designed primarily for mobile platforms.

Automated Beta/Internal Change Notes with Fastlane

Sun, 02 Jun 2019 16:51:01 -0700

Do your TestFlight or Crashlytics have change notes that say something useless like Fixed bugs? This is probably as useful as the equally ambiguous commit message fixed.

Or maybe you painstakingly look through your PRs to find out what changes went in since your last release and scribble something out quickly so you can just get the build ready for your product or testing teams.

This process of writing up beta/internal change notes can be streamlined and save devs precious brain cells that can be used for more valuable decision making.