From skeuomorphic, to flat, and now modern design styles (a spectrum of both), David Hoang has been designing for iOS since he bought his first generation iPhone. In this talk, David expresses his ideas and thoughts on what makes good interface design, how good design practice is a matter of seeing, and how anybody can build the skills to be a good designer (including you).
David will share a mixture of academic design best practices and personal learnings from his own experience. After this talk, you'll be more prepared to:
Whether you're an indie developer doing your own design work, or a beginner who trembles at the thought of Sketch and hesitates in Interface Builder, this talk will refine your skills and boost your confidence.
The Objective-C runtime is at the heart of the language, and is still heavily involved in Swift. We'll take a look at exactly what the Objective-C runtime is, how it works, how it ties into Swift, and what you can do with it. We'll finish up with an instruction-by-instruction walkthrough of the objc_msgSend function that drives every square bracket expression you write.
You can commit, pull, and push from the command line when you need to, and you're ready to learn some more git features–but you aren't trying yet, because your source code is a *terrifying* place to experiment with unknown git commands. In this workshop, we'll work together in a pre-existing toy repo so you can get comfortable doing things like: browsing history to find the source of a bug (bisect & blame), using the most helpful of Xcode's built-in source control support (no, it's not snapshots), and getting back to the state where "everything worked" (reset, stash, reflog).
SourceKitten, an open source wrapper around Apple's SourceKit, is a great tool for parsing your Swift code and generating useful materials from it like documentation or dependency graphs. We'll go into details of how it works, how to use it, and what we can do with it on a large code base.
It’s hard to believe that it’s already been 3 years since the Apple Watch was first announced to the public. We’ve seen a multitude of changes throughout its short history and are still imagining what the future is for the “most personal product Apple has ever made.”
In this session we’ll walk through the Apple Watch’s brief history, discuss the evolution the product has made in its short lifespan and what developers can do to make the most out of it’s most personal attributes. From tips and tricks for Watch Connectivity to lessons learned from implementing ClockKit, we’ll cover an array of Watch specific APIs. At the end, we’ll take a look at upcoming changes in watchOS 4, as well as take a deep dive into what needs to be done to upgrade from previous watchOS versions to support the latest one.
This is an introduction to Maps, Coordinate Systems, and cool tricks you can do with them. This introductory session will cover the basics of working with maps, what coordinates do and how to use and convert them, and how to draw paths on maps using sensor data.
You've spent this week intensely learning, both deepening your knowledge of existing tech and playing with tons of new APIs. And now you're all fired up, and can't wait to share it with your team back home!
In this hands-on workshop, you'll learn to choose a good topic, narrow your focus to a few specific objectives, and brainstorm materials & techniques to make sure people really grasp these new ideas. If you're writing your first presentation, you'll come out with welcome starting scaffold–and if you're writing your fiftieth, you'll shore up those pedagogical skills that are so easy to overlook.
Jono will discuss practical design-led thinking approaches to creating scalable and agile server-side API’s for your mobile applications, from initial planning through to execution and documentation. While targeted at Swift as the language, you’ll be able to apply these techniques to creating API’s in almost any server-side language.
With the phenomenal success of the iPhone and the App Store, there are more users than ever who are not savvy about technology and software. To reach these new users and turn them into customers—and even fans—it’s vital to communicate the benefits of what have been geek products to a non-geek audience. In this presentation, we'll review common missteps that we geeks make in app descriptions, documentation, website copy, and customer support. Then we'll focus on how to revise them to appeal to a wider audience.
Let's get down to bits and bytes! Abstraction is great, but sometimes it's useful to dig down. In this session, we'll explore exactly how Swift lays out data in memory, including both your own variables and Swift's internal data structures. We'll build a program to recursively scan memory at runtime to dump out everything we want to know, then walk through its results and what they mean, and compare and contrast with how C and C++ store their data.
What’s Apple planning for its media frameworks in the next 12 months? What’s it doing with Apple TV, or the HTTP Live Streaming standard? We won’t know until the curtain drops on WWDC! In this talk, we’ll amass everything audio- and video-related that gets announced throughout the week, combine it with the solid base of frameworks already present in the Apple platforms, and figure out from there what we’re going to be playing with in 2018.
With Facebook shutting down Parse, everybody knows to never again depend on a third party for their backend solution, right? Sure, and after you spend six months trying to write your own syncing service, how's that working? In 2016, Google has added a ton of features to Firebase, their popular backend-as-a-service solution. Firebase's primary offering is a realtime database in the cloud that syncs changes to and from multiple concurrent users, and their Swift-friendly iOS SDK makes it ideal for mobile use. In this session, you'll learn how to set up a Firebase backend and build an iOS app around it.
Details coming soon!
Let's explore directly programming the GPU using Metal and Swift. Enjoy giant speed gains in your existing code, and dream up whole new classes of apps.
It's not obvious how to even start thinking about this stuff. What kinds of problems can be attacked? What is the learning curve? What are the trade offs? We'll get things cleared up and start exploring with real code.
Swift-Metal playgrounds will be available to get your feet wet and start experimenting. You'll go home with a starting point for your own projects.
Isn’t that what everyone wants to know? How do you estimate how long an a feature or system is going to take to complete? We know that estimates are often wrong, but can’t we say something?
Maybe, we can.
We’ll talk Monte Carlo solutions, estimation history, and why communicating error in measurement is important.
It used to be that if you wanted to write on the web, you posted to your own blog. Now, most text and photos go into closed platforms like Twitter. But what if we could bring the UI innovations of today's social networks and apply them to blogs and independent publishing? In this talk we'll explore the challenges of building a new social network, with details on user interface design and code for creating an Instagram-like service on iOS and microblogs.
The show takes place at the City National Civic, and runs from 7:00 PM to 11:00 PM. Tickets included in your Next Door admission.
Swift is not a functional programming language. Pushing too hard to make it one fights Swift and breaks Cocoa.
But Swift has absorbed some fantastic lessons from the functional world, and while value types may not quite be the present, they are clearly the future. We’ll explore how decades of work in functional languages have influenced Swift, and how you can use those features best while staying true to Swift.
The animation foundations in iOS are well-designed, intuitive, and powerful. What can we learn about how they are built, the capabilities that they give, and the assumptions that they are built upon, that we can bring to our own software design? Whether we are building apps or SDKs or doing frontend or backend, good framework and API design is universal. Let's learn together from one of the best examples.
Xcode is a fabulous tool, but especially when you're just getting started, you might not know all the ways you can bend it to your will. We'll talk through both much-loved and little-known keyboard shortcuts, custom behaviors you should absolutely add, the joy of breakpoints, and if we're lucky, some super helpful new debugging components in Xcode 6.
Swift is great for writing iOS and Mac apps, and its creators also mean for it to be used as a systems programming language. However, certain traits about Swift make it officially off-limits for use in some audio/video-processing scenarios. What's the deal, is it not fast enough or what? We'll look at what media apps can and can't do in Swift, and what you're supposed to do instead. We'll also look at strategies for knowing what responsibilities to dole out to Swift and to C, and how to make those parts of your code play nicely with each other.
Many mobile applications have to deal with passwords. Users and developers hate them but accept them as a necessary evil. This session looks at how we as developers can make the lives of our users easier when it come to password through good UI and and taking advantage of technologies such as Touch Id and the Safari keychain.
Keychain, disk encryption, Common Crypto, certificates. Security can be daunting for Cocoa developers. There are so many frameworks filled with words you’ve never heard before solving problems you don’t understand. And why does so much of it have to be in C?
The truth is that good security is hard, but the code doesn’t have to be. This session will show you how to best use the many security tools Apple provides. You’ll learn how to properly encrypt with AES, how to make the most of iOS’s device encryption features, how to best manage SSL, and more. If you’re using AES for anything, but don’t know what an HMAC is, you need to attend this session.
Let's explore the powerful math behind 2D animations and printing, starting with a quick overview of the CGAffineTransform API. Then we'll get hands-on in a Playground. This Playground can also serve as a debugging tool when you use CGAffineTransform in your own apps. Please bring Xcode or an iPad with Playgrounds to fully participate.
Text and string processing is a subject that looks easy at first, but becomes tremendously complicated the more you look into it. Unicode is the modern standard for computer text processing, and it's full of complexity. In this talk, we'll take a deep look at Unicode's history, design, and structure. You'll learn about code points, code units, combining characters, normalization, emoji, UTF-8, UTF-16, and UTF-32. With this foundation in place, we'll bring it all back to practical applications by seeing how it fits in with Swift's powerful but sometimes complicated String API.
Many apps have some global state or services that need to be accessed at various places in code. In this session, we begin with singletons, and work through design iterations arriving at an approach using protocols and existentials Swift that make these global dependencies more explicit, while making subsystems that rely on the them more easily tested and evolved.
Sure, everybody likes Metal but the Accelerate framework is where the magic really happens. This talk assumes no prior usage of BLAS or Fortran.
We’ll talk some Math, some Matrices, some Ceiling Wax and Kings.