<?xml version="1.0" encoding="utf-8" standalone="yes"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom">
  <channel>
    <title>Side Effect</title>
    <link>/</link>
    <description>Recent content on Side Effect</description>
    <generator>Hugo -- gohugo.io</generator>
    <language>en-us</language>
    <managingEditor>thibault@sideeffect.io (Thibault Wittemberg)</managingEditor>
    <webMaster>thibault@sideeffect.io (Thibault Wittemberg)</webMaster>
    <copyright>2026 Side Effect All rights reserved</copyright>
    <lastBuildDate>Wed, 11 Jan 2023 00:00:00 +0000</lastBuildDate><atom:link href="/index.xml" rel="self" type="application/rss+xml" />
    <item>
      <title>Debouncing with Swift concurrency</title>
      <link>/posts/2023-01-11-regulate/</link>
      <pubDate>Wed, 11 Jan 2023 00:00:00 +0000</pubDate>
      <author>thibault@sideeffect.io (Thibault Wittemberg)</author>
      <guid>/posts/2023-01-11-regulate/</guid>
      <description>When developing an iOS application, it is a common need to handle the frequency at which information is processed. For example, when making changes to a search field, we might want to request a remote API for each update. However, sending too many requests in quick succession can cause the server to become overloaded. To avoid this issue, it is important to pace the requests in order to prevent overloading the server. One solution to this problem is to use reactive programming and apply a Debounce operator to a stream of user inputs. However, if you don&#39;t want to use reactive programming, async sequences, or third-party libraries, you can explore a solution using pure Swift concurrency. In this article, we will look at how to use this approach to manage the frequency of information processing in an iOS application.</description>
    </item>
    
    <item>
      <title>AsyncSequence extensions</title>
      <link>/posts/2022-03-13-asyncsequenceextensions/</link>
      <pubDate>Mon, 21 Mar 2022 00:00:00 +0000</pubDate>
      <author>thibault@sideeffect.io (Thibault Wittemberg)</author>
      <guid>/posts/2022-03-13-asyncsequenceextensions/</guid>
      <description>Swift 5.5 introduced structured concurrency, and with it came AsyncSequence, a new way to provide a flow of values over time. Wait, what? Isn&#39;t this what Combine is all about? From Apple, &#34;The Combine framework provides a declarative Swift API for processing values over time&#34;. Are these technologies similar? Interchangeable? Well, sort of! In this article we will explore the differences and similarities between them and we will go over a repo that brings Combine-like operators to AsyncSequence.</description>
    </item>
    
    <item>
      <title>Equatable Errors in Swift</title>
      <link>/posts/2021-12-10-equatableerror/</link>
      <pubDate>Fri, 10 Dec 2021 00:00:00 +0000</pubDate>
      <author>thibault@sideeffect.io (Thibault Wittemberg)</author>
      <guid>/posts/2021-12-10-equatableerror/</guid>
      <description>Error is a base type in Swift that aims to represent an issue happening in the application flow; thus, it is very common to use it as an existential type that will cross the application layers. With Error being a protocol, we can implement our own custom errors making them Equatable if needed. In doing so we might have to leak implementation details across the application. This article explores a way to make an error conform to Equatable without compromising its abstraction.</description>
    </item>
    
    <item>
      <title>A DSL for state machines in Swift</title>
      <link>/posts/2021-02-13-statemachinedsl/</link>
      <pubDate>Sat, 13 Feb 2021 00:00:00 +0000</pubDate>
      <author>thibault@sideeffect.io (Thibault Wittemberg)</author>
      <guid>/posts/2021-02-13-statemachinedsl/</guid>
      <description>State machines are great tools to describe systems with a finite number of states. They are predictable and testable, which is something we praise for as developers. State machines can be defined in a pretty abstract way, which makes it a good candidate for a Domain Specific Language implementation. In this article, we will try to create a DSL that can describe state machines in Swift and use it in a feedback loop architecture.</description>
    </item>
    
    <item>
      <title>Functions as dependencies in Swift</title>
      <link>/posts/2020-08-19-functionsasdependencies/</link>
      <pubDate>Wed, 19 Aug 2020 00:00:00 +0000</pubDate>
      <author>thibault@sideeffect.io (Thibault Wittemberg)</author>
      <guid>/posts/2020-08-19-functionsasdependencies/</guid>
      <description>Implementing an architecture within an application can be challenging. There are rules we can follow (SOLID, Clean Architecture) and patterns to guide us (MVVM, MVP, MVI, Redux, …) but sometimes, things we thought were well established deserve a step back.</description>
    </item>
    
    <item>
      <title>Introducing Spin</title>
      <link>/posts/2020-03-26-spin/</link>
      <pubDate>Thu, 26 Mar 2020 00:00:00 +0000</pubDate>
      <author>thibault@sideeffect.io (Thibault Wittemberg)</author>
      <guid>/posts/2020-03-26-spin/</guid>
      <description>Introducing Spin, a universal feedback loop system in Swift. A Feedback Loop is a system that is able to self-regulate by using the resulting value from its computations as the next input to itself, constantly adjusting this value according to given rules.</description>
    </item>
    
    <item>
      <title>Swift - An Aspect Oriented Programming Language ?</title>
      <link>/posts/2019-07-20-swift-aop/</link>
      <pubDate>Sat, 20 Jul 2019 00:00:00 +0000</pubDate>
      <author>thibault@sideeffect.io (Thibault Wittemberg)</author>
      <guid>/posts/2019-07-20-swift-aop/</guid>
      <description>To answer this question, we must first understand what is Aspect Oriented Programming (aka AOP). I like to see AOP as a response to a certain kind of failure of Object Oriented conceptions.</description>
    </item>
    
    <item>
      <title>Property Wrappers In Swift 5.1, The Missing Published Implementation</title>
      <link>/posts/2019-06-18-propertywrappers/</link>
      <pubDate>Tue, 18 Jun 2019 00:00:00 +0000</pubDate>
      <author>thibault@sideeffect.io (Thibault Wittemberg)</author>
      <guid>/posts/2019-06-18-propertywrappers/</guid>
      <description>It’s been an amazing WWDC this year. SwiftUI and Combine were some big announcements of the conference. They will have a huge impact on our daily life as iOS developers.</description>
    </item>
    
    <item>
      <title>RxReduce - Reactive State Container Architecture Part 2</title>
      <link>/posts/2018-06-25-rxreduce-part2/</link>
      <pubDate>Mon, 25 Jun 2018 00:00:00 +0000</pubDate>
      <author>thibault@sideeffect.io (Thibault Wittemberg)</author>
      <guid>/posts/2018-06-25-rxreduce-part2/</guid>
      <description>As we saw in “RxReduce - A Reactive State Container Architecture Part 1”, State is a central concern in applications. I strongly invite you to take a look at this first article. So far, we haven’t introduced the concept of Reactive Programming and how it can address some issues I’ve encountered in traditional implementations of State Containers. We will see how RxReduce, an open source framework of the RxSwiftCommunity, can help you handle the State, its mutations, and the asynchronous work related to the side effects, in a Reactive way.</description>
    </item>
    
    <item>
      <title>RxReduce - Reactive State Container Architecture Part 1</title>
      <link>/posts/2018-06-24-rxreduce-part1/</link>
      <pubDate>Sun, 24 Jun 2018 00:00:00 +0000</pubDate>
      <author>thibault@sideeffect.io (Thibault Wittemberg)</author>
      <guid>/posts/2018-06-24-rxreduce-part1/</guid>
      <description>State management has become a very popular concern lately in mobile applications. The idea of a state that should be the single source of truth within an application is quite attractive ! The views would only be a displayable artefact of this state 👌.</description>
    </item>
    
    <item>
      <title>Type safe network layer</title>
      <link>/posts/2018-04-28-typesafenetworklayer/</link>
      <pubDate>Sat, 28 Apr 2018 00:00:00 +0000</pubDate>
      <author>thibault@sideeffect.io (Thibault Wittemberg)</author>
      <guid>/posts/2018-04-28-typesafenetworklayer/</guid>
      <description>There are plenty of posts about doing a network layer in a type safe way with Swift. No matter the used network API, those approaches all rely on returning a data type that is precisely what we expect. In this post we will try to go a little bit further by strongly coupling the endpoint we want to fetch and the data type we are expecting.</description>
    </item>
    
    <item>
      <title>A glance at conditional conformance</title>
      <link>/posts/2018-04-02-glanceatconditionalconformance/</link>
      <pubDate>Mon, 02 Apr 2018 00:00:00 +0000</pubDate>
      <author>thibault@sideeffect.io (Thibault Wittemberg)</author>
      <guid>/posts/2018-04-02-glanceatconditionalconformance/</guid>
      <description>Swift 4.1 is available since a few days now and it comes with an interesting feature - Conditional conformance. This is a new tool for achieving Protocol Oriented Programming as well as API designing. This post is a quick take on this brand new technic and will be followed for sure by deep dive posts in a few weeks.</description>
    </item>
    
    <item>
      <title>Elegantly chaining UIViewPropertyAnimators</title>
      <link>/posts/2018-03-24-elegantlychaininguiviewpropertyanimators/</link>
      <pubDate>Sat, 24 Mar 2018 00:00:00 +0000</pubDate>
      <author>thibault@sideeffect.io (Thibault Wittemberg)</author>
      <guid>/posts/2018-03-24-elegantlychaininguiviewpropertyanimators/</guid>
      <description>Usually my posts are mostly about design patterns, software architectures (or RxFlow 😀), but this time it will be different and frankly I didn&#39;t think I would write about this kind of topic. But I think I have something cool to share - so today we are going to talk about Animations with Swift.</description>
    </item>
    
    <item>
      <title>Protocol Oriented Tips For MVVM in Swift</title>
      <link>/posts/2018-01-02-protocolorientedtipsmvvm/</link>
      <pubDate>Tue, 02 Jan 2018 00:00:00 +0000</pubDate>
      <author>thibault@sideeffect.io (Thibault Wittemberg)</author>
      <guid>/posts/2018-01-02-protocolorientedtipsmvvm/</guid>
      <description>Hi folks. Lately MVVM has become some sort of standard as an architecture for iOS apps. It offers a good separation of concerns, a good way to format data and great view binding mechanisms with frameworks such as RxSwift. In this post I will give few tips I use to ease the implementation of this pattern.</description>
    </item>
    
    <item>
      <title>RxFlow Part 3 - Tips and tricks</title>
      <link>/posts/2017-12-22-rxflow-part3/</link>
      <pubDate>Fri, 22 Dec 2017 00:00:00 +0000</pubDate>
      <author>thibault@sideeffect.io (Thibault Wittemberg)</author>
      <guid>/posts/2017-12-22-rxflow-part3/</guid>
      <description>This is the final chapter of our journey within RxFlow. I’ve already exposed all the key features/principles of the framework in these 2 previous parts, let’s dive into some tips and tricks I used thanks to Reactive Programming.</description>
    </item>
    
    <item>
      <title>RxFlow Part 2 - In Practice</title>
      <link>/posts/2017-12-09-rxflow-part2/</link>
      <pubDate>Sat, 09 Dec 2017 00:00:00 +0000</pubDate>
      <author>thibault@sideeffect.io (Thibault Wittemberg)</author>
      <guid>/posts/2017-12-09-rxflow-part2/</guid>
      <description>A few weeks ago I introduced in this blog an iOS framework called RxFlow. I’ve been working on this framework for several months, and it is now ready to be used. If you haven’t read it yet, I suggest you take a look at this post &#34;RxFlow Part1 - In Theory&#34;.</description>
    </item>
    
    <item>
      <title>Versatile Namespace</title>
      <link>/posts/2017-11-22-versatilenamespace/</link>
      <pubDate>Wed, 22 Nov 2017 00:00:00 +0000</pubDate>
      <author>thibault@sideeffect.io (Thibault Wittemberg)</author>
      <guid>/posts/2017-11-22-versatilenamespace/</guid>
      <description>In Swift, some APIs such as RxSwift use a technic that confines the code they’re exposing in a dedicated namespace. In this post we will figure out how this is done in the most generic and versatile way.</description>
    </item>
    
    <item>
      <title>Type erasure in Swift</title>
      <link>/posts/2017-11-09-typeerasure/</link>
      <pubDate>Thu, 09 Nov 2017 00:00:00 +0000</pubDate>
      <author>thibault@sideeffect.io (Thibault Wittemberg)</author>
      <guid>/posts/2017-11-09-typeerasure/</guid>
      <description>With Swift, you can define protocols by associating one or more generic types. These types are defined using the associatedtype keyword. The name “Generic Type” is a bit usurped here, we should talk about a placeholder for a reserved type. Indeed, we will see that such protocols do not offer great flexibility of use when it comes to consider them as generic.</description>
    </item>
    
    <item>
      <title>RxFlow Part 1 - In Theory</title>
      <link>/posts/2017-11-08-rxflow-part1/</link>
      <pubDate>Wed, 08 Nov 2017 00:00:00 +0000</pubDate>
      <author>thibault@sideeffect.io (Thibault Wittemberg)</author>
      <guid>/posts/2017-11-08-rxflow-part1/</guid>
      <description>This is a first article in a series that will be the heart of this blog for a while. I’m going to introduce RxFlow - a framework of my design implementing Reactive Flow Coordinator within iOS applications. RxFlow relies on RxSwift and is a project supported by the RxSwiftCommunity.</description>
    </item>
    
    <item>
      <title>EZStream</title>
      <link>/posts/2017-11-01-ezstream/</link>
      <pubDate>Wed, 01 Nov 2017 00:00:00 +0000</pubDate>
      <author>thibault@sideeffect.io (Thibault Wittemberg)</author>
      <guid>/posts/2017-11-01-ezstream/</guid>
      <description>EZStream is the easiest way to stream your device camera in any web browser.</description>
    </item>
    
  </channel>
</rss>
