No architecture needs to have a massive view controller

So you’re sick of massive view controllers? Me too. Many architectures attempt to overcome this problem in a way that I view as extremely complex for the problem they’re trying to solve.

I favor simple architectures and simple solutions because they’re easy to understand, develop, and maintain. For this reason, I normally start my projects using the MVC architecture. I find for most projects it strikes a great balance between complexity and abstraction. It keeps things well-separated by giving the model, view, and controller layers their own concerns.

A lot of Developers, though, complain that MVC leads to Massive View…

From verbose to concise

Say you’re making a singleton or static class to represent data and/or logic that will never change. In many cases, you can convert this logic to an enum and save yourself a bunch of hassle. An enum has much of the functionality of a class, but doesn’t require an instance and doesn’t allow for stored properties — so doesn’t manage state. Instead of properties, you get cases. Instead of values, you get the RawValue. In this tutorial, you’ll refactor an existing static class into an enum.

What Is a Static Class?

A static class is a class that contains only class/static methods and properties. It’s…

The single responsibility principle in action

In this tutorial, we’ll implement MVC in a way that you may not be familiar with. We’ll create a reusable UICollectionView that’s implemented by its parent UIView and delegates item selection events to a UIViewController. This makes for a very small view controller when compared to the default way we tend to implement them. In addition, it gives you an entirely reusable view that you can invoke with just a single line of code.

This tutorial will cover separating concerns using MVC. If you don’t like MVC, don’t like the fact that I used a view model, or don’t like…

Is async/await ready for production?

A lot of us have been waiting a long time for async/await syntax in Swift. First proposed in 2017, this API sets out to clean up the pyramid of doom that happens so often with async code. In the WWDC State of the Union, we were introduced to some amazing-looking async code using this syntax. If you’re a professional iOS Developer or learning to become one, you may be wondering if it’s ready for production.

̶I̶M̶H̶O̶ ̶t̶h̶e̶r̶e̶ ̶a̶r̶e̶ ̶s̶o̶m̶e̶ ̶t̶h̶i̶n̶g̶s̶ ̶t̶h̶a̶t̶ ̶n̶e̶e̶d̶ ̶t̶o̶ ̶c̶h̶a̶n̶g̶e̶ ̶b̶e̶f̶o̶r̶e̶ ̶a̶d̶o̶p̶t̶i̶n̶g̶ ̶t̶h̶e̶ ̶f̶r̶a̶m̶e̶w̶o̶r̶k̶,̶ ̶b̶u̶t̶ ̶u̶l̶t̶i̶m̶a̶t̶e̶l̶y̶,̶ ̶t̶h̶a̶t̶’̶s̶ ̶a̶ ̶d̶e̶c̶i̶s̶i̶o̶n̶ ̶y̶o̶u̶ ̶a̶n̶d̶ ̶y̶o̶u̶r̶ ̶t̶e̶a̶m̶ ̶n̶e̶e̶d̶ ̶t̶o̶ ̶m̶a̶k̶e̶…

Take your development to the next level, eliminate your assumptions with Unit Tests

If you’re anything like me, you make a lot of assumptions when you develop software. Also, if you’re anything like me, you probably didn’t realize it until recently, or maybe you still don’t realize it. Trust me when I say, “assuming you aren’t making assumptions is the worst assumption you can make.”

In this article, I’ll introduce you to Test Driven Development by implementing a very simple method and test case. Let’s say we’re developing an e-commerce app and we need to devise a way to add money to the cart. Following the single responsibility principle, this method will only…

Increase performance by avoiding retain-cycles

In Swift, memory is handled for us pretty efficiently via ARC. Basically, reference objects (such as classes) hold a count for how many times they’re being referenced. When the count reaches 0, the item is marked for deallocation and removed from memory when the system needs the space.

If we aren’t careful though, we can encounter situations where the memory space never gets marked for deallocation because we’ve created a retain cycle. Unfortunately for us, these can be pretty tricky to track down.

In this tutorial, you’ll implement a unit test that can test any object to see if it’s…

A good API doesn’t break easily

Often when developing codebases, you probably want to model a situation with one of 2 possible outcomes. In Swift, this often means using optionals as the return type for a method. The idea is one of them will be nil, and the other will be non-nil.

What you may have done in this situation is create a method that returns a tuple with 2 optional parameters. The one that isn’t nil is the one that passed the test. This solves the problem of wanting to know which contains a value. Unfortunately for you, this creates a new problem.

The factory pattern keeps your code clean. Enums keep data flexible

Encapsulate your static initialization data — keep your call sites and objects clean

One Type, Different Property Values

Often times when creating a custom type, you’ll want to create many instances of that type with different initialization values. For example, if you’re modeling a Vehicle, you may want different vehicles with a different number of wheels, different colors, different body styles, etc…

To achieve this, we often make our initializers flexible by being able to pass in whatever value we want for each property we’re initializing. While there’s nothing wrong with this solution, it can lead to a lot of boilerplate code at call sites…