In an enterprise environment, publishing to live from the desktop really doesn't cut it - testing, customer approval and change tracking all require more checks, steps and environments than the usual Visual Studio or Azure tools provide.

Octopus Deploy is a NuGet-based system that allows great flexibility in managing deployments to numerous environments across multiple releases.

This session will give an introduction to Octopus Deploy, showing how it can be used to deploy a web site to a local IIS instance, a "test" server and up to Azure, and how it can be easily integrated with a CI build system to control releases.

Designing secure systems is hard. Soon, more and more of us will be working on web apps, and software as a service, so knowing about this stuff matters.

Red Gate is in the process of growing from purely standalone desktop apps into the world of writing software as a service offerings in the cloud.

As part of that journey we’ve been making mistakes and learning as we go.

This session is a nice introduction to security with lots of examples from things that we’ve learnt along our way. It’ll cover the basics of thinking like an attacker, things you might expect your framework to do for you automatically but actually it doesn’t like CSRF vulnerabilities, to proposed “features” that might make the software easier to use and more awesome, but also makes an attacker’s job much easier as well.

A deep dive into the shallow end of Angular JS. This is an intro into Google's wonderful JS framework. We'll paddle about in the syntax, let the markup nibble our toes and we'll wallow in the power of our new found client-side MVC. Angular JS brings you all sorts of goodness that Backbone and Knockout can only dream of. We'll build stuff and play with stuff. You'll love it.

The new Async features come along with the very useful WhenAll and WhenAny methods to execute sets of tasks.

We will delve into how these work, the effect of exceptions within any individual task and cancellation. This leads to the creation of common patterns such as Redundancy, Interleaving, Throttling and Early Bailout.

Given time we'll also get to peek at progress reporting, something that provides the feedback to add further sophistication to these common patterns.

Expect overviews of the patterns, followed by lots of code samples so get the latest Visual Studio 2012 RC installed ready for action.

Unit testing has become something of a buzzword within the industry over the past few years, and many developers have been playing catch-up to learn how to unit test properly. The good thing is that it's relatively easy to get up and running with authoring unit tests - the problem is that it's also easy to do unit tests badly. This is unfortunate, and can in many cases be worse than having no unit tests at all.

This session draws on experiences and real-world samples to illustrate how well-intentioned unit tests can become a hindrance, and how to ensure that your team fall into the pit of success of writing unit tests that are cheaper to author, cheaper to maintain, and easier to reason about.

Everyone has that one idea that could be the next big thing. However, starting is the hardest part. This session will help attendees overcome this by providing practical and real world advice on how they can take a high level idea and turn it into reality focusing at both the product and technical level.

Forming the presentation around Lean Startup techniques, Ben will initially cover how to test the concept with potential users to gauge interest based on well-known techniques and his experience of building products and startups. Covering wireframes, initial customer acquisition and how to ask the right questions, attendees will understand the most effective ways to test their ideas.

Once you’ve found the next big thing, you’ll need to build it. Continuing the lean startup focus, Ben will describe the tools and techniques he has used to speed up time to market and identifying the right thing to build instead of just how to build it.

Once launched, it’s down to improvements. This section focuses on measuring users behaviour and engagement enabling you to identify areas that are working but more importantly the areas users are having problems.

By the end of the presentation, participants will have key insights into the startup world and how they can go from vision to reality. The aim is to give people the tools and techniques required to go off and implementing the ideas they already have at the back of their mind.

Over 4 years ago 7digital realised that they needed to address how they were approaching changes to their API and that they needed to improve the way they got these features out to the world. The code base was monolithic, feedback cycles were slow and the team felt powerless.

This is a 101 introduction to Continuous Delivery as implemented at 7digital -a story of what we aimed for, what changes we made and what we've achieved so far.

When designing software, we often need to solve numerous instances of the same problem. When designing user-interfaces, we need to describe the layout and interaction. When financial systems, we need to describe a wide range of financial contracts or, for example, recognize different patterns in price change.

Domain Specific Languages (DSLs) give us a way to solve such repeating problems. By designing a composable functional library, we can build an expressive language for describing our problems. Using the flexible F# syntax, we can get code that even non-programmers can understand.

Takeaways: What will you get from the talk?

• Learn a bit of F# so that you can start writing DSLs on your own
• Understand key functional concepts and learn how you can improve your C# code
• Explore a number of practical DSLs ranging from 3D graphics to modeling of financial contracts

Develop a game in c# using MonoGame and you'll be able to target multiple platforms whilst sharing a huge percentage of the code across those platforms. I will present an introduction to MonoGame and talk about my experience having used it for the past 18 months, including my experience of publishing my first iPad app (written in c# using MonoGame - not a line of objective-c in sight!). If I'm feeling brave we'll knock up a quick demo app during the presentation to show how easy it is to produce smooth animations for your game characters - There will be dragons, goblins and dancing crabs!

Unit testing is one technique we have at our disposal when writing any sort of application, but often we end up writing far too many pointless unit tests for tiny pieces of logic that don't really matter and miss out on the bigger picture.

Taking a feature-by-feature approach to testing, and starting with an end-to-end harness (from Javascript/HTML all the way to persistence) can yield in very positive results, but often isn't done because it is perceived as difficult or expensive to maintain.

It doesn't have to be this way, using the modern headless browsers available to us and by utilising standalone web servers and treating the database as an implementation detail, we can iterate quickly on new features without sacrificing coverage and have a test suite that runs everywhere without having to set up expensive selenium installations.

In this talk, we will look at my preferred toolset for doing this and demonstrate some techniques for designing our test suite and our overall architecture to keep testing both end-to-end and at a fine-grained unit testing level cheap and easy. You will come away wishing you had done this years ago!

"As .NET developers we have been raised by Microsoft to believe that every problem can be addressed with a tool. When it comes to loose coupling, DI Containers look like enabling technology, but it's really, really important to realize that the solution doesn't lie with the tool. It lies in the understanding that DI (or Inversion of Control) is a fundamentally different way to reason about and design software."

Mark Seeman (http://www.infoq.com/articles/DI-Mark-Seemann)

In this talk, I will take you through the principles and patterns of Dependency Injection that help us to write maintainable and testable code. This talk will get you from 0 to productive in 1 hour.

SignalR provides simple real-time publishing and subscription for .NET applications, both web and non-web. Now officially supported by Microsoft, it opens exciting possibilities for real-time messaging and synchronisation in a simple to use package. This talk will show how to use SignalR as a mechanism for application data signalling, in a variety of forms: from browser to browser, server to browser, and external service to server and browser.

If you select this session, you'll see me try to put together an application from scratch in one hour using:

• AngularJS
• Simple.Web
• Simple.Data
• TypeScript
• Twitter Bootstrap

And I'll even try to tell you what I'm doing as I go along.

Go on, vote for this. If nothing else, it'll be fun to watch me perspire.

HTML5 is already the clearest choice when it comes to doing front-end development on the web, and is fast becoming a great option for building certain kinds of mobile app, but what about those of us that still need to write desktop software?

This talk will explore how you can ditch WPF, Windows Forms and all the rest of the substandard frameworks that we have been forced to use when building desktop software. It will show you a bright new path that allows you to follow the likes of DropBox, Adobe and Spotify in building your software using modern web technologies.

Expect a session with code (C#, JavaScript) and lessons from building commercial desktop software.

You may have heard of these terms. You may even have a vague idea of what they are. Perhaps they seemed like a lot of work. Perhaps complicated applications are the only place they make sense. Perhaps you looked into them vaguely before passing them on. Sure you're not missing out? In this session, we'll look at some of the benefits and drawbacks of each. Along the way, we'll discuss some implementation approaches. They may just be a lot more useful than you think - and a lot lot simpler. Architecture astronauts stay away.