James Wiseman

Found by my parents when clearing the attic of their house. A poem from my Grandfather, Wilfred Engel to his wife, Alice, on a ruby wedding anniversary card.

November 25th 1973

To: Mate-O-Mine

We set out together, Mate O’ Mine,
When youth was in its prime.
Life the way that lie before us,
Steep the hill we had to climb.
We neither of us knew the way,
How steep the path, how great the load.
Now I know great the debt I owed,
To God, for Mate O’ Mine

We  set out together, Mate O’ Mine,
We’ve wended vale and hill.
Now it’s homeward through the twilight,
We must wander at God’s will.
We’ll neither of us fear the gloom,
Love still shall make our pathway shine.
Should you be last returning home,
I will greet the Mate O’ Mine.

Mate o’mine music : words by Leslie Cooke

Occasionally, I like to give my mind a treat, and visit some of those sites that claim to be able to value domains. I made reference to one, StrategicFirst back in my post of May last year, Your Website Archive on the WayBack Machine, which valued my site at $5000!

Last time I checked StrategicFirst was no longer with us, but there are some more, which I thought I would share.

Firstly we have the the valuation service at err, $timator.Com. This values the domain name at a whopping $35,692 at the time of writing.

Not to be outdone, TweetValue.com values it at an eye-watering $140,951!

Does exactly what it says on the tin site ValueTheWebsite.com is a little more conservative at $5,441.

Suspiciously similar is the valuation at domainvalue.congland.com, which quotes the value as $5,413.

Perhaps slightly more realistic is the valuation at estibot.com, which estimates the worth as $380.

dnScoop attempts to ruin my fun by valuing it at a paltry $27!

That’s more like it! CubeStat.com cheers me up a little with a valuation of $1,721.34.

Valuate.com comes in with some identical stats to estibot.com. $380 again.

Meanwhile, URLAppraisal.net estimates $19,650.15.

Two more, $2,850 at MySiteCost.com and £1,269 (UKP) at EstimURL.com.

I’m getting bored now, but time for one final estimate. According to WebArtiter.com, JamesWiseman.com is worth $7391.25.

I stopped on page 2 of a Google search for “domain value” (unquoted). Looking at pages 3 onwards there would appear to be many more. This seems to me like a perfect opportunity for some sort of aggregation utility.

In reality I’m never going to sell this site unless I get a really good offer. Regardless of how much it is worth to someone else, its worth a lot to me, and represents a lot of my time invested.

JavaScript isn’t very particular about whether or not you declare your variables (its loosely typed). In fact, you can often get away without doing so. Consider the following:

x = 0;
alert(x);  //alerts '0' quite happily

The about example isn’t overly problematic, but that doesn’t mean that its a sensible thing to do. This, assumes you intended to do this. Consider the following:

var receivedParts = 0;
recievedParts = GetReceivedParts();

Whoops! Can you spot what’s wrong? Yes, we’ve spelled ‘received’ differently (mixed the ‘e’ and ‘i’ in our typing). JavaScript doesn’t care, though.A value is assigned to the latter without complaint.

Of course we might have intended to do this, but even this is inadvisable. Consider the following:

receivedParts = receivedParts + 1;

Our variable isn’t defined, so, again we have a bug.

Of course, in strongly typed languages, this isn’t an issue. In effect, JSLint is attempting to make JavaScript a more strongly typed language.

A Guide To JSLint Messages

This article is one of a series on the error and warning messages produced by JSLint.

JavaScript will let you repeat your declarations without complaint, however it’s rarely, if ever, a good idea to do so:

var x = 0;
var x = 1; //no complaints!

JavaScript here will simply disregard the first declaration. The above is clearly nonsense, but there are circumstances in which a developer might declare a variable twice in faith. Consider the following:

if (condition) {
    var x = 0;
} else {
    var x = 1;
}

Here, the developer has made the assumption that JavaScript allows you to scope variables locally. The developer is, of course, wrong in this assumption. All declarations are hoisted to the top of the containing scope. So, in effect we still have two declarations.

The same message is produced for other declarations, e.g. functions:

function foo(){};
function foo(){}; //'foo' is already defined.

Multiple declarations of the same name are subject to confusion and buggy code, and therefore should be avoided.

A Guide To JSLint Messages

This article is one of a series on the error and warning messages produced by JSLint.

In JavaScript we can assign a function expression to a variable, like so:

var foo = function() {
    return 1;
}; //assign function expression to 'foo'

This is perfectly valid, and often useful.

It is also possible to assign a variable the return value of the function expression by invoking the function, like so:

var foo = (function() {
    return 1;
}()); //assign '1' to 'foo'

This is also valid, although less commonly useful.

These are two distinct techniques with distinct conventions, so, the following may well give rise to confusion:

var foo = (function() {
    return 1;
});//assign function expression to 'foo'

The above is equivalent to the first sample of code, and will execute in exactly the same way. JSLint encourages you to wrap invoked function expressions with parentheses. Wrapping non-invoked function expressions in the same way may be indicative of something non-intentional, or at very least be misinterpreted by a future developer.

In other words, stick to the first convention for the assignment of function expressions.

A Guide To JSLint Messages

This article is one of a series on the error and warning messages produced by JSLint.

This is the longest error message that JSLint boasts. In full it reads:

“Wrap an immediate function invocation in parentheses to assist the reader in understanding that the expression is the result of a function, and not the function itself.”

What a mouthful!

This is relatively simple to explain, however:

var a = 1 + function() { return 1; }(); //assigns '2' to the variable 'a'

The JSLint error can be addressed by adding parentheses around the function:

var a = 1 + (function() { return 1; })(); //assigns '2' to the variable 'a'

However, this will yield another JSLint message Move the invocation into the parens that contain the function.

So, of course to address this, we wrap the whole invocation with the parentheses, like so:

var a = 1 + (function() { return 1; }()); //assigns '2' to the variable 'a'

So what is the reason for this? Well, actually, the message itself explains is quite well: “Assist the reader in understanding that the expression is the result of a function, and not the function itself.” Not all of JSLint is about bugs and problems. Some are all about achieving a consistent style. This is one of them.

This is similar to another wordy JavaScript message: Function statements are not invocable. Wrap the whole function invocation in parens, which captures isolated unwrapped function declarations. Seen in the following example:

var a = 0;
function foo(a) {
    alert(a);
} (a);

Here, we can see that, again, the invocation is missing a wrapping parentheses. However, in direct contrast to the first example, the code immediately above will fail.

A Guide To JSLint Messages

This article is one of a series on the error and warning messages produced by JSLint.

JSLint reports this error when a function name has been omitted from a functions statement. For example:

function(a) {
    alert(a);
}

It is possible that the original intention was more like the following:

function foo(a) {
    alert(a);
}

Although, it is also conceivable that a function expression was also intended:

var foo = function(a) {
    alert(a);
}

A Guide To JSLint Messages

This article is one of a series on the error and warning messages produced by JSLint.

This message was acutally too long for the subject title. In full, it reads:

“Function statements should not be placed in blocks. Use a function expression or move the statement to the top of the outer function.”

We can reproduce this message with the folllowing code:

var a = 0;
if (a === 0) {
    function b() {
        alert(1);
    }
} else {
    function b(a) {
        alert(2);
    }
}
b(); //call the function. But which one?

The intention is to decalre a function based on some condition, but this doesn’t necessarily work, and the condition is likely to be ignored. Instead we are at the mercy of each inditidual implementation of the JavaScript interpreter.  With the above examples, we may see either “1″ or “2″ alerted.

To achieve what we are attempting we need to use a function expression, like so:

var a = 0;
var b;
if (a === 0) {
    b = function() {
        alert(1);
    }
} else {
    b = function(a) {
        alert(2);
    }
}
b(); //call the function.

This will work every time.

A Guide To JSLint Messages

This article is one of a series on the error and warning messages produced by JSLint.