I gave a presentation at work about Boost.Asio, and it came out reasonably well, so I figured I would post the slides here. Its a brief introduction to Asio and what one might use it for. Also has some basic concepts and patterns one might use while programming with Asio. Aimed for a technical audience, but nothing too detailed though.

Boost.Asio Tech Talk Slides (PDF)

This is just a random note that I’ve actually known for quite awhile, but I figured I would post it online somewhere where others could find it. Apparently Microsoft made a disk editor thing called ‘Disk Probe’, which came in the NT Resource Kit. I had found it available to download standalone a really long time ago, but it doesn’t appear to be available anymore. However, you can find it in the Windows XP Service Pack 2 Support Tools available from Microsoft’s download website.

Its a bit weird (at least, the NT version was), but its pretty useful if you ever find yourself playing with raw disks and you need to access them from inside windows in a pinch.

I’m taking a workshop at work taught by David Abrahams, and he briefly mentioned this thing called XSMELL, which apparently allows you to write XML-like things in pure C++ code. From the README:

Congratulations! You have in your hands the MOST BRILLIANTEST C++ XML CREATION
LIBRARY EVER CREATED.

...

And you no longer have to worry about generating malformed XML! After spending
hours fighting obscure C++ compiler errors, you’ll be 100% certain that your
XML is correct.

Definitely amusing. 🙂

I’ve always been a fan of PuTTY, the Windows terminal emulator. Its extremely simple to use and is one of the main reasons I like using windows to maintain linux systems. One of the biggest things I like about PuTTY is that it allows you to copy on highlight, and paste into the window by right clicking. It saves so much time and is really easy to use.

So when I moved my desktop to Ubuntu this summer and got rid of XP, this has really been one thing that I really miss. However, I just found a blog post that explains copy/paste in X, and that a similar system actually exists system-wide, except it uses the ‘middle’ mouse button instead.

Seriously, this is an awesome feature that I did not know about, and definitely am going to take advantage of. Now I just need to remap one of the extra buttons on my mouse to be the middle one so its more convenient to use…

The FIRST Robotics Competition is using the National Instruments cRio platform for the robot controller this year, and the operating system on it is vxWorks 6.3. After we participated in the competition, I had gotten a great idea involving putting a webserver on the robot so that it would be easier to tune various parameters on the robot (which I will be releasing soon).

I decided to use Boost::Asio for the networking layer since I had been meaning to write something using it for awhile anyways, and since its portable I could do the initial development on my home computer and then easily (at least, ideally) transfer it to another platform. I also decided to use Boost::Thread for the same reason. If you haven’t used Boost before, I highly recommend it — it has a lot of well-written and useful C++ header-only libraries.

Unfortunately, vxWorks is a bit different than ‘standard’ POSIX/*nix systems, so there are a number of patches one needs to make to Boost 1.38.0 in order to compile. I’ve submitted the patches to boost, so hopefully by the time 1.39.0 rolls around you won’t need this. 🙂

You can download the full patchset needed from my FRC resources page. Download it.

I’ve also posted bugs on the Boost Trac site: #2917, #2953, #2955, #2956, #2957, #2958, and #2959

So, while working on the Kwarqs robotics code, I found a useful solution to implementing the singleton pattern in c++ that I believe avoids the static initialization fiasco (with a small restriction) *and* doesn’t leak memory.

What I’ve created is a template class that takes a pointer to a pointer at construction, and deletes the pointer as it is getting destructed. While you cannot guarantee when the class is created due to static initialization issues, from what I can see the C++ standard does guarantee that all intrinsics are initialized before other items are constructed. By using a pointer to a pointer, we can guarantee that the location of the object will be the same (and thus destruction will happen correctly), and provided we initialize the static variable to NULL we can also guarantee that initialization will happen correctly.

Warning: A key assumption made by this class is that the static object is only accessed during the normal scope of the program — ie, the object that this class contains a pointer to a pointer to should not be accessed by anything that could be called after main() is complete. For some code bases, this can be very tricky to enforce.

Usage of the class is quite trivial:

SomeType * SomeType::m_instance = NULL;
StaticDeleter someTypeDeleter(&m_instance);

// example singleton initialization
SomeType * SomeType::GetInstance()
{
	if (SomeType::m_instance == NULL)
		SomeType::m_instance = new SomeType();
	return SomeType::m_instance;
}

And the implementation of the static deleter is also quite trivial (but I’ve provided a downloadable version as well), check it out:

// (C) 2009 Dustin Spicuzza, released under modified BSD license

template 
class StaticDeleter {
public:

    StaticDeleter(TypeToDelete ** ptr2ptr) :
        m_ptr2ptr(ptr2ptr)
    {}

    ~StaticDeleter()
    {
        if (*m_ptr2ptr)
            delete *m_ptr2ptr;
    }

private:
    TypeToDelete ** m_ptr2ptr;
};

Download it now