Adam Hathcock’s Life in Software

NUnrar 0.5

I haven't worked on this much in the month since 0.4. I did add non-seekable stream support. In truth, I'm not sure what else to do until I use it in a project or someone else asks for something.

To me, this comes down to the question “is Bar useful solely for obtaining its value, or also for its side effects?” The stylistic choices should typically be driven by a desire to clearly communicate the semantics of the program fragment.

Eric Lippert reiterates a Clean Code practice.

As you start to work with MEF one of the fundamental decisions you have to make is how MEF will be hosted. There are several factors which will impact your decision including whether you are building on Silverlight or the Desktop and whether you are building an application or a library.

MEF is one of the waves of the future in .NET. Tagging for knowledge.

Most people - even the overwhelming majority of programmers - would say that the main activity of a software developer is "writing source code". But this is a (though quite understandable) misconception - and if you take a look at the available figures on the issue or if you - as a software professional - are honest to yourself, the misconception immediately turns out to be an enormous one.

This is a great piece on maintenance and writing code being the easiest/least important part of software development.

This article is to show you how to go from a clean install of Visual Studio 2010 to running the Code Contract tools for the first time.  Since the tools aren’t included in VS install, we thought we’d provide some extra information on where to find them.  If you’re already using Code Contracts in Visual Studio 2010, this blog post probably won’t have anything new for you.  If you want an overview of the System.Diagnostics.Contracts.Contract class, please see earlier blog posts or documentation.  This post is just about getting set up for the very first time.

I completely forgot about code contracts in VS2010. Nice reminder and tagging this for later info.

I'd like to stress that none of this should cause your code any problems. The somewhat eager initialization of types without static constructors was entirely legitimate according to the C# and CLR specs, and so the new lazy behaviour of .NET 4.0. If your code assumed that just calling a static method, or creating an instance, would trigger initialization, then that's your own fault to some extent. That doesn't stop it being an interesting change to spot though :)

A good FYI. It should remain the same in .NET 4.0 release...?

In the soon-to-be-released .NET 4.0 framework and Visual Studio 2010 we are going to get a plethora of new tools to help us write better multi-threaded applications. One of these tools is a new namespace within the System.Threading namespace which is called "Tasks". The Tasks in System.Threading.Tasks namespace are a method of fine grained parallelism, similar to creating and using threads, but they have a few key differences.

Good intro. The Task library seems to be fluent and very lambda friendly.

Apparently, there's a new threadpool in .NET 4. I never did like the old ThreadPool class.

ExtensionMethod.NET is a database of C# 3.0 and Visual Basic 2008 extension methods. It contains many user-rated extension methods that will expand your code library immediately.

I stumbled upon this while googling. It's a nice little collection of utility methods.

You can't just go deriving from some class willy-nilly and hope for the best. The implementation of your base class is allowed to call the set of protected methods exposed by the base class. If you want to derive from it then you are required to read the documentation for that class, or the code, and understand under what circumstances your protected methods will be called, and write your code accordingly. Derivation is a way of sharing implementation details; if you don't understand the implementation details of the thing you are deriving from then don't derive from it.

I quoted the basic answer.

I'm not sure why this was ever a question. "Cousin" classes just can't access protected members of each other. It just doesn't make hierarchical sense.

Introduction

The Rx Framework is a very interesting and useful library recently released via DevLabs. The purpose of the framework is to provide a large framework for working with the Observer pattern. That is a nice academic description, but it is hardly enough to start using it immediately. So let us dig a little deeper.

This article is to provide an introduction to the Rx Framework by example, not by description. Do not expect even a cursory description of any internal behaviours of the framework. That is coming up in a future article. I find when learning something completely new, working examples provide me with enough information to get started and put me in a position to learn more.

More good intro stuff to the Rx Framework. Spread it!