Mobile Couch

It’s the final episode of Mobile Couch, so Jake MacMullin returns to the couch, and they discuss how they got started as developers, as well as how they feel about starting new projects.

Ben takes Jelly on a journey through his favourite points from the book Pragmatic Programming: From Journeyman to Master, which details points that you’ll want to learn if you want to be a better developer. Along the way they discuss everything from philosophy to buying dishwashers, and maybe even a little actual code here and there.

Jelly recounts his experience with interviewing for a developer position within a big tech company. He and Ben reveal a little insight into what the process is like, what you should know going in, and what you can take from the process to apply to the interviews at your own company.

Ben and Jelly run through a quick and dirty primary of Git, one of the most popular version control systems around today. Starting from the very basics, they run through all the things you need to know to use it in your day to day work, why you should be using some method of version control, and the clients they use to make things nice and easy to manage.

Once again, the Apple developer community has been host to scandal! Not a pair to leave this opportunity behind, Ben and Jelly discuss how developers can learn from this, looking at the mistakes that were made, how to avoid them, and what you need to remember when things go bad.

With Ben in London, Casey Liss rejoins Jelly on the couch to talk about leaving .Net behind for a career in the Apple ecosystem, his experience with RxSwift, and wrapping your brain around new things. Meanwhile, Jelly reflects on his recent GIFwrapepd update and his approach when migrating it from Objective-C to Swift.

How do you lay out your views? Ben and Jelly look over the different methods available on both iOS and Android, and compare their experiences with each. Together they uncover some of the oddities that can pop up in various circumstances, how to get around them, and which approach rules them all.

User notifications have had a big makeover in iOS 10, so Ben and Jelly walk through how notifications work on iOS. Along the way, they highlight some of the newer features available in the new framework, look at when you might choose local notifications over remote notifications, and discuss the two new extension points to use for customising notifications.

If you’re lucky, you’ll never need to work on an app that has to manage files, but just in case you ever do, Jelly’s got you covered with a basic overview of file management on iOS. He walks Ben through the basics, covering coordination of access to files between processes, reading parts of files, and displaying a localised version of a file path.

Dependency injection is a simple programming technique with a bit of a scary name, but it turns out that it’s excellent for highlighting the connections between classes within an app. Ben walks Jelly through the basics of using dependency injection, why singletons are bad, and places you might already be using this techique without even knowing it.

Jelly’s had a bit of a computer disaster (which he totally got from Ben), so they talk a little bit about mitigating disasters as both users and developers. Then they cover off a little bit of follow-up about monetising Messages apps, before discussing the fun and horrors of migrating your codebase to iOS 10.

Since the announcement in the WWDC keynote, Ben has been working on a couple of Messages apps, so he and Jelly go through all the ins and outs. Together they look at the super-easy Sticker pack apps, the more complex implementation details for custom apps, and even a few gotchas you might run into while developing.

With WWDC done and dusted for another year, Ben and Jelly discuss their experiences queueing for the keynote, attending side conferences, and getting the most out of the week. They then turn their attention to an quick overview some of the key things that Apple introduced for developers with iOS 10, including Siri and Messages Apps, and finally they pine for the thing they still wish they’d seen: improvements to Radar.

In the lead up to WWDC, Ben and Jelly take an early look at some of the changes coming to the Swift language this year with version 3, which like one of the biggest releases so far. With widespread changes in the wording of method names, improvements to how C APIs are handled, and a Swift version of Foundation, it’s going to be a big change to both your code, and how you read it.

Ben and Jelly turn their minds to this year’s WWDC, and spend some time talking about what they expect to come out of this year’s conference, as well as what they’re actually hoping for (there’s a difference!), including better stability in tooling and more transparency with errors.

What is good code, and how does one achieve it? Ben and Jelly spend some time working through a small project while considering the flaws, edge cases and potential shortcuts, in an effort to come up with ways to weed out bad code, while also improving the end result.

Both Ben and Jelly have worked from home for many years, so they explore the benefits and disadvantages of remote working. Together, they discuss the things you need to do to ensure stuff actually gets done, what your team can do to help you succeed, and why you’d even consider this in the first place.

Jelly walks Ben through the ins and outs of implementing In-App Purchases in your “freemium” or “paymium” apps. IAPs are deceptively annoying to get right, but Jelly covers everything, including you need to do in iTunes Connect, how the StoreKit framework works, and finally, how you validate the receipt to prevent piracy.

Many developers work with things like views and view controllers, but might not have any idea about how these things all fit together. Ben introduces Jelly to the Model-View-Controller pattern, and explains what each part of this concept is and how they come together to make an app work.

In any given project, you’ll find that there are a number of different “hats” that you have to wear, such as making the hard decisions, being a user, writing code, or designing assets. Ben and Jelly take look at some of them, discussing not only how they come into play, but also how some of the common misconceptions about them.

Giovanni Lodi (@mokagio) joins the couch to teach Ben and Jelly about the automation of tasks, and especially about the automation of the build and deploy process for iOS apps. Together, they look at the various Fastlane tools and what they each do, why you would automate these parts of your process, and how to recognise when something should be automated.

Jelly’s been using JetBrain’s AppCode to get some work done in the last few weeks, and he and Ben go over the overall experience. Together, they discuss some of AppCode’s best features: inspections, the incredible level of customisation it provides, and best of all, Swift refactoring. It wasn’t all happy though, and Jelly also spends some time unloading on Ben about the issues he faced, how he dealt with it, and what JetBrain’s support is like.

This past week, Ben attended the Apple TV Tech Talks in Sydney. Meanwhile, Jelly didn’t get the opportunity, so Ben covers of a lot of the major points he learned on the day, covering concepts like the “Focus Engine”, and discussing talks like the one given by the App Store Review team (a.k.a. the best talk ever). It turns out there’s a whole lot of stuff that can be easily missed when creating apps for tvOS, and if you missed the tech talks, you’ll want to listen to the end!

Ben’s been working on a side-project over his break, and wants to actually flesh it out into something complete and polished. There are a few things he’s not sure about, however, so he gets Jelly’s advice. Should you consider the monetisation of an app for version 1.0? How finished does an app need to be to be placed in the hands of testers? How do you get past the ever-growing list of bugs and get to the point where you can release?

Russell Ivanovic jumps on the couch to chat about what makes code good or bad, and how the perception of code changes over the years. They look at how they’ve learned to approach both their own and other people’s code, helping others learn and grow their skills, and most importantly, whether code style is important or not.

Ben and Jelly take a look back at the things they’ve learned over the past year with their approach to work as well as with the technical side of development. They reflect on what’s changed for them, and look forward to next year to consider things they’d like to approach and try in the future.

Christmas came early this year as Apple followed through on their promise to open-source the Swift language. Ben and Jelly take a look at all the things that have been included in this somewhat unprecedented release (it may even blow your mind) and look at what this might mean for the future, both for the platforms Swift now extends to, and for its predecessor, Objective-C.

After talking about dealing with — supporting — clients, Jelly thinks it’s worth touching on supporting the users of your app. He and Ben talk about his experiences with GIFwrapped and get into why it’s important to be positive, how to improve your app to get in front of support requests, and why support can be part of your marketing strategy.

If you deal with clients, you’ll discover that there’s a lot of ins and outs to working with them on a project. Ben and Jelly talk about how they deal with clients, from the refining the app idea, through scoping and quoting, to communication and running the project. Along the way, they cover finding the email sweet spot, dealing with clients who want everything, and coming up with your hourly or daily rate.

In response to a topic suggestion, Jelly draws on his recent experiences with GIFwrapped to discuss ways to ensure an app’s architecture is loosely-coupled, thereby making it easier to extend and maintain it’s functionality. He and Ben go into several important techniques that they use in the apps they write, and back each up with examples to show the benefits of approaching your code in these ways.

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.

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. Keyboard Shortcuts: Command + Shift + J: Highlight current file in Project Navigator Command + Shift + /: Menu Search

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. Xcode Open Quickly: Command + Shift + O Fold/unfold Everything: Command + Option + Shift + Left/Right Search for Method: Control + 6 Open Quickly in Assistant: Option + Enter (from Open Quickly) Close Assistant: Command + Enter Close Left Sidebar: Command + 0 Close Right Sidebar: Command + Option + 0 Edit in Scope: Control + Command + E Show Variable Type (Swift): Option + Click AppCode/Android Studio Search for Action: Command + Shift + A

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.

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.

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.

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.

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.

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.

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.

With Ben off attending Google I/O, Jake and Jelly talk art exhibitions, storyboards, Jelly’s struggle with sync, and prepping for WWDC. Jake kicks things off by talking a little about features he’s recently discovered in Storyboards, such as the ability to mark constraints and constants in storyboards as “installed”. He’s slightly ashamed, since he’s realise that these features have been around for a while now, but never the less, it just makes him love them more. To make him feel worse, Jelly tosses out a new feature Jake’s never heard of: the ability to provide image assets based on device and size class. He also agrees that storyboards are the logical choice for visual layout design (WHAT?); things like autolayout constraints make more sense in a visual format than in code. Jelly then spins the discussion off to talk about his issues with sync in GIFwrapped: a year and a half into working on the app, he’s still having issues. In response to an announcement from Dropbox that they’re moving to a new version of their API, he’s working on a new structure for the GIFwrapped library, part of which means writing his own Dropbox client directly on top of the HTTP API. This leads to the question of which is better: notifications, protocols (like delegates), or blocks. Jelly first asks Jake’s opinion, then proceeds to describe his rationale for the use of each one. Jake wants to spend a little time talking about how to prep for WWDC, which is happening next week, so he spends a little time explaining what he’s been doing to get ready: re-watching last year’s sessions, filing radars, and preparing sample projects to take to labs.

With the videos from the final NSConference out to watch for free, the couch discuss some favourites, as well as conferences in general. Plus, a brief look at presenting alternate view controllers, such as onboarding screens and login dialogs. After a brief (and ridiculous) discussion about what WWDC might have in store this year, Ben reveals that he has a list of his favourite videos from NSConference 7, and the couch spends some time discussing each one for a few minutes. Somewhere in the middle, they get sidetracked by a discussion of conferences, both first and third party, and Jelly’s one lament, which is that there isn’t more opportunities for conferences in Australia, while so many happen in America or Europe. With NSConference covered, Jake poses a couple of questions for Ben and Jelly to answer: how do you handle showing an onboarding sequence on first load, and how can you do something similar with login screens, showing a login modal over another modal if the user isn’t logged in?

Jake has his watch in hand, so after going back over some unit testing follow-up, and with a single weekend’s experience, the couch looks at first impressions, the various delays that people are struggling with, and handling multiple asynchronous tasks with dispatch groups. Jelly segues seamlessly into follow-up, and talks about how he spent some time since the previous episode creating unit tests for one of his open source projects. He struggled a little with getting started, but feels like the endeavour was worthwhile (it found bugs!). He’s still wary about full test-driven development though. Pre-ordered watches have started arriving, including Jake’s, and so the couch discusses the pre-order experience, Apple’s offer of expedited orders to random developers, and the watch labs that were offered prior to the launch for on-device testing of Apps prior to day one release. This leads to both Jake and Jelly giving their first impressions, including the delay that they experienced with waiting for Jake’s glance to load it’s data, and the fact that there’s a large gap between the experience of first-party and third-party apps. Jelly uses this as an opportunity to cover what gives him the inspiration for his apps, and how being the first in the store doesn’t prevent someone from coming along with a better implementation and succeeding. Moving along, Jake talks about an issue he had this week with implementing multiple API calls for displaying data in a today extension. After trying a few solutions (including NSOperationQueue), and then he discovered dispatch groups, so after he covers how he implemented them, the couch discuss why you would choose them over an operation queue. This spawns a conversation about APIs and how Jake’s implementation is covering up a potential issue with the API he’s using. Is it better to use a potential complex API endpoint that doesn’t provide the data in the format you need, or stick a server between the app and the API to parse out just the bits you need? Also, did you know Jake got an Apple Watch?

Leading with follow-up, Jake touches on his experiences with developing a WatchKit after having talked to David, how he’s fetching the content for his glance, and how the Swings analogy made him rethink the way he was trying to lay out his views (and thus making his efforts more successful). After getting nostalgic about a listener-submitted Codewarrior mug, Jake talks a little about the various Steve Jobs biographies he’s read, before touching on some assert related feedback. This leads Ben to pose the question about whether you should leave asserts on, or remove them for release code. The couch discusses where people use asserts, and in what cases you might actually want to ship asserts rather than displaying an error. Moving on, Jake asks if Ben has any opinions on testing, and this leads into a discussion about unit testing, and what exactly a unit test should cover. From the conversation expands to cover various other kinds of testing, like integration testing, and UI testing with UI automation. As they start wrapping up, Jake mentions that the bit he likes about unit testing is that it makes him think about the structure of his code, which Jelly believes he already does. In fact, he believes that if you’re relying on testing to structure your thinking, you’re doing it wrong. This prompts Ben to ask about how Jelly approaches his code, which Jelly answers by roughly describing his process when he built Static Tables. Laying out blank classes and methods to create a basic structure, fleshing them out, then writing an example app for testing. Finally, Jake adds that Playgrounds are what got him started on unit testing in the first place. He loves the concept of code being executed as he’s writing it, but the lack of external frameworks lead him to trying out unit testing.

Joining the couch this fortnight is Underscore, a.k.a. David Smith, host of Developing Perspective and independent developer extraordinaire. There’s so much to talk about, but the biggest topic is the Apple Watch, and specifically developing apps for it, which is something that David has some experience with. To kick things off, Jelly asks David what drew him into developing in the first place. This leads to talking about why he keeps a large catalogue of apps, and how he achieves sustainability through diversity, while also providing him with the ability to satiate his short attention span. Turning their attention to the Apple Watch, David explains why he’s focusing on developing for Apple’s new device, and how’s he’s managed to create apps he believes are compelling for a device he hasn’t yet been able to fully experience. The couch then start talking about the actual development process in a bit more detail, discussing things like what methods are called at different points within the app’s lifecycle, and when you should be refreshing the data that’s shown in a glance. At this point, Ben asks about how David has achieved animations on the Watch, and so David describes how you perform animations, from timers to more complex, image-based animations, like the bar graph in Pedometer++. From there, they discuss measuring the experience of the app, and how it’s not always the obvious choice, as well as what the balance of complexity should be when it comes to building apps where there is very little as far as input mechanisms.

While Ben is at NSConference, Jake and Jelly compensate by talking about the new Macbook, Jake’s recent experience with converting a Swift 1.0 project to 1.2, and a couple of Haneke-related tricks they’ve learned recently. Jake wants the world to know about the one thing he managed to predict correctly for the Apple Event: the inclusion of hardware other than the Apple Watch. This leads to talking about the new Macbook as a development machine, despite the slower compile times as compared to a Macbook Pro. This starts to lead into a discussion about Swift 1.2, which apparently has far improved compile times than the previous version. First of all, however, Jake lays some groundwork by detailing some bugs he fixed in an update for the app he talked about on the last episode, including the parental section accessibility issue and the solution he devised. Jake then finally gets to the details of his migration of the app’s codebase to Swift 1.2, including the changes to the as operator, and the changes to @autoclosure. This procedure has made him question Swift’s simplicity, however, and he wonders if it will be a language that is easy for newcomers to pick up, or whether Objective-C might be the better choice. The migration has also introduced him to forking an open source repository to contribute changes, and he details the changes he made for a page control alternative and how he made it compatible with Voiceover. Finally allowed to talk about some of his work, Jelly takes the mention of Haneke as an opportunity to talk a little about custom fetchers, and Jake then talks about implementing custom formats with the caching library.

Jelly’s had some wine, and a long day to boot, so after a failed first attempt at recording the episode, the couch talks developing for Android, goes into more detail about the value types discussion from the last episode, discusses the Blue and Black/White and Gold dress dilemma, and makes predictions for the “Spring Forward” event. In the past week, the Australian media have been shocked to discover that you can send iMessages to people if you know their email address, much to Jake’s annoyance. Meanwhile, Jelly takes no stock in the mainstream media’s ability to report accurately on technology issues, citing people’s tendency to blame technology for things that are actually user error. This leads to a quick discussion of how old devices are treated and Ben’s inability to keep one charged off of the cable. Ben then starts to give a bit of a primer for getting started with Android development, including which IDE to grab and how to get the emulator running. This is soon somewhat derailed as Jake begins to list features he likes in Android Studio, and the discussion devolves into a comparison between it and Xcode. Of course, it doesn’t take much to go from there to talking about Swift, and Ben ends up talking more about the video from Andy Matuschack mentioned on the last episode. After Jelly does the intro at this point, and it’s revealed that this is the second attempt at recording the episode, Jelly brings up the topic of the Blue and Black/White and Gold dress that recently took the internet by storm. The couch first discusses the science behind the phenomenon, and then Jelly attempts to spin off onto accessibility, and how some users see your app differently. This prompts Jake to talk about some accessibility weirdness he recently came across with working on a kids app: not only does the app read out instructions for accessing the parental features, but the gestures used become impossible with accessibility gestures turned on. Having officially given up on the show at this point, Jake then turns the couch’s attention to the rumoured Apple car (the most mobile of devices), and specifically, the reasons he thinks that it’s an actual thing that Apple are working on. He then moves on to predictions for the imminent Apple event, including things that might be announced alongside the watch.

Tonight! Ben uses a Word template, Jelly iterates a build number, and Jake watches half of a video. Hot off the heels of the release of his book about Cocos2D, Ben gives the couch a quick walk through what it’s like to write a book, from what tech is used, having your work edited and your code reviewed, and what it’s like to deal with a publisher. Jake then begins to review some of the Testflight follow-up, prompting Jelly to vent about his plentiful issues that Testflight has caused over the previous week or so, such as build that don’t install and crashes that occur on launch. Jake then actually manages to touch on some bits that weren’t covered in the previous episode, as well as a new feature that launched since then. Moving on, Jake brings up the new version of Swift, which has a bunch of bug fixes, improvements and new features, such as: less compiler crashes, single line unwrapping of multiple optionals and improvements to let. While he’s on a roll, Jake also talks about video presentations he’s watched recently, including two that introduce React Native, an upcoming project from Facebook that changes the way you deal with native views in mobile apps, and another by Andy Matuschack on managing complexity in Swift.

Jelly has wanted to talk about Testflight for a while, and he finally gets his chance, comparing Apple’s beta distribution tool with the previous methods, like Ad Hoc and Enterprise distribution. After dealing with some follow-up backend services, Jelly brings up the topic of Apple’s Testflight, it’s new beta distribution tool. The couch discuss the previous methods for sending out builds, which involved provisioning profiles, UDIDs, and endless nightmares about testers not receiving builds immediately after getting the initial email. Turning to Testflight’s limitations, the trio go through some of the larger issues that it has, mostly looking at it’s iOS 8 requirement and the need to go through review before distribution, as well as the limitations of iTunes Connect accounts, which are a requirement for internal testers.

Russell Ivanovic (@rustyshelf) joins the couch to discuss back-end services for mobile apps, the differences between software-as-a-service and building your own web service, and go into why you might choose one over the other. After several side tracks, including trying to figure out who has the higher Crossy Road score, and a whole bunch of French, Jake kicks things off by asking why you might want to integrate web services to begin with. Since everyone pretty much agrees on the answer (and that iCloud does not a good back-end make), they move onto discussing some of the services out there, like Parse and Azure, that allow you to create something with some amount of transparency. Jelly feels left out, and begins to explain that his method of choice is to build a service from scratch, usually in (the abhorrently evil) PHP, and Russell chimes in to explain how the web services for Pocket Casts and Pocket Weather are built from scratch in Java and Ruby on Rails. Jake doesn’t feel like this is an option for him, since he hasn’t kept on top of the advancements in this area, and he feels that it would take him too long to get things up and running. Using an example of generating scaled images using Cloudinary, he explains how he set a basic thumbnail creating service up for an app he’s building in around 20 minutes. After this, the discussion takes a quick turn to scaling: Jake doesn’t need it for this project, but it’s definitely something you need to consider. Jelly hears Ben mention a bug, and after having Jake explain it (Azure having a dependency conflict), he launches into the biggest issue he’s had with a third-party service: when Giphy changed their API and broke GIFwrapped’s built-in search feature. This brings up the discussion of how to guard against issues with third-party systems: encapsulating all the third-party related code in a single class, or providing alternate solutions. Finally, the couch discuss the process you would go through in choosing to use a third-party system, such as expertise, time, existing libraries, and the like. They go into the details of Jake’s situation — developing apps for clients — and weight up the potential benefits and issues in comparison with Jelly and Russell, who are building products.

The couch is back from holidays, so they take the opportunity to talk about things that they worked on over the short break, and what they like to do during downtime to keep themselves sharp. Having received some feedback about extensions from the previous episode, Jelly details how Target Membership can help developers build extensions into their apps while supporting iOS7. He explains how this works, and why it might not be such a great idea. Jake then touches on his recent experiences with Android’s “support libraries”, which allow developers to support new APIs on older systems. This leads to discussing methods of supporting older versions of iOS, which doesn’t have this ability, and Jelly explains how he prefers feature detection over system version detection. Jake also follows up on his argument about Today extensions, citing Drafts reinstatement as partial proof that he is correct. Jelly can’t handle someone else being right, so he asks Jake to explain Pcalc’s reinstatement, which Jake can’t do. He does believe, however, that recent rejections aren’t completely unsurprising, as Apple’s behaviour on this matter appear, to him at least, to follow some form of pattern. Moving along very quickly, Jelly asks the other two what development they did over their breaks. Ben details a side project he did as part of a Christmas gift for his wife, Jake explains how he learned a little about functional, and then Jelly explains that rather than working on GIFwrapped, he did some “comfort” coding in PHP. This leads them to discuss the low-reward jobs, like refactoring, that they sometimes do during downtime. Ben notes that Jake’s code is usually pretty good, and is commented, which takes them off down a path of discussing comments in code: when it’s good, when it’s bad and what the past practice for commenting your code might be. Getting back on track, Jelly talks about his approach to implementing low level things as a method of learning how they work. He explains how he goes about it, detailing his experience backwards-engineering NSScanner in PHP. As usual, Jake then spins the topic off onto Swift, explaining the inability to call UIAppearance’s appearanceWhenContainedIn: method in Swift. This leads to talking about Swift’s viability as a future-proof language, which in turn leads to discussing Swift as a server-side language.