I think templates cause a headache in C++ because we are using the same language feature to address two different paradigms. Generic Programming is programming by static interfaces. This is the traditional use of templates as witnessed by Ada and the new Generics in Java. The other paradigm is Generative programming. People often relate the two because of the C++ template connection, but they are two different paradigms. For instance, Template Haskell uses a completely different mechanism for Generative Programming, one that is more orthogonal with the language. C++ Generative Programming with templates was more on accident than by intention; therefore, it is fraught with peril and exception. If the language would separate out its Generic programming facilities from its Generative programming facilities, I believe it would be a much cleaner and simpler language. Note that this also explains why languages with Generics (e.g., Java) are looked upon as less powerful than C++. This is because they only support Generic programming, not Generative. However, it could be that when they do add in Generative support, they do so in a much cleaner manner; giving a more powerful langauge that is simple as well.

On page 2 you have written:

"When efficiency is an issue, and you need ultimate flexibility, C++ is the only object-oriented (multi-paradigm, even) game in town."

I do not agree. Look at Ocaml: http://caml.inria.fr

I _could_ agree if you had inserted "mainstream", "popular", "large community", etc.. somewhere in that sentence.

So there _is_ alternative for C++ which satisfies all of your issues above. It's just not popular and widely-known. Unfortunately.

I enjoyed this article. C++ is definitely the 128-shaft loom of computer programming.

To answer your question: "Which version do you find easier to grok?" -- the Python one! The curiously recurring template pattern still looks like sleight of hand to me (I prefer to use object factories to keep track of instances).

You say that you use Python when you can and C++ when you have to, and mention Boost.Python for connecting the two. What are your thoughts on mixed-language systems?

Also, regarding your statement:

"When efficiency is an issue, and you need ultimate flexibility, C++ is the only object-oriented (multi-paradigm, even) game in town."

I would argue that a mixed language system is a contender -- for example, Python for the main body of the code, C++ for the bits which need to be heavily optimised. (And we do still see some mixed language systems which embed assembler into C/C++ for reasons of efficiency).

I also claim that C is efficient and flexible. In my opinion its simplicity leaves it less open to abuse than C++.

I think the line "The first time _incr executes, the try block fails, since _count has not yet been made an attribute of the class object ..." is incorrect and confuses class attributes with instance (data) attributes. Class attributes can be accessed before an instance of the class is created.

I don't see the need to check for AttributeError when you have already initialised _count to 0.

You can simply use:

class Shape(object):
    _count = 0	# A shared value for Shape classes with no current objects

    @classmethod
    def _incr(cls):
        cls._count += 1

    @classmethod
    def showCount(cls):
        print 'Class %s has count = %s' % (cls.__name__, cls._count)

    def __init__(self):		# A constructor
        self._incr()

Or even simpler:

class Shape(object):
    _count = 0	# A shared value for Shape classes with no current objects

    @classmethod
    def showCount(cls):
        print 'Class %s has count = %s' % (cls.__name__, cls._count)

    def __init__(self):		# A constructor
        self.__class__._count += 1

From the article: “My current leaning is to use Python when I can, C++ when I must (which is still often and usually enjoyable) [6], and to be ever on the lookout for a language that gives most of the power and flexibility of C++ but loses most of the headaches.”

You might want to take a look at Objective C, which to my mind fits the bill quite nicely. Just for fun, I decided to code an example solution in Objective C paralleling your examples, (I'm a bit rusty, having spent most of the past five years working with Java, but it's probably not too far off target). I posted it here:

http://jroller.com/page/JonathanLehr?anchor=a_simpler_programming_language

Jonathan

A couple of Java centric comments on your well written article:

1. The Java world is about to tackel the issue of how to teach Java with the introduction of generics. I would suggest that they should take your advice and stop teaching arrays and primitives and instead stick to Objects and generics for beginners.

2. Java provides an ideal language that is easy to use like Python and runs as well as C++. Therefore one language can be both your beginners/testers language and your powerful developers language.