Wednesday, 31 May 2017

An Opinionated Approach to Using ASP.NET Core - Scott Allen

Improve the architecture, design, and code inside your ASP.NET Core applications with an opinionated approach to ASP.NET.

In this talk we’ll look at strategies for organizing projects, solutions, files and folders. We'll look at data access alternatives and see some tips for writing unit and integrations tests.

Tuesday, 30 May 2017

Patterns for scalability and availability in (trading) systems - Michel ...

This talk will walk through a number of useful nontraditional approaches and architectural patterns to building systems that combine high availability, high throughput and low latency.

Throughput and low latency is often contradictory and some of the tradeoffs you do usually comes at expense of either one or the other. This presentation covers approaches used in large scale trading systems where there are requirements to process hundreds of thousands of business events per second and reliably react to them whilst capturing and reacting to thousands of business transactions per second while maintain and distributing data to tens of thousands of concurrent users in an environment where milliseconds matter.

Monday, 29 May 2017

Where’s my free lunch? - Hadi Hariri

Have you ever thought about how many amazing things we get in this day and age for free? Think about it, whether it’s articles in daily newspapers, social media, your code repository, your continuous integration server as a service. And that’s not even mentioning all the amazing open source libraries, frameworks that are all out there.

Sunday, 28 May 2017

Toward a Better Front End Architecture: Elm - Jeremy Fairbank

Amidst the overwhelming cacophony of competing JavaScript frameworks, Elm is a promising voice. Elm is a relatively new language that compiles to JavaScript. Elm is a functional language that encourages describing UI, state, and events in a declarative manner, while performing as good as or better than the current JavaScript framework hotness. With type safety and pure programming constructs, Elm promises code that has fewer bugs and is easier to reason about. In this talk, dive into Elm, exploring its syntax and more importantly its architecture. Learn about unidirectional data flow, composable UI components, update functions, and commands for side effects. Ultimately, discover how functional programming with Elm’s architecture can solve real problems. Leave this talk equipped to start utilizing Elm to construct non-trivial apps with more maintainable code and better determinism.

Saturday, 27 May 2017

Serverless Compute with Azure Functions - Magnus Mårtensson

In the age of the Cloud we have almost grown accustomed, or even weary at times, of paradigm shifting technology promising gold and green forests. And here is another one – Serverless Compute.

It was in fact Amazon who coined the term for their popular Lambda service. Microsoft’s retort is that they did in fact plant the seed for the concept with “Simple Batch” aka. WebJobs. Azure has now followed suit in the Serverless wave with Azure Functions a very competent and interesting service with full hooks into the Platform and all other services that live there, such as VSTS, Logic Apps and much more. We developers, architects and DevOps are able to dig into the spoils of the battle of the giants and enjoy a new paradigm which will make us much more effective developers at a fraction of the cost! The Cloud breaths innovation in every breath. The advent of Serverless Compute certainly is one such energizing advance!

Friday, 26 May 2017

Launching patterns for containers - it's more than just scheduling - Mic...

When you design your microservices strategy you will likely come up with patterns for when and how your services should execute.

Traditional container scheduling services often deal with running container instances and distributing those instances across your cluster according to resource constraints - but your microservices design may also have other requirements such as message-based services that run and listen for topics; services that run on a scheduled job cycle; and services that may run in different ways based on initialization and have many instances running in parallel at any given time. This session looks at architecture patterns for container-based solutions; and illustrates the execution of these patterns with Docker containers and related tools. Concepts are platform independent but demos will be based on Kafka and Azure Container Service with Mesosphere DC/OS, Mesos, Marathon and Chronos.

Thursday, 25 May 2017

The Past and Future of Domain-Driven Design - David West

The state-of-the-practice for software development in 1968 was 'Domain-driven Design'. Then "Software Engineering" happened and we lost our way. Academia insisted on telling practitioners how they should do their jobs. Numerous practitioner led 'revolts" — including Eric Evans' DDD — attempted to escape the shackles of formalism and put us back on track; but with very limited success. This talk will discuss the specifics of what went wrong and provide concrete recommendations on how to make things right.

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.