RWDevCon 2017 – Notes and Thoughts
I attended the third RWDevCon March 30 – April 1 in Alexandria, VA. (Yes I know that was 10 days ago, but I had a lot of notes.) It was the third time RWDevCon was held, thus I was one of a reported 12 faithful attendees who have attended all three conferences. I even dragged a colleague from one of my customers to attend this year.
Why do I return for the joy of back to back eight hour days of seminars (this year with a third all day workshop for added pleasure)?
- Hands-on Tutorials. Before each conference, Ray Wenderlich (the “RW” in the DevCon) and his team send out the slides that will be covered in the tutorials (a small PDF) along with a Zip that includes PDFs of slides and Xcode of all of the demos and labs (with multiple start and stop points) that will be covered as well…and this Zip is huge. This size comparison drives home the point: this is the most hands-on conference of any developer conference I’ve been to. I was prepared this time, had all of these files loaded in Notability on my iPad and was taking notes on the PDFs (aside: I was a skeptic about the Apple Pencil, but this note-taking setup has converted me). In the previous two years, there were some pacing issues, where there was just way too much to type in the demos, and that got in the way of listening to the instructor. When the instructors type while they talk, and expect you to listen while you talk, laptops get closed and people start to just listen…which is okay, but not optimal. This year, I only experienced that one time. Ray and his team, with all of the practice they put into these sessions, have it down.
- Conference organizers who listen. I (and every other attendee) received an email from Ray asking what types of sessions we’d like to see in the conference. I do not recall all of my responses, but I did list “error handling”, “unit testing”, “machine learning” and “application architecture”. All of these appeared on the agenda. Even a small item, like a request to have something other than those nasty, incredibly-bad-for-you Coke products during the breaks was listened to…with Naked Juice now as an option. When they listen to their attendees, good things happen.
- Ray and Vicki. As I was walking into the workshop the first day, I ran into Ray, looking very bleary eyed. Though I knew he’d probably been up all night reviewing sessions and entertaining the vast horde of Brits he seems to employ (!), he stopped for a quick chat and update. Vicki walks through with her ever present smile, knowing everyone’s name. Though I only see these two once a year, they are very enjoyable people and I revel in their success. They make no excuses about being introverts, but practice their presentations over and over until they seem comfortable in the spotlight. I hope RWDevCon grows to dominate the world, just so they can enjoy the fruits of their labor.
- The RWDevCon team. They work hard, they are there to help you learn, and they are a lot of fun. And Brian lets me win at the card games (sometimes). Ray and Vicki, at every conference so far, talk about inclusion, about letting people feel not only comfortable but like they belong. They walk the walk.
- Beer. Ray and Vickie call this friendship, camaraderie…but let’s face it – we’re here for the beer (and the card games. and the people). I must ding Mr. Wenderlich, though for two beer notes:
- At the bash at the Carlyle Club, Ray was telling me how wonderful the beer was that he was drinking; when he left to go do host-type things after setting his bottle on the bar, I asked the bartender for one…only to find out that Ray had just quaffed the last one (but left an inch in the bottle…I did NOT drink after Ray). I do not remember what beer this was as I have blotted it from my mind.
- For the receptions at the hotel, the catered food and mojitos were quite good. But when Sam Adams is the best beer of the selection…time to head down to the Trademark for their excellent selection of beers….or to the post-conference bottle share…but that is a later session.
It would be great to see RWDevCon grow into something much larger, so that those that put in the hard work could realize that success. But it is also excellent at the size that it currently is. Ray, Vickie and the team have a hard balancing act to do.
Bottom line: I cannot recommend this conference more highly to any and all iOS developers. Most of these sessions provided me with enough information that I could use what I learned immediately. Some are difficult enough that I’ll need to review the data before knowing enough to be dangerous. But the amount of tools and education gained in these three days provides a high ROI on time and money spent.
All day workshop – App Architecture (Josh Berlin and René Cacheaux)
It was a tough choice between the Debug workshop versus this one, but need won out. I’d recently completed a cycle count and inventory Swift application in a very tight timeline, and I KNEW I had broken many app architecture rules in haste….so I went to task to re-learn and hopefully be amazed by some new ideas as well. Had I known attendees would be getting a copy of Derek’s (who was leading the other workshop) Advanced Apple Debugging and Reverse Engineering book at the conference close, I would have had more incentive to choose this session…until Josh and René put out an app architecture book.
After meeting one of my three favorite nephews for brews and dinner at the Trademark downstairs the night before, I was primed and ready (obligatory local beer picture included) for the next morning’s 8 hours session.
What I learned:
- Josh and René are both from Austin, where I’ll be living soon. Beers will be shared.
- From the intro: “Thoughtful design of the boundaries between your apps subsystems is the foundation of a stable codebase.” Deep stuff for 9am!
- Dependency Injection (the demos used the Swinject library, there are others available). The first demo pulled an API call out of the view controller and put it into a Swinject Assembly….need to use this as we refactor our cycle count app.
- Storyboard Dependency Injection.
- Use case driven development. This is not a new subject, a quick google of that phrase shows many old articles on university web sites, IBM, ACM, etc. But the workshop (specifically Demo2) showed swift version of implementing use case objects.
- Unidirectional data flow with a state store.
- Redux – state stored outside of the view controller
- Some RxSwift as an appetizer to the session tomorrow (this actually had me change my schedule to attend the RxSwift session instead of the Fastlane session).
After the workshop, with a full brain, sore butt from sitting, an hour to spare until the opening reception and the threat of bad running weather in the ensuing days, I headed out to run down King Street, a very cool old set of blocks that runs towards the river, right into more running trails (obligatory running scenery picture included – session details after the photo).
There were three tracks of sessions. There are the ones I selected to attend. There are several others that I either worked through the demo material or plan on doing so…as, so far, one cannot be in two places at once.
Machine Learning on iOS (Alexis Gallagher)
Why I attended: I want to employ machine learning with two of our products (Secure Workflow and Clinical Decision Support).
What I learned:
- Docker can actually be run on my wimpy old MBA, making me glad I didn’t upgrade (but of course, when the chipset gets refreshed, I’ll be the first in line).
- The setup was well done, starting the training part of the machine learning demo first (so it would actually complete on a wimpy old MBA) and then going through the theory.
- The docker image had Google Tensor Flow, and we used the inception3 algorithm.
- Alexis has some great smiles…and some rather frightening frowns.
- We made training data by pulling images out of videos, classifying those videos as smiling and frowning, and then letting the Docker image train on the pulled out images against the baseline.
- The tensorFlow console is accessible in the Docker, and allows you to browse deeply through the Inceptionv3 network.
- I spoke with Alexis after the session, and discussed with him how I wanted to employ machine learning. Based on my description, he suggested linear regression and pointed me towards the Machine Learning course on Coursera taught by Andrew Ng of Stanford University (which he also mentioned at the top of his “Where to go from here?” slide and the end of the session). A session of it just started, and it was a great suggestion (thanks, Alexis).
iOS Concurrency (Audrey Tam)
Why I attended: We have an old objective-C app that is getting converted to Swift, and it needs some concurrency help at one customer as their network is slower. I’d like to put parts of the data refresh in the background while updating the animations of the workflow tasks and notes. Plus Audrey is my wife’s name, so there you go.
What I learned:
- I have a lot of work to do.
- What not to do (deadlocks, race conditions, priority inversions)…same concurrency problems that exist in all programing languages
- Dispatch groups, dispatch barrier tasks
- Async operations
Building Reusable Frameworks (Eric Cerney)
Why I attended: The old objective-C app I mentioned earlier has frameworks, and they need to be updated.
What I learned:
- “A library is a tool, but a framework is a way of life.” Let’s do t-shirts!
- Explanation of some of the differences between the three main dependency managers (Swift Package Manager, Carthage, CocoaPods)
- SPM still doesn’t support iOS
- using ‘git tag’ to manage versions
- Demo 1 walked through Swift Package Manager; Demo 2 walked through building a multi-platform library (which, as I’ve heard, is a tool, not a framework…)
- great demo on access control, and a good list of “gotchas” on bundle specifications, global values, and singletons
RxSwift in Practice (Marin Todorov)
Why I attended: Reactive programming. Buzz words. Got a taste during the app architecture workshop. And I sensed a book was coming (obligatory signed book page picture included, only found Marin and Ash though…there’s a lot of authors!)
What I learned:
- Don’t try to use reactive programming for everything (also mentioned in one of the inspiration talks)
- Asynchronous code and observables. Demo 1 walked through “Variable” and emitting and subscribing to events
- Using Observables with “bindTo” to tie incoming JSON directly to a tableView. This I will definitely use as we update our workflow app.
- Using “bag = DisposeBag()” to get rid of subscriptions…takin’ out the trash!
- I’ll walk through the book for more detail. We should be able to use this in the tableViews that are in our cycle count and inventory app, which shows which aisles still have items to be counted since this is made available via RESTful web service, and currently gets updated in a non-reactive way if the current user assigns themselves an aisle to count.
Practical Unit Testing I (Jack Wu)
Why I attended: Code is never tested enough. Especially mine.
What I learned:
- When Jack says “practical”, Jack means practical. Lots of good points about balancing the time it takes to write and maintain tests versus having “good” and “useful” tests. Another way to read this: “Jack hates testing code as much as I do, so let’s do it efficiently and quickly and no one will get hurt.”
- Write tests before you refactor, make sure the tests succeed, then refactor.
- How to write a basic unit test
- How to write a UI Test in Xcode, and how to make them not so darn slow
- You can refactor you code to be more testable, and this makes for easier to understand code. My lead developer is a refactoring machine, and his code is always testable….make sense.
- I started in the session writing tests for the next version of the cycle count and inventory app. This was a very practical and applicable session.
Swift Playgrounds in Depth (Jawwad Ahmad)
Why I attended: I didn’t get to use playgrounds enough as a kid. It was a tough choice between this one and Practical Unit Testing II.
What I learned:
- Playgrounds are still flaky. Several folks had to restart Xcode (myself included) to get the Live View to work.
- IndefiniteExecution in a playground….cool
- Reading from and writing to a file in a playground…quite useful
- moving code into a framework to use in a playground
Advanced iOS Design Patterns (Joshua Greene)
Why I attended: The description talks about authentication, auto re-login, data and thread safety designs.
What I learned:
- This was one session where I could not keep up with all of the typing, and for the most part sat back and listened.
- Demo 1 walked through MutlicastClosureDelegate; Demo 2 walked through the Visitor pattern.
- During the lab time, I actually started going through the “On-boarding” seminar slides and demo/labs. I’ll be running back through both of these sessions again. The on-boarding piece is quite useful for first time training users, even (or especially) for Enterprise apps.
Swift Error Handling (Mike Katz)
Why I attended: My error handling looks like the if-then-else statement from hell.
What I learned:
- I’m going to “borrow” all of Mike’s error handling routines.
- throws, try (not the rugby kind of try I’m used to!), do/catch
- pass errors up (from inside to the call)
- Using a Result-type and map
- The Lab went through ways to provide error responses to AlamoFire and also a way to do auto-retries after timeout errors
- The RW team pushes the session and conference evaluations hard, because they compile them on the fly. And, in this closing session immediately after the last inspiration talk, Ray details a summary post-mortem and asks for more feedback. This is the only conference that I can recall that does this.
- One way they push the evaluations is they give out prizes (you get an entry ticket for each evaluation). And, for the third year in the row, I won…nothing.
- But I did get two books, both of which have been previously mentioned (RxSwift and Advanced Apple Debugging). And managed to get both of them signed (obligatory signed book pictures)
Post-conference bottle share
Why I attended: I brought two great beers from local Houston breweries and they needed to be tasted. (obligatory Houston beer picture included, especially since several people asked about them. They were mighty tasty)
What I learned:
One could make a case that this wasn’t really part of the conference. But it was. We traded beer stories, travel stories, family stories, tried to kill a monster in a dungeon while bluffing (more card games), and generally had a great time. All were invited.
With the amount of pre-conference setup, conference materials and notes gathered from this (and the previous two) RWDevCon, the investment here will continue to pay off as they are used and referenced. Next comes incorporating these into release plans for the apps we already have deployed, and those we will deploy in the future.
Some additional photos included here at the end.