DEV Community: Mario Nachbaur

Why your network requests may timeout intermittently in your iOS simulator

Mario Nachbaur — Fri, 14 Mar 2025 13:47:00 +0000

TL;DR: It appears that setting URLSessionConfiguration.multipathServiceType = .handover messes up with the simulator. Use conditional compilation to only set it on physical devices.

For some time, we at the iOS team at work were experiencing a quite strange phenomenon with the iOS simulators. Some times, some days, but not always, the iOS simulators refused to connect to our backend APIs, and all the requests did timeout. This meant we had to switch to developing and testing on our physical devices, which is a tad more inconvenient. Restarting the router, disconnecting or connecting to a VPN would help fix the issue, but not always.

We even thought our backend, or any proxy service in use, had some sort of geographical restriction or protection against bots — remember, only the simulators were affected. But inspecting the raw network requests, the ones made with a physical device and the ones from a simulator were 100% identical, so not sure how they would detect a simulator request.

After a long debugging session, we noticed we were initiating our URLSession objects in the following manner:

let configuration = URLSessionConfiguration.default
configuration.multipathServiceType = .handover
// ...
let session = URLSession(configuration: configuration)

From the .handover documentation:

A Multipath TCP service that provides seamless handover between Wi-Fi and cellular in order to preserve the connection.

which sounds amazing, specially for an app like ours designed for people on the go. I seems that that setting was responsible for the timeouts in the iOS simulator. Only in the simulator. So we changed the initialization code to something like:

#if !targetEnvironment(simulator)
configuration.multipathServiceType = .handover
#endif

The documentation for .handover also mentions that you should only use it "for long-lived or persistent connections", so we will also tweak which URLSessions have that option enabled and which don't.

Renaming variables in Swift closure capture lists

Mario Nachbaur — Thu, 28 Mar 2024 16:00:00 +0000

Published on my blog

If you have written any Swift code, you probably have seen capture lists. Let me show them to you in case you're not sure what they are:

class Some {
  var number: Int = 42

  func method() {
    someNetworkRequest(callback: { [weak self] result in
      self?.number = result //     ^ this thing right here
    })
  }
}

That thing between the square brackets ([ ]) is the capture list. It allows us to define the context of the callback. In this case, we capture self weakly, to avoid memory cycles.

The problem

With the introduction of iOS 17, SwiftUI gained a new View modifier: onChange(of:action:) where action takes two values, the old one and the new one. This allows code such as:

struct Some: View {
  @State private var isCreating: Bool = false

  var body: some View {
    Text("")
      .onChange(of: isCreating) { wasCreating, isCreating in
        guard wasCreating && !isCreating else { return }
        print("Finished creating")
      }
    }
}

This is just a simplified example to show the modifier. Just imagine that instead of a Bool we are using an enum with many cases.

On iOS 16 and prior, the modifier only provides the new value, making it difficult to check the current value and the previous one. There is however, a small workaround using capture lists:

onChange(of: isCreating) { [isCreating] newValue in
  guard isCreating && !newValue else { return }
  print("Finished creating")
}

Using a capture list, we can capture the current value, which is equivalent to the old value. And the callback provides us with newValue.

The solution

The previous code works, but the naming is awkward. isCreating points to the old value, and newValue is too generic. We could rename it to newIsCreating, but still, not the best name.

Here is when renaming variables inside the capture list shines. Let's look at the example:

onChange(of: isCreating) { [wasCreating = isCreating] isCreating in
  guard wasCreating && !isCreating else { return }
  print("Finished creating")
}

Inside the capture group, we are declaring a new variable wasCreating which the value of the captured variable isCreating (the old value). Then the callback provides us with isCreating (the new value)

Finishing

The examples shown may be obsolete with iOS 17 new modifier, but there are a lot of developers supporting iOS 16 and below. I wrote this article solving the exact problem I faced, but I'm sure there will be many, many situations where renaming a variable would be very helpful.

WebSocket service behind nginx reverse proxy

Mario Nachbaur — Tue, 24 Jan 2023 18:28:00 +0000

I have all my backend services behind a nginx reverse proxy. It allows me to host many services with different URLs on the same machine, when they're lightweight enough. And it manages SSL and everything needed for secure connections for me, so I can keep my code simple.

The latest service I'm working on relies a lot on WebSockets. Most browsers only allow wss:// (secure web sockets) connections from web pages served with https://. So I needed to serve the socket with SSL.

Configuration

For a successful web socket connection, we need to ensure that the HTTP version is correct and pass some headers to the service.

server {
    location /ws {
        proxy_http_version 1.1;
        proxy_pass http://address:port;
        proxy_set_header Connection $http_connection;
        proxy_set_header Upgrade $http_upgrade;
    }
}

This configuration only applies to the /ws route, because that is where the socket is. We set the HTTP version to 1.1 since nginx uses 1.0 by default, and forward the Connection and Upgrade HTTP headers to the service.

Keeping the socket open

The first thing I noticed after setting up the reverse proxy is that my connections were closing after a while. Turns out nginx closes connections that don't send any data within 60 seconds. You can increment this timeout thanks to the proxy_read_timeout directive:

location /ws {
    # ...
    proxy_read_timeout 300s;
}

But I opted to send ping messages periodically from the client to tell the service that I'm still interested in keeping the connection open. I didn't like the idea of setting the timeout to some large time amount and have a connection open indefinitely.

Today, I enter the IndieWeb

Mario Nachbaur — Sun, 12 Apr 2020 16:38:07 +0000

Today I updated my personal website. If you ever visited it before, you may think that nothing has changed. And you'd be right, visually not much has changed since I created it, just some links here and there.

I know my website may look simple, barebones, or some may say... ugly, but I like it that way. Also, I'm very proud that it supports light / dark theme based on your system preferences. And more importantly, it has this feature that I'm sure yours doesn't.

So what's the IndieWeb? It's a way to use your own website as your entire online presence. You can set it up as your personal business card of sorts, and even log in into services with it, which is just mind blowing.

`h-card`

The first thing you'll probably want to do is set up your profile. How can you do it? You have to add an h-card to the index page fo your website. Here's mine:

As I mentioned earlier, visually nothing has changed in my website, and that's partly because there's no minimum data requirements to build your h-card. My website had the exact amount of data I wanted to share.
Since the IndieWeb focuses on humans first, machines second, they are against hiding content.

The h-card is about defining metadata about you, and the way you do it is adding classes to DOM elements. There are a lot of properties you can use to present yourself. The IndieWeb respects how you want to publish your content and that includes you personal information, that's why there's no defined structure to build your h-card.

Here are some h-card examples, of varying complexity:

<span class=h-card>Mario Nachbaur</span>

This one's probably the bare minimum

<div class=h-card>
  <span class=p-name>Mario Nachbaur</span>
  <span class=p-nickname>marionauta</span>
  <p>I am a full stack software developer that likes
    <span class=p-category>Rubik Cubes</span>.
  </p>
</div>

I use p-category to tell people about my hobbies

<div class=h-card>
  <a class="p-name u-url u-uid" href=https://mario.nachbaur.dev>
    Mario Nachbaur
  </a>
</div>

You can use multiple properties in a single element

You can go to my website and check out how I configured my h-card (secondary click, view page source). The website is very simple and the source it's easy to read.

IndieAuth

This part is what wowed me the most. The fact that there are online services that allow you to sign up and log in using your website (remember, your website is your identity) is amazing. And the process to set it up couldn't be easier. Just have links with rel=me between your profiles in various web services.

Sadly, there aren't that many services that support it, and I don't think that I'll be using it that much, but the fact that I can do it is incredible. I will consider adding IndieAuth to the next project I build.

The cost vs. the fun

The only requirement to use the IndieWeb is owning a domain name, and host a website. Yes, domain names cost money and the hosting for the website too (unless you use a free service). That said, I think the cost is justified with the concept of the IndieWeb, owning your data, content and so on. The whole idea has The Matrix vibes to it, avoiding silos, that I enjoy.

If you already own a personal website, you don't loose anything trying it. In fact, you'll gain a couple of hours learning an interesting format. I promise it's worth it!

Lastly, thanks to Kev whose post inspired me to enter the IndieWeb, and to Brian, who explains really well the h-card format.

On if let bindings in SwiftUI

Mario Nachbaur — Sat, 11 Apr 2020 16:59:43 +0000

Update: with Xcode 12, we can write if let bindings without problems. This code is now valid:

if let address = library.address {
    Text(address)
}

I'll leave the post up for historical context.

Recently I was building an app that lists public libraries in my home city. In early stages, the main view was just a list view that displays the library name and address. Something like this:

Quick prototype of my app

As you can see, some libraries don't have an address, because of some unrelated reasons. And if the address isn't present, the name should be vertically centred in the row.

A library not having an address is translated into my data model as an optional String. Here's a simplified version of my Library model:

struct Library {
    let id: String
    let name: String
    let address: String?
}

Neat, eh?

Initial approach

If a library doesn't have an address, I won't render a Text component for it, simple as that. And the easiest way for me to do that was using an if let binding:

VStack {
    Text(library.name)
    if let address = library.address {
        Text(address)
    }
}

This WON'T compile!

As it turns out, SwiftUI doesn't like this. The compiler tells us that Closure containing control flow statement cannot be used with function builder 'ViewBuilder'. I beg your pardon?

How else am I supposed to conditionally render views in my app if "control flow statement cannot be used" to build it? After a moment of panic, I tested using a normal if:

VStack {
    Text(library.name)
    if library.address != nil {
        Text(library.address!)
    }
}

Force unwrapping make kittens cry

And surprisingly that worked... wtf. Needless to say, I wasn't very exited with that solution, since it requires force unwrapping an optional value. I knew that there was another way.

Current solution

One of the key features of SwiftUI is that if we add a nil component to our view, it won't show up, it's just ignored. So, what's the easiest way to convert a conditional string into a conditional Text? That's right, using map.

Here we map over the possibly nil address, without needing to force unwrap it, as the closure will only be executed if there was a value in the first place. This, however, seems like a hack. But hey, It works.

VStack {
    Text(library.name)
    library.address.map { address in
        Text(address)
    }
}

Heh, mapping an optional... I can still hear my CS professor talking about monads.

Let's wait and see

As I was reading some discussions about this issue, I found out that SwiftUI builds views using a struct named ViewBuilder — remember the error I was getting before? If we peek its definition (cmd + shift + o in XCode to go to any class definition) we can clearly see that it supports if statements, but nothing more.

SwiftUI is not event a year old, and we know Apple only introduces big features once a year. So here's hoping that when the next version of SwiftUI shows up, they add if let support.

Avoid notches in your PWA with just CSS

Mario Nachbaur — Sat, 26 Oct 2019 11:16:50 +0000

At work, I'm usually creating native mobile apps, both in Swift and React Native. But for a new project, we decided it was better to implement a progressive web app. I have experience in HTML, CSS & JavaScript, so I thought there won't be any problems.

All was going according to plan until we met a new enemy: The iPhone X.

Excuse me, I'd like to TAP those buttons!

Native background

In the native world, we have something called safe area, a "box" where we can put things inside and be sure they'll be outside of the notch and bottom areas.

This way it's easy to tell the app to place some component at the top of the screen, but move it a little to the bottom if there's a notch in the way.

For the PWA, the easiest way to avoid that stupid bottom bar is by adding some padding-bottom, but that would break all other devices. I thought to add a CSS class conditionally with JavaScript, but that seemed like a hack.

CSS Environment Variables

As you may know, we can now define and use custom CSS variables with var(--padding-bottom). The same way, browsers can also define their own. They're in the process of standardization, but Apple has created some of their own.



.navbar {
    padding-bottom: 0;
    padding-bottom: env(safe-area-inset-bottom, 0);
}

We define the bottom padding for browsers that don't yet support environment variables. If we were to omit the first rule, the second one is broken and nothing applies.

For browsers that do support them, we want the bottom padding to be equal to safe-area-inset-bottom, and fall back to 0 if the variable isn't set.

Similarly, there are also variables for the top, left and right screen edges.

Success!