Here are the articles that were published in November 2005.
So quick as a flash after I'd posted my last post (KISS TDD hello), an ex-coworker wrote "While I appreciate your thoughts on TDD, you seem to dismiss BDUF [Big Design Up Front] as being unnecessary. [...] Seems to me that SOME DUF is necessary to keep the TDD in some frame of context, no?" Read more...
There's a lot of chatter in the blogosphere at the moment about Microsoft's ill-advised attempt at rewriting TDD (now generally known as MSTDD). I wrote about it myself in this post when I was feeling depressed about the uptake of TDD here at work. But now the Big Guns (tm) of the test-driven development movement have been coruscating Microsoft for what is, admittedly, a blundering attempt at calling a waterfall methodology TDD. (There's a great series of posts by Scott Bellware on his blog about all this debacle.) [Update Wed 23-Nov-2005: MSDN has now removed, er, retired, the article. 416 people had voted on it for an average score of 1.19.] Read more...
Continuing my occasional series on multithreading in C# and .NET
("continuing" in the obsessive sense of this just becoming a blog about
multithreading ), here's a quick implementation of a special kind
of thread, one that can be waited on. Hang on, I hear you say, that's
what Thread.Join() is for isn't it?
Read more...
Over the course of my work over the past month or so, I've been very involved in multithreading and concurrency, especially with regard to C# and .NET. As a first approximation (!) to my involvement, witness my recent articles on lock-free data structures in C# 2.0 (here'sthe final one; it has links to the others), but here's another item in the same general area that you may also find interesting and useful. Read more...
Last time in this series on building lock-free data structures in C# 2.0 we designed and implemented a lock-free queue, a FIFO structure that doesn't use locking to ensure correct thread safety. In doing so we also built a lock-free free list to ensure that we wouldn't block on the memory manager when allocating nodes. This time we'll tie it all up by creating a lock-free priority queue, one for a limited number of priority values, based on the code I wrote earlier. Read more...
Every now and then I get a little homesick, and there's usually some nostalgia thrown in for good measure. So this week it was triggered by watching the old TV series, The Saint, on DVD and, of course, that then triggered some wondering about my Volvo 1800S. I don't know about your childhood, but mine was highlighted by my parents allowing me to watch episodes of The Saint, starring Roger Moore, and of The Avengers, with Diana Rigg and Patrick McNee (called, bafflingly, Chapeau melon et bottes de cuir, in France, which translates as Bowler Hat and Leather Boots). Read more...
In my previous article in this series on lock-free data structures, I'd implemented a lock-free queue. In doing so, I showed that despite the simplicity of the underlying data structure, making it perform in a lock-free manner in a multithreaded application was no mean feat.
In my closing remarks though, having breezily talked through the design and the implementation of the non-blocking queue, I briefly noted that there was a problem with the dequeuing operation (and indeed there was the same problem with the popping operation in the stack): there was no guarantee that a node had been finished with once the underlying linked list had been updated. Read more...