Add an eventDDD North 2012 schedule
Saturday 13th October 2012
-
10 Practices That Make Me The Developer I Am Today
I've tried pretty much every fad that's cropped up during my career. I'm willing to give pretty much anything a fair go to see if they live up to the hype. Most are nonsense, some are awesome, and usually those guys that were doing it 20 years before us knew what they were doing.
Come with me as I trace through my career from junior noob to senior developer. I'll cover the core practices I've picked up along the way that I use every day, why I value them, and why you should value them if you don't already.
I'll cover the habits that I think make a real difference to your day-to-day work and some new practices that I'm come across that you may want to try.
-
Async C# 5.0 - Patters For Real World Use
by Liam Westley
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.
-
BDD - Look Ma! No Frameworks
An interactive session where I will explain BDD and how to use it to start building effective products that your customers, clients and users actually want.
This will be followed by practising how to use this to make your codebase self documenting and focussed.
All this and not a framework in sight!
-
C# + PowerShell - Happy Couple
Windows PowerShell is a great tool for system administrators and normal users alike. One of its design principles was extensibility. It provides powerful scripting mechanism but is also very easy for developers to create new tools and utilities to be integrated with PowerShell. It provides easy to use SDK that eliminates many tasks that typical command line tool would require.
The session introduces into PowerShell development from the ground up. You will learn how to start and the basics of argument processing, output and pipeline processing. We will also look at error handling and diagnostics to end up deeper in custom types and type conversion. After the session you will be able to sit down and write a tool your system administrator will love you for.
-
Defensive Programming 101 v2
The web is a funny old place. You create a wonderful application, deploy it for the world to see and then everybody just wants to break it.
This session will show you some of the common security mistakes made by developers and how to avoid them. There will be some demos with code in C#.
Talk is rated level 100-200 with a target audience of web developers (not just ASP.NET. All the examples will be done in .NET. Even if you are not a web developer some of the parts of the talk will be handy) and assumes knowledge of web programming, basic security concepts, a working brain and sense of humour.
-
Event Driven Architectures
by Ian Cooper
So you have decided to break up that monolithic application into services, after all it worked for Amazon, right? Perhaps you want to embrace the DevOps model, perhaps you want to scale your development. But just how do all those services talk to each other, and how do you build a UI on top of them? In this session we will look at the event driven architecture approach and give you an understanding of how we use messaging to communicate, just what we are communicating about, and how to build a composite UI.
-
Gadgeteer for .NET
by Robert Hogg
Gadgeteer is a rapid prototyping platform for small embedded hardware devices, that has the advantages of .NET programming and simple assembly of electronics from a kit.
Using the software tools you know - C# and Visual Studio - you can use Gadgeteer to easily construct both simple and sophisticated devices.
This session will explore what is possible with Gadgeteer.
-
Getting Started with Caliburn.Micro and Windows Phone 7
Getting started with the Windows Phone 7 Development Platform is relatively simple, however, using a Framework like Caliburn.Micro takes away some of the more mundane tasks, and allows you to focus on what you are trying to achieve. In this session we will start with a blank Windows Phone 7 project, and start to create our first Windows Phone 7 application using features such as:
ActionMessages
Action Conventions
Binding Conventions
Navigation Service
The Bootstrapper
The IPhoneService
Tombstoning
Lauchers and Choosers
The IWindowManager -
JavaScript Sucks And It Doesn't Matter
JS is a rubbish language.
No really - it is, you've all seen the 'WAT' video right? (If you haven't I'll show you some of the WTFs we're all talking about.
But why is any of this important? What makes for a good codebase? The language? The frameworks? The developers? What metrics are we going to use when it comes to working this out?
Let's look at at some C# (let's face it, probably our collective preferred language) and some idiomatic and equivalent JS - and see that actually, this world isn't so bad - so long as we focus on writing good code.
Warning: I am likely to have some opinions in this talk and be derisive about tooling and our reliance on it.
-
Lions and Tigers and Hackers! Oh My!
In recent months there has been massive media focus on the Stuxnet and Flame Cyber weapons, malware is an increasing issue and industrial espionage is occurring every day throughout the UK against companies like yours, and you probably don't even know it's happening.
In this fun, relaxed yet terrifying session we'll explore the cyber landscape, the reality that we're now facing and what you can realistically do about it.
-
Rewriting Software Is The Single Worst Mistake You Can Make - One Year On!
by Phil Collins
Joel Spolsky once said that rewriting software from scratch is the single worst strategic mistake a software development company can ever make.[1] We all know of the Netscape story and the never-released v5.0. So as a developer how do you react when you're faced with the fact that there is little other choice than do exactly what you're told you should never do.
During this session I will describe how as a team we are managing to beat the odds and rewrite our main flagship product from a legacy platform into VB.net; as well as describing the decisions behind the choice of language, the choice of development methodology, how we built the project plan, what has changed since we started, how the plan and we have adapted, how we learnt from our mistakes and our successes, how working with Bournemouth University and their study of our rewrite has helped us, and whether or not we still think it's something you should never do.
Almost one year on since I last spoke about this project and two years into the rewrite project as a whole it's time to bring everyone uptodate with how it's going and what's changed over the past year.
[1] Joel Spolsky, Things You Should Never Do, Part I - http://www.joelonsoftware.com/ar...
-
Riting Roslyn Refactorings: Harnessing The Compiler As A Service
The .NET Framework 5.0 (or later) is expected to include the much anticipated Compiler As A Service feature (code named Roslyn). Since the .NET Framework 1.0 the compiler has been written in unmanaged C++. With the release of Roslyn it is written in C#. This means it is simply an assembly of .NET types wrapped up in a Console Application. And here’s the all-important part – the types are public. You can use the same types that the compiler uses in your own applications. You can compile code on the fly. Effectively you can turn any .NET language into a scripting language. This session shows a preview of what the support will look like in the .NET Framework 5.0 and focuses on practical examples focussed mainly on refactoring existing code.
-
Selenium A UI Testing Paradigm
by Nathan Gloyn
You may or may not have heard of Selenium the open source test framework for web applications.
In the session we’ll cover:
· What Selenium is and where it’s come from
· How it works
· The various ways to use it
· How to build your tests for ease of understanding and reuse
Whilst focusing on using Selenium the talk will also cover best practices around UI testing regardless of the tool you use to do the testing.
-
So Just What Is Spatial SQL?
by Peter Shaw
Maps and Geo-location are everywhere these days, but just how many of you still take that Latitude & Longitude you get from your mobile app and put the values into normal decimal columns in your database?
With Geo-Spatial SQL and a correctly configured spatial aware database you can take control of this data and do some very clever stuff with it.
Want to know how many of your customers live within a 10 mile radius of your office?
What about which is the nearest fast food restaurant to the person currently looking at your Facebook app?
or maybe you want to track where your delivery drivers are?
Spatial SQL can provide the answers to this and many other location and distribution based questions, and can produce some very interesting statistics for graphing & charting and market analysis.
In this session I'll introduce you to the concept of spatial SQL using Open Geo-consortium standards, most of which can be used with slight modification in the current versions of MS-SQL 2008 and up.
I'll give a high level overview to what is available, why you might want to use it and the type of operations that can be performed directly in your database along with some of the tools you can use to provide rich mapping and statistical visualisation in your .NET applications.
-
Test All Things Or Maybe Not: A Pragmatists Experience
by Will Charles
I love automated tests for my code because I hate manually testing code. But over time I've found that a difficult to maintain test suite is even worse to maintain than retesting my app by hand when I make changes.
In this session I will talk about what things have made test suites difficult for me to maintain and how it can be mitigated. We'll briefly look at creating unit tests when working with legacy code and talk about why it doesn't matter what _DD you're using so long as it's providing value to you and your apps.
Let's get rid of the dogmatism and start looking at how we can use this!
-
The Business of Side Projects
Like many developers I have started and abandonned my fair share of side projects. There are so many great ideas but it never seems like there is the time to finish them. I decided that if I wanted to spend more time on my side projects, they were going to have to start paying for themselves.
In this talk I will discuss how I've started to do that and how the new app store markets are hopefully making it possible for more people to make a living (or a percentage of one) from their own software.
I'll talk about creating the app Font Picker and getting it into the Mac App and soon the Windows 8 store. I'll let you know how well it's gone so far, and try to extrapolate how feasable it is to make a living completely out of my own sofware in the future.
-
The Good, The Bad And The Automated
by Paul Stack
A bad deployment process can not only cost our applications downtime but cn also cause developers a lot of stress and irritation. The deployment of an application should be easier than we currently make it. Technically speaking, you should be able to release your application whilst sipping a cocktail on a mediterranean beach. This, of course, isn’t the case for a lot of projects. In traditional waterfall methodology, deployment wasn’t thought about until just before it happened, this caused issues on deployment night. As software developers, we should practice the art of delivering software not just developing it.
In this session, Paul will look at the pitfalls that developers can face when trying to delivery the software they have worked hard to develop. Paul will demonstrate that continuous delivery is a great way to face these pitfalls and that it should form a solid part in the application development lifecycle. Paul will show that devops isn’t just a fancy job title and will discuss effective deployment techniques that everyone in a development team can become responsible for.
On leaving this session, developers should take away the belief that delivery should not be stressful and that it should be as easy as clicking a magic button at any time, anywhere.
Outline:
- Discuss the common pitfalls developers face
- Introduce the concept of continuous delivery as a mechanism to cure these pitfalls
- Look at effective deployment techniques that the entire team can take ownership of
- Give reasoned arguments as to why continuous delivery is a great way to deliver software, regardless of the block in place to it. -
Unit Testing With Visual Studio 2012
In the Visual Studio 2012 RC there are major changes to the way unit testing frameworks are implemented, you are no longer limited to MSTest it is now a pluggable model. In this session I will show what is now available ‘out the box’ and what other options are open to allow you to leverage the testing tools you want to use.
-
Using Your NuGet for Fun & Profit (Redux)
The explosive take-up of NuGet clearly demonstrates just how valuable a packaging system for .Net can be.
This session is a refined and improved repeat of that run at DDDSW - it will look the issues surrounding creating NuGet packages for use within your own organisation rather than for general consumption, and will look at the options for hosting a NuGet server both on-site and in the cloud.
It will also demonstrate the NuGet.PackageNPublish tooling released by Landmark at DDDSW4 which makes creating packages to contain your libraries as easy as File->New Project.
-
WebSockets and SignalR - Building the Real Time Interactive Web
by Chris Alcock
In this session we will explore the key concepts of new 'HTML5' WebSockets standard, looking at its implementation on both the client and server, before moving on to look at the use of SignalR for connectivity and RPC between server and client, looking at both browser and alternative client implementation. To conclude the session will explore where these two technologies meet, looking at the use of WebSockets by SignalR.
-
Working Effectively with Umbraco
by Andy Gibson
Umbraco is a Content Management System that has been making waves in the .NET development community lately (for various reasons). Because of it's flexibility, extensibility and relative ease of use for the end-user, It is widely used and very popular with digital agencies using the .NET stack. However being an established CMS there are many tools, patterns and practices you can apply to Umbraco development that can significatntly improve your productivity (and make life a little easier for your designers too!).
This session will cover areas such as:
- Project and folder stucture
- Automation with Rake
- Writing clean code without codebehind (or clogging up your Razor views)
- Optimising use of the Umbraco Node API.
- Hints and tips for faster, more effecient umbraco development
If you're interested in working more effectively with Umbraco, this is the session for you!