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.