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.
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.
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.
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’.
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 testafter and testfirst 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 browserbased 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.
• Foundational unit testing techniques
• The testing pyramid
• Introduction to TDD
• Objections to TDD (and their refutations)
• 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.
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.
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.
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.
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.
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.
by Roland Guijt
"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
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.
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.
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.
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.
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.
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
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.
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.
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.
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.
by Kevin Jones
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.
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.
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.
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.
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!
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.
16th–20th May 2016