The famous large flat thing slightly more useful than a rock

Here at Konstellation, we just launched the PageGangster for mobile devices including iPad, iPhone, iPod touch and Android. I developed the clientside for this in JavaScript and we launched it with automatic user agent detection serverside. But this had some problems.

I read some info about this and conclude, that some iPad user agent strings include the word “iPhone” and some users of all types of devices fake their user agent strings.

But then I read on the above link, that no matter what, the navigator.platform attribute would always be set to the right type of device. So in the regular web version of the publication viewer we have now (which uses Flash), we have added a JavaScript detecting if the serverside script did not redirect the client properly:

if (navigator && navigator.platform && navigator.platform.match(/^(iPad|iPod|iPhone)$/)) {
	location.replace(location.href+"?force-mobile");
}

It seems simple, but solves the problem of some users seeing the dreaded blue box instead of their publication optimized for their device.

On another node, this experience of developing a web application for the iPad/iPhone was very rewarding and I gained many insights, which might spawn other posts. And if you have any questions about it in any way, feel free to ask here – but please do not submit bug reports about the PageGangster for mobile – do that via info@pagegangster.com instead.

Related posts:

1. The iPhone developer boycott in the works
2. Coordinate-Proxy – January 2010 Ideas
3. App Idea Store – January 2010 Ideas

I do not know how to integrate all these things, but a good traffic analyzer should know not only who links to you but also who is sharing links to your services through which channels. It should report which channels generate the most traffic, but also who pushes the links to these channels etc. If someone e.g. tweets/diggs/reddits about your service/website a lot, it should be reflected.

About the short-comings of Google Analytics, my main concern is, that when experimenting with how you can track new things, there is a 1-4 hour delay on page tracks and up to 3 days delay on custom variables tracking (in my experience). A good provider really ought to have a development option available, that only allow limited traffic but provide almost-instant analysis of this data.

Why?

This is one of the simplest of Google’s services, and thus we really need a contender. With the availability of cheap clouds, it should be quite easy to set up, though it would require some funding to provide it to people for free. Google Analytics does not innovate that much – not in the social media tracking area at least. They are more interested in developing new things in the “how can I make people buy more crap from me” category for web shop owners.

What’s next?

Do with this idea whatever you like – expand, implement, trash or forget. Just remember, that if you use it in anyway make sure to attribute me according to the Creative Commons Attribution 3.0 License, that all these 365 Social Ideas are published under.

Related posts:

1. Social Subway – January 2010 Ideas
2. Comment On Everything – January 2010 Ideas
3. Coordinate-Proxy – January 2010 Ideas

Well, I have implemented a very simple demo of the first steps. So far, the script only makes sure to add some extra text to the current selection when ever the mouse button is released (which is how most users select most text) and it only works in Firefox (tested in 3.6). Next steps include making the link direct to the actually selected content, record text copying in Google Analytics, add cross-browser checks etc.

The script is published under the same license as these ideas, CC-BY 3.0.

Why?

Copy-paste is another quite common way of interacting with websites and allowing people to easily spread the word about your website in a new way ensures you credit where such is due. Creating a full-featured jQuery-plugin from this should be fairly easy and then making sure it integrates with Google Analytics if present – and then we’re actually done.

What’s next?

Do with this idea whatever you like – expand, implement, trash or forget. Just remember, that if you use it in anyway make sure to attribute me according to the Creative Commons Attribution 3.0 License, that all these 365 Social Ideas are published under.

Related posts:

1. Social Traffic Analyzer – January 2010 Ideas
2. Comment On Everything – January 2010 Ideas
3. App Idea Store – January 2010 Ideas

The idea is to create a bookmarklet, just like the Readability mentioned above, but instead of simply scraping the contents of the article and only present it to the user on-screen (and then all this is lost when he leaves), also connect to his locally downloaded and running News Aggregator, which will then store the URL, headline and body (and maybe the images, that the user selects as interesting and relevant) for offline viewing at any later stage. Imagine it a bit like sharing a link on Facebook, but actually only share it with yourself by copying the full contents and selected images to a local storage, and then read any article that you have found interesting at any later point.

This idea is completely legal, as no server ever scrapes any content from any website and no public display is made of the copy. The “copy” is made by the user himself only on his computer to the user’s own hard drive as if he copy-pasted it into a Word-document (which is always legal if only for personal use). If one wanted to implement a sharing-function in the application, it would however have to link directly to the original URL as the scraped content cannot be shared in a way, that could ever satisfy publishers.

Why?

Reading long articles in your browser is difficult and tiresome – especially when cramped in between navigation, advertisements and “layout”. If this idea was implemented, we could all in a legally safe way copy article contents for local viewing without having the problems of RSS-feeds (most only showing the first paragraphs) or news aggregators (some blocked by publishers).

What’s next?

Do with this idea whatever you like – expand, implement, trash or forget. Just remember, that if you use it in anyway make sure to attribute me according to the Creative Commons Attribution 3.0 License, that all these 365 Social Ideas are published under.

Related posts:

1. Browser Snapshot Sharing – January 2010 Ideas
2. Swell Wave – January 2010 Ideas
3. Comment On Everything – January 2010 Ideas

Introduction

In a regular (i.e. useful) number system, the digit values are powers of a given number starting with the right-most digit representing a digit value of the given base number to the power of 0, the second digit from the right representing a digit value of the given base number to the power of 1 etc. This has a lot of advantages beyond the topic of this post. Thus, in a base 10 number system, the right-most digit value is 1, the second from the right is 10, then 100 etc. There is a simple rule for how we go from one digit value to the next and for how to find an arbitrary digit value just by knowing the digit position.

But the simple point I’m making here is, that we could invent a number system, where the digits represent arbitrary values – e.g. the first digit from the right represent 1s, the second digit represent 4s, the third represent 178s, the fourth represent 179s etc. We can express any number in this (we could just extend the available numbers with letters or other symbols as we see fit) – in the example given here, the decimal number 2000 would be represented as 11*179 + 0*178 + 7*4 + 3*1 = B073. It is quite a useless set of digit values, and it is a very hard representational number system to do any math in.

For the XKCD book page numbering, Randall has chosen a number system, where the first digit from the right represent 1s, the second digit represent 3s, the third represent 7s, the fourth represent 15s and so on – thus there is actually a rule for finding the digit value for the n‘th digit (from the right) = 2i-1 – compare this to the binary system, in which the digit values can be calculated as 2(i-1).

UPDATE 2009-11-26: As it has been pointed out to me, this number system (which is skewed one off binary) is called skew binary. The only interesting property that I can find anyone reference is the fact, that increment only ever has one carry-over, which makes increment very easy to implement (and I could thus implement it in regexp as given further below). It is however only a “scientific” numbering system, and I can find no reference to any (other) usage in the wild. The article linked before is the first Google hit for “skew binary” and it is an 11 year old slide – which indicates further, that it is a rarely used system with only theoretical purposes.

Conversions

So, how to find the value, that a given XKCD page number represent? Simply multiply each digit by the digit value – if the i‘th digit (where i=1 represent the right-most digit) has the value xi the translation of an n digit XKCD page number can be done via this formula:

General conversion rule from XKCD page numbers to decimal numbers

The reverse translation can’t be done like regular conversion between regular bases bulding the number from the right (using modulus and division), but has to be done from the left. Thus we need to find the maximum i for which 2i-1 is less than the given number – which we do via log2(number+1). Then we go from this maximum i (which denotes the number of digits n in the XKCD page number) to 1 and for each step find the i‘th digit by evenly dividing the target number with 2i-1 and storing the remainder as the new target number – here both implemented in JavaScript:

function dec2xkcd(d) {
  var i = Math.floor(Math.log(d+1)/Math.LN2);
  var r, x = "";
  for (; i; i--) {
     r = Math.pow(2,i)-1;
     x += Math.floor(d/r);
     d = d%r;
  }
  return x;
}
function xkcd2dec(x) {
  var d = 0, l = x.length, i = l;
  while(i--) {
    d += parseInt(x.charAt(i))*(Math.pow(2,l-i)-1);
  }
  return d;
}

We can verify these by running some tests converting back and forth:

function c(d) {
  var x = dec2xkcd(d);
  var d_ = xkcd2dec(x);
  return d+" => "+x+" => "+d_;
}
c(1); // 1 => 1 => 1
c(6); // 6 => 20 => 6
c(15); // 15 => 1000 => 15
c(16); // 16 => 1001 => 16
c(119); // 119 => 111110 => 119
c(120); // 120 => 111111 => 120
c(6542); // 6542 => 110011001010 => 6542
c(5469835); // 5469835 => 1010011011101101001020 => 5469835

Properties

The selection of digit values are not completely random, they do follow some system, but not the systems of regular power-based number systems. So the properties, that regular power-based number systems have are not present in this, but it does have other properties.

First of all, the notion 2^n-1 is known from Mersenne primes. What this tells us however, is nothing useful about the system except that some digit values are prime – like 3, 7, 31 and maybe, maybe not an infinite number of the infinite other digit values.

Another property is, that from any digit value dn, the next digit value can always be calculated as 2dn + 1. This means, that the largest number the can be represented by n digits is a left-most 2 followed by n-1 0s – the next number in sequence is a left-most 1 followed by n 0s. But again, this is quite trivial and not really that useful.

The repunit numbers (numbers consisting solely of 1s) in this representational system represent the numbers 1 (1), 4 (11), 11 (111), 26 (1111), 57 (11111) and this order is actually the second column of the Eulerian numbers (defined by sequence A000295 in OEIS) – but this is still quite useless.

Algebra

So, is this usable as a number system? Can we do math in it? Can we in a simple way multiply numbers? Let’s start by making an algorithm for adding 1 to (incrementing) an arbitrary number. Observe, that we cannot simply safely increment the last digit if it is a zero – because if the number has a 2 in it (which only occurs in at most one position in the number and with no trailing 1′s), increment is done by converting the 2 to a 1 and incrementing the digit to the left of the 2 – examples:

• Increment 2 => 10
• Increment 12 => 20
• Increment 102 => 110
• Increment 120 => 200
• Increment 1012 => 1020
• Increment 2000 => 10000

It is not trivial, but then again, not that hard. For numbers without a 2, simply increment the right-most digit (which has to be a 0 incremented to a 1 or a 1 incremented to a 2).

Then, how do we subtract 1 (decrement)? Here the rule is, if the number has trailing 0s (one or more right-most digits are 0), decrement the right-most non-zero digit and change the left-most of the trailing 0s (the number just to the right of the right-most non-zero) to a 2 and keep the remaining as 0. If the number does not end in a 0, simply decrement the last digit – examples:

• Decrement 2 => 1
• Decrement 10 => 2
• Decrement 12 => 11
• Decrement 112 => 111
• Decrement 1010 => 1002
• Decrement 1020 => 1012
• Decrement 10000 => 2000

Still not trivial, but not impossible. UPDATE 2009-11-26: The fact that you at most have to alter two connected digits when decrementing or incrementing is what makes this number system interesting as this is a lot easier to implement that normal “base-based” number systems, where you worst-case have to alter all digits of the number when in- or decrementing – compare incrementing the decimal number 999999.

Comparison of numbers is done exactly as for numbers in any (regular) base – if one has more digits that the other, the “longest” number is higher. If not, compare digit by digit starting from the left, if a digit is higher in one number, than the same in the other, that number is larger, if equal, go to next digit. If all digits are the same, the numbers are equal.

All right, so far so good. Then we can add and subtract (but as we won’t consider negative numbers, subtraction cannot be negative). We add x to y by incrementing y and decrementing x at the same time until x equals 0 – the value of y is then the result. For subtracting x from y (i.e. y - x), we decrement both numbers until either is zero – the value of y is then the result (thus 1 – 2 is 0, as we don’t do negative number).

The next logical step is to consider multiplication (of positive numbers only of course). We multiply x by y by creating a result variable r and add x to it y times (decrement y each time until 0).

Implementation

Note: this gets very pointless, so feel free to skip to the conclusion – which is that all of this is just silly and pointless.

First, increment and decrement in JavaScript:

function inc(x) {
  if (!/2/.test(x)) {
    return x
      .replace(/1$/, "2")
      .replace(/0$/, "1");
  }
  return x
    .replace(/(0|^)2/, "10")
    .replace(/12/ , "20");
}
function dcr(x) {
  if (!/0$/.test(x)) {
    return x
      .replace(/1$/, "0")
      .replace(/2$/, "1");
  }
  return x
    .replace(/20(0*)$/, "12$1")
    .replace(/10(0*)$/, "02$1")
    .replace(/^0+/, "");
}
function id_test(d) {
  var x = dec2xkcd(d);
  var x2 = inc(x);
  var x0 = dcr(x)
  return x0+" ("+xkcd2dec(x0)+") => "+x+" ("+d+") => "+x2+" ("+xkcd2dec(x2)+")";
}
id_test(1);   // 0 (0) => 1 (1) => 2 (2)
id_test(2);   // 1 (1) => 2 (2) => 10 (3)
id_test(6);   // 12 (5) => 20 (6) => 100 (7)
id_test(7);   // 20 (6) => 100 (7) => 101 (8)
id_test(117); // 111100 (116) => 111101 (117) => 111102 (118)
id_test(123); // 111120 (122) => 111200 (123) => 112000 (124)
id_test(127); // 200000 (126) => 1000000 (127) => 1000001 (128)
id_test(128); // 1000000 (127) => 1000001 (128) => 1000002 (129)
id_test(603); // 100101120 (602) => 100101200 (603) => 100102000 (604)

Then comparison:

function cmp(x1,x2) {
  var l = x1.length, l2 = x2.length;
  if (l != l2) {
    return l > l2 ? 1 : -1;
  }
  var i, c1, c2;
  for (i=0; i<l; i++) {
    c1 = x1.charAt(i);
    c2 = x2.charAt(i);
    if (c1 > c2) {
       return 1;
    }
    if (c2 > c1) {
       return -1;
    } 
  }
  return 0;
}
function cmp_test(d1, d2) {
  var x1 = dec2xkcd(d1);
  var x2 = dec2xkcd(d2);
  var c = cmp(x1, x2);
  if (c > 0) {
    return x1+" ("+d1+") is greater than "+x2+" ("+d2+")";
  }
  if (c < 0) {
    return x2+" ("+d2+") is greater than "+x1+" ("+d1+")";
  }
  return x1+" ("+d1+") equals "+x2+" ("+d2+")";
}
cmp_test(1,1);     // 1 (1) equals 1 (1)
cmp_test(1,2);     // 2 (2) is greater than 1 (1)
cmp_test(2,1);     // 2 (2) is greater than 1 (1)
cmp_test(117,117); // 111101 (117) equals 111101 (117)
cmp_test(117,121); // 111112 (121) is greater than 111101 (117)
cmp_test(127,128); // 1000001 (128) is greater than 1000000 (127)
cmp_test(127,126); // 1000000 (127) is greater than 200000 (126)

Then addition:

function add(x1, x2) {
  while (cmp(x2, "0")) {
    x1 = inc(x1);
    x2 = dcr(x2);
  }
  return x1;
}
function add_test(d1, d2) {
  var x1 = dec2xkcd(d1);
  var x2 = dec2xkcd(d2);
  var xs = add(x1, x2);
  var ds = xkcd2dec(xs);
  return x1+" ("+d1+") + "+x2+" ("+d2+") = "+xs+" ("+ds+")";
}
add_test(1, 1);   // 1 (1) + 1 (1) = 2 (2)
add_test(1, 2);   // 1 (1) + 2 (2) = 10 (3)
add_test(2, 1);   // 2 (2) + 1 (1) = 10 (3)
add_test(7, 7);   // 100 (7) + 100 (7) = 200 (14)
add_test(8, 17);  // 101 (8) + 1002 (17) = 1110 (25)
add_test(53, 17); // 11100 (53) + 1002 (17) = 100100 (70)

Then subtraction:

function sub(x1, x2) {
  while (cmp(x1, "0") && cmp(x2, "0")) {
    x1 = dcr(x1);
    x2 = dcr(x2);
  }
  return x1;
}
function sub_test(d1, d2) {
  var x1 = dec2xkcd(d1);
  var x2 = dec2xkcd(d2);
  var xs = sub(x1, x2);
  var ds = xkcd2dec(xs);
  return x1+" ("+d1+") - "+x2+" ("+d2+") = "+xs+" ("+ds+")";
}
sub_test(1, 1);   // 1 (1) - 1 (1) = 0 (0)
sub_test(1, 2);   // 1 (1) - 2 (2) = 0 (0)
sub_test(2, 1);   // 2 (2) - 1 (1) = 1 (1)
sub_test(7, 7);   // 100 (7) - 100 (7) = 0 (0)
sub_test(17, 8);  // 1002 (17) - 101 (8) = 102 (9)
sub_test(53, 17); // 11100 (53) - 1002 (17) = 10012 (36)

Finally multiplication:

function mul(x1, x2) {
  if (!cmp(x2, "0")) return x2;
  // x2 is not zero, go
  var r = x1;
  while (cmp(x2, "1")) {
    r = add(r, x1);
    x2 = dcr(x2);
  }
  return r;
}
function mul_test(d1, d2) {
  var x1 = dec2xkcd(d1);
  var x2 = dec2xkcd(d2);
  var xs = mul(x1, x2);
  var ds = xkcd2dec(xs);
  return x1+" ("+d1+") * "+x2+" ("+d2+") = "+xs+" ("+ds+")";
}
mul_test(1, 1);   // 1 (1) * 1 (1) = 1 (1)
mul_test(1, 2);   // 1 (1) * 2 (2) = 2 (2)
mul_test(2, 1);   // 2 (2) * 1 (1) = 2 (2)
mul_test(7, 7);   // 100 (7) * 100 (7) = 11010 (49)
mul_test(17, 8);  // 1002 (17) * 101 (8) = 1000102 (136)
mul_test(53, 17); // 11100 (53) * 1002 (17) = 111000101 (901)

Conclusion

As expected, it is just a silly and very useless number system – but fun to play around with though. If you however find other interesting properties of this representational system, please feel free to comment.

However, it should be clear to anyone, that this has nothing to do with a ternary number system just because the only digits are 0, 1 and 2 – it is closer related to the binary number system.

UPDATE 2009-11-26: Albeit still useless, the number system actually has the name “skew binary” as mentioned in the introduction – and thus has been the target of some scientific research previously.

No related posts.

With HTML 5 and the introduction of datasets, we can do something new. The main advantage and the really huge application area for datasets are, that you can include custom attributes in the serverside-rendered HTML, that the client-side script will use to enhance the browsing experience.

A common example: You have a gallery page, which has an area for displaying a large image and one for a list of thumbnails. In the serverside-rendered HTML you render the first picture in the large image and a list of thumbnails below. In javaScript you hook a function for each thumbnail to change the large image. But where do you supply the path for the large image? It could be done via several methods:

• from the server render a JavaScript-array that do the mapping,
• have a strict naming-convention, and e.g. always remove “-thumb” from the thumbnail path to obtain the large image path,
• hide it on the node by abusing some existing legal property – e.g. hide it in the title-field of the thumbnail, or
• add it is a new property on the node, that will make your document non-compliant with the standard.

But with datasets, the server simply includes the large image path on the thumbnail image node (or the surrounding link node) via a custom data-attribute here named data-fullpath:

<img
  id="large-image"
  src="images/large/picture1.png"
  alt="Large Picture 1"
/>
<ul id="thumbnails">
  <li>
    <a href="gallery_with_picture1_enlarged.html" title="View Picture 1">
      <img
        src="images/thumbs/picture1.png"
        data-fullpath="images/large/picture1.png"
        alt="Picture 1"
      />
    </a>
  </li>
  <li>
    <a href="gallery_with_picture2_enlarged.html" title="View Picture 2">
      <img
        src="images/thumbs/picture2.png"
        data-fullpath="images/large/picture2.png"
        alt="Picture 2"
      />
    </a>
  </li>
  <li>
    <a href="gallery_with_picture3_enlarged.html" title="View Picture 3">
      <img
        src="images/thumbs/picture3.png"
        data-fullpath="images/large/picture147_no_conventions.png"
        alt="Picture 3"
      />
    </a>
  </li>
</ul>

Of course, in live implementation the links above would link to pages, where the other thumbnails where shown in the large area to allow for graceful degradation, but this is just to show the idea. The above example have now been updated to provide actually interesting links in the surrounding <a>-tags and not just link to the image as several have suggested.

The JavaScript that went with this would be something along the lines of (asuming jQuery.dataset functionality):

$("ul#thumbnails a").click(function(e) {
	$("#large-image").attr("src", $(this).find("img").dataset('fullpath'));
	return false;
});

See full example here – it works in all browsers, and is valid HTML 5. The JavaScript works in non-HTML5 browsers, as it includes a little jQuery plugin I wrote adding the method dataset, which includes a fallback if the DOM attribute “dataset” is not available.

I personally find this to be a very clean way of implementing this feature over the many hacks, that we need to use today. And this is of course not limited to galleries, but can be used for anything, where the script needs to know extra information about the objects in the document in order to add additional functionality through scripts on the page – this could include having a reference to “previous” or “next” image in the above gallery, meta-information about rows in a table to use for client-side searching, filtering or sorting, meta data for link previews and many other possibilities.

NB: This is not to be used as meta-data for external entities – only for scripts on the page enhancing the browsing experience. For providing meta-data for external entities, use microdata, which is completely different from datasets – but the two could be used to convey the same meta information, just with different recipients in mind.

Related posts:

1. Web Sockets in HTML 5 might solve the http pull problem once and for all

/^1?$|^(11+?)\1+$/

I will try to explain it in a simple way and then do some benchmarking on this simple expression, a slightly optimized version of the expression as well as compare it to more optimal algorithms.

I can explain it very simply. The first part of the expression check the special cases of zero or one 1′s. The second part checks whether the number of 1′s is a multiple of another substring of 1′s. It does that by un-greedily matching the shortest possible string of 1′s larger than one (the shortest possible is initially of course two 1′s) as the first group and then checks whether the remaining number of 1′s is evenly divisible by this by a factor larger that zero – that is, if there were six 1′s, the remaining number of 1′s after having matched the first two would be four, which is evenly divisible by two by a factor larger than zero. If we tried to match nine 1′s, the first attempt at matching two 1′s in the first group would fail, as the remaining seven 1′s is not evenly divisible by this. But the regular expression backtracking engine would then backtrack to matching three 1′s in the first group, and then the remaining six 1′s would be evenly divisible by this number, and the pattern matches – thus 9 is not prime as expected.

The penalty? Well, try to match eleven 1′s, the first group would initially be set to two 1′s, and the remaining expression fails, the initial group would then be set to three 1′s, and the remaining expression would still fail, then the initial expression would be set to four 1′s (which is just stupid prime-checking-wise – 2 was not a factor, then how could 4 be?) and it would still fail – and so on until the engine would match all eleven 1′s as the first group and check if the remaining zero 1′s is evenly divisible (by a factor larger than zero of course) which it isn’t and only then would the expression fail. It is thus highly expensive, as there is of course no need to check if any number higher than the square root of the number to check divides the number evenly, if all numbers below the square root doesn’t.

To do some speed-testing, let’s try to check the number 9017 (which is the product of the somewhat large primes 71 and 127 and thus not prime) and the number 9029 (which is next prime after 9017). And for the fun of it, let’s test it in JavaScript right here in the browser:

function check1(number) {
	var t1 = new Date().getTime();
	var str = "";
	for (var i = 0; i<number; i++) str += "1";
	var t2 = new Date().getTime();
	var result = /^1?$|^(11+?)\1+$/.test(str);
	var t3 = new Date().getTime();
	return "Time of generation: "+(t2-t1)+" ms, time of checking: "+(t3-t2)+" ms, result: "+number+" is "+(result ? "not " : "")+"prime";
}
check1(9017); // "Time of generation: 2 ms, time of checking: 6 ms, result: 9017 is not prime"
check1(9029); // "Time of generation: 2 ms, time of checking: 64 ms, result: 9029 is prime"

64 ms for failing to validate 9029 as not prime is way too long, so let’s simply change “(11+?)” to “(1{2,x}?)” with x being the square root of the given number truncated to an integer:

function check2(number) {
	var t1 = new Date().getTime();
	var str = "";
	for (var i = 0; i<number; i++) str += "1";
	var sqrt = Math.floor(Math.sqrt(number));
	var re = new RegExp("^1?$|^(1{2,"+sqrt+"}?)\\1+$","");
	var t2 = new Date().getTime();
	var result = re.test(str);
	var t3 = new Date().getTime();
	return "Time of generation: "+(t2-t1)+" ms, time of checking: "+(t3-t2)+" ms, result: "+number+" is "+(result ? "not " : "")+"prime";
}
check2(9017); // "Time of generation: 2 ms, time of checking: 11 ms, result: 9017 is not prime"
check2(9029); // "Time of generation: 2 ms, time of checking: 12 ms, result: 9029 is prime"

This actually increased the time to check for non-primes (as “{a,b}?” is more expensive than simply “+?” as the recursion needs to keep track of the limits) but greatly reduced the time it took to check for primes, as it only checks up until 95 1′s (95 = floor(sqrt(9029))) and not all the way up to 9029 1′s.

But just for the fun of it, let’s compare with more common check’s – like Sieve of Eratosthenes:

function check3(number) {
	var t1 = new Date().getTime();
    var nonprimes = [];
	var sqrt = Math.floor(Math.sqrt(number));
	var pointer = 2;
	while (pointer <= sqrt && nonprimes[number] !== true) {
		for (var i = pointer; i <= number; i += pointer) nonprimes[i] = true;
		while (++pointer <= sqrt && nonprimes[pointer] === true);
	}
	var result = nonprimes[number] == true;
	var t2 = new Date().getTime();
	return "Time of checking: "+(t2-t1)+" ms, result: "+number+" is "+(result ? "not " : "")+"prime";
}
check3(9017); // "Time of checking: 1 ms, result: 9017 is not prime"
check3(9029); // "Time of checking: 1 ms, result: 9029 is prime"

It is pretty clear, that the regular expression does not in any way compare to an optimal algorithm – but the original regular expression referenced in the top is none the less a very intelligent hack on the regular expression engine mechanics.

No related posts.

The largest such (might even be larger than ShareThis) is AddThis. Their API is incredibly simple, as you can actually share anything by giving a simply link to their site with url and title of what to share.

The simplest way to share via AddThis is by opening a link like this:

http://www.addthis.com/bookmark.php?v=250&url=http%3A%2F%2Fwww.barklund.org%2Fblog%2F2009%2F06%2F08%2Fusing-addthis-with-flash%2F&title=Barklund.org%20-%20Using%20AddThis%20with%20Flash

Integrating this into an example like my previous for ShareThis is then of course very simple as well – encode URL and title, append to URL of AddThis bookmarking page and open this page in a popup of the proper size (found by experiment). See example here.

Related posts:

1. Announcing MXHR4AS3: Multipart/mixed-file download by Flash clients
2. Weird bitmap fill crash error in Flash CS4.
3. Flash development and the practice of Scripted Layout

However, who decides which libraries to include and how common should a library be, before Google will include it? Personally I believe they should add SWFAddress to the list of supported libraries as well.

You can however still load SWFObject from the Google JavaScript API and SWFAddress from a local file without any problems. It is quite straightforward:

<script type="text/javascript"
        src="http://ajax.googleapis.com/ajax/libs/swfobject/2.2/swfobject.js">
</script>
<script type="text/javascript" src="js/swfaddress.js"></script>
<script type="text/javascript">
	swfobject.embedSWF("file.swf", "target", "100%", "100%", "9.0.0");
</script>

Simply including the SWFAddress library after the Google JS API script works like expected.

But what is the potential consequences or drawbacks from doing this – depending on Google for serving site-breaking libraries? Some note, that this will increase load time, as the user’s browser now has to create a new connection to a new domain, do DNS lookup and the whole thing. I believe, that when enough sites use the libraries this way, every user will soon have the libraries cached, and when they visit your site for the first time, they will already have all the libraries needed and can thus use the page several seconds faster than if they had to download yet another copy of jQuery to their local cache.

And of course, I have to mention the possibility, that if Google goes out of business, your sites will break. But, it is way more likely that all your libraries will go defunct before Google kicks the bucket, so I believe that to be the least or your worries.

Please share your thoughts on whether it is at all meaningful to use Google JavaScript API and if so, how to determine or influence which libraries they should support.

Related posts:

1. Copenhagen on Google Earth
2. Google Docs Application – January 2010 Ideas
3. Vimeo highly vulnerable to CSRF attacks – now fixed

This feature does currently not work – see list of updates below

ShareThis is a great service for adding shareability to your website in a very simple way. It even includes the “tip a friend” option, so you don’t need to code that for your own site. I will describe how to embed it from flash.

Note 2009/05/19: Due to changes in the ShareThis API popup-functionality is broken currently (both in my example and in some of my live projects). I have filed a bug with ShareThis to fix this ASAP.

Note 2009/05/21: ShareThis have now fixed the above bug but there is still a minor JavaScript error thrown. The popup works now though as it should from both JS and Flash.

Note 2009/06/08: ShareThis now broke it again. And this time their support staff doesn’t answer. Please see an example implemented with AddThis instead.

Note 2009/06/19: ShareThis finally fixed it again. They wrote a mail on the 17th to me stating the bug was reintroduced when they implemented CDN, but would be fixed in the next release. Let’s hope it stays that way.

Note 2009/08/14: ShareThis has recently implemented a brand new version of their service – and surprise: it is not backwards compatible. Thus my popup example is broken again. I will investigate and fix soon.

Note 2009/08/17: ShareThis has promised to deliver a flash API within a few weeks. Let’s see what happens then…

You can do that in two ways, either by using a overlay div in HTML or creating a popup (that might get blocked). The prettiest and most user friendly is of course the overlay, but in order to have HTML overlays on top of Flash elements, you need to set the Flash wmode to transparent. This has a strange and unfortunate side-effect (which has been bug-reported to Adobe), that the keyboard defaults to standard US layout. For US websites, this is not a big problem, but for a Danish website it matters a lot. There are many differences between US and DK keyboard layout including Danish special characters and the location of the @-sign. Thus, wmode-transparent cannot be used for Flash-objects having input fields requiring users to enter text (which could contain special characters) or an email address (which contains the @-sign). Thus we need to use the popup-solution.

First, simply go to sharethis.com publisher section and customize your widget. Instead of placing the widget code snippet where you want the button, put it in the <head>-section of your website. The code snippet I got was:

<script type="text/javascript" src="http://w.sharethis.com/button/sharethis.js#publisher=636e055b-a4a2-4f9c-872c-b7aa9a701bb0&amp;type=website&amp;send_services=email&amp;post_services=facebook%2Clinkedin%2Cmyspace%2Cdigg%2Cdelicious%2Ctwitter%2Creddit%2Ctechnorati%2Cwordpress%2Cblogger%2Cgoogle_bmarks%2Cwindows_live"></script>

Then create a little javascript function like:

  function share(url, title) {
    var s = SHARETHIS.addEntry({
      url: url,
      title: title
    }, {button:false,popup:true});
    s.popup()
    return false;
  }

Finally, simple call this function from Flash using ExternalInterface:

var url:String = "http://www.barklund.org/blog/2009/05/06/using-sharethis-with-flash/";
var title:String = "Barklund.org - Using ShareThis with Flash";
import flash.external.ExternalInterface;
ExternalInterface.call("share", url, title);

See an example here – the javascript function is invoked both from a regular HTML link and from a simple Flash file using just the above ActionScript.

Related posts:

1. Using AddThis with Flash
2. Minor change in handling NaN positions in Flash Player 10,0,22
3. Announcing MXHR4AS3: Multipart/mixed-file download by Flash clients