iOSDevUK 6

This was my first year attending the iOSDevUK conference, hosted by Aberystwyth University in Wales. I took a bunch of notes throughout the conference and here are some of my favourites.

Day 1 (Tuesday)

Organisers Chris Price and Neil Taylor kick off with a short introduction.

img_0800

A conference such as this is an ideal platform to get recognised, the sponsors all had a strong presence and multiple opportunities to remind attendees of career opportunities.

Tackling Refactors – Lessons learned from rewriting the Instagram iOS Feed

Ryan Nystrom, from the Instagram engineering team, describes how the old version of the feed worked.

It’s based on a collection view, with a deep hierarchy of view controllers:

  • Home view controller inherits
    • Feed view controller, which inherits
      • Networking view controller, which inherits
        • Collections view controller

Feed Item data models drive the data source (also implemented by the view controller), they contain all information required to display all kinds of cells (photos, videos, user info, likes, comments etc). Adding a new type of cell required adding even more properties to the Feed Item, which, over time, became a god object.

The amount of technical debt led to the engineering team rewriting the entire feed. This took almost a year, mostly due to no feature freeze and therefore having to implement new features in both the existing feed and the new version.

Their solution involved using a Longest Common Subsequence algorithm for finding the changes in feed data and only reloading the necessary cells. They also removed the view controller inheritance model in favour of Item Controllers (not a UIViewController subclass) which manage the cells.

img_0801

It is written in Objective-C and C++ (the LCS algorithm, mostly for performance reasons) and will be open sourced “later this month” as IGListKit.

Running A/B tests on your app using Firebase Remote Config and Analytics

Todd Kerpelman demonstrates Google’s Firebase platform, specifically the Remote Config feature.

This allows developers to setup a key-value store that can be used to provide an app with different values depending on certain conditions. For example a newsletter subscription button’s text could be set to “Subscribe” for 70% of users, and “Get Offers” to the remaining 30%. The value used can be determined based on a set of rules/conditions such as random percentile, device region/country, language, etc.

Prototype Everything

Niels van Hoorn pitches FramerJS, a tool for creating interactive prototypes of pretty much anything you can think of.

img_0804

It uses a WYSIWYG editor to build prototypes and generates CoffeeScript, which can be modified and shared with others. Device Preview allows the prototype to be used on a real device, making it easy to spot any potential issues with the design, though this does require a £7.99 companion iOS app (on top of the $129 for the OS X app itself).

From “Real” Native to React Native

Matt Oakes explores the pros and cons of multi-platform development, with a focus on React Native.

Multiple Development Teams:

  • Pros
    • native, first-party development tools
    • fast performance
    • well supported
  • Cons
    • little to no code reuse
    • duplicated effort
    • differing implementations

Cordova:

  • Pros
    • shared code
    • shared development team
  • Cons
    • poor performance (web view)
    • non-native views
    • no official development tools

React Native:

  • Pros
    • native components
    • good performance
    • good development tools
    • mostly shared code
    • mostly shared development team
    • can be embedded (one screen/portion of a screen can be React Native)
  • Cons
    • mostly written in Javascript
    • unofficial development tools
    • changing fast, 2 week release cycle, generally with breaking changes
    • not fully production ready

React Native is based on components, which are analogous to UIViews. Components can be compose together to create higher level components.

Native custom classes can be imported for use within React Native Javascript.

Apps can be modified without recompiling & relaunching, which is good for a fast development cycle, e.g. change the text of a button/label and see it take effect immediately.

React Native apps also include an on-device UI inspector.

Building & Distributing a Closed-Source Framework

Steven Hepting, discusses why creating and distributing frameworks (even just internally) are generally a good idea.

img_0805

Paraphrasing somewhat: “Publishing code as open-source is often a difficult proposition for management, closed-source provides many of the same benefits and can make it easier to transition later to open source.”

Direct quote: “Most big apps take about 20 minutes to compile”, decomposing the app into component frameworks reduces this time and increases reusability.

Some cool things:

Building a “fat” framework (one that can be used on the simulator as well as real devices) using xcodebuild.

Then use lipo to combine the two frameworks into one.

To see the disassembly of a framework, use:

Dynamic vs Static – https://pewpewthespells.com/blog/static_and_dynamic_libraries.html

Dynamic frameworks are loaded at runtime and therefore can be slow, though this is (apparently) improved in iOS 9.3. Set the DYLD_PRINT_STATISTICS environment variable to 1 to print info of how long it takes to load libraries.

Lightning Talks

These were rapid-fire talks on a variety of subjects, each lasting around 5 minutes.

Morality in Software Development

Paul Ardeleanu talks about how we as developers have a moral obligation to do the right thing. Implementing accessibility is a choice, and by choosing not to do it, we exclude an entire group of potential users. Optimising performance for better battery usage doesn’t immediately sound like a ground-breaking idea, but when the energy usage of the app is multiplied by potentially hundreds of thousands of people it becomes apparent that our work can have an impact on the planet.

Release Trains

Mark Tunnicliffe with a presentation on the agile release process at Now TV.

The talk starts with a few phrases you may hear:

We need to delay the release, the story is still in development as the specs arrived late.

Just found a bug, we need to include a fix in this release but it will take 2 days to fix.

That release we just spent a week testing? It’s not going live until next month

Followed by how Now TV apply release trains with a consistent process.

  • Set development “trains” – 2 sprints, 2 weeks each. (4 weeks)
  • Regression testing, immediately after development train (1 week).
  • Certification – Apple + 3rd party (1 week)
  • Train departs (week 6)
  • Repeat

The releases are on a regular, 6 week cycle. This forces dependencies to have design/specs/analysis ready. If it’s not ready it goes into the next cycle.

Incidentally Spotify also employ (or at least did employ) a similar model, as described in their 2 part Engineering Culture video:

Tech Has Roadmaps, Should Your Career?

John Gilbey with a reflective piece on taking control of your career and avoiding stagnation by learning, expanding your skillset and keeping up-to-date. Not a particularly content-rich talk, but very inspiring nonetheless.

Is Your App A Door Handle, Or A Door Knob?

Steve Westgarth answers this odd question with a quick look at the UX of two methods of opening a door.

  • Door knob: difficult to grasp, difficult to turn
  • Door handle: simple, easy to use

An knob/handle analogue in the software industry being the CAPTCHA, which doesn’t fulfil the user needs, instead it solves a developer problem (preventing spam).

The “door handle” version of CAPTCHA would be the implementations that require the user to, for example, select pictures of trees, essentially gamifying the process. Or No CAPTCHA reCAPTCHA removing the need for user interaction completely.

The main takeaway I had from this talk was the quote “Your problems are not your users problems”.

This talk has also been given previously, and recorded: http://www.codemobile.co.uk/2016/09/07/app-door-handle-door-knob/

Ended with a pitch for the codemobile.co.uk conference in April 2017 in Chester.

Day 2 (Wednesday)

Good weather means a perfect photo opportunity.

iOSDevUK Conference Photo

Component Driven and Modular UI Code with ViewModel

Alexey Demedetskiy takes us on a tour of various architectural patterns, specifically using View Models for both content (e.g. label text) and actions (e.g. button taps).

img_0808

A couple of tidbits – a dependency tree is better than a dependency net, and the parent should be responsible for it’s child dependents.

Slides are available on Speaker Deck.

Functional Programming for Busy OOP

Diego Freniche somehow manages to turn the subject of Functional Programming into the most hilarious talk of the conference. If you get a chance to see this guy talk, do it.

img_0809

I spent more time laughing than taking notes so they’re a bit light here, but the slides are available on SlideShare.

A funny little dig at MVC: “Model View Everything”.

Golden nuggets: Declare everything as constant and let the compiler warn you when you try to change something. Prefer returning tuples rather than using the inout keyword.

Non-optionals are the new thing. We’ve had optionals in Objective-C for years (being able to set something to nil). What Swift really introduces is the ability to make something non-optional, e.g. the ability to prevent something being set to nil.

High Performance iOS Networking

Clay Smith takes a deep dive into modern networking with a look at the current state of apps and server infrastructure.

img_0810

It’s unlikely these days that a client talks to a single server.

Thanks to physics, information takes time to travel from the server(s) to the end-user device.

  • Wales to San Francisco: (approx.) 5284 miles
  • Speed of light in Fibre optic: 2*10^8 m/s
  • Human “this wasn’t instantaneous” time: ~100ms
  • We can perceive latency even under perfect conditions.

We need to do everything in our power to speed up the transfer process or reduce the amount of information being transferred.

TCP uses 2 roundtrips to transfer data due to the initial handshake process. TLS (required by App Transport Security) adds additional overhead of more roundtrips. TCP Fast Open, support for which was introduced in iOS 9, aims to reduce the time required for establishing the connection.

Some tips for app devs:

  • Reduce the number of connections needed/made.
  • Use latest TLS. Use nscurl --ats-diagnostics <url> to check an endpoint’s compatibility with ATS.
  • Physically closer is better – use a CDN.

HTTP/2 can be used to increase performance further, and is also supported in iOS 9 and above. It provides connection multiplexing (uses the same connection for multiple requests), header compression. iOS 10 adds support for stream priorities, and server push. Most major CDNs support HTTP/2.

Moving away from protocols, the concept of Backends for Frontends (BFF) is introduced, which is essentially a fancy term for using an intermediate server between an existing, possibly legacy system, and a client device.

img_0812

The talk closes with some tips on debugging network related issues / performance.

  • CFNETWORK_DIAGNOSTICS, packet trace like Wireshark (https://developer.apple.com/library/ios/qa/qa1887/_index.html)
  • rvictl, virtual interface for capturing network traffic from a device
  • Network Instrument
  • mitmproxy. 0.16 supports HTTP/2
  • Charles proxy
  • Fiddlier
  • NSURLSession metrics (iOS 10). NSURLSessionTaskMetrics

Slides available on Speaker Deck.

iOS for CBeebies

Ross Butler, describes how the BBC uses agile processes for delivery of their CBeebies apps.

Planning

  • What? Why?
  • Facts
  • Usage drops off over time after release/updates
  • Assumptions
  • Users want to be made aware of new content
  • Hypotheses
  • Risks & issues

Story Mapping (https://www.quora.com/How-do-you-estimate-in-Scrum-when-velocity-is-unknown)

  • Product focussed
  • Story of a basic user journey
  • Draw a line to define MVP
  • Whole team + Product Owner

Shaping

  • How?
  • Delivery team
  • BA captures requirements
  • Technical feasibility
  • Research
  • Spikes
  • Goals & roadmaps

Design Sprints

  • UX
  • Crazy eights
  • Eighths of paper with designs
  • Dot voting
  • Dots next to ideas that are liked
  • Putting ideas in front of users

Three Amigos

  • Developers, QA, BA, UX
  • Smallest testable increment
  • Dependencies (e.g. assets)
  • Development backlog

Development 

img_0813

Combination of Scrum & Kanban

  • Daily stand-ups (Scrum)
  • Gather around JIRA board
  • Wheel of misfortune, whoever’s name comes up has to run the standup
  • WIP limits (Kanban)
  • Column turns red when there are too many tickets
  • Devs will “swarm” onto bottlenecked columns
  • QA will pull tickets from “Ready to QA”
  • Burn-up charts

img_0814

iPlayer team uses physical board with playful post-its.

img_0816

Continuous Integration

  • GitHub
  • Mac mini build server running Jenkins
  • HockeyApp
  • Google Play / TestFlight

iPlayer team used to use Calabash but moving towards Xcode UI tests. “Hive”, a bunch of physical devices that the UI tests run on.

img_0817

Continuous Delivery

  • Provide builds to QA
  • Beta testing groups (Android only currently)
  • Stakeholders
  • Channel controllers, “big bosses” etc
  • Games team / 3rd party developers (contracted out work)
  • Aspirations to deliver to Store
  • Versioning
  • Don’t want stakeholder builds to be ahead of QA builds
  • Feature flags, toggle via settings bundle
  • Deployment of remote configs
  • Forced updates
  • URLs / endpoints

Pan-App Requirements

  • Data protection / information security
  • Tooling (Echo, stats client)
  • Collecting kid’s info – all stored on device & encrypted
  • Parental gate

Stepping In

Invite kids to come in and try out apps in development

  • Co-creation sessions
  • Audience members invited to trial work in progress
  • Multi Variate Testing (like A/B/n testing)

Retrospectives

  • What are we doing well?
  • What could we do more of?
  • What could we improve?
  • Dot voting
  • Items written on post-its
  • Grouped into similar items
  • Vote for changes

Important to promote the positives. Just because something went well doesn’t mean it’ll continue automatically, good to have a conscious effort.

Accessibility

  • VoiceOver / Talkback as a minimum standard
  • Make it a part of business as usual. Don’t do it at the end!

Analysis

  • Build, measure, learn
  • User feedback
  • Stepping in
  • Analytics
  • Crash reporting
  • Key Performance Indicators

Day 3 (Thursday)

I’m An Idiot!

Rich Turton admits he’s an idiot, and reveals that the rest of us probably are too!

img_0821

The talk never mentions Imposter Syndrome but it certainly seems to have a lot of similarities. I know I’ve certainly felt like a fraud on more than one occasion.

He explains that it’s ok to ask for help, introducing the 15 minute rule; attempt to solve an issue yourself, but if no progress has been made after 15 minutes, you must ask for help.

Serious Simulation with GameplayKit

Adam Ederbach shows how he used GameplayKit features in a simulation of hospital staff. Making use of a few parts of the framework; Entity Component System (ECS), State Machines, and GKRandom.

img_0822

ECS favours composition over inheritance, and is made up of, not surprisingly, Entities, Components, and a Component System. Components are combined to describe an Entity. Components are triggered by the Component System.

For example a Dragon entity could have the following components:-

  • Flies
  • Breathes fire
  • Reptilian

The State Machine was used to model the possible states each member of staff could be in at a given time, such as (not exhaustive):-

  • Idle (at home)
  • Travelling
  • In surgery

GKRandom made it easier to generate random numbers within a range, under repeatable conditions (i.e. given an initial seed), and shuffling arrays (with GKRandomSource).

One of the closing points of the talk was simple, but profound, “keep it simple to start with, a great way to fail is to be too ambitious”.

img_0823

Review Of The Year

Dave Verwer closes the conference with a look back at 2015-2016, iOS 9 and the features and new API that came with it.

iPad Multitasking, a good end user experience. This feature represents another indication to clearly listen to what Apple are saying/hinting at. Auto Layout and Size Classes, both released years earlier, was paving the way for this feature (and obviously for devices of varying sizes in general).

3D Touch, not necessarily as useful as it first appeared, personally I use Quick Actions more than any other 3D Touch-based feature but still not that often. iOS 10 has expanded the number of Quick Actions throughout the system and no doubt we’ll see more and more apps adopting it.

UIStackView, this brilliant new UIKit addition brings the ability to stack, horizontally or vertically, other views (including UIStackView itself). It dramatically reduces the amount of constraints the developer needs to create in order to provide this kind of layout. It’s not very often Apple introduce a big view-based component (UICollectionView was the only major addition since 2.0).

Spotlight Search allows apps to integrate into the system level search, surfacing a vast amount of information in a new way.

App Transport Security (ATS) increases the security of our apps by requiring HTTP requests to be encrypted using TLS. Although it’s currently possible to bypass this functionality, it will become mandatory from 1st January 2017.

Safari View Controller adds the ability to embed a cut-down version of the Mobile Safari browser into an app, this is a huge improvement over a simple UIWebView/WKWebView. It includes Reader, AutoFill, and shares cookies & website data with Safari, allows a more seamless transition for users.

And finally… Only a self-confessed font geek would mention the new San Francisco font. It turns out it’s more than just a font, it’s 4 fonts in 1. SF on iOS and macOS, and SF Compact on watchOS, each with 2 sub-fonts known as Optical Sizes, “Text” and “Display”. The system automatically switches between Text and Display fonts depending on the size. Akinori Machino has a good writeup.

Leave a Reply

Your email address will not be published. Required fields are marked *