New year, new microphone.

In this episode, I’m going to talk about:

• A new microphone for podcasting, the Shure 87A
• 2022 in review
• How to Run Stream’s Docs on a Multipass VM
• Xcode Cloud scripts: Fastlane and Cocoapods
• Swift async/await in AWS lambdas
• Looking back at my 2022
• Using CallKit - How to Integrate Voice and Video Calling Into iOS Apps
• HTTP/3 support for URLSessionTesting Apps with an iPhone and the CarPlay Simulator
• Trap exit code (SIGINT, SIGTERM etc) in a Swift Package Executable CLI
• The day my app got thousands of downloads and in-app unlocks

It has been a while since my previous episode. Recovering from Do iOS and then December happened. Holidays, some family illness. But I kept going in some capacity. Getting a new microphone is a big incentive to get going again.

But I need your thoughts and input.

Runway
Put your mobile releases on autopilot and keep the whole team in sync throughout. More info on runway.team

Lead Software Developer 
Learn best practices for being a great lead software developer.

Chapters

• 0:00 Intro
• 3:02 Shure Beta 87A
• 7:11 What do you think of the Shure Beta 87A vs the Samson Q7?
• 8:35 My 2022 in Review
• 14:11 How to Run Stream’s Docs on a Multipass VM
• 15:42 Xcode Cloud scripts: Fastlane and Cocoapods
• 16:50 Swift async/await in AWS lambdas
• 17:28 Looking back at my (Pol) 2022
• 17:57 Using CallKit - How to Integrate Voice and Video Calling Into iOS Apps
• 18:50 HTTP/3 support for URLSession
• 19:08 Testing Apps with an iPhone and the CarPlay Simulator
• 19:45 Trap exit code (SIGINT, SIGTERM etc) in a Swift Package Executable CLI
• 20:36 The day my app got thousands of downloads and in-app unlocks
• 22:00 Outro
• 22:38 About that LastPass thing

Transcript

Welcome to AppForce1 episode 97. My name is Jeroen Leenarts and I’ve been developing software for over 20 years, developing iOS apps for over 10 years, running the Dutch CocoaHeads for over 9 years.

If you are an iOS app developer, you should listen to my podcast because I will keep you updated on interesting articles, conferences, and events you might not have heard about.

As you may have noticed, I have not been putting out me regular episodes since Do iOS. I am in a sort of void considering in what direction to take my podcast. I did a couple interviews and that's about it for December. In following the Swift/iOS developer space closely, I am noticing something. A lot of great content is being produced by many different people. But I also see that a lot of the same topics keep coming back. The articles that excite me are either really in-depth or not that relevant to iOS developers. I am not sure yet where to take things.

Regardless, I will run down the list of the top articles in my feed since my previous episode. Once I am done with my usual meandering monologue.

Of note, my family and I have been to Paris right after Christmas and we had a great time visiting sights like the Eiffel tower, the Arc'd Triomph, Champs-Elysees, and the Sacré-Coeur. My youngest, Milan, mostly enjoyed the rides on the subway system. Go figure. The trip on the high-speed train was great. It is something else, speeding next to a highway and overtaking cars at over twice their speed. A Thalys train cruises at 280 km an hour. Or 180 miles an hour for my imperial listeners. Bloody quick if you ask me.

In this episode, I’m going to talk about:
- A new microphone for podcasting, the Shure 87A
- [[2022 in review]]
- [How to Run Stream’s Docs on a Multipass VM](https://getstream.io/blog/docs-docusaurus-multipass-vm/)
- [Xcode Cloud scripts: Fastlane and Cocoapods](https://www.polpiella.dev/xcode-cloud-scripts-fastlane-and-cocoapods/)
- [Swift async/await in AWS lambdas](https://www.polpiella.dev/swift-async-await-in-aws-lambdas/)
- [Looking back at my 2022](https://www.polpiella.dev/looking-back-at-my-2022/)
- [Using CallKit - How to Integrate Voice and Video Calling Into iOS Apps](https://getstream.io/blog/integrate-callkit-ios/)
- [HTTP/3 support for URLSession](https://blog.eidinger.info/http3-support-for-urlsession)
- [Testing Apps with an iPhone and the CarPlay Simulator](https://www.createwithswift.com/testing-apps-with-an-iphone-and-the-carplay-simulator/)
- [Trap exit code (SIGINT, SIGTERM etc) in a Swift Package Executable CLI](https://antran.app/2022/swift_package_executable_trap_sigint/)
- [The day my app got thousands of downloads and in-app unlocks](https://nemecek.be/blog/178/the-day-my-app-got-thousands-of-downloads-and-in-app-unlocks)

### The Shure 87A
For a while, I have been saving up for a microphone. A Shure 87A. And a few days ago this microphone was on sale on a big Dutch online shopping site. I was surprised, because it was a markdown of about 50 percent. And considering the normal pricepoint of this microphone, that was a lot. Regardless, at that price it was an insta-buy for me. Especially considering I already saved more than the discounted ticket price of the microphone.

My current microphone has been a Samson Q7 dynamic microphone. It's served me over 200 episodes already. I bought it right at the start of my podcast to just have something. I was able to pick up the Q7 at 25 euros. Also discounted down from its listed price of about 50 euros.

I am taking a bit of a chance here with the new Shure 87A microphone because it is a super-cardioid condenser microphone. Say what? A super-cardioid condenser microphone. Cardioid is about which direction of sound the microphone picks up in relation to the microphone capsule, also called the pick-up pattern. With a cardioid microphone you have to be right in front of the microphone, otherwise, your sound will drop off significantly quickly. The benefit of such a pick-up pattern for podcasting is picking up less of the sounds in your envionment.

The "super" just says the effect is somewhat stronger. Both the Samson Q7 and the Shure 87A have a cardioid pattern. What is a big difference between the two is that the Q7 is a dynamic microphone and the 87A is a condenser microphone.

To demonstrate this effect, I can move to the left of my microphone. Move over to the right. And back in front again. And also if I move back and forth, you will notice. As I just did.

I have always been a strong advocate against condenser microphones for podcasting. A lot of people tend to pick a Blue Yeti microphone for example. Which is a condenser microphone. And the big drawback of a condenser microphone is the sensitivity of the microphone. It just picks up everything. Not only all the detail of your voice, also everything in the background. The sensitivity of most condenser microphones is the biggest reason I never tell people to get one. Unless you have a treated noise free recording space.

But with the Shure 87A I am able to take the risk in my recording space. Because of the super-cardioid pattern. Anyways... It is always best to just compare. And obviously your appreciation of the difference, or the lack there of, depends in a large part on how you choose to playback my audio.

So first, the Samson Q7 without any treatment or processing:
> If you are an iOS app developer, you should listen to my podcast because I will keep you updated on interesting articles, conferences, and events you might not have heard about.

Here is the same audio clip of the Samson Q7 with noise reduction.
> If you are an iOS app developer, you should listen to my podcast because I will keep you updated on interesting articles, conferences, and events you might not have heard about.

And now you hear the Samson Q7 with the usual treatment and noise reduction:
> If you are an iOS app developer, you should listen to my podcast because I will keep you updated on interesting articles, conferences, and events you might not have heard about.

Next the Shure 87A:
> If you are an iOS app developer, you should listen to my podcast because I will keep you updated on interesting articles, conferences, and events you might not have heard about.

Here is the same audio clip of the Shure 87A with noise reduction.
> If you are an iOS app developer, you should listen to my podcast because I will keep you updated on interesting articles, conferences, and events you might not have heard about.

And finally the Shure 87A with my usual treatment and noise reduction:
> If you are an iOS app developer, you should listen to my podcast because I will keep you updated on interesting articles, conferences, and events you might not have heard about.

My personal conclusion is that the 87A sounds way better, but it does need some noise filtering because the 87A has some baseline hum, which is hardly noticable, but easy to take out.

Now let's have a look at some iOS development related content.

The first article is written by me, and a bit of a different topic. But I really liked how it turned out. It is about Multipass.

### [[2022 in review]]

### [How to Run Stream’s Docs on a Multipass VM](https://getstream.io/blog/docs-docusaurus-multipass-vm/)
This is an article I wrote on Stream's blog.

> By using Multipass and a few convenient scripts, I am able to create a runtime environment for Stream docs without having to worry about the side effects of anything that might have ended up on my system. If it turns out to be broken after a while, a full reset of my Docusaurus environment takes just a few minutes. I am also using Multipass VMs more and more when looking at other people’s code. I like the idea of being able to work on something in total isolation from anything else I am working on.
> 
> If you add something like VSCode remote development to connect and edit on your Multipass VMs, the experience is even better.
>
> Also note the avahi daemon  installed on the Multipass VMs. This maes things available locally on a `.local` TLD, and only adds to the convenience.
>
> One could ask, why not use Docker instead? I think it is a matter of preference. Also, when using Docker you have to rely on Docker Compose. An amazing tool, but I just want to have a lot of control over a basic runtime environment. Once I am happy with what I created in/with Multipass, turning that into a Docker Compose configuration is quite easy.

I think you should check this article because I wrote it, obviously, but also because Multipass or another way to isolate your workstation from random experimentation with multiple projects.

The next article is by Pol.
###  [Xcode Cloud scripts: Fastlane and Cocoapods](https://www.polpiella.dev/xcode-cloud-scripts-fastlane-and-cocoapods/)
> [Xcode Cloud](https://developer.apple.com/xcode-cloud/) is a CI/CD service made by Apple which is deeply integrated into Xcode. Since its introduction, there has been a lot of discussion amongst iOS developers on whether it is a good alternative to existing CI/CD providers and what migration to [Xcode Cloud](https://developer.apple.com/xcode-cloud/) would look like.
> 
> Setting up this new service is rather straigh-forward for small or new apps but it can be daunting for big codebases which have been around for a long time. These big codebases tend to still rely to some extent on third-party dependency managers such as [CocoaPods](https://cocoapods.org/) and on third-party CI/CD tools such as [Fastlane](http://fastlane.tools/).
> 
> The use of such third-party frameworks tends to put people off switching over to [Xcode Cloud](https://developer.apple.com/xcode-cloud/) but, in this article, Pol will go through how [the use of custom CI scripts](https://developer.apple.com/documentation/xcode/writing-custom-build-scripts) can help you and your team progressively migrate to [Xcode Cloud](https://developer.apple.com/xcode-cloud/) without having to abandon the tools you have used for a long time. More specifically, this article explains how to build an app using [CocoaPods](https://cocoapods.org/) and upload the resulting app archive to [AppCenter](https://appcenter.ms/) using [Fastlane](http://fastlane.tools/) from an [Xcode Cloud](https://developer.apple.com/xcode-cloud/) workflow.

Pol also wrote about
### [Swift async/await in AWS lambdas](https://www.polpiella.dev/swift-async-await-in-aws-lambdas/)
> The [swift-server](https://github.com/swift-server) team have been hard at work getting the first stable release of the [swift-aws-lambda-runtime project](https://github.com/swift-server/swift-aws-lambda-runtime) ready.
> 
> The changes for this unreleased 1.0 version include, among others, the adoption of `async/await`. In this article we'll rewrite an existing lambda to use the latest `main` revision of the [swift-aws-lambda-runtime package](https://github.com/swift-server/swift-aws-lambda-runtime) and take an early look at what the new APIs look like and how they enable us to use `async/await` in AWS lambdas.

Some really cool stuff you can do on Amazon's cloud with scalable architecture without deploying any servers.

And then there is Pol's
###  [Looking back at my 2022](https://www.polpiella.dev/looking-back-at-my-2022/)
I just had to include this link of Pol's look back on 2022 in this episode. Pol not only mentions my podcast, he also indicates his talk at Do iOS has been a first in person speaking engagement for him. Overall, Pol did a lot in 2022 and I am curious to learn what 2023 will be for him.

The next article, the 5th one, is by my colleague Amos.
### [Using CallKit - How to Integrate Voice and Video Calling Into iOS Apps](https://getstream.io/blog/integrate-callkit-ios/)

> CallKit helps developers to integrate and adopt native iOS video and voice calling into their VoIP apps. If you want to add CalKit support for an iOS project, you should import the framework and implement its classes and objects to handle incoming, outgoing, and active calls.
> 
> [CallKit](https://developer.apple.com/documentation/callkit) lets users make and receive calls with [VoIP](https://developer.apple.com/documentation/pushkit/pkpushtype/1614481-voip) (Voice over Interner Protocol) apps using the iPhone’s Phone app interface on iOS. In this tutorial, you will learn to build a sample iOS application demonstrating how to integrate the Apple CallKit framework with iOS apps.

Amos does an amazing write-up on how to deal with this framework in your app. The lessons are applicable to any app wanting to integrate with CallKit.

Marco Eidinger provides us with an overview of what HTTP/3 provides us and in what way everything is already taken care of by URLSession. Biggest takeaway I had from his write-up is that w should be fine.
### [HTTP/3 support for URLSession](https://blog.eidinger.info/http3-support-for-urlsession)

Moritz has some experience with CarPlay he wants to share with us.
###  [Testing Apps with an iPhone and the CarPlay Simulator](https://www.createwithswift.com/testing-apps-with-an-iphone-and-the-carplay-simulator/)
> Ever since WWDC 2022, there is a new way to test CarPlay-enabled apps with your iPhone and **Apple's CarPlay Simulator**.
>
> The CarPlay Simulator can run a CarPlay-enabled app in a window that simulates the in-car display experience, almost as if you are running it inside a car's CarPlay system or an aftermarket module.
>
> The CarPlay Simulator comes as a part of the ****Additional Tools for Xcode**** package and can be [downloaded from the Apple Developer Website](https://developer.apple.com/download/more/?=for%20Xcode).

An Tran has a really nice low level article about typical things you will run into when dealing with CLI tools.
###  [Trap exit code (SIGINT, SIGTERM etc) in a Swift Package Executable CLI](https://antran.app/2022/swift_package_executable_trap_sigint/)
> When building an executable CLI product using swift package, especially ones with long running tasks, users can exit the script at anytime by sending exit code to the process, for example, by tapping `CTL+C` or execute `killall` command.
> 
> Sometimes the CLI needs to trap such signals to do cleanup works. For Example, if the CLI is writing data continuously into a file, it might need to close the file properly on exit so that the file will not be corrupted.

Leave it to An Tran to provide some answers to these very specific challenges when building a CLI tool.

And finally we have Filip whose app Scna it was a part of the Indie App Santa project. He wrote about that in an article titled:
###  [The day my app got thousands of downloads and in-app unlocks](https://nemecek.be/blog/178/the-day-my-app-got-thousands-of-downloads-and-in-app-unlocks)

> This year, Filip's document scanner app [Scan it](https://apps.apple.com/app/scan-it-scan-and-export-pdf/id1509634112) was part of the fantastic [Indie App Santa](https://www.indieappsanta.com/) project. Going in, he had yet to learn what to expect beyond some significant amount of downloads.
> 
> Scan it was featured on December 5, so Filip felt the urge to wake up soon and check that there is not a massive fire to put out. Thankfully he woke up to just a few support emails mentioning the price is not Free (probably a timezone issue) and problems with Family Sharing…
> 
> Looking at it now, Filip has gotten less than 20 support emails and a few messages on Twitter. For some reason, during the “D-Day,” it seemed like many more.
> 
> Thankfully people were supportive and understanding.

Filip writes a good recap on his experience when receiving a big influx of new users. It does not matter for what reason this happens, the lessons are universal. You are never ready, you can only do your best. And most likely, if you did a decent job developing your product, and you are open about the challenges you are facing, things **will** work out.

### Outro
And that's it again for this time.
If you have any feedback, please send me a message through Twitter. My DMs are open. And don’t forget, you can buy me a coffee. Link for that is in the shownotes.