j a c k *

I Hate C++: Dots and Arrows...

C++ was a huge disappointment. Touted as a next-generation C language, it should have had all the power of a modern, object-oriented language, but with fewer of the painful and annoying aspects of C. It was the big chance to take the lessons of what was right and wrong about C -- generally a pretty good language -- and apply them to language designed from the ground up to be a standard.

An opportunity that was entirely squandered.

I have a long list of these things -- little things that affect every C programmer every day that could have been fixed in C++. I don't want to list them all because that would be boring, but I want to give a couple of examples. As part 1 of my series, I give you the difference between 'dot' and 'arrow'. It leaves a bad taste in my mouth every single time it trips me up.

There is only one interesting thing you can do with pointers in C: you can dereference them. They can be treated as quasi-numbers for certain purposes, but when the rubber meets the road you have to follow the pointer and find the object that it refers to. This is done like this:

x = *x_ptr;

Structures, on the other hand, are mainly containers for things, so what you do is access their fields. This is done like this:

x = s.x_field;

It turns out that real-world code almost always deals with pointers to structures, and most of the time when you want to act on a pointer to a structure you want to access the fields of the structure. Using the notation of pointers and structures, this would be done like this:

x = (*s_ptr).x_field;

Even the original creators of the C language realized that this is ugly in the extreme. So they added some syntactic sugar to their compiler to hide this idiom. Instead of a combination of asterisk and dot, C programmers write this:

x = s_ptr->x_field;

This arrow operator only works on pointers to structures, and the dot operator only works on structures. The compiler will complain if you confuse the two -- telling you very specifically that you are using the wrong set of punctuation marks. I consider this one of the most annoying design flubs in the original C language. The two forms are logically identical; there's no reason why they shouldn't be interchangeable. I should be able to write:

x = s_ptr.x_field;

There's no possible ambiguity since the dot operator cannot apply to a pointer. If it's a pointer to a structure the compiler should be able to dereference it automatically before accessing the field. Using a different operator was sheer laziness on the part of the original C-compiler authors.

Is this fixed in C++? It was a golden opportunity, but no. C++ compilers still smugly point out that you're using the wrong operator but don't lift a finger to help. C++ will make implicit casts left and right, calling hidden methods behind your back at a moment's notice, but it will not treat a dereference like a cast -- converting automatically from a pointer to the thing itself as needed. That's just lame.

- jack*

UPDATE: part 2

Breaking News: News Broken...

There's a lot that can be said about the Shirley Sherrod saga, and there's plenty of blame and shame to go around, but I want to focus on one small aspect. Or, perhaps, the only thing that matters. Josh Marshall and David Frum have pointed out that this fiasco shows the media in this country is broken. My point is that it's deliberate.

The modern conservative movement and Republicans in particular work to destroy that which opposes their radical, redistributive agenda by controlling it. In governance paid-for politicians strive to point out how inherently bad government is at the same time that they, themselves, enact disastrous and destructive policies. Deficits are bad, they tell us. And yet massive tax cuts are touted as an economic boon, while social and stimulative spending are routed as budget-busting in opposition to logic and common sense. Of course the result is even more deficits. So Republican politicians in power can now turn around and tell us -- despite the policies that they, themselves, enacted -- "See? Government doesn't work."

The exact same plan to subvert a thing against itself has succeeded, brilliantly, to destroy journalism. Objectivity is impossible, they say -- everyone has a bias, and media bias is almost entirely liberal. Somehow this allows them to justify a right-wing bias that would make the worst butchers in history blush. From this position of authority they spout a constant stream of attacks, smears and innuendo against their political opponents. And when one of those attacks -- as in the Sherrod case -- turns out to be almost criminally lacking in the most basic of journalistic ethics, what do they do? Those same paid-for media faces turn around and tell us, "See? Journalism is inherently biased."

Our system relies on two systems as a final check on authoritarian power. The first is the vote, which depends on citizens having confidence in elected officials acting in their interests. The second is the free press, which reports when elected officials aren't acting in their constituents' interests. We cannot afford both parts of this feedback cycle to be deliberately and systematically destroyed by a cynical but powerful minority.

- jack*

Why I Hate C++, intro...

I've been a software engineer for a pretty long time. I'm not completely grey and insensible yet, but that's because I started young. My first professional gig, when I was a high-school student in the late 70's, involved programming in FORTRAN. The C language had very little traction at that point outside of universities.

That changed. C practitioners struggled and fought their way into the mainstream, until eventually C had displaced most other languages based on pure popularity. I was also a C convert because I could get more done in C than in nearly any other language. It was parsimonious and straightforward, and you could save a lot of keystrokes by typing "{" (open-curly-bracket) instead of the word "begin".

Sometime in the late 1980's there was a market struggle between C++ and Objective-C as to which would be the logical follow-on to the reigning C language. Both were object-oriented and had some strengths and weaknesses relative to each other, so it was kind of an interesting debate. I was a bit of an Objective-C partisan but I was open to being convinced. But never mind. C++ won not because of superior design features but because of something like nepotism. C was a standard, and C++ was the new standard designed by a duly anointed standards body. Thus the heir apparent assumed the throne.

But C++ was a benevolent dictator. You could still write in "standard" C if you wanted to, and as long as you eschewed the magic keywords like "class" and "new" the C++ compilers would let you do it. So, for another decade or two, I continued to write plain old C code. C++ held very little appeal for me.

To be clear, I am an object-oriented programmer. I like object-oriented techniques and use them routinely -- in C. Anyone who thinks you need object-oriented language constructs to write object-oriented code is very confused or -- more likely -- just young. I was writing object-oriented code in FORTRAN before some of these C++ programmers were even born.

For various reasons, but mostly because (a) I need to develop an SDK that will appeal to today's programmers, and (b) I'm interested in expanding my own skill set, I have been writing a lot of C++ lately. I am not, by any means, a C++ expert. There's a very great deal of knowledge required to make that claim, and I am nowhere near that level. But I have a good background in many languages and have designed many of my own.

So hopefully it's clear I'm not an idiot, and at the very least I can give good reasons why this old engineer hates C++.

- jack*

UPDATE: part 1