Authoring Useful Software LibrariesDavid Whitney
We'll work through some common sense advice for building software libraries touching on what makes a package or library good and worthwhile, how to keep the barrier to entry low for users, and helping potential contributors extend your code. We'll also touch on error handling, bridging libraries and writing just enough documentation.
So you want to be a Tech Lead? 10 things you need to do to succeed.Joel Hammond-Turner
"Tech Lead" is an amorphous job title - is it all about the technology, or all about leadership? What should the balance really be?
And it can also be a complex and thankless role too - particularly if you find yourself becoming the go-to guy (or gal) for everyone from the intern to the product manager.
In this talk I'll cover (at least) 10 things that I think are essential to success in both areas, including how to address technical debt, herd your PMs and make sure your development team has a steady flow of work (and beer, pizza or other "motivationals").
Windows 8.1 Behaviors SDK and Universal App upgrade war storiesJoshua Whittle
In this session, I will be covering using the Behaviors SDK that now comes with Visual Studio 2013 for use in Windows 8.1 Apps. Behaviors are very useful in keeping your MVVM code clean and avoiding lots of decision making in your view models.
The second section of the session will be some war stories when upgrading your Windows 8.1 app to a Universal App, and in turn I will provide advice on how to avoid/tackle these issues.
What is Desired State Configuration and how does it help me?Richard Fennell
Desired State Configuration (DSC) is the Star Trek technology for managing deployment. The captain says 'helm make it so' and it just happens.
A big statement! Does is work as advertised?
In this session I will look at how DSC is implemented, how you can extend it and how it relates to deployment technologies such as Chef, Puppet, System Center, Octopus Deploy and Release Management.
There Is No AgileNick McKenna
I’m having an existential crisis. After seven years of practising Agile, it has finally dawned on me that it really doesn’t exist.
Let me take you through the stories of the teams I have worked with and coached and share with you the common insights and developments that Agile teams make as they progress towards their Agile nirvana goal.
I will discuss common innovations that Agile teams have made over the years and also discuss some of the practices that have been discarded and some of the developments that are yet to come…
Patterns all the way downPhillip Trelford
Of late the C# and VB.Net teams have been proposing adding basic pattern matching features for future versions of their respective languages. This talk will introduce pattern matching concepts in languages where it is already employed including F#, Erlang and ECMAScript 6. We'll look at the proposed changes to C# and VB.Net, and how lightweight types and pattern matching can be used as a simpler alternative to class hierarchies. Expect to see plenty of concrete real-world examples in this live coding session, including LOB apps through to compiler scenarios.
Break free, be agile!Preet Singh
Agile is finally here, it is now well know even in remote parts of Yorkshire. We have started following it. Can we finally say we are agile and successful with it? I have been trying to make sense of it for past few years. Why? What? and then most importantly How?. In this talk I aim to take you to the land that we forgot in the midst of implementing agile. This is my account of how my experience with agile and how the agile mindset forced me to visit that forgotten land again. It made me realise that it all starts with Code and the rest is just detail. We will look at how making our code agile, makes us agile. We will look at how breaking some rules around planning, certainty, architecture and perfection actually helps us to be more agile in our code and respond to change quicker.
Restructuring and Migrating into and out of TFSRichard Fennell
We have many options to manage our application lifecycle. Irrespective of the tools in use there is a good chance that any choice you made in the past will not seem so sensible now. In this session I will look at the tools available to restructure and migrate in and out of on premise TFS as well as to Visual Studio Online, whether using TFVC or Git source control.
Using F# for Line of Business ApplicationsIan Russell
C# is a great language for developing Line of Business applications but F# is even better! If you want to write code that expresses your requirements clearly, ensures correctness and supports rapid, and fun, development then guess what, F# does all that and more!
No prior experience of F# is necessary for this session but be warned, once you've seen what F# can do, you won't want to go back to C#!
Web components with MVC & Polymer JS (Quick Start)Peter Shaw
You heard there's a revolution coming right?
Well there is, and it's called "Web Components".
Most of you are used to creating things like "HTML Partials" in ASP.NET MVC, or using custom controls in Webforms.
You can build an entire application if you want too, then simply place it into your web page using:
In this session, I'll show you how to get started in an ASP.NET MVC Application using Google's PolymerJS system, getting you started on the road to true HTML components encapsulation, ready for the road ahead.
Visual Studio CodedUI: Improving Resilience in your Automated testsRiccardo Viglianisi
CodedUI is a powerful Test Automation technology within Visual Studio, unfortunately it's still all too easy for your Automated Tests to break in the course of a project as the UI in evolves.
You can reduce the chance of this happening (and reduce refactor time if it does happen) if you go about writing your tests in the right manner. I'll be showing the methods I've adopted to achieve this and then demonstrating them with practical examples.
Introduction to S.O.L.I.DColin Mackay
An introduction to the five S.O.L.I.D. principles (Single Responsibility Principle, Open/Closed Principle, Liskov Substitution Principle, Interface Segregation Principle, and Dependency Inversion Principle). In this session we'll take basic OO concepts and expand on them to give a grounding in the SOLID principles. The examples are in C#, but the concepts can apply to any OO language.
Exploring Cross-platform Mobile Development with HTML5 Hybrid ApplicationsBill Ayers
So you've had a killer idea and you need to get a site up quickly but why should you spend time creating the same old code to handle registering your users, storing data, etc?
Come along to this session and I'll tell you all about the different approaches there are and show you an alternative way to build apps that doesn't need you to write any server side code at all yet still provide the functionality you need and possibly more.
Keeping it responsive - cross-platform MVVM with ReactiveUISam Hogarth
Building an awesome user interface is hard work. You've got the complexities of real life to deal with - handling user inputs, dealing with slow network connections and managing background workers. There's also this testing thing that people keep going on about!
We need a way of handling the real world, whilst behaving in a predictable and responsive manner. Enter ReactiveUI, a fusion of MVVM and the Reactive Extensions (Rx) for .NET applications.
In this session I'll introduce ReactiveUI, show you some tips and tricks, discuss the benefits and tradeoffs of the framework and show how it can be used as a solid foundation for building cross-platform .NET applications.
BDD, Why you should be doing itRichard Tasker
Behaviour Driven Development has been around for almost 10yrs and yet I still talk to people who think it is just a different way of writing unit tests.
BDD is a process the whole team can use, from BAs to Devs to Testers.
This session will talk about what is BDD, how you can apply it to your process and the advantages of introducing BDD into your process.
CQRS & Event sourcing – an Azure implementationAndrew Macdonald
When thinking about developing a new software product, it’s normal (for me at least) to think ‘let’s play it safe – let’s use the same techniques we always use’.
This time though, I thought ‘No – I like the sound of this CQRS thingymabob’ and after a bit of investigation ‘ooo… event sourcing – that sounds cool too’ – ‘I know what - I’ll use both’
In this session we will explore these exciting concepts and walk through how they are implemented in a real life production project that targets Azure table storage as a first class citizen.
As in Life, so in Memory Management: Premature Promotion Produces Poor Performance and a Menagerie of Other Grotesque BlundersBart Read
Both the JVM and CLR provide automatic memory management with garbage collection. Developers are encouraged to write their code and forget about memory management entirely but, whilst ignorance is bliss, it can also lead to a host of problems further down the line. And if you move back and forth between platforms the differences can sometimes trip you up!
In this session we’ll compare and contrast memory management in both the JVM and CLR. We’ll look at some of the “classic” blunders that cause trouble and how to avoid them. We’ll also talk about the tools that can help you get to the root of problems when they do occur.
An Introduction to Functional Programming with F#Ian Russell
F# is a functional-first programming language which helps you to tackle complex computing problems with simple, maintainable and robust code. In this session, Ian Russell will get you started on the road to thinking and writing code functionally.
Near Field Communication and Proximity in Windows and Windows PhoneSteve Spencer
In a world of devices we are continually wanting to communicate more and more with the devices around us. This talk will go through the technologies being integrated into tablets and phones which can be used to communicate between devices whether that is through tapping and NFC or with devices close by using Bluetooth and WiFi Direct.
Active Patterns in F#Richard Dalton
Active Patterns have been described as F#'s killer feature. This session will take you from the basics to advanced topics like nested active patterns. Along the way you'll encounter some key topics in functional programming including Partial Application & Currying.
If you have some experience of F# or Functional Programming, but haven't quite "got" Active Patterns, this all-code, no slides session will set you straight.
If you are brand new to functional programming and want to get a sense of what all the fuss is about, this session will show you a style of programming that is far removed from the OO/Imperative code that you may be familiar with.
Join the Dark Side - Why developers should choose managementCeri Shaw
Have you even thought to yourself "There's no way I'd ever want to be a manager” ? If so then this talk is for you!
‘Management’ is seen as a bit of a dirty word in the development community, so much so that we’ve had to give it other names so that people will do the job (Scrum master for example!) but it doesn’t have to mean PHB’s and David Brent. It isn’t anti-agile to have managers and there’s a real need for more developers to step up into management roles. It also doesn’t have to mean ceasing to write code.
This talk is based on my own journey from developer to manager. I’ll describe the different types of management, why we need developers to do the job and why the job might appeal to you.
By the end of the talk I aim to convince you that management is something you can and should do!
How I turned dull old deck lights into multicolour Internet controlled disco deck lighting!Stephen Harrison
Featuring: The NeoPixels, An Arduino, Node Red, MQTT, a dab of 3D Printing and not forgetting some dull old deck lights!
As a weekend project I recently converted some out old deck lights into Internet connected RGB lights, in this talk I will walk you though the steps I took to do this so you can see how easy it is to make your own Internet of Things Thing.
I will show you how to connect up and program an Arduino, steal (sorry, re-use) some code to make it control NeoPixel LEDs based on messages it receives from an MQTT Broker, how to publish messages to that MQTT Broker using Node Red and how easy it is to use some basic 3D printing to make the NeoPixels fit into old deck lights.We won't go very deep into the various technologies and won't actually be doing any live 3D printing, but I'll cover the higher level aspects of each of the technologies, with introductions to MQTT and Node Red which are emerging as serious players in the IoT space so that you take away the knowledge of how to get started to make your own connect things.
Introduction to the R Programming LanguageGary Short
R is the programming language of choice for data scientists. In this session I'll give you an introduction to the language, covering all the main areas as well as a good set of coding standards, after which, you'll have all the knowledge you need to write the next great data science prediction engine and get bought out by Google. When you do, remember who taught you the basics! :-)
From CRUD to EDA: a true storyAlessandro Melchiori
When a project starts, all seems so easy: from requirements to implementation. How many times you heard from business: "It's so easy that we don't even need to speak about"...and you start in the (almost) easiest possible way. With CRUD. But what's happens when the business grows? Or when you discover hidden complexities?
This is a true story, about a big financial project, started as a simple one, but with a lot of underground complexity. During the talk I'll describe how we moved from a CRUD approach, to CQRS and EventSourcing, distributing the system among different geographical places, using MongoDB and RabbitMQ
Write your own compiler in 24 hoursPhillip Trelford
Compiler writers are often seen as the stuff of myth and legend.
In this session we'll step behind the proverbial curtain and reveal how compilers actually work.
Expect plenty of live code samples, primarily in F# and C#, covering language design and parsing, all-the-way through to emitting code.
This session is aimed as a primer for those interested in writing an external DSL, general purpose language or just understanding how these things work.
It's all about the User, man! (Authentication and Authorization with OWIN)Joel Hammond-Turner
Google, Facebook, Twitter, even Office265 - these days getting a user to sign in to your web application is all about federating identity. And with OWIN, it's easier than ever to integrate with these identity providers. In this talk I demonstrate hooking these providers up, how to avoid rolling your own user database, and what other great libraries are available to help.
How did I manage to get on well with GitMatteo Emili
When I first approached Git I did not like it. At all.
But after 'seven stages of grief', I reached a point where I can happily live with it. In this session I want to share how did I do that, and especially how does it fit in my everyday work while it is used by hundreds of people.
Owin: The great asp.net rebootsteve higgs
Asp.net has a long history of delivering web applications; unfortunately this history comes with a fair amount of baggage. This all changed with the introduction of owin. Owin lets us achieve a level of efficiency and portability using asp.net that would be inconceivable using the existing .net infrastructure.
In this session I will cover:
The whats and whys of owin, how's it different to what we already have? What do we get out of it?
Owin hosts and middleware
Running owin on multiple platforms using mono
Fast and simple in-memory integration tests using the owin testing infrastructure
Owin in .net vNext
In short: Owin - it's really fast, extremely portable and you should use it; here's why.
Refactoring Away from Test HellAlastair Smith
Your builds have been red for years; maybe they’ve never been green. Someone learned about mocking frameworks at a conference years ago, and now you can’t sneeze without breaking a test. There’s 30 lines of setup and you can’t tell what your tests even do. What happened to the promises of flexible, well-designed code that unit testing and TDD made?
In this talk, I will cover immediately-applicable ways to refactor your way out of test hell, and demonstrate some open-source libraries to help you clean up your test code, all based on my encounters with dodgy tests from my current and previous jobs. You will come away with practical examples of how to make your tests work for you rather than against you, including recommendations for the correct use of mocking libraries.
Hadoop Kickstarter for Microsoft DevsGary Short
Big Data is the new shiny thing right now, and if you read the blogosphere you'd be forgiven for thinking it was a tool for Linux devs only, (or worse, only for those annoying hipsters with their shiny Macs). Nothing could be further from the truth however. Windows makes an excellent platform for Hadoop and in this session I'll show you everything you need to know to get started. From downloading and installation, to writing our your first map reduce job, using both the streaming API and the SDK, this session will cover it all, so come along and join the big data wave!
Meeting C# 6.0Matt Ellis
C# 6.0 introduces several new language features, like expression bodied type members and the null propagating operator. It's also a complete rewrite of the compiler, reimplementing it from scratch in C# and creating APIs to host the compiler yourself.
In this talk, we'll take a tour of the new language features, looking at what they do and how they work. We'll also spend some time looking at why "compiler as a service" is a Good Thing.
Lessons learnt scaling a mainstream restful APIDavid Whitney
A walk through the design, launch, and evolution of a RESTful API that ended up powering some of the largest charity campaigns in the UK. We'll go through what worked, what didn't, along with some tips and advice to help you grow your own API to be ready for consumption by just about anyone.
Functional DDDAlessandro Melchiori
Very often we approach, more or less unconsciously, DDD's principles only with object-oriented paradigm, without exploring if other "style" can live better with aggregates, value objects, commands and domain events. Well, yes: there is 'other' out there... In this session we will see how a functional language as F# can lead to a more intuitive and compact implementation of our domains.
SharePoint: the Good PartsBill Ayers
Windows On Devices - a first lookIain Angus
At Build 2014 Microsoft demonstrated a version of Windows running on the Intel Galileo microcontroller board. The Windows Developer Program for IoT program has now released a preview supporting the standard Arduino Wiring API and a subset of Win32. This session will get you up and programming Windows on the Intel Galileo using Visual Studio 2013.
Brownfield RefactoringDom Finn
Coming onto a massive old code base with an existing team can be a very daunting task. Especially when everything is going wrong. No change can be made on the code base without something breaking. The database is constantly "running slow" and requirements come in on a scrap of paper that need to be completed in comical time-scales.
I think everyone has seen this before and you have ~3 choices.
1. Get out of there!!!!
2. Join the zombies and just earn your money.
3. Kick some ass and change everything!
I have chosen number 3 a couple of times now and I wanted to share my experiences of what I do in these circumstances, what worked and what didn't work.
From Scratch to HTML CSS and JqueryJon Bulmer
In the DDD conference last year we attended a session, talking about the need for IT professionals to go out and inspire our children with Scratch. We tell the story of the journey in that 12 months and introduced www.zero2coding.co.uk. The platform we are developing to turn the dream of coding for all into a reality.
We have worked with teachers, children and have faced red tape. With persistence, patience and shear determination young coders are starting to get hooked, looking to move their Scratch projects to the next level with HTML CSS and Jquery.
Come and see what we have done and see where the next 12 month will bring us.
RavenDB: an introduction to document databasesMauro Servienti
<p>RavenDB rapidly moved from being one of the emerging kids to a stable and mature platform to built scalable and reliable applications.
In this talk we'll start introducing document databases concepts, such as schema-less and eventual consinstency, and then we'll see how to create applications using RavenDB as the storage backend
AngularJS directivesMauro Servienti
Directives in AngularJS are one of the most powerful concepts and one of the hardest things to understand and manage. In this session we will start introducing directives basic concepts and we will deep dive into the programming model, and challenges, understanding how to build custom directives starting with a simple breadcrumb to move to a much more complex typeahead.
Monitoring your applications with Application InsightsMatteo Emili
We all aim at developing a great product, but it would not be possible without some real data from customers’ experiences, in a process of continuous improvement.
The best way of doing that is by employing a common, cross-platform infrastructure which should ease the cost of implementing it from scratch. Visual Studio Online introduced Application Insights for monitoring production applications and diagnosing issues which happen inside them.
We will look at how to implement it in our applications and how to use the data it gathers for 'closing the loop' in our ALM.
An Actor's Life for Me – An introduction to the TPL Dataflow Library and asynchronous programming blocksLiam Westley
Every version of the .NET Framework has brought improvements to asynchronous and concurrent programming. While .NET 4.0 brought the async/await model which is useful for improving UI responses and server applications, it can sometimes still be tricky to marshal multiple threads within longer processing pipelines.
The Dataflow Library consists of a Nuget package built on top of the Task Parallel Library (TPL). It harnesses the actor-based programming model to provide a set of dataflow blocks data structures that buffer and process data, which you can connect together to form custom pipelines with messages passed between the blocks.
By using the Dataflow Library you can concentrate on the messages and actions being performed, while the blocks marshal the messages, provide concurrent message processing and buffering as well as supporting cancellation and exception handling.
Automating deployment and testing with Visual Studio Online and OctopusDeployJoel Hammond-Turner
Last year I showed how OctopusDeploy was a great (and simple) deployment platform. Now, I'll show how the latest V12 build templates in Visual Studio Online can let you automate building, deploying and testing software - whether it's a Nugettable class library or your brand new social website.
Decoupling from ASP.NET - Hexagonal Architectures in .NETIan Cooper
The term 'hexagonal architecture' has come back and forth in popularity since Alistair Cockburn first mooted it, with the Rails community's recent soul searching over its importance or threat just the latest. So what is a hexagonal architecture, why might you want to use one, and why is the 'Rails just falls away' (https://www.youtube.com/watch?v=tg5RFeSfBM4) threat so discomforting to web framework builders. How can we make 'ASP.NET just fall away'.
In this presentation we will look at the Layered Architectural style - when we would want to use one (as opposed to the alternatives) and when it is appropriate how to implement one. We will look at how to implement the Ports & Adapters (Hexagonal's 'proper' name) style, explaining what the different layers are.
We will look at the value the command pattern for implementing our ports , explain why Netflix uses it in Hystrix for reliability. On the way we will discuss Retry, Timeout and Circuit Breaker and explain how we can do better than Hystrix with a Command Dispatcher and Command Processor.
We'll show code throughout, including a look at the Paramore. Brighter framework, an OSS version of the platform we use at Huddle to build this kind of architecture.
As a bonus we will round off showing you how easy it is go from sync to async with this approach.
Data Science for Fun and ProfitGary Short
Make no mistake, data science can be hard, but it can also be fun. In this session I'll introduce you to Classic and Bayesian Statistics and Machine Learning, all through the medium of predicting horse racing results. We'll explore a number of techniques for making such predictions and we'll finish by combining them into a powerful "mixed model" prediction engine, that's sure to pick the next big winner. This session won't only improve your knowledge, it'll improve your bank balance too! Note: probably won't do the latter though. :-)
Troll Hunting on the InternetGary Short
Shockingly Robin Williams recently took his own life. As if that wasn't tragic enough, more shockingly his family then had to abandon social media due to the perverse behaviour of the trolls, people who take great delight in upsetting others by posting outrageous statements to their Facebook walls and Twitter streams.
In this session we'll examine this problem from a data scientist's point of view, showing how to use computational linguistics to ensure that such posts never reach people's streams and using network theory to trace and expose the trolls so that they no longer have the shield of anonymity to hide behind.
The examples in this session will be in F# (cos why the hell not, right?).
How the (?!.*) do Regular Expressions work?Matt Ellis
Everyone knows that regular expressions are insanely powerful. But do you ever feel like they’re a write-only language? Do you create them by trial and error? Do you know your anchors from your lookaheads? Zero length and greedy matches? Backtracking?!
Let’s take a look at how regular expression engines work, under the covers. By following the steps an engine takes to evaluate an expression, we’ll take some of the mystery out of how these arcane symbols can match user input.
Getting started with SVGPeter Shaw
All the "kewl kids" are doing fantastic scaling graphics in thier UI's these days, but how?
Scaleable Vector Graphics (SVG for short)
Simple, SVG unlike the more traditional bitmap way of doing things, are infinitely scaleable. Imediately this means no more producing three versions of an image for your site (Mobile, Normal and Retina)
SVG however has much more under the hood than just making super scaling logos and Icons, it's a graphics description language that's fully controllable from CSS and as easy to work with as regular HTML tags.
In this short session, I'll give you a basic introduction to SVG, how you can use it inline with your HTML and set you in the right direction to start making your web UI's nice and scaleable.
All your types are belong to us!Phillip Trelford
No program is an island.
Modern apps connect to a wide variety of data sources. F# type providers help bring that data easily to Visual Studio and Xamarin Studio with types and code completion.
This session will demonstrate a wide variety of type providers, from JSON to SQL to the Freebase, and how F# type providers help bring the world to your finger tips!
Quick and Dirty SOA with RavenDb and Reactive ExtensionsSean Newham
Event sourcing in a “not-always” connected worldAlessandro Melchiori
In a "not-always" connected world we have a problem: merge business transactions across network boundaries. In this context, event sourcing is useful because we can think to our system's evolution with state transition.
Synchronize (only) data is not so easy because we lose why something happens. Events are the answer to trace and synchronize business process and identify "merge conflicts".
Rebuilding your desktop UI in HTML 5. Just... why?Alastair Smith
You’ve heard about HTML5 UIs and embedded browsers like CEF, but what happens when you actually try to build an application on this pile? The SQL Source Control team at Red Gate are doing exactly that, and I’ll describe and dissect our experiences to date running up to our initial beta release.
Why did we choose HTML in the first place? How did we choose our technology stack? How is it working out for us? What would we do differently if we were to do this again? All these questions and more will be answered, and you'll be able to make an informed decision about whether this is the right approach for you!
How to Save the World Without Leaving Your BedroomGary Short
Well technically it's my daughter's bedroom, since she moved out I've converted it to my home office but I digress, where was I... Oh yes, saving the world.
In May 2014, the Chicago Council on Global Affairs met in Washington, D.C. and predicted a collision between two growing global food crisis: a demand for high-quality meat and dairy and a climate system of storms, floods, heat waves and droughts that have only diminished crop yields.
In this session we'll take a code heavy (C#) look at what data science can do to help maximise crop yields, at every level from sowing to harvest; including the interesting question of, "can we monitor crop health from space?" (hint: yes we can and it's very cool <grin>).
So come alone to this session and find out how data scientists are helping to save the world from the comfort of their offices. (or ex-bedrooms in my case).
Using Xamarin Forms to make a cross platform Agenda AppRichard Garside
Why doesn't everyone just use Windows Phone?
Then I wouldn't need to worry about having multiple versions of my app with business code and UI in a variety of languages. Plus I could use C#, not have to remember how Java works, learn if Swift is worth learning or even have to think about Objective C.
The Xamarin Tools have brought the Mono version of .NET and C# to iOS and Android and now with the recent release of Xamarin Forms they've brought XAML and the possibility of cross platform (but tailored) UI as well.
In this session I'll be showing you how to create a simple agenda app for a conference that will work on Windows Phone (clearly the best phone OS), iOS and Android. You'll see how you can use the same XAML for you UI, but still have an app that looks totally at home on whatever platform it is compiled for.
NServiceBus: introduction to a message based distributed architectureMauro Servienti
SOA and distributed have been buzzwords for a long time, a message based architecture that embraces the SOA principles is the real solution to a scalable and distributed environment where HA or/and temporal decoupling are a must.
In this session we will introduce messaging concepts and see how NServiceBus, a powerfull toolkit to rule all the aspects of a messaging transport, can dramatically simplify the development process of a distributed, scalable and highly available solution.
3D Printing for DevelopersStephen Harrison
In January I bit the bullet and got myself a 3D printer, it's been a mixture of fun and frustration since then, however as a software developer it's a great feeling when you are able to hold something in your hands that your code has produced out of thin air (well that and a roll of ABS filament!)
In this talk I will take you through my experiences of 3D printing with a MakerBot Replicator 2X, some tips for success and the many failures. I'll show how you can create 3D models to print using SketchUp and OpenSCAD. We will dive into OpenSCAD and see how we can use our day to day skills as a developer to create printable 3D models. I'll show what can go wrong with the help of my many failed prints and even some that turned out good!
Due to the nature of the beast I won't actually be demonstrating with a 3D printer, I'll leave you to find a local maker space to get hands on.
Scream if you want to go faster: speed up .NET and SQL Server web appsBart Read
We all know that websites need to be fast. But how do you juice up creaking web apps that have been around for a while without deploying the thermonuclear option (i.e., the costly and much-maligned ground-up rewrite)?
Unfortunately this can still prove tricky, especially when the issues lie in the database layer. Help is at hand though: I’ll show you the techniques that will help you hunt down performance problems in your database, and relate them back to your .NET code. But that's only half the story: we'll also talk about the strategies you can use to fix them from the relatively simple, to the much more involved.
You should leave with an arsenal of optimisation tricks for every occasion!
The Internet of Things - Thought about it? Now try it.Robert Hogg
The Internet of Things (IOT) has been subject to a lot of Hype, but it is here now and ready to be used. What it needs are great developers to pick up the mantle.
So come along and find out how you can take on the challenge of IOT.
This session will cover...
Developing for the Internet of Things both from a device perspective and in the cloud.
Looking at areas to use IOT outside of hobbyist areas and how to look at IOT in a new way to help build new types of solutions.
From the Devices side this session will be looking at how to build great connected devices using Microsoft’s new Developer program for IOT based on the Intel Galileo board running Windows.
From the Cloud side this session will include a breakdown of the best ways to integrate and deliver meaningful insight into your IOT swarm of devices.
Take on IOT and see what you can do.
If .NET Developers are from Mars, where are Rubyists from?Eva Barabas
We, humans find it easier to look at differences rather than similarities. Hence, when given the opportunity to work as a Rubyist within a team of .NET devs, I was sceptical at first.
During the last 6ish months, I realised that there isn't 'them and us' but more a tight knit group of like-minded developers, a team working towards the same goals. I.e. delivering robust applications to our users and aiming at clean code in our codebases.
I would like to take this opportunity in sharing some of our similarities and maybe encourage other teams to take the bold step in working together with some other talented developers despite the choice of programming language.
Micro Services: conquer monoliths, before they own youKiran Singh
The monoliths have you! With their "all in one place" tens-of-projects solutions, entangled dependencies and tied down release schedules, they are restricting your creativity and your company's profits. Allow me to show you how Micro Services can lead you to a path of efficient delivery, as Netflix and Amazon, among many, have discovered.
It's not decision to be taken lightly - we've had to work through issues on various fronts in our attempt to break the monoliths into Micro Services. This will be a down in the trenches story with no sugar coating - if we've failed by the time I present this talk, you'll have the pleasure of watching me eat the humble pie!
Although I rather hope to give you a way to tame your monoliths and make development a pleasure. To really make it worth your while, I'll also share tips from others who have implemented Micro Services in their environments.
Developing Prototypes in a Connected WorldMark Stevens
The modern world is replete with devices collecting information about the environment, people, nature and the performance of many modern devices even the humble kettle. For many developers this presents a change in mindset moving from the macro world of desktop/web environments to the smaller environment of microcontrollers.
In this session we will look at some of the options available in the maker / hobbyist development market including:
- Netduino (.NET Microframework)
- Raspberry Pi
- ST Discovery boards
The session will conclude by looking at connecting such devices to the macro world and the Internet of Things (IoT).
Moving batch scripts to the cloud using Azure Web JobsSteve Spencer
This session will introduce Azure Webjobs and show examples of their use.
Not just layers! What can pipelines and events do for you?Ian Cooper
When developers reach into their toolkit for architectural styles, they often explicitly uses layers to separate their domain from their presentation logic or infrastructure. They often implicitly use the repository style, with independent components updating the database. But there are many more styles out there, which can help you build your applications. In this talk we look at two of them: pipelines and events. Pipelines let us deal with streams of data effectively, and events provide significant advantages for loose coupling.
We discuss where these styles are appropriate and how to implement them in .NET. As both approaches can be used in-process or out-of-process we'll show examples of both, leading to an understanding of how distributed systems communicate using ideas such a SEDA - the staged event driven architecture.
Burnout is real and it's coming to get you.Richard Dalton
Do you love programming?
I love programming. I've loved programming since I was 10, that's 30 years ago.
If the people I graduated college with are typical then about 1 in 5 of them are still writing code for a living. Where are the rest? Academia, Management, Training, Other Professions, perhaps no longer working at all.
If you write code then you need a plan B because simple attrition means you are unlikely to be able to keep doing what you love into your 40's unless you take steps to make sure you are the 1 in 5.
Burnout is real. I've seen it in others, I've experienced it myself, one thing I haven't done is talk about it, and despite knowing a large network of programmers (of a certain age) I rarely hear it spoken about, I never see it covered by talks.
Don't vote for this session if you want code. There will be no code. I have another session that contains only code, vote for that instead.
This talk contains humour, confessions, cold hard facts, stark warnings, useful suggestions and more humour, because you've got to laugh at the absurdity of it all.
Everything you need to know about .NET memoryBen Emmett
.NET's memory model is near-miraculous engineering, freeing you from many of the complexities of memory in unmanaged languages, while still being fast and efficient. Most of the time.
For all that managed memory is a boon and a blessing, when it goes wrong it does tend to go very wrong, so it's worth getting to grips with what's going on under the hood.
In this session we'll dive into the internals of .NET's memory model to look at how it works, and tackle some of the most common misconceptions. We'll also discuss its imperfections, how you can fix problems when they arise, and some techniques you can use every day to proactively avoid issues in the future.