Oh wait, the demise part hasn’t happened yet… right?

For those of you who don’t know me (why the @(*$*@ are you reading my blog?), you might not know that I’ve grown a strong distaste for social networking as of late. I deleted my Facebook page a long time ago. I absolutely refused to ever get a MySpace page. I don’t follow anyone on twitter, nor do I tweet.

I judge a person’s worth on a scale that’s a direct inverse of the number of Facebook friends they have. Seriously, the only people I’ve ever met that have ridiculous amounts of social networking “friends” are always the ones that are completely clueless as to how much people hate them.

I don’t want to learn something about you through a Facebook update. Nor do I want people learning stuff about me through someone else’s “at a glance” updates page. No I didn’t read your blog, and no I’m not going to. If you’d like to talk to me, go old school: write me an email, or a letter, or pick up the telegraph machine and dial my number. Or, go new school and VOIP / webcam me. I’ll be doing the same.

Of course, the hypocrisy of writing this in blog form is not lost on me. I guess I just felt like I owed it to myself and the rest of the internet to make this post.

Communication technology is supposed to bring us closer together. Despite what certain controlling bodies may want, it’s meant to enable us, the commoners, to have a voice. It’s meant to redistribute the true power that comes along with knowledge to the people.

Social networking doesn’t bring us closer together, it keeps us from really communicating. It’s the new opiate for the masses. Because mind-numbing passive entertainment is no longer enough. We need to be watching television and checking status updates on our smart phones simultaneously.

Does anyone out there really feel more connected or enabled now?

Yeah? Let me guess, you have 600 Facebook friends don’t you?

I’m not saying that I think these new communication technologies we’ve built are worthless. I think using twitter to help fight fires is both innovative, and completely stupid — but hey, if it works, why not? Looking to make new business or research connections? Yeah that makes sense. Obsessively pouring the details of your mundane bullshit life into a server on the internet so your equally as boring and mundane friends, and their friends, can know about the minutia of your life? Lame.

It’s truly odd to me. I spent my youth practically growing up inside a computer. I had a computer life, and a real life… not because I didn’t want the worlds to collide, but because they couldn’t. No one else I knew was jacked in. And I loved it… I loved spending hours hanging out with “friends” on IRC, and causing mischief. It was an exciting time of discovery… I remember the first MP3 player (the 16-bit reference player from the Fraunhofer Society), the first JPEGs, dear god the first animated GIFs. It was a playground filled with cool people, doing interesting things.

Now it’s a bunch of douchey idiots using the technology that we once used to exchange information and “subvert the global suppression!” (AKA HACK THE PLANET!) (we were young okay), to talk about what they did last night, and what cute things their cats do. Let’s not forget the old jaded people who do nothing but rant (ahem).

Don’t get me wrong, I still love the internet. It’s grown into something I never would have imagined. It really is what I had hoped it would become, more so. It really can connect us all — hell I frequently use it to talk to a close friend who lives in Ireland. Pen and paper has nothing on Skype! It really does keep power in the hands of the people. Sort of. If you want to know the truth you can actually find it. Of course, the surface is still nothing but brainwashing and media hype. We can’t win them all I guess.

Anyway, as I was saying… it’s truly a weird thing for me. To think about turning off my internet presence. It’s something I’ve been doing for over half my life. I’m not a researcher, but I still consider myself a computer scientist at heart. Part of me just feels weird about what seems like going backward. I feel a bit like a religious zealot or some other crazy person… like I should be shunned or locked up or something.

But, nevertheless, here I am. Going Dark.

I encourage everyone to do the same: disconnect from social media, and connect to people… real people.

Do something real… go outside. Talk to someone. Pick up the phone. Hug someone. Make love to your spouse. Go to a bar. Walk the dog. Pet your cat. Do anything… anything but waste your time on Facebook. Hell, even watch TV… at least with TV there’s no pretending that you’re not alone.

Good-bye no one. Hello life.

p.s. Look for my new project: goingdark.org, coming soon! A site where people who don’t like social networking can go to meet other people who don’t like social networking. .

So here’s my quick review: it’s about as quiet as a baby seal being clubbed to death. No joke, it makes a loud screaming noise when the churning gets tough. Eerie. It takes up a lot of counter space, and it’s not the most aesthetically pleasing device, nor is it the most well made. The freezing unit looks pretty solid, but the motor arm, and mixing paddle are made from plastic. That said the only other device I’d consider purchasing, the Lello Musso Lussino Ice Cream Maker 4080, costs significantly more than the Cuisinart. When this one burns out I’ll probably replace it with the Lello though.

Having said all that, I would, without hesitation, recommend the 50BCC to anyone. There’s a markedly clear division in my life: there’s my life as it was prior to owning an ice cream maker, and there’s my life as it is now. It’s hard to describe what it’s like, but the best I can come up with is this: it’s like having a garden, only instead of the garden being made of dirt it’s a metal cube, and instead of growing plants, the end result is a sweet, creamy, cold, nectar of the gods, set to the tune of whatever your brain and tastebuds can come up with. Honestly now I look at every ingredient and wonder about its suitability for inclusion into an ice cream. Pickles: considered it, rejected it. Cayenne pepper: considered it, have a plan for it. Peas: considered it, unsure about it.

And similar to having a garden, with each mouthful of god nectar you can smile in the smug satisfaction of being able to stick some xantham gum up the ass of some douchebag corporate foodie in one of the many tiny pointless towns called Exploitedville, USA. Go ahead, club a baby seal. Not only will you not hear it because your 50BCC will be screaming like a banshee, but you’ll have plenty of good food karma to spare. I wonder: baby seal ice cream? Wrong, just wrong.

Have you ever taken a close look at what happens when grocery store ice cream melts? Have you ever wondered why ice cream from the store is kind of “fluffy?” Let me assure you that the weird liquid separation you see when it melts, and the fluffy texture are in no way natural. Modern ice cream barely qualifies as ice cream at all. In fact, most commercial ice creams are solidified through the use of various viscous compounds. The most common is Xantham gum, which if produced in North America, is almost certainly derived from corn. Even “all natural” ice creams will often include guar gum, or “natural tara gum”. Yes tara gum is made from a plant, but no it’s not natural. It’s also used for killing insects and in creating leather for furniture. So when buying ice cream it’s your choice: corn or insect free leather. Mmmm… tasty couch!

The only exception I’ve been able to find is good ‘ol Häagen-Dazs. The downfall to the Dazs, as I can attest to, is it comes in small packages and is quite expensive. Not only that but the flavor selection is a bit limited.

And, now that I have an ice cream maker, I can say that Dazs isn’t even that good. Even some of my “failed” creations are leaps and bounds ahead of Dasz in terms of both texture, and flavor. Did you know that real French Vanilla ice cream is made with custard? I do now, because I’ve made it, and although it’s quite a bit different than the so called “French Vanilla” you can buy in the store, it’s also much, much, better. Seriously they put some egg ingredients in there, along with some yellow colouring, and call it French Vanilla.

I should also give a warning: I used to pretend this blog was mostly devoted to technology and computer science related topics, but likely for the next while it will be devoted mostly to ice cream recipes .

On that note I’ll end with a killer recipe I came up with today. I previously made a Peanut Butter and Banana ice cream, but today I made two batches, one of peanut butter, and another of banana. They both turned out awesome, but the PB was the star for me. Of course they compliment each other well. But anyway, here’s the Peanut Butter:

Ingredients:

1/4 to 1/2 cup Peanut Butter to taste (choose your favorite kind, I used a creamy variety because I like creamy ice cream)
1 cup heavy cream
1 cup table cream
1 cup whole milk
1/2 cup organic granulated sugar

Directions:

Put the sugar, peanut butter, and milk in a sauce pan and slowly heat the mixture until the peanut butter is dissolved. Transfer it to a mixing bowl and whisk it until the sugar is dissolved (if it isn’t already), put it in the freezer and wait for it to be cold again. Mix in the creams, and you’re good to go!

The hardest part is getting the PB ratio correct. The taste changes a bit during the freezing process, it gets a little less potent, so keep that in mind. I started with ~1/4 cup but when I added in the creams I realized it wasn’t going to have the punch I wanted, so I added in another few spoon fulls. I was too lazy to reheat the mixture, so the newly added PB gave the ice cream some interesting flaky bits which I actually kind of like. I might make it like that on purpose again next time.

Since I know for a fact that Abrams is not stupid that rules out #1 which, sadly, leaves us to contemplate the notion that the entire six seasons of Lost really was nothing more than a joke on millions of people. It makes a great deal of sense, and it was an interesting ride, but it was clearly falling apart at the seams by the end: the numbers that dominated the first two seasons were explained by the single sentence “Jacob liked numbers?” Really? The whole time travel and moving island plot arcs were completely inconsequential and meaningless. Again… really? The statues? Dharma Initiative experiments… all pointless.

And, the best, the whole point and cause of everything: the light inside the island. It’s a transparent plot device that was whipped up and inserted in the final portion of the final season which was meant to explain the unexplainable. But, it’s a complete fallacy, you can’t explain unexplained phenomena with something else that never gets explained.

It would be easy to continue ad nauseam, but since I promised this wouldn’t be just another complaint thread, I’ll stop there. My point is, Lost was a joke. A cruel, but very profitable joke, on those of us who thought perhaps there really was a plan, and kept watching in anticipation of learning how all the puzzle pieces fit together.

It’s been about a week now since I watched the final episode, and it’s had some time to sink in. At first I was just like “well… that sucked.” But, the more I thought about it the more I realized that I actually consider Lost a fairly big injustice. Most will shrug it off, but it’s becoming a trend. I never thought the Battlestar ending could be usurped as far as disappointing show enders go, but sure enough, Lost did it.

So here’s my question to J.J. Abrams: why should I invest hours watching any more of your shows? Sometimes I’m able to avoid certain products simply out of some moral or ethical principle, but in this case it’s much easier. I’ve actually been soured against network television. I used to enjoy watching Fringe (another Abrams show), and now there’s no way I can stomache it. It’s as if Lost was the entertainment equivalent of food poisoning for me.

Fortunately not all television shows have gone the way of Lost. Legend of the Seeker is probably my favorite currently airing TV show right now. Yeah it seems a bit lame on the surface… it’s kind of cheezy, but the storyline is excellent. It’s based on a series of novels by Terry Goodkind, so unless they are completely inept, I can’t see how they could screw it up.

That said, I’m definitely going to be a much more cautious about investing that much time in a TV show again. Even without commercials, all six seasons of lost amounts to 84 hours of time. When these types of shows pop up again I think I’m going to wait on the sidelines until the show is done and then watch it via whatever media delivery / storage mechanism is popular at the time.

Perhaps I’ll go back to reading books for a while. They’re not guaranteed to be any better, but at least they don’t cram ads down my throat, nor do they typically make me want to burn them after I’ve finished reading them.

Although that’s big news for me, it’s not actually the point of this post. As it happened, I ended up having a bit of time off between when I left my old job and when I start the new job. It wasn’t enough time to go anywhere, so I thought I’d park myself on the couch (or in my chair) and play through a game from start to finish in a few epic marathon sessions. It’s not something I’ve been able to do in… a decade or two?

So, my first task was to find a game I actually wanted to play. This was no small feat in and of itself. Honestly, most games these days are regurgitated garbage, and amount to little more than Doom clones, or a clone of some other high popular game from a time when people were actually creative.

As an aside, I should say, this is partly why I like the casual game scene so much these days, especially on the iPhone. People are doing a lot of inventive things in that space, but the problem is very few of the casual titles have the gameplay depth (or length) that you find from a AAA release. I wanted something much heftier… plus staring at an iPhone screen for more than a few hours bugs my eyes out.

So, I tried everything I could think of. I looked at all the current new releases, I resubscribed to Eve Online, I picked up the Humble Indie Bundle, I looked through countless old game lists. I kind of wanted to pick up a new MMO, but honestly, as much as I love the idea of an MMO, I simply have yet to find one with the depth of gameplay of any of its non-MMO counterparts. Yes Eve Online is ridiculously deep and complex, but when it comes down to it, it’s still largely a grindfest, where you’re repeating the same tasks over and over again to accomplish some menial feat. Regardless of how complex the game rules are, the act of playing the game is really no different than any other MMO: go kill X of Y, travel from A to B to A, rinse, repeat.

Oddly enough, I’m actually a fan of loot whoring games, and grindfests that are the Diablo and rogue-like type games, so I often wonder what makes me enjoy those games but not MMOs. There’s a subtle distinction but in rogue-likes, the grind is not the purpose, nor a requirement. You’re simply exploring and the beasties you encounter are obstacles, the loot is a secondary (but important) reward. The push to keep going, for me, comes from discovering new and unique environments, and from some overarching goal such as killing a massively evil monster and saving the world.

After contemplating this stuff for a while, I decided it was time to go back to some old-school dungeon crawling, and ended up picking up a copy of Torchlight. It’s a shameless Diablo clone, but it is a fresh take on the genre. I won’t go into a review of it, since plenty of others have done that already, but I will say that it’s a great game. It’s got a unique graphical style, great level design, well thought out skill progression, is extremely mod-friendly, and addresses all of my complaints that I had with the Diablo series (mainly convenience issues).

Again though, this isn’t exactly the point of my post. After finding a game I wanted to play, I decided to see if I could get it work under Linux using Wine. The game has been given a “platinum” rating on Wine’s app database, which means it supposedly runs nearly perfectly. However, this simply isn’t the case. The game crashes on startup, and only works if it’s run in safe mode with a lot of the graphical niceties (like fragment shaders) turned off. Ultimate I ended up having to reboot into Windows to play it — a huge inconvenience .

So, to come full circle: I suppose the point of my post was related to my new job after all. The state of gaming on alternate platforms like Linux and Macintosh is definitely improving, but it’s simply not where it could and should be. I am really excited to be working for a company that’s working toward being a part of the solution.

Amsterdam is definitely a very cool and unique city! I’m extremely glad we were able to find Jess a last minute flight, and that the hotel didn’t mind her staying in my room (which was booked as a single). We had lots of fun exploring Amsterdam, taking in as much of its culture as we could (and were willing to). Amsterdam is definitely a place where whatever you want, is pretty much what you get, and we quickly learned that there’s lots of things Amsterdam has to offer that we weren’t that interested in .

That being said, those elements are part of what makes Amsterdam such a cool place, and I for one applaud them for their forward thinking on many subjects. I’ve personally never felt so safe amongst so many people, at all times of the day / night.

We checked out nearly every major area of the city, and although the hotel was right next to the insane touristy areas we quickly gravitated toward the quieter more local areas of Amsterdam. We tried to find as many local places to eat as we could, and mostly just soak in the atmosphere. It was neat to see some of the [in]famous parts of the city like all the coffee shops, and the red-light district, but I found once we left those areas I got a much greater sense for the city, and I began to understand why people would live there.

I didn’t take many photos, since Jess was along, and hopefully she’ll post some of hers soon, but for now you can check out some of the photos I snapped with my phone if you’d like:

As for the conference — I really enjoyed presenting, and got some good questions from people afterward which was great. My paper is now published in Computer Animation and Virtual Worlds Volume 20 Issue 2-3 (June 2009) by Wiley InterScience.

I enjoyed the research, and the whole process of grad school, but I’m also glad it’s all finally over and done with! The trip and conference was a perfect way to say good-bye to that part of life.

It’s also a nice bit of closure on the years spent head deep in fluid simulation stuff. I really enjoyed doing it, and I’m glad I decided to do a Master’s at Dalhousie, but I’m also happy that soon it’ll be done and over with. It’s an awesome way to end that period of research, and although I don’t know exactly how yet, I’m sure it’ll spark the beginning of something new too.

As excited as I am to present my research to others I must admit that I’m also looking forward to checking out Amsterdam and the Netherlands (and maybe even a surrounding country or two if there’s time). I’ve never been to anywhere in Europe before, so I’m planning to make the most out of my free time while I’m there! I don’t know how well connected Amsterdam is yet, but hopefully if there’s WiFi abound I should be able to update on the go!

For more information on my thesis, and a video of the application in action, check out the project page.

1
2
3
4
5
6
7
8
9
10

template <typename... Args> struct count;
 
template <typename T, typename... Args> struct count<T, Args...> {
        static const int num = count<Args...>::num + 1;
};
 
template <> struct count<> { static const int num = 0; };
 
// let's use the struct
const int numArgs = count<1, 2, 3, 4, 5, 6, 7, 8, 9, 10>; // numArgs will be equal to 10 because there are 10 parameters given to the count struct

Line 1, is pretty much the root of all template metaprogramming trickery. The fundamentals of it all relies on recursive partial specialization, and line 1 just sets up a forward declaration to the count struct, which never actually gets used. There’s some complicated rules to how partial specializations are chosen by a C++ compiler, but the basic rule of thumb is that the most specialized version of the template that applies is what’s chosen. So although our instantiation at line 10 could match our blank forward declaration, it doesn’t. The meat of our tiny template metaprogram gets called instead: the recursive partial specialization at line 3.

And this partial specialization brings us to the key behind using variadic templates in the real-world. Since it’s not possible to do random access on the pack elements, the only choice is to “unroll” the packs recursively. The trick is to define the partial specialization such that the first argument is just a single parameter, and the next is a parameter pack:

template <typename FirstArg, typename... RemainingArgs> struct count<T, Args...>;

When the above struct is instantiated with a parameter pack, the first element gets pulled out of the pack into FirstArg, and the remaining parameters are placed in RemainingArgs. So, if the count struct makes an instantiation of itself with RemainingArgs... as the only instantiation parameter, again the first parameter will get pulled out and become FirstArg, and the rest will get placed in RemainingArgs. Thus, we can now easily unroll any parameter pack!

Let’s go back to the first code listing at line 4. This is where the recursion happens, and we can see exactly what we were talking about above happening. The count struct calls itself with the remaining arguments, and simply keeps track of the number of times the recursion happens by incrementing a counter along the way. When the instantiation finishes count::num will be set to the number of parameters in the parameter pack as of the initial instantiation plus 1. We add one because technically the recursion only counts the number of items in the parameter pack which, due to our partial specialization, is going to be one less than the number of parameters we pass to count (remember the first element gets picked out of the parameter pack).

The next thing we need to do, like in all forms of recursion, is to define the termination condition of the recursion. There are a number of ways to do this, but in this first example, we employ the “empty partial specialization” trick:

template <> struct count<> { static const int num = 0; };

This terminates the recursion not because num is implicitly set to zero, but because this specialization does not call itself. Therefore when the recursion has completely unrolled the parameter pack we hit this empty specialization and since there is no recursive call, nothing else happens. We only bother to define num here so that if someone explicitly instantiates a count struct with no arguments, they can still call count::num and get a value of zero rather than a compilation error.

Alright, so that was fun, now let’s look at something a little more complex, and a lot more useful:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

template <int N, typename... Args> struct elementType;
 
template <int N, typename T, typename... Args>
struct elementType<N, T, Args...> {
        static_assert(N < sizeof...(Args) + 1, "overflow!");
        typedef typename elementType<N - 1, Args...>::type type;
};
 
template <typename T, typename... Args>
struct elementType<0, T, Args...> {
        typedef T type;
};
 
// now let's use our elementType struct
elementType<0, int, char, std::string, double>::type var0 = 1; // var0 is an int
elementType<1, int, char, std::string, double>::type var1 = '2'; // var1 is a char
elementType<2, int, char, std::string, double>::type var2 = ";P"; // var2 is a string
elementType<3, int, char, std::string, double>::type var3 = 3.14159; // var3 is a double

The basic idea behind the elementType struct is that we give the struct an index and a variable number of types, and we can then use the struct’s type definition as a custom data type that maps back to whatever parameter the index value is associated with. The above listing at lines 15 through 18 do exactly that.

What’s so great about that, and why would such a thing be useful? While it may not seem like such an awesome thing to do at first, what we’ve done is found a way to pick elements out of a parameter pack by an index. Essentially we’ve given ourselves a way to allow random access to packs. The technique used is similar to the count struct, but not quite the same. We’re still using recursion, but this time we need to stop the recursion at the right element.

Take a look at line 6 in the above listing. This is where all the magic happens. The elementType struct calls itself using the same variadic unrolling trick that count used, except we decrement N at each step of the way, until N reaches zero, and we hit the termination condition (the partial specialization for when N is zero at lines 9 through 12). This means if we give an index of 5, we’ll get 5 recursions and the typedef that ends up getting defined is the one for the 6th parameter in the pack.

No problem right! So let’s put all this together for something actually useful — a variadic tuple class:

1
2
3
4
5
6

template <typename... Args> 
struct tuple {
        tuple(const Args&... args) {}
};
 
tuple<int, char> t1(1, '2');

The idea is we want to be able to use our tuple class like line 6 shows. This is the example from Part I, and as I previously mentioned, this isn’t so useful. Sure it lets us declare a tuple like we want, but it doesn’t actually store the tuple’s constructor arguments, nor does it give us any way to retrieve them. So how are we going to store the elements?

Like all things variadic, we’re going to use a recursive template definition! The tuple class will instantiate itself recursively, storing the arguments as it goes. Basically the tuple class will become a compile-time linked list of sorts. This means we’ll also have to use more metaprogramming to get access to the elements, but for now let’s take a look at the tuple class definition itself:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

template <typename... Args> struct tuple;
 
// recursion termination condition
template <> struct tuple<> {};
 
// recursive tuple template
template <typename Head, typename... TailArgs>
struct tuple<Head, TailArgs...> : private tuple<TailArgs...> {
        /**
         * \brief  Recursive constructor
        **/
        tuple(const Head& head, const TailArgs&... tailArgs) :
                tuple<TailArgs...>(tailArgs...),
                mHead(head)
        {
        }
 
private:
        Head mHead; ///< Tuple head
};

Although this might look a bit weird at first, there’s not actually that much that’s new here. We’re still just recursively defining a template class, and unrolling a parameter pack as we do it, but we’re doing it via inheritance this time. The tuple class’ base class is actually itself. We use the same trick we’ve used before to extract the first parameter from the parameter pack, but now we pass the template’s TailArgs to the base class so that the base class’ Head becomes the first element in its super class’ TailArgs.

When the instantiation of this class finishes it will be a tuple class that has an mHead member variable set to the value of the first argument in the parameter pack given to the tuple’s constructor as the head variable (which you can see being set at line 14). That tuple class will have a base class that itself has an mHead member variable which is set to be the second parameter in the initial instantiation’s parameter pack (or the first parameter given to the base class instantiation). This process repeats until all the parameters in the initial pack are exhausted and the termination condition is hit.

Okay, so that’s pretty cool, but now what? Basically we’ve got this weirdly constructed tuple class with a strange inheritance hierarchy that stores all the elements given to the constructor — we still need some method for extracting them! This is where all our previous metaprogramming fun comes into play. We’ve already built much of the framework we need to make this happen:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

template <typename Head, typename... TailArgs>
struct tuple<Head, TailArgs...> : private tuple<TailArgs...> {
        /**
         * \brief  Recursive constructor
        **/
        tuple(const Head& head, const TailArgs&... tailArgs) :
                tuple<TailArgs...>(tailArgs...),
                mHead(head)
        {
        }
 
        /**
         * \brief  Get a tuple argument
        **/
        template <int N>
        typename elementType<N, Head, TailArgs...>::type
        get() const {
                return getValueFromTuple<N>::template getValue<typename elementType<N, Head, TailArgs...>::type, Head, TailArgs...>(*this);
        }
 
        /**
         * \brief  Get the head value
        **/
        Head                            head() const { return mHead; }
 
        /**
         * \brief  Get the next argument in the chain
        **/
        const tuple<TailArgs...>&       next() const { return *this; }
 
private:
        Head                            mHead;                                  ///< Tuple head
};
 
// let's use our new get function!
tuple<int, char, bool, double> t1(1, '2', true, 3.14159);
char c = t1.get<1>(); // template get function where the index specified returns that parameter of the tuple class

The first function we’ve added is the tuple’s get function, which can be seen being used at line 37. So how the %@*! does that work anyway?

Our new class member template function works pretty much the same as Boost’s tuple library (although much simpler). All we’ve done is defined a template function that takes an integer as a template parameter, and we’ve used our elementType struct, which we’ve already seen from earlier in the article, to set the return type of the function to whatever type is at that index in the tuple’s parameter pack!

We are missing some pretty important code though. The get function then calls the getValue function, which we’ve yet to define:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

template <int N>
struct getValueFromTuple {
        template <typename ReturnType, typename Head, typename... TailArgs>
        static ReturnType getValue(tuple<Head, TailArgs...>& t) {                                                                          
                return getValueFromTuple<N - 1>::template getValue<ReturnType, TailArgs...>(t.next());
        }                                                                          
 
        template <typename ReturnType, typename Head, typename... TailArgs>
        static const ReturnType getValue(const tuple<Head, TailArgs...>& t) {                                                                          
                return getValueFromTuple<N - 1>::template getValue<ReturnType, TailArgs...>(t.next());
        }                                                                          
};                                                                           
 
// termination condition for when getValueFromTuple is instantiated with zero
template <>
struct getValueFromTuple<0> {
        template <typename ReturnType, typename... Args>
        static ReturnType getValue(tuple<Args...>& t) {                                                                         
                return t.head();
        }                                                                         
 
        template <typename ReturnType, typename... Args>
        static const ReturnType getValue(const tuple<Args...>& t) {                                                                         
                return t.head();
        }                                                                         
};

This might look a bit complicated, but there’s absolutely nothing here we haven’t seen before. We define a template struct called getValueFromTuple that takes an integer as a template parameter. This is done so that we can partially specialize the struct so we have a termination condition for the function we actually need (getValue). C++ function templates are a bit more limited than class templates in how we can partially specialize them — specific specializations by constants are not allowed, so we use this struct wrapping trick to give us what we need.

The getValue function is also nothing new. It does the exact same recursive unrolling that the elementType struct uses to extract a specific parameter by index. The function recursively instantiates itself until N reaches zero and the termination condition is called. The trick here is that getValue calls the tuple class’ next() function during each instantiation, which passes the tuple’s base class to the next instantiation of the function. All we’re doing here is walking the “list” of parameters passed to the tuple’s constructor, we just happen to be doing it by walking the class hierarchy.

Let’s take a quick look at the tuple’s next() function to see how this works:

const tuple<TailArgs...>&       next() const { return *this; }

This is how we trick the compiler into returning its base class — which has an mHead that contains the next parameter in the pack. The return type is the same type that the base class has, so when we return ourselves through the this pointer the compiler does the right thing and casts down to the base class.

So there we go: a fully functioning variadic tuple class that stores its constructor parameters and gives us a way to get at them by their index! We can now do this:

tuple<int, char, string, double> t1(1, '2', "variadics rule", 3.14159);
 
int    var0 = t1.get<0>(); // var0 is now 1
char   var1 = t1.get<1>(); // var1 is '2'
string var2 = t1.get<2>(); // var2 is now "variadics rule"
double var3 = t1.get<3>(); // var3 is now 3.14159

Sweet! Of course there are many improvements that could be made such as allowing access to elements by reference (for efficiently storing and retrieving large structures), adding iterators, copy constructors, operator overrides, etc, but I’ll leave that stuff as reader exercises .

For the next installment the plan is to go even deeper down the the metaprogramming hole, and see what kind of compile-time fun we can have. Template metaprogramming is a really useful skill to have; the more you can do at compile time, the fewer instructions need to get executed at runtime, plus, as we’ve just seen in this article, metaprogramming trickery can make other code more readable and, in turn, easier to maintain. Not only that but playing around with template metaprogramming is a great way to get to know your compiler, and the C++ language!

The same goes for C++’s templates. Have you ever wondered how Boost’s Tuple library works? Well, Boost does a lot of cool complex things, like defining variadic templates using preprocessor and template metaprogramming, but in the end it’s actually pretty simple:

struct NullArg {};
template<typename Type1 = NullArg, typename Type2 = NullArg, typename Type3 = NullArg> 
class tuple {
        tuple(T0 t0) {}
        tuple(T0 t0, T1 t1) {}
        tuple(T0 t0, T1 t1, T2 t2) {}
};
 
tuple<int, char> t(1, '2');

Of course this tuple class doesn’t store or let you retrieve arguments, only allows for up to three parameters (adding more arguments, while monotonous without some preprocessor fun, is easy), and there’s some definite metaprogramming magics that go into tuple’s get<X>() template function, but it’s all still possible.

Getting back to the point: alright so we can, in effect, do variadic templates already, even without fancy C++0x. So why are they good? Well, all we’re really able to do is emulate variadic templates. The compiler always sees those “variadic” structs as having the maximum number of parameters, which means extremely long mangled names (increased binary size), slower compilation time, stupidly complex compiler diagnostic output, and did I mention slower compilation time? Not to mention that it’s an ugly and hacky way to achieve something that could be much more elegant. It’s fine for libraries to define handy structs with variadic emulation, but do you really want your production code nastied up like that? Likely not.

So, in come’s C++0x’s variadic templates. They’re easy, fun, and the whole family can use them! The syntax looks like this:

template<typename... Args> 
class tuple {};
 
tuple<char, int, bool> t;

Not so useful yet, but as you can see the ellipsis operator is given new purpose, and in this case it’s meant to denote a template parameter pack. It can also be used to denote a parameter pack expansion, like this:

template<typename... Args> 
class tuple {
        tuple(Args...) {};
};
 
tuple<char, int, bool> t('1', 2, false);

Here we’ve created a variadic tuple template and expanded the Args parameter pack in the constructor, thus letting us pass a variable number of arguments to the tuple’s constructor.

You can use the pack expansion pretty much anywhere it makes sense: base classes, constructor initializers, you name it, but in my opinion the real power of variadics comes once you start using them in conjunction with template functions and we begin to utilize C++’s powers of argument deduction. Take a look at this:

template<typename... Args>
struct tuple {
        tuple(Args...) {};
};
 
template<typename... Args>
tuple<Args...> make_tuple(Args... args) {
        return tuple<Args...>(args...);
}
 
int main() {
        auto t1 = make_tuple(1, 2, 3, 4, 5);
        return 0;
}

Nice and clean! There’s no need to specify all the template arguments to make_tuple because the compiler deduces them from the function arguments! Also note the use of the C++0x auto keyword there. Auto variables are still statically typed, they just get their type set to whatever initializes them.

So there’s the ultra-basics. Up next I’m going to start exploring what you can really do with variadic templates — like how you can extract an arbitrary element from a pack, pack searching, and other fun compile time trickery. You’d think Bjarne might have wanted to allow random access to variadic parameter lists, but that just wouldn’t be any fun. Why do things with random access when you can do it all with recursion!

Ready for more? Head to Part II!

• Mike the Headless Chicken
• Mayonnaise
• Cop’s Eye
• Space stations kick ass