Monoliths “Unstrung”

One downside to the functional approach outlined in the article–that I didn’t see mentioned–is the fact that the interface is actually being split in a few cases, which is actually detrimental to cohesion. This happens when you have multiple overloaded forms of a function, and you keep one “flexible” one as a member function, but make the others external functions. Why not keep those as members for the sake of consistency? You can still implement them in terms of the one “flexible” member function, thereby continuing to ensure good encapsulation.

A few thoughts on applying the spirit of the law discussed in the article to other languages:

• C# – Use extension methods, but the “this” type should be as generic as possible. You still get the benefits of DRY but in a more object-oriented fashion that works well with Intellisense and cohesion. I like the extension  method approach better than the old static-methods approach (e.g., string.Join) because it still enforces good encapsulation, and is less verbose and more cohesive than the alternative.
• Ruby – Use mix-ins that use duct-type delegation to other methods. These can be automatically mixed into all applicable classes when the mix-in is “required”.
• Lisp – Brilliant! All you have are functions!

It’s also important to note the power you derive from combining this functional approach with lambda functions, function objects, and covariance.

See also: How Non-Member Functions Improve Encapsulation

[OperationContract]
[WebInvoke(UriTemplate = "/{encodedGameId}", Method = Verbs.Post)]
void AddSample(string gameId, Contracts.Sample newSample);
[WebDispatchFormatter]

If you leave off any of the query parameters for GetStatistics, WCF cheerfully returns “Method not allowed”. I wanted to make the “tag” parameter optional, and worried this would be a deal breaker.

Fortunately, I came across this WCF post by Ron Jacobs.

The basic idea is to leave off the optional query parameters in the UriTemplate, instead manually pulling them from the current request context. This approach is actually similar to the way you access query parameters in RoR, so I should have thought of doing it like this in the first place.

In fact, if you beef up Ron’s QueryString class, it can clean help you DRY up your code by taking care of data type conversions on the sly.

The moral of the story is that a framework’s design can induce sneaky biases that you only discover as they jump out of the shadows to bite you.

Thanks Ron!

Lots of these words are obscure, and therefore useless. For example, what’s an abaca?

Perfect for making your own T-Shirt. Like, you could put 7e55e118 below a mesh , and only CG hackers would understand.

No other operating system can match Windows for the number of devices supported, but it definitely comes with a trade-off. If you have fallen prey to a poorly-written driver, don’t despair! All you need to do is whip out your trusty copy of WinDbg, and within a few minutes that wimpy driver will cower before your superior kernel ninja skills!

Learn how to debug Windows BSOD crashes. Also, here is a more general tutorial on WinDbg.

Now, once you’ve found the culprit, you have three options. Choose wisely:

1. Get the latest driver from Windows Update or the device manufacturer’s website.
2. Replace the rogue device with something from a company who actually tests their hardware before shipping it.
3. Buy a Mac. They never crash, right?

XFS does not support dirent::d_type

What the?! In other words, a line such as this will always be false:

de->d_type == DT_FIFO

Jungle Disk uses readdir_r() to list files and check their types. Uh oh. That means that on XFS partitions, everything looks like a regular file! You can see this for yourself using code like this:

#include <iostream>
#include <cstdlib>
#include <dirent.h>
#include <sys/stat.h>

using namespace std;

int main(int argc, char *argv[])
{

  dirent holdde;
  dirent *de;
  struct stat st;

  cout << "DT_BLK = " << DT_BLK << endl;
  cout << "DT_CHR = " << DT_CHR << endl;
  cout << "DT_DIR = " << DT_DIR << endl;
  cout << "DT_FIFO = " << DT_FIFO << endl;
  cout << "DT_LNK = " << DT_LNK << endl;
  cout << "DT_REG = " << DT_REG << endl;
  cout << "DT_SOCK = " << DT_SOCK << endl;
  cout << "DT_UNKNOWN = " << DT_LNK << endl;

  DIR *dir = opendir("/home/vmuser/xfs");
  while (readdir_r(dir, &holdde, &de) == 0 && de)
  {
	  cout << de->d_name << " [" << (int)de->d_type << "] " << endl;
  }
  closedir(dir);

  lstat("/home/vmuser/xfs/TESTFIFO", &st);
  if (S_ISFIFO(st.st_mode))
	  cout << "XFS FIFO detected: " << st.st_mode << endl; 

  lstat("/home/vmuser/ext3/TESTFIFO", &st);
  if ((st.st_mode & S_IFIFO) != 0)
	  cout << "EXT3 FIFO detected: " << st.st_mode << endl; 

  return EXIT_SUCCESS;
}

So what’s the solution? Good old, reliable stat(). That function does work with XFS on Linux. Unfortunately, this means you will have to make an extra call for each file after listing the dir.

If you are interesting in hacking the Wii, you need to check out WiiBrew. This is the place to go for information about compiling, running, and debugging your own custom Wii apps. For example, WiiBrew is where I found out about the excellent Homebrew Channel.

Dotbatman is porting the cult classic Super Mario War to the Wii. What are you going to do?

Update: You no longer need a copy of Zelda to install the Homebrew Channel! Check out the latest Bannerbomb hack. 

/*
Copyright (c) 2008, dotbatman (nerdfortress.com)
All rights reserved.

Redistribution and use in source and binary forms, with or without modification,
are permitted provided that the following conditions are met:

	1. Redistributions of source code must retain the above copyright notice,
	this list of conditions and the following disclaimer.

	2. Redistributions in binary form must reproduce the above copyright
	notice, this list of conditions and the following disclaimer in the
	documentation and/or other materials provided with the distribution.

	3. Neither the name of the nerdfortress.com nor the names of its
	contributors may be used to endorse or promote products derived from
	this software without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/

#ifdef __cplusplus
extern "C" {
#endif

#ifdef DIRENT_H

// This has already been included in the project once, so we only need prototypes
static DIR* opendir (const char *path);
static int closedir (DIR *dir);
static struct dirent* readdir (DIR *dir);
static void rewinddir (DIR *dir);

#else // First inclusion

// We don't want to be redefining these functions over and over again.
#define DIRENT_H 

#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <string.h>
#include <sys/dir.h>
#include <fat.h>

typedef DIR_ITER dir_t; // For libfat

// This structure can hold all the juicy details for our functions,
// and it doesn't need to follow any standard but having d_name in most cases.
typedef struct dirent
{
	DIR_ITER*	dirPointer;
	char		d_name[FILENAME_MAX+1];
} DIR;

static DIR* opendir(const char* path)
{
	DIR* dir;

	// Check the path yourself. This is just to make sure we don't trip over
	// someone elses really bad code (tm).
	if (!path || *path == 0)
	{
		errno = EINVAL;
		return NULL;
	}

	DIR_ITER* dp = diropen(path);
	if(!dp)
		return NULL; // diropen sets errno for us, so just return NULL. 

	// Build our DIR struct
	dir = (DIR*)malloc(sizeof(DIR));
	if(!dir)
	{
		errno = ENOMEM;
		return NULL;
	}

	dir->dirPointer = dp;

	// Return that DIR for use with other functions.
	return dir;
}

static int closedir(DIR* dir)
{
	int retval;

	if (!dir)
	{
		// Not a good DIR, but thanks for playing... aha ha ha ha.
		errno = EBADF;
		retval = -1;
	} else {
		// Pass the DIR_ITER pointer to libfat and shut 'er down.
		retval = dirclose(dir->dirPointer);
		free(dir); // Clean up after ourselves
	}

	return retval;
}

static struct dirent* readdir(DIR* dir)
{
	// We'll need to store each entry from the listing
	char entry[FILENAME_MAX+1];

	if (!dir)
	{
		errno = EBADF; // Bad DIR. No biscuit.
		return NULL;
	}

	if(dirnext(dir->dirPointer, entry, NULL) == 0)
	{
		strncpy(dir->d_name, entry, FILENAME_MAX);
		return dir;
	}

	// We're all out of files to give you
	return NULL;
}

static void rewinddir(DIR* dir)
{
	if (dir != NULL)
	{
		// If you need documentation on this one, you've got bigger problems.
		dirreset(dir->dirPointer);
	}
}

#endif // DIRENT_H

#ifdef __cplusplus
}
#endif

Get the Visual Studio 2008 Keyboard Shortcuts Cheat Sheet

Bonus! For all you VIM ninjas, get even more keyboard love with ViEmu and my favorite VIM cheatsheet.
Bonus #2! Check out these other well-done programming cheat sheets.
Bonus #3! Use these little-known features of Visual Studio to be more productive.

One of my favorite operators is modulo, or simply mod. This thing is pure magic. For example, suppose I needed to keep track of whether I was on an odd or even row in a table. People do this all the time to color alternating rows, making the information more readable. I could write some code like this:

is_even = false
rows.each do |row|
  if is_even
    color = :even
  else
    color =  dd
  end

  is_even = !is_even
end

Using the magic of the mod, I can simplify my life a little:

rows.each_with_index do |row, i|
  if (i % 2) == 0
    color = :even
  else
    color =  dd
  end
end

Now, that was OK, but not really all that magical. But lets take this idea one step further. Suppose you were providing a web service and you had a bunch of clients connecting to your servers. In order to distribute the load, you could use some kind of proxy or load balancer. Each client would then connect to one IP address and the proxy would divvy up the requests among your servers. The problem with this is you have a potential bottleneck in your system; you can only respond to requests as fast as your proxy can process the traffic.

One alternative is to harness the magic of the mod. The first thing you need is some kind of unique ID for each client. This could be a username, a GUID, or whatever. The second thing you need is to give each client a list of servers it can connect to.

Now, the client will need to figure out all by itself which server in your cluster is its buddy for life. Its soul mate. The client does this by first taking it’s ID and hashing it into a number. The hash algorithm should have as even a distribution as possible (i.e., two IDs that are similar should hash to totally different numbers). Can you tell why this is important? Now, once the client has that fancy number in hand, it is time to invoke the magic of the mod. Simply mod the ID hash by the number of servers, and the number you get is the index of the server you should send your requests to.

If you are, well, paranoid, and want to ensure that a rogue piece of software isn’t sending everything to a single server, regardless of the client ID, you will need some way of looking up the ID for each request and then doing the same hash-lookup procedure on the server side that the client is supposed to do. If the result is kosher (i.e., the server receiving the request is the one the client should be talking to), the server processes the request. Otherwise, the server returns a big fat error. As big and fat as possible.

What is your favorite use for the mod?