SDD Deep Dive 2015 Agenda Summary
Tuesday 8 November to Thursday 10 November 2016 (daily)
WRK-01 Angular 2 fundamentals
This workshop is designed to get you started on the right path to building Angular 2 applications by creating an application from scratch while demonstrating various capabilities of Angular 2.
From setup to deployment, we’ll look at how to build Angular components and tie the components together with routing. We’ll create forms and use HTTP communication with a Web API. Services, observables, templates, and filters will all play a role in building the application, and by the end of the workshop you will have all the required knowledge to start your own project.
Topics that we’ll cover in-depth over the three days include:
- An Introduction to Angular 2
- Working with TypeScript and ECMAScript 2015
- Decompose an application with Routing features
- Creating services and using dependency injection
- Building components in-depth
- Working with HTML templates and the new Angular 2 binding syntax.
- When to create low level directives
- Unit testing and packaging for production
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 1.0 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 two-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.
Technologies covered: .NET Core, ASP.NET Core, MVC, Web APIs, Claims, OpenID Connect, OAuth 2.0, WS-Federation, SAML, JSON Web Tokens, Single Sign-on and off, Federation, Delegation, Home Realm, Discovery, CORS
Day 1: 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
- Web Application Patterns
- Single Sign On / Single Sign Off
- Claims Transformation
- Federation Gateway
- Account & Identity Linking
- Home Realm Discovery
Day 2: Web APIs & Access Control
- Securing APIs
- Architecture & Scenarios
- Token-based Authentication
- OAuth 2.0
- Token lifetime management
- Refresh tokens
- OpenID Connect & OAuth 2.0 combined
- Server to Server communication
- Native & mobile Applications
- Custom credentials & token requests
Day 3: IdentityServer Architecture & Deep Dive
- Dependency Injection
- Claims & tokens
- User interface
- Storage system
- Logging & eventing
- Hosting & deployment
Writing software is not the creative game that sometimes it appears to be. Writing software is sometimes sold as an exercise of abstraction, design and analysis but it is mostly about building concrete stuff for the customer to use. And especially these days, customers hardly accept to face a software that is not easy and effective to use. No clear learning path exists to take developers to become architects and architects to become better architects Today the only good architect is the architect who deeply understands the business domain and can play two roles at the same time: the classic software architect and the UX architect. Many aspects of software architecture can be abstracted away from technology but, at the end of the day, when it comes to building stuff for the customer you choose one primary platform and a collection of concrete technologies. This workshop finds its place in the realm of Microsoft .NET and all presented technologies come from the Microsoft Web stack.
In the first day, the workshop focuses on patterns and pragmatism, estimates and no-estimates, impact of technology on the overall design. Practical methodologies like DDD and ubiquitous language, event storming, UX-driven design, and even TDD will be discussed in the context of the .NET Framework and the C# language so that hopefully everyone can find the right combination of tools and techniques to take projects home closer to time and budget constraints.
For the second day we stick to one architecture pattern —the layered architecture as it was originally formulated in DDD a decade ago. Using a few real-world examples (and excerpts of code and architecture from real .NET projects) we’ll set up the various layers in an unusual top-down fashion. You’ll be surprised to see how the architecture right for the job emerges naturally and ends up matching most of the buzzwords you may hear today like CQRS, infinity cloud scalability, polyglot persistence, NoSQL databases, and the like.
The third day has the largest impact on the actual code you may be writing. It starts from the core fact that every application, including very large applications, is a CRUD in some way. There are at least two variations of CRUD applications you might come to grips in the near future as customers start looking more into flexible and user-centred features and in-house business intelligence tools - historical CRUD and social CRUD. The foundation for both is that crazy little thing called event sourcing - nothing really new in software but something really mind-blowing for architects (and users) these days. We’ll see handmade implementations of events using Entity Framework and SQL Server as well more specific event-based persistence tools such as EventStore and Memento.
In the end, the workshop doesn’t follow a push model and doesn’t aim at restructuring your technical and analytical skills. It presents tips-from-the-trenches of production projects and leave it there for you to pull just what you like and reckon helpful. Even the plain validation of your current practices.
This three-day instructor-led workshop provides attendees with the knowledge and skills to develop and diagnose applications with .NET Framework 4.6 and Visual Studio 2015. Developing applications for the .NET Framework requires familiarity with fundamental mechanisms such as Garbage Collection, Serialization, and Application Domains; taking advantage of the latest hardware requires Multithreading and Asynchronous Programming; Diagnosing our applications requires familiarity with profiling and monitoring tools. The workshop is packed with practical code samples, demos and exercises to facilitate understanding the covered features from a .NET perspective, as well as from a more holistic system-oriented point of view.
During this 3-day workshop, we will cover the following topics:
- Overview of the .NET Framework
- Overview of the .NET Type System
- Visual Studio and .NET Framework Versions
- .NET Backwards and Forwards Compatibility
- Visual Studio Multi-Targeting Support
- Memory Management
- Overview of Memory Management
- Garbage Collection First Steps
- GC Flavors
- Interacting with the GC
- Weak References
- Finalization and the Dispose pattern
- Threading and Asynchronous Programming
- Taxonomy of Multi-Threading
- Manual Threading
- Thread Pool
- Asynchronous evolution in .NET
- Async Programming Model (APM)
- Event Async Pattern (EAP)
- Task Parallel Library (TPL)
- Concurrent Collections
- Application Domains
- Application Domains as Isolation Boundaries
- Creating and Unloading AppDomains
- Executing Code in an AppDomain
- AppDomain Boundaries
- Debugging and Diagnostics
- Performance Counters
- Process Explorer
- Process Monitor
- Performance Profilers
- Visual Studio Debugging Tools
- Dumps 101 with Visual Studio
One of the primary skills an architect must have is the ability to create, document, and communicate software architectures. Unfortunately, too many architects haven’t gained the right level of proficiency in this skill, resulting in applications that don’t meet the needs of the business.
This three-day hands-on architecture workshop is designed to provide you with the knowledge and skills necessary to effectively create, document, and present software architectures. Through interactive course materials and architecture exercises, this course will teach you how to analyze your business and technical needs, select the right architecture style, create architectural components, and effectively diagram and document your software architecture.
Knowing where to start is exactly where we begin the workshop. Through interactive exercises you will learn how to identify key architectural characteristics that shape your software architecture. Using those characteristics, you will then learn how to analyze and use various architecture patterns and styles to make intelligent choices as to which architecture style is best suited for 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 being able to identify and define architectural components – the building blocks of any software architecture. In this workshop you will also learn how to identify architecture components and refine the granularity of those components. You will also learn about component coupling and cohesion and the important role they play in creating an architecture.
Along the way, you will learn evolutionary architecture techniques that will help you evolve your architecture over time to allow your architectures to remain flexible in the face of constant change. Through interactive exercises you will 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.
- Workshop logistics and introductions
- Identifying architecture characteristics
- Architecture characteristic kata exercises
- Understanding monolithic architecture patterns
- Understanding distributed architecture patterns
- Event Driven
- Understanding architecture techniques and styles
- Creating hybrid architecture patterns
- Identifying architectural components
- Refining component granularity
- Understanding component coupling
- Understanding component cohesion
- Putting it all together (architecture kata exercises)
- Patterns of evolutionary architecture
- Software architecture anti-patterns
- Diagraming software architecture
- Documenting software architecture
- Presenting software architecture
- Diagram and presentation kata exercises
Microservice architecture decomposes monolithic applications into discrete, atomic, full-stack service silos. It's patterns and principles take over where Service-Oriented Architecture left off by including recent advances in containerization and DevOps culture. In fact, embracing Microservice architecture forces you into better practices related to design and operations – by necessity – but arguably as it should be. It embraces modern patterns and practices, including Domain-Driven Design, single responsibility pattern, bounded context pattern, service-orientation, Conway’s Law, and heterogeneous development stacks.
This 3-day workshop begins with a journey through the evolution of Microservices principles and patterns, followed by design discussions of real applications and visual topologies, and then you will get a deep dive into the platforms and tools. You’ll learn the process of design, development, deployment, upgrade, scale and operations for Docker-based solutions; hosted container and Microservices platforms provided by Docker, Google Cloud, Amazon Web Services and Microsoft Azure.
Day 1: Microservices design, concepts and container foundations
- The goal of day 1 is to discuss Microservices design principles, how to approach a new solution or existing solution migration; and gain a fundamental understanding of Docker and containers which informs other platform discussions in later days
- Evolution of Microservices
- Microservices principles, patterns, anti-patterns, and the value proposition
- How application architecture and run-time infrastructure must evolve to deliver anti-fragile, dynamic applications composed of Microservices
- Design and migration considerations and strategies
- Decomposing monolithic applications into Microservice components
- Containers and Docker fundamentals
- Orchestration and scheduling fundamentals
- Windows containers
Day 2: Platforms and tools
- The goal of day 2 is to take the basics of containerization and Microservices design and apply it to a development experience across a few core platforms described here
- A tour of containerization platforms
- Docker Universal Control Plane (UCP), Docker Data Center (DDC), Docker Container Registry (DCR)
- Amazon EC2 Container Services
- Google Container Engine
- Azure Container Services
- Azure Service Fabric
- Developing and deploying solutions with each platform
- Developer experience
- DevOps lifecycle
- Feature comparisons
Day 3: Implementation patterns, high availability, health and recovery
- The goal of day 3 is to continue to experience each platform while covering the implementation details of a real solution; demonstrations will cross platforms to provide breadth of understanding, meanwhile platforms will be compared
- Implementing Microservices principles and patterns
- Domain Driven Design (DDD)
- Single responsibility
- Bounded context
- Circuit breaker
- Event sourcing
- Eventual consistency
- Stateful and stateless services
- Partitioning strategies
- Actor models
- High availability techniques
- Server density and container distribution
- Load balancing nodes vs. containers
- Auto-scale for nodes and containers
- Versioning, upgrades, roll back and roll forward strategies
- Health and recovery
- Implementing self-healing across nodes and containers
- Health monitoring and diagnostics; process, platform tools, implementation strategies
During these three days, attendees will build the same application using the three most popular web frameworks, so that at the end of the workshop they can make an informed decision about which framework is best suited for their needs.
More and more projects are moving towards web, and the biggest question is “Which framework should I choose?”. The fact that the sheer number of choices is growing every day is not making anyone’s life easier either. And then comes the anguish, “Did I choose right? What if…”.
In this workshop we are going to build the same application from scratch using three different frameworks. You will have a chance to tag along and experience first-hand the advantages and disadvantages of each framework and how they can map to the needs of your own application.
For the best experience during this workshop, we recommend you bring your own laptop with the latest version of Git and Node.js, and the editor of your choice installed on it (VSCode, Atom, WebStorm, etc.).
For the past five years I’ve had a lot of exposure to different web frameworks, so I am in a very fortunate position to be able to compare and contrast them objectively. During the day I am involved in a project where we use React a lot, I’m co-author of the official training for Aurelia, and I have worked with Angular for many years and with Angular 2 since the alpha stage, as part of the team that wrote the documentation.