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.

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 use 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() {
  for (int i = 0; i < x; i++) {
    if (i == y) b();
  }
}
 
public void b() {
  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.

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.

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 code

Using Joda Time it’s super easy to iterate over the next days using the plusDays method of DateTime. Finding Friday the 13th dates is straight forward this way. Sure, we could optimize it but Joda Time seems to be really fast so there’s no need to do this.

public static List<DateTime> getNextNthFriday13th(final int n) {
  final List<DateTime> fridays = new ArrayList<DateTime>();
 
  DateTime dt = new DateTime();
  int curN = 0;
  while (curN < n) {
    dt = dt.plusDays(1);
 
    if (dt.getDayOfMonth() != 13) continue;
    if (dt.getDayOfWeek() != DateTimeConstants.FRIDAY) continue;
 
    fridays.add(new DateTime(dt.toInstant()));
    curN++;
  }
 
  return fridays;
}

Finding the next year with the most Friday the 13th dates is simple too. Just get the next n occurrences of Friday the 13th and sort them by year to find the one with the highest amount. Another way to solve this is this: just search the next year that has got three Friday the 13th dates and you’re done. Have a look at the code of this method to see my quick solution.

Conclusion

It’s a real joy to use Joda Time because its API has got methods for a lot of use cases. Although I haven’t done any performance tests yet it seems to be lightning fast. I recommend that you should definitely have a look at it.