Shift in the protocol paradigm
In this article we will be talking about the recent changes related to protocols: opaque, existential and generic types; some and any; runtime and compile-time polymorphism.
Modularity. What problem does it solve?
In this article we will discuss the problem that can be solved by modularity and how exactly modularity can make you project much better thing to deal with.
Do protocols break Single Responsibility Principle?
In previous posts we’ve mentioned all the different use cases for this language feature. Now let’s consider some hidden complications which we get together with all the power.
Pitfalls of protocol extensions
In previous posts we’ve mentioned all the different use cases for this language feature. Now let’s consider some hidden complications which we get together with all the power.
Protocol extensions
When people speak about how powerful protocols are in Swift, in a lot of cases they consider protocol extensions as part of this power. That’s unfair because it’s a separate language feature, and an interesting one. Here we will detach and dissect it.
Dark side of extensions in Swift
Extension is a very powerful concept in Swift. It has several different applications in our code: we can extend the data types we don’t own, we can extend our own ones, we can separate the functionality and protocol conformance. Each one of them gives us additional capabilities and extra powers, but some of them come together with drawbacks which we have to consider.
Several faces of protocols
“Protocols is one of the most powerful language features in Swift” - people say. Hard to argue. In Swift you can do a lot of different things with protocols. (Maybe even too many… but we will talk about it later).
Modularity. Encapsulation
What is this post about:
- what modularity gives us in terms of context separation
- what can help us to keep the module properly encapsulated
- what is a Showcase app and how it can improve our development
- what might be some possible challenges
Modularity. Boundaries
In this post we’ll talk about why boundaries matter and what types of modularity can we distinguish in our projects based on the existing boundaries.
Thoughts on rewriting the Messenger App by Facebook.
In my small iOS information bubble this post from FB-engineering exploded so nobody could ignore it.
Navigation Bar Customisation. Part 2 - UINavigationBarAppearance and proper view/model separation.
Navigation bar customisation is quite a trivial task, but even before iOS 13 you could approach it in couple of different ways. This year another API has appeared. The new way suppose to replace the old ones and solve the issues which were not addressed by Apple so far. Let’s see how it fits into the toolset that is in our disposal.
Navigation Bar Customisation. Part 1 - The Basics.
Customisation of a navigation bar is one of the first tasks a junior iOS-developer takes up. Roughly every app (and even most of the test samples and tutorials) has a navigation stack and nobody wants to stick to the default system style of a bar.
Property Wrappers
In my opinion property wrappers are one of the most interesting features of SwiftUI and the upcoming Swift 5.1. Here I’ll share what has caught my attention and what looks the most interesting about this brand new thingy.
Aftermath of WWDC
Happy New Apple Year! For ones who work with iOS/macOS/swift development every new year starts not in January but in the beginning of June.
Siri Shortcuts Practical Tips
Let’s say, you decided to implement a new platform feature in your app. You read the documentation, checked some tutorials and examples in the internet, you created a sample app and everything worked great. Then you started to integrate it into your existing production app, and here came all the fun.
Serialization of enum with associated type
Enumerations are not just first-class citizens in Swift. They adopt many features traditionally supported only by classes, such as computed properties or static and instance methods. Enumerations can also define custom initialisers, can be extended to expand their functionality beyond their original implementation, and can conform to protocols to provide standard functionality.
Siri Intents
Siri Intents are the cornerstone notion of all the interaction with Siri no matter if it is full-fledged SiriKit usage or Siri Shortcuts. In this post we will try to figure out what Siri Intent is, what is the difference between Domain Related Intents and Siri Shortcuts and which approach is suitable for which use cases.
iOS App Extensions: Data Sharing
App extensions are permeating more and more into our daily job. But some nuances of the way they work are still not so obvious. In this post I try to investigate different ways to share data between an app and its extension.
Object serialization in iOS
In this post I’ll try to systemise the knowledge about major formats and types of data serialization in iOS development. I will also compare ObjC approach to the problem (NSCoding) with the one we got in Swift 4 (Codable) and will take a look at some specific use cases like interop between them and the ability to work with complex object graphs.
Compile-time code optimization for Swift and Objective-C
Some time ago I needed to switch off asserts for one of the configurations in our project. I kinda read somewhere that whether or not asserts compile to the resulting binary depends primarily on the code optimisation level. But I wondered if there was any way to control the asserts without changing the optimisation level? What if I don’t want to touch it for the asserts only? Do we have separate optimisation levels for Swift and Objective-C code? What do they mean, what are they influence on? How do two compilers in the mixed Swift/ObjC project work together optimising the code? What specifically the compiler does for each optimisation level?
Thoughts on iOS Architecture
Seems like in software development and in iOS particularly yet another post about the architecture looks banal if not just boring. But believe me I won’t compare MVVM to VIPER or tell you how bad it is to have Massive View Controller. I will not explain you why you should follow a single responsibility principle, why DI is good or what are the trade-offs of using singletons - I assume you already know that (if not, there are tons of articles about it). This post is more as an attempt to structure my own thoughts on this topic. There will be more questions asked than answers given.
HealthKit changes observing
There are plenty of “Getting started with HealthKit” tutorials which tells you how to set up the HealthKit integration, request an access to read and write data and make simple queries. That’s pretty much enough you need to know if you just need to get user’s sex, height or recent weight measurement. I assume you already know how to deal with all that. But what if you need to monitor and process the changes in user’s HealthApp? For this purpose HealthKit provides you HKObserverQuery.
Stranger things with Core Data Stacks comparison
Core Data is one of the most arguable frameworks for iOS/macOS development and Core Data Stack is indeed one of the most arguable questions inside Core Data topic. Which stack to choose? Which one is more efficient? Discussions about all that have been going on in the community for years.
CADisplayLink and its applications
Usually developers get to know CADisplayLink as an advanced timer for “creating smooth frame-by-frame animation”. And that’s one of it’s application, but not the only one. Let’s take a look at the class, it’s capabilities and some general approaches to use it.