Advanced Usages of Inversion of Control Containers Oren Eini - AGI477 -> Evaluation Add to my schedule You already understand the concepts of Inversion of Control and Dependency Injection, now is the time to see how far we can make the IoC container works for us. This talk will focus on using an IoC container in complex scenarios. We will talk about generic decorator chains and generic specialization, contextful containers and IoC DSLs. These powerful concepts can greatly enhance your ability to respond to change in your application.

Agile Q&A with Dave Laribee and Friends David Laribee - AGI291 -> Evaluation Add to my schedule Join Dave Laribee - Agilist and software entrepreneur - for an Agile talk on Agile. Challenge Dave and a panel of Agile experts speaking at DevTeach to provide actionable answers about eXtreme Programming practices such as TDD/BDD, pair programming, continuous integration, and collective ownership. Have a question about Scrum or release planning? Need to know how to integrate QA into the Agile delivery model? Participants drive content by suggesting a list of topics, prioritizing them, and voting a covered subjects done as we fuse a fast-paced and rolling panel discussion with an XP-style planning game.

Are Agile and Domain Modeling Frenemies? Michael Stiefel - AGI355 -> Material Evaluation Add to my schedule Are Agile and Domain Modeling Frenemies? Can They Work Together? Advocates of agile development often claim to use domain modeling when building software. Yet there are some serious conflicts in approach between the two. Agile developers often deprecate explicit design work. Yet domain models cannot be just built on the fly. Since both approaches have a great deal to offer, this talk explores how to get them to work together.

Behavior-Driven Development Installed David Laribee - AGI233 -> Evaluation Add to my schedule It’s been said that BDD is TDD done right, but what does that really mean? In this introductory survey we'll take look at the one-two punch of User Stories and Behavior-Driven Development as a critical link in the Agile value chain. First, we’ll understand what makes a good user story and share techniques for authoring and managing them. We'll take a deep dive on writing some acceptance criteria and scenarios. Armed with this foundation, we'll examine how BDD is used to turn a story into working software and compare BDD to the more-established and better-known process of Test Driven Development. Some consideration will be given to tools such as NBehave, RSpec, Rhino Mocks and the AutoMockingContainer. If you're looking for specific examples and code, this is a session for you!

Convention-over-Configuration in a .NET World James Kovacs - AGI321 -> Material Evaluation Add to my schedule As developers, we spend an inordinate amount of time transforming objects from one representation to another... view-models or DTOs to domain objects... domain objects to database rows... Wouldn't it be nice if this could happen automagically for us? This session will look at using convention-based approaches in Fluent NHibernate and AutoMapper to do exactly that!

Domain Driven Design Chalk Talk Greg Young - AGI376 -> Evaluation Add to my schedule We as developers and designers face increasingly more difficult problem spaces. By creating models around these problems we can create better, more flexible, longer lasting, and further distilled solutions to these problems. Domain-Driven Design is a formalization of this process. This talk introduces many of the basic patterns in Domain-Driven Design but instead of focusing on the patterns themselves it focuses on the interactions and intentions of the patterns. In other words, we will talk about "entities" for about 30 seconds before we get down and dirty on some real life problems and handle the tough stuff like determining aggregate boundaries and the roles of application services. A novice should be able to take away something from this talk, but then again so should an expert.

Done Done Erik Renaud - AGI397 -> Material Evaluation Add to my schedule Duo with Francois Tanguay Come hear Erik & François talk about what it means to be finished. On traditional 3 year projects, everyone knows when it’s done. How do you define this on a agile project, when you never know when the client will stop asking for new functionality ? What do we

Getting to Release-per-Feature with Lean David Laribee - AGI284 -> Evaluation Add to my schedule What if we could release a feature to our customers as soon as it was completed? Challenges such as code that in progress make this difficult, but if we could get there we'd reap the benefits of faster return on investment and shorter feedback between customer and developer. In this talk we'll examine the tactics behind release-per-feature. We'll survey process tools from the Lean Software Development movement: Kanban and Value Stream Mapping. We'll also delve into the technical, looking at branching strategies and composite applications.

Getting Your Mind Around TDD Claudio Lassala - AGI249 -> Evaluation Add to my schedule Even though the name suggests that Test-Driven Development (or TDD) is all about testing code, it is actually more about designing the code. By following TDD, a developer writes code that is well designed, tested, and documented, and therefore, the quality of what is produced is much higher then that of a code-and-fix approach.

Inversion of Control Containers Hamilton Verissimo - AGI332 -> Evaluation Add to my schedule Inversion of Control Containers: it is all about isolation There are plenty of IoC Containers nowadays. Some promise to 'fix' your design, to increase testability and so forth. Let's take a step back and see from where the IoC Containers came from, their main goals, the concepts involved and how they simplify (or not) some design decisions.

Isolating Dependencies in Tests Using Mocks Claudio Lassala - AGI354 -> Material Evaluation Add to my schedule Isolating Dependencies in Tests Using Mocks and Stubs Soon after getting used to writing "unit" tests, developers tend to realize that those tests weren't really testing "units"; they were testing way more than that. In order to write real unit tests, it's necessary to use test doubles such as mocks and stubs. This session covers how to create and use those, and how to use Rhino Mocks to simplify things further. As we learn about those things, we'll also learn about the importance of thinking through how we write our code, putting thought into the dependencies that a class may have, and how things should be split up.

Light Up Your Apps with IoC Conventions James Kovacs - AGI347 -> Material Evaluation Add to my schedule Inversion of Control (IoC) containers, such as Castle Windsor, increase the flexibility and testability of your architecture by decoupling dependencies, but as an application grows, container configuration can become onerous. We will examine how convention-over-configuration can allow us to achieve simplicity in IoC configuration while still maintaining flexibility and testability. You can have your cake and eat it too!

ORM+=2: More Than Just Data <-> Objects Oren Eini - AGI432 -> Evaluation Add to my schedule Object relational mapping are becoming only more popular, as people developing complex systems find that they need more than the tabular model to work with in their applications. A sophisticated ORM can do a lot more than merely get the data out of the database in object form, it can be a valuable assest in simplifying development and making things possible. In this session, you will see how you can utilize an ORM in untraditional ways to get an additional, better, approach to solving complex issues. Some of those ways include business rules, localization, state transitions, inversion of control, etc. All done via the ORM layer, and all can be used to drasticly simplify the complexity of the given scenarios.

Producing Production Quality Software Oren Eini - AGI244 -> Evaluation Add to my schedule Working software is no longer the only thing that we need to produce. We need to create a software system that has a chance of surviving in the cruel world of production system, outside the clean room and sterile environment of development and QA. Understanding bottlenecks in the system, preventing cascading failures and recovery strategies have ceased being the problems of the very high end players. With the cost of system downtime being measures in $$$/second, this is an area we have to consider all the way. In this talk we will cover how we can map common weaknesses in the system design, preemptively protect ourselves from them, and produce software systems that can withstand the real world hostile environment.

Releasing To Production Every Week Owen Rogers - AGI329 -> Evaluation Add to my schedule Delivering more value faster is the mantra of every software team; however, new features don't start to deliver value until they are running in production. Compressing release cycles without compromising quality is the key to increasing value. For the past year, my team has been following an agile process that allows us to consistently deploy new releases into production every week. In this session, I'll talk about the lessons learned, the tools we use and the process we follow.

The Importance of Confidence in Development Donald Belcham - AGI387 -> Evaluation Add to my schedule During the life of a software development project confidence issues can arise. Developer, management and client confidence in the code or in each other are normal to find. What tooling, processes and practices can we, as professionals, bring to projects to increase the confidence of all parties involved? How can these tools and techniques integrate on greenfield and brownfield projects? Software development is much more than a challenge of technical problem solving. It’s also a discipline that requires you to be aware of the interaction between different components of the project team and its deliverables. Mitigating the risk of failures in confidence can be accomplished through the prudent use of existing and tried techniques. This session will look at some of those techniques and discuss how and where they will lead to increased confidence for both the technical and non-technical members of the project.

User Stories, Iterations, and Releases David Laribee - AGI278 -> Evaluation Add to my schedule Agile projects revolve around user stories. User stories are the artifact that enables functional specification of the application, project management, and estimation and planning of the work. User stories also provide the starting point for acceptance test-driven development. They are the central, unifying tool that gets everything started and keeps it going. This session covers writing user stories, expressing acceptance criteria, story estimation using fibonacci numbers and story points, as well as release planning, iteration planning, and retrospectives.

Writing Domain Specific Languages in Boo Oren Eini - AGI374 -> Evaluation Add to my schedule Domain Specific Langauge is not just the DSL SDK from Microsoft. A DSL can make working with the domain much easier, since you are capable of leveraging the domain concepts directly. The other alternative to a DSL is an XML file, and we all know how well declarative model can work when you need imperative concepts, just consider NAnt for a minute and you will see the issue. Usually, writing a DSL in .Net would be a complex issue, requiring writing a parser, interpreter, etc. Boo already handles all of that, and its open architecture means that it is very easy to extend it to express the concepts of the domain. This talk will show you how to build DSLs in Boo and how to utilize this power in your applications.

A Deep Dive into the ASP.NET AJAX UpdatePanel Rob Windsor - NET328 -> Material Evaluation Add to my schedule The ASP.NET AJAX Extensions, which provide the core AJAX functionality, include a control called the UpdatePanel which allows developers to add AJAX-like functionality to a page. By wrapping portions of ASP.NET pages in an UpdatePanel, you automatically transform postbacks originated by page controls to lightweight, AJAX postbacks. In this session we will do a thorough examination of the UpdatePanel, going from the basic uses to interacting with requests from client-side JavaScript. The demonstrations include: an introduction to the UpdatePanel, using external triggers, using the UpdateProgress control, handing multiple postback requests, and handling server errors.

AJAX 4.0: Rich Internet Applications Come of Age Don Kiely - NET465 -> Material Evaluation Add to my schedule The ASP.NET team at Microsoft just never sits still. They are enhancing the AJAX features of ASP.NET with great new stuff like client-side template rendering, declarative instantiation of behaviors and controls, a DataView control, markup extensions, and new bindings. Everything is in flux, but there are few parts of ASP.NET as exciting as what is coming down the road. During this session we’ll explore these new features as implemented in the current release and see how you can make your Web applications an even better experience for users. Microsoft’s plans for AJAX will blow your mind!

ASP.NET AJAX Tips and Tricks Rob Windsor - NET375 -> Material Evaluation Add to my schedule The combination of Visual Studio. the .NET Framework 3.5 and the ASP.NET AJAX extensions give you very powerful tools for building rich, interactive web applications. In this session we will discuss how to effectively use these tools with a specific focus on making the development experience faster and easier. We'll take a look at the intellisense and debugging features of Visual Studio 2008, how to utilize script-callable web services, how to use the ASP.NET History feature to manage browser history, how to use the Membership and Profile systems from client-side JavaScript, and how to use jQuery with ASP.NET AJAX,.

ASP.NET Dynamic Data John Bristowe - NET358 -> Material Evaluation Add to my schedule ASP.NET MVC contains a new scaffolding feature based on Dynamic Data that provides a rich framework for creating data driven web sites. Learn how to quickly build a Dynamic Data web site using features like model level validation, field and entity templates, and scaffolding.

Building custom web app. with the Sitefnity Adam Crandall - NET325 -> Material Evaluation Add to my schedule Presented By Adam Crandall and Sing Chan Sitefinity is a development platform for construction and management of websites, community portals, and intranets. Inspired by Web 2.0 UIs, the product delivers top experience for end users, while the flexible architecture empowers developers to be in a full control. In this presentation will create a new Sitefinity website and build a cutom application leveraging Sitefinity, it's extensive API and the .Net framework.

Data in the Cloud Shawn Wildermuth - NET301 -> Material Evaluation Add to my schedule Storing data outside the data center is not a new concept. But with the introduction of Microsoft's Azure and Amazon's SimpleTable platforms, storing your data in a available/scalable way is becoming easier. In this talk I will discuss the storage model for these services and how you can determine what data you can trust in the cloud.

Death of a Web Server: Crisis in Caching Richard Campbell - NET318 -> Evaluation Add to my schedule Our web servers don't tell us what's wrong, they just fail and it's up to us to figure it out. In this session you'll watch the diagnosis of a failing web site under load. The load test will be live and the servers will fail as you watch. You'll learn how to instrument a web site to understand the failure. Then you'll learn how to diagnose the failure and evaluate the solutions - whether to change code, alter configuration, add hardware or more. If you've ever had to answer the question "Why is the web site so slow?" this session is for you!

From One Web Server to Two: Making the Leap Richard Campbell - NET345 -> Evaluation Add to my schedule Every web application starts out on a single web server. And while we've been told over and over again that you can always move to multiple web servers, it's not as simple as that! This session digs into the details of what it takes to make that leap - all the changes needed to let your application function properly with more than one server. You'll learn about replicating your web application between two servers and how to keep the content in sync. The techniques and challenges of load balancing are explored. And you'll explore the critical challenge of moving to multiple servers - getting rid of affinity. There's more affinity than just the session object, but that is a key starting point. Moving to multiple servers isn't easy, but this session will give you the check list of what to do to be successful.

Fun with HTTP Handlers & Security Miguel Castro - NET387 -> Material Evaluation Add to my schedule Want to learn how all about handlers and produce something useful at the same time? I’ll show you how to write both DLL based handlers and ASHX handlers while at the same time showing you how you use them to protect and/or track file downloads on your sites. This one will be cool and fun, and you have commercial software to sell, you do not want to miss it.

Integrating ASP.NET AJAX with SharePoint 2007 Rob Windsor - NET352 -> Material Evaluation Add to my schedule SharePoint provides a great infrastructure for quickly building intranet and Internet applications. ASP.NET AJAX provides a foundation for creating highly productive Web interfaces. Combined they are two great tastes that taste great together! In this session we will cover how to get started working with ASP.NET AJAX inside of SharePoint 2007. We will take a look at how to prepare a Web Application for ASP.NET AJAX, and how to use various ASP.NET AJAX tools such as the ScriptManager and UpdatePanel controls, JSON-enabled Web services, and the AJAX Control toolkit to add rich interactivity to your SharePoint sites. Attendees of this session should be familiar with WSS 3.0 development and to have had some exposure to ASP.NET AJAX.

Integrating MS Outlook 2007 and MOSS Yaroslav Pentsarskyy - NET456 -> Material Evaluation Add to my schedule In many organizations SharePoint has become one of the most common collaboration tools. There is still, however, a habit of users trying to collaborate using Microsoft Outlook - sending versions of documents to one another. In this session, we'll look at how you can integrate Microsoft Outlook 2007 and MOSS 2007 so that users can save their email attachments to predefined document library or their “My Site”. This powerful example will also uncover many other integration capabilities between MOSS and other MS Office 2007 applications. Having a convenient integration, users in many organizations will see more benefits in utilizing MOSS for their daily tasks. Participants will be supplied with the sample allowing them to implement the solution in their work environment.

jQuery 101 Rod Paddock - NET101 -> Material Evaluation Add to my schedule Web 2.0 is here to stay. jQuery is a javascript library that abstracts away all of the gory details of working with Javascript for web applicatons. This session will demonstrate how to added Jquery to your ASP.NET applications today. This session will focus on proper uses of Jquery including how to organize your javascript code, how to use selectors in Jquery. How to manipulate your web content dynamically. Along with uses of the standard Jquery library time will also be spent exploring some of the most useful Jquery plugs ins.

Leveraging Telerik Web Controls In Your SharePoint Shereen Qumsieh - NET351 -> Material Evaluation Add to my schedule Telerik currently offers a full suite of powerful UI controls which seamlessly integrate into SharePoint and help developers build feature rich and highly responsive user interfaces for MOSS and WSS. In addition to their standard suite, Telerik offers a free version of the built in rich text editor that is cross browser compatible and offers support for the macintosh platform. This session will walk you through the steps for building SharePoint Web Parts and Custom Application Pages with specific code examples that leverage Telerik to provide a richer end user experience. We'll cover a specific subset of the Telerik Web Controls including: RadGrid, RadComboBox, RadAjax and RadCalendar and I'll also demonstrate briefly how to setup the Telerik RadEditor for SharePoint.

Leveraging the Power of jQuery in ASP.NET Web Appl Sing Chan - NET355 -> Material Evaluation Add to my schedule jQuery is a lightweight, open source, JavaScript library and is one of the most popular DHTML/AJAX libraries on the web. Now that Microsoft is making jQuery part of its official development platform, find out how you can integrate the power of jQuery in your web applications. Learn how to: • enable Intellisense for jQuery in Visual Studio 2008 • leverage jQuery’s elegant and efficient selector API to query for HTML elements and apply commands to them • integrate jQuery with your web applications that already incorporate ASP.Net AJAX

SharePoint 2007: A Developers Primer Rob Windsor - NET334 -> Material Evaluation Add to my schedule SharePoint is an awesome tool. It allows you to build web sites, manage lists of data, collaborate on documents, and so much more – all done through a simple, easy to use, web interface. When you need to go beyond the built in capabilities of the product, SharePoint also provides a rich set of APIs to code against. This session explores the most commonly used features in the Windows SharePoint Services developer APIs, as well as the types of components and applications in which they can be utilized. Topics covered include the WSS object model, WSS web services, creating simple web parts, and adding event handlers to lists.

SharePoint Development Tips and Tricks Sherman Woo - NET321 -> Material Evaluation Add to my schedule This session will take a look at the many tools, utilities, and source code found around the web. The tools help make our SharePoint Developer's lives easier, and the many source code samples help us learn and grow. The session will focus on a lot of demos, working within Visual Studio 2008 and also showcasing a few tools that SharePoint developers shouldn't live without.

Understanding ASP.NET Under the Covers Miguel Castro - NET374 -> Material Evaluation Add to my schedule In my humble opinion, nothing makes you a better developer than truly understanding how something works beyond the superficial. We all know ASP.NET as the great framework and development environment for delivering web applications; but do you truly know what happens, in detail, from the moment you request an ASPX page to the moment the HTML is served? A lot of this is the web control architecture that resides at the very heart of ASP.NET, and a lot of is based on the fact that ASP.NET is designed for so much more than just serving pages. In fact, learning how controls work is learning how ASP.NET works. In this session, I’ll step through the process from the moment you type your URL to the point where you see the page on your browser and every step in between. While you learn and understand this roadway that is the ASP.NET architecture, you’ll see how it is capable of handling many other things besides web pages. This session is for the beginner who is new to ASP.NET as well as for the advanced developer who simply wants to get more intimate with how it truly does what it does. Learn about controls, handlers, modules, page parsing, request, response, etc. This is not new MVC, or bleeding edge Silverlight. No egos here, just a terrific appreciation for understanding the ins and outs of something that has successfully let you deliver great web applications for 8 years now; in my opinion, a prerequisite for anything else we do with Microsoft tools on the web today.

An Overview of Oslo Matt Winkler - NET231 -> Evaluation Add to my schedule "Oslo" is the family of new technologies that enable data-driven development and execution of services and applications. This session will describe the key platform components: the M family of languages, the Repository and tooling. Additionally we’ll cover the developer scenarios Oslo will deliver in v1 and provide a view into the longer term goals.

An Overview of the MEF John Bristowe - NET348 -> Material Evaluation Add to my schedule An Overview of the Managed Extensibility Framework (MEF) The Managed Extensibility Framework (MEF) is a new extensibility model in the .NET Framework that provides a simple declarative model for application developers and extenders to build openly extensible applications. Come to this session and you'll learn about our Composition model and the APIs that work with it. You'll learn about composable parts, exports, imports and the composition container that brings them all together. You'll see how using the model you can develop open-ended applications that can easily be extended both internally and by third-parties.

Building an Application with Oslo Matt Winkler - NET371 -> Evaluation Add to my schedule In these 75 minutes, we’ll start from an idea and build an application using Oslo. We’ll pull together the pieces of the Oslo platform, MSchema, MGraph and MGrammer to build our application. Along the way, we’ll discuss practical issues, such as testing the models as they are built, handling changes to the application, security, replication and common patterns that emerge when modeling data. We’ll also cover how to build a data-driven runtime to consume the data that is placed into the repository. As the description suggests, this talk will be heavy on code and light on slides.

Code Generation Kathleen Dollard - NET341 -> Material Evaluation Add to my schedule After decades of evolution code generation is ready for an overhaul. New potentials arise as our increasing understanding of code generation converges with changes in Microsoft offerings. You’ll learn core code generation principles that transcend all code generation tools. Building on this you’ll get a dip into template languages seeing both T4 which is part of Visual Studio and VB9 XML literal templates in order to understand the strength of each approach. Once you understand how templates work, you’ll dive into metadata – the part of the system that uniquely describes the specific application your building. You’ll see two approaches to protecting handcrafted code on the .NET platform. And you’ll see how to hook generation into your development process. The overall process of application generation has not matured and is rapidly changing – this talk doesn’t promise silver bullets. Instead you’ll leave with a good understanding of the latest code generation techniques and how you can fit them into your unique development environment.

Conquering XML with LINQ in Visual Basic 9 Beth Massi - NET368 -> Material Evaluation Add to my schedule XML permeates every modern application today including XHTML, XAML, RSS, SOAP, and Open XML, to name just a few. The latest version of Visual Basic in Visual Studio 2008 supports a new language syntax aimed at making you much more productive when working with LINQ to XML. In this session, we'll walk through language features like XML literals, embedded expressions, and axis properties in order to create, query and transform complex XML using LINQ with this powerful but easy to use syntax. We'll also cover tips and tricks and look at other interesting and productive uses of this technology that you may have never thought of before. Say goodbye to XSLT and hello to Visual Basic 9.

Customizing the Entity Framework Model Julia Lerman - NET381 -> Material Evaluation Add to my schedule The Entity Data Model's real power is in its ability to be customized to provide a data schema that YOU want to code and query against, not a schema that is fine tuned by a DBA for performance. If you've only looked at the initial model created by the EDM Wizard, you're bound to be surprised at how dramatically you can impact model. This session will look at both VS2008 and VS2010 to teach you how to implement various types of inheritance, Entity Splitting, Abstract entities and complex types. You will also learn how to do some advanced mapping such as mapping associations as well as digging into the XML to take advantage of QueryViews and Defining Queries. We'll take a look at mapping Stored Procedures in the Entity Data Model and some of the new mapping features in EF4.

Data Sources and Data Binding in WPF Beth Massi - NET369 -> Material Evaluation Add to my schedule Data Sources and Data Binding in WPF Business Applications In this session we'll go over the major classes and interfaces involved in data binding in Windows Presentation Foundation (WPF) clients using a variety of data sources including DataSets and custom object collections. This session will demonstrate the differences in Winforms and the WPF data binding architectures and how you can design your business entities to work well with any Windows smart client. Well also take a look as some of the new WPF drag-drop data binding tooling that will be available in Visual Studio 2010.

Data Visualization Applications with WPF Tim Huckaby - NET337 -> Evaluation Add to my schedule Building Data Visualization Applications with the Windows Presentation Foundation (WPF) This session will be heavily demo focused to accentuate how the power of the Windows Presentation Foundation (WPF) can be used to visualize data. WPF is the next-generation presentation sub-system for Windows. It provides developers and designers with a unified programming model for building rich Windows smart client user experiences that incorporate UI, media, and documents. WPF uses vector based graphics rendering, which results in better graphics and presentation for an application. WPF also has other features such as layout, styling, and data binding, which, when you mix with interactivity, enables scenarios such as interactive data visualization. When you put all this together, you have a unified API for various presentation components, such as 2D and 3D documents and declarative programming through XAML, which is a powerful platform for data visualization that can be used to really “light-up” you enterprise applications. WPF is manifested in 3 major application platforms (Windows Client, Silverlight & Microsoft Surface) and all will be covered in this session at some level.

Declarative UI Programming with XAML Tim Huckaby - NET233 -> Evaluation Add to my schedule Declarative UI Programming with XAML: WPF, Silverlight & Surface XAML has become the de facto declarative language for UI development on the Microsoft platform spanning Windows, Web and the Microsoft Surface. This transformation to a single declarative language for all platforms has enabled Microsoft to deliver on the bold promise of a cross platform user experience programming model for the future. In this unique session we take a look at how knowledge of XAML and .NET languages like C# and VB.NET allow you to develop applications for Windows (WPF), the Web (Silverlight) and the Microsoft Surface using the same coding constructs and idioms. In this demo packed session we will take a look at how graphics, animations, data binding, styles and templates are commonly implemented on these platforms and how XAML makes all of this possible.

Expression Blend to Build World Class WPF App. Kevin McNeish - NET262 -> Material Evaluation Add to my schedule Working with Expression Blend to Build World Class WPF application Expression Blend is the tool of choice for building both WPF and Silverlight front ends. This session takes an in-depth look at Expression Blend's many features including animations, data binding, user interface layout, and so on, to give you the information you need to get productive immediately using this excellent UI design tool. You will also see how it's possible to use Expression Blend to create a single user interface that can be used in both WPF and Silverlight

Future Directions for Microsoft Visual Basic and C Beth Massi - NET383 -> Material Evaluation Add to my schedule Microsoft has decided to Co-evolve their premiere .NET languages, Visual Basic and C#. In this session you will gain insight into language team's strategy and direction for implementing new features. You'll also learn about the new capabilities of the next version of the languages, including additional productivity features, syntax simplifications, and a host of other improvements.

Implementing Microsoft Virtual Earth in Your ASP.N Jim Duffy - NET302 -> Material Evaluation Add to my schedule In this session attendees will learn how to add mapping capabilities to their ASP.NET applications utilizing Microsoft Virtual Earth. This demo intensive session will explain how to integrate and programmatically control the Microsoft Virtual Earth service. Topics covered include displaying a default map, displaying a specific map, how to zoom and pan, working with the navigation controls, adding custom controls, adding shapes and plotting specific points, importing GEORSS data, selecting road, aerial or hybrid displays, working with map events, and working with bird's eye view images. From displaying sales hotspots to providing driving directions, if you've ever wanted to know how to add interactive mapping features and capabilities to your web applications this session is for you.

Integrating Virtual Earth and SQL Server 2008 Jim Duffy - NET303 -> Material Evaluation Add to my schedule In this demo intensive session attendees will learn how to use Virtual Earth to leverage SQL Server 2008's new spatial data types, geometry and geography. This session will demonstrate how to use Virtual Earth to display the results of spatial data queries as well how to save spatial information created by user interaction in Virtual Earth. If you are interested in learning how to retrieve, display, and update spatial (latitude and longitude) data using Virtual Earth and SQL Server 2008 this session is for you.

iPhone Development for .NET Developers Kevin McNeish - NET384 -> Material Evaluation Add to my schedule This session introduces .NET developers to the tools and technologies available for building applications that run on the iPhone platform. It compares and contrasts Visual Studio with the Xcode development environment and demonstrates the basics of building a simple application that runs in the iPhone simulator and can be deployed to an actual iPhone device

Microsoft Concurrency and Coordination Runitme Ranjan Sen - NET332 -> Material Evaluation Add to my schedule Present DSS/CCR available in Microsoft Robotics Studio and DSS/CCR Toolkit. Illustrate the asynchronous decentralized programming model will examples and demo. Illustrations are using C#.

Microsoft Parallel Processing Technologies Ranjan Sen - NET331 -> Material Evaluation Add to my schedule Introduce the Parallel Computing Initiative at Microsoft along with the range of language extensions, libraries, tools, development suits, server platforms suitable for addressing the multi-core, multi-core and server cluster based program development. Provide demos of using Task Parallel Library (TPL) using C# and Parallel Patterns Library (PPL) for C++. Visual studio 2010 debugging and profiling tools for parallel program development

Objective-C for .NET Developers Kevin McNeish - NET289 -> Material Evaluation Add to my schedule This session compares the Objective-C language with the .NET C# language, focusing mostly on the object-oriented language features including declaring classes, inheritance, interfaces, polymorphism, memory management, and design patterns such as Model-View-Controller, Chain-of-Responsibility, and Delegation

Refactoring with Generics Kathleen Dollard - NET339 -> Material Evaluation Add to my schedule Generics open up new opportunities to increase the robustness of your code, improve its performance, and significantly reduce the total amount of code you write. After a brief introduction to generic syntax, Kathleen will show you how using generics improves the quality of your code. You’ll see how easy it is to shift your current collections to generic collections and learn how LINQ takes advantage of generic enumerable sets. You’ll learn how to write your own generic methods and classes. You’ll see how to leverage the spectrum of generic possibilities in a business object hierarchy that reduces the total lines of code by about 50%! Finally we’ll take a deep dive into nuances of generics, such as their relation to shared data, layered generics, reflection, and lambda expressions You’ll walk out of this talk understanding how to use generics to improve your own applications.

So You're Finally Getting Into WCF Miguel Castro - NET254 -> Material Evaluation Add to my schedule Stop using Web Services and Remoting! OK, now that I got your attention let’s get serious. These two technologies are all but dead. You need to start learning WCF if you haven’t already. It’s the platform for all connected applications going forward, and you know what? It’s significantly easier to use than you think. In 75 minutes, I’ll teach you what you need to know to hit the ground running with Windows Communications Foundation. Don’t miss it!

Visual Studio Debugger Tips & Tricks John Bristowe - NET343 -> Material Evaluation Add to my schedule The Visual Studio Debugger provides a slew of features that make the task of debugging both easier and more efficient. Learn about time-saving tips and tricks for all versions of the Visual Studio Debugger, including the new debugger features in Visual Studio 2010. Hear about the new mixed-mode debugging feature, the breakpoints window enhancements, the new WPF visualizers, and a number of other features. Also learn about thread debugging enhancements, new features for making stepping into properties easier, and more. Join us as we crack open the toolbox and walk through some of the debugger's best practices.

WCF and WF, Like Birds of a Feather Rob Daigneau - NET392 -> Material Evaluation Add to my schedule We all know that WCF is Microsoft’s technology for the creation of WS* and RESTful services. Then there’s WF for workflow modeling and development. These two technologies go together like, well you know, peanut butter and jelly. Join us in this session to see how to create WCF services that leverage WF in order to invoke asynchronous long-running processes. If time allows, we’ll also peer into the future to see what .Net 4.0 will bring to the table.

What’s New in Entity Framework .NET 4 aka EF4 Julia Lerman - NET202 -> Material Evaluation Add to my schedule Have you been waiting with anticipation for Entity Framework v2? Well, it’s now called EF4 and it is finally here to play with in the recently released VS2010/.NET4.0 Beta 1. In this session, Programming Entity Framework author, Julie Lerman will give you a lap around the new bits. We’ll take a look at the much improved EDM Designer, T4 code generation, the lazy loading implementation, query compilation improvements, model-first design, the new ObjectSet class, new methods that will help with n-tier development and the much anticipated POCO support for agile and test driven development. We’ll also talk about some of the features that didn’t make it into the Beta 1 but will be coming soon, such as Foreign Key support.

A lap around the Silverlight Toolkit and SDK Justin-Josef Angel - SLV323 -> Evaluation Add to my schedule A lap around the Silverlight Toolkit and Silverlight SDK Controls "The rate in which Silverlight is changing now days is just staggering and sometimes might be a bit overwhelming. Recently in November 2008 Microsoft shipped the Silverlight Toolkit. The Silverlight Toolkit is a collection of Silverlight controls, components and utilities made available outside the normal Silverlight release cycle. Join Justin Angel as he gives you the grand tour of the Silverlight Toolkit and Silverlight SDK Controls. When you go to work next week - you will know everything you need to know about the Silverlight Controls. How does AutoCompleteBox filter items? How does ImplicitStyleManager change styles? How does DockPanel position items? How do we globalize TimePicker? and many more questions will be answered. Justin Angel is a Microsoft Silverlight Program Manager. He was so deeply involved with shipping the Silverlight Toolkit that he was the one to press the mythical ""Ship it!"" button."

Architecting Applications In Silverlight D'Arcy Lussier - SLV364 -> Evaluation Add to my schedule Silverlight can be thought of as a hybrid presentation technology, sharing pieces of ASP.NET and Winform development. This means that architecting a Silverlight application has its own unique challenges and considerations. This session will cover areas like communcation channels, deployment, security, and layering. (Note: Developing Applications in Silverlight session is recommended as a pre-requisite but not required)

ASP.NET Integration With Silverlight D'Arcy Lussier - SLV341 -> Material Evaluation Add to my schedule While some websites could be written entirely in Silverlight, some websites only require Silverlight for certain parts. We'll look at these scenarios in depth and cover how a Silverlight application can interact with an ASP.NET application from within the browser, interface with javascript, and communicate with other Silverlight applications on the same page. (Note: Developing Applications in Silverlight session is recommended as a pre-requisite but not required)

Building Behaviors in Silverlight 3 Shawn Wildermuth - SLV363 -> Material Evaluation Add to my schedule The ability to attach verbs to objects in Silverlight 3 represents a powerful extension to the data bound model. In this talk I will build a Behavior using managed code then and show how it works in Blend 3 and XAML.

Deep diving into Silverlight UI framework Justin-Josef Angel - SLV354 -> Evaluation Add to my schedule Deep diving into Silverlight UI framework through Silverlight controls In first glance Silverlight seems to have a pretty extensive learning curve. And what do we as developers do when confronted with "framework magic"? We stick to the basics and tend to roll our own mini-framework. In this talk we'll uncover and unmystify all sorts of Silverlight/WPF framework magic and we'll try to get a better understanding of those. Some of these hardcore Silverlight concepts include: * The VisualStateManager - How does a button animate it's visuals when clicked/hovered? * DataTemplates - How does ListBox know the template of it's item? * ItemsControls - How does ComboBox generate ComboBoxItems from CLR Instances? * Re-Templating - How does Expression Blend allow us to transform a ListBox to a solar system? Justin Angel is a Microsoft Silverlight Program Manager.He was so deeply involved with shipping the Silverlight Toolkit that he was the one to press the mythical "Ship it!" button.

Enhance SharePoint with Silverlight 2.0 Medhat Elmasry - SLV388 -> Material Evaluation Add to my schedule Take SharePoint to the next level. Learn about how to configure your development environment and the SharePoint 2007 server so that Silverlight 2.0 can be hosted in a Web Part. Once that is out of the way, we will build some simple Silverlight applications and deploy them into SharePoint. During the journey, we will consume a SharePoint web service in Silverlight, use WCF Data Binding and also learn about available tools that can significantly facilitate matters.

Navigating the DMZ Shawn Wildermuth - SLV352 -> Evaluation Add to my schedule The Blend/Visual Studio story is supposed to bring peace to the ongoing battles between developers and designers. But there are real world hiccups in how this integration works. In this session, I will highlight lessons learned from the field to help you turn your cease-fire into a full-fledged peace.