The second day started with a BizTalk Server session: "Enterprise Ready BizTalk - Best Practices from Customer Implementations", by Ewan Fairweather, one of the authors of the excellent "Professional BizTalk Server 2006" (ed. wrox). Not the greatest of sessions, but it had some interesting stuff. One of the topics covered was BizUnit, the test framework for BizTalk, and what I found interesting here was the usage of the database query shapes to query BizTalk's own database, as well as the notion of "priming messages", to warm up the system to the tests you are doing. The session also described and demo'ed code coverage using Visual Studio's performance tools (vsperfmon/vsinstr), to use for instance when testing pipelines of custom components, and the last part was dedicated entirely to Disaster Recovery and the various mechanisms available, from Log Shipping to SAN mirroring or applicational mirroring.
After this, a level 200 session, "Introducing the Microsoft Synchronization Framework", by Philip Vaughn. This was a very high level and un-technical description of the features of the just announced sync framework, presenting its use scenarios (offline and collaboration). The framework supports both hub&spoke and P2P topologies, and was described as "the glue for S+S". The fw includes three components: a sync agent (the "deamon"), a set of built in providers (relational, file system, etc. -- and like the name implies, this set is extensible), and the runtime, and basically supports a "poll" model of change detection, based on versions. Apparently there's already a dev center at MSDN about this CTP technology. The session also included a demo of n-way contact synchronization between a SQL database, Outlook contacts, Windows Mobile 6 Contacts, and Windows Vista contacts. Also, the SF is based on metadata information for the sync, which was summarily described, but no-one quite understood what that metadata consists of. I was really curious about the Sync Framework, but this was definitely not the best of sessions, especially because of being too general for a technical audience (IMHO).
Following this session was lunchtime's David S. Plat's "Why Software Sucks". David Plat is a very engaging and amusing speaker, and his session was basically about user experience... problems. The session highlighted several UX problems, enumerated his law of UX design: «Know thy user because he is not thee», and ended giving 5 suggestions: 1) Add a Virgin to the design team (ie, someone from outside); 2) Break convention when needed (ie, Palm/OneNote/MS Money lack of a Save feature); 3) Don't let the edge cases complicate the mainstream case; 4) Instrument carefully (ie, get info from user usage); 5) Always ask: "Is this individual design decision taking us closer to Just Working? or farther away?" (ie, are we introducing unnecessary steps or interaction). Having worked in Usability in my previous life, the message convened in the session really resonates with my personal views on this topic. HOWEVER, this is an easy session to make: the problems and bad examples in UX abound (I used several when I sold usability services), and Usability is described in a very light way. I totally agree with David Plat's principle, and clearly having the developers engage users (or at least be conscious of them and of the difference in usage profiles) is advantageous, but by itself this is not enough. Plus, I've seen a lot of bad decisions being done by marketing (after all, marketing teams design sites/products, not developers -- usually, at least), NOT developers, so pointing the fingers at them is not 100% correct. To conclude: a fun and motivational session, if not 100% "scientific". :-)
After lunch there was another excellent session by Pat Helland, "Life beyond distributed transactions: an apostate's opinion". Pat's basic premise is that you shouldn't use distributed transactions. They are fragile, and they break encapsulation (especially in SOA scenarios). The entire session explored what happens when you assume this, and ways to design your systems, also focusing on scalability. Pat published an article at CIDR 2007 which apparently is available online for download on this topic alone, and he also has posts on his blog about this which I highly recommend. This is the kind of session that makes you re-consider the way you design systems. One of the sentences that I always find motivational is his "accountants don't use erasers". A lot can be derived from this, especially in the way we use databases.
Btw, and I didn't know this, apparently Pat was involved in the several implementations of Transactions, both local and distributed (2PC), and the word "apostate" means "someone who used to believe [in distributed txs] but no longer does". And when someone in the audience asked him about the MS sales pitch about dist tx's a few years back, he just honestly replied: "You're right. I'm sorry."
Next session, Neil Padgett's "Implementing solutions that leverage MS Sync Framework to provide sync capabilities across devices, services and applications". This session gave some more detail about the Sync technology, and included both a repeat of the contact-sync demo and some code samples (who had the idea of using dark blue keywords over a dark gray slide background?). I learnt that the SF is a set of assemblies, about "sync endpoints/replicas" - the various parts in a sync network - , and that the providers are used to expose these replicas. Neil also described the concepts of Version (of the information) and Knowledge (a representation of the versions a replica knows about), essential to the architecture.
I'm guessing the team still didn't have the time to prime SF's presentations, as this was another somewhat poor session. Also Neil didn't always speak very clearly, so I ended up leaving early.
The next session I picked was about "Microsoft Robotics Studio", by Martin Calsyn and Olivier Bloch. Robotics Studio is very frequently mentioned because of the CCR (Concurrency and Coordination Runtime), which can be used to manage apps w/out robots. Back to the session: Martin did most of the session and demos, which several robots on-stage. The basic idea of the RS is abstracting the capabilities of the robots (which are controlled with Web Services), and once you do this, you can now change the specific physical robot without modifying your code. MRS also includes a visual programming language (VPL).
I have been an owner of Lego Mindstorm for some years now, and am still amazed with how easy it is to program robots using Lego's visual language. This session is mostly unrelated to most of my everyday work, but it was very interesting nonetheless. It's a technology to keep an eye on, even if only for personal curiosity.
And thus ended the second day of the event. At night, there was a "Influential's" dinner, with several MVP's, RD's, and conference speakers. Did I mention TechEd was largely about networking? ;-)