TechEd Developers 2007 Barcelona - Day 4

November 13, 2007

Windows Communication Foundation Performance

You got to hand it to him: Justin Smith certainly has some interesting things to say about WCF. A few months ago, I have read his excellent book Inside Microsoft Windows Communication Foundation which is probably the best WCF book I've read so far. This book is about how WCF is built from the inside out instead of the endless features and tweaks of WCF from a developer perspective. I consider these kind of books to be far superior to the ones that only mimic the MSDN documentation. Period. But back to the talk. Here are some random notes I've made during the session:

  • WCF is faster than ASP.NET web services and Web Service Enhancements (WSE).
  • NetNamedPipeBinding and NetTcpBinding are the fastest bindings that come out-of-the-box. No real surprise there.
  • With the DataContractSerializer (DCS)  you get the most performance (no surprise there either). Using the NetDataContractSerializer (NDCS) is strongly discouraged, definitely from a performance perspective. With the XmlSerializer you get the worst performance, but may be an option when you are using complex XSD contracts.
  • The JSON encoder in NET 3.5 looks promising.
  • The binary encoder use syntactic compression (XML InfoSet). Redundant data in a message is removed using a dictionary.
  • Always use the asynchronous methods of a WCF proxy, never the synchronous methods. WCF services are asynchronous by default.
  • Read Increasing Middle-Tier Client Performance on MSDN.
  • Don't use the using directive with WCF proxies. I already blogged about this here.

Building Languages With The Dynamic Language Runtime

The DLR will be the next big thing. Martin Maly managed to write a LOLCode implementation that targets the DLR while he was flying to Barcelona. He showed us his implementation during this session. You can download the source from John Lam's blog.

Designing High Performance, Persistent Domain Models

I had very high expectations set for this session. Udi Dahan managed to fulfill my high expectations and go well beyond. This session was not about technology, but about the core skills. I didn't see that one coming from a TechEd conference. To say it with some wise words from a colleague of mine: this session completely blew my mind :-). He didn't talk about the technology du jour, just about POCO's (Plain Old CLR Objects).

He started off with talking about the domain model pattern (in the context that I understand domain models and domain-driven design). If it is ever possible to have a favorite pattern, well the domain model pattern does it for me. Then he went on about different fetching strategies (eager loading and lazy loading) and how to use them for different scenarios. The solutions he came up with were clean, neat and everything that maintainable code should have. You can read about it at his blog here and here. The slides of this session can be downloaded here.

Some memorable things I wrote down:

  • The actual choice of an ORM (or any other technology) is not important from an architectural point of view. I like that.
  • Drive-by-architecture: an architect who comes by the development team, drops the architecture and then takes off. For the record: this is NOT a good thing.
  • Joins hurt scalability: de-normalize the database when you need to.

I actually learned something worthwhile during this session. I'd like to attend more sessions like this one. Two thumbs up.

Dealing with Concurrency and Multi-Core CPUs with Today's Development Technologies

As I mentioned before, targeting the multi-core CPU's will be a huge thing for the next-generation of applications that you build. That is what this session was all about. I've used the current System.Threading library several times now, so nothing new there. As you may or may not know, I'm quite a fan of the Power Threading library from Wintellect. But still, I think that developing multithreaded applications could be a lot easier.

I'm particularly interested in the ParallelFX stuff that Microsoft is working on. The problem was that Joe Duffy didn't quite get to the interesting stuff as he had put too much content in his session. As he was going overtime he briefly mentioned some of the things of ParallelFX, but that quite ruined it for me. What a shame.

Test-Driven Development in Practice - How Does it Really Work?

This was probably the worst session I attended at TechEd 2007. It was the entire opposite of Roy's excellent interactive talk on day 3. I don't want to talk much about it as I'm trying to suppress the bad memories.

PS: I'm blogging this in retrospect as I couldn't get the blogger administrator web site to run on the CommsNet PCs because they had  JavaScript turned off.

If you and your team want to learn more about how to write maintainable unit tests and get the most out of TDD practices, make sure to have look at our trainings and workshops or check out the books section. Feel free to reach out at

Profile picture of Jan Van Ryswyck

Jan Van Ryswyck

Thank you for visiting my blog. I’m a professional software developer since Y2K. A blogger since Y2K+5. Provider of training and coaching in XP practices. Curator of the Awesome Talks list. Past organizer of the European Virtual ALT.NET meetings. Thinking and learning about all kinds of technologies since forever.



Thank you for visiting my website. I’m a professional software developer since Y2K. A blogger since Y2K+5. Author of Writing Maintainable Unit Tests. Provider of training and coaching in XP practices. Curator of the Awesome Talks list. Thinking and learning about all kinds of technologies since forever.

Contact information

(+32) 496 38 00 82