If you want to have specific values that MEAN something and won't be decoded in the application by complex logic operating on context data, then design the database better. Sometimes I do use meta-values in the data such as 0 = not chosen, -1 = something else (often with these values in the lookup table, for example, but that has its own problems). But not always. One has to use experience and a keen mind in these situations to choose what will be the simplest, easiest to use & understand, and still maintain data integrity.
Okay, so you can't design the database better if you can't change the database. If you transform NULL into some value that one is "supposed" to interpret a certain way but otherwise doesn't mean what it looks like (e.g., 1/1/1900 means something and it's not the date January 1, 1900), then unless you have absolutely complete control over how the data is used, you're potentially introducing data quirks that could have disastrous consequences.
VB6 CAN accept Nulls in the Variant data type. There's nothing wrong with using Variants in most GUI situations. Tight loops that are executed thousands of times? Okay use a typed variable. But when working with columns from databases, just use variants. Don't taint your data by losing the "extra value" that NULL provides you. Now you're just risking someone somewhere getting confused. (E.g., does 0 mean that's the price or does it have no price? Heck, who knows? At least a null will be clear you didn't mean it was free.)
You can also use the built-in function Nz() if you want something more explicit than the null-defeating concatenation operator:
[tt]strClaim = Nz(RsTempRecordset.Fields("Claim"), "Not on file")
intSomeNum = Nz(RS.Fields("SomeNumericColumn")), 0)[/tt]
If that function is not enough for you, write your own function that encapsulates business logic and use the dratted thing.
In fact, now that I think about it, I suggest that you not go around interpreting the NULL in the middle of code that does something else. This isn't just about code re-use but also about good practices. When you need to modify or examine how nulls are handled, you shouldn't have to find it buried in some routine somewhere. It belongs in a data business logic module.
I've been learning about Agile Development and any desire for unit testing capability makes this a clear and easy requirement. How can you test your null logic if the only place it lives is in the middle of something else? And if you're not testing your code, well... go read up on Agile if you want to know what it says about not doing test-driven-development. (Yes, I'm a recent convert.)
P.S. The concatenation operator & converts to string and defeats nulls. But you can also concatenate strings using the + operator which propagates nulls. It may not be best practice since not everyone is aware of this, but you can exploit this really elegantly:
[tt]strName = LastName & (", " + FirstName)[/tt]
Be careful when doing implicit type conversion with +. Do you know off the top of your head what result and data type you'll get with this:
[tt]varResult = "1" + 1[/tt]
Is it "11" or 2?