Wednesday, 24 May 2017

Agile Experiments in Machine Learning with F# - Mathias Brandewinder




Just like traditional applications development, machine learning involves writing code. One aspect where the two differ is the workflow. While software development follows a fairly linear process (design, develop, and deploy a feature), machine learning is a different beast. You work on a single feature, which is never 100% complete. You constantly run experiments, and re-design your model in depth at a rapid pace. Traditional tests are entirely useless. Validating whether you are on the right track takes minutes, if not hours.

In this talk, we will take the example of a Machine Learning competition we recently participated in, the Kaggle Home Depot competition, to illustrate what "doing Machine Learning" looks like. We will explain the challenges we faced, and how we tackled them, setting up a harness to easily create and run experiments, while keeping our sanity. We will also draw comparisons with traditional software development, and highlight how some ideas translate from one context to the other, adapted to different constraints.

Tuesday, 23 May 2017

C# Scripting in the .NET Core world - Filip W





While still being relatively niche, over the recent years C# scripting has grown to become a first class citizen in the Roslyn compiler and can now be enjoyed and applied in your applications in various ways.

Together, we will dissect what’s going on under the hood in C# scripting and how you can make use of it in the cross platform, lightweight, .NET Core world (which, by the way, creates a perfect environment for low ceremony C# scripting). We'll also have a look at scripting via the new .NET CLI, how you can integrate it into your everyday development workflows and how you can debug the script assemblies.

Sunday, 21 May 2017

Big Scrum: Scaling Scrum with Nexus - Martin Hinshelwood





The proliferation of scaling frameworks shows there are real challenges in scaling agility, and the solutions don’t seem to involve inventing yet more frameworks or formal processes.

So then, why is it so hard to find success in agility at scale? Large scale agility can be found in exploiting Scrum’s simplicity while emerging and sustaining technical excellence. Something that sounds so easy shouldn’t be so hard, and for some it isn’t. This session highlights successes in growing large scale agility using Big Scrum while maintaining technical excellence to deliver value faster.

Saturday, 20 May 2017

Serverless F# with Azure Functions: fsibot goes nano-services - Mathias Brandewinder



Feeling a bit left behind by the whole micro-services hubbub? Fear not! This is your chance to get ahead of the curve, skipping straight to serverless nano-services, using Azure Functions.

In this talk, we will cut through the buzzwords, and explain what Azure Functions are, why you should care, and how beautifully they fit with a functional style of development. We will demonstrate the benefits of the approach on a real-world example, illustrating along the way some patterns, benefits and gotchas.

Friday, 19 May 2017

Programming Across Paradigms - Anjana Vakil



What's in a programming paradigm? How did the major paradigms come to be, and why? Once we've sworn our love to one paradigm, does a program written under any other still smell as sweet? Can functional programmers learn anything from the object-oriented paradigm, or vice versa?

In this talk, we'll try to understand what we mean (and don't mean) when we talk about programming paradigms, and the connection (or lack thereof) between the code we write and the paradigm we use. We'll take a closer look at three influential paradigms -- imperative, object-oriented, and functional programming -- and try to understand each in terms of its historical context and relationship to other paradigms. In doing so, we'll see that the dividing lines between these paradigms may not always be as clear as we tend to assume, and that “competing” paradigms may have more in common than we often acknowledge.

Whether code newbies or seasoned developers, we might walk away with a slight shift in our perspective on the paradigms we code in, giving us not only deeper insights into our favorite (or least favorite) programming worldviews, but also higher-level lessons for how to craft and understand our programs under any paradigm.

Thursday, 18 May 2017

Feature Branches and Toggles in a Post-GitHub World - Sam Newman



During the evolution of the ideas behind Continuous Delivery, many of us came to the conclusion that having branches for features was not a good idea, and resulted in some fairly problematic issues. This was contentious at the time, with lots of discussion around whether or not feature toggles or feature branching was the right way forward.

Roll on several years, and through Git and GitHub, branches are everywhere. Is this a problem?

This talk re-examines the role of feature branches and feature toggles, and looks at them in the context of new research and technology to try and distill down some sensible lessons in a post-GitHub, but hopefully not post-factual, world.

Wednesday, 17 May 2017

Idée Fixe - David Nolen



For an industry steeped in a mythos of innovation and invention, the path towards reliable software is often obstructed by a web of fixed ideas. Fixed ideas, by actively obscuring alternatives, lead us to inaccurately the weigh the risks and benefits associated with our choices whether they be of an engineering, managerial or business nature. Alan Kay famously quipped that a difference in perspective is worth 80 IQ points but in this talk we'll see that it's worth considerably more than that.


Tuesday, 16 May 2017

DevOps and Agility with Visual Studio, Azure and Scrum - Martin Hinshelwood



Agile is dead! Long live DevOps! Um.. ALM… um…

There has been a plethora of "agile is dead" of late posts yet the long list of failed agile that has caused it smell very little like agile. What was missing? Come and find out how to make a success of your agile project, and what will immediately spell disaster…

Paying lip service to a lexicon is no longer enough…

Monday, 15 May 2017

Debugging Under Fire: Keep your Head when Systems have Lost their Mind - Bryan Cantrill



As software is increasingly developed to be deployed as part of a service, the manifestations of defects have changed: the effects of broken software are increasingly unlikely to be felt by merely one user, but many (or even all) -- with concomitant commercial consequences. Debugging service outages puts everyone in an uncomfortable spot: operators must learn how to deal with the uncertainties of broken snowflakes, while developers must adapt their debugging techniques to the constraints of a production environment. And in all but the most immature systems, service outage denotes cascading failure: there is not one bug but several -- often in different components that are interacting in unforeseen ways. These technical complexities coupled with the high visibility of a downed service can lead to stress, confusion and (in the worst cases), panic. In this talk, we will address debugging during an outage, looking at not only specific technical challenges (and techniques to address them), but also the psychology, team dynamics and organizational challenges of debugging under fire.


Sunday, 14 May 2017

Meeting Resistance and Moving Forward - Linda Rising



It's "those skeptical people" who are most annoying. They don't seem to listen to our ideas. They usually start raising objections before we have even finished describing what we are thinking. They have a counterargument for every argument. What's to be done with "those people"? In this presentation, Linda will pull patterns from the Fearless Change collection plus the latest research in neuroscience to help you in the challenges you face with resistance.


Saturday, 13 May 2017

Serverless: the Future of Software Architecture - Peter Sbarski



With the release of AWS Lambda, there has been a sustained movement toward experimentation and the adoption of serverless architectures, which allow developers to build rich, scalable, high-performing, and cost-effective applications without having to maintain traditional multitier backends. In addition to being able to run custom code in a compute service such as Lambda, developers also have access to a dizzying array of powerful, single-purpose services. By composing and combining these services in a loose orchestration, developers can build complex yet easy-to-understand systems.

Drawing on his experience building a large serverless platform, Peter Sbarski explains how to create scalable applications using serverless architecture with AWS Lambda, API Gateway, and other services. Along the way, Peter covers the five principles of serverless architectures, establishing the core concepts that underpin serverless architectures, and describes patterns and practices for setting up, developing, and deploying serverless architectures.

Friday, 12 May 2017

The Many Meanings of Event-Driven Architecture - Martin Fowler



During my career, I've often people heard people describe their systems as "event-driven". But when looking deeper that phrase seems to lead to some very different architectural assumptions. On a recent workshop we identified four different patterns which tend to appear under the title of "event-driven": event notification, event-based state transfer, event sourcing, and CQRS. We feel that understanding and using these more precise terms will lead to better communication and decision making.


Thursday, 11 May 2017

The Async Arrow - Troy Kershaw


In object-oriented design, dependency injection is a well-known design pattern, although it's a complicated solution to the problem of decoupling. Functional programming offers a simpler way.
This talk examines dependency injection in object-oriented design, and explains how it's not required (nor desired) in functional programming. You'll also learn how a proper functional design eliminates the need for mocks and stubs in unit testing, enabling you to entirely reject the notion of dependencies.

You don't need to know Haskell or F# to attend this session; relevant syntax will be explained just-in-time. Object-oriented examples will be in C#.

Wednesday, 10 May 2017

From Dependency injection to dependency rejection - Mark Seemann


In object-oriented design, dependency injection is a well-known design pattern, although it's a complicated solution to the problem of decoupling. Functional programming offers a simpler way.
This talk examines dependency injection in object-oriented design, and explains how it's not required (nor desired) in functional programming. You'll also learn how a proper functional design eliminates the need for mocks and stubs in unit testing, enabling you to entirely reject the notion of dependencies.

You don't need to know Haskell or F# to attend this session; relevant syntax will be explained just-in-time. Object-oriented examples will be in C#.

Monday, 8 May 2017

Opening Keynote - Microsoft Ignite Australia - Scott Guthrie



Cloud technology is rapidly evolving, offering new ways to enhance productivity through organisational digital transformation. To harness this shift, and evolve your organisation’s capabilities, it’s more important than ever to invest and learn new skills to leverage the cloud. Join Scott Guthrie our Executive Vice President of Microsoft Cloud and Enterprise on Tuesday morning to kick-start Microsoft Ignite Australia. Scott will focus on how technology enables digital transformation and, along with guests, demonstrate new technologies and investments for you to leverage our technology to make change happen.

Sunday, 7 May 2017

Building Polished Xamarin Forms Apps - Rob DeRosa



Learn about UI enhancement tips and tricks to build a polished and production-ready Xamarin.Forms apps.

Saturday, 6 May 2017

Responsive Xamarin apps with Realm - Nikola Irinchev





Nick is part of the Realm Xamarin team and will show how easy it is to get a Realm-backed application up, running, and syncing. Some of the key concepts explored will be: - Deploying the Realm Object Server to an Azure instance - “Liveness” of Realm objects in the context of data binding - Sharing Realms between users - Realtime synchronization and conflict resolution The talk will be suitable for people who have no experience using Realm, but some experience with Xamarin.Forms is expected.

Friday, 5 May 2017

Next Generation Asynchronous Patterns in JavaScript - Jonathan Mills



With ES6 and ESNext we are no longer limited to simple callbacks when dealing with our asynchronous JavaScript code. This session will walk through four options for async patterns, addressing when to use each one and identifying the problems they solve.
We will start with a discussion of ES6 Promises and generators, continue with ESNext Async/Await, and close with a conversation about RxJS. Broaden your understanding of the available tools and start writing better asynchronous JavaScript today.

Thursday, 4 May 2017

The (Awesome) Future of Web Apps - Jad Joubran



The web is becoming more and more powerful everyday, especially with the launch of Progressive Web Apps. PWAs are experiences that combine the best of the web and the best of apps.

You can now build web apps that run from your home screen, receive push notifications & work offline.

Join this talk for an interactive introduction into the world of Progressive Web Apps.

Wednesday, 3 May 2017

There Be Dragons in the New JavaScript - Scott Allen



After two years of using ECMAScript 2015 features in live applications, I’ve come to recognize a few areas that developers can find confusing. 
There are also features with the potential to hurt the maintainability of the code for other developers, and degrade the performance of the application at runtime. In this session we’ll look at features like string templates, arrow functions, promises and modules in a different light.

Tuesday, 2 May 2017

Taking Elixir to the Metal with Rust - Sonny Scroggin



Elixir is a great choice for most applications. It's powered by the battle-tested Erlang VM know as the BEAM. It allows programmers to build incredibly fast, efficient, scalable, and fault-tolerant distributed systems.
As it turns out, Elixir isn't the fastest kid on the block. And while raw CPU speed matters little for most applications, there does exist a couple reasons you might want want to reach for tools that give you access to native power.

In this talk we're going to discuss Native Implemented Functions (NIFs) - Erlang's Foreign Function Interface (FFI).

NIFs are normally implemented in C and are considered dangerous. But we're going explore writing safer NIFs in Rust - a new systems programming language developed by Mozilla, that focuses on memory safety.

We'll talk about the pitfalls with writing NIFs and how Rust can make this process easier and safer.

Monday, 1 May 2017

Getting the Most Out of Xamarin.Forms for Visual Studio 2017



David Ortinau shows how to use your .NET skills, XAML expertise, Visual Studio, and Xamarin.Forms to deliver world-class Android, iOS, and UWP apps faster than ever. Dave will share and demo advanced design features, powerful libraries, out-of-the box and custom controls, and new capabilities that you’ll want to use immediately.



From tips on improving Android Layout performance and including native controls and APIs to how to save development time with XAMLC, get the expert guidance and step-by-step demos you need to deliver lightning-fast, native apps.