Embracing the Future with Web3 and Blockchain in Swift & iOS Development
Part 1

In the dynamic landscape of mobile app development, staying ahead means embracing emerging technologies that redefine the way we interact with digital platforms. Enter Web3 and blockchain — revolutionary forces reshaping the internet as we know it. As iOS developers, harnessing the power of Swift, Apple’s sophisticated programming language, we have the opportunity to pioneer the integration of Web3 and blockchain into the iOS ecosystem.

Web3 represents a paradigm shift towards a decentralized internet, where users have greater control over their data and interactions. At the core of this evolution lies blockchain technology, offering immutable ledgers, smart contracts, and cryptographic security. The potential applications of Web3 and blockchain in iOS development are as diverse as they are exciting, from decentralized applications (DApps) revolutionizing finance and gaming to NFT marketplaces redefining digital ownership.

This initial article serves as an introductory guide, outlining the essential components of blockchain technology and how they can be utilized in iOS environments. As we delve deeper into this series, I will provide practical examples involving NFTs and showcase a real-world application to demonstrate how these technologies can be innovatively applied in iOS apps. This sequence aims not only to educate but also to inspire iOS developers to explore the burgeoning possibilities of blockchain technology in their projects.

Stay tuned for part two, where we turn theory into practice with engaging, hands-on demonstrations.

Whether you’re a seasoned iOS developer or a newcomer eager to explore the cutting-edge of technology, this exploration of Web3 and blockchain in Swift & iOS development promises to ignite your creativity and propel you towards the forefront of digital innovation.

Key definitions

Web3 - Web3 refers to the next generation of the internet, characterized by decentralized protocols and applications that prioritize user sovereignty and data ownership. Unlike Web2, which relies heavily on centralized platforms and intermediaries, Web3 aims to empower individuals by enabling direct peer-to-peer interactions and fostering trust through cryptographic principles. In essence, Web3 represents a shift towards a more open, transparent, and inclusive internet where users have greater control over their digital identities, assets, and interactions.

Blockchain - Blockchain is a distributed ledger technology that enables the secure and transparent recording of transactions across a network of computers. At its core, a blockchain consists of a chain of blocks, each containing a list of transactions cryptographically linked to the preceding block. This immutable structure ensures that once a transaction is recorded, it cannot be altered or tampered with, thus providing a high degree of trust and security. Blockchains can be public, allowing anyone to participate in the network (e.g., Bitcoin), or permissioned, where access is restricted to certain entities (e.g., enterprise blockchains). Blockchain technology finds applications in various fields, including finance, supply chain management, voting systems, and decentralized applications (DApps).

Decentralization - Decentralization refers to the distribution of power, authority, or control across a network of nodes or participants, rather than concentrating it in a single central authority or entity. In decentralized systems, decision-making processes and resource allocation are distributed among multiple participants, often through consensus mechanisms, without relying on a central intermediary. Decentralization can foster transparency, resilience, and democratization by reducing single points of failure, mitigating censorship, and empowering individuals to have greater autonomy and sovereignty over their data and interactions. This concept is fundamental to various technologies and movements, including blockchain, Web3, decentralized finance (DeFi), and decentralized autonomous organizations (DAOs).

Smart contracts - Self-executing contracts with the terms of the agreement directly written into code. They automatically execute and enforce the terms of the contract when predefined conditions are met, without the need for intermediaries.

Worthy mentions:
Non-Fungible Tokens (NFTs) - Unique digital assets stored on a blockchain, representing ownership of a specific item, artwork, or collectible. Unlike cryptocurrencies such as Bitcoin or Ethereum, NFTs are not interchangeable, as each token has its own distinct value and properties.

Decentralized Finance (DeFi): A financial system built on blockchain technology that aims to recreate traditional financial services (such as lending, borrowing, trading, and investing) in a decentralized manner, without relying on intermediaries like banks or brokerages.

Web3 in iOS apps

By leveraging blockchain technology, iOS apps can offer decentralized and transparent solutions that do not rely on central authorities. This enhances trust among users by ensuring that data and transactions are immutable and verifiable.

Next to that, blockchain technology provides robust security features such as cryptographic encryption and decentralized consensus mechanisms. This helps in safeguarding user data and preventing unauthorized access or tampering, which is crucial for maintaining user privacy and protecting sensitive information.

Web3 and blockchain iOS apps empower users by giving them greater control over their digital assets, identities, and interactions. Through features like self-sovereign identity and ownership of digital assets (such as NFTs), users can have more autonomy and agency in the digital realm.

Building blockchain and Web3 iOS apps opens up opportunities for innovation and disruption across various industries. From a decentralized finance (DeFi) to supply chain management, gaming, healthcare, and beyond, these apps can revolutionize traditional systems and create new paradigms of interaction and value exchange.

Embracing blockchain and Web3 technologies in iOS app development helps future-proof apps against evolving technological trends and user preferences. As the Web3 ecosystem grows and matures, iOS apps that integrate these technologies will remain relevant and competitive in the rapidly changing digital landscape.

Q: How do I use Web3 in Swift?

Here’s an overview of key concepts and components related to implementing Web3 in Swift:

Blockchain Networks - Web3 in iOS allows developers to connect and interact with various blockchain networks such as Ethereum, Bitcoin, or other blockchain platforms that support the Web3 standards.

Wallet integration enables users to manage their cryptocurrencies and interact with decentralized applications securely. Developers can implement features like creating wallets, importing/exporting wallets, and signing transactions within their iOS applications. This includes transactions for transferring cryptocurrencies, interacting with smart contracts, and executing other blockchain operations.

Smart Contract Interaction - Web3 libraries enable iOS developers to interact with smart contracts deployed on blockchain networks. This includes functionalities like deploying smart contracts, calling methods, and listening to events emitted by smart contracts. They also handle communication with blockchain nodes and APIs. This includes sending and receiving transactions, querying blockchain data, and subscribing to real-time updates from the blockchain network.

Libraries

In iOS development, leveraging Web3 technologies is made accessible through libraries such as Web3.swift, EthereumKit, and web3swift.

Web3.swift
https://github.com/Boilertalk/Web3.swift

With Web3.swift, developers gain a powerful toolkit for seamlessly integrating Ethereum-based functionalities into their iOS applications. Offering an intuitive interface and robust functionalities, Web3.swift empowers iOS developers to effortlessly engage with Ethereum-based blockchains. This library encompasses a wide array of capabilities, spanning transaction management, blockchain data querying, smart contract interaction, and Ethereum wallet management

EthereumKit
https://github.com/yuzushioh/EthereumKit

Meanwhile, EthereumKit is a Swift framework designed to simplify the integration of Ethereum blockchain functionality into iOS applications. Tailored to streamline complex tasks, EthereumKit offers a range of features essential for iOS developers entering the realm of blockchain development. It facilitates seamless interaction with Ethereum nodes and smart contracts, enabling tasks such as transaction signing, data retrieval, and smart contract interactions. With EthereumKit, developers gain access to a suite of tools that streamline development, empowering them to create robust and efficient Ethereum-enabled iOS applications.

web3swift
https://github.com/web3swift-team/web3swift

Additionally, web3swift provides a comprehensive solution for Ethereum wallet management, transaction handling, and smart contract interaction, empowering iOS developers to easily build decentralized applications.

Whether it’s interacting with smart contracts, sending transactions, or managing Ethereum wallets, these libraries offer essential building blocks for crafting innovative Web3 experiences within iOS environments.

Keep in mind that the Web3 ecosystem in Swift is still evolving, so you may need more support in these libraries. It’s essential to review the documentation, community support, and updates before integrating any library into your iOS project.

Web3 Platforms & Data Providers

Exploring alternative avenues, iOS developers can effectively leverage blockchain technology by utilizing Web3 platforms and data providers. These tools provide a robust foundation for seamlessly incorporating blockchain capabilities into iOS applications, enhancing functionality and user experience.

Integrating blockchain technology into iOS applications requires a robust infrastructure that can handle the unique complexities of blockchain data. Web3 data providers like Alchemy or Infura are pivotal in this integration, providing APIs that facilitate a seamless connection to blockchain networks. These providers enable iOS developers to implement a wide range of blockchain functionalities, including but not limited to, managing user wallets, executing smart contracts, and accessing detailed transaction histories.

🚀 Getting Started with Ethereum Development Using Alchemy

Furthermore, the use of these data providers not only enhances the functionality of iOS applications but also scales with the application as user demand increases. Providers like Alchemy boast high-performance node infrastructure which can handle increased queries as blockchain usage grows, without compromising the speed or reliability of the application.

Q: How to integrate data providers?

Integrating blockchain technology into iOS applications can be achieved through the strategic use of Web3 providers by embedding them into the networking layer or the backend endpoints of the app. This approach enables iOS developers to harness the full potential of blockchain functionalities while ensuring the app remains responsive and user-friendly.

By incorporating Web3 data providers into the networking layer of an iOS app, developers can establish a direct line of communication with blockchain networks. This integration allows for real-time data retrieval and interaction with blockchain services, such as executing transactions or querying blockchain states, directly from the user’s device. Implementing Web3 at the networking layer means that blockchain data can be processed and handled at the same level as other network operations, ensuring that the data handling is seamless and efficient. It allows the application to maintain a consistent performance standard, managing blockchain interactions as part of its native network operations.

Alternatively, integrating Web3 functionalities at the backend allows for more complex operations and enhanced security measures. By handling blockchain interactions server-side, sensitive data and blockchain logic can be managed away from the client side, minimizing security risks associated with client-side exposure. Backend integration involves setting up endpoints that interact with the blockchain, processing requests such as wallet management, smart contract deployment, and other blockchain-specific actions. These endpoints then serve the processed data to the iOS app as needed, similar to any other API service. This method not only secures the blockchain operations but also offloads the computational burden from the user’s device, leading to better app performance and lower latency in user interactions.

• What is a Blockchain Node Provider? Why Do I Need One?
• What is Infura

Ethereum transaction fundamentals

Understanding the key elements of Ethereum transactions can provide insight into how Ethereum operates and how it supports more complex operations like smart contracts. Here are the crucial components used in Ethereum transactions:

Nonce - The nonce is a unique number assigned to each transaction sent from a specific Ethereum address. It serves as a way to ensure that each transaction is processed only once and in the correct order. The nonce starts at zero for each address and increments by one for each subsequent transaction sent from that address. This prevents replay attacks and ensures the integrity and order of transactions on the Ethereum blockchain.

Gas Price - Gas is a unit used to measure the computational work required to execute operations on the Ethereum blockchain. Gas price refers to the amount of Ether (ETH) a user is willing to pay per unit of gas to have their transaction processed by miners. It essentially represents the transaction fee paid to incentivize miners to include the transaction in a block and process it. Transactions with higher gas prices are typically processed more quickly, as miners prioritize transactions with higher fees.

Gas Limit - Gas limit specifies the maximum amount of gas that a sender is willing to consume for a transaction. It represents the upper bound on the computational resources (gas) that can be utilized to execute the transaction. If the execution of a transaction exceeds the specified gas limit, the transaction will fail, and any unused gas will be refunded to the sender. Setting an appropriate gas limit ensures that transactions do not exceed the sender’s resource constraints and protects against potential infinite loops or other resource-intensive operations.

v, r, s (Signature Fields) - These fields make up the cryptographic signature generated from the private key of the sender, which is used to verify the authenticity of the transaction. The signature ensures that the transaction cannot be altered by anyone once it has been issued.

Chain ID - Introduced in EIP-155 to prevent replay attacks across different Ethereum-based chains, the chain ID indicates which Ethereum network the transaction is intended for (e.g., mainnet, testnet).

ABI Contract transaction - In the context of Ethereum, an ABI contract refers to the contract’s Application Binary Interface, which specifies the methods and parameters that can be used to interact with the contract.

An ABI contract essentially serves as a communication interface between Ethereum smart contracts and external applications or clients. It defines the structure of the contract, including its functions, inputs, outputs, and events. By adhering to the ABI specification, developers can ensure that their smart contracts can be properly understood and interacted with by external parties.

ABI contracts are typically generated from Solidity or other smart contract programming languages during the compilation process. They provide a standardized way for applications to interact with Ethereum smart contracts, enabling seamless integration and interoperability across the Ethereum ecosystem.

Dynamic contracts - In blockchain terminology, dynamic contracts are smart contracts that possess the capability to adapt or modify their code or behavior over time. Unlike static contracts, which are fixed and unchangeable once deployed, dynamic contracts incorporate features that enable adjustments based on specific conditions or triggers.

Dynamic contracts often utilize functionalities such as upgradeability, allowing certain sections of the contract’s code to be substituted with new implementations, or parameterization, which enables flexible adjustments to behavior without altering the underlying code.

Real-World Example: Dynamic Leasing Agreements in Real Estate

Imagine a commercial real estate platform built on the Ethereum blockchain, designed to manage lease agreements dynamically. This platform caters to various properties — offices, retail spaces, and warehouses. Each property has different leasing terms and conditions, which can change based on market demand, duration of the lease, and specific tenant requirements.

Every time a property is listed for lease, a new smart contract for that particular lease agreement is dynamically generated. This is essential because each property might have unique terms based on its size, location, and the tenant’s business type. For instance, a warehouse might require different lease terms than retail space in a city center. By using dynamic contracts, the platform can create customized contracts on the fly, ensuring that all specific terms agreed upon between the landlord and the tenant are legally binding and automatically enforced via the blockchain.

Once these contracts are created, they must be managed and interacted with by various stakeholders, including property owners, tenants, maintenance services, and regulatory bodies. Here, the ABI comes into play. The ABI defines how interactions with these contracts occur, allowing software to understand how to read from and write to the contracts. For example, a tenant might need to verify terms, make a payment, or even terminate the lease. The ABI makes these interactions straightforward and standardized, ensuring that all actions are executed according to the underlying smart contract provisions.

Thanks for reading!

In summary, the incorporation of Web3 and blockchain technologies into iOS development represents a groundbreaking frontier for application advancement. Through the capabilities offered by Web3.swift and its seamless integration with Ethereum and other blockchain networks, iOS developers now have unparalleled opportunities to craft decentralized applications, integrate blockchain features, and engineer innovative solutions that redefine various sectors. By leveraging decentralized finance (DeFi), non-fungible tokens (NFTs), smart contracts, and beyond, iOS developers stand at the forefront of shaping the digital landscape. As we delve deeper into the potentials of Web3 and blockchain in iOS development, we embark on a journey toward a more decentralized, transparent, and interconnected digital realm.

The current article serves as an introductory piece, laying out the essential components of Blockchain and Web3 to equip iOS developers with the necessary theoretical knowledge. Upcoming in the series, Part 2 will delve deeper, featuring hands-on examples involving Non-Fungible Tokens (NFTs) and a detailed case study on a real-world application. This progression from theory to practice aims to provide a comprehensive understanding and inspire innovative uses of blockchain technology in iOS app development.

Explore These Resources Before Our Next Deep Dive

GitHub Libraries

• web3.swift
• Ethers.swift
• Geth.swift
• SwiftCryptoTokenKit

Forums and communities

• Stack exchange: Ethereum
• Ethereum Magicians Forum
• r/ethereum
• r/ethdev

Educational

• CryptoZombies
• Blockchain Specialization
• Investopedia
• edX Blockchain course

Dino is our valuable team lead.
At Azikus, we design and develop top notch mobile and web apps.
We are a bunch of experienced developers and designers who like to share knowledge, always staying up to date with latest and newest technologies.
To find out more about what we do, feel free to check our website.

Azikus

Unleashing the Power of Web3 and Blockchain in iOS — Part 1 was originally published in Azikus on Medium, where people are continuing the conversation by highlighting and responding to this story.

“Wow, how does Instagram make their screens animate like that?”
“Amazing animations, I wish I could do that.”
 — an iOS developer who hasn’t read this article

In this article, a few techniques that are making a difference for those high-end projects and applications will be presented. An important mention is that we are doing everything programmatically using UIKit, without the usage of storyboard/.xib files.

What exactly constitutes a high-end application? The answer usually lies in additional attention to detail and perfecting every user interaction inside the application. High-end applications usually contain a lot of “natural” user interactions with incredible smoothness and fluidness. The application should pay attention to “how it feels”. That’s why, for example, Instagram is one of the most popular apps today.

Applications that are considered to be top-notch use cutting-edge technology when it comes to the tools used in their development. Alongside advanced technological techniques, there is a delicate sense of design to ensure the best possible application “feel”.

Upper interaction, taken from Instagram, is the one that is going to be reproduced and explained in this article. The general idea with this interaction is how the flow feels unified — two screens share an image of the selected item. Additionally, we have terrific feedback on our finger moving. The screen follows our finger and dismisses depending on our movement rather naturally. Instagram uses this interaction both on the shop screen and on the user profiles screen to generate the selected item details screen.

Animation implementation

These animations require a pretty complex set of techniques to be implemented. It takes quite a bit of time for it to be perfect and detailed to the wanted behavior.

Our transitioning example consists of implementing animations for a screen presenting and a dismissal with a gesture in-between which decides if the screen should be dismissed based on the user’s behavior. The screens share an image that resizes accordingly to each screen’s needs.

The initial step of the animation is to implement the presentation. The wanted behavior includes that the presentation and the next screen involve the exact image we tapped on. That is going to be done by implementing a custom presentation animation from the starting screen to the one with an enlarged image and details. Similar to this technique, we will also implement the dismissal of the screen which will return the image to its previous location. To complete the screen dismissal behavior, we will also add a gesture which is taking care of the user’s finger interaction.

Transitioning

Usually, every iOS project consists of multiple screens. Those screens need to be shown somehow, right? Well, in iOS screens are shown by either pushing a ViewController on the stack or by presenting a ViewController on top of the parent one.

Pushing and popping ViewControllers usually notes a flow inside an application. A flow needs to have its Navigation controller, which as its name explains, handles navigating screens. Pushing is the action of showing a screen — putting a screen on top of the stack. Popping a ViewController means hiding a screen, removing it from the top. Basic examples are shown below.

navigationController?.pushViewController(ShowingViewController(), animated: true)

navigationController?.popViewController(animated: true)

Another way of showing a ViewController is by modally presenting it. It is usually used when you want to interrupt the current flow by an action. Modal screens are widely used for showing error and info messages. Also, they can start a new flow, but by preserving a current flow in the background. Present action shows the modal ViewController while a dismiss action hides the top presented ViewController.

present(UIViewController(), animated: true, completion: nil)

dismiss(animated: true, completion: nil)

There are various ways of exploiting native functions for navigation and those methods are thoroughly covered in blogs and StackOverflow.

Transitioning delegation

https://developer.apple.com/documentation/uikit/uiviewcontrollertransitioningdelegate

Apple provided a way to enable custom animation creation by adding a transitioning delegate to appropriate ViewControllers. That is our first way of creating a custom high-end transitioning behavior between screens. There are two protocols that are available: UIViewControllerAnimatedTransitioning and UIViewControllerInteractiveTransitioning. Animated transitioning is used for basic operations like presenting and dismissing while interactive transitioning is used to implement the behavior of updating the animation while happening. Alongside implementing one of the transitioning delegates, a ViewController must also conform to UIViewControllerTransitioningDelegate. This ViewController, as shown in the code below sets the animated transitioning delegate to itself for the present and dismiss actions.

The next task is the conformation to the UIViewControllerAnimatedTransitioning delegate. This conformation determines the duration of the animation and sets the methods responsible for handling the presenting and dismissal animation. Methods are selected based on the transition context which holds the necessary data about the animation.

While instancing our presented view controller we have to set the modalPresentationStyle property to custom which denotes that we will have a custom handle for its presentation. Next to that, we have to set the transitioning delegate of a newly created ViewController to its presenting one. Of course, we have to note that we are using the animated presentation.

Now, we have all our transitioning delegates set and we are ready to start implementing our custom animation. As we see from the .gif with our finished animation at the top, we are using the same image on both the presenting and the presented ViewControllers — which is exactly the main piece in our animation puzzle.

The definition of our animatePresent function which handles this screen showing includes the transition context, the presented ViewController, and UI elements that are used in the animation. Here we have an imageView which we are transitioning to the presented screen, sizeView which helps us get the frame of the shown image, and dimmingView which produces a shadow on the parent screen.

To start with the animation, we should prepare our “canvas”. Generally, that means we have to use additional views that are exclusively used in the animation process. Canvas creation starts by defining the global transition containerView — the containerView of the transition context. This view will hold all of the necessary subviews used in the animation. We should be careful and hide our presented screen until it is time for it to become visible. That is being done by setting the alpha to 0 for its main view.

The next part is the creation of the views we will use in our animation. The animation will have an image transforming from its current location and size to the new one defined on the new screen. Additional attention should also be granted to animating the rest of the new screen. The rest also appears from the starting image enlarging and moving downwards as the animation progresses. In the code snippet above, we have an initialization of those elements with its frame set to be the same as on the starting screen.

The final part of presenting the screen is the animation. Firstly, we are enlarging the image and relocating it simultaneously. That is being done by animating the imageView’s frame to the one on the new screen. Alongside the image, we are resizing the frame of the contentView to acquire the size of the newly made screen. After the size animation finishes, the key elements should be set in place and then we can animate showing the rest of the presenting screen.
Finally, we are removing temporary views from the container views, adding the dimming view to the presenting screen, and completing the transition. With that, our custom presenting animation is finished.

Next up, we have the dismissal of our presented screen. The very noticeable thing is that our screen moves with our behavior before its being dismissed. That’s gesture handling which will be explained later on. The current focus is the dismissal animation.

The dismissal animation implementation has a similar logic. As with the presenting, dismissal also requires the same definition with UI elements that participate in the animation. In this instance, we are initializing a new imageView element which will transition an image from the presenting screen to its parent. We are taking the current frame of the imageView and converting the frame to the sizeView in the parent screen so we “return” the image in its place. With the image been set in its place, the next thing to do is remove the mocked imageView from our views and complete the transition in the transition context.

Gesture handling

https://developer.apple.com/documentation/uikit/uigesturerecognizer

Gesture recognizers are the object used to capture and handle the user’s input in the applications. Apple’s gesture support includes taps, swipes, pinches, and others.

For our purpose, we will use PanGestureRecognizer which is used to capture and handle the dragging of the user’s finger over the screen.

The initial important thing is view hierarchy. We should use an additional containerView on top of the ViewController’s default view to enable this kind of animation. This enables us to “move” the containerView around the screen with its content on it and maintain the view of the top ViewController intact.

The handle of our movement starts with adding our pan gesture to the containerView and initializing a function that will run after a gesture trigger. As it could be seen from the snippet, two variables are prepared — view which is being dragged by the pan gesture and general translation in the superView. The rest of the handle consists of two parts: the change handle and the ending handle.

Change handle begins with determining the starting point of the translation. This case right here enables the gesture only to be handled when the drag is going to the right. According to that, we are saving the initial and every other subsequent transition so we can precisely determine the data about our next transition. The most crucial part of the gesture animation is the next part — to determine the translation of the containerView and to scale it. The translation is done by setting its center with the desired offset. In the snippet, it is done by offsetting the center by translation value multiplied by a constant of 0.35. To determine a wanted scale, we conducted a small algorithm that calculates the scale and then is applied using the CGAffineTransform. With those methods we get the screen moving and resizing smoothly.

This snippet contains an ending phase of our gesture. This chunk of code fires when the pan gesture ends — that can happen when the user reaches the edge of the phone or he lifts his finger from the screen. Based on the velocity of the user’s finger, the algorithm determines whether the screen should dismiss or return to its initial state.

Room for upgrades

Just as any other software development element we can also enhance the behavior of explained techniques. The upgrades might consist of remodeling the animations — using more views or more complex animation patterns. Space for imagination is unlimited so any element transition with explained patterns is possible. It is worth mentioning that one can also try implementing interactive transitions — usually used in push/pop transitions.

Those interactive transitions as their name suggests are consumed while the user is interacting with the application. That means that screens are showing or hiding parts of their content while the user is deciding his next action with his gesture.

Last call

Combining mentioned techniques makes transforms a basic screen transition into a high-class one. These techniques are used by top-notch applications with unlimited budgets. Both the discovery and the implementation of those transitions are rather costly and complicated actions. They are, however mandatory for a supreme iOS developer if he wants to compete with the big-game players. Complex and costly actions are usually the elements that make the difference in the end considering the application’s overall performance and user experience.

Dino is a valuable member of our iOS team.
At Azikus, we design and develop top-notch mobile and web apps.
We are a bunch of experienced developers and designers who like to share knowledge, always staying up to date with the latest and newest technologies.
To find out more about what we do, feel free to check our website.

High-end transitioning in iOS was originally published in Azikus on Medium, where people are continuing the conversation by highlighting and responding to this story.

The State of the Art of iOS DevOps

One of the main aspects of software development is software quality. Products with high quality tend to go closer to the top in different statistics charts, especially financially oriented ones. Thanks to DevOps, applying the best software development practices and techniques has never been easier.

The definition of DevOps (Development and Operations) has never been clearly defined. Its meaning combines multiple aspects of each software product life-cycle. The main goal which every DevOps engineer tends to achieve is to ensure continuous and fast product delivery with the highest possible quality.

Nowadays, mobile development companies and clients are focused on fast product delivery where quality is often neglected. DevOps is a good solution for those fast, agile product developments since it unites the need for speed and final product quality.

Things covered by DevOps usually involve:

• Project startup — Xcode, package management
• Code management — keeping your code clean and well-formatted
• Automated testing
• iOS code signing
• Deployment — App Store Connect, CI

The new beginnings

“The early bird catches the worm”

Every high-quality project starts with a high-quality start. It is important to invest time into the initial setup to make the future development process easier. That means spending resources to choose an appropriate architecture, set up a project structure, and select required tools.

This results with less bugs, a high stability rate, easier development for the engineers, and overall fewer resources being unnecessarily spent.

Xcode

Every iOS project starts with Xcode, an IDE developed by Apple, containing all the required toolset to create apps for Mac, iPhone, iPad, Apple Watch, and Apple TV. This is the ultimate root of creating a high-quality app. With the initial app setup in Xcode, you can save yourself a lot of time in future app deployments.

Targets

Xcode setup begins with managing your project targets. Each target represents a product to build. That being said, there are multiple ways you can distinct your targets. The most obvious one is the distinction between app types based on the device — the target can represent an iOS app, watchOS app, or OS X app. Another important distinction is another one widely used — test/production distinction.

A target is defined by its own bundle identifier, which is used as an identification to the operating system and App Store. It is also commonly used as an asset to connect with different services, like Facebook, Google, Firebase, etc. With different targets you can adjust their settings and with their references you can produce code run only by the desired target. This way, you can separate your test/production API calls, adjust UI and do whatever is needed in each environment. Often, this target distinction is usedAlso, targets are a great way to manage whitelabel apps with said possibilities.

Xcode configuration

An elegant alternative to the multiple target creation is managing your build configuration settings with xcode configuration file (.xcconfig). Xcode offers “Debug” and “Release” configurations by default when we create a new project. You can additionally add your own personalized configurations which are further configurable via .xcconfig files.

Xcode configuration file (.xcconfig) is a simple key-value based file where you store your build settings. For each configuration you create you can set a belonging configuration file which then dictates build behaviour.

More on this: https://www.appcoda.com/xcconfig-guide/

Schemes, build phases, build settings

Schemes are used to build and run apps from Xcode. They are usually closely connected to targets — each target has its own running scheme. However, you can create additional schemes for additional purposes, like running different scripts before building the same codebase or running with memory management diagnostics. Scripts are managed in the build phases section of Xcode project settings. For each different script you have to add the new phase to the build. These sections also manage compile sources and bundle sources for each target. Finally, duty of build settings sections is to handle different types of application settings, like supported architectures, code signing, etc.

Package managers

CocoaPods

GitHub - CocoaPods/CocoaPods: The Cocoa Dependency Manager.

http://cocoapods.org

CocoaPods is a tool which manages dependencies for Xcode projects. The secret lies in its simplicity, where all your dependencies are specified in a simple text file called Podfile. CocoaPods simplifies the usage both for library authors as for library users. It is personally my favorite tool to use. It is easy to install via sudo or command line and it’s also really intuitive to use. You just have to add the library you desire to install into Podfile, optionally you can add the version of the library and that’s it. Eventual updates are managed quite easily with pod install or pod update commands. The downsides of CocodaPods are increasing the value of build time and hard process of making the code work if something goes wrong with the imported library. Also, since CocoaPods are implemented in Ruby, an additional language knowledge is mandatory to introduce new libraries.

Carthage

https://github.com/Carthage/Carthage

Just as CocoaPods, Carthage is also a tool to simplify dependency management for an iOS application. Dependencies are also stored in a special file which is then used for framework installations and updates. Carthage is also written in Swift which means that iOS developers can be easily familiar with the Carthage implementation and further development. One of the best benefits that Carthage offers is it being flexible and it is easy to integrate it in big and ongoing projects, as opposed to Cocoapods. It can also be easily integrated into a CI server. However, Carthage currently supports only dynamic frameworks without any support for static libraries. And since Carthage is a relatively new tool, some important libraries may not be available.

Generally, both Carthage and CocoaPods are more than advisable to use in your projects. On one hand, Carthage is preferable because of its Swift origin and it excels with bigger projects, since only one build is required for libraries to be integrated. CocoaPods on the other hand increases overall build time since the tools has to build pods on every clean build. But it excels in its simplicity and wide-range of supported libraries. Technically, you can use both tools in your project and divide the work based on their adaptability to the problem.

Swift package manager

Swift package manager is a tool integrated with the Swift build system, used for managing distribution of Swift code. Swift organizes its code into modules, which are then reusable for any other wanted purpose. Dependencies are also represented by modules, with their known source and requirements for the package version. Package manager recursivelly runs the automated process of downloading and building all of the project dependencies.

Code clean as a whistle

“It is not enough for code to work.” ― Robert C. Martin

In my engineering career, I don’t think i have heard a syntagm being said more than “clean code”. The importance of clean code is probably known to any decent mobile developer. It is a must have for a quick and successful product development. Clean code is primarily important to enable future product improvements and deployments. DRY (Don’t repeat yourself), KISS (Keep it simple stupid) and YAGNI (You ain’t gonna need it) are just some of the numerous clean code principles which are hardcoded in the successful developer’s minds.

There are a few tools to assist with the clean code management in the iOS world, besides handling indentations with Ctrl+I.

SwiftLint

https://github.com/realm/SwiftLint

SwiftLint is a rule-based tool for Swift code management. It is easy to install and easy to maintain. After an easy integration with the project and Xcode, developer has to choose the set of rules to help him format the code. There are over 100 available rules, thanks to SwiftLint community. Everyone can participate in the future development with their own pull requests on the SwiftLint’s github. Rules can be optional — warning will pop up in the Xcode editor, or they can be mandatory — Xcode would throw an error. Additionally, you can create your custom rules. Also, there is an option to “break” the rule in the editor if that’s really necessary.

All in all, SwiftLint is an all-around tool considering code cleanliness and trivial to use.

SwiftFormat

GitHub - nicklockwood/SwiftFormat: A command-line tool and Xcode Extension for formatting Swift code

Just as the name suggests, SwiftFormat is a tool to format Swift code. SwiftFormat thanks its success to its versatility — it is used in 4 different ways: As a manually ran command tool, as a source editor extension, as a build phase in Xcode project and as a Git pre-commit hook. Next to standard formatting, SwiftFormat handles additional Swift clean code problems, like implicit self, redundant parentheses and other code deviations. It also enables a developer to customize a set of rules and option used to format the final code product. A difference to SwiftLint is that a SwiftFormat fixes the deviant code, rather than telling you to do so.

Testing, attention please

“One test a day keeps the doctor away”

As you already know, tests are the only sufficient way of making sure your code works as it is imagined. For sure, you have crossed paths with some edge cases ending up on your beta test. Testing is a reliable way to detect your logic failures, double-check your UI and acquire performance data.

Xcode offers testing tools within its XCTest framework. Probably the most important and time investing part of testing is Unit testing. Each unit test should assert the expected behaviour of a method or a function in your code. Ideally, one test is required for every scenario a method or a function offers. One should especially identify and cover all the edge cases with the highest quality test writing. Similar type of tests are Integration tests. Instead of covering a small logic part, integration tests cover the behavior of larger systems of functions. These tests are used to make sure that the components/modules work together. Other than Unit and Integration testing, XCTest is able to produce UI testing. UI testing compares recorded state of the UI with the state produced by a more recent build. That means that there are two modes to pay attention to — recording mode and testing mode. Finally, there are Performance tests where user can measure performance information, like time taken or memory used.

Testing in Xcode is done by importing XCTest and subclassing XCTestCase. When you add a new testing class, Xcode kindly offers you a template to fill your testing needs.

More on native Apple testing on: https://developer.apple.com/documentation/xcode/testing_your_apps_in_xcode

Testing coverage

Code/Test coverage is a measure that quantifies the amount of code covered by existing tests. It is a measure that allows the identification of chunks of codes that are left untested. It, however, does not include the test quality.

You can enable code coverage in Xcode by going into test options and marking the Code coverage checkbox. Coverage report is then generated for every subsequent testing session in the Report navigator. Newly retrieved coverage data can then be shown inline by checking on the Code coverage option in the Adjust Editor Option button.

Codebeat

https://codebeat.co

Code review is an important part of any product development since it combines more viewpoints on the same codebase with an extra pair of eyes to capture mistakes. Codebeat is a tool that automates the process of code review. There is a certain amount of things we always check when reviewing code, like coding style, coding practices or outdated APIs.

Codebeat offers an automated code analysis when ran. It marks occurrences of well known code imperfections, for example code duplication. Similar to SwiftLint, Codebeat also supports customizable rules where you adjust your code review to your personal liking. That being said, during the process of code review, you can pay attention to things that lint or code format ignored. That includes cyclomatic complexity, block nesting or other generic limitations you require.

Signature here, here and here please

“Finish strong.”

After your code is clean, your bugs are resolved, features working, tests are successful and the QA has given you a green light, it is time to deploy your application.

iOS code signing

One of the things Apple requires from you is code signing. Code signing is Apple’s way to make sure applications are signed by trusted developers with valid certificates. Various security elements are involved in the process and the final outcome is making sure that the code wasn’t changed or corrupted after it had been signed.

To start with the code signing process, you will need a certificate signing request, created from your own Keychain Access. This is used to confirm developer’s identity in the process.

There are two types of certificates you need to worry about. Development certificates are used for internal deployment. They are necessary for testing your application on internal devices. On the other hand, when you’re ready to publish your app, you will need a distribution certificate which is necessary to run your app on any device.

More on certificates on: https://developer.apple.com/support/certificates/

Along with certificates, you need to take care about provisioning profiles. Just like the case is with certificates, you have both development and distribution provisioning profiles. Once again, development profiles are used for internal app testing, while distribution profile is needed to publish your app on the AppStore. Provisioning profiles are a combination of the app data, like app ID and the belonging certificates.

More on provisioning profiles: https://developer.apple.com/documentation/appstoreconnectapi/profiles

After you’ve acquired all needed certificates and provisioning profiles, you need to import them into the Xcode. You can then select whether you want Xcode to automatically manage your code signing, where you just have to select your team, or you want to manually upload the provisioning profiles.

A great read which explains code signing in detail: https://blog.codemagic.io/how-to-code-sign-publish-ios-apps/

Deployment

“It is time to meet the world”

App Store Connect

App Store Connect is an Apple’s service to upload, submit and manage your applications. It is necessary to create a new application for every build you want to test (if you are testing through Apple services) or deploy. For example, if you want to deploy the build of every of your project’s targets, you’ll have to create an application for every target with its own bundle ID.

After creating your App Store Connect, it is time to return to Xcode. There, you can upload your app via “Archive” option. Xcode then automatically checks all your signatures, profiles, app versioning and other important settings. After the checks have passed and upload finished, you will have a build uploaded to the App Store Connect.

Apple offers TestFlight as a solution to internally test your apps on real devices. You just have to send invites to testers and they will be able to test every uploaded build. They will be able to send you feedback with screenshots and the service will register crashes. Additionally, TestFlight offers Beta testing, with external groups option.

App Store Connect also offers enabling in-app purchases and subscription methods. It also covers app privacy settings, ratings and reviews.

Finally, your application has to pass a review. You have to provide crucial information about your application — Final name, app screenshots, review information, etc. Apple personnel will carefully go through your app and inform you about eventual tweaks you have to make to publish the app. If everything goes smoothly, you’ll get a green light and showcase your app to the world (Or part of it, depending on your settings).

More on App Store Connect: https://developer.apple.com/app-store-connect/

Continuos integration (CI)

Continuous integration is an automated process of testing and deploying new builds of an application. It is an elegant way to reliably test new code updates and deploy builds once the application is ready to update. A good CI tool will help you save time on the monotonous repeating actions of producing application versions.

Using native Apple developer tools for CI has always been a secure way to handle the deployment process. They can’t be manipulated by third-party frameworks and they are well documented by Apple. Some of the major tools include xcodebuild, altool, agvtool, codesign and security. You can already realize that these tools are used via command line, so you will have to spend some time to understand what each of these tool’s possibilities are. All of the tools produced by companies are using the native Apple developer tools for testing and deployment under the hood.

Fastlane

fastlane - App automation done right

https://github.com/fastlane/fastlane

Fastlane is one of the most popular choices for a CI. It is an open-source platform based on Ruby, and its functionality is defined in a configuration file called Fastfile. Fastfile is structured from lanes where each lane represents one process which is being automated. Those lanes help the developer to run desired commands in order every time a new build is introduced. Fastlane offers over 170 actions which are available for Android, iOS and Mac platforms.

Bitrise

Bitrise - Mobile Continuous Integration and Delivery

Next to Fastlane and native development tools, there are a lot of cloud-based paying options which handle your integration process. There are Nevercode, CircleCI, there used to be BuddyBuild and there is Bitrise. Bitrise is really hot right now, and one of the most favorite developer selections for CI. Bitrise supports a wide range of technologies, from iOS and Android to React Native or Flutter. It also includes a large number of services available to automatically connect your application with (Firebase, Slack, Github, …). Bitrise is very well documented so its usage is quite easy to handle.

Long story short

All these tools and techniques mentioned are just a fraction in the overall DevOps possibilities. There are a countless possible ways to combine stages of the development and deployment process and it all unites under the DevOps term.

It is definitely smart to invest into DevOps which is supported by a recent surge in DevOps engineer position openings on the market. For a big company with complex products, DevOps engineer is a must have to handle and simplify the overall production process.

Dino is a valuable member of our iOS team.
At Azikus, we design and develop top notch mobile and web apps.
We are a bunch of experienced developers and designers who like to share knowledge, always staying up to date with latest and newest technologies.
To find out more about what we do, feel free to check our website.

AZIKUS - full service digital agency

DevOps in iOS was originally published in Azikus on Medium, where people are continuing the conversation by highlighting and responding to this story.