Automated testing is hard but necessary. A fully automated testing system requires serious investment and attention to be successful. LMAX has been committed this approach since its inception 6 years ago and learnt many hard lessons along the way. We will share the highlights our experience of testing a large and complex system including; the different types of testing that we apply, design patterns to write robust tests, tools (some open source) built to support the process and a few war stories.

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).

New technologies and a need for innovation mean we test within a rapidly changing and evolving environment. But no matter how much we estimate and plan, something seems to throw these plans into chaos. Agile helps us to minimise this disruption through an iterative and incremental approach but regardless we seems to get surprised and frustrated by change.

Nassim Nicholas Taleb argues most IT projects live in Black Swan territory. A black swan is a metaphor for an unpredictable event that in hindsight was preventable. Sound familiar? Software testing is the ultimate black swan challenge. Our very role is to search for unpredictable events. The irony is that in the process of hunting for these black swans, our testing itself becomes the target of black swans! For example, development takes longer than anticipated, business change their minds and bug retesting takes longer than hoped. These black swans (well maybe black cygnets) impact our ability to accurately estimate and plan.

Taleb argues that instead of attempting to improve prediction we are better off developing a more robust approach to change. It’s time for a rethink in testing. It’s time to change our approach from one of control to one that embraces disruption. One in which testing becomes stronger and more valuable as a result of change. But how? The key lies in developing a testing mindset and developing tester skill. In this talk I will discuss how to helps testers become expert black swan hunters and how to develop a testing process that embraces disruption and welcomes change.

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.

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.

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.

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.

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.

Traditional web applications have typically followed a layered architecture; Presentation, Service, Business and Data Access Layers over a relational database. While such applications often have a great deal of capability, there are practical limitations on how well they grow, evolve and scale in a dynamically scalable environment like the cloud.

Come and watch John Azariah and Mahesh Krishnan share their practical experiences of how Modern Architectural Patterns such as CQRS, Queue Centric Workflow, Event Sourcing and Map Reduce combine with NoSQL databases among other things to address issues such as reliability, flexibility and scalability in modern real-world cloud applications.

This exciting talk will showcase a Twitter-like social application, written using these patterns running in the cloud.

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.

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.

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.

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

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.

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

A large percentage of mobile apps use SQLite relational databases for persistence (such as Core Data on iOS), but are they always the right option?

NoSQL databases offer a compelling alternative in web applications, but developers seem firmly attached to a relational model on the device. There are a number of scenarios where this can deliver sub-optimal outcomes, such as search performance and data sync. This presentation will cover these issues and present a few alternatives, focusing on practical demonstrations of specific NoSQL approaches on iOS, however the concepts are highly applicable to other mobile platforms.

Microservices and rich client javascript apps are all the rage. As we move away from monolithic software into the world of specialised services, how do we ensure that integration testing does not become more of a problem than the original monolith was?

Using the example of how “pacts” were implemented at realestate.com.au, attendees will learn how to use automated consumer driven contracts and throw away their integration tests.

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

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.

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.

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).

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.

Functional Programming has shown the benefits of removing mutation and side-effects, resulting in programs fundamentally simpler and more composable. Nonetheless, many of these programs still rely on applying side-effects to external systems such as databases, file-systems or external services. This talk looks at applying these ideas to systems architecture, and how it can make whole systems fundamentally simpler to build, operate and reason about.

Functional approaches to architecture have other key benefits such as being naturally suited to audit and reversion of state to previous versions. They tend to have lower operational risk associated with them.

This talk looks at the history of systems built with an underlying functional architectures such as journaled file-systems and databases, event sourcing, and content-addressable storage, as well as the application of these ideas in programs such as Lucene and git.

We’ll show that there is an underlying philosophy of FP that can be brought to most aspects of system design and architecture, even while presenting a mutable face to the world.

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.

Relational databases are a pretty high-level abstraction to start with. Chuck an ORM over the top, and the temptation to treat them as a magic box is understandable. We all know it’s wrong, sometimes we even kid ourselves we’ll get a specialist in for a week at the end for a design review, but there’s this app to build, and these sprints to run, and while the abstraction holds everything’s good. Abstractions never hold.

In this talk we’ll go beyond the basics and run through ten of the more common misconceptions developers have about relational databases, how they work, and some of the bear traps that lie in wait for the unwary. You will not leave an expert relational database designer, but hopefully you can avoid walking into some of the more common gotchas in future.

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.