•  

Sessions at SDD 2016 on Tuesday 17th May Breakout sessions

View as grid

Your current filters are…

  • 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

  • Dawn of the reusable web: diving into web components

    by Cory House

    Modern web developers face some big problems. We’re drowning in a sea of div tags and JavaScript libraries. Our markup isn’t semantic. And there’s no standard for creating reusable components that can be shared across projects. But there’s great news: Web components are coming to the rescue, and will dramatically redefine the way web apps are built. Learn how to create rich, powerful, and reusable components using simple tools you've likely already mastered: HTML5, JavaScript, and CSS. Explore the mysterious Shadow DOM and learn how to extend HTML by creating your own custom elements. We’ll explore the current state of web components and consider what the future holds.

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

  • Leveraging cloud with Visual Studio Team Services

    by Martin Hinshelwood

    With the new features in Visual Studio Online there really is no need to keep that local TFS server around. Not only that, but many people are taking advantage of the opportunity to move from TFVC to Git while sticking with TFS. Come and see Martin show you how to migrate to Visual Studio Online, and how to avoid the common pitfalls.

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

  • SOLID deconstruction

    by Kevlin Henney

    The SOLID principles are often presented as being core to good OO design practice. Each of S, O, L, I and D do not, however, necessarily mean what programmers expect they mean or are taught. By understanding this range of beliefs we can learn more about practices for objects, components and interfaces than just S, O, L, I and D. This talk reviews the SOLID principles and reveals contradictions and different interpretations. It is through paradoxes and surprises that we often gain insights. We will leave SOLID somewhat more fluid, but having learnt from them more than expected.

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

  • Ten things you need to know about SpecFlow

    by Seb Rose

    SpecFlow is quite a recent addition to the software development toolbox. Sometimes it feels like we’re using a hammer to drive in a screw, so in this session we’ll explore what it’s good for and when to use it. We’ll also look at what problems it doesn’t help with and when not to use it.

    As you might expect, I’m a huge fan of using SpecFlow, as part of a well thought out approach to Behaviour Driven Development (BDD) or Specification By Example (SBE). I’ve also seen the pain of organisations who have tried using SpecFlow from a pure test automation perspective, and this is one of the misapplications that we’ll talk about.

    We’ll look at a further 9 specific, actionable recommendations for using SpecFlow well, including how to write maintainable executable specifications, organising large suites of specifications in an accessible way, and where SpecFlow fits into an Agile development process.

    By the end of this session you’ll know enough to decide whether your problems are more like a screw or a nail – and whether SpecFlow is the right tool.

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

Schedule incomplete?

Add a new session

Filter by Day

Filter by coverage