Barry Gervin |
Building Next Generation Data Access Layers with the ADO.NET Entity Framework |
As Developers, we've been building components in our data access layer (DAL) with ADO.NET classes such as Connections, Commands, DataReaders, DataSets and our own custom Helper classes and Data Classes. We build data access layers with a clear separation of concerns between business logic, data access, and data storage. We do this to increase cohesion and maintainability of our code, and also to increase developer productivity. What does this exactly mean in terms of the Entity Framework? What is the best approach to using the Entity Framework within our Data Access Layer? There are several workable models for leveraging the Entity Definition Model (EDM) within our applications. On one end of the spectrum, we can use the Entity Definition Model as a tactical tool for data access which is isolated to our Data Access Layer. This hides the Entity Framework from the rest of our application, effectively separating the concern of data access from the rest of our application. Another technique includes leveraging the conceptual Entity Definition Model deeply throughout our solution's layers and tiers. In this session, we compare and contrast these approaches including the middle ground, and see how these architectural choices affect maintainability, readability, and developer productivity. Most developers don't frequently have the opportunity to start from a fresh slate, so we'll also examine a refactored evolution from traditional data access layers through to incremental use of the Entity Definition Model. |
Brian Noyes |
User Experience (UX): Selecting the Right Client Technology |
Choosing between Web and Windows applications has always been a challenging decision and often becomes a raging debate on every project where both are an option. Now you have to pick between multiple variants of each. Should you develop a smart client or a browser-based solution? Should you use Windows Forms or Windows Presentation Foundation for smart clients? Should you use straight ASP.NET, ASP.NET AJAX, XAML Browser Applications, or Microsoft Silverlight for browser-based apps? This session explores the motivations behind selecting smart client or browser-based applications and what key factors should steer you towards one or the other. It then demystifies the differences between the various options within each space and helps you understand when each one is appropriate. See sample implementations in each to get a feel for what is different about them from a development perspective, so you can factor in both your requirements and your development team's skills to the selection decision. |
David Chappell |
Understanding Software-Plus-Services: A Perspective |
The move to service orientation is well underway, both inside enterprises and on the Internet. What role does traditional software play in a world of online services? In particular, how is Microsoft approaching the combination of software-plus-services? This presentation provides an overview of this area, giving an introduction to and a perspective on this emerging combination. A primary focus of the session is platforms for supporting hosted applications, i.e., applications that run in the cloud. |
David Chappell |
Choosing Communication Styles: SOAP/WS-* vs. REST |
Two approaches to creating Web services are most visible today. One, using SOAP and the WS-* specifications, follows in the footsteps of earlier distributed computing technologies. The other, the RESTful style, is explicitly based on the principles of the Web itself. Both have value, and going forward, both will certainly be used. This presentation describes these two approaches, looks at when each one makes sense, and shows how Windows Communication Foundation (WCF) can support applications built using either style. |
David Platt |
Why Software Sucks |
Users think that today's software sucks. It's unsafe, unreliable, and hard to use. These problems are not technical. We've been able to solve them for many years, but instead we've gotten a paper clip with eyebrows. Why? Software sucks because developers forget (or never knew) THE bedrock principle of software development: KNOW THY USER, FOR HE IS NOT THEE. For example, what do your customers come to you for? Hint: it's not software. For another example, do you think your users care about your application? They don't. Never have, never will. They care about accomplishing the task that it does. They don't want to think about you or your application at all. It's your job to care about them anyway. This session shows good and bad examples from commercial software and Web sites --those that understand and help their users, and those that treat users with contempt. For example, consider the ads for Microsoft Office that show non-upgrading users wearing plastic dinosaur heads. Developers fear looking like dinosaurs by not having the latest technology, but ordinary users fear breaking an installation that currently works, or having useless junk like dancing paper clips slow down their computers so they need to buy new ones. Your user is not you. We put this nation on wheels not by training the entire population as mechanics, but by improving cars so they seldom need mechanics. The same transition needs to happen to the software industry. This talk provides sound design principles so that your software won't suck. Learn how blindness will improve your vision. |
David Platt |
Discussing Proven Practices for Using Smart Client Software Factory |
The Smart Client Software Factory is extremely valuable guidance released by the Patterns & Practices Team. Using the software factories enables us to solve common challenges that we encounter on a daily basis. At the same time using factories brings with it a significant learning investment. They are not always easy to understand, nor is it obvious which of the many paths to take (or not to take). In this interactive session, discuss patterns and anti-patterns of using the Smart Client Software Factory, and learn about the current state, philosophy, and goals of the new Windows Presentation Foundation Composite architecture. |
Jeffrey Palermo |
Data Access Layer: Architectural Concerns for Object/Relational Mappers (O/R-M) with Examples in NHibernate |
O/R Mappers have crossed the chasm and are now mainstream. NHibernate is one of the primary ones in use today, and over the next few years, we'll see experience reports from LINQ to SQL and Entity Framework. This session explores some architectural decisions that face designers of systems using OR Mappers for data access. It discusses how to leverage the full power of the ORM while keeping the mapper decoupled from the application logic. Heavy emphasis is placed on testability and designing for maintainability. This session has a strong emphasis on separation of concerns and demonstrates how to provide for easy testing of the data layer while defining the architecture. All samples and demos are applicable to most OR Mappers but are demonstrated with NHibernate. |
Jeffrey Palermo |
Architectural Considerations for the ASP.NET MVC Framework |
Microsoft is releasing the ASP.NET MVC Framework very soon, and many developers will begin using it right away. This session focuses on architectural concerns when using the MVC Framework. Dependency Injection can help decouple the application and make your code more maintainable and testable, but how do you enable this? Join Jeffrey Palermo for a boots-on-the-ground talk about how to fit ASP.NET MVC into your Web application architecture while avoiding some of the pitfalls common with Web Forms. We cover the following in depth: Designing for testability, loose coupling, separation of concerns, automated testing of controller actions, dependency injection, and leveraging IoC container support from the MvcContrib open source project. |
Juval Löwy |
Software Development Life Cycle: Applying Service Orientation to the Development Process |
When you develop a service-oriented application, it would be naive of you to expect that the only things you will do differently will be limited to design and technology. The development process itself needs to be service-oriented. You cannot "stare into the fire" of Windows Communication Foundation (WCF) without a mature service-oriented development process supporting your effort. This talk presents you with a service-oriented development process that you can apply to your WCF-based products to plan and track your progress, manage requirements, and ensure faster time to market. |
Juval Löwy |
Decoupling Contract from Implementation: Microsoft .NET Interface-Based Programming End-to-End |
Separation of interface from implementation is a core principle of component-oriented programming. The client is coded against an abstraction of a service (the interface), not a particular implementation of it (the object). This session starts by presenting .NET interfaces and describing various interface-based programming techniques. Next, see how to address a set of practical issues involving the definition and use of interfaces, such as Generics and interfaces, how to implement multiple interfaces, or how to combine interfaces and class hierarchies. The session ends with a discussion of interface design and factoring guidelines, and points out the best practices. |
Krzysztof Cwalina |
Evolving Reusable Libraries: Microsoft .NET Framework Base Class Libraries, Lessons Learned |
Subsequent versions of reusable libraries need to be highly compatible. Because of that, such libraries are very difficult to change (evolve) after their initial release. This talk covers guidelines and techniques for designing and architecting reusable libraries so that they are easier to evolve. |
Mario Cardinal |
Separation of Concerns: New Practices for Decreasing Coupling and Raising Cohesion |
This presentation presents simple but well-proven design principles to simplify managing dependencies between elements composing a .NET program. It discusses abstract class and interface as a means to reduce dependency surface; as well as component, namespace, and service as a means to decrease coupling. Learn the single responsibility principle, as well as dependency injection and inversion of control techniques to depend upon stability. At the end of this presentation you will understand why architects worry so much about coupling, cohesion, and separation of concerns. |
Mark Miller |
The Science Behind Creating a Great User Experience |
Explore the how and why of great UI. If you believe you're not an artist, that UI is merely subjective, or that a great UI is not worth the effort, then this session is for you. Learn how to measure UI quality, covering user models, entry points, orienteering and discoverability, with tips and code samples for the Windows Presentation Foundation (WPF) and .NET developer sprinkled throughout. Regardless of whether you're building WPF applications or the traditional WinForms or Web ones, you'll learn how to reduce visual noise, lower barriers to entry, enhance clarity and in general make your applications a pleasure to use. It's all about making your customers happy, and this session shows you how. |
Miguel Castro |
Using Sexy Extensibility Patterns to Build Long-Lived, Highly Reusable Applications |
Like everything else in the software lifecycle, some things are cool and some are just plain boring (though necessary). This session keeps you energized by showing you some exciting patterns that will allow you to enhance and extend an application without affecting the original design or code. Learn to design your applications using providers, plug-ins, and modules; in the end making an application as robust and full-flavored as a good beer. |
![Miha]() Miha Kralj
|
Architectures: The Good, the Bad, and the Ugly |
This session is designed to help architects develop critical thinking skills around the process and tools they use to develop their architectures. This will be accomplished by taking examples of failed architectures and mapping them to the patterns that could have been leveraged to improve the delivery. |
![Helland]() Pat Helland
|
Life beyond Distributed Transactions: An Apostate's Opinion |
Many decades of work have been invested in the area of distributed transactions including protocols such as Two-Phase Commit, Paxos, and various approaches to quorum. These protocols provide the application programmer a façade of global serializability. The presenter of this session is a strong advocate for the implementation and use of platforms providing guarantees of global serializability. In general, application developers simply do not implement large, scalable applications assuming distributed transactions. When they attempt to use distributed transactions, the projects founder because the performance costs and fragility make them impractical. Natural selection kicks in, and instead, applications are built using different techniques which do not provide the same transactional guarantees but still meet the needs of their businesses. This talk explores and names some of the practical approaches used in the implementations of large-scale, mission-critical applications in a world that rejects distributed transactions. We discuss the management of fine-grained pieces of application data, which may be repartitioned over time as the application grows. We also discuss the design patterns used in sending messages between these repartitionable pieces of data. The talk is intended to provoke a different way of thinking about the direction of applications in a wildly scalable world. |
![Helland]() Pat Helland
|
The Irresistible Forces Meet the Moveable Objects |
There is a vast array of economic forces being unleashed on our industry today that require us to change how we create applications. From many core processors, low-end datacenters through to the rise of "Pervasive Intermittent Connectivity" and the re-definition of the Client, this session provides a unique perspective of the changing landscape and asks the question: How we can create applications that are approachable to implementers, composeable in their deployments, and responsive to these economic and technical forces bearing down on us? This talk is about a vision and not about product announcements. Be inspired by the future and join us! |
![Nielsen]() Paul Nielsen
|
Pragmatic Data Architectures: Six Measurable Attributes |
This session unpacks the Data Architecture Principle into the six measurable attributes of a data-centric application: Data Integrity, Performance/Scalability, Usability, Extensibility, Security, and Availability; and discusses the benefits and lifecycle costs of each attribute. Based on the premise that it's possible to achieve a balance of all six attributes though the pragmatic application of principle-driven data architecture, the specific tasks and design patterns that result in each attribute are presented as they relate to each of the five database-related roles (data architect, data modeler, database developer, database administrator, and data quality analyst) that contribute to the six properties. |
Rafal Lukawiecki |
Data Protection with Cryptography of Microsoft .NET Framework 3.5 and CryptoAPI: Next Generation |
Are you still using DES, RSA, MD5 or SHA-1? Do you know how this might expose your company to a loss? Why is CAPI 1.0 being retired? Is the architecture of the new Open Cryptographic API for Windows (CNG, Cryptography Next Generation) any better than CAPI 2? What is Suite-B? Do you realize that the next few years will see a dramatic replacement of those security fundamentals we used to silently rely on? These are some of the questions we answer in this information-packed and fast-paced level 300 session aimed towards developers and architects who are already familiar with basic cryptographic and security concepts. We spend a good amount of time discussing the most recent crypto extension of .NET Framework 3.5: System.Security.Cryptography which has just been enhanced to give you direct access to the power of Suite-B, leaving CNG as your alternative, Win32 API. We explain when one API has advantages over the other, as you already would know which is easier to use. While we are not going to explain the inner workings of any of the covered algorithms, we do give you a good background to all the new ones, so that you can make better choices while designing Data Protection strategies for your systems. Windows Vista and now Windows Server 2008 have been the first commercial operating systems to include a full support for all of those innovations. Consider this as an opportunity to incorporate the awesome power of the recent security and cryptography developments in your software. For the curious, we may even tell you why we cannot tell you about Suite-A... |
Rockford Lhotka |
Architects: How Are They Made? |
In a company where I worked we lost an employee with six months total experience because we wouldn't promote him to "Architect". Another company hired him in that role a week later. Is it possible to be an architect with six months' experience? Six years? What is it that makes some people valuable architects after just a few years, while others never even come close? Is it possible to cultivate architects? Train them? Or do they just spontaneously "get it"? Nearly every organization is crying out for quality architects at the enterprise, application, and systems levels. Come join in this nature vs. nurture debate. Learn what personal attributes you should look for or cultivate in prospective architects. Learn some techniques that do (and don't) work, information that will directly apply to your organization as you try to hire or create your own architects. |
Roy Osherove |
Designing for Testability: Bridging the Gap between Design and Testing in Object-Oriented Software |
Unit Testing and Agile Methodologies seem to be the latest buzz in the software industry these days, but many people who actually try to Unit Test their application (whether new code or 'legacy' code) find out quickly that doing a thorough job can be tough if some thought about the code's design for testability is not considered. In this talk we discuss various methods of designing your APIs so that they are easy to test: Breaking dependencies with Dependency Injection patterns, how design patterns help, interface-based programming, and more. We also take a look at the future of testing tools and see what other options there are, or will be available as we architect our software with the next generation testing tools. |
Ted Neward |
Pragmatic Architecture: The Role of an Architect |
Much has been said over the past half-decade about architects, their job, and their role(s) within agile development groups. Unfortunately, not all of it has been positive, leaving many practicing architects wondering what, exactly, they're supposed to be doing besides taking up space and acting as the scapegoat for project failures. In this presentation based on the MSDN columns of the same name, we take a hard look at the architect, his responsibilities, direction, and day-to-day duties. We explore this through a series of use-case project team scenarios, both agile and otherwise, and in the end, finally answer the question once and for all, "Is there room in the world for an architect on an agile team?" |
Udi Dahan |
Web Scalability via Asynchronous Systems Architecture |
The main lesson learned from the big sites over the past year has been to step away from the database and do more work in memory. The scalability benefits of asynchronous communication have become better known, but many developers are still struggling with taking traditionally synchronous processes like user authentication and making them asynchronous. In this presentation, learn step-by-step the patterns, frameworks, and code needed to implement all user management processes for a Web site. The session deals with scalability, Web farms, sagas for long-running transactions, as well as the security implications of our decisions. |