ffuts.org

Logitech G500 Gaming Mouse - Impressions

Sat, 22 May 2010 16:06 -0700

Got a Logitech G500 mouse recently and I thought I’d just quickly note my impressions of the mouse and its associated software. First, some background on my previous (non-throwaway) mice to give an idea of what I’ve used before:

Logitech MX1000: a wireless mouse that had little to no lag in my particular environment, in contrast to:
Logitech MX Revolution: the wireless mouse Logitech sent me as a replacement for the MX1000 above; had two wheels, one of which had a free spinning mode; unfortunately had terrible interference problems for me and was essentially unusable
Razer DeathAdder: a wired mouse with a great shape, just wish it had more buttons
Purchased the Logitech G500 because my Razer mouse was double-clicking sporadically and developed a flaky scroll wheel (scrolling down would sometimes scroll up)

I don’t have much to say about the mouse itself that hasn’t already been said on the internet – it feels good in the hand and has plenty of buttons. I’m going to focus on the part I found more interesting, the on-board memory.

Now, one problem with most of these mice is that while the left, right, middle, and two side buttons (Mouse4 and Mouse5) are supported natively by Windows, any additional buttons on them require the appropriate drivers to be installed. This isn’t necessarily bad in itself, but I always liked the ideal of a mouse that just works, fully functional, without requiring any drivers. The DeathAdder added on-board memory to avoid this issue, so you could do things like save a macro to Mouse5 and bring it to another computer and have that macro available. Unfortunately, it only had five buttons, all of which already have standard functions, so I never found a good use for this feature. However, the on-board memory did let you save your mouse DPI settings, which was somewhat useful.

The G500 also has on-board memory, but this time it also has the spare buttons to make it worthwhile. In addition to the five standard buttons, the G500 has one extra side button, two DPI buttons, a left wheel tilt and a right wheel tilt. All of these are programmable and, as long as you stick to commands that can be sent by a keyboard or a mouse (including standard media keys like volume and playback controls), will work on any computer without drivers. It apparently does this by acting as several human interface devices, including a keyboard and a mouse:

It’s pretty interesting assigning a keystroke like ‘A’ to a side button or having your DPI buttons control the system’s volume. After setting my bindings up I uninstalled the SetPoint software and still have a fully working mouse. Neat.

Accessing a Git repository with TortoiseHg on Windows

Fri, 09 Apr 2010 10:31 -0700

If you’re using Hg and you want to get hold of a Git repository there is an extension, hg-git, that lets you do this.

On Windows the installation process for this hasn’t always been the easiest, as you needed to first install the dulwich Python library (which I always seemed to have trouble doing) and then hg-git. The TortoiseHg guys have made this a lot easier in recent versions of TortoiseHg, as they now include the dulwich libraries.

So, step by step:

You’ll need TortoiseHg 0.9.3 or later. Get the latest version.
Bring up a command line and enter this line to clone the latest hg-git to your desired directory (this is “installing” hg-git). I’ll use D:\TortoiseHg\hg-git in this example.
```
> hg clone http://bitbucket.org/durin42/hg-git/ D:\TortoiseHg\hg-git
```
Open up your user-specific Mercurial.ini. The location of this file may change occasionally, read the Mercurial docs if you have trouble finding it.
On Windows Vista and Windows 7 this file is typically located at:
```
C:\Users\YourUsername\Mercurial.ini
```
while on Windows XP you’ll find it at:
```
C:\Documents and Settings\YourUsername\Mercurial.ini
```
Alternatively, bring up the Windows “Run” dialog and enter:
```
%USERPROFILE%\Mercurial.ini
```
which will work on all recent Windows platforms.
Navigate down to the [extensions] section and add this line to that section:
```
hggit = D:\TortoiseHg\hg-git
```
Where D:\TortoiseHg\hg-git is the directory you cloned hg-git to earlier. This line may already exist or may be commented out with a semicolon, in that case just remove the semicolon and update the directory.

Now you can clone a Git repository like so:

> hg clone git://github.com/richhickey/clojure.git D:\TargetDirectory

The result is you’ll have a Mercurial enabled repository at D:\TargetDirectory. You can push, pull, and generally treat it as an Hg repository. Try
```
> hg help hggit
```
for additional help and information, or check the HgGit page on the Mercurial wiki.

Great Boost Documentation

Sat, 03 Apr 2010 18:20 -0700

I found out from the Life of Andrew blog that there is a new source for Boost information available. It’s a Creative Commons licensed book covering a wide range of Boost libraries, some of which are usually under-represented documentation-wise (looking at you, ASIO). It was originally written in German by Boris Schäling, but Andreas Masur has translated it into English for those of us who aren’t so culturally adapted.

A brief skim of the book gives an extremely promising impression and I think it’ll be one of the first resources I point newcomers to Boost to in the future.

Simplify signals and slots connections with unique connections in Qt 4.6

Tue, 12 Jan 2010 14:43 -0700

Somehow there’s absolutely no mention of this in the What’s New in Qt 4.6 summary, but one of my favorite new features in Qt 4.6 is a surprisingly simple one: the Qt::UniqueConnection connection type.

The default connection type for connect() is Qt::AutoConnection, which sets up either a direct or queued connection depending on whether the signaling object and receiving slot are in the same thread or not. This connection type allows you to connect a particular signal/slot pair multiple times (so emitting a signal once could call a slot twice) which has caught me on a number of occasions.

This is really simple to work around: you can add some bookkeeping to keep track of that particular connection or you can use disconnect() where appropriate to maintain 0 or 1 connections. The new Qt::UniqueConnection connection type, on the other hand, lets you be sure that a connection is made only once. It’s not something you always need, but when you do, it lets you keep your code a bit cleaner.

One caveat is that Qt::UniqueConnection makes a unique Qt::AutoConnection, meaning you don’t have the ability to explicitly specify a unique queued connection, for example. In a case like that you will have to keep track of the connections yourself, as before.

Qt 4.6 has prebuilt binaries for Visual Studio

Wed, 02 Dec 2009 12:42 -0700

I’ve just found out that Qt 4.6 actually includes prebuilt LGPL binaries for Visual Studio 2008, so there’s little reason to spend time building Qt unless you need to use some other version of Visual Studio.

The prebuilt binaries are downloadable from here. Alternatively, you can visit the Qt download page, choose LGPL, and look on the right hand side of the page for the download link.

I highly recommend using the prebuilt libraries, as you will save a tremendous amount of time (it takes hours to build Qt). After you finish downloading and installing the libraries, install the Visual Studio add-in to make it easier to handle the custom build steps for moc and ui files.

Qt 4.6 is out, compiling it with MSVC

Wed, 02 Dec 2009 01:39 -0700

Qt 4.6 has been released (with some new features) so I’ve taken the opportunity to make sure my instructions on how to compile Qt with Visual Studio are still accurate. The additional steps on how to take advantage of your multi-core processor (using jom) still work, as well.

[Edit: Qt 4.6 actually has prebuilt binaries/libraries for Visual Studio 2008, which is preferable to spending hours building Qt]

I’ve made a note in the article but I’ll repeat it here because it’s a major time-saver: you should delete, from your Qt folder, these instances of mocinclude.tmp:

\Qt\2009.05\qt\src\3rdparty\webkit\WebCore\tmp\moc\debug_shared\mocinclude.tmp
\Qt\2009.05\qt\src\3rdparty\webkit\WebCore\tmp\moc\release_shared\mocinclude.tmp
\Qt\2009.05\qt\src\script\tmp\moc\debug_shared\mocinclude.tmp
\Qt\2009.05\qt\src\script\tmp\moc\release_shared\mocinclude.tmp

Deleting the first two mocinclude.tmp files will prevent a LNK2019 error while building Webkit, while deleting the last two (which are new in Qt 4.6, as far as I can tell) will prevent an Error: Unknown interface while trying to build qscriptextensionplugin.h.

An update on building Boost with MSVC (still with dual/quad/multi-core action)

Thu, 19 Nov 2009 02:05 -0700

I’ve noticed that in recent versions of Boost (1.39.0 and newer) there is a way to do a “Simplified Build from Source” if you’re using Microsoft Visual Studio. Here are the steps as I like to write them:

Download the latest version of Boost and extract it to some location (we’ll assume D:\Boost\), making sure to maintain the directory structure.
In a command prompt, navigate to your Boost library folder (D:\Boost\boost_1_41_0\) and then use this command, which builds your very own copy of Boost Jam (a build system):
```
> bootstrap
```
Now, in the same command prompt, enter this command, where N is the number of processors/cores you have available for compiling (for example, -j4 if you have a quad-core processor):
```
> bjam.exe -jN
```
Wait.
After the build completes you will have a stage subdirectory (D:\Boost\boost_1_41_0\stage\) which will contain a lib subdirectory, containing the compiled libraries.

This simplified process removes the need to get a copy of Boost Jam, which, as trivial as it sounds, really does make a big difference to the friendliness of the entire procedure. It also reduces the number of necessary arguments to zero (or one, if you consider multi-core a necessity), although there are some situations where you may still need the older arguments (in which case I refer you to my previous entry on the subject).

SteveStreeting.com's great series of articles about distributed version control systems

Sat, 07 Nov 2009 00:43 -0700

Steve Streeting (the man behind OGRE, a 3D graphics engine) has been writing about his experiments with distributed version control systems, particularly Mercurial and Git. In particular, his latest blog post contains a summary of his experiences with the two version control systems and is probably the most in-depth article I’ve read on the topic.

The most interesting portions of the article (and his prior posts) are the ones which talk directly about managing the OGRE source within each of the two DVCSs. OGRE is not a small project and it’s very illuminating to read about what parts of a (distributed) version control system are important to a larger project, as this is stuff you may not personally experience until it’s too late to change your mind.

For my own personal projects I use Subversion (TortoiseSVN is a great piece of software) and I’m not in any particular rush to switch over to a DVCS just yet. It’s simple, straightforward and fits well with my workflow. For larger projects, especially ones where you’re collaborating with people across the Internet, I’d give some serious thought to using a DVCS and reading about other people’s experiences is extremely helpful.

Windows Sidebar Gadgets

Mon, 12 Oct 2009 11:57 -0700

Windows Vista and Windows 7 provides what they call Windows (Sidebar) Gadgets (the Sidebar moniker is removed in Windows 7). These gadgets do the same thing as similar products from Yahoo (formerly known as Konfabulator) and Apple (the Dashboard), providing small amounts of functionality and information within easy reach.

The Windows Live Gallery is a perfect example of how not to make a download center. If you take a look at the Sidebar gadgets category, most are of rather poor quality, and a fair number of the good ones use plagiarized skins and/or code.

There’s no community presence on a site like that, and without a community to help deter poor behavior I think the free-for-all atmosphere makes it hard for the good submissions to float to the top. deviantART is a great example of a site that does the right stuff; their Sidebar gadgets section is cleaner and easier to use.

Anyway, I bring this up because there are some gadgets on The Hobby Lounge which you won’t find on deviantART and unfortunately exist in a plagiarized state on the Windows Live Gallery. I was in the process of updating some of my older gadgets from this site and it took me a surprisingly long time to find the website again, even though I knew exactly what I was looking for. My google-fu is usually pretty decent so I figure I’ll make a note of it here for myself and maybe help them get noticed a bit more.

Optimization switches and Visual Studio 2008

Fri, 02 Oct 2009 15:29 -0700

In a previous entry I noted that you generally do not need to micromanage your optimization switches.

However, in Visual Studio 2008 (both with and without SP1) there is a bug where the default optimization switch, /O2, is not applied even when shown in the IDE under Configuration Properties->C/C++->Optimization.

This happens when you select <inherit from parent or project defaults>. Instead, you want to explicitly set Maximize Speed (/O2) (it will show up in bold when explicitly set). You should also verify that the /O2 flag is being applied by viewing the command line (Configuration Properties->C/C++->Command Line).

There is more about this bug on Microsoft Connect, where it’s also noted that this bug will be fixed in Visual Studio 2010.

Right-click context menus with Qt

Thu, 23 Jul 2009 20:47 -0700

Getting right-clicks to popup a context menu is pretty straightforward in Qt. There are just a couple of things to watch out for…

First, there are several ways to tell Qt you want a context menu. One approach is to subclass the widget and override the QWidget::contextMenuEvent() event handler. However, I think the easiest approach is to call setContextMenuPolicy(Qt::CustomContextMenu) on the widget you want, and then connect the customContextMenuRequested() signal to the appropriate slot:

// myWidget is any QWidget-derived class
myWidget->setContextMenuPolicy(Qt::CustomContextMenu);
connect(myWidget, SIGNAL(customContextMenuRequested(const QPoint&)),
    this, SLOT(ShowContextMenu(const QPoint&)));

Next, note that the const QPoint& pos parameter in the customContextMenuRequested() signal is normally in widget coordinates. However, also note that classes which inherit from QAbstractScrollArea¹ instead use the coordinates of their viewport(). Either way, you will need to map these coordinates to global coordinates using mapToGlobal().

Finally, simply either popup() or exec() your QMenu. Remember that popup() is non-blocking, so if you wish to use that, make sure your QMenu is created on the heap!

void MyClass::ShowContextMenu(const QPoint& pos) // this is a slot
{
    // for most widgets
    QPoint globalPos = myWidget->mapToGlobal(pos);
    // for QAbstractScrollArea and derived classes you would use:
    // QPoint globalPos = myWidget->viewport()->mapToGlobal(pos); 

    QMenu myMenu;
    myMenu.addAction("Menu Item 1");
    // ...

    QAction* selectedItem = myMenu.exec(globalPos);
    if (selectedItem)
    {
        // something was chosen, do stuff
    }
    else
    {
        // nothing was chosen
    }
}

Examples include QTreeWidget, QTreeView, QListWidget, QListView, QTableWidget, QTableView, QTextEdit, QPlainTextEdit, and QMdiArea. ↩

Consolas is a poor choice for web use

Mon, 06 Jul 2009 15:22 -0700

Consolas, with ClearType enabled, is a gorgeous font, and is my preferred monospaced font. However, take a look at it without ClearType (there’s a sample image on the linked Wikipedia article)—those jaggies hurt.

That’s why you shouldn’t define Consolas in your style sheets. You can’t know/assume that everyone who views your webpage will have ClearType on (or at least some form of font-smoothing), and those who don’t have it enabled will suffer through text that looks as though it were drawn freehand with a mouse.

Instead, unless you are going for a specific effect such as trying to mimic old terminals, keep your font-family for <pre> and <code> elements short and to the point. I personally use

font-family: "Lucida Console", "Monaco", "DejaVu Sans Mono", monospace;

which is usually enough to keep Courier (+ New) out of the way. If someone is missing all of these fonts they’ll likely have a decent enough substitute.

Compile Qt 4.5 for Visual Studio, using your multi-core processor

Thu, 25 Jun 2009 20:28 -0700

If you want to use Qt 4.5 with Visual Studio you’ll need to compile it yourself. The instructions are simple, and fairly well documented on various blogs and websites. Essentially: (read steps 7 and on for multi-threading information)

[Edit: These steps still apply for Qt 4.6, but Qt 4.6 actually has prebuilt binaries/libraries for Visual Studio 2008 which I highly suggest looking at instead]

This step is important. You will potentially save some time by deleting these mocinclude.tmp files:
```
\Qt\2009.05\qt\src\3rdparty\webkit\WebCore\tmp\moc\debug_shared\mocinclude.tmp
\Qt\2009.05\qt\src\3rdparty\webkit\WebCore\tmp\moc\release_shared\mocinclude.tmp
\Qt\2009.05\qt\src\script\tmp\moc\debug_shared\mocinclude.tmp
\Qt\2009.05\qt\src\script\tmp\moc\release_shared\mocinclude.tmp
```
Deleting the first two mocinclude.tmp files will prevent a LNK2019 error from building Webkit, while deleting the last two (which are present in Qt 4.6) will prevent Error: Unknown interface from occurring while trying to build qscriptextensionplugin.h. If you’re missing any of them don’t fret, it’s actually a good thing.
Using a Visual Studio Command Prompt, navigate to your Qt folder (I’ll use D:\Coding\Qt\2009.05 in this example).
Go to the Qt folder inside there (e.g. D:\Coding\Qt\2009.05\qt). It’s the one that contains configure.exe.
Enter the following command, changing win32-msvc2008 to win32-msvc2005 if necessary.
```
> configure -opensource -shared -ltcg -no-qt3support -platform win32-msvc2008
```
What this does is fairly self explanatory. The -shared switch will make sure that Qt is configured for dynamic linking (even though that’s usually the default option there’s no guarantee). We need to specify the -ltcg switch to turn on Link Time Code Generation. LTCG is off by default since, in combination with a statically built Qt, it will make linking very slow for any projects that use Qt. However, if we configure Qt for dynamic linking this won’t be an issue.
You can add or remove switches as desired (try configure help) but I find most of the defaults suitable. Sure, you may not need OpenGL (or SQL or Phonon or…) support right now, but it’s a separate module anyway and you’re already compiling the rest of Qt.
All you need to do now is run nmake…but wait.
Do you have a dual-core or quad-core processor or can take advantage of multi-threaded compilation? Get the jom tool instead. There’s some info about jom in this Qt Labs Blogs article. You can download the latest version of jom from ftp://ftp.qt.nokia.com/jom/ (jom.zip should be just fine).
Use jom by simply unzipping and running it in the same directory as configure (which is still the same as before, D:\Coding\Qt\2009.05\qt).
```
> jom
```
Happily build Qt much faster. For example, on my machine (a Core 2 Quad) it took an hour for the build to complete.
Unless you really enjoy manually handling custom build steps, don’t forget to get the Qt Visual Studio Add-In. After installing it make sure that it’s aware of the location of your Qt installation (Qt->Qt Options) and then use File->New->Project... and select one of the Qt templates to get started.

#include Guidelines

Mon, 22 Jun 2009 19:20 -0700

This is mostly for my own reference, but here are some of the guidelines I like to follow when it comes to #includes in C++. Given foo.cpp and foo.h:

foo.h should include everything it mentions and no more. For example, if you use boost::random in the implementation, don’t #include <boost/random.hpp> in foo.h.
foo.cpp should also include everything it mentions and no more.
foo.cpp’s first include should be #include "foo.h".
Precompiled headers, if used, should be specified in foo.cpp only and will need to be the first #include (#include "foo.h" will then be the second).
Except for the above two exceptions, the order I like to follow for #includes is:
1. Headers from your own project (generally of the form #include "baz.h")
2. Headers from non-standard libraries (such as Qt)
3. Standard libraries (I include Boost in here because I use it so pervasively)
4. Platform headers (like #include <windows.h>)
Within each of the above groups try to alphabetically order the #includes if at all possible.
Forward declare whenever you can get away with it.

The difference between Qt::Key_Enter and Qt::Key_Return

Wed, 10 Jun 2009 10:48 -0700

It’s specified in the documentation, though in a slightly subtle manner. Essentially, Qt::Key_Enter is the keypad Enter, while Qt::Key_Return is the “regular” Enter, the one which you normally use while typing.

Visual Studio 2010 sounds pretty neat so far

Tue, 09 Jun 2009 10:04 -0700

I’m a very big fan of the Visual Studio IDE (I think it’s the best around, for any platform). However, Microsoft has historically put less of a emphasis on the C++ portion and the past couple of versions have had only minor bullet points on the C++ side.

I think they’ve wizened up a bit and the next Visual C++, 2010, has some notable improvements in store (C++0x support, for one). They’ve also put a lot of work into completely reworking their C++ IntelliSense engine. There’s not much for me to say, really, as they have a great blog. I’ll just highlight some of the articles I found the most interesting, which coincidentally all focus on IntelliSense:

Qt: staticMetaObject is not a member of...

Fri, 29 May 2009 21:11 -0700

Just got this error message while compiling a tiny class that derives from QTreeWidgetItem:

error C2039: 'staticMetaObject' : is not a member of 'QTreeWidgetItem'

What this is saying is that QTreeWidgetItem does not inherit from QObject, meaning that your own, singly-inherited class also does not inherit from QObject. Inheriting from QObject is one of the prerequisites to using the Q_OBJECT macro, which, if you’re anything like me, you automatically insert into any Qt GUI related class.

If you’re not using any of the meta object stuff in your subclass, such as signals/slots or properties, just take out the Q_OBJECT macro. If you need to use signals and slots, you’ll need to make your subclass multiply-inherit from QObject as well. If you take this route, remember that “Multiple Inheritance Requires QObject to Be First”, otherwise you’ll get either the same error as above, or something along the lines of “YourClass inherits from two QObject subclasses” from the moc.

Captchas shouldn't be the default defense against bots

Thu, 21 May 2009 15:17 -0700

Captchas are useful to prevent bots or similarly automated activities from occurring. However, they’re not perfect and many of them can be broken with a targeted attack. In a sort of arms race fashion, captchas get more and more intricate, but some take this a bit too far and aren’t really even human solvable.

In any case, large sites have to have some way to separate bots from humans, and captchas may be the only solution. It’s still an arms race, but at least the large sites have the resources to throw at it.

What about the small sites? Your blog about your cat? Your forum for fellow gum-chewers? Do you really need (or want) a captcha for these types of sites? Unfortunately, what happens is a crawler stumbles upon your site, notices it uses some popular blog or forum application it knows about, and attempts to register so it can subsequently flood your site with spam. If you use a popular application, such as phpBB3 (for the sake of argument), once the generic, built-in captcha gets broken, all non-customized phpBB3 sites are vulnerable. So a spammer just needs to try to break this one particular captcha and suddenly they’ve unlocked the ability to spam millions of forums. It provides the volume that spammers need to make spam work.

What I suggest instead is that the default mode of operation for a forum (or any application, really) should be to ask a simple question upon registration, with both the answer and question provided by the person who is running the site:

Q: What is my cat’s name?
A: Fluffy

Q: Which of the following is a brand of gum? Oreos, Jellybeans, Trident, Snickers
A: Trident

Incidentally, yes/no type questions should be disallowed, as the answers (‘yes’ and ‘no’) would be common enough to automate.

Now, spamming your forum requires actual human intervention. Obviously this sort of approach will fail if you have a large or popular site, but if you own such a site you already know you have to take more steps to protect your site.

One potential problem is I could see lists of questions/answers being hand-generated and passed around, but this could be mitigated by expiring questions/answers after some time. If you’re feeling particularly clever you could even flag the old answer as being a ‘bot-answer’, which might work well in concert with an Akismet type service:

Q: How old is my cat?
A: Fluffy (hello, bot!)

Anyway, I feel that captchas are a bit of dead end in terms of anti-spam measures for small sites. Small sites are not typical targets for spammers, as the reward is not worth the effort. However, if all these small sites are protected by the same captcha, breaking that captcha gives that spammer access to (small-sites × millions), which is worth the effort.

More thoughts on Qt 4.5

Thu, 07 May 2009 16:35 -0700

I’ve been using Qt 4.5 for a couple more weeks now and I’ve had a few more thoughts on the framework.

I don’t know if I could handle using the plain Win32 API for GUI ever again
Even with Qt’s “parent handles the deletion of its children” memory management system it’s still easier to use (and reason about) shared_ptr or another smart pointer, as long as you’re not working with widgets or similar GUI elements. If you’re working with GUI elements, Qt’s memory management works perfectly and makes sense.
You can assume that any addWidget()-like function will take ownership unless explicitly stated otherwise. I still wish they would just say straight out that “this function takes ownership”.
In my opinion the documentation would be much improved for newcomers if they had a “Qt Best Practices” section. You can get a sense of how things should be structured if you look at their sample programs, but there’s a lot to go through.
Other than those two nitpicks, the documentation is consistently quite good.
I would suggest that you avoid using the Qt containers and instead favor the standard C++ containers whenever possible. There’s less to learn, and most C++ programmers will have a firm grasp of the containers in the std namespace. Some Qt functions do return QStringList or some other Qt container, in which case you may as well just leave it in the container you get it in.
On the other hand, if you’re going to use Qt, you may as well use QString everywhere. It’s used extensively through the Qt framework, so you won’t be able to avoid it. It’s a pretty decent string library anyway, with plenty of useful functions, and it handles Unicode cleanly in my experience.
QTextEdit isn’t particularly performant, particularly when you resize it and it has to perform lots of word wrap calculations. Use QPlainTextEdit if you can.

A really quick boost::random guide

Wed, 06 May 2009 20:03 -0700

This is a really short and quick guide on how to use boost::random. The best place to start is, as always, the documentation, but Boost also provides a simple sample program that covers the library in a good “how to get started” fashion.

What I’m about to write here is even shorter and less detailed – it’s just the basic code needed to generate some random numbers.

// Initialize a random number generator.
// Boost provides a bunch of these, note that some of them are not meant
// for direct user usage and you should instead use a specialization (for 
// example, don't use linear_congruential and use minstd_rand or 
// minstd_rand0 instead)

// This constructor seeds the generator with the current time.
// As mentioned in Boost's sample program, time(0) is not a great seed,
// but you can probably get away with it for most situations.
// Consider using more precise timers such as gettimeofday on *nix or
// GetTickCount/timeGetTime/QueryPerformanceCounter on Windows.
boost::mt19937 randGen(std::time(0));

// Now we set up a distribution. Boost provides a bunch of these as well.
// This is the preferred way to generate numbers in a certain range.
// In this example we initialize a uniform distribution between 0 and the max
// value that an unsigned char can hold (255 for most architectures)
boost::uniform_int<> uInt8Dist(0, std::numeric_limits<unsigned char>::max());

// Finally, declare a variate_generator which maps the random number
// generator and the distribution together. This variate_generator
// is usable like a function call.
boost::variate_generator< boost::mt19937&, boost::uniform_int<> > 
    GetRand(randGen, uInt8Dist);

// Generate a random number
int aRandomNumber = GetRand();

Namespaces are one honking great idea

Wed, 29 Apr 2009 09:17 -0700

The title of this post comes from the last line of The Zen of Python.

It applies to C++ too: namespaces are great. Namespaces let the Boost folks contain all sorts of widely varying libraries without having to worry about naming collisions in user code. Namespaces let you mix multiple libraries easily and safely. Namespaces let you group sets of related free functions together, without needing a class. Namespaces also let you work around one thing I’ve always found a bit unusual with enums: the way they don’t have their own scope.

enum ValidValues
{
    Value1,
    Value2
};

This ends up declaring Value1 and Value2 in the underlying scope. What I like to do is wrap the enum in a namespace:

namespace ValidValues
{
    enum Enum
    {
        Value1,
        Value2
    };
}

This sticks Value1 and Value2 in the ValidValues namespace. The only disadvantage is declaring a variable of this enum type gets a bit silly and inconsistent. For example:

ValidValues var = Value1; // error, ValidValues is a namespace, Value1 is undefined
ValidValues::Enum var = Value1; // error, Value1 is undefined
ValidValues::Enum var = ValidValues::Value1; // okay

This is yet another area where C++0x will offer its own solution, in this case, strongly typed enumerations.

Right aligning a button in a QToolBar

Thu, 23 Apr 2009 08:32 -0700

Sometimes you will want to add a right-aligned button to a QToolBar. The first thing that probably comes to mind is to add a QSpacerItem to the toolbar, but that won’t work as QSpacerItem is not a child of QWidget, so you can’t use the addWidget() member of QToolBar. Instead, make a basic QWidget, set its sizePolicy to Expanding, and add that widget to your QToolBar. For example:

QWidget* spacer = new QWidget();
spacer->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
// toolBar is a pointer to an existing toolbar
toolBar->addWidget(spacer);
toolBar->addAction("Right-aligned button");

If you end up using a lot of these spacers you could even create a subclass.

Qt 4.5

Mon, 20 Apr 2009 09:16 -0700

Qt is a well known cross platform framework. It’s probably most well known as the framework on which KDE is written.

Anyway, over the weekend I experimented with it a bit, and in terms of C++ GUI development it’s a breath of fresh air. It approaches the ease of use of the .net GUI facilities, which is great for a language with no built in introspection abilities. The “moc” preprocessor that Qt requires (that lets them do things such as signals and slots) you to run on your source files is still a bit weird, but it’s really not as bad as it seems.

The Qt framework is also impressively comprehensive, making it very easy to code applications directly against Qt, instead of coding against a particular OS or a particular compiler.

The style of the framework itself is more traditional than the common notion of modern C++, having more of an emphasis on subclassing and overriding virtual functions than on generic algorithms. The memory management system is definitely foreign: they encourage you to allocate on the heap, yet there are very few delete statements. The way it works is that QObjects (Qt’s base class) accept a pointer to a parent in their constructor, which makes that particular QObject a child of the parent. When the parent is deleted, it takes care of deleting all its children. It’s a change from RAII, for sure.

It also takes a couple of hours to compile Visual Studio compatible versions of the various components, so don’t do it as a last minute thing.

Porting a Winsock application to Linux...select(2) is not as simple as MSDN makes it seem

Fri, 10 Apr 2009 17:54 -0700

I’m in the middle of porting bits of a Winsock application to Linux. Luckily when I first wrote the networking bits I had made an effort to write it in a somewhat cross platform manner. As a result, I stuck to select(), send(), recv(), and all the other function calls that Winsock provides that are close to the Berkeley socket interface. Things go pretty smoothly, although for some reason there’s this really weird pause when connecting that didn’t exist before…

Finally I hit a point where, for some reason, I couldn’t establish a connection to the server and it just times out. That’s really strange, so I threw good old debug statements all over the place and find out that this select() call is not doing much of a select:

if (select(0, &rdset, &wtset, &errset, &tv) > 0)

Notice the 0? MSDN states that it is:

nfds
Ignored. The nfds parameter is included only for compatibility with Berkeley sockets.

Then I check the equivalent docs on the Linux side of things:

nfds is the highest-numbered file descriptor in any of the three sets, plus 1.

Well, if I set nfds to 0, select() won’t be doing very much selecting! Windows has FD_SETSIZE at 64 by default, and it ignores nfds and just checks whatever descriptors are in the fd_sets that you pass to it. Linux considers sockets and files the same thing, and thus has a much higher FD_SETSIZE (1024 and 4096 seem to be common). You don’t want select() checking 4096 descriptors, so you set nfds to the highest file descriptor you want it to check, plus one. (As an aside, setting nfds to FD_SETSIZE is a bad idea.)

if (select(my_socket + 1, &rdset, &wtset, &errset, &tv) > 0)

Where my_socket is an appropriate file descriptor (such as the one returned by socket()). This works just fine in Windows too, since it ignores the nfds parameter.

Armed with this newfound knowledge, I go and fix all the other select() statements in my code, which ends up fixing the weird pause as well. Effectively, without a proper nfds value, select() just acts as a timer and blocks until the specified amount of time has elapsed.

All AJAX sites need a fancy indeterminate progress indicator...

Sun, 05 Apr 2009 20:22 -0700

Ajaxload is a neat little site that generates those throbbers/spinning wheels that are in vogue nowadays. Your website/application won’t be complete without one, after all.

PNG has a well designed magic number (or FourCC)

Fri, 03 Apr 2009 17:20 -0700

Even with all the XML floating around, binary formats still have their place. It’s good practice to place an identifier at the beginning of the binary file, so that the file type can be determined even in the absence of a proper file extension.

The simplest route to take is to just stuff some plain text there:

[M Y F I L E][rest of file]

However, consider following the design of the PNG magic number, described in detail in the PNG book. With some really neat design they are able to quickly detect some common forms of corruption caused by an incompatible transfer mechanism. In that case your identifier may look like:

[\211 M Y F I L E \r \n \032 \n][rest of file]

With an identifier like this many common forms of transfer corruption can be quickly identified, and you can spit out a simple “corrupt file” message instead of trying to read a broken file.

Don't forget about copy constructors and the copy assignment operator

Fri, 03 Apr 2009 12:30 -0700

Something that I’ve always found handy to do is to decide, right away, what the copy semantics of a particular class are. Generally it turns out that it makes no sense (or is a lot of work) to allow copying, in which case the standard approach is to define the copy constructor and assignment operator as private.

An alternative approach and one that I think is a bit more self-documenting, is to inherit from boost::noncopyable. This achieves the same effect and makes it immediately obvious that the class will not allow copying.

class MyClass : boost::noncopyable { };

The most correct way to use boost::noncopyable is to inherit it privately, since inheriting it publicly could let people do really funny stuff like:

void stuff(const boost::noncopyable& obj);

(more details here)

A RapidXML gotcha

Thu, 26 Mar 2009 13:00 -0700

I just spent a couple of hours trying to track down why I was seemingly losing data values while modifying nodes in the DOM. It’s spelled out in the documentation, but it definitely threw me for a loop (I would consider this behavior surprising). Basically, RapidXML gives you the ability to assign/modify the value of a node and it also likes to create data nodes when you parse a document. When printing, the data node takes precedence over the value.

When you create a document from scratch this likely won’t bite you, but when you parse an existing document and neglect to supply the parse_no_data_nodes flag, the parser creates data nodes. If you try to update your values with the value() function, it works just fine (and you can even pull it back out without any problems), but when you use the print() function, the data node (which you haven’t updated) will show up instead.

What made this even more difficult to track down was how value() will return the first data node it finds if there isn’t a value yet, so it really does seem like you have a value already. I’ve updated my prior RapidXML entry to include the parse_no_data_nodes flag, which may save someone some time down the road.

shared_ptr is great...but sometimes auto_ptr is actually better!

Sat, 21 Mar 2009 18:04 -0700

Modern C++ programming benefits greatly from smart pointers. Smart pointers automate the error-prone process of making sure you have a matching number of new and delete statements. There’s even one included in the C++ standard library: std::auto_ptr.

It’s not a true general purpose smart pointer, however. For one, it has somewhat unusual transfer-of-ownership semantics:

std::auto_ptr<MyClass> a(new MyClass());
std::auto_ptr<MyClass> b = a;
// a now points to nothing!

This also makes it dangerous to use in containers, as described in Using auto_ptr Effectively. On the other hand, shared_ptr (which will be available in the next C++ standard, C++0x, and is now available in the Boost libraries) is a reference counting smart pointer. It keeps track of the number of references to a particular object, and when there are no more references, it deletes the object. This is safe to use in containers. In fact, you can use shared_ptr pretty much everywhere and you will never have to worry about manually releasing memory again (cycles and threading are pretty much the only major problems).

However, while shared_ptr is a great general purpose smart pointer, auto_ptr has its uses. If you have a function that involves transfer-of-ownership semantics (whether receiving or giving), why not use the smart pointer that perfectly captures those requirements? The ‘sources’ (creates and then gives away ownership) and ‘sinks’ (takes ownership) described in the Using auto_ptr Effectively article is a prime example of this. Instead of using comments to specify that the caller of a function must manage the lifetime of the returned object, auto_ptr forces them to manage it (and if they don’t, it’ll clean itself up anyway). shared_ptr will likely work just as well, but it doesn’t capture the semantics.

Another noteworthy reason to use auto_ptr when the semantics are suitable is that while auto_ptr can give away ownership to shared_ptr, shared_ptr cannot give away ownership to auto_ptr or another smart pointer (there is no release() function in shared_ptr).

auto_ptr is on its way to deprecation, but we haven’t even seen C++0x yet, so I wouldn’t worry too much about it. Its replacement, unique_ptr, will have the same transfer-of-ownership semantics, just implemented in a much safer way, so it’d be worth the effort to get used to using the right smart pointer for the job.

Speaking of which, do you know what scoped_ptr is?

Don't spend time micromanaging optimization options in Visual C++

Sat, 14 Mar 2009 14:37 -0700

It’s surprisingly common to see people ask what the best Visual C++ optimization options are for their C++ code.

The best answer is to profile and benchmark.

Failing that, it’s pretty simple. Use /O2 to optimize for speed, and /O1 to optimize for size. That’s (almost) it. If you have a large program you will probably benefit more from optimizing for size:

Generally speaking, small applications should be compiled with /O2, and large applications should be compiled with /O1 because very large applications can end up putting a lot of stress on the instruction cache of the processor, and this can lead to worse performance. To minimize this, use /O1 to reduce the amount of “code bloat” introduced by the optimizer from certain transformations such a loop unrolling or selection of larger, faster sequences of code. [MSDN]

But what about Enable Intrinsic Functions (/Oi), Omit Frame Pointers (/Oy), etc.?

Check out the documentation for /O2 and /O1:

/O1 (Minimize Size) : Equivalent to /Og /Os /Oy /Ob2 /Gs /GF /Gy
/O2 (Maximize Speed) : Equivalent to /Og /Oi /Ot /Oy /Ob2 /Gs /GF /Gy

They are already all specified. Yes, the property pages say Disabled or No, but what they really mean is Default.

The only general optimization I’m aware of that doesn’t fall in this category is Whole Program Optimization (/GL), which also requires Link Time Code Generation (/LTCG).

Finally, what about Full Optimization (/Ox)?

In general, /O2 should be preferred over /Ox and /O1 over /Oxs. [MSDN]

[Edit: Note that there is an IDE bug in Visual Studio 2008 which may affect whether or not optimizations are applied. I write more about it here.]

Several compilation options I use with C++ projects in Visual Studio

Thu, 12 Mar 2009 16:39 -0700

These are compilation options that I typically enable for any C++ projects in Visual Studio. They should go in the project’s property settings, under Configuration Properties→C/C++→Command Line, in the Additional options textbox. They are listed here exactly as they should be entered in that box (equal signs and all).

/MP : This enables multi-process compilation, which can provide a significant speed boost on the multi-core processor you likely have in your development (or build) machine. As the MSDN documentation states, it is not compatible with the Enable Minimal Rebuild option, which, depending on the situation, may negate any performance advantage this switch has. Disabling minimal rebuild is not as bad as it sounds¹ and in my projects I’ve found that using /MP confers a significant improvement in compilation time. You definitely want to enable it for Release builds, at least. Reference.
/D_CRT_SECURE_NO_WARNINGS : This switch disables the warnings that Visual Studio spits out if you use any of the C RunTime functions that Microsoft has provided secure replacements for (such as strncpy). This isn’t necessarily a bad idea, but their safe functions are not part of the standard and are thus non-portable. Reference.
/D_SCL_SECURE_NO_WARNINGS : Just like the switch above, only for the Standard C++ Library (anything in the std namespace). Reference.
/D_SECURE_SCL=0 : Disables checked iterators. Disabling this feature can improve performance when using iterators, at the expense of less protection against unsafe iterator use. Generally there isn’t too much of a performance difference (a Visual C++ lead states that they measured about a 6% difference in this feedback / bug page) so it may be worth leaving it on most of the time. Reference.

Note that /D_CRT_SECURE_NO_WARNINGS and /D_SCL_SECURE_NO_WARNINGS are /D_CRT_SECURE_NO_DEPRECATE and /D_SCL_SECURE_NO_DEPRECATE, respectively, in versions prior to Visual Studio 2008.

Disabling Minimal Rebuild does not mean that the whole project gets rebuilt every time, just that Visual Studio uses a “was this .cpp/.h modified?” approach instead of trying to determine if the exact changes you made warrant a recompile. ↩

Stop wasting time stepping into functions you don't care about in Microsoft Visual Studio (C++)

Mon, 09 Mar 2009 17:58 -0700

The Visual Studio debugger is amazingly useful. However, you soon learn to sigh the moment you come into contact with something like this:

boost::scoped_ptr<Startup> dlg(
    new Startup(settings->GetWindowPosition()));

You want to step into the Startup constructor, but there is a lot of stuff in your way.

First you will step into shared_ptr::operator-> (did I mention that settings was a shared_ptr?).
Then you will step into GetWindowPosition().
Then into operator new.
And then into your Startup constructor. Yes!
And finally you’ll finish with the scoped_ptr constructor if you so choose.

If you’ve done this a lot you’ve probably gotten really good at the Step Out shortcut (Shift-F11).

Well, here are two alternatives!

First, while program execution is paused, right-click anywhere in the source window and look for the Step Into Specific item. You can select any of these functions to instantly step inside.

Alternatively, there is a special undocumented (and unsupported) registry key that you can use to specify functions that you always want to skip. Navigate to HKLM\SOFTWARE\Microsoft\VisualStudio\9.0\NativeDE\StepOver (users of a 64-bit variant of Windows will want to check HKLM\SOFTWARE\Wow6432Node\Microsoft\... instead) and add some string values like this example:

Name: 50 (priority, higher values have greater priority)
Value: std\:\:.*=NoStepInto

Name: 60
Value: operator new=NoStepInto

Name: 70
Value: boost\:\:.*=NoStepInto

The backslashes are necessary because : (colon) is a special character in Visual Studio regex. You sometimes see two backslashes used in other examples, this is only necessary if you are directly editing a .reg file (which I don’t recommend). These rules will adjust the behaviour of the Step-Into command and make it skip anything from the std or boost namespaces, as well as the basic operator new. It will still step into an overloaded operator new, so don’t fear. There are more details on this blog post, as well as microsoft.public.vsnet.debugging.

One more thing: you can combine these two approaches. Say that you’ve added a skip for the entire boost namespace, but you decide you really want to take a peek inside one particular line and see exactly what is happening to your parameters. Pause execution on that line, and then right-click and use Step Into Specific. This is still the same list as before and it works the same as before, regardless of any NoStepInto rules.

rwb_question, a FluxBB Captcha-Question extension

Thu, 05 Mar 2009 15:16 -0700

Here’s a quick little extension I wrote for the FluxBB forums. It lets you ask a simple question to the user which they must answer correctly in order to register. I find this sort of anti-spam solution more than enough for low traffic forums, and somewhat paradoxically more effective than a standard image based CAPTCHA (for small forums).

This extension is for FluxBB v1.3-r718 and has not been tested on any other version of FluxBB. I imagine with a little modification it’d work with PunBB as well, but that hasn’t been tested. Install this extension by extracting it to your /extensions folder, and then activate it through the admin control panel.

Download rwb_question here.

Boost.Thread triggers warning C4103 in Microsoft Visual Studio

Mon, 02 Mar 2009 17:28 -0700

Got a whole mess of warnings when I moved some of my includes around, particularly this one: #include <boost/thread.hpp>

abi_prefix.hpp(19) : warning C4103: 
'd:\boost\boost_1_38_0\boost\config\abi_prefix.hpp' : 
alignment changed after including header, may be due to missing 
#pragma pack(pop)

Some experimentation reveals that including thread.hpp before winsock2.h triggers all these warnings. The simple solution is to just move #include <boost/thread.hpp> down below #include <winsock2.h>.

Building Boost (now with dual/quad/multi-core action!)

Mon, 02 Mar 2009 16:27 -0700

Update: More recent versions of Boost (1.39.0 and later) have a simpler build process, which I’ve written about here.

Steps to build the non-header-only Boost libraries on Windows, such as Boost.Thread and Boost.Regex, using Microsoft Visual Studio:

Download the latest version of Boost and extract it to some location, say, D:\Boost\, making sure to maintain the directory structure
Download the latest version of Boost Jam (you want the ntx86 binaries) and extract it to some location (probably the same as above), again making sure to maintain the directory structure
Your directory structure should now consist of D:\Boost\boost_1_38_0\ and D:\Boost\boost-jam-3.1.17-1-ntx86\
Make sure you have lots of hard drive space (at least 5GB)
In a command prompt, navigate to your Boost library folder (D:\Boost\boost_1_38_0\) and then use this command (read further down if you want details about what these arguments are doing):
```
> ..\boost-jam-3.1.17-1-ntx86\bjam.exe --toolset=msvc --build-type=complete stage
```
If you have a dual/quad/many-core processor or can otherwise take advantage of parallel jobs, also add the -jN switch, where N is the number of jobs to run at a time (e.g. bjam.exe -j4 --toolset=msvc).
And wait. This will take a very long time.
After it completes you will have a stage subdirectory (D:\Boost\boost_1_38_0\stage\) which will contain a lib subdirectory, containing the compiled libraries. You may move these anywhere you wish.
You will also have a bin.v2 subdirectory which was used for temporary files. You may delete this folder to reclaim some hard drive space.

More details:

--toolset=msvc : tells Boost Jam to compile with Microsoft Visual Studio.

--build-type=complete : notes that you want every possible combination built (Debug/Release, Multi/Single threaded, Static/Shared).

stage : a build target which builds the compiled libraries to the stage directory (which you can set with --stagedir=<STAGEDIR>). Contrast this with the install target, which builds the compiled libraries, but also copies the header-only libraries to a particular location. This is generally an unnecessary step since you’ve already extracted the Boost headers somewhere already. Look inside the Jamroot file inside your Boost folder for more details.