IOT and Event Based systems can process huge volumes of data. Which typically needs to be stored and read in near real time for event processing, in addition to being read in bulk to feed data hungry learning systems. Apache Cassandra provides a high performance, scalable, and fault tolerant database platform with excellent support for time series data models typically seen in IOT systems. It's millisecond (or better) latency can support systems that react to events in real time, while scalable bulk reads via batch processing systems such as Apache Hadoop and Apache Spark can support learning applications. These features, and more, make Cassandra an ideal persistence platform for modern data intensive, event driven, systems.

In this talk Aaron Morton, CEO at The Last Pickle, will discuss lessons learned using Cassandra for IOT systems. He will explain how Cassandra fits into the modern technology landscape and dive into data modelling for common IOT use cases, capacity planning for huge data loads, tuning for high performance, and integration with other data driven systems. Whether starting a new project, or deep into the weeds on an existing system, attendees will leave will leave with an understanding of how Apache Cassandra can help build robust infrastructure for IOT systems.

At this very moment, there are over 5 billion people tapping and swiping on their mobile phones in every corner of our planet. There are people in Sri Lanka tapping and swiping, South-Africa, Ecuador and Tanzania. The Albanias and Swedes, also busy tapping and swiping.

As a technologist, your aim in life is to capture as many of these tappers and swipers as you can. Given that there are only about 22 million developers in the world, it is likely that the tappers and swipers will not at all be just like you. Building a product for people like you, therefore, greatly limits the size of your total addressable market - which in short, is really bad business.

We know that startups co-founded by designers are far more likely to succeed. But why is this? What exactly do these mysterious Design Creatures do, and more importantly, what can you learn from them to help your product win the tapping and swiping game?

Join Anna for an entertaining, practical and example packed presentation that will absolutely change the way you view the role of design in the making of your next product.

There are many advantages to using vector-based assets in your Android apps — smaller binary size, faster loading, easier support for all pixel densities, dynamic drawing, and more ways to animate. Despite the upsides, SVGs and VectorDrawable assets are more complex to author and use.

Luke and Marc explore everything needed to create, export, and implement SVGs and VectorDrawables on Android, including common issues and their remedies.

The Internet of Things is undeniably here. In the last year we have heard tell of of security cameras, dishwashers and even ovens roaming the internet unsupervised.

As a consultant and writer about the Internet of Things, I have worked to bring my experience from 20 years in manufacturing and internet security to the IoT world. This presentation will cover the tools and techniques I use to build secure, reliable and rapidly updatable IoT devices.

The techniques covered are applicable to both the simplest embedded devices with no general-purpose OS, and more powerful devices running Linux or Windows.

Implementing IoT projects doesn't have to be difficult, time consuming and expensive.

MicroPython brings Python 3 to embedded platforms, and since Python is one of the easiest languages to learn, and there are WiFi SoCs available around $5, this is a great way to get started in IoT! We'll look at:

• What is a System-on-a-Chip (SoC) with some specific examples based on the ESP8266 and ESP32 WiFi SoCs
• Why Python? A quick look at C and IoT vulnerabilities
• How to install MicroPython and communicate with the ESP SoC to write programs
• What it is capable of and what things are being developed for it
• How to contribute to the MicroPython project

At WWDC this year, Apple announced their CoreML and Vision frameworks. These allow you do easily implement machine learning models inside your app, running on the GPU on an iPhone. Suddenly a world of machine learning is possible in ways that it wasn't before.

In this talk, you'll see a real world example written in just hours which implements a freely available object classification model to find out who is a good dog. Silly as this sounds, it shows the power now at our disposal.

We’ll look at what you need to do to build a simple app, and then dig into some of the innards of machine learning to see what we need to do to create something really useful.

With a building bursting at the seams and a move to a new location some years away one of our Hackathon teams came up with an idea to improve the “facilities” for the building staff. Initially what started as a bit of a joke soon grew into a fully-fledged idea of building a comprehensive IoT solution that can constantly keep check of the usage state of the showers and toilets at Seek. Not just for morbid curiosity, but to help maintain better cleaning and hygiene of the facilities and also help people use them more effectively. The solution was met with great success and is in the process of becoming a permanent solution in the building.

We will cover:

• What IoT devices we found effective
• How you can leverage the capabilities of AWS to rapidly stand up complex solutions without investments in Infrastructure
• Which “areas” of Seek are more popular than others!

As the future approaches us more and more rapidly, we feel the impact of the choices we make today sooner and with more force. This talk offers practical advice on how to drive and deliver value to a business continuously by building systems that scale to the needs of a business working towards an unknown future.

Did you know that less than 30% of the internet population speaks English? And this percentage is slowly decreasing as cheaper smartphones become ubiquitous and new users from Brazil, Russia, India and China come online everyday. If you want to reach this global market, it is important to translate your mobile apps into your user's native language. This is why Canva decided to build a localised app from the get go.

In this talk, we will present a quick introduction to internationalisation and the key things to consider when localising your mobile app. You will learn about the various tools available to enable translations at scale and how those integrate with your app. You will also get some hands-on, practical information about the unique development challenges presented by languages that have different pluralisation rules to English and languages that are written from right-to-left. We will show some examples of our internationalisation approach in our iOS app. Lastly, we will wrap up with how this fits into our Feature development and Release process. Expect lots of practical advice that will help you get started on localising your own mobile app.

Diving into the feasibility of using a single code base for generating multiple front-end applications.

We'll discuss using React and React-Native for building apps that provide a consistent experience across native, mobile and desktop web.

Using React and React-Native as the UI layer upon a shared JavaScript core codebase can greatly improve your organisation's delivery of new features to customers.

We'll talk about our migration strategy for the new apps replacing our existing apps, piece by piece. Not slowing down our continuous release of features to customers while replace the apps.

Elm, for a long time the flag bearer of Functional Reactive Programming on the web, recently switched to a simpler pure functional architecture, citing 'ease of use'. Those of us that have worked on complex RxSwift/ReactiveCocoa apps can sympathise with this - using FRP injudiciously in your app can make the code difficult to understand and near impossible for new developers to pick up.

So are we able to apply some of the techniques and patterns from Elm into Swift iOS apps? It turns out the Elm architecture is a really great fit for Swift - it allows us to:

• reserve our FRP hammer for the use cases that make the most sense
• separate out a simple, consistent, and highly testable pure functional core, and
• provide a flexible, yet easily understood & applied set of architectural building blocks.

This session will cover the basics of implementing and using an Elm-style architecture in a Swift app, will include lessons learnt in a real-world implementation, pitfalls/benefits, and implementation considerations should you adopt the approach in your own app.

The importance of good software testing in the larger software development world is taken as a given, yet in many IoT projects, software testing is done in an ad-hoc manner if it is done at all.

In this talk I will show how there are multiple techniques for software testing your IoT projects, when each of these techniques is appropriate, and hands on examples of how to use them. I will show how Test Driven Development can be used to improve the reliability, reproducibility and speed of development of your IoT projects.

When designing a mobile app, specifically on iOS, one must consider Apple’s Human Interface Guidelines. These are the set of guidelines that needs to be followed to create an app that is cohesive with the rest of the operating system. The chances are, most people in the industry are familiar with the guidelines. However, there are items that seem to be commonly ignored. The talk will go through few of those items and at the end discuss the technical impacts for not following the guidelines

One of the items is the use of the launch screen. In many apps, the launch screen is used as a splash screen, with some variation of a logo and sometimes with fancy animations. However, the launch screen actually has a different purpose, which is to be a static state to provide a seamless transition between the launcher and the app. Thus, the launch screen should look like blank state of the first screen of the app. For example, look at the launch screens of Facebook and Twitter, in this case Facebook follows the guidelines.

Following the design guidelines not only affects the user experience side of the app, it also has a technical impact. An example is using a hamburger menu. Developers tend to use a third party library, which reduces maintainability. Third party libraries are of course useful, but using them to purposely ignore the guidelines is questionable. Moreover, there is an accessibility impact of using non-native elements. Adding accessibility support manually to custom UI elements is another overhead to consider.

Aeons ago, in the year 2000, Joel Spolsky proposed the Joel Test, a set of questions that he recommends all software development teams should be able to answer “yes” to, in order to help them build great software.

This talk takes a look at these questions through technical, people, and process lenses, to see if they are still relevant in software development today. It investigates whether we should add any new questions, given the changes that have occurred in the industry in the last 17 years. And looks in to changes to these questions to make them more relevant for development of mobile products.

This session will give a practical demonstration of how to convert an existing deeply nested view hierarchy for a typical Android app into a more efficient (in terms of measure and layout performance) hierarchy using ConstraintLayout. I will also show how you can use the features of the ConstraintLayout library to create view hierarchies that enable rich animations with little effort.

Automated Acceptance Testing is one of the essential ingredients of a healthy agile software practice. Unfortunately, attempts to adopt this on mobile usually result in the creation of slow, brittle and highly complex UI tests - where did we go wrong?

This approach is a far cry from the original idea of acceptance testing and does little to improve the reputation of mobile development. Automation is meant to bring confidence – but used in this way, it creates more problems than it solves. This leaves development teams and businesses left on a seemingly never ending quest for the next thing - usually in the guise of a new framework promising to be better than the last e.g. KIF, Calabash, Appium etc.

React Native allows developers to create native cross-platform using JavaScript, or really anything that will compile to JS C#, TypeScript, or even F#. But why would you use React Native? How run-time typed language like JavaScript be a better choice for developing apps than say, Swift, Java, Kotlin, C# ( Xamarin ) or C++ all compile time static type checked languages. Firstly is just that, there is no need for a compile step, React Native can update the JS without having to reload compile and replace the previous application. Compiling an app everytime can take a long time for a small project this might be 1-5min, but larger apps can easily take as long as 45 minutes or more to build a single app.

In this talk, we will explore how features like hot code reloading allow for much faster edit and run cycles, how you can use tools like Flow or TypeScript to add type safety without incurring the long compile times found in more native methods. To Prove the how simple and fast React Native is to builds apps we will create a simple app live on stage. To top it all off, you can even embed React into existing Native Apps, avoiding the need for total rewrite.