on-multitasking

Two days ago, I stepped over a plank of wood
    and walked past a barren tree.
My family and I hugged mugs of thin tea
    and huddled around a kerosene heater set to low.
I almost wish it weren't so peaceful.

Yesterday, I watched a heron
    glide along a riverbank.
It's whiteness a stark contrast
    to the fragments of houses and overturned cars.
I almost wish I hadn't seen it.

Last night, I watched a crescent moon
    in a cloudless sky.
The blackness of a city without power
    produced stars unlike I have ever seen.
I almost wish I had just gone to bed.

Today, I stepped over a plank of wood
    and noticed a lone cherry blossom on a branch.
It's pink petals fluttering in the moist wind
    at once delicate and strong.
I almost wish life were not so beautiful
    and so resilient.

If you’ve had these questions in your head from time to time, you might resonate with his treatment of them. He doesn’t necessarily try to answer them directly. Instead, he shows what might be the consequences of taking certain stances on the issues. Some of the characters consciously pick over these questions. Others haplessly encounter the results without realizing that there was even a question or a stance to be taken.

The philosophical merit aside, this moving story is still worth a read. It takes you through the lives of people you probably know or will meet. You will learn something about them if not about yourself.

I had some difficulty wading through some of the pages toward the middle of the book but toward the end, I couldn’t put it down. It was well worth the time.

I’m not a vengeful person so I don’t readily relate to the motivating force behind the arc of the plot but Dumas draws me in anyhow with the beautiful imagery, the deep characters and the fantastic circumstances. He brings you along a journey where only you, he and the count are the ones who really know what’s going on.

I had a hard time keeping track of who was who through most of the beginning of the book. Luckily, Dumas doesn’t introduce too numerous a cast of characters. If you get confused or frustrated by not knowing who is who in the beginning, soldier on anyhow.

Fast forward to real life. I didn’t remember my love of literature until relatively recently. I dusted off my library card and took a list of recommendations from a friend to my local library and recommenced my education.

This is the first of a series on specific classics of literature. It represents my taking a stand against the obvious trend cheekily intimated by Twitterature that contemporary society’s patience for meandering through beautiful prose or getting goosebumps over a great work of poetry is waning. I will attempt to explain why I think each work is worthwhile. If you don’t already, may this series inspire you to fall in love with the classics.

bool lua_t::load(const std::string& filename)
{
    lua_pushcfunction(state_, traceback_function);

    if (luaL_loadfile(state_, filename.c_str()) != 0)
    {
        lua_pop(state_, 1);
        return false;
    }

    if (lua_pcall(state_, 0, LUA_MULTRET, -2) != 0)
    {
        lua_pop(state_, 1);
        return false;
    }

    lua_pop(state_, 1);
    return true;
}

The “sort of thing” I’m referring to is restoring the state of the Lua stack at every exit point from a function which manipulates it. In the above case, I had to use three distinct calls to lua_pop to achieve this. Today, I found a new approach that can simplify dealing with the Lua stack from C++.

struct stack_bookmark_t
{
    explicit stack_bookmark_t(lua_State& state_)
        :
            state_(&state),
            top_(lua_gettop(state_))
    {
    }
    ~stack_bookmark_t()
    {
        lua_settop(state_, top_);
    }
private:
    lua_State* state_;
    int top_;
};

The motivating example changes to this.

bool lua_t::load(const std::string& filename)
{
    stack_bookmark_t bookmark(*state_);

    lua_pushcfunction(state_, traceback_function);

    if (luaL_loadfile(state_, filename.c_str()) != 0)
    {
        return false;
    }

    if (lua_pcall(state_, 0, LUA_MULTRET, -2) != 0)
    {
        return false;
    }

    return true;
}

At every exit from this function scope, the destructor of stack_bookmark_t ensures that the stack height is restored to its prior state.

I have seen brave young men dropping 4 meters (that’s about
12 feet for the uninitiated) down a waterfall in their
kayaks. Oddly, the drop wasn’t a problem for any of the
daredevils. The tricky currents just after the falls
consumed one very expensive carbon-fiber paddle as well as
the ego of its former owner.

I have ridden my bike along luxuriously wide roads
alongside some of the most polite drivers I’ve ever
encountered amidst green lawns, tree-lined avenues, and
picturesque lakes.

I have visited a bakery, or more aptly, a boulangerie, where
I was greeted with “bonjour” and thanked with “merci”.
Studies have shown that bread tastes better when it grows up
in this kind of environment.

I have visited a world class art museum and have seen the
facilities where a peaceful government conducts its
operations.

But mostly, I have been extremely impressed by the people of
Canada. I don’t think they realize how beautiful and
charming they are. They are universally nice and polite.
Despite the busy, eclectic, urban environment, folks smile and
acknowledge you even when you’re not somehow in their way.
They seem generally very healthy, fit, and full of life.
(This could be a fine moment to mention health care but I
will choose not to get involved in the silliness of that
debate.)

All in all, I am extremely pleased to have spent this
weekend getting to know Ottawa and its people. People of
the world, take note, when you want to find an example to
follow and a city to model yours after, you could do worse
than to visit Ottawa, Ontario, and learn from its peaceful,
beautiful people.

I recently had an idea that I wanted to publish in a C++ trade magazine, any of them would do.  I pitched my idea to Dr. Dobb’s, a rather prestigious computer programming publication and Overload Online, the free journal of ACCU, a community of programmers interested in things C and C++ related.  Overload was interested in my idea and complimented me by reviewing a draft but they noted that another author, Martin Moene, had presented a very similar idea, and encouraged me to write a follow on article.  I ultimately decided against writing the follow on article and, at first, I was crestfallen at being scooped.  Martin’s idea and mine are nearly identical in spirit if a bit different in execution.  But, more important than the individuals involved are the ideas and I’m glad these ideas are now firmly in the public domain where developers can benefit from them regardless of who presented them first.  (I’m laughing at myself a little in writing this last sentence but I resonate with the sentiment.)

So it is with a great deal of satisfaction at both my personal triumph over my own ego and at the honor of being part of this discovery that I present to you my original draft of this technique.

c++-register-access

I owe a debt of thanks to Scott Meyers who honored me by giving me feedback on an early draft and for teaching his course on Effective C++ in Embedded Systems which inspired me to look harder for a solution to the problem this technique aims to solve.