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.