The Eclipse project with the code for this post can be downloaded as tar.gz or zip. You can browse the code online here.

The idea

How exactly do you want to rearrange the letters in the words? How do you calculate whether a word has more changes compared to the original word than another one? Permutations, the Hamming and Levenshtein distances come to the rescue. I implemented the Steinhaus–Johnson–Trotter algorithm to calculate permutations and almost copied variants of the distance algorithms from somebody else.

When the software now reads a text it extracts the individual words, calculates all permutations of the letters and selects either a word with a small or large Levenshtein distance based on the user’s input. This way we can either generate a variant of the text that’s pretty easy or really hard to read. Since it might not be possible to calculate permutations for long words due to performance reasons the software may fall back to a Fisher–Yates shuffle.

Tests

Try running the software with a certain text yourself but from what I’ve seen so far it is really no problem to read a variant of a certain text if some letters are rearranged. If the Levenshtein distance is at its maximum or the letters are ordered by pure chance it may really get difficult though.

For example lets use the first sentence of the last section. Right now, the result looks like the following:

How eactlxy do you wnat to rearrgnae the ltteers in the wodrs?
How eltaxcy do you wnat to rgnaaerre the ltreets in the wrdos?

The first one uses a small, the second a larger Levenshtein distance. A future version of the software could produce words where the position of a character isn’t moved further away than one or two characters compared to its original position; this would make the words even easier to read.

Conclusion

It is really interesting to experiment with words and the results are stunning. In the end it is nice to see that we are able to adapt to rearranged letters in words, still being able to comprehend the text, reading it without much problems. Finally, we should wonder what our brain is capable of and try writing proper words without typos in the first place.

How to

We’ll change your email signature in a way that tells people the message was sent using an iPhone. It doesn’t matter which email client you’re using: while Apple Mail is great, using Outlook will be okay as well.

Open your email client’s configuration menu, find the part that lets you change your signature and enter the following text into the input field:

Sent from my iPhone

Click on save and make sure that the signature will be used when writing new emails or replying to the ones from your friends.

Although you don’t really have an iPhone everybody will be impressed that you sent him/her a message with your cool gadget.

Conclusion

Sure, if the one you’re sending an email is a geek I bet he’ll find out that you didn’t really send the message with an iPhone in no time. Nevertheless, most people won’t be able to notice this but just think that you’re the proud owner of an iPhone.

Next up:

• How to pretend having an iPad.
• How to avoid meeting people in real life so they don’t notice that you haven’t really got Apple’s latest hardware.
• How to write silly posts on a 27″ iMac.

The HTML markup consists of a simple HTML select element that triggers a certain JavaScript function via the onChange hook. The JavaScript function in turn just sets the window.location to the given file and so the browser starts downloading.

<script type="text/javascript">
function download(d) {
        if (d == 'Select document') return;
        window.location = 'http://example.com' + d;
}
</script>
 
<select name="download" onChange="download(this.value)">
<option>Select document</option>
<option value="a_file.pdf">A PDF document</option>
<option value="another_file.pdf">Another PDF document</option>
</select>

This technique can be used to jump to any page you want, e.g. you may use a select box instead of a large menu on your page. It helps you to include information – e.g. a long list – in a page with the compact select dropdown box that can be placed almost everywhere without consuming much space.

Just recently I tried rewriting OpenGL’s routines that handle matrix calculations as part of a lecture at the university. Pretty soon I came to the conclusion, that I had to optimize my code if I wanted to compete with the implementation provided by OpenGL.

This post presents at quick look at CPU Sampler which helped me making well-founded decisions resulting in a faster implementation.

Howto

Once you’ve developed your software with Xcode and want to profile it using CPU Sampler, all you have to do is to click on Run – Run with Performance Tool – CPU Sampler. This will start the tool and run your application; you can start and stop the recording as you see fit.

As soon as you end your application you can have a look at the samples collected during the last run. This is the interesting part because you can review how long a certain function was running and the percentage tells you how long this took compared to the overall run.

Try playing around with the various options. In most situations you can stick with the defaults but there’re more interesting things to look at if you want to. For example try changing the Active thread from All threads to something else and the view will show the corresponding samples only.

Example

As I said, I tried rewriting OpenGL’s routines that handle matrix calculations. This was meant as an exercise to understand the operations needed that changed the matrices. Of course, the implementation was way slower than OpenGL and I should try speeding it up.

Using CPU Sampler I immediately identified a bottleneck and a major difference between my implementation and the one that comes with OpenGL. The slow part of my code could be found in repeated calls to cos and sin. Since OpenGL seems to work with the libraries of my graphics card directly I guess it tries to do certain computations there.

What I now did was substituting the calls to cos and sin with code that used a lookup table to retrieve precalculated values. This resulted in a major performance boost – still, OpenGL’s code is twice as fast as my one.

Have a look at the following screenshots. They show a run using OpenGL’s implementation of matrix manipulations, my own and an optimized version of my own implementation. Comparing the naive and optimized version of my code clearly shows that the optimized variant doesn’t spent much time calculating cos and sin.

Conclusion

I wanted to show that using a profiling tool like CPU Sampler that comes with Apple’s Xcode may make your life much easier if you’re trying to optimize your application. This helps you to make wise decisions when it comes to optimizing code so you don’t have to obfuscate your software with hard to read code blocks that have a very little effect regarding performance.

It’s nice to see that Apple ships tools like this with its IDE. Have a look at the other performance tools and you’ll be amazed how many cools things Xcode is capable of – things you wouldn’t even dream about in other IDE’s.

Although you can find this information in the Codex too, I would like to show you how easy it is to add a sidebar somewhere into your theme. You’ll see that it’s just about adding some function calls here and there – that’s it and you’ve got a new sidebar that can hold arbitrary widgets.

Three simple steps

Having a list of steps you can work through seems to be the best approach for this howto. Just follow these three steps and you’ll have a new sidebar in your theme.

1. Register the sidebar

First, you’ll have to register the new sidebar using register_sidebar. Open the file functions.php of your current theme – if there’s no such file just create it – and search for calls to register_sidebar. If you can’t find any that’s fine and you can go on inserting the function call where ever you like but if your theme already got a sidebar you should find at least one occurrence of the aforementioned function.

In case there’s already a call to register_sidebar insert the new calls to this function after the existing one. This way you’ll make sure that the widgets placed in another sidebar don’t suddenly appear in your new sidebar while the other one seems to be empty; has to do with the internal ordering of the sidebars.

The code is as easy as the following: just insert the function call and adjust the name as you see fit; please choose a unique name.

<?php
# maybe other calls to register_sidebar here...
# ...
register_sidebar(array('name' => 'My new sidebar'));
# ...
?>

Want to fine tune the appearance of your sidebar? Have a look at other parameters here.

2. Inserting the sidebar into the theme

Once you’ve registered the sidebar you’ll have to tell WordPress where the widgets associated with the newly created sidebar should appear. This, of course, depends on your specific theme and other considerations as well.

For now, lets assume we wanted a new sidebar below the title of a post. We would open the file single.php – or index.php if single.php doesn’t exist – of our theme and insert the following code:

...
<h1><?php the_title(); ?></h1>
<?php if ( !function_exists('dynamic_sidebar') ||
           !dynamic_sidebar('My new sidebar') ) : ?>
  <!-- This will be displayed if the sidebar is empty -->
<?php endif; ?>
...

See that we provide the name of the sidebar registered above in the function call to dynamic_sidebar. If you want to show some default content in case no widgets are assigned to the sidebar you can do so by changing the HTML comment to something else; this may be particularly interesting if you’re developing a theme and the user hasn’t customized the sidebar yet.

If you want to read more about dynamic_sidebar check out the Codex here.

3. Adding widgets

Now that you’ve added a new sidebar to your theme you should start adding widgets. Your new sidebar should appear under Appearance – Widgets and is ready to use. If you’re not satisfied with the appearance of the sidebar or the widgets try tweaking the parameters of register_sidebar or adjust your CSS.

Conclusion

It’s pretty easy adding multiple sidebars to your theme. This post presented the basics which are sufficient most of the time. If you want to learn more about sidebars and widgets a good starting point is the Widgets API page in the Codex; extra parameters can be found there.

The more sidebars a theme has the more flexible it is. From a user’s perspective it’s just nice to display widgets just where one wants to. Since it isn’t that hard to add another sidebar users can do this on their own or hire somebody to do this for them at low costs.

In this post I’d like to present some Java code using the latest and greatest version of HttpClient that allows you to crawl any site, have a look at the HTTP header fields, the site’s content and measure how long it took to download the site. It’s almost the same what Google’s feature does.

The Eclipse project with the code for this post can be downloaded as tar.gz or zip. You can browse the code online here.

Implementation

The team building HttpClient does a great job improving and perfecting the software. I really like using this fully featured client implementation when it comes to retrieving data via HTTP. It’s easy to set up and configuring as you see fit is a snap.

I’ve used it for this little project too because I only needed four lines of code to get it running. In my opinion the HttpClient API can’t get any better than this. Check out the following code:

HttpClient httpclient = new DefaultHttpClient();
HttpGet httpget = new HttpGet(url);
HttpResponse response = this.httpclient.execute(httpget);
HttpEntity entity = response.getEntity();

Once you’ve done that you can use the HttpResponse and HttpEntity objects to retrieve the HTTP header fields and the downloaded content; the EntityUtils come in handy here.

If you run my implementation it prints the following information: HTTP return code, HTTP header fields, the downloaded content and the time it took to execute the request. This is similar to the information offered by Google’s Fetch as Googlebot feature. As you can see, it’s pretty easy implementing it on your own if you haven’t got special requirements.

Conclusion

Nevertheless, Google’s Fetch as Googlebot feature is a really nice thing and I think they’ll expand its features as a greater part of the Webmaster Tools. In this post I wanted to show you that it’s pretty easy building a similar tool on your own. By the way, using e.g. the Web developer plugin for Firefox might be good alternative too.

Note, that Google probably invested a lot more work to get this feature rolling and it’s very likely that it wasn’t that easy for them to make it part of the Webmaster Tools. In this regard this post might make you think that this feature was an easy one – you guessed it, that’s probably not the case.

I’ve packaged the functionality inside a WordPress plugin called is_child that you can download here. Unzip it, upload it to wp-content/plugins and activate the plugin.

Coding is_child

Doing a quick web search brings up tons of sites providing some sort of is_child or is_tree function. Most of the time it’s something like the following:

function is_child($parent) {
  global $post;
  return $post->post_parent == $parent;
}

This is great and a pretty nice solution. I’ve taken this approach and extended it with the following functionality:

• by default we’ll retrieve all parent pages up to the root node and test whether the current page is part of this tree. This behavior can be disabled though.
• you can supply the name (slug) of a post/page instead of the ID and the function will look it up for you.

All this combined with some error checking makes a great idea even better. Just have a look at the code if you would like to know more about the exact implementation.

Conclusion

We’ve seen that it’s very easy to test whether the current page is a child of another page or part of a certain tree in your page hierarchy. Packaging this into a plugin or placing the necessary code into your theme’s functions.php allows you to display certain content on particular pages only. In case you’re using the Widget logic plugin you now can display widgets on pages belonging to a particular subtree of your pages only, which is great.

Although these ideas may apply to a lot of different programming languages I chose to give examples written in Java, PHP or Python. There should be no problem to translate this into other, similar languages.

Indentation hell

A lot of years ago I read a text file describing the preferred coding style for the Linux kernel: it said that you’re screwed anyway if you need more than three levels of indentation. This stems from hackers using a screen resolution that allows a certain number of characters only. Writing code that uses a lot of nested statements causes the problem that you can’t read everything on a 80×25 terminal; wrapping lines may make things worse.

Back then the solution was to either increase the screen’s resolution or write clean code. Even today the latter is a good idea not only when writing code but maybe configuration files in general. Imagine a sysadmin in the server room with an old monitor only – he’ll thank you that you formatted the comments with a text width of 80 characters or less.

Let’s have a look at an example like the following. You’ll notice that I’ve used four levels of indentation: a for loop, an if statement, another for loop and another if statement.

for (int i = 0; i < x; i++) {
  if (i == y) {
    for (int j = 0; j < z; j++) {
      if (j == a) {
        // do something special
        // ...
      }
    }
  }
}

We can spot this pattern by looking at it’s tail: a lot of closing curly brackets. Refactoring this snippet consists of splitting the code into various functions and calling them at the right time. One solution might look like so:

public void a(final int x, final int z) {
  for (int i = 0; i < x; i++) {
    if (i == y) b(z);
  }
}
 
public void b(final int z) {
  for (int j = 0; j < z; j++) {
    if (j == a) do_something_special();
  }
}
 
public void do_something_special() {
  // do something special
  // ...
}

Now, the code is much easier to read and unit testing it will be more fun too. Don’t be afraid of adding extra functions into your program when you could write it all into one method/function. The latter is harder to maintain and rest assured that more method/function calls won’t add a serious performance penalty to your application in any way.

Inverting

It’s likely that you’ve seen a method that starts with an if statement, almost all the method’s code is inside that statement and at the end of the method you find the else block with only one statement in it, maybe some error handling code.

Instead of writing if statements that span multiple pages and contain lots and lots of code the following technique allows you to have the if statement on one line. As discussed above this avoids an unnecessary level of indentation as well.

Let’s have a look at an example: a simple method containing an if statement with another if statement which holds the real code of the method.

function doIt() {
  if (something == true) {
    if (something_else == true) {
      # do something...
      # ...
    }
  } else {
    throw new Exception();
  }
}

Simply by inverting the if statements we can write them on one line, producing the following, much cleaner code:

function doIt() {
  if (something == false) throw new Exception();
  if (something_else == false) return;
  # do something...
  # ...
}

Again, not just the statement but the whole method is easier to read. If you’re checking preconditions, this is the way to go. This also prevents the indentation hell mentioned above.

Splitting

Speaking of checks for the preconditions of certain methods, one might tend to put all checks into one single if statement. This may save you from e.g. writing code to throw an exception more than once but may result in a hard to understand if statement.

I recommend writing if statements that test only one or two conditions. Have a look at the following code which contains a giant if statement.

def method(a, b, c):
  if a <= 10 or a >= 20 or \
     b == False or \
     c == 'unknown':
    raise SomeException('Invalid arguments')
  # do something...
  # ...

We could argue that the code is pretty clean and easy to understand. True in this case, but the semantics aren’t obvious. What about introducing two more methods and raising more specific exceptions? Would result in this:

def method(a, b, c):
  if not inRange(a, 10, 20):
    raise SomeException('Argument a is out of bounds')
  if not isValid(b) or not isValid(c):
    raise SomeException('Argument b or c are invalid')
  # do something...
  # ...
 
def inRange(a, start, end):
  return a >= start and a <= end
 
def isValid(a):
  return not ( a == False or a == 'unknown' )

This may bloat your code a little bit but helps you reading the code almost like a sentence. Splitting one large if statement into smaller ones may result in sensible error messages too. And the introduction of small helper methods makes unit testing fun again.

Sorting

If you’re using the previous technique – splitting a single if statement into smaller, more concise portions – you should consider the order of the if statements. Let’s think about a simple example: in a recent post I tried finding occurrences of Friday the 13th dates by iterating over a given time span. The method looked like so:

while (/* ... */) {
    date = date.plusDays(1);
 
    if (date.getDayOfMonth() != 13) continue;
    if (date.getDayOfWeek() != DateTimeConstants.FRIDAY) continue;
 
    // ...
}

The two if statements test whether the current day is a Friday the 13th date. First checking whether the current day is the 13th day of a month speeds things up a little bit because we’ll only check whether this day happens to be a friday – the other way around would be more expensive in terms of performance.

This technique also applies when your if statements call expensive methods to test a certain condition. You may want to call the ones with the least overhead first thus reducing the time spent in your if statements.

Conclusion

In this post I presented some simple solutions that should help you writing cleaner, better code regarding if statements. Following these rules will make your code much easier to read and to maintain. Just give it a try and you’ll definitely notice the positive difference.

Sure, I haven’t given any references to real projects helping you to verify that the examples given in this post exist in real projects. I think searching in real projects for code like the above shouldn’t be much of a problem. And I’m pretty sure you’ll agree on this.

You can download the plugin here, unzip it, upload it to your wp-content/plugins directory and activate it.

How to

Using this plugin is super simple: just add a custom field named cnote to a post/page and enter the content that should appear next to the comment form into its value field.

Here’s an example:

When WordPress renders the page, the plugin will pick up the content of your custom field and display its content next to your comment form. It may look like so:

The plugin expects that you enter some text, so it inserts your content into a p element. This element has got a class cnote helping you to style the notes with CSS.

The code

In case you’re developer and want to know more about the code just have a look at the plugin, it’s really straight forward. What it does is this: look out for a custom field named cnote, if it’s present we’ll output it’s contents otherwise nothing happens.

$note = get_post_meta($post_id, 'cnote', true);
if (empty($note)) return;
echo '<p>', $note, '</p>';

This gets registered with the comment_form action and will be executed once the theme calls this action.

Conclusion

Using custom fields we can add hints to comment forms on a post/page basis. This technique may be really helpful in case you would like to tell the user something special just before he fills out the comment form.

The Eclipse project with the code for this post can be downloaded as tar.gz or zip. You can browse the code online here.

Preliminary

It’s likely that you already know how to calculate prime numbers but I’d like to show you a feasible approach anyway. The idea is based on the sieve of Eratosthenes: starting with the number 2, use it as a prime number if it isn’t divisible by any other prime number otherwise discard it. The advantage: easy to implement, the disadvantage: not that fast.

If we’d like to calculate the prime numbers starting with 2, up to 500 we could write the following code snippet:

for (int i = 2; i < 500; i++) {
  if (isDivisibleByPrime(i)) continue;
  primes.add(i);
}

This implementation is simple yet fast enough for my purposes. Note that using Java’s primitive types it’s not possible to find prime numbers of arbitrary length; more work is required here if you want to do that.

Arbitrary groups of primes

What I call a group here is a set of prime numbers differing by a particular number. One example would be triplets of prime number that differ by six, called the sexy prime triplets. You could think of many combinations, i.e. twins, triplets or quadruplets where the numbers differ by e.g. 2, 3 or 6.

The code that finds these sets of prime numbers is straight forward. It generates a list with prime numbers, searches for a given pattern – e.g. sexy prime triplets – and prints the results. By changing the parameters you can make up any combination you like but keep in mind that some will return an empty result.

Check out the file PrimeGroups, specifically the top of the main method. Try chaning the paramters start, end, amount and distance. Did you expect to get that many results for a certain pattern? It can be quite entertaining changing amount and distance, don’t you think?

Conclusion

It’s easy and interesting to search prime numbers that match certain criteria. Have a look at the code and you’ll see that the implementation is pretty easy and doesn’t require extra coding skills if you don’t want to search for particularly large primes. Finally, it’s a nice exercise – even as a math novice – thinking about numbers and prime numbers in particular.