Dr. Random

A bit on making functions tail-recursive in F#

Sun, 14 Jun 2015 21:09:13 +0000

If you recall a while back when I was demonstrating some Functional Data Structures, I mentioned the fact that some of the functions were not tail recursive, and that this is something that we would probably want to do something about. Which raises the question: How exactly do we go about making a function tail-recursive? I am going to attempt to address that question here.

One of the first problems with creating a tail recursive function is figuring out whether a function is tail recursive in the first place. Sadly this isn’t something that is always obvious. There has been some discussion about generating a compiler warning if a function is not tail recursive, which sounds like a dandy idea since the compiler knows enough to know how to optimize tail recursive functions for us. But we don’t have that yet, so we’re going to have to try and figure it out on our own. So here are some things to look for:

fold - The greatest thing that ever happened to your data structure

Mon, 08 Jun 2015 17:16:22 +0000

Let’s say that you’ve been working hard on this really awesome data structure. Its fast, its space efficient, its immutable, its everything anyone could dream of in a data structure. But you only have time to implement one function for processing the data in your new miracle structure, so what would it be?

Ok, not a terribly realistic scenario, but bare with me here, there is a point to this. The answer to this question, of course, is that you would implement fold. Why you might ask? Because if you have a fold implementation then it is possible to implement just about any other function you want in terms of fold. Don’t believe me? Well, I’ll show you, and in showing you I’ll also demonstrate how finding the right abstraction in a functional language can reduce the size and complexity of your codebase in amazing ways.

Purely Functional Data Structures–Part 2

Tue, 24 Jul 2012 18:15:17 +0000

So here we are at part 2 in the series of posts looking at Functional Data Structures from the book of the same name by Chris Okasaki. Last time we looked at what is perhaps the simplest of the functional data structures, the List (also useful as a LIFO stack). Up next we’ll continue in the order that Chris Okasaki used in his book, and take a look at implementing a Set using a Binary Tree.

Purely Functional Data Structures–Part 1

Mon, 23 Jul 2012 06:00:00 +0000

I thought it might be fun to explore a little bit of CS as it applies to functional programming, by looking at the idea of Functional Data Structures. This is actually an area that is still getting a lot of active research, and is pretty interesting stuff overall. The general idea is to try and figure out ways to provide immutable data structures which can be efficiently implemented in a functional setting. So you look at some standard data structures, like a linked list, and find a way to implement that as an immutable linked list. One of the really cool features of Functional Data Structures is that because your dealing with them in an immutable setting, you can actually get a lot of re-use out of them….specifically for something like a list, you can add an item to the list, and return a “new” list that consists of the old list and the new item, and literally provide a structure that points to the old list instead of copying items. Even if you have other parts of the code referencing older versions of the list without the new item, you don’t have to worry since none of them can mutate the list.

A quick (?) retrospective on learning (and using) F#

Sun, 22 Jul 2012 15:00:00 +0000

As you may have guessed from the title, I’ve started doing some work with F#. Initially I was somewhat reluctant to go down the F# path because some of the more interesting aspects of the other functional languages I’ve been exploring are not present…specifically the type systems behind Scala and Haskell, the laziness of Haskell, and the concurrent programming model of Erlang. In spite of these perceived downfalls, there were some definite plusses, namely interoperability with everything .Net, immutability by default, and the wonderful concise programing model of a functional language.

Sometimes doing the right thing is still not the right thing

Tue, 20 Mar 2012 10:14:00 +0000

Tentatively subtitled: “How scale can make fools of us all”

This is going to be a real life war story…cause I haven’t done one of those in a while, and this particular case really ticked me off. Here’s the scoop: I’ve got a “service” which is called by other parts of the system. And by “service” I don’t mean something running in its own process and waiting for SOAP/REST requests or messages, I simply mean something that has a defined entry point (a static method in this case), where you pass in some data, and get something back.

I think Scala may be a gateway drug

Tue, 24 Jan 2012 06:52:00 +0000

As I have been trying to learn more about Scala, there have been several paths that I’ve had to follow. One is getting acquainted with the state of Java development, since ultimately Scala exists within the Java ecosystem. Another is finding my way around the Scala libraries, tools, and idioms. But there is a third that seems to be somewhat deeper, and that is coming to grips with the functional nature of the language.

Making the Climb Part 4–Pattern Matching

Sun, 22 Jan 2012 20:23:58 +0000

Continuing our journey down the path from the familiar to the down-right bizarre, we find ourselves at Pattern Matching. This is a feature of the Scala language that shows it’s functional side in a strong way. Pattern Matching is a fundamental part of functional languages in general, and provides a way to write very concise and expressive code. On the surface, pattern matching in Scala looks an awful lot like switch statements in C# (and Java for that matter), but you shouldn’t cling too hard to that association.

Grappling with multiple remotes in git-tfs

Wed, 16 Nov 2011 06:53:00 +0000

If you happen to be one of the many people in the unfortunate situation to be stuck working with TFS source control on a daily basis and gaze longingly at the folks using Git or Mercurial wishing you could have some of that distributed goodness for your very own self, I am here to tell you that all is not lost. There are a couple ways you can work with a distributed version control system along side TFS and try and reduce the pain associated with TFS. One way I wrote about here as an answer to a question on StackOverflow. This technique worked fairly well for me dealing with a small codebase with only a few branches. However, it became unmanageable once I started working in an environment which had a large TFS repo with several different branches that I needed to switch between on a regular basis. You can read about some of the issues I ran into within the updated section of the answer, but overall things got messy quickly.

Making the Climb Part 3 - Generics of a Higher Kind

Wed, 05 Oct 2011 16:24:00 +0000

This is part 3 in a series. If you’ve not followed-along so far, you may want to check out Part 1 and Part 2 first.

It’s time to start digging in to some of the crazy-goodness that makes Scala such a glorious and wonderful thing. First things first, though, we have to talk a little bit about this history of Generics in Java and the JVM.

Type Erasure and you…

Back around the time that .Net was adding support for generics, the folks in Java land were doing the same…sort of. The biggest difference between the way Generics were implemented in .Net and Java is the fact that in .Net generics are supported directly in the CLR (sometimes called reified generics), whereas the JVM did not include direct support for generics. Ok, so what does that actually mean? Well, for starters it means that when you’re dealing with Generics in Java you run into Type Erasure. Type Erasure means that when Java code with generics are compiled, the generic type information is removed at compile time, so while you’re looking at an ArrayList in Java, the JVM sees this as just an ArrayList, and things get cast as needed. There are a couple of types which get reified into actual types (Arrays are the best example), but for the most part this doesn’t happen. In contrast in the .Net world a List gets compiled into a List`1<System.String> which is a real type at the IL level. Now, I’m not going to get into the argument about whether or not type erasure is good or bad, but it is a fundamental difference between the two platforms.

Making the Climb Part 2–Object-Oriented Programming in Scala

Sun, 14 Aug 2011 23:39:00 +0000

In Part 2 of this series we’re going to move into some of the object-oriented aspects of Scala. For a primer on what Scala is, and a quick primer on syntax, check out part 1.

Let’s start with the built-in object structure

Like C# and Java, Scala has a built-in object hierarchy, and a standard library full of goodies. Unlike Java and C#, Scala tackled the issue of reference types and value types head-on, so while the root type in the Scala type system is the Any type, there are two descendants of Any that come into play before any other type. The two are: AnyRef, and AnyVal. As you might guess AnyRef is the base type for all reference types (including types made available from Java), and AnyVal is the base type for all value types. This is a little bit like the class and struct type constraints in C#, only you can use these as variables. They can also be used to limit type parameters, but Scala Generics are going to have to get their own post.

Making The Climb: Head-To-Head with Project Euler (questions #1 & #2)

Thu, 04 Aug 2011 01:50:00 +0000

I’m going to take a brief intermission in my Scala series, and show a head-to-head comparison of some code in Scala and C#. To do this, I’m going to go with the first and second problems from Project Euler. If your not familiar with the site, it’s a playground full of problems that are absolutely perfect for functional languages (cause they tend to be mathematical functions). So let’s get started with Question #1:

Making the Climb: Chronicling the journey from C# to Scala

Sun, 31 Jul 2011 19:41:00 +0000

Hows that for a title, eh? Yeah, I know, not great, but there is only so much creativity I can manage in a day, and as you will soon find out my mind is busy with all kinds of new and interesting thing, so any spare neural pathways which may have one been useful for something like clever titles are now just too busy to be bothered.

So what is this all about? Several months ago I had an interesting experience. One that I could almost compare to a religious experience, only not quite so….religious. It started with the most excellent book [Seven Languages in Seven Weeks](http://pragprog.com/book/btlang/seven-languages-in-seven-weeks) by Bruce Tate, from our good friends at the [Pragmatic Programmers](http://pragprog.com/). Now, I will admit that I’ve not actually read all of it…yet. The reason is that while I found the first several languages (Ruby, Io, and Prolog) interesting, and challenging, it was [Scala](http://www.scala-lang.org) that had a certain something that kept me wanting to know more. Mr. Tate actually didn’t care much for the syntax of Scala, and was rather pleased to move on to Erlang. Meanwhile I was off and running downloading Eclipse and the Scala IDE, looking at testing frameworks, online documentations, and what’s this? Android development with Scala!?!? I was hooked.

What is Scala all about?

2003 - A drunken Martin Odersky sees a Reese’s Peanut Butter Cup ad featuring somebody’s peanut butter getting on somebody else’s chocolate and has an idea. He creates Scala, a language that unifies constructs from both object oriented and functional languages. This pisses off both groups and each promptly declares jihad.
James Iry - A Brief, Incomplete, and Mostly Wrong History of Programming Languages

Announcing the Duhking Library for .Net 3.5

Thu, 17 Jun 2010 21:46:05 +0000

If it walks like a giraffe and talks like a duck then what is it? Maybe a duhk? Who knows, but it certainly is not a duck. So if that is the case, then you can probably guess what the Duhking library is all about…or maybe you can’t. In terms of programming, Duck Typing refers to the ability of some languages to allow you to treat an object of one type as an object of a different type, provided the methods/properties needed exist on both objects. Statically typed languages are usually not very good at this sort of loosey-goosey type inference, which is why this behavior is typically restricted to languages with less stringent rules on typing.

More CodeRush Awesomeness

Tue, 15 Dec 2009 15:08:00 +0000

On November 27th, a beta release of the 9.3 version of the Developer Express components, including CodeRush and Refactor Pro! was made available to subscribers. This release is pretty significant to me because it contains a major feature that I have been waiting for for a long time: A Unit Test Runner. There were some teasers released by Mark Miller a while back, which only made me want to get my hands on the tool that much more. My initial impressions are that it is very nice. It is similar to TestDriven.Net in that it provides context menu options to run tests at various levels of granularity (single test, file, project, and solution level) and includes a debug option. At this point it does not contain some of the additional coolness that TestDriven gives you like NCover/Team Coverage and TypeMock integration, but it does have the advantage of being extensible. I know it was extensible because Mr. Miller told me it was extensible (the title “The Extensible Unit Test Runner You’ve Been Waiting For” was a clue). I did not realize how extensible, however, until after I submitted a bug report to DevExpress. The bug I was reporting (the NUnit TestCase attributes were not recognized), it turns out, was already brought to the attention of the DX team by way of a forum post, and they had already planned on correcting it with the next 9.3 release, but I could have saved myself (and Vito on DevExpress team) some time by taking a peek at the source samples bundled with the 9.3 release. Yep, you guessed it, there with a shared source license were all of the test framework implementation projects. So this meant I could whip together my own temporary fix while I was waiting for the next release. It seemed like something that other folks might want to know about, so I thought I would share it here.

Announcing CR_MoveFile: DxCore plug-in for moving files around in a solution

Mon, 07 Dec 2009 19:17:00 +0000

As of right about now, you should be able to mosey on over to the DxCore Community Plug-ins page, and grab a copy of CR_MoveFile. This is a plug-in I created primarily as a tool to aid in working in a TDD environment, but which certainly has uses for non-TDD applications. It does basically what the name suggests, it allows you to move a file from one directory in your solution/project structure to another, even one in a different project. I implemented this as a code provider (since it could change the functionality if you move the file from one project to another), so it will appear in the Code menu when you have the cursor somewhere within the beginning blocks of a file (“using” sections, namespace declaration, or class/interface/struct declarations). Once selected you are presented with a popup window which has a tree that represents your current solution structure, with your current directory highlighted. You can use the arrow keys to navigate the directories and choose a new home for your file.

Getting a CodeRush: Inside a CodeRush CodeIssue

Wed, 07 Oct 2009 17:22:00 +0000

Anyone who has been around me for more than a few hours while coding, or who pays any attention to me on Twitter will know that I am a huge fan of CodeRush and Refactor Pro! from DevExpress. I consider these sorts of tools essential to getting the most out of your development environment, and I think CodeRush is one of the best tools available for a number of reasons, not the least of which is it’s extensibility. CodeRush is built on top of DxCore, which is a freely available library for building Visual Studio plug-ins (incidentally, DevExpress also have a free version of CodeRush called CodeRush XPress, which is built on the same platform). DxCore provides any developer who wants it access to the same tools that the folks at DevExpress have for building plug-ins and extensions on top of VisualStudio, and several developers (including yours truly) have done just that.

Some code for sorting lists which may contain dependencies

Fri, 18 Sep 2009 20:08:47 +0000

I ran into this odd problem recently working with some Linq2SQL based persistence code. There is some code someone put together to commit a list of changed entities to the database as part of a single transaction, which simply iterates through the list and performs the appropriate action. The problem I was having was that I had an object referenced by another object that needed to be persisted first, otherwise there was a foreign key violation. To add to the strangeness there seemed to be some magic going on (most likely utilizing the INotifyPropertyChanged goodness), so that even if I tried to persist just my dependent object first, both were still showing up in the list, and always in exactly the wrong order. Now, I’m okay with magic. Magic makes a lot of things a lot easier. The problem arises whenever the magic is incomplete, and doesn’t follow through to take care of all of the operation. Its like someone comming up to you and saying “Pick A Card”, at which point you do, and put the card back, and they say “I know what your card was” and walking away. Not real convincing. This is what was going on here. There was the smarts to know that changes were being made to more than one entity, and there were even attributes to define what properties contained dependent objects, but no smarts to actually deal with a case when you would want to save more than one object in an object graph at a time.

Review: Art of Unit Testing by Roy Osherove

Wed, 02 Sep 2009 17:36:02 +0000

I was pleased to find recently that Roy Osherove’s Art of Unit Testing was available on Safari. I have been following Roy’s blog for a while now, and was quite excited at the prospect of him writing a book on Unit Testing. It was only my personal cheapness that kept me from shelling out the $25 to get the E-Book version from Manning ahead of time. I have to say, now that I have read it, that it would have been well worth the money. Before I get too deep I want to provide some context for what I am about to say.

Some (good?) string extension methods

Sun, 22 Feb 2009 17:19:09 +0000

So, to take a slightly different turn from my usual meta discussions of process, theory, and architecture, there have been several people who have offered up some examples of extension methods that they have found useful, now that .Net 3.5 is roaring along nicely. There are some collections of such utilities, like the Umbrella project, and some folks like Bill Wagner who have written books on the subject (okay, there are other things in there too), so I thought I might as well throw my hat into the ring as well. Specifically, there was this tweet from @elijahmanor a few days ago. It points to a positing which includes some extensions on string to convert from strings to value types (int, long, short, etc). I pointed out that in our current project we have distilled this down to a single extension method: To().

Do I have the answer yet? Not really

Sun, 08 Feb 2009 00:31:31 +0000

So previously I posed a question, which in it’s simplest form is: Should you write code for the rest of your group (or at their proficency level), or should you write code as advanced as you need. and let it serve as an example for those on your team who are less advanced in their abilities. The practical answer I have come up with is, like most answers of this type, “It depends”.

Use of a "Personal Branch" for long-running stories

Sun, 08 Feb 2009 00:09:21 +0000

At Envisage, we have a 1 week iteration. This means that we typically don’t want a single story to go longer than one week. We also change up the pair rotation once per week. The estimation process is not perfect, though, and we have a lot of support from management to choose doing things right, rather than doing things now, which leads to stories going beyond a single iteration. So when this happens, there is usually a small rock/paper/scissors session with the developers involved to determine who will be taking the story. More often then not, the story goes with the machine (and the developer) that was used to do the work, since it is usually not practical to check in changes at the end of the week (also, our QA builds on Fri for a demo, so a green build is needed on Fri).

How important is your Code Audience?

Tue, 08 Apr 2008 17:30:04 +0000

We had a friend visiting from out of town last night, and she is apparently fond of “Top Chef”. This was the first time I had encountered this particular “reality” based show, and I found in a lot of ways it was like the majority of the rest of the shows out there; trying hard to create drama where there really isn’t any. In this particular episode there was a challenge to cook food for a neighborhood block party. The group that did the worst in this particular case cited the fact that they were preparing food for everyone including kids, as a reason for not getting jiggy with the menu (in a culinary sense). The response from the judges was that good food would speak for itself, and they should have considered it their responsibility to raise the collective bar of quality for the neighborhood.

The evolution of design, and the continued search for "The Way"

Tue, 02 Oct 2007 20:53:00 +0000

I’m currently finding myself in the midst of an evolutionary change. And I’m not talking about my super-human mutant powers, I’m talking about the way I’m thinking about solving a specific set of problems.

Let’s start with a sample….Lets take something like processing credit-cards as a benign and IP free place to start. As a subject that I really have no practical experience with, it seems like an appropriate choice. I’m going to assume that there are different rules for doing checksum validation on credit card numbers, depending on what the card is (Mastercard/Visa/Discover/etc). Now, here is evolutionary step 1: Use a basic case statement to process the various cards. Here is what something like that would look like:

I'm getting more fluent...and its kinda strange

Sat, 15 Sep 2007 15:29:40 +0000

About two weeks ago I crafted my first Fluent Interface. Since then I’m finding myself seeing more and more places where I think such an approach would be useful. The part that I’m finding odd is that it is something that just recently became a possibility for me. The big motivating factor behind that I believe was reading the post that Martin Fowler did on the subject, in which he basically describes it as a super-great idea (okay, I’m paraphrasing, but you get the idea). The concept is fairly simple; write an API that reads like a sentence.

Forcing redirection to HTTPS in ASP.Net

Fri, 17 Aug 2007 21:02:01 +0000

I ran into this issue today when trying to find a quick and dirty script to enforce redirection from HTTP to HTTPS for an intranet site we’re enabling for HTTPS (yes, I know SSL on an intranet??? One word - Audit). I thought this would be easy…I half expected that there would be an IIS setting to handle this for me; I was wrong on both counts. So what I ended up doing is using an old DNN HttpModule which was set up to allow the user to specify specific tabs in DNN for SSL, and greatly simplifying things to work to my advantage. I thought I would post it so I wouldn’t have to look for it again.

Taking the CodeRush Plunge

Fri, 13 Jul 2007 15:00:21 +0000

I recently decided to take the plunge and get CodeRush and Refactor! Pro (along with DxCore) loaded instead of Resharper. Now, don’t get me wrong, there is a lot I like about Resharper, but overall the performance was becoming an issue. There were often problems with VS freezing for no particular reason, and then coming back as if nothing was wrong…I swear it was like my IDE had narcolepsy or something.

One of the things I noticed immediately about CodeRush was the fact that there was a single installer, and when I went to run it I was able to install it on all versions of Visual Studio, including the Orcas Beta. This was nice when compared to Resharper’s separate install for vs 2005 and vs 2003. It also makes me feel good about improvements in the product being available for all versions of the IDE. One thing that I noticed about R# was that there was some work being done in the VS 2005 version around performance, but that did not seem to trickle down to the VS 2003 version. I think the big reason for this is the fact that CodeRush and Refactor! are implemented on top of DxCore, which provides a very clean abstraction from the scariness that is the Visual Studio integration layer.

More On Testing and "Friend" Assemblies

Mon, 18 Jun 2007 15:33:00 +0000

So if you recall from some of my earlier posts, I’ve talked about the concept of the “Friend” class in C++ and how it could apply to TDD within .Net. Well, today, with the help of Roy Osherove, I just stumbled upon the InternalsVisibleToAttribute within .Net 2.0. This allows you to specify within one assembly, another assembly that should have access to the internal members of your assembly. This is genius, and goes a long way towards allowing you to keep your code encapsulated, while still being testable. If we could just get them to go one step farther, and allow for access to private and protected members as well, life would be good, and there would be no more of this OOD vs TOOD junk.

Struggles with the UpdaterApplicationBlock

Mon, 11 Jun 2007 18:53:07 +0000

The project I’m working on now has a huge need for auto-update. Strangely enough, there aren’t a whole lot of documented solutions for an auto-update application for .Net 1.1. In the 2.0 world you have ClickOnce, which handles those sorts of things for you (and in a way that isn’t terribly difficult to manage as a developer…as long as you pay attention to what your doing), but the only real option you get from MS on this is the AutoUpdater Application Block from the Patterns and Practices guys. I took a look at this when it was in it’s 1.0 version a while back, and really didn’t care for it much. The big reason was that it required you set up an AppStart.exe file, which would take a look at your config file to determine which directory to start the app from. When updates arrived, they were put in new directories based on versions. This seemed like a lot of effort, and a lot of overhead. The good news is that there is now a 2.0 version of the application block, and it looks like it is much more configurable, and has the ability to do inproc updates.

You got your DDD in my SOA!

Tue, 05 Jun 2007 14:09:50 +0000

I’ve been trying to catch up on past episodes of .Net Rocks while on my hour+ drive to work everyday, and this morning listened to the interview with Jimmy Nilsson (episode # 191) on Domain Driven Design. I’ll admit now that I have not had time to read his book all the way through, but it is one of the ones that I’m most eager to dig into, since not only is he talking about DDD, but he’s also talking about the Martin Fowler design patterns from PoEEA.

More Thoughts on Language Support of TDD

Mon, 04 Jun 2007 14:21:47 +0000

Thinking about my earlier post discussing the OOP vs TOOP problem, I mentioned at the end that the best solution to this problem in my mind would be integrated language support for test classes. Specifically, a way to let the Compiler/Runtime know that a specific class is a test class, and should therefore be able to access any and every property of a class.

It occurred to me that such blatant intrusion into the privacy of a class is not unknown in the programming world. C++ has the notion of a “Friend” class. This is a class that can access all members of another class regardless of their protection level. To keep things civil, so that just any class can’t declare itself to be a Friend of any class it wants, the class that the Friend class would be accessing would declare specifically that classes X, Y and Z are fiends, and so can have free reign. Granted this is considered to be rather scary, and one of those features that makes C++ an ideal tool for shooting ones own foot off.

Using Unit Testing To Document Requirements

Fri, 01 Jun 2007 15:17:02 +0000

Here is something I’ve been kicking around in my head for a while, and thought I would put it down in more or less a “permanent” format so maybe I’ll do something about it sometime…

Back when I was first trying to get my head around TDD, one of the things that I found most clarifying was an idea I first saw in Test Driven Development in Microsoft .Net (Microsoft Press). The idea is that you write tests based on your requirements. So as a developer, you should have hopefully been given a list of requirements by someone for the project you are working on. When you go to build the software you start looking at the requirements list, and the pick on (usually a simple one) to start implementing. Once you have your requirement you start brainstorming tests that can be implemented to fulfill that requirement. Once you can no longer think of tests for a requirement, you move on to the next one. After that once you have run out of requirements, then your done writing the software.

To TOOP or OOP? How to decide?

Tue, 29 May 2007 21:12:42 +0000

Its been a while now, but Roy Osherove posted some articles about Testable Object-Oriented Programming. That is, designing your code to be testable by default. The part of this that is most interesting is that he suggests that sometimes you need to sacrifice encapsulation in favor of being able to test your code. This is where one of the biggest flaws with TDD (at least in my opinion) begins to show. I think the idea of making code testable breaking encapsulation is one of the only arguments against TDD that I have heard that I can’t give a good defense for, and it makes me crazy.

I love Mock Objects, but am I a "Mockist"?

Tue, 29 May 2007 15:45:00 +0000

I have officially crossed over….I am now using Mock Objects in my tests and loving it. After much humming and hawing, and trying to figure out how to write truly effective tests, I decided to give it a go, and so grabbed a copy of Rhino Mocks and started the grueling task of converting some data access code so that I no longer needed a database to run the tests. It took a little bit to get my mind around the new way of thinking, but I have to say it worked great. I’m now able to test my data access routines with complete success, and about a 95% code coverage rate. This is all on top of the fact that I’m using Enterprise Library (for 1.1) for data access and exception handling.

More on Marker Interfaces

Tue, 16 Jan 2007 17:15:01 +0000

I’ve been reading the “Framework Design Guidelines: Conventions, Idioms, and Patterns for Reusable .NET Libraries” book recently, and I came across a section discussing interface design, which had direct bearing on one of my earlier posts regarding programmer intent. They basically state flat out that you should never use marker interfaces in .Net. Instead, you should favor custom attributes, and then test the type for that attribute. This was interesting to me, since I have been trying to determine what, if any, value marker interfaces would have in .Net. In the Java example I cited, one of the benefits was that the JavaDoc information associated with the interface would then be attached to the class, so you would have clear intent from the developer when the interfaces were used. .Net documentation comments don’t carry that same direct association…granted, when the documentation is generated, most of the time there will be a link to the interface definition..but it’s not quite the same. On the other hand, generally a custom attribute will not even provide that link, so from a doc standpoint there is less information available.

Capturing Programmer Intent

Tue, 02 Jan 2007 16:48:24 +0000

I was listening to the ArCast recorded with Scott Hanselman earlier today, and he was talking about the idea that Non-Software artifacts should approach zero. If you’ve seen some of his posts, or listened to some Hanselminutes podcasts, you have no doubt come across this idea before. I like this particular phrasing mostly because it gets to the heart of what I think one of the most often overlooked aspect of the programming process is; Namely, the intent of the programmer.

Thread Exception Change in .Net 2.0

Wed, 31 May 2006 15:47:26 +0000

I just learned that Microsoft changed the way unhandled exceptions in Threads are propogated in .Net 2.0 vs the way they worked in 1.1. With 2.0 any unhandled exceptions in a thread will not only cause that thread to exit, but will also be bubbled up to the thread that started the offending thread. Overall, I think this is a good thing, since not only will it force people to handle exceptions within their thread code, but it will also eliminate the problem of processes mysteriously stopping if there is an unhandled exception on a thread. It will, however, cause some serious grief for any developers not expecting that sort of behavior. I’m sure I’m not the only one who has seen less than steller multi-threaded programming tactics in applications which should be better behaived (heck, I’ve done my share of shoddy thread handling in the past).

Learn something new every....

Wed, 24 May 2006 16:30:23 +0000

It just goes to show that there are always little surprises waiting around the corner. I’ve been looking at least casually at .Net 2.0 since Beta 2, and I even read through the “What’s New” for C# 2.0 to see if I missed anything. Somehow I managed not to notice Implicit Delegate Assignment (or at least that’s what I’m calling it).

It is now possible to assign a delegate using just the Class and Method name…you no longer have to create a new instance of the delegate type. Not a huge thing, I know, but for those of us who are easily impressed it’s, well, impressive.