A couple of weekends back Kat and I went to the Open Tech 2008 one day conference in London. I had planned to write about some things I came across there in some depth, alas time is against me. It would be criminal for me to let it go completely unmentioned though.

There’s something amazing about OpenTech: it costs just £5 to attend. For the breadth of coverage, interesting speakers, things learned, and inspiration gained over the day this is an extreme bargain.

Giving myself a few minutes to note down a few points still in the top of my head 10 days later:

• There was an overwhelming theme of “public good” running through the conference. From the projects devoted to this, such as mysociety.org, through to entrepreneurs and icons pushing to inspire everyone to follow their various leads. This is a great change from the usual case of “this tech is cool because, well, it is” – I loved to hear that tech was cool for the ways is was actually helping everyday people.
• Further contrast between the geeks and the suits (generalisations, I know.) A few weeks back I went to a serious business-tech conference hosted by the 451 group, this was also good stuff but coming at security from a completely different angle (security was just one of several topics covered.) The contrast is all the more interesting because there’s a convergence. At the business conference we hear “security is difficult, we have to try harder, alas, some things may be impossible” at OpenTech we hear “security is impossible, but we can try harder and do better.” There’s far too much depth to this for me to go into right now, not that my own thoughts are in any good order. Suffice to say, studying the application of security from social and economic standpoints would be very interesting right now. There’s a lot of material out there, and people(/businesses) are speaking more openly about security issues these days I think.
• More on/around security. People get very confused about identity versus reputation, especially when technical definitions of authentication are worked into the mix. People, even a room full of geeks, know very little about the history of currency, and banking in general (a cultural weakness in the geek horde?) Cryptographers are regarded as some sort of higher being… maybe they are! (Aside: I’ve just read Simon Singh’s Fermat’s Last Theorem – it lives up to its reputation, and man those number theorists are an insane bunch!)
• Ubiquitous networking has changed the world, maybe those of us who’ve lived through the changes sometimes don’t appreciate how revolutionary the changes are (I have trouble seeing it sometimes, much older geeks seems to see it more clearly.) What’s scary, is that the field is still young and haphazard, what further refinement will bring is difficult to imagine.
• The above is amazing, now how to we deliver this to the rest of the world. Can it actually help solve the terrible problems most of the world has? I’d like to think so.

Of the sessions I attended these are memorable:

• Most entertaining: The Web is Agreement, Paul Downy. A talk/rant around current trends centred on Paul’s sketch of the same title. (The talk “Living on The Edge” from Danny O’Brien was also entertaining, and the only time I’ve seen a geek talk “flood” with what can only be called “groupies”, it was strange.)
• Most inspiring: Digital Money, David Birch. This guy’s online presence seems to be a blog about digital money. In essence this was a short, angry rant about the fact that us geeks have not solved the problem of “digital money.” At the core of the rant was the idea that functional digital cash will make the world a better place, breaking down unnecessary barriers in the world of money (think of sending aid/donations right to where they’re needed, family members sending money home without the “Western Union” tax, etc.)
• Most relevant (to me): Security Discussion with Ben Laurie and Friends. Four security/crypto geeks/experts talking about how much things are broken. Entertaining, enlightening, and (to some) challenging.
• Most disappointing: Android and the Open Handset Alliance. It just wasn’t techie enough, more a marketing spiel from a “developer advocate.” I wa hoping for a crash “how stuff works” intro to Android.

On reflection… of the talks I saw there were a lot of “grumpy old(er) men.”

From time to time I have to draw a diagram. This excites me, I enjoy diagrams. Back in university the way to draw a diagram for a report was either xfig or to marking it up directly in latex. But they’re oldskool there are groovy new ways to draw diagrams these days. The state of the GUI diagramming art seems to be either inkscape or dia.

Really? Well… I don’t think so. While both are good in an attractive sort of way, they also both suck. On my Ubuntu “hardy” machine I get SEGVs out of inkscape every few minutes, not sure why and have no time to investigate. As for dia, it is just plain lacking. In inkscape I can group objects and resize the group, in dia a group of objects (even just rectangles) isn’t scalable! (Even xfig can do that.) So I have one option that breaks and is unusable, and another that lacks essential features and is unusable! All I want to do is draw some boxes with words in them, and maybe make them look pretty.

So, I’m using xfig now. Clearly, it is the state of the art in Linux diagramming. (And I’m oh so tempted to boot over to Windows and use Visio sometimes.)

What else is there? If I want to draw some class diagrams, boxes and lines, maybe even UML shudder, what do I use? A few apt-cache searches bring up some candidates, but I just don’t have time to play with them. I’ve got a bloody diagram to draw! Go go xfig!

Inkscape is extremely promising, I’ll maybe try it again in another year.

All these years I’ve been making regular use of good old std::endl without realising that it is a templated function! We live in a crazy world. Somewhere in the back of my head I guess I’d just assumed it was simply platform-dependant constant… not quite.

I came across this merry discovery when implementing a logger, since re-inventing the wheel is always so much fun. It isn’t as bad as it seems, the “logger” is basically just a matter of encapsulating the relevant utility code, weighing in at less than 500 lines of which more than half are API comments.

Anyway, I’d like my logger to act like a std::ostream, although I don’t want it to be a std::ostream really (preferring to avoid inheriting from such beasts without a really good reason.) The functionality is simple, it wraps a set of std::ostreams to send the output to. The important part is that it implements log levels and and log message classes (which you can register and name if you wish.) At any one time there is a log threshold and a set of active classes. To keep things really simple it has a single output method that takes only a std::string ref.

Now I want to use it with good old << since that is comfortable and not unexpected so I implement:

template <typename T>
Log& operator<<(Log & log, T const & t) {
    std::ostringstream oss;
    oss << t;
    log.output(oss.str());
    return log;
}

This seems to work swimmingly until I try the likes of log << std::endl, then it fails to compile. Eh, what on earth is std::endl that the template won’t catch it? A peak into the ostream C++ header tells us it is a function pointer:

  template<typename _CharT, typename _Traits>
    inline basic_ostream<_CharT, _Traits>&.
    endl(basic_ostream<_CharT, _Traits>& __os)
    { return flush(__os.put(__os.widen('n'))); }

Egads! So I implement this (bear with me):

Log& Ephedrine::operator<<(Log & log, std::ostream& (*fn)(std::ostream&)) {
    std::ostringstream oss;
    fn(oss);
    log.output(oss.str());
    return log;
}

And now I can do this:

g_log << Log::NORMAL << "Normal log output.  A number is " << 2.123 << std::endl;
g_log << Log::VERBOSE << "Verbose log output." << std::endl;

Joy.

But there’s more than one worm in this can. Note that in the definition above it calls flush on the ostream. In the doxygen comments it notes “This manipulator is often mistakenly used when a simple newline is desired, leading to poor buffering performance.” On checking the standard there it is too, this is std::endl by definition. I’ve never used ostreams, thus never std::endl, in performance critical code but I’ll have to keep this in mind if I ever do! In all of the C++ books I’ve read, a fairly large number, I don’t recall ever seeing this noted anywhere.

This brings into mind a question of design. I’ve avoided being an std::ostream yet gone and used std::endl, and std::endl is supposed to flush the stream (by definition, it’s in the standard, see section 27.6.2.7.) My current implementation doesn’t flush the streams, so what should I do?

• A) Not care.
• B) Reimplement as Log::endl (which will ultimately call std::endl and thus end up flushing the streams!)
• C) Create a special case specifically for std::endl.

I don’t like the first option, not my way of doing things by preference (alas, it has been known to happen.) The second option is easy to implement but will feel unnatural to the user (a moot point, I’m the sole user!) The third option smells “wrong,” but I already decided to do it didn’t I, and I went one step worse and broke the guarantee for std::endl (albeit probably mostly unknown.)

Is C really enough though? No, it turns out. Aside from breaking the flush guarantee it also doesn’t go quite far enough. Think about std::hex and similar modifiers. By converting them to a string (an empty string) before writing to the underlying std::ostreams their meaning is lost. My original implementation above is, in essence, an abomination.

In the end I settled on E: templates. What I should have done in the first place, but avoided since I was hung up on pimpl at the time (templates and pimpl don’t mix well.)

template <typename T>
void Log::output(T const & t) {
    ... /prep/
        BOOST_FOREACH(std::ostream & os, m_osList) {
            os << t;
        }
    ...
}