Cananito/KeepingPerformanceInMind.md

## KeepingPerformanceInMind.md

      
    Raw
  

              KeepingPerformanceInMind.md
            
          
    Keeping Performance in Mind

With Swift many people have been diving into the world of functional programming and value types. One of the many benefits of the former is the use of new abstractions in the way of functions: filter, map, and reduce.
I won’t talk about the pro’s and con’s of this approach, but for example, instead of writting custom loops:

If you want to convert an array of Ints to an array of Strings, you map: [1, 2, 3, 4].map({ String($0) }) // Produces ["1", "2", "3", "4"].
If you get the sum of all Ints of an array, you reduce: [1, 2, 3, 4].reduce(0, combine: { $0 + $1 }) // Produces 10.
If you want to know if an array doesn’t contain any object with a given flag, you filter and get the count. Or do you?

This last example came up in a recent project. With the excitement of this new paradigm I failed to see right away one issue: array.filter { $0.someFlag }.count isn’t a very performant thing to do.
The full condition looked something like this:
if (array.filter { $0.someFlag }.count == 0) {
	// Doesn’t contain what we want. Unlikely scenario.
} else {
	// Contains at least one of the things we want.
}
This internally creates a new array and loops through all of its contents. Our nice and convenient abstraction is potentially costly.
Before writting down the simple solution, I should explain that I tend to favor efficient code over easy-to-write-or-read code. I never do premature optimizations, but performance is always in the back of my head.
In fact, because the contents of the array aren’t that big, you could hardly tell that it wasn’t as fast as it should be. But why let this go when the change is simple enough?
The first thing that came to mind was: “I’ll go ahead and write a good ol’ for loop”. But wait! We don’t need to go back all the way. We don’t get to keep the established functional abstractions, but at least let’s do it functionally and efficient!
The function itself:
extension Array {
	func containsCondition(condition: T -> Bool) -> Bool {
		for element in self {
			if condition(element) {
				return true
			}
		}
		return false
	}
}
And now our if statement turns into:
if (array.containsCondition { $0.someFlag } == false) {
	// Doesn’t contain what we want. Unlikely scenario.
} else {
	// Contains at least one of the things we want.
}
Ignoring the naming of the function, we improved things a bit, while keeping the functional approach. A new array is no longer allocated, and we only loop until we find a given condition.
Using XCTestCase’s measureBlock, we can get an idea of the time it takes to run the code in each case:
class Object {
    let someFlag: Bool
    init(someFlag: Bool) {
        self.someFlag = someFlag
    }
}

class FunctionalPerformanceTests: XCTestCase {
    var array = Array<Object>()
    
    override func setUp() {
        super.setUp()
        
        // Populating the array with a similar ratio seen in the mentioned project.
        for (var i = 0; i < 200; i++) {
            self.array.append(Object(someFlag: false))
        }
        for (var i = 0; i < 2000; i++) {
            self.array.append(Object(someFlag: true))
        }
    }
    
    func testFilterCountPerformance() {
        self.measureBlock() {
            let condition = self.array.filter { $0.someFlag }.count == 0
        }
    }
    
    func testContainsConditionPerformance() {
        self.measureBlock() {
            let condition = self.array.containsCondition { $0.someFlag }
        }
    }
}
Your milage may vary, but the first approach took 0.016 seconds to run, while the second one took just 0.001 seconds (on a 2.8 GHz Intel Core i7, with 16 GB 1600 MHz DDR3 RAM). Pretty much what we were expecting.
In hindsight and like I mentioned before, the improvements are barely noticiable. You could only tell if the array consisted of thousands and thousands of elements. Or if accessing the object's flag was an expensive operation. Or if we had to do this repeatedly. But I still stand by the change.
Update (08/06/2015): At some point the contains function was added to the Swift standard library. So the way to do this now is:
if (array.contains { $0.someFlag } == false) {
	// Doesn’t contain what we want. Unlikely scenario.
} else {
	// Contains at least one of the things we want.
}