SDD 2016 schedule

View as grid

Monday 16th May 2016

  • A day of ASP.NET Core 1.0

    by Dominick Baier and Brock Allen

    There are major changes in the next version of ASP.NET and MVC.

    ASP.NET Core 1.0 is the new modular hosting framework for web applications written in .NET, and ASP.NET Core MVC is the next version of Microsoft’s server-side web framework that unifies MVC and Web API. This release “is a reboot”, as quoted from a project manager on the ASP.NET team.

    The world of ASP.NET is changing significantly, and this day-long workshop will cover these differences. This includes the changes in the hosting model of ASP.NET, how the .NET runtime can be ~/bin deployed to allow applications to be deployed completely self-contained, what changes are being made in MVC to build both HTML and API web applications, and the underlying project and compilation system that will be used to build it all.

    At 9:30am to 5:30pm, Monday 16th May

  • A day of async programming

    by Andrew Clymer and Richard Blewett

    Asynchronous programming is being pushed further into the norm with the introduction of the new async and await keywords. It is therefore becoming more and more important that we write async libraries for our own application stack.

    During this intensive workshop we will do a deep dive into how these new features work, and into the mechanics of how best to deliver asynchronous functionality into your applications.
    We’ll focus not only on asynchronous compute but also on asynchronous IO, and how you can adapt existing old-style APIs to work with the new coolness.

    The two speakers co-authored the Apress book Pro Asynchronous Programming with .NET.

    At 9:30am to 5:30pm, Monday 16th May

  • Angular 2.0 workshop

    by Tiberiu Covaci

    Angular 2.0 is a JavaScript framework brought to you by the same team from Google that brought you the AngularJS framework. This is a completely new framework that, except the name and some of the core team members, has nothing to do with the old version. Angular 2.0 targets modern browsers, and is written in TypeScript, a JavaScript superset developed by Microsoft.

    In this workshop you will learn how to set up the dev environment, the basics of TypeScript and ES2015, and of course the basics of Angular 2.0. At the end of the day, you will have a much better understanding of Angular 2.0, together with a complete solution that you can take home with you so that you can continue to work on it and improve your skills.

    We recommend that you bring a laptop running a modern code editor like Visual Studio 2015, Visual Studio Code, WebStorm, Sublime, or Atom. Power sockets will be available in the classroom - if you're coming from outside the UK, don't forget to bring a plug adapter.

    At 9:30am to 5:30pm, Monday 16th May

  • Building Microservices with Docker

    by Sam Newman

    In this workshop, we’ll briefly introduce the core concepts of Microservices, before diving deep into the details behind how you can build and deploy them. Attendees will participate in a number of interactive exercises using Docker and friends to learn some concrete techniques for managing Microservices, including service discovery, scaling via multi-host Docker, and version management.

    This workshop is definitely more about the ‘how’ rather than the ‘why’.

    At 9:30am to 5:30pm, Monday 16th May

  • Getting better at TDD

    by Seb Rose

    This workshop will explain what TDD is, how and when you should use it, and how to ensure you avoid the common pitfalls that are frequently seen. The day is experiential, and combines hands-on practice with formal instruction.

    At the end of the course delegates will be able to: write better unit tests; explain the testing pyramid and how it underpins test strategies; compare TDD to test­after and test­first development; describe the costs and benefits of TDD; begin to practice TDD in their place of work; contrast the various types of test doubles available; utilise test doubles in their development process; understand how to apply TDD to legacy code.

    The course will be run with delegates working in pairs either in a browser­based development environment provided by the trainer or in a development environment of their choice. Opening introductions will allow the trainer to ascertain the skills/experience mix of the delegates. A group exercise exploring the pros and cons of automated testing follows.

    Topics covered:

    • Foundational unit testing techniques
    • The testing pyramid
    • Introduction to TDD
    • Objections to TDD (and their refutations)
    • Red­/Green/­Refactor
    • Recycling tests and other advanced concepts
    • Four rules of simple design
    • Costs and benefits of automated testing
    • Test doubles (mocks, stubs, fakes and dummies)
    • TDD with legacy code
    • Maintainable test suites
    • “TDD as if you meant it”

    Delegates will be given a reading list and detailed guidance on how to continue to develop their TDD skills once they finish the course.

    At 9:30am to 5:30pm, Monday 16th May

  • Setting up a production monitoring and diagnostic environment

    by Sasha Goldshtein

    Modern applications are extremely complex, and with complexity come difficulties in diagnosing performance issues, memory leaks, crashes, and other problems that might manifest only in the production environment.

    In this workshop, we will review the tools, libraries, and best practices for setting up your production monitoring and diagnostic environment. Through a series of detailed hands-on labs, you will learn how to measure performance in a production environment without interrupting operations, how to automatically diagnose and detect the root cause of crashes and memory leaks, how to identify and display specific objects in memory without suspending or modifying the application code, how to set up alerts for performance issues, and many other topics of relevance.

    At 9:30am to 5:30pm, Monday 16th May

  • Software architecture fundamentals

    by Neal Ford

    The job Software Architect places in the top ten of most annual surveys of best jobs, yet no clear path exists from developer to architect. Why aren’t there more books and training materials to fill this demand?

    First, software architecture is a massive multidisciplinary subject, covering many roles and responsibilities, making it difficult to teach because so much context is required for the interesting subjects. Second, it’s a fast-moving discipline, where entire suites of best practices become obsolete overnight.

    Part one of this workshop focuses on the many elements required to make the journey from developer to architect, covering process topics like the impact of Continuous Delivery on architecture, technical subjects like application, integration, and enterprise architecture, and soft skills. While we can’t make you an architect overnight, we can start you on the journey with a map and a good compass.
    Part two of this workshop takes a deeper dive into application, integration, and enterprise architecture topics, including evaluating architectures via Agile ATAM, the impact of continuous delivery on architecture, comparing architectures, SOA, SOAP, and REST, integration hubs, and enterprise architecture approaches and strategies.

    I conclude the day with a hands-on Architectural Katas exercise, allowing attendees the chance to apply some of the architectural theory covered earlier.

    At 9:30am to 5:30pm, Monday 16th May

  • Software project design

    by Juval Löwy

    Much as the need to design the system, you must also design the project: from scheduling resources behind the services, to tracking your progress across developers, services and phases of completion, to validating your plan, and accommodating changes. This requires understanding the inner dependencies between services and activities, the critical path of integration, the available floats, the staff distribution and the risks involved. All of these challenges stem from your design and addressing them properly is a hard core engineering task – designing the project. In this full day tutorial Juval Lowy shares his approach for software project design, along with his unique insight for delivering software on schedule and budget.

    You will also see to deal with common misconceptions and typical roles and responsibilities in the team. Time permitting, Juval will demonstrate how project design fits into development processes such as Agile, common pitfalls of design in an Agile environment, and how to design the development process for maximum productivity.

    At 9:30am to 5:30pm, Monday 16th May

Tuesday 17th May 2016

  • Keynote - Evolutionary Architecture

    by Neal Ford

    For many years, software architecture was described as “the parts that are hard to change later”. But software architecture is the balancing of capabilities versus constraints. If build changeability is one of your prime capabilities, evolutionary change becomes easier. The Microservice architectural style is quite popular, but it is only one in a family of evolutionary architectures.

    This keynote session defines the characteristics of this family of architectural styles, along with engineering and DevOps practices necessary for implementation. We’ll cover the principles behind evolutionary architectures, the practices needed for success, how organisation and team structure affects these architectures, and specific engineering practices that facilitate evolutionary architectures. We’ll also discuss migration strategies from common existing architectural types towards more evolutionary architectures.

    At 9:30am to 11:00am, Tuesday 17th May

  • Comparing service-based architectures

    by Neal Ford

    Microservice architectures are quite popular, described as “SOA done correctly”. But what are the real differences between these architectural styles? And what about the middle ground between the “shared everything” of SOA versus the “shared nothing” of Microservices? This talk explores the similarities and differences between various service-oriented architectural styles. We’ll examine the characteristics of SOA, Microservices, and hybrid service-based architectures, along with the considerations and constraints for each. We’ll also discuss specific engineering practices, orchestration styles, re-use strategies, and migrating from monolithic applications to service-based or Microservice architectures.

    No one architecture can solve every problem, and many projects take on more complexity than necessary by choosing the wrong paradigm. This session will leave you informed enough to make pragmatic decisions about the appropriate architectural style.

    At 11:30am to 1:00pm, Tuesday 17th May

  • ES2015: the next JavaScript version today

    by Roland Guijt

    ES2015, formerly known as ES6, is the biggest update for the JavaScript language that we've seen for many years, and it introduces a ton of new features. For example, we can now make use of classes with inheritance support, and arrow functions enable you to do functional programming and help with the current problems with this keyword. Not to mention block scoping and builtin promises! In this demo-rich session we'll visit the core new features of ES2015. All of this goodness you can use today, because with the right tools you can transpile to ES5, which is implemented in current browsers. We'll see this in action too.

    At 11:30am to 1:00pm, Tuesday 17th May

  • Immutability

    by Kevlin Henney

    "When it is not necessary to change, it is necessary not to change" observed Lucius Cary, four centuries ago. He could well have been talking about program state (had such a concept existed). We have it by the bucket — by the megabucket, gigabucket and terabucket — and most code, designs and programming languages assume that program state is something that is changeable. But should it be? Is this assumption always valid? Is state change as necessary as its widespread use might suggest? Immutability is a cornerstone of pure functional programming, and is often seen to be exclusively associated with it, but immutability and other restrictions on state mutability are more widely applicable, and certainly not the sole preserve of functional languages. It is a necessary practice in languages with reference-based semantics and in concurrent environments, for example. Without it, code becomes difficult to reason about (oh...) or chock full of locks and deadlocks (ah...). This loss of simplicity may seem familiar.

    This session explores the consequences, benefits and implications of programming in an immutable (or less mutable) style, from value objects and pure functions to persistent data structures and concurrency

    At 11:30am to 1:00pm, Tuesday 17th May

  • Lessons learned: being Agile in a Waterfall world

    by Phil Japikse (MVP)

    Scrum and XP have found a strong following in the development community. But most non-development groups (such as web administrators, production support, security, testing, and users/stakeholders) inside the enterprise are not only far from Agile, they’re not really interested in trying to be more Agile.

    We’ll start with a refresher on Scrum, and then use real-world experiences from large enterprise development projects to teach you how to effectively work with non-Agile teams. Instead of trying to "convert" them, we’ll discuss strategies to adapt to their needs while remaining Agile in the development realm.

    At 11:30am to 1:00pm, Tuesday 17th May

  • Managing your data with React and Redux

    by Jack Franklin

    React gave us a great way to think about components and structuring web applications but with one crucial piece missing: data. React provides no opinions with regards to how to manage data and state through a complex web application. Flux came along to solve this, but at first it had many implementations and picking the right one became tricky. Thankfully one emerged from the rest: Redux (http://redux.js.org/). Redux is an opinionated small framework that provides a mechanism for dealing with your application's state in a logical way that doesn't become a big bunch of spaghetti as your application grows. In this talk I'll take you through the basics of Redux and demonstrate how we can use it to organise all our application's state and data as it changes over time.

    At 11:30am to 1:00pm, Tuesday 17th May

  • The Zen of Azure machine learning

    by Jeff Prosise

    Azure Machine Learning is a cloud-based predictive-analysis service that offers a streamlined experience for developers and data scientists of all skill levels. It's accompanied by the Azure Machine Learning Studio, which is a browser-based tool that allows you to build models using simple drag-and-drop gestures. It comes with a library of time-saving experiments and features best-in-class algorithms developed and tested in the real world by Microsoft businesses such as Bing. In this session, which is built around live demos, you'll get acquainted with Azure Machine Learning and learn why many in the data community consider it the greatest invention since sliced bread.

    At 11:30am to 1:00pm, Tuesday 17th May

  • The Zen of IoT and Azure Stream Analytics

    by Jeff Prosise

    Azure Stream Analytics is a cloud-based service for ingesting high-velocity data emanating from IoT devices, sensors, applications, websites, and other sources and analyzing that data in real time. It supports a SQL-like query language that works over dynamic data streams and makes analyzing constantly changing data no more difficult than querying databases. With Azure Stream Analytics, you can set up jobs that analyze incoming data for anomalies or information of interest and record the results, present notifications on dashboards, or even fire off alerts to mobile devices. And all of it can be done at low cost and with a minimum of effort — frequently without writing a single line of code. In this fast-moving, demo-laden session, you'll get up close and personal with Stream Analytics, see a job analyzing IoT data streams built from scratch, and learn about real-world applications for this service.

    At 11:30am to 1:00pm, Tuesday 17th May

  • Treat your code as a crime scene

    by Adam Tornhill

    We’ll never be able to understand large-scale systems from a single snapshot of the code. Instead we need to understand how the code evolved and how the people who work on it are organised. We also need strategies that let us find design issues and uncover hidden dependencies between both code and people. Where do you find such strategies if not within the field of criminal psychology?

    This session will reveal the wealth of information that's stored in our version-control systems. You'll learn to predict bugs, detect architectural decay and find the code that is most expensive to maintain. Along the way you'll also see how to evaluate knowledge drain in your codebase, learn the social pitfalls of team work and much more. As a bonus you'll get an introduction to both modern offender profiling and its powerful counterparts in the software world.

    To achieve this, the session combines research on software evolution with findings from various fields of psychology.

    At 11:30am to 1:00pm, Tuesday 17th May

  • What the changes in .NET mean to you

    by Kathleen Dollard

    Your tools are changing! After a dozen years, upcoming versions of .NET and Visual Studio will have incremental changes, significant changes implemented incrementally, and a few big changes. This talk is an independent look at the changes in Microsoft tools, and some parallel changes in how Microsoft interacts with the ecosystem. You’ll appreciate how important the new C# and Visual Basic compilers are to future language design and new Visual Studio features. You’ll learn more about the newly designed versions of ASP.NET and Entity Framework, and how they will co-exist with new updates to the existing versions.

    You’ll see the progression of the .NET Framework from a platform specific monolith to the new open source cross-platform version. And you’ll see new language features that will make your code cleaner and more reliable. This talk is designed to answer your questions about how changes in Microsoft tools affect your future development

    At 11:30am to 1:00pm, Tuesday 17th May

  • Agile architecture part 1: from stories to code

    by Allen Holub

    Agile systems must be designed so that they can easily accommodate, and stand up to the stress of, constant change. To do that, they must closely model the user's image of how the system works. Moreover, Agile architectures are developed incrementally as the system evolves, not all at once prior to coding.

    The process of building this sort of architecture starts with user stories and ends up with code. We'll look at how to do that, showing how the story evolves into an architecture using tools like story development, factoring, and CRC cards. We'll also look at essential structural challenges like modularity, and issues surrounding polyglot implementation and Microservices.

    At 2:00pm to 3:30pm, Tuesday 17th May

  • Clean code: writing code for humans

    by Cory House

    Anyone can write code a computer can understand, but professional developers write code that *humans* can understand. This session discusses best practices for writing code in a style that’s easy to create, maintain and comprehend. We have a lofty goal: programming style as documentation. We’ll discuss concrete methods to get you there and give you a vocabulary for pragmatically evaluating code quality. Various refactoring techniques, code smells, and best practices are discussed including fail fast, return early, arrow code, being “stringly typed”, the outline rule, and table-driven methods. While examples are in C#, coders in any language should be able to follow along and apply the principles discussed.

    At 2:00pm to 3:30pm, Tuesday 17th May

  • Consuming REST APIs, for all interpretations of REST

    by Darrel Miller

    There is a growing API economy. Almost every software business is either starting to consume APIs or produce APIs for others to consume. When it comes to building APIs, REST has won the popularity contest, but from a technical perspective the term has little meaning. Everyone has their own definition.

    This talk will discuss how to efficiently consume an API whether it is the simplest list of HTTP endpoints with JSON payloads, or hypermedia-driven using bleeding edge, content negotiated, media types. We will talk about how to build re-usable and resilient client code that can insulate your client application from the dreaded V2 API. You will hear lots of practical guidance and insight that is not commonly discussed. Whether you are new to REST or an experienced practitioner, I believe you will leave this session with some fresh perspectives on the subject.

    At 2:00pm to 3:30pm, Tuesday 17th May

  • Introduction to ASP.NET Core MVC

    by Brock Allen

    ASP.NET Core MVC is the next version of Microsoft’s server-side web framework, and its main feature is the unification of ASP.NET MVC and ASP.NET Web API. This is a major release with the framework redesigned to accommodate this merge. Additionally, Core MVC is designed to run in ASP.NET Core 1.0 which is a new hosting layer for ASP.NET applications. This session will bring you up to speed on everything you need to know about the new Core MVC.

    At 2:00pm to 3:30pm, Tuesday 17th May

  • JavaScript for C# programmers

    by Kevin Jones

    If you're a C# programmer you may well have been asked to write JavaScript in your day job, or you may be wondering what all the fuss is about. JavaScript is enough like C# to be dangerous to the uninitiated, so this talk aims to remove some of that danger. We'll cover the similarities and the differences. The syntax of the two languages is similar, and we will cover this very briefly, but the scoping rules are different. Once we have that out of the way we’ll move onto the two big things: functions, and the dynamic nature of the language. C# has dynamic types and lambdas, both of which have been added to the language fairly recently, whereas with JavaScript these were built in from the start.

    We’ll examine the power and flexibility that they give the language. We will also cover some JavaScript patterns that let you provide similar data hiding mechanisms that you get in C#. Come along and learn why JavaScript is not the toy language that other people may have told you it is.

    At 2:00pm to 3:30pm, Tuesday 17th May

  • Optimising the query stack of layered applications

    by Dino Esposito

    The best-selling point of CQRS that makes the pattern look like common sense to many developers is that you keep write and read stacks completely separated, and based on different models and even different implementation patterns and technologies. In this talk, we’ll first use CQRS architecture to physically separate read and write code and then discuss ad hoc storage, event sourcing, and DB snapshots. Finally we’ll focus on the query stack and build a sample read-only domain layer where the Entity Framework context and LINQ extension methods work together to deliver you a pseudo query language that looks amazingly similar to the language actually spoken by experts in the business domain.

    At 2:00pm to 3:30pm, Tuesday 17th May

  • Power debugging with Visual Studio 2015

    by Andrew Clymer and Richard Blewett

    All developers know how to use F9 to set a breakpoint, but do you really know how to debug effectively inside and outside Visual Studio?

    This talk will showcase the new features of the debugger in Visual Studio 2015 (CPU, and memory usage), along with some that you probably never knew existed.

    At 2:00pm to 3:30pm, Tuesday 17th May

  • Top 10 Entity Framework features every developer should know

    by Phil Japikse (MVP)

    In this session, I’ll take you through my favourite features of Entity Framework, which will significantly improve your productivity and ease of maintaining your data access code.

    At 2:00pm to 3:30pm, Tuesday 17th May

  • Agile architecture part 2: nuts and bolts

    by Allen Holub

    Successful Agile development projects have an architecture that reflects the needs of the process. You simply can't accommodate changing requirements or refactor effectively if your system isn't designed to accommodate those practices. This class shows how good (and bad) structure affects agility, and explores design principles that keep your design on track in an Agile environment.

    We'll look, specifically, at the SOLID principles (Single-Responsibility, Open-Closed, Liskov-Substitution, Dependence-Inversion), and Interface-Segregation principles, and at how design patterns improve agility, and at several common practices that can sabotage your project.

    Finally, we'll look at good OO structure, with a focus on Fragile Base Classes and Implementation Hiding.

    At 4:00pm to 5:30pm, Tuesday 17th May

  • An introduction to TypeScript

    by Andrew Clymer and Richard Blewett

    TypeScript lets you write JavaScript the way you really want to. TypeScript is a typed superset of JavaScript that compiles to plain JavaScript. For the C# developer TypeScript brings sanity to JavaScript development. The decision by Google to write Angular 2.0 in TypeScript suggests that TypeScript is here to stay.

    This talk is designed to introduce the C# developer to the world of web development without having to know too much about JavaScript.

    At 4:00pm to 5:30pm, Tuesday 17th May

  • Building smart apps with Azure Machine Learning

    by Jeff Prosise

    Azure Machine Learning is a cloud-based service for building models that "learn" from data presented to them, and use it to perform predictive analytics. But it’s not just interesting to data scientists. Developers can leverage it too, to build apps that are smarter than ever before, whether the goal is to do credit card fraud detection, offer online shopping recommendations, or anything else that fits the machine-learning mold.

    In this demo-heavy session, Jeff builds an ML model from scratch, wraps a Web service around it, and builds a client app that uses the model. If you don’t leave this session with ideas for building better apps, then you slept through the entire presentation!

    At 4:00pm to 5:30pm, Tuesday 17th May

  • C# 6

    by Kathleen Dollard

    C# 6 offers features to help you write clean and concise code. Explore auto-property initialisers and getter only auto-properties. See the sometimes subtle effects of features like using static members and exception filters. Simplify your code with index initialisers and expression bodied members. Make your code more robust with await in catch/finally, null-conditional operators, the nameOf operator and string interpolation. Find out what #pragma does and have a chance to ask about features that were cut. The team and community are already working on ideas for C# 7. The talk closes with a discussion of the process and some of the exciting features being considered.

    At 4:00pm to 5:30pm, Tuesday 17th May

    Coverage video

Schedule incomplete?

Add a new session

Filter by Day

Filter by coverage