I had never heard of it before. So, in preparation for my next job interview, I thought I take a look at it.

While trying to figure it out, I stumbled over this quote:

The Visitor pattern is possibly the most complicated design pattern you will face. (Source)

I totally agree. (And this is probably why I’ve never heard or used it before.)

But since I’m not a quitter I went on and tamed it. So, in this article I’m going to shed some light on this mysterious design pattern.

Definition

The main problem (in my opinion) with the visitor pattern is that it’s often not really clear what it does. So, let’s start with the following definition (based on Wikipedia):

The visitor design pattern is a way of separating an operation from an object structure on which it operates. [...] In essence, this pattern allows one to add new virtual functions to a family of classes without modifying the classes themselves;

Motivation

Let’s explore what this means. I’ll provide some basic examples with increasing complexity to illustrate the motivation behind the visitor pattern.

Note: All examples are in C#.

The Object Structure

The definition above states that the visitor pattern separates “an operation from an object structure“. So, let’s define this object structure.

Assume we have some kind of wikicode parser. The wikicode allows us to write documents in plain text but enrich them with some formatting (bold text) and hyperlinks.

So, we have classes for plain text, bold text, and hyperlinks:

public abstract class DocumentPart {
  public string Text { get; private set; }
}

public class PlainText : DocumentPart { }

public class BoldText : DocumentPart { }

public class Hyperlink : DocumentPart {
  public string Url { get; private set; }
}

And we have a document class:

public class Document {
  private List<DocumentPart> m_parts;
}

Scenario 1: Converting Into HTML

Now let’s assume we want to convert this document into HTML.

The most straightforward way would be to add a virtual method called ToHTML() to DocumentPart, like this:

public abstract class DocumentPart {
  public string Text { get; private set; }
  public abstract string ToHTML();
}

public class PlainText : DocumentPart { 
  public override string ToHTML() {
    return this.Text;
  }
}

public class BoldText : DocumentPart { 
  public override string ToHTML() {
    return "<b>" + this.Text + "</b>";
  }
}

public class Hyperlink : DocumentPart {
  public string Url { get; private set; }

  public override string ToHTML() {
    return "<a href=\"" + this.Url + "\">" + this.Text + "</a>";
  }
}

And the Document class would also get a ToHTML() method:

public class Document {
  private List<DocumentPart> m_parts;

  public string ToHTML() {
    string output = "";
    foreach (DocumentPart part in this.m_parts) {
      output += part.ToHTML();
    }
    return output;
  }
}

Then, by calling Document.ToHTML() one could convert the whole document into HTML.

Scenario 2: Different Output Formats

Let’s add some complexity. Additionally to the previous scenario, we now also want to allow the conversion into plain text and LaTeX.

A naive way would be to provide implementations for each output format:

public abstract class DocumentPart {
  public string Text { get; private set; }
  public abstract string ToHTML();
  public abstract string ToPlainText();
  public abstract string ToLatex();
}

public class PlainText : DocumentPart { 
  public override string ToHTML() {
    return this.Text;
  }
  public override string ToPlainText() {
    return this.Text;
  }
  public override string ToLatex() {
    return this.Text;
  }
}

public class BoldText : DocumentPart { 
  public override string ToHTML() {
    return "<b>" + this.Text + "</b>";
  }
  public override string ToPlainText() {
    return "**" + this.Text + "**";
  }
  public override string ToLatex() {
    return "\\textbf{" + this.Text + "}";
  }
}

public class Hyperlink : DocumentPart {
  public string Url { get; private set; }

  public override string ToHTML() {
    return "<a href=\"" + this.Url + "\">" + this.Text + "</a>";
  }
  public override string ToPlainText() {
    return this.Text + " [" + this.Url + "]";
  }
  public override string ToLatex() {
    return "\\href{" + this.Url + "}{" + this.Text + "}";
  }
}

public class Document {
  private List<DocumentPart> m_parts;

  public string ToHTML() {
    string output = "";
    foreach (DocumentPart part in this.m_parts) {
      output += part.ToHTML();
    }
    return output;
  }

  public string ToPlainText() {
    string output = "";
    foreach (DocumentPart part in this.m_parts) {
      output += part.ToPlainText();
    }
    return output;
  }

  public string ToLatex() {
    string output = "";
    foreach (DocumentPart part in this.m_parts) {
      output += part.ToLatex();
    }
    return output;
  }
}

This implementation suffers two major problems:

• The code for the Document.To...() methods is almost identical. This may lead to errors when changing one of the methods but forgetting to update the others.

• Each document part needs to know every possible output format.

These problems can be solved with the visitor pattern.

The Visitor Pattern

The visitor pattern consists of two parts:

• a method called Visit() which is implemented by the visitor and is called for every element in the data structure

• visitable classes providing Accept() methods that accept a visitor

Visitor: Convert To HTML

Let’s start with the visitor. As example, we’re going to implement the “convert to html” operation.

For this, we need to define an interface called IVisitor:

public interface IVisitor {
  void Visit(PlainText docPart);
  void Visit(BoldText docPart);
  void Visit(Hyperlink docPart);
}

Then we implement to HTML conversion:

public class HtmlVisitor : IVisitor {
  public string Output { 
    get { return this.m_output; }
  }
  private string m_output = "";

  public void Visit(PlainText docPart) {
    this.Output += docPart.Text;
  }

  public void Visit(BoldText docPart) {
    this.m_output += "<b>" + docPart.Text + "</b>";
  }

  public void Visit(Hyperlink docPart) {
    this.m_output += "<a href=\"" + docPart.Url + "\">" + docPart.Text + "</a>";
  }
}

Visitable: The Document Structure

By applying the visitor pattern to our document classes, they change to this:

public abstract class DocumentPart {
  public string Text { get; private set; }
  public abstract void Accept(IVisitor visitor);
}

public class PlainText : DocumentPart { 
  public override void Accept(IVisitor visitor) {
    visitor.Visit(this);
  }
}

public class BoldText : DocumentPart { 
  public override void Accept(IVisitor visitor) {
    visitor.Visit(this);
  }
}

public class Hyperlink : DocumentPart {
  public string Url { get; private set; }

  public override void Accept(IVisitor visitor) {
    visitor.Visit(this);
  }
}

public class Document {
  private List<DocumentPart> m_parts;

  public void Accept(IVisitor visitor) {
    foreach (DocumentPart part in this.m_parts) {
      part.Accept(visitor);
    }
  }
}

Note: The implementations of Accept() seem to be identical for all child classes of DocumentPart. However, we can’t move the code into the base class because IVisitor doesn’t have an method Visit(DocumentPart) but only for the concrete implementations. (We could solve this through reflection, though, but would lose compile-time checking.)

Putting It All Together

Now, to convert a document to HTML we can use this code:

Document doc = ...;
HtmlVisitor visitor = new HtmlVisitor();
doc.Accept(visitor);
Console.WriteLine("Html:\n" + visitor.Output);

To convert the document into LaTeX, we’d need to implement a LatexVisitor:

public class LatexVisitor : IVisitor {
  public string Output { 
    get { return this.m_output; }
  }
  private string m_output = "";

  public void Visit(PlainText docPart) {
    this.Output += docPart.Text;
  }

  public void Visit(BoldText docPart) {
    this.m_output += "\\textbf{" + docPart.Text + "}";
  }

  public void Visit(Hyperlink docPart) {
    this.m_output += "\\href{" + docPart.Url + "}{" + docPart.Text + "}";
  }
}

The implementation of the actual document classes remain unchanged.

Side note: If you’re wondering whether Accept is a good name or whether the method should be renamed (e.g. to Convert): Check whether operations other than conversions are possible. For example, one could implement a BoldTextCountVisitor or a UrlExtractorVisitor. If such operations are possible, you should stick with the name Accept – as this communicates that the visitor pattern is being used here.

The Actual Problem Being Solved

If you’re not into theory, you can skip this part. It explains the formal problem the visitor pattern solves: something called double dispatch.

Now, what’s that?

Single Dispatch

Most (all?) OOP programming languages support single dispatch, more commonly known as virtual methods. For example, consider the following code:

public class SpaceShip { 
  public virtual string GetShipType() {
    return "SpaceShip";
  }
}

public class ApolloSpacecraft : SpaceShip { 
  public virtual string GetShipType() {
    return "ApolloSpacecraft";
  }
}

Now, execute this code:

SpaceShip ship = new ApolloSpacecraft();
Console.WriteLine(ship.GetShipType());

This will print “ApolloSpacecraft”. The actual method implementation to be called is chosen at runtime based solely on the actual type of ship. So, only the type of a single object is used to select the method, hence the name single dispatch.

Note: “Single dispatch” is one form of “dynamic dispatch”, i.e. the method is chosen at runtime. If the method is chosen at compile time (true for all non-virtual methods), it’s called “static dispatch”.

Double Dispatch

Let’s add some asteroids:

public class Asteroid {
  public virtual void CollideWith(SpaceShip ship) {
    Console.WriteLine("Asteroid hit a SpaceShip");
  }
  public virtual void CollideWith(ApolloSpacecraft ship) {
    Console.WriteLine("Asteroid hit an ApolloSpacecraft");
  }
};
 
public class ExplodingAsteroid : Asteroid {
  public override void CollideWith(SpaceShip ship) {
    Console.WriteLine("ExplodingAsteroid hit a SpaceShip");
  }
  public override void CollideWith(ApolloSpacecraft ship) {
    Console.WriteLine("ExplodingAsteroid hit an ApolloSpacecraft");
  }
};

With this, let’s execute some more code. With:

Asteroid theAsteroid = new Asteroid();
ExplodingAsteroid theExplodingAsteroid = new ExplodingAsteroid();
SpaceShip theSpaceShip = new SpaceShip();
ApolloSpacecraft theApolloSpacecraft = new ApolloSpacecraft();

this code:

theAsteroid.CollideWith(theSpaceShip); 
theAsteroid.CollideWith(theApolloSpacecraft);
theExplodingAsteroid.CollideWith(theSpaceShip); 
theExplodingAsteroid.CollideWith(theApolloSpacecraft);

will print:

Asteroid hit a SpaceShip
Asteroid hit an ApolloSpacecraft
ExplodingAsteroid hit a SpaceShip
ExplodingAsteroid hit an ApolloSpacecraft

Everything is as expected. Now, consider this code:

// Note the different data types!
Asteroid theExplodingAsteroidRef = new ExplodingAsteroid();
SpaceShip theApolloSpacecraftRef = new ApolloSpacecraft();
theExplodingAsteroidRef.CollideWith(theApolloSpacecraftRef);

The desired result here would be “ExplodingAsteroid hit an ApolloSpacecraft” but instead we get “ExplodingAsteroid hit a SpaceShip“.

The problem is that C# (and Java, C++, …) only supports single dispatch, but not double dispatch. The method chosen is only based on theExplodingAsteroidRef, but not on theExplodingAsteroidRef and theApolloSpacecraftRef (which would be double dispatch).

Not Actually Solved Problem: Iterators

Many pages on the internet associate the visitor pattern with traversing some data structure, usually a tree or hierarchy.

This got me totally confused because at first I couldn’t figure out what’s the difference between the visitor pattern and the iterator pattern.

The point here is: The main goal of the visitor pattern is to solve the double dispatch problem. Solving the iterator pattern is only a byproduct. If you’re just look for a way to iterate a data structure, the iterator pattern may be a better alternative instead.

Suppose you have this class:

// List of ints
public class MyList : IVisitable, IEnumerable {
  private List<int> m_list;
  public Enumerator GetEnumerator() { ... } // iterator pattern
  public void Accept(IVisitor visitor) { ... } // visitor pattern
}

Now, you want to calculate the sum of all integers in the list.

You can do this either by using the iterator pattern:

IEnumerable myList = new MyList(...);

int sum = 0;
foreach (int value in myList) {
  sum += value;
}

Console.WriteLine("Sum: " + sum);

Or you can do this by using the visitor pattern:

IVisitable myList = new MyList(...);

IVisitor visitor = new SumVisitor();
myList.Accept(visitor);

Console.WriteLine("Sum: " + visitor.Sum);

Issues

There are some issues (or problems) with the visitor pattern.

Iteration Order

One problem is the iteration order.

For example, if you define a visitor pattern on a tree, the iteration may be depth-first or breadth-first.

So, if you have some operation (visitor) that requires a certain iteration order, you may have a problem.

For example, you could implement the visitor pattern for saving a data structure to disk where each visitor represents a different file format. This would allow you to easily add new file formats later. However, this only works as long as all file formats store the data in the same order. If two formats require different orders, this pattern doesn’t work anymore.

New Visitables

If you add new visitable, you need to update every visitor that’s already implemented.

Let’s take our document classes from above. We had the classes PlainText, BoldText, and Hyperlink.

Now, let’s say we want to add a class for underlined text. The interface IVisitor would thus change to:

public interface IVisitor {
  void Visit(PlainText docPart);
  void Visit(BoldText docPart);
  void Visit(Hyperlink docPart);
  void Visit(UnderlinedText docPart); // added
}

Due to this change we would also need to update all visitors we’ve already implemented. We could use reflection to solve (or just hide) the problem but in the end the visitor pattern works best on data structures that don’t change.

Access to Private Members

There’s another issue when the visitors need access to private data of the visitables.

To stick with the visitor pattern, you may be force to make this data public, even though it’s not supposed to be public, thereby breaking the principle of information hiding.

Summary

The visitor pattern is a relatively complicated pattern.

Design goal: Separate operations from the data structures they work on. As a nice side effect, this allows you to add operations to data structures that you can’t change (maybe because you lost the source code for them).

You need:

• IVisitor (the operation) providing a Visit() method for each visitable class; needs to be implemented by every visitor.

• IVisitable providing an Accept(Visitor) method; needs to be implemented by every visitable class.

Issues:

• Difference to iterator pattern sometimes a little fuzzy.
• Iteration order can’t be controlled.
• Adding or removing visitables requires you to update all visitors.

• Visitor implementations may be in conflict with the principle of information hiding.

Real world examples:

• Converting a data structure into different output formats. Compilers are a good example for this.

• Implementing drawing code for some scene graph/map structure on different platforms (e.g. OpenGL vs. DirectX).

CodeProject

Today, I spent the whole morning figuring out why Windows Setup always placed the Windows boot manager on a separate drive – and not on the drive I was installing Windows onto.

The “easiest” solution would be to unplug all other drives, install Windows, and then replug all drives. But since I’m a engineer I wanted to find out the real cause of the problem.

Turns out, the root problem is the BIOS’ boot order (a.k.a. boot sequence). A computer’s BIOS has a boot order list which basically defines from which device (hard disk, CD drive) to boot. If the BIOS can’t boot from the first device, it tries the second one, and so on.

The BIOS usually lets you define this order. Either all devices are in one big list, or each device type (CD drives, hard disks) has its own list.

Now, when you install Windows, the setup asks the BIOS for this list. And no matter what you do, Windows Setup will always install the boot manager on the first hard disk in this boot order list.

In particular, the disk on which you want to install Windows has no influence on where the boot manager is being installed.

So, the only way to influence the location of the boot manager is to change to boot order in the BIOS.

Side note: New devices are usually added to the end of the boot order list. So if you have multiple hard drives and replace one (e.g. because the old one was broken or too small), the new drive may end up at the end of the list – and not at the position where the replaced drive was before; thus messing up the boot order.

Determining the Boot Manager Partition

So, how can one determine the location of where boot manager is installed?

From Windows Setup

Determining on which drive Windows Setup will install the boot manager onto is almost impossible from Windows Setup itself.

The only hint you get, is if:

• your installation disk has no partitions (i.e. is empty) …

• .. and then you can create a partition on this disk.

In this case Windows Setup will show you a dialog reading:

To ensure that all Windows features work correctly, Windows might create additional partitions for system files.

If this happens and you click on “OK”, Windows Setup will automatically create a partition called “System Reserved” where it’ll install the boot manager.

If this doesn’t happen the boot manager may or may not be installed in the correct location. If this is the case, you can only check the location after Windows has been installed.

From Windows

To determine the partition where the boot manager is installed, go to:

Control Panel > Administrative Tools > Computer Management > Disk Management

The partition where the boot manager is installed has the word System in its status.

So, if you copy some files and have already copied about 60%, you may see something like this:

Knowing this, what’s wrong with this image?

Why the heck do I get an indeterminate progress bar for a download progress. Hell, there’s even a percentage displayed for the download.

With Apple’s AirPort Utility, configuring an AirPort Express Base Station is quite easy. There are, however, some pitfalls when trying to extend an existing Wi-Fi network. So I’m going to shed some light on this topic in this blog post. I’ll be using my AirPort Express Base Station to illustrate these pitfalls but the information should apply to any other Wi-Fi access point as well.

Extending Wi-Fi networks over Wi-Fi (repeater)

In the “Wireless” section, the AirPort Utility gives you an option called “Extend a wireless network”. This option allows you to extend an existing Wi-Fi network. (Who would have guessed?)

The catch here is, though, that this will extend your Wi-Fi network over Wi-Fi. So, the AirPort Express Base Station will communicate with your other access point(s) over Wi-Fi. It’ll become a repeater.

The advantage is that you don’t need any cables to extend the range of your network. The disadvantage is that this will reduce your wireless bandwidth (by 50% in the worst case). While this will probably have no real effect on your surfing speed, the speed of copying files from one computer to another will be drastically reduced.

Extending Wi-Fi networks over Ethernet (roaming)

Fortunately, there is an alternative: extending Wi-Fi networks over Ethernet (cables). This is called roaming and has existed since the earliest days of Wi-Fi.

For the AirPort Express Base Station (and maybe other Wi-Fi access points as well) there are three things you need to know:

1. In “Wireless” section, don’t use “Extend a wireless network”! Instead, use “Create a wireless network” and enter the same SSID and Wi-Fi encryption as the network you’re extending.
   Background info: If a computer finds multiple Wi-Fi networks with the same SSID, it’ll assume they represent the same network. It’ll then pick the one that’s best suited (usually the one with the best signal strength).
2. 

   In the “Network” section, you need to set “Router Mode” to “Off (Bridge Mode)”.

3. 

   You need to plug your Ethernet cable into the WAN port – not the Ethernet port.
   Note: I’ve only tested this with an AirPort Express Base Station of the second generation. As far as I understand it, on the first generation you need to plug your Ethernet cable into the (only-existing) Ethernet port instead.

Wi-Fi channels

Most modern Wi-Fi access points can choose their Wi-Fi channels automatically and you should usually let them do this.

However, if you really want to manually select the Wi-Fi channels, use different channels for each access point (if possible). Computers recognize Wi-Fi networks by their SSIDs, not by the channel they use.

The 5 GHz band

Wi-Fi channels are selected from a so called “frequency band”. All access points support the 2.4 GHz band, while most newer access points also support the new 5 GHz band.

The advantage of the 5 GHz band is that it’s (currently) less crowded. So, Wi-Fi speed is usually higher in the 5 GHz band than in the 2.4 GHz band.

Not all Wi-Fi access points can use both bands at the same time. The AirPort Express Base Station (2nd generation), for example, does support this, while my FritzBox 7270 only supports either 2.4 or 5 GHz (but not both at the same time).

If your access point support both bands at the same time, use the same SSID for both (if you have the option to choose). This helps on devices where you can’t prioritize your Wi-Fi networks (like on iOS or Android) to always pick the 5 GHz band.

You should also know that only the newest (at the time of writing) and more expensive devices support the 5 GHz band. For example, only the iPhone 5 supports the 5 GHz band while all older iPhones do not. Also, most cheap notebooks don’t support 5 GHz either.

Links

This article is mostly based on my own experience as well as the following links:

• Multiple access points for the same SSID?

• Does it make sense to keep different SSIDs for 2.4GHz and 5GHz wireless networks?

Also, very helpful is the AirPort base station status lights (LED) listing from Apple, if you want to know what the color and state of your AirPort’s LED means.

If you have some binary files you need for your Visual Studio project but you don’t want to add them to your version control system, here’s a PowerShell script that does the downloading for you:

download.ps1

Basically this mimics a very simple dependency management.

Source Repository: https://bitbucket.org/mayastudios/powershell-downloader/

Configuration

At the very top of the script, you define which files to download where.

For example, this downloads the x86 and the x64 version of a SQLite .dll file:

$base_url = 'https://mydomain.com/sqlite'
$files = @{
  '..\sqlite.dll' = "$base_url/x86/sqlite.dll"
  '..\sqlite_x64.dll' = "$base_url/x64/sqlite_x64.dll"
}

Entries must be separated by line breaks or semicolon (;).

Paths are relative to the location of the script file.

Usage

To include the script in your project, call it from your project’s Pre-build event.

For example, if you’ve placed download.ps1 in a folder called libs in your project, use this line to execute it:

powershell -ExecutionPolicy ByPass -File "$(ProjectDir)\libs\download.ps1"

That’s it.

When Does It Download

The script will download the files if:

• they don’t exist
• the script file is newer as the files (idea behind this: you’ve changed the file version to download)

• a file named force-download.txt exists in the scripts folder and this file contains anything else but “false”

These rules are defined in the Needs-Downloading function.

But what if you want to know the file’s path instead of opening it? Here’s how:

• Hold down ⌘ + ⌥ to reveal the file’s path below the preview box appearing to the left of the search result list.

• ⌘ + click, or ⌘ + ⏎, to reveal the file in the Finder.

However, there are also some very pit falls when coming from C# (or any related programming language).

There’s one very mean pit fall when it comes to functions and their return values that – if you don’t exactly know how PowerShell works – makes you pull out your hair.

Assume this PowerShell code:

function PrintAndReturnSomething {
  echo "Hello, World"
  return 42
}

$result = PrintAndReturnSomething

What do you expect $result to be? An integer with value 42, right? Let’s check it out.

We’re adding the following line to the end of the script:

echo ("Return type: " + $result.GetType().FullName)

Now, when you run the script, you’ll get:

Return type: System.Object[]

Wait, what? Where’s the “Hello, World”? And why the heck is $return an object array?

The first problem (pit fall) is that PowerShell treats every non-captured object (i.e. one that isn’t assigned to a variable) as return value.

Functions Return Everything That Isn’t Captured

Let’s have a look at a different script for a moment:

function LongNumericString {
  $strBld = new-object System.Text.StringBuilder
  for ($i=0; $i -lt 20; $i++) {
    $strBld.Append($i)
  }
  return $strBld.ToString()
}

One would expect that LongNumericString returns just a string; but it doesn’t. Instead it returns an object[] with this contents:

Capacity           MaxCapacity                        Length
——–                ———–                               ——
16                 2147483647                         1
16                 2147483647                         2
16                 2147483647                         3
16                 2147483647                         4
16                 2147483647                         5
16                 2147483647                         6
16                 2147483647                         7
16                 2147483647                         8
16                 2147483647                         9
16                 2147483647                        10
16                 2147483647                        12
16                 2147483647                        14
16                 2147483647                        16
32                 2147483647                        18
32                 2147483647                        20
32                 2147483647                        22
32                 2147483647                        24
32                 2147483647                        26
32                 2147483647                        28
32                 2147483647                        30
012345678910111213141516171819

The problem here is that $strBld.Append returns a StringBuilder object. And since this return value isn’t assigned to a variable, PowerShell considers it part of the return value.

To resolve this problem, prefix $strBld.Append with [void]:

function LongNumericString {
  $strBld = new-object System.Text.StringBuilder
  for ($i=0; $i -lt 20; $i++) {
    [void]$strBld.Append($i)
  }
  return $strBld.ToString()
}

Note: The keyword return is totally optional. The expression return $strBld.ToString() is equivalent to $strBld.ToString(), and even to $strBld.ToString(); return.

Function Return Values = Function Output

Back to our initial script. Now that we know how PowerShell composes return values for functions, why didn’t PrintAndReturnSomething return just 42?

One needs to understand that PowerShell doesn’t actually care about return value but rather about output of functions. The return value is just considered to be a part of the output. This way, PowerShell doesn’t just allow you to pipe text (like ls -l | sort in bash), but to pipe actual objects.

For example, Get-ChildItem C:\ | Format-Table Name, Length is the same as:

$child_items = Get-ChildItem C:\
Format-Table -InputObject $child_items Name, Length

PrintAndReturnSomething uses echo (which is an alias for Write-Output) to print “Hello, World”. This is output and thus part of the function’s return value.

To force PowerShell to write something to the console (rather than including it in the return value), use Write-Host instead of echo.

The corrected code is:

function PrintAndReturnSomething {
  Write-Host "Hello, World"
  return 42
}

$result = PrintAndReturnSomething
# Return is now a "System.Int32" with value 42.

Summary

To sum things up:

• PowerShell functions will always return (as object[], if there’s more than one return value):

  • all uncaptured objects (i.e. objects that haven’t been assigned to variables)
  • as well as all output (from echo/Write-Output)

• Exclude from return value:

  • Uncaptured objects: prefix with [void]

  • Console output: use Write-Host instead of echo/Write-Output

Acronis Drive Monitor comes with a service called “Acronis Scheduler2 Service”. As long as this service runs, it somehow breaks access to my external USB 3.0 drives. If I try to copy files to my external drive, the progress will freeze after a minute or so (together with a explorer window trying to access the external drive).

Solution: Stop the service (USB drives will start working again immediately), or uninstall Acronis Drive Monitor completely.

Fortunately, this is easy to fix. Just open up Terminal and paste in the following lines (all at once) to fix the problem!

/System/Library/Frameworks/CoreServices.framework/Versions/A/Frameworks/LaunchServices.framework/Versions/A/Support/lsregister -kill -r -domain local -domain system -domain user && pkill Finder

Cause of the problem: When you delete an application, its entry in the “Open With” menu is not deleted. This also applies to app updates, where the old version of the app is deleted and replaced by a new one (which gets its own menu entry). The problem probably only occurs for non-Mac App Store apps.

Random “The type or namespace name ‘XXX’ could not be found” errors when building

Mono for Android randomly produces “The type or namespace name ‘XXX’ could not be found” errors when building a solution. These errors don’t really exist and disappear after a rebuild.

NullReferenceException in AppDomain.UnhandledException handler

To achieve this, use this snippet:

function order_posts_by_mod_date($orderby) {
  if  (is_home() || is_archive() || is_feed()) {
    $orderby = "post_modified_gmt DESC";
  }

  return $orderby;
}

add_filter('posts_orderby', 'order_posts_by_mod_date', 999);

In your theme, just dump this snippet into functions.php. (You may need to create this file in your theme’s directory.)

Since Android 4.0

Since Android 4.0 (API level 14) you can download the source code by using the “SDK Manager”.

After downloading them, you’ll find them under <android-sdk>/sources.

Before Android 4.0

The Problem

Despite the fact the Android is (supposed to be) an open source project, the downloads don’t include the source code of Android. So, when opening an Android class in Eclipse, you may see something like this:

To solve this problem you had to manually download the whole Android source code (which contains much more than just the Java source code files) and then manually assemble a source files directory from the Java files scattered throughout the Android source tree. Very tedious and certainly not very simple.

The Solution

Fortunately, there is a Google Code project named “adt-addons” aiming to solve this problem (for API levels 13 and lower). The project actually consists of several Eclipse plugins, but the one you want is called “Android Sources”. You can either search the instructions on the project page, or follow them (nicely formatted) here.

Basically what you need is to install the “Android Sources” plugin (about 170 MB). Here’s the update URL:

http://adt-addons.googlecode.com/svn/trunk/source/com.android.ide.eclipse.source.update/

After installing the plugin, simply restart Eclipse and the Android source code is already attached to the Android classes.

But even without this add-on, Firefox allows you to restrict your search by adding a character in front of the search terms, like so:

Notice the * in front of the search term bugs. This restricts the search to bookmarks.

Here’s a list of the most important restrictions:

All these shortcuts can be edited in about:config under browser.urlbar.

Why is there an “OK” and a “Cancel” button? What do they mean?

(“OK” means “Close” and “Cancel” means “Stop Backup”. When you start a backup, the button is actually labeled “Close” (instead of “OK”).)

ReSharper is such a tool. It provides refactoring capabilities for C#/Visual Studio.

Unfortunately, the renaming code in ReSharper currently (version 7.1.1) contains a bug. This bug may prevent ReSharper from renaming all occurrences of a certain symbol.

The following code exhibits this problem:

using System;

public class SomeOtherClass {
  public string GetString(int col) {
    return null;
  }
}

public class MyClass {
  public void YouCantRenameMe() { }

  public void ThisFunctionBreaksTheRenaming() {
    // The following line breaks the renaming.
    SomeFunction((row) => row.GetString(0));
  }

  public void SomeFunction<T>(Func<SomeOtherClass, T> func) {
    YouCantRenameMe();
  }
}

If you try to rename the method YouCantRenameMe() (in line 10), ReSharper won’t rename the method call in line 18.

The problem is the code in method ThisFunctionBreaksTheRenaming() which somehow breaks the renaming process.

Update: This bug is not present in version 7.1. So, for now, I’ve downgraded to this version.

02-04 17:09:32.010: W/(4300): Bad call to mono_mutex_lock result 11
02-04 17:09:32.010: A/(4300): * Assertion at /Users/builder/data/lanes/monodroid-mac-monodroid-4.4-series/6418373f/source/mono/mono/metadata/loader.c:2181, condition `ret == 0' not met

This flood of log messages made the whole deployment process very slow (54 seconds to deploy a fresh project).

As workaround I found that disabling Use Fast Deployment in the project settings “solved” the problem for me.

I’m still waiting for an answer from Xamarin on this issue. Update: This problem is tracked here.

This is the goal behind the MonoDroid Unit Testing Framework which can be obtained here:

https://bitbucket.org/mayastudios/monodroid-unittest/

Happy testing!

Since I’m a well-behaved programmer, I filed a bug report for this.

For now, I have to use monitor.bat from the Android SDK’s tools directory to work around this issue.

To enable “Click to Play” in Firefox…

1. go to about:config and click on “I’ll be careful, I promise!”

2. search for plugins.click_to_play and set it to true (by double-clicking the entry)

After that, when you get to a page that contains Flash (videos), Java, or any other plugin, you’ll get a “Click to Play” message for the plugin.

Usually you would do something like this (code in C#):

int Compare(int a, int b) {
  if (a < b) {
    return -1;
  }
  else if (a > b) {
    return 1;
  }
  else {
    return 0;
  }
}

However, when comparing int values, there’s a much quicker way to do this:

int Compare(int a, int b) {
  return a - b;
}

That’s it.

Note: Care should be taken if a and/or b can come close to int.MaxValue or int.MinValue. In this case the results may not be what one wants (like if a = int.MinValue and b = 1 then the result will be int.MaxValue which is wrong obviously).

Click here to view the embedded video.

This post is about how to display (draw) a mathematical function with R.

Side note: There’s a very nice and interactive tutorial for R available over at codeschool.com. It’s free and takes about 3 – 4 hours to complete.

To draw a function, use the built-in function curve().

Let’s start with something simple:

curve(x^2)

This will plot the function x² and will look like this:

Since we didn’t specify any boundaries for the x and y axes, R used 0..1 for the x axis and chose the y axis to fit.

Of course, we can manually specify the range for the values on the x axis:

curve(x^2, -4, 3)

This will plot x² with -4..3:

As you can see in this plot, R makes the y axis match the required value range (here: 0..15).

Sometimes, however, this may not be desired. There are two ways to fix this.

First, you can specify the aspect ratio to be 1 (cause log scales are for quitters). In this case, the x and the y axes will use the same scale:

curve(x^2, -4, 3, asp=1)

will give us:

The other option is to explicitely specify the range for the y axis by using the ylim parameter:

curve(x^2, -4, 3, ylim=range(c(-1, 4)))

will give us a y axis range of -1..4:

For more information on curve(), just type ?curve in R’s prompt.