Despite order of magnitude advances in hardware, significant improvements in software development and execution remain elusive. Modern practices of Continuous Delivery; Functional Programming; Microservices; Data Driven; NoSQL; Event Sourcing; Accelerated Development; Mobility; IoT; SAAS are only possible due to significant improvements in hardware.

What if FAST Hardware => FAST Software? Is this talk we look at ways in which simple design allows us to exploit the power of modern hardware. We begin with a quick look at hardware today and tomorrow and why software slows it down! We the argue through examples that aligning the software and hardware architecture often leads to much simpler, and faster solutions.

This session aims to provide .NET developers with enough information to get started with Cordova for cross-platform development, while still using the tools familiar to them.

The talk will be a live demo of a hello world Cordova project on the Windows Phone 8 and Windows 8 platform. It will demonstrate the basics of the Cordova developer workflow and how to use the best aspects of Visual Studio to develop and debug the application.

The Internet of Things (IoT) is the integration of the physical world with the digital world using open standards, enabling us to build new classes of applications that help to make people safer, healthier, and better informed.

We need to turn our minds to solving the worthwhile challenges that are as-yet unsolved in these new classes of application; in doing so, we are solving problems that affect the vast majority of the world’s population, for the physical world is where they live.

My objective in this talk is to show you how easy and rewarding it is to get involved with building the IoT, using some practical examples of technology along the IoT spectrum:

• A long-range radio modem for integrating remote sensing devices with the Internet.
• An inexpensive image recognition module capable of tracking many objects at high speed.
• An autonomous flying robot that can find a lost bushwalker and drop a bottle of water to them. This example will draw on my experience building from scratch a quadcopter entry for this year’s UAV Outback Challenge uavoutbackchallenge.com.au

Using these pieces of the IoT, I will show some examples and demonstrations of what can be done by applying and extending the technical skills you already have, by leveraging the very approachable open source hardware and software that’s available. I’ll include some pointers for what technologies to use and how to get started.

We’ll explore the development of the Fireballs in the Sky app, designed for citizen scientists to record sightings of meteorites (“fireballs”) in the night sky. We’ll introduce the maths for AR on a mobile device, using the various sensors, and we’ll throw in some celestial mechanics for good measure.

We’ll discuss the prototyping approach in Processing. We’ll describe the iOS implementation, including: libraries, performance tuning, and testing. We’ll then do the same for the Android implementation. Or maybe the other way around…

References:

Fireballs in the Sky app (iOS: https://bit.ly/1eZ68BA, Android: https://bit.ly/1eK6X1S). Fireballs in the Sky website (https://www.fireballsinthesky.com.au/), sponsored by Curtin University.

Exceptions are part of API and system design, but often very little thought is given to the Exceptions that are raised, how they are named, and most importantly how the clients of your API or system are supposed to react.

• The typical developer approach to exceptions, and why developers act that way.
• Checked and unchecked exceptions – enforcing the API or just getting in the way
• Fourteen different exceptions that will pretty much cover anything any system or component will need to communicate.
• Making an exception useful, what does a client want to know when an exception is raised?
• The resurgence of HTTP response codes in the wake of REST,
• the ones you should know
• a couple of interesting thoughts on API versioning and health checks
• exceptions in asynchonous processing

Parametricity builds on the work of Philip Wadler and Danielsson et al. It is a robust, ubiquitous technique to improve code readability in all programming environments.

This talk will explore the specific details of parametricity. Some of the theoretical underpinnings will be examined with a heavier focus placed on their practical application. We will be using several programming languages; Haskell, Java and C#.

After this talk, expect to have a clear understanding of the reasoning process that is increasingly used by professional programmers. You will also learn why there is consistent dismissal of degenerate methods of code comprehension. You will see why so many open-source projects are able to work so well with many committers who have such diverse insights. We all agree on one unifying point; parametricity is how to achieve robustness and we won’t give it up for anything.

You too, can achieve this goal in your project

References:

1. Theorems for free!, Wadler, Philip, Proceedings of the fourth international conference on Functional programming languages and computer architecture, pp 347 – 359, 1989, ACM
2. Fast and loose reasoning is morally correct, Danielsson, Nils Anders and Hughes, John and Jansson, Patrik and Gibbons, Jeremy, ACM SIGPLAN Notices, vol 41, num 1, pp 206 – 217, 2006, ACM

Almost all apps rely on APIs, no app is an island, entire of itself. We want to keep our apps slick and simple, pushing complex logic to the server, allowing iOS devs to focus on shiny new user experiences. All the hipster developers are using microservices and deploying to the cloud, but what does that mean for your front end apps and APIs? At realestate.com.au, we’re building simpler apps backed by smarter microservices using REST, hypermedia and HATEOAS, not just object.to_json.

This session will demonstrate how to quickly build iOS apps to discover, consume and navigate these services using HAL JSON, and some nifty Objective C libraries for networking and functional-reactive goodness in a way ‘future you’ will be thankful for.

Developers who are familiar with open source will likely be aware of pull requests, which were created and popularised by GitHub as a way of providing some automation, visibility and social interaction around merging software changes. What is less talked about is the use of pull requests for commercial/private/proprietary software development, which not only yields the same advantages as with open source development, but also a lot more.

In my experiences so far I’ve found that the single most effective change I have introduced to a software team that has improved the quality of software output is to introduce pull requests. It also has a positive effect on other things like improved collaboration and collective code ownership.

This talk will take a deep-dive into pull requests and explore advantages, gotchas, integrating with a continuous delivery workflow, a range of tips based on my experience so far using them on open source and commercial projects and some tips on how to get started.

We’ll explore the development of the Fireballs in the Sky app, designed for citizen scientists to record sightings of meteorites (“fireballs”) in the night sky. We’ll introduce the maths for AR on a mobile device, using the various sensors, and we’ll throw in some celestial mechanics for good measure.

We’ll discuss the prototyping approach in Processing. We’ll describe the iOS implementation, including: libraries, performance tuning, and testing. We’ll then do the same for the Android implementation. Or maybe the other way around…

References

Fireballs in the Sky app (iOS: https://bit.ly/1eZ68BA, Android: https://bit.ly/1eK6X1S). Fireballs in the Sky website (https://www.fireballsinthesky.com.au/), sponsored by Curtin University.

We build increasingly sophisticated architectures and web applications but rely on HTTP and the humble string to hold them together. We apply widely understood data formats (XML, JSON) to our requests and responses so both sides understand structure but how does each party declare its expectations of the content of the message? What’s more, how do we avoid a excessive coupling between components and the data formats they share?

Attendees of this talk will come away with a better understanding of why it is so important to think about integration and an idea of some of the ways we can get smarter about the division of responsibilities in our systems. This will include tools and techniques like consumer contracts and generative testing that allow us to better reason about uncertainties, test our assumptions and localise faults in our systems.

Organizations are gradually learning to stop fooling themselves.

The rise of agile development helped us focus on building smaller things. We stopped fooling ourselves about quality, about the designs of our solutions inside and outside, and most importantly, we stopped fooling ourselves that people wanted what we were building. Upon learning we were building the wrong thing, we learned that our concerns about quality and design were premature. The rise of Learn startup thinking helped us focus on learning faster. We’re now learning to build experiments not designed to be scalable or maintainable, but to be quickly deployable and to return more data that helps us learn faster. We’re learning that the hard part of software development is learning fast, not building fast.

This talk is about the rise of learning as a valuable activity. I’ll give examples of organizations that invest in experiments that take the cooperation of developers, testers, product mangers, infrastructure, sales, and marketing. At the end of these experiments organizations are left with no deliverable product and only the knowledge that the product they’re thinking of should or shouldn’t be built at all.

In the past we’d have called this waste. We’ve invested lots of money and time and received nothing. But today more and more organizations are realizing we’re playing a longer game. They’ve learned to stop fooling themselves and work together to learn more, faster.

Toyota / Lean people always start with the question: What problem are you trying to solve?

Is this not the question that most innovators should start with?

Given the Toyota-influenced origins of Lean Startup, given the drive toward more systematic approaches to innovation with various canvases and Design Thinking, how might we apply the Toyota Kata approach to both structure innovation as well as teach how to coach innovators?

I’ll use recent innovation experiences as examples of how this might work.

Ever tried to write complex front-end code using Javascript and JQuery? Ever inherited Javascript soup? So many languages now use Html for their client UI – Ruby, Php, .Net, Java to mention a few. We can use Cordova to package Html applications for native app-store delivery. Yet so many end up with unmaintainable piles of javascript.

In this session I’m going to show you how you can use Angular to tame your front-end code. Starting with a browser, a text-editor, and a simple piece of Html, we’ll use it to create a rich yet simple controller. We’ll write some Jasmine tests to confirm what’s going on and mock out some Http calls along the way.

By the end of the talk you’ll have an understanding of Angular controllers, directives, modules, resources and factories, and how to test them all using Jasmine.

In this session, attendees will learn about the implementation of a micro-services architecture at REA. This will include the drivers for choosing to implement micro-services, how the adoption of micro-services has driven changes to infrastructure, deployment, testing, monitoring and support, and even team structures. We’ll share lessons that we have learned and things that have gone well and less well, and some of the approaches and tools that we’ve adopted to make the approach sustainable.

The session will be presented as a case study of a set of ongoing projects at REA which are transitioning from legacy monolithic applications to an application and integration architecture with small independently-deployed services. We will provide participants with references to existing industry material for further references (e.g. blogs, upcoming books).

Picture a light-sabre duel between Automation & Virtualization. Virtualization had the upper hand for a while until Automation used the powers of Chef & Puppet to drive Virtualization into a corner. Before putting away his light sabre Virtualization says: “You can’t win Automation. If you strike me down I will become more powerful than you can possibly imagine.” After which Virtualization was obviously brutally murdered by Automation.

Virtualization has however returned in the form of Docker. Docker forces us to completely rethink what an application is. Just like a Virtual Machine a Docker Container is a self-contained unit with everything needed to run your application: (Linux) OS, runtime environments, dependencies and your code. Unlike VMs it does not incur the same overhead: disk space is shared where possible and there is no CPU overhead. From the outside a container is nothing more than a blob that accepts network connections on a port and possibly talks to other blobs on other ports, possibly a disk somewhere.

This opens up extremely interesting use cases: Running exactly the same setup on your laptop as in production; Private clouds; Heroku style deployments; But most importantly, making the Micro Service architecture actually feasible to run in production.

In this talk I will be explaining the core concepts of Docker and end with a demonstration of the features to show off its power.

Can reactive designs be implemented in any programming language? Or, are some languages and programming paradigms better for building reactive systems? How do traditional design approaches, like Object-Oriented Design (OOD) and Domain-Driven Design (DDD), apply to reactive applications. The Reactive Manifesto strikes a balance between specifying the essential features for reactive systems and allowing implementation variations appropriate for each language and execution environment. We’ll compare and contrast different techniques, like Reactive Streams, callbacks, Actors, Futures, and Functional Reactive Programming (FRP), and we’ll see examples of how they are realized in various languages and toolkits. We’ll understand their relative strengths and weaknesses, their similarities and differences, from which we’ll draw lessons for building reactive applications more effectively.

We’ll explore the development of the Fireballs in the Sky app, designed for citizen scientists to record sightings of meteorites (“fireballs”) in the night sky. We’ll introduce the maths for AR on a mobile device, using the various sensors, and we’ll throw in some celestial mechanics for good measure.

We’ll discuss the prototyping approach in Processing. We’ll describe the iOS implementation, including: libraries, performance tuning, and testing. We’ll then do the same for the Android implementation. Or maybe the other way around…

References:

Fireballs in the Sky app (iOS: https://bit.ly/1eZ68BA, Android: https://bit.ly/1eK6X1S). Fireballs in the Sky website (https://www.fireballsinthesky.com.au/), sponsored by Curtin University.

Using task boards or story walls is a key Agile practice, but are you making the most of it? Visual Management is more than just putting cards on a wall, it is a growing style of management that focuses on managing work only by what you can see rather than reports or paper being shuffled around. Visual Management allows you to understand the constraints in the system, mitigate risks before they become issues, report on progress from the micro to the macro. Visual Management can also be used to demonstrate to customers and clients where the work they care about is at. This presentation is all about taking the management of your work to the next stage of transparency. Discover:

• How to identify when your story wall isn’t telling you everything and how to adjust it
• What the three different types of story walls are and which one is more suitable to certain circumstances
• Different ways to visualise your product backlogWhy queue columns and limiting work in progress is so important regardless of whether you are using Scrum or Kanban
• How symbols and tokens can be used to give more information
• What else can you use other than story walls to visualise information
• How to ingrain Visual Management into both the team and management structures of your organisation
• Visualising Your Quality, Testing and Team
• What is systemic flow mapping and why is it important

In this session, attendees will learn about the implementation of a micro-services architecture at REA. This will include the drivers for choosing to implement micro-services, how the adoption of micro-services has driven changes to infrastructure, deployment, testing, monitoring and support, and even team structures. We’ll share lessons that we have learned and things that have gone well and less well, and some of the approaches and tools that we’ve adopted to make the approach sustainable.

The session will be presented as a case study of a set of ongoing projects at REA which are transitioning from legacy monolithic applications to an application and integration architecture with small independently-deployed services. We will provide participants with references to existing industry material for further references (e.g. blogs, upcoming books).

For some years, there has been a quiet renaissance in a form of software development once relegated to niche fields of academia and computer science: functional programming. Functional languages like Scala and Clojure are attracting significant attention from developers, and aspects of functional programming are creeping into established development languages/platforms like Java and .Net. But what is the catalyst for this renaissance? The increasing scale and sophistication required of custom software development has led people to reprioritise the benefits of functional languages (e.g., immutability, expressiveness) as a way of increasing code quality, boosting development productivity and reducing complexity. This presentation is aimed at those unfamiliar with functional programming and will describe the reasons for it’s recent resurgence and why many IT organisations should be considering trialling functional programming alongside their existing development languages.