SDD 2017 attendee, looking for slides, code samples or session videos? – Click here

SDD Deep Dive 2017 Workshops

Show all presentation descriptions

Tuesday 7 November 2017

9:30

9:30–17:30

3-Day Workshop

WRK-01 Hands-on software architecture fundamentals

Neal Ford

Show/Hide description

One of the primary skills an architect must have is the ability to create, document, and communicate software architectures. Unfortunately, too many architects lack proficiency in this skill, ultimately resulting in applications that don’t meet the needs of the business.

This three-day hands-on architecture workshop provides you with the knowledge and skills necessary to effectively create, document, and present software architectures. Through interactive course materials and architecture exercises, this course teaches how to analyze your business and technical needs, select the right architecture style and pattern, define architectural components, and effectively diagram and document your software architecture.

Through interactive exercises you learn how to identify key architectural characteristics that shape your software architecture. Using those characteristics, you then learn how to analyze and use various architecture patterns and styles to make intelligent choices to determine which architecture style best suits your particular needs.

While knowing what architecture pattern best fits your situation is critical to the success of your architecture, that is only the start. Creating an architecture is also about the ability to identify and define architectural componentsthe building blocks of any software architecture. In this workshop you also learn how to identify architectural components and iteratively refine the granularity of those components. You also learn about component coupling and cohesion and the important role they play in creating and maintaining an architecture.

In addition, you learn evolutionary architecture techniques that help evolve your architecture over time to allow flexibility in the face of constant change. Through interactive exercises you also learn how to effectively diagram your architecture, document your architecture, and finally present your architecture to key stakeholders as well as developers.

This workshop is designed to be technology-agnostic, so all of the materials presented apply to any platform or language.

Day 1

Workshop logistics and introductions
Identifying architecture characteristics
Exercise: Architecture characteristic kata
Understanding monolithic architecture patterns
- Layered
- Pipeline
- Microkernel
Understanding distributed architecture patterns
- Microservices
- Service-Oriented
- Service-based
- Event Driven
- Space-based

Day 2

Domain-specific architecture patterns
- CQRS
- LMAX
Exercise: choosing proper pattern kata
Creating hybrid architecture patterns
Identifying architectural components
Refining component granularity
Exercise: defining components
Understanding component coupling
Understanding component cohesion

Day 3

Diagramming software architecture
Documenting software architecture
Presenting software architecture
Exercise: present your architecture solution
Building evolutionary architectures
Exercise: define fitness functions to protect architecture characteristics
Composite architectures
- Building reactive architectures with simple event queues
- Hybrid service/microservice architectures
- Migrating between architectures

Workshop Information Sheet

9:30–17:30

3-Day Workshop

WRK-02 Mastering ASP.NET Core with Angular

Chander Dhall

Show/Hide description

9:30–17:30

3-Day Workshop

WRK-03 Practical Microservices: nuts and bolts (architecture to implementation)

Allen Holub

Show/Hide description

Microservice architectures break up monolithic server-side applications into a system of small cooperative independent actors. Microservice systems have unique challenges – they must be designed in a domain-focused way to be maintainable, and building them is not as easy as one might think, given that they must be secure, very lightweight, platform neutral, language independent, and independently deployable.

Your service system must be built around appropriate logical and physical architectures and technology, or you will lose all the benefits. There’s a lot of ‘devil in the details’.

This class is a deep dive into all aspects of microservice design and implementation. You’ll learn how to design microservice systems that are easy to maintain and deploy. You’ll learn the real-world issues of implementing services on a lightweight messaging framework, and accessing those services securely over a web portal. The focus is on the practical, with particular emphasis on decoupling services from each other and eliminating single points of failure (like brokers and centralized discovery/scaling).

This is an architecture class, but we’ll look at a lot of code as well.

What you’ll learn

You’ll understand exactly what a microservice is and how to build one
You’ll learn about various approaches to service architectures, both orchestrated and choreographed
You’ll learn how to design effective service-based architectures around your problem domain
You’ll learn how to get large clouds of cooperating services to interact effectively and reliably
You’ll learn the real-world issues surrounding service construction and deployment
You’ll learn the pitfalls of microservice-based systems and how to correct for them

Prerequisites

There will be several code examples in C#, so a reading understanding of that or a similar language (Java, C++, Swift) will be helpful.

Day 1

What is a Microservice?
Characteristics of a microservice; the good, the bad, and the ugly; Agile and other volatile-requirements environments; impact on the development organization and processes; testing difficulties and deployment strategies; moving from the monolith; Conway’s law; how architecture impacts the organization.

Logical architecture
Mini, micro, or nano; reactive services vs. objects; domain-focused architecture & DDD; essential design principles and patterns; responsibility-based design; bounded contexts; implementation hiding; Active Object (actor); eventual consistency; statelessness; incremental design and development; going from stories to code.

Hands-on exercise: logical architecture

Day 2

Hands-on exercise: logical architecture (continued).

Physical architecture
Essential patterns (single-method cloud services, reactive, proxy, router mesh, fabric); inappropriate infrastructure (languages etc.); interfacing to the outside world; communications infrastructure and messaging; UI architectures (Presentation/Abstraction/Control)

Inter-service communication
REST-less communication; lightweight messaging; ZeroMQ compared to Rabbit and Kafka; PubSub vs push/pull; Brokerless, point-to-point communication

Orchestrated systems
Containers (Docker); UCP, DDC, DCR

Choreographed systems
Eliminating single points of failure; service swarms (decentralized self-scaling fabrics); emergence; decentralized discovery (registries) and scaling; startup (cloning); shutdown; hot updates

Hands-on exercise (time permitting): building a messaging-based service.

Day 3

Reliability/health
Heartbeating; monitoring; circuit breakers; bulkheads; testing vs alarms

Security
User; inter-service; every service is an attack surface; service-specific attacks

Deployment and platforms
Service independence; VMs, Amazon EC2, Lambda; AWS containers; Azure Container Services; Azure Service Fabric

Workshop Information Sheet

9:30–17:30

3-Day Workshop

WRK-04 Identity & access control for modern web applications & API using ASP.NET Core

Dominick Baier

Show/Hide description

Modern application design has changed quite a bit in recent years. “Mobile-first” and “cloud-ready” are the types of applications you are expected to develop. Also, to keep pace with these demands, Microsoft has revamped their complete web stack with ASP.NET Core to meet these architectural demands.

Needless to say, you also have to secure these apps.

Multi-platform, multi-client, and highly-mobile users bring a new set of challenges, so the approaches of the past are no longer appropriate for modern applications. This three-day workshop is your chance to dive into all things security related to these new technologies. Learn how to securely connect native and browser-based applications to your back-ends and integrate them with enterprise identity management systems as well as social identity providers and services.

This workshop covers everything you need to know to build modern and secure web, native & mobile applications. The foundation will be Microsoft’s latest technology stack, but will also include IdentityServer4, which is the officially recommended framework for building token services.

The class covers the following content and six hands-on labs.

Foundation & Authentication
- Identity & Access Control in .NET Core
- ASP.NET Core Security Framework
- Claims-based Identity
- Cookie-based Authentication
- Social Logins (e.g. Google, Facebook, Twitter, etc.)
- OpenID Connect
- Data Protection
- Authorization
- Web Application Patterns
- Single Sign On/Single Sign Off
- Claims Transformation
- Federation Gateway
- Account & Identity Linking
- Home Realm Discovery
Web APIs & Access Control
- Securing APIs
- Architecture & Scenarios
- Token-based Authentication
- OAuth 2.0
- Clients
- Scopes
- Flows
- Token lifetime management
- Refresh tokens
- OpenID Connect & OAuth 2.0 combined
- Server to Server communication
- Native & mobile Applications
- SPAs
- Custom credentials & token requests
IdentityServer Architecture & Scenarios
- Setup
- Configuration
- Dependency Injection
- Services
- Customizations
- Claims & tokens
- User interface
- Storage system
- UI Workflows
- Logging & eventing
- Hosting & deployment

Hands-on Labs

The hands-on labs each take one to two hours and include step-by-step instructions and reference solutions.

ASP.NET Core Authentication and Authorization
In this lab you will add cookie-based authentication to the movie review website using the cookie authentication middleware and claims-based identity. Once users are authenticated, you will then also implement policy-based and resource-based authorization using the ASP.NET Core authorization framework.

External Authentication
In this lab you will remove the local authentication in the movie review application and change it to use external authentication. For the first part, you will use the OIDC protocol and use IdentityServer as the provider. For the second part, you will use social media accounts as the provider.

Federation Gateway
In this lab you will consolidate all external authentication into a single authentication gateway. IdentityServer will act as this gateway. You will also implement single sign-out which allows the user to sign-out of both the movie web app, and IdentityServer.

Web APIs
In this lab the movie review logic has been split into two projects: one for the back-end movie review logic as a web API, and one for the front-end movie review UI as a web application. The web API will require access tokens to use its functionality, and the movie review web app will obtain access tokens and pass them to the web API. IdentityServer will be used to issue this access token to the movie review web application.

Mobile and Native client applications
In this lab the client application is a native, cross-platform console application. The pertinent steps in this lab will be the same if you’re building a Windows or macOS desktop application, and are no different than if you were to use a platform-specific UI framework to build your application (WinForms, WPF, MacApp, Cocoa, GTK#, etc).

JavaScript client applications
In this lab the movie review application has been rewritten as a pure JavaScript-based application. It won’t have as much functionality as the previous labs, but it will suffice to show how to obtain an access token and call a web API.

Workshop Information Sheet

9:30–17:30

3-Day Workshop

WRK-05 .NET under the hood – how stuff actually works

Andy Clymer

Richard Blewett

Show/Hide description

Lift the simple veneer of the .NET platform and really understand what makes it tick! We’ll unpick key parts of the framework and demonstrate how they work, enabling you to code more effectively and to gain bank of knowledge to help you understand why.

As well as talks, the three days will include hands-on workshops. All you will need to bring is a laptop running VS2015 or above, and a mind that’s keen to learn.

Session 1: Peeling back the .NET type system

All developers know how to create types, but do you really understand the difference between reference types and value types? When should you use a value type over a reference type, what limitations exist with value types, and what benefits do you get from using a value type? In this session we will answer these questions and many more, looking at various aspects of the .NET type system including generics and nullable types.

Session 2: Plugins and AppDomains

There are several ways of making applications and frameworks extensible in terms of layering and using abstractions. However, to make applications extensible beyond compile time introduces another set of issues: how are extensions/plugins discovered? How can you restrict what a plugin is allowed to do? How can you load a new version of a plugin without restarting the application? We’ll look at reflection, attributes and AppDomains, and see how they can be used to create flexible, extensible frameworks.

Session 3: Language mechanics, it’s a kind of magic

In the early days of C# there was virtually a 1-1 mapping between C# and IL. Much has changed, and the developer is now encouraged simply to describe their intent and the compiler builds the appropriate code. This session will dive under the hood and show how various C# features like events, iterator methods, anonymous methods, extension methods, dynamic and many more all result in code gen by the C# compiler. These layers of abstraction initially make us more productive, but sometimes they hide those hard-to-find bugs, & can add a deluge of performance implications that once we understand how the mechanics of the features work we can quickly fix.

Session 4: LINQ, from the ground up

Most developers use LINQ on a daily basis, but do you really understand how LINQ works? Building on the knowledge from Session 3, we will re-implement LINQ for Objects from the ground up. We’ll show how LINQ works, and reduce the many gotchas that developers encounter when using LINQ. Having established how LINQ to Objects works we will then move on to understanding how LINQ works with non-object stores such as relational databases. Again, with a solid knowledge of how LINQ works with these kinds of stores we can eliminate much of the head scratching that occurs when things go wrong.

Session 5: Rx, from the ground up

Reactive Framework is a library that uses the .NET IObservable interface and LINQ to create a compelling new programming model that allows you to build “event” based code with declarative LINQ statements. This session allows us to see the mechanics of how it works.

Session 6: Understanding asynchronous programming

Creating units of work that run at the same time is a key concept of asynchronous programming both for compute and IO. In this session we will look at the Task abstraction and how it can be used in various ways to create asynchronous work. Once asynchronous work is running we will look at how we can observe and cancel the asynchronous operations. Finally, we’ll look at how we can write our own implementation of the Task abstraction, to allow any asynchronous behaviour to be described as a Task.

Session 7: Working safely and effectively with asynchronous programming

Asynchronous programming requires careful attention to detail since most objects are not designed with multithreaded access in mind. This session introduces the importance of synchronization using a variety of synchronization techniques from Interlocked and Monitor-based synchronization, to reader write locks to concurrent data structures, and lock free algorithms (to name just a few). Along the way, we’ll discuss the merits and costs associated with each technique, giving you an insight into which to use, with the hope that next time you won’t just opt for the lock statement.

Session 8: Async and Await

.NET 4 introduced the new “task” abstraction, and C# 5 takes advantage of integrating this into the language via the async and await keywords. Furthermore, the new task abstraction promotes a new way of architecting asynchronous behaviour; in this session we will explore how to take advantage of these keywords and other new types and features being exposed in the next version of .NET to deliver far simpler asynchronous Windows UIs.

Session 9: Inside the Garbage Collector

The garbage collector has been part of .NET since its inception. However, exactly how the GC works is often shrouded in mystery. Also, the fact that memory management is automated doesn’t release the developer from caring about memory issues –it’s just that those memory issues appear in a different guise. In this module we take the lid of the GC, look at how it works and is optimized, and then assess what this means for you when you are writing your code: things you do that can help the GC and things that cause it problems.

Session 10: Power debugging

There are many debugging problems for which VS provides very little support – particularly threading and memory management issues. WinDbg and the plugin SOS.DLL bring a new set of tools to .NET developers which can provide insights that help you solve bugs that you see during testing, but also allow you to diagnose issues occurring in production systems where the only data you can get is a crash dump file.

Workshop Information Sheet

9:30–17:30

3-Day Workshop

WRK-06 Building Cloud-based applications with Microsoft Azure

Jeff Prosise

John Garland

Show/Hide description

In the early days of cloud computing, the “cloud” was mostly a place to park data and spin up virtual machines. Today it is much more. In addition to providing access to traditional storage and compute resources on Linux as well as Windows, Microsoft Azure includes extensive infrastructure options, rich management and analytical tools, and dozens of services to aid developers in building intelligent services and applications. Learn about the various features that Azure has to offer and how to use them to build super-scalable applications in this 3-day, hands-on workshop. All you need is a laptop with Windows 10 and Visual Studio 2017 installed; we will provide the rest!

Day 1 – Infrastructure and Core Services

Session 1: Introduction to Microsoft Azure
Learn what Azure is and what services it offers. Learn the basics of architecting cloud-based apps, and then activate your Azure Pass and apply what you learned to building your first-cloud-based application.

Session 2: Azure Compute
Learn about the various Azure compute services, how they’re used, and how they work. Learn how to deploy VMs and clusters of VMs that are networked together to form HPC clusters. Also learn the basics of Docker, the world’s most popular containerization platform, and learn how to deploy containerized workloads to the cloud using Azure Container Service.

Session 3: Azure Storage
Learn how to store data in the cloud by leveraging Azure Storage services such as Blobs, Tables, and Queues. Learn how to manage these services using the Azure Storage Explorer and how to interact with them using REST APIs and packages that wrap those APIs. Also learn about other ways to store data in the cloud, including Azure DocumentDB and Azure SQL.

Session 4: Azure Active Directory
Learn about the identity and access-management services that Azure provides and how to use them to secure your applications and implement single sign-on.

Day 2 – Applications, Services, and Microservices

Session 1: Azure App Service – Web Apps, API Apps, and Mobile Apps
Learn how to host Web apps and Web services in the cloud, how to use Easy Tables and Easy APIs to store data and expose REST endpoints, how to implement push notifications and data syncing in mobile apps, and more.

Session 2: Azure App Service – Logic Apps
Learn how to implement complex workflows in the cloud using Azure Logic Apps. Then put your newfound knowledge to work building an app that removes potentially offensive content from a Web site and sends e-mail notifications to a service administrator.

Session 3: Azure App Service – Azure Functions
Learn how to use Azure’s newest compute service to deploy functions written in C#, JavaScript, PowerShell, Python, or other languages that run in response to blob triggers, timer triggers, WebHooks, and other stimuli.

Session 4: Azure Service Fabric
Learn how to use Azure Service Fabric to build microservice-based applications that feature automatic fail-over and that can scale to meet to the heaviest demands.

Day 3 – Intelligence and Analytics

Session 1: Azure Stream Analytics
Learn how to use Azure Stream Analytics to extract information from high-velocity data streams originating from IoT devices and other data sources. Then use what you learned to build a real-time dashboard for Stream Analytics output.

Session 2: Microsoft Cognitive Services
Learn about the 24 APIs available in Microsoft Cognitive Services for building intelligent apps. Then use the Computer Vision API to automatically caption photos uploaded to a Web site and generate search metadata from the objects in the photos.

Session 3: Azure Machine Learning
Learn how to use Azure Machine Learning to build sophisticated machine-learning models that perform optical character recognition, fraud detection, image classification, and more, and how to deploy models to the cloud as REST services. Then build a model that uses a public dataset to perform optical character recognition, deploy it to the cloud, and write a character-recognition apps that uses the model.

Session 4: Azure DevOps
Learn about the role of Azure in DevOps and how to use it to streamline your software-development processes.

Workshop Information Sheet

9:30–17:30

3-Day Workshop

WRK-07 I will make you a better C# programmer (2017 functional edition)

Kathleen Dollard

Show/Hide description

Get better at what you do by spending three days focusing on C#/.NET fundamentals and functional techniques. C# and .NET are powerful, flexible and changing. The power and flexibility comes with a cost in complexity, and occasionally surprises. Changes open doors to new techniques to learn about. If you’re an intermediate or advanced C# developer, you’re ready to for this combination of fundamentals and theory, along with its practical application as you watch a sample application transform across the three days.

This year’s workshop includes applying functional techniques in C#. You’ll learn some theory, so you can explain the changes to your team. And you’ll see specific, pragmatic ways functional techniques improve your code.

Purity, referential integrity and removing side effects refer to removing all state dependencies, so that results are entirely predictable. Teamed with immutability, code becomes easier to trust, understand and test. Because you use LINQ, you use first-class and higher order functions, along with generics. You’ll see this extended to solve broader application problems. You’ll learn about pattern matching as a new control flow structure in C# 7 and see how it reduces code and makes it easier to understand.

Combining these ideas with isolation of technology from domain, results in a simple application infrastructure with most code moved into pure methods and declarative flows.

Of course all your code is not simple and neat! A valuable consequence is that simple code fades into common patterns allowing the complex code that needs your attention to stand out. Declarative refactoring makes this code much easier to understand.

You’ll also see why some techniques, such as lambda calculus and heavy use of recursion don’t make sense in C#.

The workshop also includes .NET fundamentals. You’ll take a deep dive into common .NET features like LINQ, puzzles on types and overloads, and how to achieve immutability. You’ll see the different roles asynchronous programming plays on the server and in desktop apps, along with right and wrong things to use async and await in C#. And you’ll also look at design issues such as how generic designs increase code reuse at the cost of coupling, when interfaces make sense, and the role of dependency injection.

It’s easy to postpone production and quality considerations while you’re writing your application. You’ll see testing strategies applied to the sample application. You’ll also see logging/tracing added and how to use this alongside the logging information that’s already provided by .NET and Entity Framework. And you’ll learn how to do light profiling and performance evaluation.

Most of the workshop is in the full .NET framework, but you’ll also see the final version of the sample application changed over to .NET Standard.

Applying these techniques to your application and team takes knowledge, understanding and leadership. In bits and pieces, to cleanse your palate between the deep dive sessions, you’ll spend some time on skills designed to make it easier for you to change your team’s coding style after the workshop.

This workshop teaches intermediate and advanced developers to leverage that power by using new, misunderstood and underutilized techniques. This workshop goes deep right where you need it. If you’re an intermediate or advanced C# developer, you’ll leave this workshop creating better C# code faster.