Join us in CTRL as Paul kicks off #ioscon 2017!

In this talk, you'll discover examples of usage with swift-protobuf in server and client apps. Yusuke will also highlight pros and cons compare to JSON based on his knowledge and experiences.

Sadly enough, many of the apps available today with those capabilities have some architectural limitations:

• Many of them are written in a way that is really dependent on a specific hardware.

• Some restrict their use cases to whatever is provided by the hardware devices.

• And almost all of them expect having a connection with the real device as the only way to test if they work properly.

However, we can also use an advanced architecture, like the Clean Architecture, to create a beautiful, scalable, testable, and robust application. Join Jorge and he will share with you how you can do it!

This is a "Code or it didn't happen" (TM) talk.

Along the way Matthias will tell the story of how and why him and his team decided to make MindNode accessible, and which challenges they faced. Since Mind Mapping is a highly visual activity, they had to go the extra mile and faced several non-trivial challenges, like creating a linear structure of a two-dimensional mind map, adding functionality to give an overview of the structure of the mind map and so forth.

The main reason to talk about generics in Swift is... they're fun! But more importantly, Swift can be tough to learn for you if you have a dynamic languages background. Generics add flexibility and some magic to boringly static Swift. However, Pawel will not go into details of programming language architecture, but rather show cool, motivating examples of every day use of generics.

Join Janie as she goes over some of the basics of GPU programming to make this more approachable.

Eliasz has been using ReactiveCocoa for past 2 years. Starting with Objective-C implementation, then jumped right into Swift. He's noticed that many of you are afraid to get into amazing world of FRP, so he wanted to share with you that this topic can be really enjoyable. Everything done in gentle way that will be well received by you if you're completely unfamiliar with FRP.

Join Zsolt and learn on the tools that they've built and the challenges they've faced (and how they've overcome them) to make this possible.

This talk aims to save those unlucky teams who are struggling with little to no access to professional designers by presenting the (tongue-in-cheek) Rules of Visual Design for Developers! They are rules that make sense even to a simple programmer like Lasse - rules of thumb that most often lead to a pretty good outcome.

In this short talk, Paul will show you how to unit test your code using Playgrounds, how to make use 3rd party libraries and generally how to avoid the excuse of testing being too hard :)

Get your Xcode ready and follow along.

In this talk you'll learn why Swift relies so heavily on value types and why it matters in practice. You'll then move on to protocol-oriented programming, and Paul will demonstrate how it helps you re-architect your code to be flatter and more composable. Finally, you'll get a lightning fast introduction to functional programming, and how tools like flat map and reduce can help make your code clearer and simpler.

Those three are all useful to know by themselves, but the real magic comes when they are used together, so once you understand the basic components you'll learn how to put them together so you can write natural, idiomatic Swift.

Please note: You will need to have Xcode 8.2. prior to attending this workshop.

With Kitura you can quickly build a web app on macOS or Linux, and deploy it to the cloud.

Join this workshop to explore server-side Swift hands on with the development team who wrote Kitura, and learn why Swift might be a great choice for your next backend project.

Ian and Chris will cover setting up Kitura, writing a simple app, connecting it to a database, and deploying to the cloud. You'll learn new skills to take your Swift knowledge to the next level.

Find out more on Kitura here and here.

IMPORTANT If you're running macOS, you will need to install the latest Xcode 8 in advance. Participants running Linux do not need to install anything. Participants running Windows... cannot participate :-)

In Objective-C you can achieve similar clear and correct expressive power if you sacrifice concision, with a mixture of inheritance and blocks, or by using the visitor pattern. Due to the massive amount of boilerplate you need, you don't reach for these patterns nearly as often as you should. However, you have a tool to manage boilerplate in Objective-C -- preprocessor macros! Despite the limitations of the macro substitution system, with a few macro tricks, you can build a massive macro that can give us algebraic data types with none of the boilerplate. You can declare our types just as you would with Swift enums!

ONE_OF(PIBarCode,

CASE(QrCode, NSString *, code),

CASE(Upc, NSNumber *, num1, NSNumber *, num2, NSNumber *, num3, NSNumber *, num4)

)

In this talk, Brandon will cover why algebraic data types matter, how it's possible to represent them in Objective-C (albeit verbosely), how you can remove the verbosity with macros, and the downsides and upsides of using this one-of macro.

Brandon is passionate about finding and sharing ways to write clean, maintainable code, increasing our industry's productivity. Features of modern programming languages, like Swift's enum, helps you to write correct code on the first try -- functional programming can get us there.

Moderated by Paul Ardeleanu and Jorge Ortiz Fuentes, this is a not-to-be-missed end of day 1!

Join us in Ctrl as Paul Ardeleanu kicks off the conference!

Whether you are an educator, working in a team, or ‘just’ teaching yourself, this talk will give you better tools for dealing with complexity. Catja will explore learning styles, motivation and coder’s block, practice and best practice, as well as involving the community and giving back to it – using the rather intimidating CoreData framework as an example.

(1) associate a key with a value and

(2) get some value given a key if such a value exists.

That's basically it. Caches tend to appear in layers. In a CPU, memory reads check L1, then L2, then L3, then RAM. When you want to load an image, you first check RAM, then disk, and finally network.

In a mobile app, if you don't nail your cache code, your users will suffer. Excessive networking causes both battery and data-plan drain. You can help ensure a clean correct implementation by combining caches. Given two caches A and B, A on-top-of B means first check A, fallthrough to B, then write back to A. Now you can define a monoid for caches. Monoids imply easy composition. Easy composition means reasoning about our code becomes easy.

Such an abstraction isn't possible to express both statically and generically in languages like Objective-C and Java, but you can with Swift's strong type system. The caching library Carlos provides the foundation upon which you can build prefetching and other useful transformations. Adopting such a system simplified our codebase: Caches became reusable legos. But the complexity doesn't just all go away, it's just hidden. When an abstraction is so nice, it's tempting to think of the actual caches and cache glue as black-boxes. There was once a reference cycle inside the library that led to large bitmaps leaking and phones running out of memory. It's important to actually think about the implementation details in detail, since these are your building blocks for the rest of the system. When your building blocks are stable, your building is stable.

Caching and prefetching are necessary for mobile apps. In this talk, Brandon will share with you how to think about caches as monoids, how a monoidal caching system can simplify our jobs as software engineers, and what real-world problems you ran into when putting such a system into production.

equinux AG makes Live TV for macOS, iOS and tvOS, Mail Designer Pro and VPN Tracker for macOS and several other apps on two or more platforms. Adrian will be sharing their experiences, as well as the pros and cons of different approaches.

Adrian will also explore the business and marketing aspects of a universal app, versus separate apps.

In this session, the original author of Swinject, the most popular dependency injection framework in Swift, will instruct the basic concept and advantages of dependency injection, and demonstrate its practical applications.

The talk covers:

• Tight coupling / loose coupling

• Inversion of Control (IoC)

• Initializer/property/method injections

• Testability with external systems and mocking

• Dynamic dependency injection with a container

• Static dependency injection in Cake Pattern

Join Lasse as he explains the fundamentals of each of these technologies along with their respective pros and cons through a concrete example of an iOS app and tvOS app negotiating to share authentication tokens. After all, there's hardly anything more annoying than "typing" your email address and that super-strong, hard-to-guess password using a Siri remote so let's replace all that cumbersome input with a simple confirmation dialog.

Then you’ll explore some techniques for stream-lining the process of writing and working with tests - and how JetBrains’ AppCode can mitigate many common pain points.

Swift itself brings some new tricks to the table that can allow you to rethink the traditional process of TDD - and question whether you even need the tests at all!

Chris and his friends built buddybuild, which makes it simple to automate these tasks, by removing the complexities previously involved when cobbling together disparate build, deployment feedback and crash reporting systems. Enabling you to focus on what you do best - building your apps.

In this workshop, Chris will walk through using buddybuild to build an iOS app, add tests, set up code signing, send builds to out to test groups, collect testers' feedback and crash reports, then ultimately submit the app to the App Store.

In just 90 minutes, you'll learn how to take your app from source code to App Store submission.

Easily follow along during the workshop using this sample project.

Miguel will share with you some tools, practices and changes they've applied at Peak to improve developer productivity and solve common problems mobile developer teams have. Their iOS team is made up of 2 app developers, and 4 content developers focused on iOS and Android. The company can't afford to spend a lot of time building tools and changing practices, but they do the minimum amount to greatly improve their ability to deliver:

• Minimal QA and release process

• Smart Continous integration

• Manage localizations with a minimal CMS

• Dealing with many new in-progress localizations

• Refactoring to support ABTesting

• Feature switches

• Demo mode (for Apple Retail Stores)

• Building smart in-app developer menus

• Team collaboration to productivity issues

GraphQL is a product-developer-friendly and efficient method for fetching structured data from a server, designed to be an alternative to REST. It was developed in 2012 as an internal project at Facebook, open sourced last year, and is now being used by an increasing number of well known companies.

An important benefit over REST is that it allows clients to ask for the exact data they need, without the server sending extraneous results or having to perform extra roundtrips to fetch related objects. This is especially important for mobile apps, because cellular networks can be bandwidth constrained and often suffer from high latency. It also makes it possible for a single server endpoint to support multiple versions of your app, without explicit versioning of your API.

In this talk, Martijn will discuss why GraphQL is such a great match for mobile development, and talk about his efforts to build an open source GraphQL client for iOS, written in Swift. In particular, Martijn will explain how the client takes advantage of code generation and the strongly-typed nature of GraphQL to enable static type safety from the server to the UI.

Typically explained by way of sophisticated, but often also complex functional reactive programming frameworks, such as ReactiveCocoa and RxSwift, it can be difficult to see the simple principles underlying functional reactive programming. In fact, these principles are sufficiently simple that they can explained by building a functional reactive programming library from scratch.

Join Manuel in his journey to illustrate how you can construct your own lightweight functional reactive programming library out of simple components using Swift’s support for protocol-oriented programming. Moreover, he will share with you how to use this library to design and implement the change propagation between the model and view components of a Cocoa app. All of this is illustrated with concrete Swift code taken from a simple iPhone application whose source code will be made available.