Mobile Couch

A new version of iOS means new features, and this year brings a handful of big ones, slide over, split view, picture in picture and 3D Touch. Ben and Jelly takes a good long look at each of these new features, talk about how to go about implementing them, and investigate some of the things you’ll need to remember to create the best experience possible.

• Slide Over and Split View Quick Start
• Strategies for Handling App State Transitions
• Picture in Picture Quick Start
• SBShortcutMenuSimulator
• Could this be the patent behind 3D Force Touch on the new iPhones? (9to5Mac)
• Getting Started with 3D Touch

We'd love it if you got in touch! We are @_mobilecouch on Twitter and you can even email us at [email protected], if you're so inclined!

For the past few weeks, Jelly has been refactoring the core components of his app, so he feels like he needs to talk it out with Ben. The two look at their experiences with refactoring code and talk about the best ways to approach it, what it’s place is within your regular workflow, and most importantly, how to know when you’re finished. Along the way, they explore the basics of extreme programming, the problems with building up technical debt, and the longevity of Swift and Objective-C.

• Automatically resolving git merge conflicts in Xcode’s project.pbxproj file (Roadfire Software)
• Extreme Programming: A Gentle Introduction
• Let's Play 'Refactor the Mega-Controller' with Andy Matuschak (Realm)

We'd love it if you got in touch! We are @_mobilecouch on Twitter and you can even email us at [email protected], if you're so inclined!

Ben and Jelly cover some tips and tricks they use to get through their work day, from basics like keyboard shortcuts to bash scripts for automating build numbers.

• AppCode
• Android Studio
• Reveal
• Integrating Reveal: Load Reveal Without Changing Your Xcode Project
• UI Automation JavaScript Reference for iOS
• UI Screen Shooter on GitHub
• ImageOptim
• Fastlane
• agvtool (Mac OS X Developer Tools Manual)
• Destroy Xcode Tedium (Red Sweater Blog)
• Versioning with Xcode (JellyStyle)
• Update Version (GitHub Gist)

We'd love it if you got in touch! We are @_mobilecouch on Twitter and you can even email us at [email protected], if you're so inclined!

After dealing with some follow-up about privacy policies, as well as mentioning a couple more methods for handling blocks within blocks, Ben introduces Jelly to the basics of functional programming. Together they walk through their approaches to the handling of a parsed JSON structure, as Ben explains several functions, such as filter, map, reduce and flatMap, as well as the underlying approach and how it can benefit your code.

• App Store Review Guidelines
• Sequencer on GitHub (Objective C)
• Sequencer on GitHub (Swift)
• Advanced NSOperations (WWDC 2015)
• Example JSON
• Swift Classes vs Structs
• Building Better Apps with Value Types in Swift
• Somewhere Between Tomorrowland and Frontierland - Daniel Steinberg
• NSCamp 2015

We'd love it if you got in touch! We are @_mobilecouch on Twitter and you can even email us at [email protected], if you're so inclined!

Jelly has been implementing some more analytics in GIFwrapped over the last few weeks, so he and Ben take a look at the various aspects of tracking your user’s behaviours.

Tracking your users has obvious privacy implications, and it’s not just Apple enforcing them. Australia’s privacy laws require that you don’t capture information that could reasonably identify someone.

With that in mind, analytics are extremely useful for learning how people use your app, and using this knowledge to try and improve it. Jelly explains a little about what he’s been starting to track and why he thinks it’s useful.

With the why and what out of the way, they begin talking about the how: discussing a handful of analytics services, including Apple’s Testflight, Answers, Google Analytics and Snowplow. The two examine the pros and cons of each service, discussing the core features and their experiences with each.

• Fabric
• Answers Documentation
• Google Analytics
• Analytics for iOS Dev Guides
• Snowplow

We'd love it if you got in touch! We are @_mobilecouch on Twitter and you can even email us at [email protected], if you're so inclined!

Jelly and Ben start the show by covering some quick follow-up about CocoaPods and Carthage, which blurs the lines between their differences. This leads into a quick discussion about how CocoaPods is now being supported by a bunch of companies with libraries, such as Google, Twitter and Hockey.

Ben then puts forward the problem of “blockception”, the effect that blocks within blocks have of excessively indenting your code, making it more difficult to read and harder to maintain. There are some native ways of dealing with the issue, but they’re still not ideal, so he has taken a look at some ways of solving the issue.

The first of these is PromiseKit, a third-party library that wraps asynchronous calls in Cocoa with versions that use promises. This allows you to keep all your blocks at the same level of scope, which has the additional benefit of ensuring that each block only captures the variables that they actually need, making memory management a little easier.

Another is ReactiveCocoa, a well-known implementation of reactive programming for Cocoa. This follows a very similar approach to PromiseKit (except with “streams” instead of “promises”), but is a much larger implementation, as it covers more than just the idea of multiple asynchronous calls.

Finally, there’s Rx, which is a C# library from Microsoft, but it’s also been brought to Java, Swift and Android. It’s a lighter weight implementation of reactive programming, and also has the benefit of being cross-platform, which means you can keep your approach conceptually similar between the different platforms you support.

• Using Submodules for Dependencies with Carthage
• Google on CocoaPods
• Manage Fabric with CocoaPods
• CocoaPods CLI Update Command Documentation
• PromiseKit
• Managing Nested Asynchronous Callbacks in Objective C using Reactive Cocoa (Tech in SF and Oakland)
• Episode 38 with Basil Shkara
• Episode 30 with Ash Furrow
• Functional Reactive Programming on iOS
• ReactiveX (Rx)

We'd love it if you got in touch! We are @_mobilecouch on Twitter and you can even email us at [email protected], if you're so inclined!

After touching on some Core Data follow-up, Jake proposes that the couch talk about Frameworks. Apple’s Cocoa includes a lot of things, and arguably more than most other first-party SDK, but there’s alway a need for additional frameworks to solve common issues.

He starts by laying out a few different pieces of the framework puzzle, from how to discover them, how to actually get the code, and how to implement it in your own projects.

One solution for managing these third-party dependencies is to use Git’s submodules. Jelly mentions that this is how he manages and maintains the external libraries he maintains alongside his code.

Another is Cocoapods, which solves all three aspects of finding and using libraries, including finding of projects, and the actual integration with your Xcode project.

Finally, the cool kid on the block right now is Carthage, which only deals with the building and preparation of the dependency tree, whereas discovery and the actual integration is dealt with by the developer.

• Haneke
• Cocoa Controls
• CocoaPods
• Carthage
• A quick note on dependencies in Ruby on Rails projects (Manfred Stienstra)
• Frameworks Increase App Launch Time (Artsy on GitHub)

We'd love it if you got in touch! We are @_mobilecouch on Twitter and you can even email us at [email protected], if you're so inclined!

Following-up from the last episode, Jelly tries to recover from his failed attempts to explain why he believes that opening up Radar isn’t the solution to all of Apple’s issues with bug reporting.

This causes Jake to note that part of the problem with Radar is that Apple, as an organisation, seems to care a lot less than Google about reported bugs in general. That’s not to say that the engineers themselves don’t care, which becomes obvious when you do hear from them directly, whether in labs at WWDC or through avenues outside Radar, such as Twitter or Apple’s developer forum.

Jelly’s about to release an new version of GIFwrapped, so he’s been thinking about things like deadlines and code freeze and how developers handle those things. So he asks Ben and Jake a few questions about how they approach an app release.

Jake feels like the best approach is to develop iteratively, and aim for regular, short release cycles (like Facebook’s two week cycle). Jelly takes issue with that, explaining that as a single developer, or even a small team, it’s very difficult to aim for that kind of model.

Ben then brings up automation, explaining that part of moving to a regular release cycle requires a change in thinking. Jake also explains that perhaps larger features need to be broken down into smaller pieces, making it easier to stick to regular release schedules.

• Apple Developer Forums
• App Store Information (Apple Developer Support)
• Average App Store Review Times
• Big Code: Developer Infrastructure at Facebook's Scale (YouTube)
• Duct-Taping The Gates Of Chaos Shut by Halle Winkler (Vimeo)

We'd love it if you got in touch! We are @_mobilecouch on Twitter and you can even email us at [email protected], if you're so inclined!

In the wake of WWDC, the couch discuss their favourite sessions and lab experiences, and some of the answers to the questions they had following the keynote.

Ben and Jake start by sharing some of their highlights from the labs at WWDC. They both explain some of the issues they took to the engineers, and the responses they got in talking them talking over.

This leads into a discussion about Radar, especially in contrast with Google’s more open bug reporting tool. Everyone agrees that there are giant holes in Apple’s tool, and Jelly’s actually convinced we might see something change next year.

Jake mentions at this point that he’s excited about the current focus from Apple on education, even in things as small as being able to run apps on device without having to be a paid developer. Jelly is quick to point out that there’s a lot of evidence that Apple has being thinking about education for at least a couple of years now.

From here, Jelly asks Ben and Jake to name their favourite sessions from the conference. Ben’s is the session on protocol-oriented programming, while Jelly really liked the session on the new system font, and the thought that has gone into typography on the platform. Jake, who also liked Ben’s pick, settles for one about new features in playgrounds.

Moving along, Jake talks a little about his experiences playing with CloudKit and CloudKit JS, coming to the conclusion that it’s still missing some crucial features, such as its lack of shared data and it’s lack of ability to run scheduled tasks.

Jelly then brings up Bitcode, which is something that Apple really hasn’t explained very much at all. Jelly cites an article he’s read which explains both what Bitcode is, and some of the reasons Apple might be interested in it. Ben’s not convinced that it’s going to work as expected, however, since it just seems too magical.

Finally, Jelly brings up to odd occurrence of a couple of presenters who made a big deal about using first-party frameworks, most notably Core Data. This leads to a conversation about Core Data vs. Realm and what they actually are and why you would choose something other than Core Data for data storage.

• Topical 13: I/O vs. WWDC
• Education (Apple Developer)
• Protocol-Oriented Programming in Swift (WWDC 2015 Videos)
• Building Better Apps with Value Types in Swift (WWDC 2015 Videos)
• Introducing the New System Fonts (WWDC 2015 Videos)
• Optical Sizing of Circles with Squares (Marc Edwards on Twitter)
• Authoring Rich Playgrounds (WWDC 2015 Videos)
• App Thinning in Xcode (WWDC 2015 Videos)
• Apple’s Bitcode Telegraphs Future CPU Plans (Medium)
• What's New in Core Data (WWDC 2015 Videos)
• Performance on iOS and watchOS (WWDC 2015 Videos)
• Realm

We'd love it if you got in touch! We are @_mobilecouch on Twitter and you can even email us at [email protected], if you're so inclined!

The WWDC 2015 keynote has come and gone, but Eddy Cue’s dance moves will forever haunt us. Jake and Ben call in from San Francisco to talk about developer-y things that got announced during the keynote and the Platforms State of the Union, while Jelly, who watched from his lounge room, fills in the gaps on some of the new APIs and kits.

Starting with the keynote, the couch quickly cover the general feeling of the presentation, the highlight of which was the inclusion of two female VPs presenting things on stage. Not to mention the brief inclusion of an app that Ben wrote in one of the videos shown as part of the presentation.

Moving into development stuff, Jelly breaks down the addition of Search APIs which use NSUserActivity, and content indexed from the internet, to create indexable content that appears in the home screen search. This builds on a new feature from last year, and along with “universal links”, allows for easier access to content within apps.

Another new feature is App Thinning, which is actually a handful of smaller features related to shrinking the size of your app’s install footprint. It includes things like splitting up assets that are specific to devices, separating out 32 and 64 bit code, and assets that are able to be downloaded as needed. This has some interesting and potentially crazy implications, and Ben and Jake aren’t sure that they’re that keen on the idea.

CloudKit is also getting a huge addition with the release of a Javascript API for building web-based apps that run on CloudKit. Ben’s not convinced that this is any better than the competitor platforms, and Jake is concerned about how serious Apple are about the web, but Jelly has taken the approach that this is perfect for newcomers, and that its architecture highlights Apple’s preference for native apps.

Everyone other than Jake has been expecting native apps for Apple Watch, which are also coming along with watchOS 2. This is a very simple change with a lot of implications, where the extension is simply moved to the watch itself. This leads the couch to question whether the watch was released too early.

The release also adds custom complications, which allow you to show simple, time-based information on the watch face. It comes with a new feature called “Time Travel” which allows you to see the information as it changes over time, allowing you to see weather in the future, or the stock price as it varies over the day.

Jake reveals that he’s using a new MacBook at this point, and his battery is running low. This prompts Jelly to quickly move on to new Xcode features, including the new Stack View, which lets you create simple, linearly-arranged sets of views, Storyboard references, which let you create properly modular Storyboard structures.

After Jake disappears, Ben and Jelly continue on to talk about the new testing features in Xcode. The first of which is UI testing, which appears to be based on UIAutomation. The second is code coverage, which Ben had feared would be too overwhelming, but appears to have been implemented in a very useful way that doesn’t appear unless you actually want it to.

And finally, they cover the highlights of the upcoming Swift 2.0, including the guard keyword, the try/catch error-handling system, the availability features, and finally the announcement that Swift 2.0 will be open-source. This causes them to reconsider Objective-C’s eventual demise, which seems more obvious now than it has been in the past.

• Topical 13: 1/O vs. WWDC
• WWDC 2015 Keynote
• WWDC 2015 Platforms State of the Union
• Quick Math's appearance in The App Effect (YouTube)
• Silver Screen Queen's appearance in the 2015 Google Design Showcase (YouTube)
• Silver Screen Queens
• WWDC 2015 Videos
• Apple Developer Resources

We'd love it if you got in touch! We are @_mobilecouch on Twitter and you can even email us at [email protected], if you're so inclined!