DevWeek 2010 Post-Conference Workshops

NOTE
The information on this page refers to DevWeek 2010. This site will be updated with information on DevWeek 2011 closer to the event.

Friday 19 March 2010

The following workshops run for a full day (from 09.30 to 17.30), with a short break in the morning and afternoon, and a lunch break at 13.00.

Unless otherwise noted in the descriptions, they are presentation-based rather than “hands-on” labs.

	Use Threads Effectively to Build Responsive and Scalable Software WORKSHOP REF: F1 Jeffrey Richter CPU manufacturers are not able to squeeze more speed out of CPUs; instead all CPUs are becoming multi-core. The only way applications can gain high performance and scalability is by effectively using threads. In this full-day talk, we’ll discuss the basics of threads (creating them, context switches, scheduling, properties, and debugging). Next, we’ll discuss the CLR’s thread pool, how it is architected and how to write applications to leverage it. Finally, we’ll focus on asynchronous programming models allowing you to build responsive, scalable, reliable applications and components making extremely efficient use of system resources. Time will be spent on threading architectures and a lot of sample code will be shown.
	Functional Approaches in C# – Deep Dive WORKSHOP REF: F2 Oliver Sturm Ideas of functional programming promise greater stability, simpler testing and debugging and especially safe application of parallelization. C# as a traditionally imperative and object oriented programming language doesn’t look like a prime candidate for functional programming, but C# programmers can still benefit from these ideas – and of course there are many benefits in being able to use a language that developers are already familiar with. In this workshop, Oliver Sturm will present an introduction to the concepts of functional programming, and several practical solutions that fulfill the promises above.
	Windows Identity Foundation (WIF) Workshop WORKSHOP REF: F3 Keith Brown Are you building web applications using ASP.NET or web services using WCF? Do you want your applications to have seamless single sign on (SSO)? Do you care about user authentication, authorization, auditing, and personalization? Do you want the ability to delegate credentials across multiple network hops without the pain of setting up Kerberos delegation in Active Directory? Are you interested in learning how to federate identity across organizational boundaries as well as security realms? If so, then this workshop is for you. In this workshop, you’ll learn about the modern approach to modeling identity: the claims-based approach, and the Windows Identity Foundation which makes it easy. You’ll learn how building claims-aware applications can allow you to centralize logic for discovering user identity attributes. Identity is tricky these days – user attributes are stored in lots of places, from LDAP directories to SQL databases. Using a claims-based identity model allows you to factor out the knowledge and code that collects these user attributes and centralize it into an application called an identity provider. This also centralizes authentication and allows you to implement SSO with very little hassle. Over time, as you add more applications to the system, they all benefit from the features in your identity provider, which you’ll probably want to improve over time, from stronger authentication methods to something as simple as an additional attribute for users. Most importantly, your application developers will never feel the need to build custom user account databases or perform their own authentication, because it’ll be so much easier to simply rely on the identity provider for these services. Because the claims-based identity model is built on standard protocols like SAML, WS-Trust and WS-Federation, you can buy an identity provider off the shelf if you don’t want to build it yourself. Active Directory Federation Services (ADFS) v2 is an example of this that comes free with your Windows Server license. And of course federation also becomes much easier because of these standards: federation across organizational or security realm boundaries (if you’re not sure what “federation” means, you’ll learn all about it in this workshop).
	ASP.NET MVC: A Developer’s Perspective WORKSHOP REF: F4 Dino Esposito ASP.NET MVC is a brand new platform to build ASP.NET applications. Based on the same runtime environment as classic ASP.NET Web Forms, ASP.NET MVC makes developing Web applications a significantly different experience than the Web Forms model. ASP.NET MVC disregards the Page Controller pattern and goes for a different pattern that can be considered a Web-oriented variation of the classic MVC pattern. When you write an ASP.NET MVC application, you think in terms of controllers and views. Your decisions are about how to pass data to the view and how to expose your middle tier to the controllers. Each request is resolved by invoking a method on a controller class. No postbacks are ever required to service a user request and no viewstate is ever required to persist the state of the page. Finally, no server controls exist to produce HTML for the browser. Overall, the ASP.NET MVC programming model poses new challenges to developers. In this workshop, we’ll go through a set of use-cases to build a set of input forms and experiment with actions, verbs, views, models, and jQuery. If you need a practical guide to form an idea and make your decision about ASP.NET MVC, this is just the right place.
	Practical Unit Testing WORKSHOP REF: F5 Kevin Jones Unit testing has become more prevalant over the last few years as more and more teams have come to realise the importance of ensuring code has some degree of test coverage. Developers are aware that code quality is an important issue, and that to get high quality code they often need to refactor. Refactoring safely requires unit tests. We will spend the day looking at unit testing, how to write a unit test, how to test external resources such as databases and web services, how to work with legacy code, and how to ensure that your code is designed to be tested.
	Incremental Design WORKSHOP REF: F6 Kevlin Henney Design is an intentional and creative act. But the intention doesn’t necessarily come all at once, perfect and fully formed. Design is also an act of experiment, of anticipation, of speculation, of reaction, of decision. Words such as patterns, refactoring, testing, iterative and incremental are often connected to design, but it is not always clear how or why they fit together. This session looks at these various concepts to see how they combine to offer a more complete picture of how and why to develop incrementally, how to cope with uncertainty in requirements and design change over time, how to envision a design and how it might evolve. Although incremental design is often described in terms of emergence, there is nothing mystical or unexplained about the nature of this emergence: it is grounded in clear principles and practices.
	A Day of Enterprise Design Patterns in .NET WORKSHOP REF: F7 Dave Wheeler & Andy Clymer Enterprise design patterns address the broader concerns on how you architect and design entire applications; and it is these enterprise patterns that will be the focus for the day. We begin with an examination of the fundamental aspects of design patterns, examining practical issues such as the use of layers and tiers; the costs of distribution (and how to mitigate them); and the use of dependency injection to facilitate test-driven development and to ease concerns over coupling of components. In the next section we delve into one of the more complex aspects of enterprise design: modeling the domain logic. We will look at the three most common approaches: Transaction Script, Domain Model and Table Module. Overcoming the friction that exists between the object-oriented world and the tabular world of the database is one of the more fascinating challenges. We will examine this area in some detail, providing examples that range from the pure code approach to how you can use mapping technologies such as nHibernate and Entity Framework. Our focus in the final section of the day is on user interface patterns, such as the various implementations of Model-View-Controller/Model-View-Presenter and the myriad of spin-offs that stem from these. We’ll look at how these patterns can be best implemented within ASP.NET, WPF and Silverlight. This is not just a day of pure theory; this is a practical analysis of the main enterprise design patterns that all architects and developers need to know, with a focus on how they are best implemented within a .NET application.
	Building Dynamic Data Driven Applications WORKSHOP REF: F8 Jim Wooley A number of technologies have been released in recent years which make building data driven applications easier. Starting with the declarative data models in LINQ and the Entity Framework, we are now able to build more dynamic applications more quickly and easily than ever before. Building on top of LINQ, we now have the ability to present data dynamically through services (using ADO.Net Data Services) and web applications (using ASP.NET Dynamic Data). In both of these, we can consume our data models the way we need to, rather than by needing constantly to modify our external contracts (in terms of Stored Procedures or service contracts). The capabilities we have available to us are not limited to the base scaffolding, but allow for significant customization as necessary for our particular business needs. In addition, we can reuse our underlying models to enforce business requirements while retaining these dynamic capabilities.
	Inside T-SQL for SQL Server 2005 and 2008 WORKSHOP REF: F9 Itzik Ben-Gan This seminar covers advanced T-SQL in SQL Server 2005 and 2008. It delves into various aspects of T-SQL including querying, programming and tuning. The seminar discusses practical problems T-SQL programmers face daily, providing different solutions to each problem, and explains in detail how to tune your code to produce robust and efficient solutions. These are the main subjects that we will cover in the seminar: Logical Query Processing Date and Time Manipulation Running Aggregations Custom Aggregations Handling Arrays and Lists Compilations, Recompilations and Reuse of Execution Plans

Return to Sessions introduction

Download code samples from DevWeek 2010

Join the mailing list for information on DevWeek 2011