Dev Conversations

Moritz Lang is a software engineer based in Berlin who works across iOS and server-side Swift, with a strong focus on observability. After starting out in 2013 with typical full‑stack web development, he quickly gravitated to Swift when it was announced in 2014 and has been combining client and server work ever since.

A university project about microservices and observability led Moritz to Google Summer of Code, where he worked on the Swift Distributed Tracing library — the missing link alongside SwiftLog and SwiftMetrics to complete the three observability pillars.

His work helped making observability more practical for production systems, by using distributed tracing with spans that can be linked together across microservices. Leveraging Swift Concurrency, task locals, and the OpenTelemetry standard, Swift OTel matured and reached its 1.0 release: the package can export Swift’s logs, metrics, and traces to any OpenTelemetry‑compatible backend. In October 2025, he presented a talk on the Server Side Swift Conference about the fresh from the oven Swift OTel 1.0.

In this episode, Moritz joins us to talk about Swift OTel’s journey, what observability means in practice for systems of any size, and how future tools like Swift Configuration could make observability setups, and Server Side Swift in general, even smoother.

• Website
• GitHub
• Mastodon

• Swift OTel

• Observability in Server-Side Swift - Si Beaumont & Moritz Lang

• OpenTelemetry

Pierluigi Cifani has been doing iOS development for over a decade, starting back in 2013 with Objective-C. When he first saw a jailbroken iPhone running a terminal, he knew that’s what he wanted to do. He’s been writing iOS apps ever since, and in the last year, he’s been experimenting with Swift on Android — a topic he presented at NSSpain 2025.

Pierluigi started programming in college with Pascal, Java, and C. As soon as he had a chance to work on iOS at his company, he jumped on it. He remembers having headaches trying to understand how UITableView worked under the hood and how to write one. He’s loved iOS development ever since, from Objective-C’s pthreads to Grand Central Dispatch and now Swift.

At his company, they’ve adopted Swift on Android using the Skip toolchain, allowing them to share business logic between iOS and Android while keeping native UIs on both platforms. This approach lets them maintain native iOS apps while making iOS developers more economically viable by enabling code sharing without compromising the iOS experience.

In this episode, Pierluigi shares his journey into Swift on Android, discusses the advantages and challenges of this approach, compares it to Kotlin Multiplatform, and explains why he chose Swift over other cross-platform solutions.

• X
• GitHub

• NSSpain 2025: Android Doesn’t Deserve Swift - But We Did It Anyway

• Skip
• Swift.org blog post: Announcing the Swift SDK for Android
• Getting Started with the Swift SDK for Android
• Swift Android Examples

Antoine van Der Lee is the creator behind SwiftLee, one of the most popular Swift development blogs, and RocketSim, a powerful iOS development tool. With over 7 years at WeTransfer and now as an indie developer, Antoine has built a significant following in the Swift community through consistent weekly content and innovative developer tools.

He started his programming journey with ActionScript and Flash, eventually finding his way to iOS development, at an agency. Later on, his transition from agency work to WeTransfer, a high-scale environment, taught him valuable lessons about code quality and collaboration. There, he also contributed to several open-source projects while building the company’s iOS apps from the ground up.

Since 2017, Antoine has maintained SwiftLee with weekly articles, building an audience that eventually enabled him to go indie in 2024. RocketSim, which started as a simple deep link testing tool, has evolved into a comprehensive iOS development suite with over 30 utilities, including unique features like camera simulation and network speed control.

In this episode, Antoine shares his journey from Flash developer to indie success, the technical challenges behind RocketSim’s unique features, his approach to consistent content creation and audience building, and some tips for a successful migration to Swift 6’s strict concurrency.

• SwiftLee
• Newsletter: SwiftLee Weekly
• RocketSim
• Swift Concurrency Course: Swift 6 Migration

• LinkedIn
• X
• Bluesky
• GitHub

• SwiftLeeds 2024: From Side Project to Going Indie
• Swiftable 2023: Harnessing the Potential: Swift Macros in Action

Tibor Bödecs shared his learnings on his iOS development on his blog for almost a decade, before transitioning to server side Swift. After having published a book on the topic, founded a software development and consulting company, and created a few open source projects, he is now a member of the Swift Server Workgroup.

Today Tibor announced a new book, written together with his wife, Kitti Bödecs, for beginners and advanced alike: Learn to Code Using Swift.

What’s unique about it, is that Kitti had no prior experience programming so she learned, practiced, and wrote content simultaneously, which makes the book a great resource for complete programming beginners. At the same time, the book covers modern and complex Swift topics such as modern concurrency practices, ownership model, and variadic generics.

His past with programming goes way back, when he started playing with Turbo Pascal on an Intel 486. His first programming job was as a PHP backend developer, and a few years later he started working on iOS apps. He started his blog almost a decade ago to share his learnings, and later on transitioned to server side Swift.

In this episode, besides sharing his story, Tibor discusses how his company, Binary Birds, is pushing for server side Swift adoption in large companies, and the challenges of convincing decision-makers that Swift isn’t just “an Apple thing”. The conversation also covers the differences between Vapor and Hummingbird, his open source projects (including what makes his last one, Toucan, unique), and brings the background story about his new book. Check it out!

• The.Swift.Dev.
• Swift On Server
• Binary Birds
• Toucan

• X
• Mastodon
• Bluesky
• GitHub

• Learn to Code Using Swift
• Practical Server Side Swift

• Generating Static Websites with Swift on the Server
• Introducing Feather CMS

• Swift Server Conference
• Hummingbird Examples Repository
• Swift Forums
• Vapor Discord
• Hummingbird Discord

Bruno’s first moments with programming were with Flash and ActionScript, and a few years later, when deciding what to study, he didn’t choose Computer Science: he went instead for game design. After working on it for a while, his interested shifted into iOS Development, when he joined an Apple Developer Academy program.

When working in Brazil’s leading food delivery app, he had a chance to work on the infrastructure of the app. As a team of more than 30 iOS developers, the regular approach with Xcode didn’t scale well, and that’s when Bruno had a chance to implement a better modularization, and a new build system: Bazel. Being one of the first companies in Brazil to adopt Bazel (if not the first), it forced him to learn about it on a deeper level.

Bruno shares these learnings, amongst other types of work he faces nowadays while working at Spotify, on his SwiftRocks.com blog. There, you won’t find the typical UIKit/SwiftUI content, but rather posts related to the Swift compiler, reverse engineering, git internals, and other advanced topics in the world of Swift, iOS, or Software Engineering as a whole.

In this episode, Bruno shares a bit of his story, from Brazil to Sweden, from game design to iOS development, and as a developer tooling and infrastructure engineer at Spotify. We also talk about his contribution to Swift with the SE-290 proposal (and its implementation in Swift 5.6), his open source projects, and what motivates him to understand deeply how things work under the hood.

• Website
• GitHub
• Mastodon

• Burnout Buddy
• sourcekit-bazel-bsp
• swiftshield (unmaintained)
• SwiftInfo (unmaintained)

• Swift Heroes 2021 - Preparing for Growth: Architecting Giant Apps for Scalability and Build Speed
• SwiftConf 2023 - Keeping Swift Apps Small: Why and How

Finn learned JavaScript as a fun way to build little websites. His programming journey, that started around the age of 12, evolved into programming Arduino projects, as he became fascinated by the idea of controlling physical objects such as LEDs. A few years later, he started learning Swift and alongside academic studies, he started building apps and games for iOS.

But it was only a few years later, when Swift started supporting embedded devices, that he was able to merge all his motivations behind programming, into a new open source project, PlaydateKit: a package that abstracts the complexities of C, and provides a more Swift-like interface to the Playdate SDK.

Another project that Finn has just released is yap: a CLI tool that uses macOS 26’s Speech framework to do on-device speech-to-text transcription. By using Apple’s frameworks and running on Apple Silicon, yap not only runs locally, but it also runs faster than any other transcription tool built on top of OpenAI’s Whisper.

In this episode, Finn tells us about his journey as a programmer, from JavaScript to Arduino, from iOS to embedded devices, and how he’s using Swift to build new tools for the community. We also explore the advantages of building CLIs in Swift, and discuss how Swift is becoming a great tool beyond iOS, with support for Linux, CLI tools, server-side projects, and embedded development.

• Website
• GitHub
• Mastodon

• PlaydateKit
• yap
• fx-upscale
• Unsqueeze

• Swift.org - Embedded
• Byte-sized Swift: Building Tiny Games for the Playdate
• Noora

Shai Mishali first encountered computers at a young age, when he got an IBM XT as a gift. He started to play with HTML and PHP to build something new in that time: websites. Around 2011 in one of his early jobs, their contractor went bankrupt, so Shai’s boss pushed him to become an iOS developer.

From there, he fell in love with iOS development. His passion for the shiny, touch-based devices, went all the way to the way to constantly learning better ways to build apps for them. By studying open source projects, learning new architectures, maintaining RxSwift (a very popular reactive programming library for Swift), and later on writing articles and books, Shai became a well-known figure in the Swift community. His talks in conferences, usually with great live coding, give the audience practical skills backed by deep knowledge.

Nowadays, Shai works as Staff iOS Engineer at monday.com. He plays a crucial role in architectural decisions and technology adoption strategies, particularly when combining (pun intended) Swift concurrency with reactive patterns. More recently, he’s been diving into core concepts of AI, and how it can help developers in a reliable way.

In today’s episode, Shai shares not only his personal journey, but also his thoughts on Open Source, using Swift to build tools, and also two hot topics. First, how Swift concurrency has evolved, and what the changes in Swift 6.1 bring to make it simpler to use. Another important topic is how developers should approach the overwhelming pace of changes that AI brings to the table: MCPs, RAG, and how to make the most of it to become a better programmer, staying ahead of the curve. Check it out!

• GitHub
• Mastodon
• X

• Swift Heroes 2024: Macro Polo: A new generation of code generation
• Swift Connection 2023 - Shai Mishali - A Crash Course of The Composable Architecture
• Swift Heroes 2022: A crash course of async await
• try! Swift NYC 2019: Getting Started with Combine
• Swift Heroes 2019: Designing a Design System

Nick’s journey into programming started early, though he didn’t follow a traditional computer science path: he studied electronic engineering at university before transitioning into web development. In 2009, the company he worked for wanted to get into iPhone app development, and this is when he took the opportunity to dive into a new field: iOS development.

This led him to become involved in iOS development, where one of his open source projects became very popular: iCarousel. It allowed displaying a cover flow interface, similar to the UI present in the iPod app. This helped establish his name in the iOS community, along with a book he wrote on Core Animation.

One day, after Swift was released, Nick decided to create a tool to solve code formatting issues, to allow himself, and his team, to focus on what matters in Pull Requests: the functionality and the architecture, not the amount of whitespaces or the position of the brackets. Nowadays, SwiftFormat is by far his most popular project, solving code formatting issues for hundreds - if not thousands - of developers.

In this episode, Nick shares his journey from web development to becoming a key contributor to the Swift ecosystem. He discusses the evolution of SwiftFormat, its technical implementation details, and how it compares to Apple’s official swift-format. He also shares insights about maintaining motivation in programming and his thoughts on the future of Swift development.

• Website
• GitHub
• Mastodon

• try! Swift Tokyo 2025 - SwiftSyntax: for good and evil
• SwiftServerConf: So You Think You Know Swift?

• SwiftFormat
• iCarousel
• Expression

Back in 2017, Pedro Piñera was working at SoundCloud in the iOS Platform team. Their codebase was a mix of Swift and Objective-C, and developers faced difficulties when dealing with linking, build phases, build settings, and other complexities. Additionally, they would have Git conflicts in the Xcode project file.

That’s when Pedro decided to create a tool that would solve Xcode’s complexity by using project generation, which would abstract Xcode’s intricacies, instead of creating a new build system. With that, Tuist was born.

As Tuist’s users come from iOS and macOS development background, choosing Swift was a no-brainer, to encourage contributions from anyone using it. The tool was well received, the project became more popular, and the community around it grew over the years. One of the contributors, Marek Fořt, added support for SPM dependencies. Later on, he became part of the core team.

Facing the challenges of maintaining an open source project, Pedro and Marek decided to establish a company around Tuist. Their objective: to guarantee a sustainable future for the project and develop a better product.

In this episode, Pedro and Marek share the journey of Tuist since its inception, and discuss the challenges of scaling an open source project: what starts as a pet project can easily burn you out. They also explore some of the contributions they are able to provide to the Swift community, by extracting battle-tested parts of Tuist into reusable packages. Finally, they share the vision for the future of Tuist, by making it become more than a CLI tool. A broader ecosystem, with a server component and automation blocks, with the goal of helping developers in their workflows of creating software, testing it, sharing with others.

• Interactive & Beautiful CLI Tools with Noora
• Running System Processes with Command

• Website
• Mastodon
• Bluesky
• Slack

• Command
• Noora
• XcodeGraph
• XcodeProj
• Tuist

• Website
• GitHub
• Mastodon

• Website
• GitHub
• Mastodon

Natalia’s journey into programming didn’t start with Swift - it was actually with Java. Later on, she worked on a codebase in Ruby, and in 2014 she joined the company that built Paw, the macOS HTTP client, where her time was mostly spent by coding in JavaScript. But working with interpreted languages didn’t feel quite right for her.

Around that time, Apple had just released Swift, and it came in a great timing for Natalia. She missed the compiled aspect of Java, but also the simplicity and the expressiveness of Ruby and JS. This brought her closer to the iOS and macOS development scene, and in 2019 SwiftUI became the new kid on the block.

With the limitations of the first version of SwiftUI, Natalia started writing great blog posts about it, drawing the attention of the engineers behind it: a few months later, Natalia joined Apple and helped build some new SwiftUI components.

In 2022 she left Apple, and slowly transitioned to fully working on her own projects. Last week Natalia published her 3rd book, SwiftUI Fundamentals, covering its core principles and concepts. Today she joins us to speak about her early career, the work she did at Apple, and how she manages mixing writing blog posts, publishing books, and doing client work.

• Blog
• SwiftUI Fundamentals
• Swift Gems
• Integrating SwiftUI into UIKit Apps

• X
• Mastodon
• Bluesky