Synaptic Misfirings: .NET

"Real World Functional Programming" by Tomas Petricek. Tom's new 'must read' book.

Wed, 20 Aug 2008 05:17:17 GMT

With the departure of the last truly geek developer from our London office to pastures greener I've been mourning the lack of decent thought provoking programming language related conversation. It's extremely grim. Given this sorry state of affairs I was very happy to discover Tomas Petricek's new book "Real World Functional Programming", to be published by the ever excellent Manning Press. Whilst the book isn't actually out until next year, early drafts are available now under Manning's MEAP program. If you want a taste of what's on offer there's a free green paper (based in part on the text so far) available at:

http://www.manning.com/free/green_petricek.html

Even in it's early, incomplete, and yet to be proof read format the book already shows so much promise that I for one can't wait for the next update. So, if you're stuck in a working environment trying to desperately filter out ambient "How many developers does it take to change a light bulb?" type conversations then this is for you. Manning has pretty much become my go-to publisher for deep programming books, they being the publishers of the utterly brilliant "Windows PowerShell In Action" and should-be-compulsory "C# In Depth".

A relatively unknown but great addition to Windows Component technologies

Mon, 28 Jul 2008 08:08:13 GMT

I've recently been spending some time wrapping my head around registration-free COM and the whole business of manifests and 'native assemblies'. The technology is I think it's hugely overlooked. The posibility exists here for packages based on legacy COM component technology to significantly reduce their registry foot print and thus offset the inevitable 'bit rot' that Windows seems to suffer over time.

I guess with Microsoft moving development whole sale into managed execution environments (such as .NET) that technologies such as reg-free COM tends to go unnoticed. Understandable, even MS has resource limits and more importantly should focus on getting more pressing issues into the foreminds of developers (i.e. parallelism and declarative style programming), still reg-free COM is definately something you should check out if you still find yourself slumming it in C++ / COM land.

C# 4 out cools the new iPhone...

Fri, 11 Jul 2008 10:00:28 GMT

Well as far as I'm concerned it does!

http://channel9.msdn.com/posts/Charles/C-40-Meet-the-Design-Team/

Bring it on! :-)

Turning loops into values using Aggregate in C# 3.0

Sun, 04 May 2008 07:22:09 GMT

I'm probably horribly late to the party with this but I figured I'd share it anyway. It's one of those things that with hindsight falls into the "Doh. Obviously!" category: System.Linq.Enumerable.Aggregate use is not just limited to numeric style operations.

There are various ways of mapping a method over an array in either C# 2.0 or C# 3.0, for example:

   string[] data = { "Softimage|XSI", "Blender", "Luxology modo" };
   StringBuilder builder = new StringBuilder();
   foreach (string s in data)
      builder.Append("(").Append(s).Append(")");

Console.WriteLine(builder.ToString());

or using the static ForEach method on Array:

   string[] data = { "Softimage|XSI", "Blender", "Luxology modo" };
   StringBuilder builder = new StringBuilder();
   Array.ForEach(data, s => builder.Append("(").Append(s).Append(")"));
   Console.WriteLine(builder.ToString());

However, nicer still if you can use C# 3.0 is System.Linq.Enumerable.Aggregate:

string[] data = { "Softimage|XSI", "Blender", "Luxology modo" };
Console.WriteLine(data.Aggregate(new StringBuilder(), (b, s) => b.Append("(").Append(s).Append(")")).ToString());

Not only does Aggregate being a extension method benefit from the whole "extension method pattern matching" mechanism which allows you to swap in different implementations (or specializations <smile>) depending on what names spaces you have open, but (and this is the really cool bit) it allows you to treat the whole loop operation as a value. It may not be immediately obvious if you haven't done much Linq before but the return type of Aggregate as used above is StringBuilder! This is how we can pipeline it right into a call to Console.WriteLine. Note also that Array.ForEach is limited to SysArrays whereas Linq.Enumerable.Aggregate by definition works with the more primitive IEnumerable<T> - in other words it will work just a nicely with Lists or anything else that reduces to a IEnumerable<T>. Of course the other nice advantage to using Aggregate is the lazy (pull) evaluation when walking the collection.

Aside: I've deliberately avoided talking about using the classic "for(int i = 0; i < data.Length; i++)" iteration method because I didn't want the main point to be lost behind the implementation dependent fact that the jitter can translate a classic-for into very efficient native code, safely omitting the bounds checking. This is about abstraction above the micro optimization level...

Why is Microsoft still using C style casting?

Thu, 10 Apr 2008 10:49:18 GMT

Why is it that the latest MFC drop still uses C style casting in its implementation? The compiler support libraries (the bits that contain such things as gcroot<>) that ship along side MFC use 'modern' (for a given value of) casting like static_cast etc. How is it the MFC guys get away with it?

Visual C++ 2008 Feature Pack released

Mon, 07 Apr 2008 14:51:29 GMT

The Visual C++ 2008 Feature Pack is well worth installing if you're still having to slum it in C++ on Windows. The 'official' MS repackaging of (most of) TR1 is nice to have at hand and the new MFC additons do produce a huge amount of visual Bang! per buck. Definately worth checking out:

http://blogs.msdn.com/vcblog/archive/2008/04/07/visual-c-2008-feature-pack-released.aspx

I wish MS would produce a real MFC alternative for WPF, I mean a proper MVC document/view framework for 100% managed solutions. It kind of sucks that the only way of getting this kind of robust rich client application superstructure is still via C++. There's no good reason for this state of affairs.

Pushing C# 3.0 and the bug-fix / enhancement retro fit problem

Sun, 24 Feb 2008 10:05:51 GMT

I managed to spend a couple of hours yesterday refactoring my very lame WPF Blog Reader with a mind to really pushing the C# 3.0 language enhancements. At the end of the exercise I figured I'd compare the two versions (old and new) using Araxis Merge (the best diff / merge tool on the planet) and it's shocking just how different the code bases are. Gone are the explicit nested loops, statements become expressions... it is in many ways a different language. Which got me thinking, it's all very well and good that MSBuild now supports multitargetting thus enabling one to use the C# 3.0 compiler and be sure you're just taking dependencies on say .NET 2.0 but, and this is I think a big 'but', expect to have to rewrite your bug fixes / enhancements if you need to retro fit them to older code streams. Now at home this clearly isn't a problem since I can keep pressing forward and I only have one client (me) and one version (the latest) - not so in the Real World. Make no mistake, C# 3.0 once you fully embrace it is to C# 2.0 what C++ with templates is to C++ before templates.

Does this mean you shouldn't use the new C# 3.0 language extentions and idioms if you have to support multiple versions? No, of course not. There's no getting away from the hugely valuable fact that C# 3.0 code is more declarative and is far more expressives in fewer lines compared to C# 2.0. Fewer lines of code equals fewer bugs. No one can argue with that. However if you do have to support multiple versions (and can't afford to bring the older 2.0 codebases into Visual Studio 2008 - which might well be the case if you have a substancial unmanaged line count) then should pretty much figure on having to write some things twice. I can't see any other way around it, there are massive benefits in the C# 3.0 syntax forms that you should press forward to - but you won't easily be merging them back into your Visual Studio 2005 hosted code bases.

Dynamic language like functionality coming to C# 4.0? Could be...

Tue, 29 Jan 2008 10:23:54 GMT

Extremely interesting prospect this:

http://blogs.msdn.com/charlie/archive/2008/01/25/future-focus.aspx

But isn't the CLR meant to support mixed language development? Shouldn't we leave dynamic method invocation to other CLR languages?

2008 Lang.NET Symposium starts tomorrow!

Sun, 27 Jan 2008 19:00:08 GMT

Definitely something to keep an eye on if you're a programming language geek, the 2008 Lang.NET Symposium starts tomorrow. The presentations Microsoft made available from the previous Lang.NET where a great source of food for thought and certainly opened up lots of new and previously unimagined avenues of enquiry for me.

http://www.langnetsymposium.com/

Ho hum, if only MS did tools for OS X (OK so there's Silverlight 2.0 - but's a runtime). I've ordered O'Reilly's 'Mono: A Developers Notebook' with a mind to learning how to develop with the Mono packaging of the Rotor / SSCLI technology. If I ever end up with an MacBook Pro (15th inch model may well be the nicest laptop on the planet) I'll at least be able to use my favourite language (C#) rather than Objective-barf-C.

Clearly in my dotage I'm becoming more and more of a languages rather than OS dude. Of course there's this interesting blurring between the two that the shared sub-domain of runtimes brings with it... but that's a whole other story.

.NET Framework Source Code Debugging In Visual Studio 2008!

Thu, 17 Jan 2008 07:20:53 GMT

If like me you where really excited about being able to step into the source code in the .NET Framework Base Class Libraries with Visual Studio 2008 you'll be pleased to know that Microsoft has just released the source symbols. Get the low down here:

http://blogs.msdn.com/sburke/archive/2008/01/16/configuring-visual-studio-to-debug-net-framework-source-code.aspx

This is huge news. A mate of mine spends a large percentage of his day job using Reflector to peek inside and extract parts WinForms, and I've often wanted to poke around inside of System.Collections.Generics, System.Diagnostics and last but by no means least System.Runtime.Interop .

I've been giving serious thought to making my next OS update Mac OS X and then using VMWare's Fusion to run Visual Studio 2008. In part because I feel rather let down by Vista and in part because I love the wonderfully elegant symbiosis one gets when both the hardware and the OS come from a single vendor. I've spent a couple of months looking into the development options on OS X, even contemplating making a go with Mono rather than taking the Objective-C / XCode route and the sad fact is that Microsoft still utterly *owns* Apple when it comes to providing tools and technologies for developers. There's nothing that even approaches .NET and Visual Studio in terms of depth and choice. I wish there was a Windows IHV who made laptops as elegant as the MacBook Pro. More to the point I wish Windows was a damn sight more component based than it currently is - or rather I wish Microsoft had a better grasp of their own internal dependencies with Windows and then offered users the chance of installing Windows without much of that legacy support infrastructure. I know said legacy support is a huge reason for Windows success, but the only thing I get from it is bloat, performance hits and increased security attack surfaces. I'm still undecided about the Mac thing and will probably wait and see if Windows 7 does a better job of delivering on the vision of what Vista was meant to be back when I attended a Longhorn Technical Design review in Redmond. When I use .NET with its wonderful languages and tools I am constantly impressed by how agile and graceful a platform it is for translating ideas into beautiful code - if only Windows itself had the same grace and elegance...

The new Visual Studio 2008 C++ / MFC Extensions are shockingly good!

Tue, 08 Jan 2008 22:18:34 GMT

Goodness knows it takes a lot for anything C++ related to impress me these days but the new Visual Studio 2008 C++ / MFC extensions (now in Beta) did just that. Install it as a hot-fix over your RTM Visual Studio 2008 install, run the MFC AppWizard, turn on everything and you end up with an awesome Office 2007 / Visual Studio 2008 (with full docking, including docking guides) hybrid. If you have a MFC app and have been glancing enviously at the WPF / WinForms folks then you should take a serious look at this. Seriously, you just won't recognise the UI experience it generates as "boiler plate" MFC - it's that good:

http://blogs.msdn.com/vcblog/archive/2008/01/07/mfc-beta-now-available.aspx

Grab the detailed docs from:

http://www.microsoft.com/downloads/thankyou.aspx?familyId=0d805d4e-2dc2-47c7-8818-a9f59de4cd9b&displayLang=en

The other side of this is the inclusion of a good deal of TR1 in the same package - something I've yet to have time to play with. If only C++ had build times remotely similar to managed code... Still mustn't be too down on the old school C(++) family and unmanaged code in general since I have a feeling I'll be messing around with Objective-C 2.0 on OS X come the summer :-)

Framework Design Guidelines 2nd Edition

Fri, 04 Jan 2008 05:18:37 GMT

Looks like one of the best .NET books I've ever read is getting the 2.0 treatment. In fact calling this a ".NET book" undersells its value - the FDG v1 should be read by anyone implementing any kind of framework on any platform in any language.

http://blogs.msdn.com/kcwalina/archive/2008/01/03/FrameworkDesignGuidelines2ndEdition.aspx

You owe it to yourself to read the 1st edition now if you haven't done so already. It's one of those rare engineering books that truly manages to be at once insightful, thought provoking, pragmatic and passionate.

The drool worthy prospect of 'Emacs.NET'...

Sun, 30 Dec 2007 18:04:50 GMT

Definitely one to keep an eye and ear open for in 2008, the prospect of a Emacs-like .NET editor freed from the shackles of Visual Studios heavyweight design surfaces and enterprise building block kitchen sink support is extremely compelling.

http://www.douglasp.com/blog/2007/12/30/BuildingLanguagesCompilersTools.aspx

Emacs of course has Scheme as its scripting language - which makes one ponder if we might at last see a programmers text editor from Microsoft with a full macro language that is just a tad more elegant than the Visual Studio Automation Model + VBA which forms the current offering.

I wonder if they'll actually include 'Scheme .NET' in the remit of this - or maybe allow any .NET language. Then again it strikes me that such a editors macro coding implementation calls for a experience closer to what PowerShell offers over say C# in terms of being able to achieve maximum leverage per line of code / script.

Whatever this turns out to be I'm super excited. Let it be super fast to load and execute and focus on text not visual design surfaces. It's sounding like another reason to maybe consider getting out to PDC 2008 this year.

Great new books for .NET developers

Sun, 09 Dec 2007 07:04:46 GMT

There's a whole bunch of Must Read books for the .NET developer right now. Currently I have three of them on the go. First of course is Don Syme's utterly brilliant "Expert F#". I bought the PDF version because I couldn't wait to read this and am enjoying it so much that I'll be picking up a hardcover copy just as soon as I can. Regardless of whether you ever use F# in production this is an essential book. Reading this book will make you a better C# 2.0 or C# 3.0 programmer. If you've been following and enjoying the interviews with Brian Beckman, Erik Meijer and others then there is much related fun and food for thought to be found here.

I've been looking for a good "advanced" C# book, one that focuses more on the language rather than its use in conjunction with a particular API or development process and Jon Skeet's "C# in Depth" is that book. Honestly speaking if you've been using C# since the NGWS days (amazing to think .NET has publicly been Out There for almost seven and a half years now) then I'd recommend "C# in Depth" over "C# 3.0 in a Nutshell". Jon's book is currently only available through Manning's early-access program, and as such I've not read the whole thing, but the sections that are currently available are totally worth your time and money.

For the past year I've pretty much put away my CG toys such as Silo to focus on programming, never the less I still get those visual creative itches and finally there's a user interface technology that really delivers when it comes to creating those whiz-bang experiences we've come to expect without having to sink hundreds of hours into writing custom owner draw stuff as with Win32 and GDI / User32. WPF is just a beautiful API to use, personally speaking I currently all but ignore the XAML side and just use the API directly. This is not as daft as it may sound since WPF + LINQ is such a powerful combination. Anyway, there's load of good WPF books, I particularly like Chris Anderson's "Essential Windows Presentation Foundation" if only for the unique overview it gives you. That said I am really enjoying reading the early drafts of "WPF In Action" by Arlen Feldman and Maxx Daymon. The style of writing is a little idiosyncratic with lots of author opinion but personally speaking I like that since it makes reading about any technology so much less of a chore. Even if like me your WPF adventures are currently mostly limited to stuff you write off the clock at home its a worthwhile book to read if only because you can very quickly replace your only-their-mother-could-love-them WinForms apps with something that's far more easy on the eyes.

Recycle your TV and enjoy these!

Eric adds to the C# immutability meme

Wed, 14 Nov 2007 10:10:52 GMT

An excellent posting from Eric in a similar thread (sic) to Joe's:

http://blogs.msdn.com/ericlippert/archive/2007/11/13/immutability-in-c-part-one-kinds-of-immutability.aspx

Gentlemen (in the gender inclusive sense), start your Parallel FX engines :-)

Don Box implies that Visual Studio 2008 will RTM on the 15th Nov 2007.

Sun, 11 Nov 2007 07:43:04 GMT

Don seems to be saying Visual Studio 2008 will release-to-web (for MSDN Subscribers) next Thursday. Freakin' awesome :-)

http://www.pluralsight.com/blogs/dbox/archive/2007/11/10/49001.aspx

Unto the valley of interop we go...

Mon, 15 Oct 2007 20:31:23 GMT

And so it came to pass that Tom did re-install C++ on his home laptop in order to lay his paws on C++ CLI. I have finally grown tired of the "needlessly COM registered, deep call stack" pattern I see over and over again. Irrespective of whether something is actually intended to be an extension point the majority of programmers (myself included) have traded registry bloat, installer woes and runtime overhead rather than get down and dirty with the CLR. Enough, it stops here I say! ;-)

"One day son, all this will be managed. One day."

Go straight to Channel 9 and watch "Programming in the Age of Concurrency - Anders Hejlsberg and Joe Duffy: Concurrent Programming with PFX"

Sat, 13 Oct 2007 04:44:37 GMT

Whilst the collective .NET world holds it breath for Visual Studio 2008 Release Candidate 1 we can at least partially sate our hunger with the awesome new Parallel FX video over on Channel9: "Programming in the Age of Concurrency - Anders Hejlsberg and Joe Duffy: Concurrent Programming with PFX".

http://channel9.msdn.com/showpost.aspx?postid=347531

In the mean time my record of not buying a directly Microsoft related book for several months but rather buying platform agnostic comp.sci books has been broken with the purchase of "Domain-Specific Development with Visual Studio DSL Tools" and the second edition of Chris Sells's excellent "Programming WPF".

Game A.I. in C# 3

Wed, 03 Oct 2007 03:45:20 GMT

Just a brief note to point out Eric Lippert's neat new blog mini series Path Finding Using A* in C# 3.0. The A* algorthim and various derivatives is a whole fascinating topic by itself and by happy coincidence I'd only just encounted it for the first time a couple of days ago in Volume 1 of 'AI Game Programming Wisdom'.

Great new managed perf presentation from Rico Mariani

Sat, 08 Sep 2007 17:19:24 GMT

Rico Mariani is a programming hero of mine so it was very nice to find that he'd recently lent his brain to the Gamefest 2007 conference. Even if you're not interested in the programming behind video games (what's wrong with you? ;-) it's a great presentation and well worth watching even if you only write line-of-business managed apps. Get the love here:

http://creators.xna.com/Headlines/presentations/archive/2007/08/25/Gamefest-2007_3A00_-The-Costs-of-Managed-Code_3A00_-The-Avoidable-and-the-Unavoidable.aspx

C# language design, backwards compatibility, feature-itis and entropy

Sun, 02 Sep 2007 05:49:40 GMT

I remember hearing a great quote from Anders Hejlsberg to the effect that "The only thing a language designer can do is to slow down the rate of decay in their language". In other words all languages eventually succumb to entropy and disappear over the prohibative-error-prone-complexity horizon, some would say that C++ at conception was fully entropic... ;-) Staying on target for a moment, Eric Lippert has two great postings on C# language design and breaking changes:

http://blogs.msdn.com/ericlippert/archive/2007/08/30/future-breaking-changes-part-one.aspx

http://blogs.msdn.com/ericlippert/archive/2007/08/31/future-breaking-changes-part-two.aspx

I'm more happy with the idea of not using C# to write managed code than I was 6 months ago. It is after all the Common Language Runtime. The deep degree of type fidelity that the CLR gives compared say to type sharing via old school COM Type Libraries means I think that dev leads and product managers should, in time, be less concerned about moving their team to C#'s eventual successor then they might have been if we where still writing unmanaged C++ with it's 'mashed-in' COM support. We'll still be writing managed code, we'll still be targeting some variant of the CLR, and we'll have fantastic language interop with what will eventually be 'legacy C#'. Complexity these days is in the platfom and the patterns required to make best use of it, rather than in syntactic and semantic details of whatever language you're using - at least until said language in it's n-th revision succumbs to rampant feature-itis. Everything has it's time, C++ had its, C# is enjoying the glory days and is I think on the cusp of not being the best tool for the job - but that's OK because the days of opaque and largely fixed once baked binaries are well and truly behind us.

Great resources on Garbage Collection

Mon, 06 Aug 2007 19:58:17 GMT

If you enjoyed the insightful Channel 9 video interview with Patrick Dussud then I can wholeheartedly recommend Richard Jones and Rafael Lins book "Garbage Collection - Algorithms for Automatic Dynamic Memory Management". Not only is this a first class introduction to the subject but it also includes numerous discussions on the various pros and cons of one implementation vs. another. It's a fascinating read and well organized so it's very easy to not only read sequentially without too many concept jumps, but also makes an excellent "keep to hand" resource when you're skimming other folks research papers on GC and related topics.

One thing that is so interesting is how GC implementations interact with their mutators. As managed runtimes (in the general, non .NET specific sense) and OS's begin to really merge over the next 5 years I think a fundamental understanding of things like GC is going to be as important as understanding how compilers and link-loaders actually work under the covers.

Action<> types (UnitFunc<>'s by another name) in Visual Studio 2008 Beta 2

Tue, 31 Jul 2007 03:44:54 GMT

I'm particularly happy about this change in Beta 2. Firstly Microsoft has moved the Func<> generic delegates out of System.Linq and into the root System namespace. This is groovy since Func<> is an important type when doing functional style programming, in other words they're really are of general use rather than just being a Linq support type.

Secondly Microsoft has come up with their version of UnitFunc<>. The Func<> parametric types can not be defined as returning void, that's what my UnitFunc<> types where, they simply had the return type closed around void. Well Microsoft have their own void returning generic delegates now called Action<>. Again these are in the root System namespace.

When using Action<> you may find it useful not to just think of it as "logic with no return value" but rather as "logic which has side effects", that's that the 'unit' in my UnitFunc<> was trying to convey.

Patrick Dussud's excellent GC video interview

Mon, 30 Jul 2007 05:13:55 GMT

Channel 9 is currently headlining a wonderful interview with the Patrick Dussud. Patrick created the CLRs Garbage Collector.

It's a really good video and well worth your time listening to / watching. In particular the insight about explicitly invoked gen 2 / concurrent collections is gold dust.

http://channel9.msdn.com/showpost.aspx?postid=329808

The conversation about cores vs. huge memories is another great sub-section. Download it now! :-)

Visual Studio 2008 (aka "Orcas") Beta 2 released!

Fri, 27 Jul 2007 05:23:03 GMT

If you haven't embraced C# 3.0 and LINQ yet now's the time. Oh apparently there's some other stuff in Orcas Beta 2 as well - but to be honest other than the aforementioned two items I couldn't give a flying 'uck :-) If you're a Real Programmer ;-) then C# 3.0 is all the motivation you need.

Download the love here:

http://msdn2.microsoft.com/en-gb/vstudio/aa700831.aspx

Actually to be fair there's some really cool other stuff like the new MSBuild engine, the WPF designer for business apps etc - the list goes on and on.

Check out the new interview with S. Somasegar over on Channel 9 for a refresh on just how totally cool 'Orcas is:

http://channel9.msdn.com/showpost.aspx?postid=329443

If you're in the finance industry and are still chained to Windows 2000 do not despair:

1. MFC 9 officially supports Windows 2000 - apparently lots of Microsoft's "larger" customers made it perfectly clear to MS that "No Windows 2000 compatability no MFC 9 adaption." (or at least sentiments to that effect).

2. Thanks to the fact the underlying CLR hasn't changed (i.e. there are no new IL instructions) and the new MSBuild and IDE project engine support strong platform multi targeting, you are still able to use the core C# 3.0 language in conjunction with existing Windows 2000 friendly assemblies.

To be clear about point 2 if you're targetting Windows 2000 then what you're not able to do is set a reference to System.Core.dll since that assembly belongs to version 3.5 of the .NET Base Class Libraries (BCL) and BCL 3.5 is not supported on Windows 2000. However since underlying the BCL the actual execution engine, i.e. the CLR itself, hasn't changed you can use C# 3.0 to generate assembles that absolutely will be 100% Windows 2000 friendly. I know 'cause I've done it - but never mind me, just look at the architecture and you'll see how this is possible: C# 3.0 totally can, and is supported doing so, layer directly atop of BCL 2.0 - with BCL 2.0 being the "common thread" that underpins BCL 2.0, 3.0 and 3.5. Platform wise you can think of it like this.

CLR 2.0, BCL 2.0, C# 3.0 --> Windows 2000 and up

CLR 2.0, BCL 3.0, C# 3.0 --> Windows XP and up

CLR 2.0, BCL 3.5, C# 3.0 --> Windows XP and up

Why would you want to use C# 3.0 if you can't use System.Linq? Simply because in the case of Linq to Objects, the "magic" is all in the underlying C# 3.0 language enhancements, the Linq Standard Query Operators are really "just" a bunch of predefined partial methods that adhere to the Linq Query Operator patterns - i.e. you could write your own implementation of those patterns (which is what Linq to Sql, Linq to Xml, Linq To Amazon etc are). Indeed I already have reimplemented much of the Linq To Objects Query Operators in "Windows 2000 friendly assemblies". Armed with a tool like Reflector it would be pretty damned easy to extract the Linq To Objects implementation. Of couse I'm not condoning reverse engineering Microsoft's implementation and indeed I doubt that would be legal. Much better to read the Linq To Objects white paper that spells out the query patterns and expected behaviour and white room implement them yourselves - which is precisely how I've done it (legal aside, it's just more fun to do it yourself - you learn more). To reiterate, the Query Operators are really nothing more or less than a set of patterns implemented in terms of the C# 3.0 language enhancements. Once you get your functional grove on you'll be amazed I think how little code it takes to implement a Windows 2000 compatible shadow of Linq To Objects.

So now you have your Windows 2000 Linq To Objects white room implementation you can start expressing your business logic using C# 3.0 query syntax, you can start getting away from over specifying your solutions to your object graph interaction, i.e. you can be more declarative. Then, once you are able to cast off the lameness that is Windows 2000 you'll have a proven and ready code base to which you'll be able to immediately apply future Linq enhacements... for example Parallel Linq. It is this last point I think that should form a major part of any "Why should I be allowed to use C# 3.0 on Windows 2000" pitch to management. Oh, the other reason is immediate short term win of C# 3.0's new syntax forms that clearly do lead to fewer lines of code, more expressivity and greater productivity - but if they aren't enough to swing it I think the medium term win of having a "parallel execution ready" codebase is the killer feature. With C# 3.0 its immediate value up front and the potential to position yourself for even more value in the medium term. Win win.

Whoot! Visual Studio 2008 Beta 2 due later this week!

Tue, 24 Jul 2007 18:18:41 GMT

A least according to Scott Guthrie it is (see first reply in the comments section for this posting):

http://weblogs.asp.net/scottgu/archive/2007/07/23/first-look-at-ironruby.aspx

I personally can't wait for this. I've had an absolute blast with Beta 1 playing with C# 3.0. Looking forward to getting my paws on partial methods another other bits n bobs. Beta 2 should be just about feature complete I guess.

Krzystof Cwalina on duck typing in C# 3.0

Thu, 19 Jul 2007 04:27:55 GMT

Krzysztof has a interesting little piece on duck typing in C# 3.0 and drops some hints about a coding for LINQ style guide (yummy).

http://blogs.msdn.com/kcwalina/archive/2007/07/18/DuckNotation.aspx

I'd love to see Microsoft produce a FP/OO in C# style guide. I've been building up my own little web-link database in this area but it would be extremely nice if folks from the mothership could pony up a paper on the subject - even if it is something that mutates at a fairly regular basis, we're developers we can deal with change.

Where are the 'unit' functions in .NET 3.5?

Fri, 06 Jul 2007 09:59:59 GMT

It's a shame that Microsoft hasn't chosen the .NET 3.5 station-stop to introduce some official 'unit' (void returning generic functions). After all they've added Func<> to System.Linq. Having standard versions of the following would help promote the FP love:

public delegate void UnitFunc();
public delegate void UnitFunc<T0>(T0 a0);
public delegate void UnitFunc<T0, T1>(T0 a0, T1 a1);
public delegate void UnitFunc<T0, T1, T2>(T0 a0, T1 a1, T2 a2);
public delegate void UnitFunc<T0, T1, T2, T3>(T0 a0, T1 a1, T2 a2, T3 a3);

The above are my own definitions (see previous posting) (perhaps just calling them 'Unit' would be better?). I've found them to be very useful in helping to express which parts of my code may have side effects against those that explicitly don't (i.e. Func<> that by definition have non-void return types).

Maybe something similiar will appear when the PLINQ train pulls in.

LINQ is love.

Fri, 06 Jul 2007 04:35:28 GMT

I've been spending a lot of time recently writing C# 3.0 / LINQ code at both work and home (various pet projects and code doodles rather than overtime) and I love it. To paraphrase Don Box, "LINQ is love". Within our little team we often comment on how painful it is going back to .NET 1.1 and no generics. Well once you've spent more than a few hours with C# 3.0 and LINQ you'll be besotten. I can honestly only remember being this smiley about a technology when I first first broke open the NGWS zip file and took my look at .NET 1.0 after years of slumming it with C++ and COM. Together C# 3.0 and LINQ (they are really two things) create one of those rare technology moments where you look at the new (programming) landscape revealed before you and you think "How did I ever manage before this?". LINQ will deeply, deeply change the way you think and structure your code. It will also be responsible for your smiling muscles getting a serious workout. I have nothing but gratitude and admiration for all the brains over at MS who contributed to this. LINQ is deep and yet at the same time you can derive instant value by only using a little (and get more the more you buy into it - not unlike PowerShell) Yes, aspects of LINQ have been available to the C++ community for a long time via STL - but unlike STL, LINQ has just awesome tooling and its ability to enrich each and every IEnumerable implementation (existing and new) means it's an awesome value-add. Heck, C# 3.0 and LINQ are going to make refactoring existing code a joy.

LINQ itself is going to play a huge part in creating tomorrows data parallel systems that cheaply and reliably exploit many core systems (see Sutter's second pillar). This is definately a train you want to get on as soon as possible if you're in the data parallel "biz". I just don't under stand why some people are so, apparently, short sighted about this particular aspect of LINQ.

Framework Design Guidelines... the film of the book...

Wed, 04 Jul 2007 05:11:31 GMT

Lord knows I'm a total fan-boy when it comes to Krzysztof Cwalina and Brad Abram's wonderful, amazing, mind expanding and thought provoking "Framework Design Guidelines" book. Well if you don't have time (a false economy in this specific case) to read the paper version then you owe it to your self to at least listen to the audio track of Krzysztof Cwalina's video presentation of the material:

http://blogs.msdn.com/kcwalina/archive/2007/06/01/FDGLecture.aspx

Seriously, get your boss to buy you a copy of this book. Heck, get your CTO to buy a copy for each .NET dev in your team - it's that good.

.NET 3.5 June 2007 CTP is available for download.

Tue, 03 Jul 2007 03:29:37 GMT

The June CTP of the .NET framework 3.5 has just (well yesterday) been published. This is a small increment on Beta 1.

http://www.microsoft.com/downloads/details.aspx?FamilyID=e6fd8663-8b77-4649-8d36-3830e18528fa&DisplayLang=en

Not sure if you can uninstall just the .NET Framework 3.5 component of the full Orcas Beta 1 and add in this CTP whilst still having a functioning IDE... Personally speaking I'd wait for someone at Microsoft to confirm that you can use the Beta 1 Orcas IDE on top of the June CTP.

Visual Studio... Island

Fri, 29 Jun 2007 05:46:41 GMT

Of all the Microsoft products Visual Studio is without a doubt the one I'd most love to be a part of if I where ever a MS employee. However since I'm not in the mean time I'll just have to make do with hanging out there in Snow Crash style...

https://www.visualstudioisland.com/

New Singularity paper "Singularity: Rethinking the Software Stack"

Thu, 28 Jun 2007 04:11:23 GMT

'Stayed up far too late last night reading this - but it was definitely worth it. Singularity, one of the managed OS implementations within Microsoft, it's a fascinating project and something any old-school comp.sci geek would I think enjoy reading and thinking about.

http://research.microsoft.com/research/pubs/view.aspx?0rc=p&type=Publication&id=1726

I should give props to LuT for originally linking to the paper. Just as C-Omega and Xen et al beget C# 3.0, Singularity itself is not something I imagine that we'll ever be using as a production OS - but as a test bed for ideas and as a pointer to future revisions of "Windows" ( >= 7 at the very least :-) ) it is none the less a worthwhile bit of tech to keep abreast of.

Who knows, perhaps eventually we'll see something like a WOS ("Win32 on Singularity" or equivalent) subsystem much like today's WOW / WOW64 and Microsoft will consign the whole of Win32 to a virtualized backwards compatibility "box". In fact I'm prepared to bet that something like that is pretty much inevitable. I'm often pointing out to devs that "managed code" as a term is not limited to just the current or future versions of the CLR as we know it. Rather "managed code" is a label for software and systems we can infer about, direct, enhance and easily shape before they fault on the hardware. In many ways I think inference and reshape-ability (sic) are as, if not more, important that "just" garbage collection (GC is wonderful, esp. coming from a world of unmanaged C++ implemented COM, but there's so much more to managed execution). "Managed" is the natural successor to the "load, execute and pray" world of (for practical purposes) opaque and (mostly) ossified binaries that constituted the C / C++ era of OS's and languages.

from book in Manning where book.subject == "LINQ" || book.subject == "C++/CLI" select book;

Tue, 26 Jun 2007 09:00:12 GMT

I'm currently reading two Manning Press books and so far have good feelings about both of them. Firstly 'C++/CLI In Action', which I just started last night and is mainly something I'm going to read once and then pray I never have to use in anger. The second is the M.E.A.P. edition of 'LINQ In Action'. The later is by far the best LINQ/.NET 3.5 book I've read (and that's including the current "Roughcuts" versions of O'Reillys 'C# 3.0 in a Nutshell' and 'Programming .NET 3.5', both of which I'm reading via Safari). If you're going to get one and you particularly want to focus on LINQ I'd recommend the Manning book. To be fair none of the .NET 3.5 books have actually gone to press yet so in theory there's time for the O'Reilly books to improve. On the subject of Manning Press books, I note that 'Windows PowerShell In Action' is their best selling book in the 'States, kudos to Bruce and if you haven't gotten onto the PowerShell train yet this is the book to start with.

This is the first time I've actually managed to make do with the purely PDF versions of technical books, I'm not sure but it feels like the font rendering on Vista makes for a more comfortable read and it also means I can have my entire technical bookshelf on a memory stick - which does not end of good for my spine when it comes to taking my books with me.

Chris Anderson's - "Essential Windows Presentation Foundation". Two thumbs up.

Thu, 14 Jun 2007 18:31:25 GMT

I finally finished reading Chris Anderson's new WPF book last night and can whole heartedly recommend it. It is a wonderful companion to Adam Nathan's WPF tome. The two books really do compliment each other, superficially there's overlap of course but the authors bring different perspectives, something that is incredibly useful with an API surface of this size. I can't say one is better than the other - buy both. It's hard to believe that "Essential Windows Presentation Foundation" is a first book - its incredibly well organized and the occasional humorous design anecdote to be found in some of the footnotes really helps humanize the technology.

Ian's epic posting on LINQ To SQL and TDD.

Sun, 10 Jun 2007 17:22:59 GMT

Serious kudos are due to Ian for this posting. Wow.

http://iancooper.spaces.live.com/blog/cns!844BD2811F9ABE9C!386.entry

How do you unit test an anonymous delegate or lambda expession?

Tue, 29 May 2007 16:15:24 GMT

Oh Gods, in discussion with a very bright friend of mine today he raised the very good observation:

"How do you unit test an anonymous delegate or lambda expression?"

Well yes how do you? I mean assuming I'm unit testing all my named functions today how do I extend that into an increasingly inlined expression based style in the future. Being able to decorate expressions inline with Spec# might capture some of the requirements but I think unit testing tools are going to have to evolve beyond their current attribute centric view of the world and maybe start 'sniffing' code using reflection to find lurking expressions and expose them...

Wez is back in town with partial methods

Thu, 24 May 2007 09:51:47 GMT

Wez Dyer's back in town with partial methods in C# 3. Yup, 'methods' not 'classes'.

http://blogs.msdn.com/wesdyer/archive/2007/05/23/in-case-you-haven-t-heard.aspx

Grumble: looks like I'm going to have to buy Expression Blend...

Tue, 15 May 2007 20:39:43 GMT

This sucks. I really don't understand why Microsoft Expression Blend isn't available under the basic MSDN Subscription. I don't need Expression Studio - just Blend itself. Trying to do animations in XAML with multiple things going on really really requires a decent time line control not to mention proper animation playback. Grrr. Here's hoping that the US price of $500 doesn't equate to £500 when it's finally available to buy here.

More C# 3 functional love

Sat, 12 May 2007 19:17:26 GMT

I'm still waiting for Wes Dyer to put pen to blog and continue his C# writing (guess pushing out those Whidbey betas are a tad cycle taxing). In the mean time the good doctor has some food for thought on the subject of recursive lambda's. Lots of fun this article.

http://blogs.msdn.com/madst/archive/2007/05/11/recursive-lambda-expressions.aspx

I've also been snooping around inside the DLR implementation that ships with Iron Python 2. There's some very neat .NET code in there - haven't had this much fun with the CLR since I first played around with the SSCLI.

Chris Anderson's excellent "Essential Windows Presentation Foundation"

Fri, 11 May 2007 05:00:41 GMT

I haven't enjoyed a .NET book as much as this since reading Bruce Payette's "PowerShell In Action". Chris Anderson's new "Essential Windows Presentation Foundation" is the perfect companion to Adam Nathan's "Windows Presentation Foundation Unleashed". The reason for my drawing a comparison with Bruce's PowerShell book is not just because both where a pleasure to read - it's that both are similiar in that they're written by folks who where intimately involved in the conceptual design of both technologies, as such both transcend other mere tutorials. Many moons ago I was lucky enough to attend one of the Longhorn Technical Design Reviews in Redmond at which venue I met Chris Anderson. I remember us all going out for eats and drinks and being hugely entertained by Chris's boundless entusiasm, generousity of spirit and amazing impression of Steve Ballmer. It's a damn fine book - I'm hard pressed to choose between it and Adams, and to be honest there isn't really a need since WPF has a huge surface area and the books really are quite different in presentation (beyond the obvious like colour printing) and approach. I'd pretty much say that both are required reading, for what it’s worth I'd probably start reading Chris's first and then interleave Adam's as you go along. Between the two of them you'll have pretty much everything you need to be creative, productive and have lots of fun discovering WPF save for some decent Expression Blend (saving up my pennies to buy a copy of 'Blend) training...

Petzold gets bitter about other folks (better) WPF books.

Sun, 29 Apr 2007 04:52:03 GMT

Now this is a real shame. Charles Petzold, technical writer par exellence, appears to have momentarily lost it and resorted to something of a low-blow in describing Adam Nathan's writing as "PowerPoint writing" (sic). It's a cheap and uncharacteristic thing for Charles to have said. Charles seems to have been very upset by Jeff Atwood's comment over on Coding Horror.

I own and have read both books (and also Chris Anderson's and Chris Sells's WPF books) so here's my take on all this.

1. Let me medium match the message.

Would Charles's book be better for having colour printing? Absolutely, but then so would any programming text concerning graphics or UI. Adam's book is not the first to take this leap - but of the comp.sci texts I've seen printed in full colour Adam's is the first to really make the maximum use of it.

2. Times change, and audiences with them.

Charles is famous in small part for his 'Does Visual Studio Rot The Mind?' article (whether you agree or not with it - it's a very entertaining read). Now I've not been programming as long as Charles (I cut my teeth on a Sinclair ZX81) and so have some sympathy with aspects of Charle's thinking in this area (especially the "know the cost of things" argument) but the article and I feel his PowerPoint jibe amount to intellectual elitism. The fact is that style of Charles presentation is such that it takes a long time in his WPF book for the reader to get even a partial view of the big picture. Times have changed, developers these days work within far shorter time to market requirements than I feel Charles's book is designed for.

Adam's book "wins" over Charles' for the following reasons.

1. It very quickly gives to a complete view of WPF (XAML and code working in harmony) - subsequent chapters increase both the breadth and detail. A pretty neat trick.

2. Adam's book is better at anticipating reader questions and addressing them using breakout boxes and side notes.

3.Adam's book might be shorter in length - but it contains a lot of detail. More importantly, it contains a lot of detail where it matters. WPF is a huge subject. No one book is going to be able to cover it all (even Petzold has a separate book coming covering the 3D aspects of WPF).

Of the WPF books I've read to date I'd recommend in the following order.

1a. Adam Nathan - "Windows Presentation Foundation Unleashed".

1b. Chris Anderson - "Essential Windows Presentation Foundation"

2. Ian Griffiths and Chris Sells - "Programming Windows Presentation Foundation" (the 2nd ed. is available now on Safari).

...

2 + n. Charles Petzolds - "Applications = Code + Markup".

[where 'n' is a extremely large positive number]

By calling someones writing style akin to a PowerPoint presentation Charles is insuling not only Adam, but also his readers. It's just possible Charles that some of Adam's readers are also (where also?) your readers. Compare and contrast with Chris Sells generosity of spirit about other peoples WPF books.

http://www.sellsbrothers.com/news/showTopic.aspx?ixTopic=2093

It's a shame Charles doesn't let people comment on his blog, I really feel if you're going to make statements like his should allow comments.

JavaScript as a Execution Engine for MSIL?

Fri, 27 Apr 2007 07:48:07 GMT

I'm really surprised this isn't getting more coverage. To be best of my knowledge the initial signs of this have been knowable since the middle of 2006. Back then the 2006 Lang.NET Symposium had a presentation comparing JavaScript to x86 machine code (no, really) and its use as a instruction set for cross compiling MSIL to (or CIL for that matter - if you're into the whole ECMA / mono scene). I note that recently Mary Jo Foley's picked this up and I guess we'll be hearing a lot more about this at MIX 07.

If you have more than a passing interest in languages in general I can't recommend the Lang.NET presentations enough. They're not all Windows/Microsoft centric. There are presentations included from invited speaks from Sun and the Mac community. It's just the smartest compiler and language folks getting together and presenting their stuff to each other.

This really could be huge - its v hard to get your run time distributed. Lord knows being required to install anything when I visit a web site (and I'm not just talking about browsing on Windows, for example when browsing on my PlayStation 3 etc) is almost always a back-button operation for me. I hate having to install stuff. The older I get the few things I want installed... Anyway JavaScript has so much penetration on just about every platform you can see how you could effectively view it as "the machine instruction set for the internet". Forget trying to make JavaScript better or even replace it completely - let's just cross compile to it. That way we can writing in a language we prefer, say C#, and then have it run everywhere - sans CLR. Very interesting. On Windows the CLR in all its present and future forms will still be the best of breed managed code execution environment - but if you want to target browsers running on absolutely anything and still use your favorite types and languages it may soon be an option.

[Updated 29th April 2007]

It would appear that some folks are not waiting around for Microsoft to deliver this.

http://jsc.sourceforge.net/

Maybe Microsoft should employee this chap. :-)

"Dynamic Language Runtime" extension to .NET coming!

Tue, 24 Apr 2007 18:11:37 GMT

File under "Way Cool!", apparently Microsoft are to add a layer to .NET to allow dynamic languages to be easily ported. In a word: awesome! :-)More info here:

http://blogs.zdnet.com/microsoft/?p=404

Hopefully someone will do a really first class Scheme .NET implementation on top of this. Heck, I'd pay money for a decent .NET / Scheme imlementation.

Now if Bill would just see fit to quit teasing and upload the smeggng Visual Studo Orcas Professional DVD ISO to MSDN I'd be a happy developer.

Visual Studio Orcas Beta 1 ships!

Fri, 20 Apr 2007 04:49:34 GMT

Whoot! :-)