Title: Francis’ Scribbles

This is a book (0-471-45879-1) about the various US government reactions to 9/11 (I still wonder if that date was chosen deliberately; 911 is the US emergency phone number.) It is well worth reading both because of the author’s understanding of the US and because of his lack of understanding of the rest of the world and factual inaccuracies with regard to things external to the US (he thinks the Basque terrorists are French.)

If intelligent, well-educated US citizens who are willing to spend time researching on the Internet remain so profoundly US-centric we continue to have serious problems for which I can see little hope for solutions.

About eighteen months ago my wife and I had a problem when visiting the US. The cause of the problem was that they had no record of my wife having left after a previous visit so she was listed as having outstayed her six months on the visa-waiver program. Fortunately the date they had for her prior entry to the US was 1909 (yes, really). Worse, she had a new passport and so the old documentation was gone. It was so manifestly an error that it only took us half an hour to sort it out. But how does such a ludicrous error get into the system?

Part of the problem was highlighted on our most recent visit where no one collected the exit part of our visa-waiver, well, not until I drew their attention to this as we were about to board for the final leg of our return journey. Is it any wonder the best estimate for illegal immigrants in the US is in the millions?

Actually the whole green card visa-waiver procedure was (I do not know what it will be like the next time I visit in the Autumn this year) ludicrous in an electronic age. Clearly they should have been completed before embarkation and many of the details could be pre-entered by the airline (flight number, date, and points of departure and arrival). Indeed, with electronically readable passports the passport number should also be inserted automatically. Such pre-processing would be in everyone’s interests. What airline wants to find that one of their passengers cannot enter the country of destination only after they have flown them there?

The processing of immigrants and visitors to the US is inconsistent with their belief that they are the most advanced technological society in the world. Requiring biometric passports is fine, but only if you have the infra-structure in place to manage data correctly and consistently. Those on the ground trying to manage the problems are generally courteous and thoughtful and can see what a mess is provided by inappropriate or incorrect use of technology. Those responsible for the systems are, at best, out of their depth.

Anyway, read the book but do not get too irate by the author’s lack of understanding of how the rest of the world views US interventions.

CLI stands for ‘Common Language Interface’ (I think) and is basically the .NET mechanism whereby processes written in different languages can interoperate.

Several years ago Microsoft produced something called ‘Managed C++’ which even their own C++ experts admitted was pretty awful. Recently Microsoft proposed that there should be a set of standard bindings from C++ to CLI. At one level this makes perfectly good sense. The trouble starts when new keywords and structures are necessary for C++ to support the CLI object model. In an ideal world we would modify CLI to better match major features of C++ (such as the concept of const qualified objects). However we do not live in an ideal world. We also have the problem that CLI is already a Standard (via ECMA) and is currently going through a revision. Obviously we want to have a major influence on that so that there is a better match with C++.

This leads to the problem that the ‘correct route’ to such a C++/CLI binding via a Technical Report from WG21 is too slow to have any chance of influencing CLI.

The ‘solution’ is to use ECMA as a fast mechanism, fast enough that we have some remote chance of getting some changes to CLI along the way. However the trouble with fast processes is the potential for mistakes along the way. This is quite worrying, not least because despite the successful efforts of Herb Sutter and Tom Plum to get the ECMA participation/liaison rules modified (or at least interpreted) so that National Body experts can have oversight of the proposals and input to them (even though without a vote) only the UK (plus France through a single expert) appears to have taken up the opportunities.

It is interesting to note that just about all the participants in TG5 (the ECMA group dealing with this) are actually also members of WG21. The real problem is getting TG3 (responsible for CLI) to listen and respond. This is another problem related to the fast timetable that ECMA groups tend to set. Even when you are using electronic communications getting consensus is time-consuming.

My biggest concern is that we know from bitter experience that getting things right takes time, and even when we think we have managed it we are too often mistaken. The experts reading this might like to think about the problems with ADL (argument dependent lookup, sometimes called Koenig Lookup) and the problems that both C++ and Java have had with exception specifications (even though they tried different approaches).

For example, in my opinion, even when we want to provide something such as ‘interface classes’ in the C++/CLI binding and use a keyword for the purpose we should stick to the underlying C++ syntax (properly declared pure virtual functions) and just use the keyword to instruct the compiler to diagnose breaches of the CLI requirements (i.e. in this case, only public members, no data etc.) The result of omitting ‘interface’ should mean as near as possible the same thing in pure C++.

I am sure that the result of the UK participation through the BSI will be that the work being done to support CLI in C++ will be much better. It is only a pity that there are not more people involved in the effort. Despite what I read in one book recently, Standards are not dead and work on them does improve the ordinary user’s lot.

I will be in Australia for the last two weeks of March and for the first week of April. I will start in Melbourne and attend the ECMA TG5 (C++/CLI) meeting there before moving over to Sydney for the WG21 (C++) meeting followed by WG14 (C) which is the reverse order to the normal one.

It is disappointing that after many of us have made a special effort to go to Australia, it seems that few if any Australian experts will make the effort to attend the meetings. Worse, the Australian National Body is no longer even an O (for observer) member of SC22 which is the parent committee of WG21 and WG14. I can think of some other places I would like to visit if local interest in Standards is not required.

The other issue is that those dates are exactly the time when I would normally be working on my contributions to the next issue of C Vu. Please make a special effort to get your contributions in early because I would like to get as much as possible done before I leave for Australia. I know I can do much of the work on a laptop but I am happier working with my reference books close to hand.

It went to reprinting five weeks after its release in the UK. US book chains have been upping their orders even before it goes to distribution there (on February 9th). As the first reprint was before a single review had been published, clearly many of you have been doing your bit to tell others about it. Please keep up the good work.

Look at the following C code. Why does qsort() fail? Please note that the compare() function does rank any two objects of type X.

struct X{
  int i;
  int j;
  int k;
};
int compare(void * p1, void * p2){
  struct X * x = p1;
  struct X * y = p2;
  if(x.i > y.i) return 1;
  if(x.j > y.j) return 1;
  if(x.k > y.k) return 1;
  return x.i + x.j + x.k – y.i – y.j – y.k;
}

int main(){
  struct X array[10];
/* code initialising array */
  qsort(array, sixeof(X), 10, compare);
/* etc. */
  return 0;
}

Please look at the following two functions that are intended to save and restore the red, green and blue intensities of a palette of 256 24-bit colours. Actually you do not need to know the gory details, all you need to know is that the first function writes some data to a file and the second is supposed to restore it. What is wrong?

void save_palette(playpen const& canvas,
                  string filename) {
  ofstream out;
  open_ofstream(out, filename);
  if(out.fail())
    throw problem("Could not open file");
  for(int i(0); i != 256; ++i) {
    HueRGB const mix(canvas.get_entry(i));
    out << int(mix.r) << " "
        << int(mix.g) << " "
        << int(mix.b) << '\n';
  }
}
void restore_palette(playpen & canvas,
                     string filename) {
  ifstream in;
  open_ifstream(in, filename);
  if(in.fail())
    throw problem("Could not open file");
  for(int i(0); i != 256; ++i) {
    canvas.set_entry(i,
                     HueRGB(read<int>(in),
                     read<int>(in),
                     read<int>(in)));
  }
}

I wonder how long you stared at that code before the penny dropped? Even given the advantage of seeing that the result was of writing out a palette and then reading it back resulted in a completely different palette it took me an embarrassing time to realise what the problem was. In a way I was lucky that the error was so visible and that it happened immediately with the compiler I was using.

The problem is that the HueRGB constructor takes three arguments. The fact that they are all identical is not important except that it guarantees that nothing has a chance to detect the error other than the human eye.

Remember that the order of evaluation of sub-expressions is unspecified. The arguments of a function call can be evaluated in any order. The compiler I was using (the MinGW version GCC) evaluates arguments right to left. The data was written to the file left to right. The result was that red and blue values were exchanged by the process.

Elegant though the canvas.set_entry might seem to some, it is fatally flawed by trying to do too much in one gulp and must be replaced by something such as:

int const r(read<int>(in));
int const g(read<int>(in));
int const b(read<int>(in));
HueRGB const p(HueRGB(r, g, b));
Canvas.set_entry(i, p);

It is generally better to evaluate the arguments of a function call like this as it avoids the possibility that an order of evaluation will arise. Making all the intermediate values const variables allows the compiler to optimise but keeps control of the order of evaluation.

Last time I set you the following little problem concerning ‘Greek’ style clues. Unfortunately I miscounted on my fingers and gave you the wrong number (I meant to give you 271, that is covered by ‘apt’, ‘tap’ and ‘pat’). 261 only provides ‘oat’ and ‘Tao’. Perhaps this error confused you into thinking you did not understand the problem. I hope that was the reason that I have not had any responses because otherwise it says little for the creativity of my readers. Anyway here are a couple of possible clues for 261:

And for the intended value (271):

[Based on: A-J representing 1 to 10, J-S representing 10 to 100, S-Z representing 100 to 800.]

So far I have had two entries but the actual selection of prize winners will have to wait till the deadline (either the production editor will manage to sneak it in at the last minute or the announcement will be in the next issue.

I have this from John Kewley:

And Richard Blundell sent me this:

The “seasonal greetings” bit is obviously the phrase you were encoding, namely “Happy Xmas”. But an alternative answer (at least on my phone) is also “Gassy Yobs”, hence the first part of my clue.

And that really gets into cryptic clues by giving the answer two ways.

Thanks to both for making the effort to come up with good clues and remembering to brighten my day by sending them in.

Another form of numerical clue is to use the time or date of some event that is well known to the readership. Clues actually using a time tend to be very much local to groups but dates can be more general:

Notes: 

More fields may be available via dynamicdata ..