Per i nostalgici di Rasputin Dischi

November 16, 2008

Ora c’è un gruppo di Facebook tutto per noi! Dal momento che ogni volta che controllo qualcun altro è capitato sul mio post a proposito di Rasputin, ho pensato che sarebbe stato divertente vedere chi siamo e quanti siamo.

Advertisements

Test results for Boost 1.37.0 and CodeGear compilers…

November 5, 2008

… may be found here!

I ran the tests both before and after applying Update 1 and the results are exactly the same.

Boost 1.37 is out

November 4, 2008

As you probably know Boost 1.37 was released yesterday. I expect it to be well received by CodeGear users, as it includes many specific patches for both C++Builder 2009 and C++Builder 2007. The good news are that many of these patches actually disable workarounds that are not needed any more and none is specific to the latest compiler version, so apparently there are no new regressions.

Among the involved libraries there are some of the fundamental ones, as Config, CallTraits, Exception, Iterator, MPL and TypeTraits. Asio, Foreach, Filesystem, Function, Functional and Serialization also received patches. Unfortunately there were quite a few patches that I didn’t manage to submit in time; these will have to wait for 1.38, I’m afraid.

I hope to be able to post test results for both CB2009 and CB2007 on the bcbboost site by tomorrow evening. Originally I didn’t plan to issue a new bcbboost release, but CodeGear released Update 1 for CB2009 too late for explicit support to be included in 1.37. In the next few days I’ll check what needs to be done.

C++ Builder 2009, Boost & bcbboost

September 22, 2008

The number of visits to this blog has increased in the last few days. I obviously don’t know for sure, but C++ Builder 2009 was recently released and one possible reason for the increased traffic is that people are looking for information on Boost support for the new compiler.

As you probably know CB 2009 includes a custom version of Boost 1.35 . This includes a very high number of specific changes which, combined with the standard compliance improvements in the compiler, increase dramatically the level of support compared with previous releases. I would consider this a very convenient solution for those that do not need the latest libraries.

I’m currently in the process of helping the CodeGear people merge their changes into the official Boost repository and I hope to finish in time for the next Boost release, 1.37 . Should I not make it I plan to check with CodeGear whether they have any objection on issuing their patches through bcbboost first.

I currently have no plans for a 1.36 backport, but if you direly need it, let me know.

Welcome to .Nick’s!

September 4, 2008

I just setup a small SourceForge project to hold the C# code I wrote during the last few months. It should be fairly general purpose, with a slant towards system tool programming, which is what I’ve been spending a fair portion of my time on since the beginning of this year. You can check it out here.

You will find the source code and a little bit of documentation. The next thing to do is to issue an initial release. Hopefully during the weekend, but don’t hold your breath.

Searching for a raskal

August 5, 2008

A while ago, while trying to find my way around the intricacies of .NET’s approach to application configuration, I stumbled upon this article. As I found the approach it described as well as the code it provides very convenient, I built around it my own configuration support classes.

Now I would like to publish my current C# toolbox as Open Source and I’d like to include stuff that’s directly derived from the article I just mentioned. Thus I’m trying to get in touch with raskal, who originally posted the article on the Nezdeboeuf blog on the RioterDeckers’ Headquarters site, to ask his or her permission.

Hopefully sooner or later someone who knows how to reach her or him will google for one of these names and chance upon this post…

Rock’n’Roll Animal – Lou Reed (1974)

June 26, 2008

In stark contrast with the minimalist approach that characterizes both his beginnings with The Velvet Underground and much of his later career, here Lou Reed presents a very triumphant, glamorous rendition of his music. Rock’n’Roll Animal starts off magnificently with a beautiful instrumental introduction which leads into a powerful version of “Sweet Jane”, one of Lou’s most famous songs and one of rock music’s most effective riffs. This is followed by a breath taking, spine chilling interpretation of “Heroin”, the archetype controversial song. If an artist’s job is to induce ideas into us by communicating at the emotional level rather than at the rational one, considering how the imagery that Lou Reed and his band throw upon us is incredibly vivid there can be no doubt that this is not only a work of art, but actually a masterpiece. Certainly this is as close as I will ever get to experiencing how it really feels. And yet…

The remastered CD version I’m currently listening to includes here a couple of songs that weren’t on the original album, “How Do You Think It Feels” and “Caroline Says I”. These don’t add much to the collection; one could almost say that they actually lower the overall average. On the other hand those who, like me, suffer from “completeness-mania” will probably be happy that these songs have been made available.

The original program resumes with a powerful rendition of “White Light / White Heat“, a fast rock’n’roll number from the Velvet Underground period. The atmosphere changes all of a sudden to a feeling of impending doom with “Lady Day”, from the Berlin album. Rock’n’Roll Animal closes on a much lighter tone with the humourous “Rock’n’ Roll”.

This is one of the great rock live albums. The songs are mostly masterpieces, very well arranged and played by accomplished musicians. In my opinion it has aged well, even though its style dates it unmistakably in the first half of the 1970’s. What can I say more? I wish I was there; instead, I urge you to buy this album, and possibly also Lou Reed Live, taken from the same concert.

insert_separator

June 25, 2008

I recently realized that there is a problem that has kept cropping up regularly in my code for the last few months: transform a sequence of words in a comma separated list. Not a big issue in itself, but I find it interesting for two reasons: first, it is almost impossible to specify a solution that matches the regularity and simplicity of the expected outcome; second, it’s a good test case for checking how well different languages support writing a generic solution.

I have to confess that I wouldn’t have given it much thought if this wasn’t a kind of problem that really irks my sense of aesthetics; what you want is something as simple as:

string1, string2, string3

A very plain sequence, without any exception or special case. Yet when you try to code it you can’t avoid making a special case of either the first or the last string, as in this Python function:

def insert_separator1(l):
    ret = l[0]
    for s in l[1:]:
        ret += ", "
        ret += s
    return ret

Otherwise you have to insert a conditional inside the loop, which conceptually you should only need to compute once, as in this alternative Python implementation:

def insert_separator2(l):
    ret = ""
    first = True
    for s in l:
        if first:
            first = False
        else:
            ret += ", "
        ret += s
    return ret

By the way, I’m well aware that Python’s standard library provides a ready-made solution:

print ", ".join([ "string1", "string2", "string3" ])

While Python is very convenient to expose programming concepts, the code where this little problem keeps coming up is actually written in C#. This language also has a library solution, which is very similar to Python’s:

using System;

class InsertSeparator1
{
    static void Main(string[] args)
    {
        string[] l = { "string1", "string2",
                "string3" };
        System.Console.Out.WriteLine(
                string.Join( ", ", l));
    }
}

These library solutions are undoubtedly convenient, but they are limited to the scenario where you want to concatenate your list elements into a single string. Sometimes, however, you would rather output your strings to a file, or you might want to interleave other kinds of things, rather than just strings.

Let’s see then how different languages support a generic solution. Thanks to generators and duck typing Python makes it very easy:

import sys

def insert_separator4(elements, sep):
    first = True
    for e in elements:
        if first:
            first = False
        else:
            yield sep
        yield e

if __name__ == "__main__":
    for e in insert_separator4([ "string1",
            "string2", "string3" ], ", "):
        sys.stdout.write(e)
    sys.stdout.write( '\n' )

Slightly less so C#, which is constrained by static typing and the subordination of generics to inheritance as a means of generalization:

class InsertSeparator2
{
    static IEnumerable<ValueType>
            InsertSeparator<ValueType>(
                    IEnumerable<ValueType> elements,
                    ValueType sep)
    {
        bool first = true;
        foreach (ValueType e in elements)
        {
            if (first)
                first = false;
            else
                yield return sep;
            yield return e;
        }
    }

    static void Main(string[] args)
    {
        string[] l = { "string1", "string2",
                "string3" };
        foreach ( string e in
                InsertSeparator<string>(l, ", " ) )
        {
            System.Console.Out.Write(e);
        }
        System.Console.Out.WriteLine();
    }
}

Note that you need to implement the IEnumerable<T> interface in order to exploit this function.

C++ is also statically typed, but thanks to a form of compile time duck typing supported by templates it doesn’t require an abstract base class:

#include <iterator>
#include <iostream>
#include <string>

template <typename InputIter, typename OutputIter, 
        typename ValueType>
void insert_separator(InputIter first, 
        InputIter last, 
        OutputIter out, 
        ValueType sep)
{
    bool initial = true;
    while ( first != last )
    {
        if ( initial )
            initial = false;
        else
            *out++ = sep;
        *out++ = *first++;
    }
}

int main()
{
    std::string l[] = { "string1", "string2",
            "string3" };
    insert_separator(l, l + 3, 
            std::ostream_iterator<std::string>(
                    std::cout), 
            ", ");
}

At first sight the C++ solution isn’t much better than the C# one. However generalization is not just a matter of language constructs; it is also a matter of conceptual framework. With little effort from our part the function above integrates perfectly with the standard library’s iterators and containers, as well as with any user defined ones, provided they adhere to the standard library constraints.

Finally, there is a solution to this problem which satisfies my quest for elegance, but it’s currently late at night and this post is already long enough as it is 😉

Talking ’bout Code Generation

May 5, 2008

In a perfect display of self-promotion, I forgot to announce here that I had a presentation proposal accepted for the ACCU Conference 2008. To get an idea of what I talked about you can read the proposal and browse through my slides.

Basically I expressed the view that code generators are a very effective means of dealing with the kind of repetitive tasks that tend to crop up when programming, especially if you use effective tools such as Python as programming language, a parser generator such as PLY for information acquisition and a templating engine such as Cheetah for the actual generation.

The Borland / CodeGear compilers and Boost 1.35.0

May 5, 2008

One of the many changes introduced with the new Boost release process is a drastic reduction in the number of officially supported compilers.  Although all versions of the Borland /  CodeGear compiler were left out, it should be noted that this only means that they have been excluded from the official release branch regression tests. This is not a good thing, as it makes it likely that regressions introduced late in the release process go unnoticed until after the release is issued.

On the other hand all the specific workarounds that I’m aware of are still present in the Boost source code and compilers from 5.6.4 onward work only slightly worse with Boost 1.35.0 than they did with the last few Boost releases.

To get a more precise idea of what works and what doesn’t you can take a look at the test results for the 5.6.4, 5.8.2 and 5.9.3 compilers. As you can see the 5.9.3 compiler does somewhat better than the other two, but there are things that stopped working for all three since the last Boost release.

However, now that gcc and VC++ are both rather close to standard compliance, Boost authors tend to rely more and more on advanced techniques that are only partly supported by the latest compiler, and not at all from earlier ones. This is likely to get worse – or better, depending on points of view – with each new Boost release. Let’s just hope that CodeGear manages to keep up.