Over the last few months, I’ve been knee-deep in ASP.NET MVC for a client mobile web application. All in all, I’m really impressed with what Microsoft turned out in the 1.0 release of the bits. I have a few posts in the hopper about how we (Thought Ascent) are using MVC to target mobile devices with views customized to platform capabilities, and will be posting those in the coming weeks.

While wandering around ASP.NET MVC-land, I was directed to Oxite, a blogging/CMS platform built on ASP.NET MVC and which leveraged the broad expertise of the guys responsible for Channel 8, Channel 9, Channel 10 and MIX Online. Oxite also powered the sharp-looking Mix 2009 site.

So, after five years of hosting this blog in WordPress, I decided it was time to switch to .NET hosting and Oxite. So far, I love it. The transfer was quick and painless, other than some minor issues with BlogML and encodings on content from the WordPress blog, but everything made it over. I’m happy to finally be on a .NET blog engine and am glad I jumped into Oxite early. It’s an Alpha project as of now, but I’m impressed with the engine and the internals and am looking forward to diving in, tweaking the source on my end and perhaps even contributing to the mainline over time.

Many thanks to Tobin Titus for the sharp-looking theme. One of these days, I should skin my own site…

Links:

ASP.NET MVC

Oxite

Note: If you came here and found a broken link from a referrer, try the search box on the right. I promise everything is still here. I plan to implementing routing to tie those links back together soon. In the meantime, a keyword or two should get you to what you’re looking for.

Well, the Rocky Mountain Tech Trifecta has come and gone, and I think the event was a big success. There was a great turnout, and some really useful sessions.

I was pleased to have a full house in my WF talk, and I hope that it was a useful time for those that chose to listen to me drone over the other available options. There was some good interaction and good questions, both during and after the talk.

If you were there, I'd love to hear your feedback, good or bad. I can take, and I'm always looking for tips on how a technical talk can be more useful. If you have unabashed praise, I like that too.

If you would like to have the slides, I've embedded those below, or you can download them here. I have some notes of many of the slides if you're interested in more detail than I shared in the presentation. There are also a few slides at the end on .NET 4.0 improvements to WF that I didn't get to during the talk.

If you would like the code and demos I used during the presentation, you can find everything in a single Zip here. Most everything you need to run the demos should be here, but you will need to create the persistence and tracking databases if you want to use those pieces. Also, you'll need to have MSMQ installed and running on whichever machine you plan to use for these demos. There's a Powershell script to create the queues in the ConsoleWorkflowServiceHost project if you want to try out the MSMQ features.

There's also some unit tests if you want to try things out independent of the web app. You'll need to stage some data, but that's pretty easy. You'll notice that I also added a Test file to test the Custom WF activities I created for this demo separate from the WF itself. This is something I only mentioned in passing in the talk, but it's worth checking out as it's a useful way to really test your custom activities.

If anything else is gnarly, feel free to drop me a comment here or an email and I'd be happy to help you out.

If you've spent any time with Windows Workflow Foundation, you probably know that every possible thing you can do to enable logging and tracing of your workflows at runtime (Tracking, logging, Tracing) can save your butt when you just can't seem to find out why the heck your workflow is sitting idle after you've just thrown a few hundred concurrent requests at it.

Tracking is pretty well documented, and I would highly recommend it, along with a Monitoring tool that gives you a view into tracking results without needing to write queries against the tracking DB (I'll cover some minor enhancements I made to this tool in another post). Not that it's really that difficult, it's just not worth your time to figure out the ins and outs of the Tracking DB schema when Microsoft plans to greatly enhance it in .NET 4.0. (along with providing Tracking data views in IIS, which will be fantastic.)

Logging, whether via Enterprise Library or another tool like Log4Net, is also pretty well documented. If you're using Workflow Services, you'd also be wise to use Service logging as another source for Workflow forensics. This is also well documented.

Tracing, on the other hand -- which I consider to be the last line of defense when WF Runtime seems fine, Tracking data is clean, but the WF isn't completing as expected and/ or you're seeing intermittent socket exceptions in the svclogs -- is not so well documented. Perhaps this is because it need not be documented as it is simple and I am daft.

In any case, I thought it might be helpful to expound upon a few of the entries I have seen regarding Workflow Tracing.

When I first looked into adding tracing to my Workflow Host, I found several articles that recommended the following code in config:

   1:  <configuration>

   2:    <system.diagnostics>

   3:      <switches>

   4:        <add name="System.Workflow LogToTraceListeners" value="1" />

   5:        <add name="System.Workflow.Runtime.Hosting" value="Verbose" />

   6:        <add name="System.Workflow.Runtime" value="Verbose" />

   7:        <add name="System.Workflow.Runtime.Tracking" value="Verbose" />

   8:        <add name="System.Workflow.Activities" value="Verbose" />

   9:        <add name="System.Workflow.Activities.Rules" value="Verbose" />

  10:      </switches>

  11:    </system.diagnostics>

  12:  </configuration>

I found one example of this on MSDN. The guidance is spot on, but it is missing a few lines that I think would be helpful for a developer at his or her wits end with WF who is just trying to get logging up and running. It goes without saying that "LogToTraceListeners" assumes that one or more trace listeners already exist in your config. They don't exactly tell you that, do they? What's more, the self-contained config above would lead one to believe that you're all set this with this block of code.

Not so. At bare minimum, you'll need to add at least one of the listeners below (unless you wanted to use the EventLog listener, but you get the idea):  

   1:  <system.diagnostics>

   2:      <switches>

   3:        <add name="System.Workflow LogToTraceListeners" value="1" />

   4:        <add name="System.Workflow.Runtime" value="Error"/>

   5:        <add name="System.Workflow.Runtime.Hosting" value="Error"/>

   6:        <add name="System.Workflow.Runtime.Tracking" value="Error"/>

   7:        <add name="System.Workflow.Activities" value="Error"/>

   8:        <add name="System.Workflow.Activities.Rules" value="Off"/>

   9:      </switches>

  10:      <trace autoflush="true">

  11:        <listeners>

  12:          <add name="ConsoleTraceListener" 

                    type="System.Diagnostics.ConsoleTraceListener" />

  13:          <add name="TextWriterTraceListener" 

                    type="System.Diagnostics.TextWriterTraceListener" 

                    initializeData="System.Workflow.Trace.log" 

                    traceOutputOptions="DateTime" />

  14:        </listeners>

  15:      </trace>

  16:    </system.diagnostics>

Obvious? Maybe, but it's easy to miss in a rush. If that's you, I hope this helped.

You might find that adding those two lines did nothing to fix your issue, in which case I might have something else for you to try. I' have seen in some cases where listeners are already set up for other parts of the system (WCF logging, for example) that the code above still won't work. If that's you, try this:

   3:    <sources>

   4:      <source name="System.Workflow">

   5:        <listeners>

   6:          <add name="System.Workflow" />          

   7:        </listeners>

   8:      </source>

   9:      <source name="System.Workflow.Runtime">

  10:          <listeners>

  11:            <add name="System.Workflow" />

  12:          </listeners>

  13:        </source>

  14:        <source name="System.Workflow.Runtime.Hosting">

  15:          <listeners>

  16:            <add name="System.Workflow" />

  17:          </listeners>

  18:        </source>

  19:        <source name="System.Workflow.Runtime.Tracking">

  20:          <listeners>

  21:            <add name="System.Workflow" />

  22:          </listeners>

  23:        </source>

  24:        <source name="System.Workflow.Activities">

  25:          <listeners>

  26:            <add name="System.Workflow" />

  27:          </listeners>

  28:        </source>

  29:    </sources>

  30:    <sharedListeners>

  31:      <add name="System.Workflow" 

                type="System.Diagnostics.TextWriterTraceListener" 

                initializeData="c:\logs\System.Workflow.trace.log"  

                traceOutputOptions="DateTime" />

  32:    </sharedListeners>

  33:    <switches>

  34:      <add name="System.Workflow.Runtime" value="Error" />

  35:      <add name="System.Workflow.Runtime.Hosting" value="Error" />

  36:      <add name="System.Workflow.Runtime.Tracking" value="Error" />

  37:      <add name="System.Workflow.Activities" value="Error" />

  38:      <add name="System.Workflow.Activities.Rules" value="Off" />

  39:    </switches>          

Notice that live 4 in the first example is nowhere to be found here. I found I didn't need it. You'll also note that I had to add a source and listener for each Namespace in System.Workflow that I wanted to trace. I can't say why this works in cases where existing sources cause the "LogToTraceListeners" switch to hit the fritz, but I thought it was worth sharing. If it gets you our of a jam, then I'm happy to have shared it.

If you've read this blog for any length of time where I've posted regularly, you'll know that I'm a pretty big wonk for composition, Composite Apps and all things assembled and reused over coding from scratch.

So it should be no surprise that I'm quite a fan of Windows Workflow Foundation (WF), the Chico Marx of the .NET Framework, underappreciated for it's elegance, simplicity and power to fundamentally change the way that applications are built in the future. Wait, that last part doesn't quite apply to a lesser-known Marx brother, but you get the idea.

I've been interested in WF (If you hear me speak about it, notice that I will never, ever call it "Dub-F." Can't do it.) from the beginning, and have spent the last four months swimming in the deep end with WF, building some key pieces of an integration layer for a payment processing system that Thought Ascent has been working on for some time. Over that time, I've discovered that WF really does have all of the potential I suspected it did, and then some.

WF is a platform that will change the way we look at building applications, and I think that WF is a great example of the kinds of technologies that will move us closer and closer to true composition of applications over the next 5-7 years. Of course, being a Workflow platform released in concert with a universal framework for building connected systems (WCF) and the UI framework of the future (WPF) sort of makes Workflow Foundation like the third member of Destiny's Child. Those other technologies were game changers from day one. WF has an uphill battle to fight for recognition and adoption, but I believe it's the game changer of the future.

Not that it's being ignored, I just think it's been undervalued in the past, typically met with comments from developers and architects like "I get how it works, I just don't see what it's for"or "what does this give me that I can't do myself with code?"

But I see that tone changing, with Microsoft putting a better and better case around Workflow though integration with key technologies, along with richer complimentary services and tighter integrations with WCF.

So why am I telling you all this?

As you may or may not know, the Rocky Mountain Tech Trifecta is coming up in Denver on February 21st. This event will bring together several experts in the world of .NET, SQL and Windows, along with a few wannabees like myself who will present on just about anything you could hope to hear about in a developers conference. And there will be some heavy hitters to be sure: Scott Hanselman, Paul Neilsen, Rob Bagby and others. I'm not worthy...

If you hadnt't guessed from the first paragraphs of this post, I'll be speaking on Windows Workflow Foundation. Here's the abstract for the talk:

The Future of Work and Workflow

Since .NET 3.0, Windows Workflow Foundation (WF) has lived in the shadow of its flashy framework companions WCF and WPF. Yet from the start WF has been, at its core, about new ways of creating durable applications and composable units of work, both of which have the potential to change the way that developers assemble solutions. In this talk, Brandon will cover some of the highlights and recent enhancements to WF (Creating workflow services with WCF and WF, Workflow Persistence and Tracking), tips and tricks for advanced workflow scenarios (using MSMQ with workflow services, custom activities, etc.), and a preview of some upcoming Workflow features in the 4.0 Framework.

If you're close to Denver and haven't signed up yet, you can sign up at www.rmtechtrifecta.com. And if you're planning on coming, drop me a line. It should be a fun day.

And if you're not planning on coming, look for slides and code here over the next few weeks.

• Releasing the Source Code for the .NET Framework Libraries - Kudos Microsoft. No question that this is a good move.
• TED 2007 - The seemingly impossible is possible (Video) - Hans Roslings uses some of the best information visualization I have ever seen (Google must agree, because they bought his Gapminder tool) to deliver a great 20 minute presentation about how our cut and dry segmentation of the world into developed and developing countries is wrong and that we have the means and ability to eliminate poverty in our lifetimes. It's well worth 20 minutes.

• Is Twitter Useless, Asinine, or The Crocs of The Web? I love the comparison of Twitter to Crocs and think it's true: There are those that find Twitter pointless (my wife) and those that can't understand why people can't see the simple elegance of power of it (myself). But more than the ability for me to know where my friends are going for dinner, Twitter is a paradigm for multi-channel information sharing and that can be quite powerful for organizations as well as individuals.

• Learning from Bill Gates & Steve Jobs - Steve Jobs' amazing presentation skills isn't news to anyone, but I like this post largely because of the side-by-side depiction of a Bill Gates slide deck and a Steve Jobs slide deck. It makes a strong point...

• Office Live Workspace revealed: a free 250MB "SharePoint Lite" for everyone - This isn't the Google killer since it's not an "online" version of the classic office applications. What it is is the slow-moving-and-customer-ignorant-IT-organization killer, which is a great thing as far as I'm concerned.

• Sharepoint is not a good development platform / SharePoint is a good development platform for applications / SharePoint is an Awesome Dev App Platform - One of our SA's said early on in his experience with MOSS 2007 application development that "MOSS takes the rapid out of Rapid Application Development," which I think is true in the OOB development experience. Since then, however, we have been able to experiment with varying ways to develop apps in MOSS and have started to see areas where we can create value and assist in speed by abstracting out some of the complexity. That being said, Visual Studio needs to catch up and help make that development experience richer. As Andrew Connell said, that's a knock on tooling and the development environment, not the platform itself.

• MOSS Faceted Search (CodePlex) - If you're using or plan to use MOSS and you want your users to get the most value out of Search, I would recommend taking a serious look at faceted search.

All MOSS Links today... some days are just like that I suppose. :)

I am an avid reader of Joel on Software. I read the book and actively follow the blog. I admire Joel, his career and his willingness to speak his mind. I don't always agree with Joel, but I always respect his opinion. He has a fundamental way of looking at seemingly complex things that can tend to oversimplify the issues, but they can also bring about understanding and foster discussion.

Apparently, his Language Wars post from last week upset DHH, a self-described "Emo Programmer," because Joel claims that Ruby on Rails isn't "Enterprisey" enough. David doesn't seem to agree and claimed that Joel's post was a textbook example of FUD in action. If this turns into Adam Curry v. Dave Winer, it could be interesting to watch.

Now I am probably out of line in declaring this a flame war when Joel has yet to provide a direct response to DHH. But DHH is doing his best to shake the trees. See Exhibit A, Two posts and two updates to the second post all in the course of one day.

DHH missed the point of Joel's post, which was to say that for enterprise applications (read: internal) there are only a limited slate of options (.NET, Java, PHP and 1/2 Python). I think he's right. And don't get me wrong... I really like Rails. I love the flexibility; I love the simplicity. I love the "fight the power" attitude that comes packaged with the bits. I have used it a bit on the side and will continue to do so when free time lands in my lap. I've even considered repurposing this blog in Rails to add some AJAX-y goodness.

But Joel's point goes beyond the classic "My programming language is cooler than yours" mentality that populates playgrounds and UNIX circles. It's not about cool or fun or exciting. It's about what the enterprise can tolerate and is ready for. When we make architectural decisions at Compassion, we always consider context. Context is king. It dictates what you can afford to do with what you've been given. Context also brings in factors like how risk tolerant your customers are and what your Machine Service Bureau (MSB) or support group is willing to maintain.

37Signals is changing the world with their software, and that's not an understatement. Do I want to use Rails in house at Compassion tomorrow? Of course, I'd love to give it a spin on something internal. Is that a wise decision based on my current context? Not for another year or two, which is exactly what Joel meant. When the Enterprise is the customer, that's a reality.

All that being said, Joel is missing something here as well. Rails may not be in Joel's short list now, but I'd be willing to bet it will be before Python makes the skip to a full option. Why? Because Rails in the poster child for agility and getting things done with software. It doesn't matter that Python has some of those flavors. Ruby on Rails is a term executives are hearing. Rails is also the poster child for AJAX and when AJAX crosses into the enterprise, so will Rails.

In addition to that, the ubiquity of SOA in the enterprise may make all of this moot eventually anyway. Think about it: If my enterprise has a fully-loaded SOA with all the ESB bells and whistles, why couldn't development team A create a rails application that used services provided by Infrastructure team B? As long as team A's app can create and consume the right messages (and don't even assume SOAP... a good ESB can translate REST to SOAP and back again) who cares what stack team A uses (assuming team A will be dogfooding said app)?

In my opinion, all of this is just smoke and wasted bits when we're in the middle of a technology shift that is enabling these things to play together. So if personal preference becomes the rule of the day (which Microsoft certainly supports by creating languages in .NET that all compile to the same MSIL code) when will these silly schoolyard squabbles stop?

Ruby on Rails, SOA, Joel on Software, Loud Thinking, DHH, .NET

I just got finished with a session by Nickolas Landry entitled "From UML to the Visual Studio 2005 Class Designer: New Tools for OOP, CBD and SOA" and I thought I'd post a few thoughts before my next session.

• ActiveNick is a great presenter who did a masterful job communicating a ton of information in a short time. This was not a light topic, but I felt that he broke the meal down into several edible chunks that made sure none of us left with information overload.
• The presentation was a great mix between slides and demos. The slides weren't heavy and didn't convey too much or too little information.

There were some great highlights from the presentation itself. Nick started with some arguments related to Visual and Domain Specific Languages and the UML:

• Developers are visual and we need visual, Domain Specific Languages (DSLs) to understand and model software. A great proof of this is the need for whiteboards in every developer cubicle and conference room.
• UML was created in 1996 to be that visual DSL, but how many of us actually use it to model our software products? Even for those of us that do use it, how many of us use it to generate code? Nick asked for hands on those two questions and only half of the 200 attendees actually model in the UML and less than 5 (people, not percent) actually try to generate code from the diagrams.
• Basically, use of the UML has shown no significant increase in productivity, no significant change in the way we create apps and the language doesn't address a number of key design issues in software (like database design, testing, deployment, component-based development and UI construction).
• In addition, because the UML is technology-agnostic, you can't cover language specific nuances or synchronize you models and code. This lack of synchronization between the UML diagrams we create and our code means that UML becomes useless as soon as scope- or feature-creep occurs.
• But on the other side, if you introduce new stereotypes and tags to the UML to account for language-specific features, the UML is no longer Unified. Ever wonder why Microsoft has avoided integrating UML diagrams into the IDE? I think this talk really settled that for me.

So do we scrap the UML? Of course not. Agile development has been created as an adaptation of the UML to answer many of the concerns Nick surfaced above. But agile doesn't answer issues related to our technology-specific development and the need for model-code synchronization. All hope is lost again... But wait! There is hope in the form of the new Visual Studio 2005 Class Designer, which comes packaged with the Standard Edition and above. Some specifics:

• The new Class Designer was created to produce diagrams using UML artifacts, but it supports .NET design concepts and language nuances. It's also strongly tied to the CLR type system.
• The designer is fully integrated into VS 2005 and provides code gen and synchronization.
• You can generate diagrams from code and use the designer as a great tool for refactoring.
• It's not a perfect tool and it doesn't do everything. However, along with a code gen tool like CodeRush, the designer can really cut down development time for classes.

Some of the features of the tool are:

• A way to visualize class hierarchies and their relationships. Basically, it does a great job of visually mocking my lack of skill in creating useful and reusable classes.
• View/ Edit class details.
• Roundtrip engineering between code and design.
• And it supports all .NET language nuances.

But Microsoft isn't trying to be a UML killer here. All they offer is the class diagram at this point and they have no plans to integrate other diagrams into the IDE. Visio is still their recommended tool for diagram creation with the UML (Although I would recommend a tool called Enterprise Architect by Sparx Systems). That being said, Nick recommends that we start using the new Class Designer for a number of reasons:

• To understand existing code- While Nick was talking, I used the designer to load classes for a Windows Service app I created earlier this year. See my point above about being mocked by the tool.
• Graphical class design- Seeing what we're creating and have created has immeasurable value to most developers
• Review and Refactor code- It's not meant as a refactoring tool, per se, but it's a great visual first pass for developers.
• Documentation is always in sync- The best reason, in my mind. Synchronization means that scope- and feature-creep don't render my hard documentation work useless.

So if you haven't yet, give it a try. Open up a .NET 1.1 application in 2005 (the import wizard will make a copy, don't worry) and generate a class diagram for your solution. It's an enlightening and encouraging sight. Thanks for giving a great talk Nick. One of my favorites at DevConnections so far.

After a couple of featherweight sessions in the morning, I got some real treats yesterday afternoon. This was a full day with three sessions in the morning and three in the afternoon, plus Microsoft on trial Unplugged in the evening. My three afternoon sessions were all that I had hoped they would be. Between a 2.0 version of Scott Guthrie's famous ASP.Net Tips and Tricks talks (Not given by Scott though), a great real-world look at Visual Studio Team System and a great preview of Atlas, I got more information than I could hanlde. I'm not going to share anything from the VSTS talk in this post becuase I have some great stuff from the other two and I want to keep this post shorter than a novel. I'm also going to sit on my thoughts about Atlas because I want to put all of my thoughts in one well-written post. Tips and tricks will have to suffice... By the Way, If you're at DevConnections, you're reading this and you were at any of these sessions, please drop me a comment here. If I missed something you found to be useful, if I got something all wrong or if you just wanted to share a thought, please post. I'd love to start a dialogue about what we're learning this week. I'm open to trackbacks too, so you can even pick up the discussion on your own blog and link back to me. Tips and Tricks for ASP.NET and VS 2005 (Bradley Millington) Summary: Bradley Millington, of the Microsoft Web Platform and tools team, gave a great talk about a number of new ASP.NET 2.0 features that haven't been highly adversised, but are pretty ground-breaking. Here are a few I found interesting:

• Cross-page posting
• URL Rewriting/ Remapping - Enables the use of "vanity" URLs instead of lengthy URLs with QueryString values.
• Building a Custom CMS with the FileSystem provider - I really want to spend some more time on this section, but I want to do some more research and make an entire post out of this. For now, this feature basically allows for content to be served from non-file system locations. This was a feature built for the SharePoint team, so I would imagine that there is a ton of depth and potential here.
• Client Scripting- Some of the new features in client scripting include simplified script registration and the ability to set the focus of the page on an error during validation.

And that's all for today. Tomorrow, I'll continue with some brain dump on today's sessions, including a get talk on SOA by Dan Wahlin and a great session on Script Callbacks by Dino Espsito. I've also updated by schedule for tomorrow. You can find it here. Until tomorrow!

I have a brief break before the final session for the day (AJAX... er, Atlas) and I thought I'd brain dump some things in the free time I have (rather than standing in line for swag... I know, you're ashamed of me. You'll get over it.) This morning I attended three sessions that had some useful information in the minutae, but were basically a Microsoft rehash of what we already know. Some of it is stuff that Microsoft has been travelling-around talking about for months. Some of it was even a rehash of stuff I heard Paul Litwin and Scott Guthrie share yesterday. I could have used a bit less, but I understand that most attendees of these sessions didn't spend the day with Paul and some didn't attend Scott's talk. In any case, I did extract some new gems that I had heretofore not heard. Not suprising though, I do miss things... I'll be happy to share below. BTW, I have been taking copious notes (using MindManager 6.0) and I do intend to publish these notes when they are a) free from my frantic typing mistakes and b) I decide which format to publish them in (HTML, PPT, PDF, Word, etc.) In the meantime, I want to keep it brief and give you some of the most useful things I've seen and heard. Inside SQL Server 2005 (Matt Nunn) Summary: This was basically another "Launch" talk about the benefit of SQL Server 2005, Visual Studio 2005 and BizTalk 2006, with the focus being on SQL Server. While the presentation was heavy on selling me on Microsoft tools, (I'm already here!) there are a couple of interesting points I pulled out:

• Matt had an interesting number about purchase decisions being made in the enterprise. According to the presentation, 77% of managers were aware of bad purchase desicions at their companies that were made due to limited information about tools and options.
• Big selling point for Microsoft: Platform integration means you don't have to worry about which application can talk to which other application. I can see the lure of this, but isn't that why we are all mad for web services? Platform integration just isn't an option for most enterprises, so I don't really see this as a selling point for the majority of prospective customers.
• Microsoft's drive to be the platform of choice for enterprise applications appears to be working. Matt threw up a stat claiming that enterprises are choosing .NET 35% of the time versus 25% of the time for J2EE. I wonder if that "Platform Integration" point isn't working after all?

Lap Around the New Enhancements for Web Developers in Visual Studio 2005 (Jeff King) Summary: In some ways, this was a rehash of things we've been seeing for months (They're loving that XHTML compliance and the fact that the IDE doesn't muck with formatting anymore). That being said, I did find some good stuff in between the cracks. Some examples:

• Document outline view - lets you see the structure of your HTML in a neat, collapsed view.
• Dynamic complilation Model - the compiler even checks your web.config now... No more spinning up the dev site and seeing cryptic web.config errors due to syntax or capitalization issues.
• Obfuscate your HTML - believe it or not, you can actually deploy your site in a manner than puts everything in the bin directory. All you see in the web directory is nearly-empty stub files.
• You can pre-compile your site when you deploy it - No longer does the first user on the site have to sit and wait for the site to load the first time. What that probably means is that you'll no longer be that first user, right? I know that's what I'm thinking....

Data Access in ASP.NET 2.0 (Bradley Millington) Summary: This was another rehash as the new DataAccess features are something Microsoft has been evangelizing for a while. However, I got some great depth on the ease of two-way data binding and the new ObjectDataSource. Some info:

• The ObjectDataSource - Finally, data binding to a middle-tier! Basically, this new DataSource allows you to treat another object as your data source. An example would be an "Orders" class that represents your middle tier to the orders table in the database. You can bind your entire CRUD layer through the object methods used for each transaction as well. In essence, you write your data access layer and the ObjectDataSource handles the appropriate calls declaratively. I can't say enough how great this new DataSource is! Makes me begin to feel that Microsoft actually does like n-tier architectures...
• Two-way data-binding has gotten much easier. In addition to the old 1-way binding commands, there is now a "Bind" command that notifies the compiler of a 2-way binding.

I have a ton of good stuff on the afternoon sessions, but I'm spent for the day. Plus, I think I need to respond to a few work emails. Maybe I'll sleep after that. Tomorrow I'll play catch-up and bring you "DevConnections Day 2 - The After-Lunch Colada Post (A.K.A The Heavy Stuff)" plus all of my sessions for tomorrow. BTW, I tweaked my schedule a bit today and made a last-minute swap in the afternoon (too much good stuff!). I've updated that and my schedule for Wednesday. If you're interested in what I'm seeing tomorrow, click here. There's a UX session in there...