//

Douglas Gregor on Variadic Templates

noreply@blogger.com (Jon) — Sun, 20 Aug 2006 07:02:00 +0000

Doug is a post-doctoral research fellow in the Open Systems Lab, part of the Computer Science department at Indiana University, Bloomington. His email is dgregor -at- cs.indiana.edu and his home page is http://www.osl.iu.edu/~dgregor.

//: You've just finished implementing Variadic Templates. What the heck are Variadic Templates?

Gregor: Variadic templates are templates that can take an arbitrary number of "extra" template arguments. Most templates take a fixed number of parameters. For example, an STL map has 4 parameters (Key, Data, Compare, Alloc) while an STL pair has two parameters (T and U). But what happens when you want to generalize a pair into a tuple (for any N), like in the Boost Tuples library? You really need tuple to take any number of template arguments: variadic templates allow you to do so, by creating class and function templates that accept any number of arguments. Variadic templates also allow you to perform transformations on all of these arguments in one step, turning many non-trivial metaprograms into simple one-line statements.

//: C++ programmers are familiar with the concept with variadic function parameters from C. But we've been cautioned to avoid them. Why are Variadic Templates safer?

Gregor: C-style variadic functions are unsafe because all type information is lost when passing arguments through C's "...". That's why only built-in and Plain Old Data types work with with C-style variadic functions, and even with those we're left wide open to format string attacks.

Variadic templates are safer because, as templates, they retain complete type information at compile-time. With printf() implemented as a variadic template, we don't need the format string to tell us the type of each argument, because we have its static type when we instantiate the template. So instead of crashing when printf() is given a format string that doesn't match the actual arguments, we can just detect the error and throw an exception.

//: How are VTs helpful? What do they make possible, easier, or better?

Gregor: Variadic templates make it easier to write templates that work with any number of arguments. You can fake variadic templates in the language, but the result is usually a mess of duplicated code, artificial upper limits on the number of template arguments, and preprocessor meta-programming. If you don't believe me, look at the implementation of Boost's Function, Bind, or Tuple libraries: we can shrink the implementation of these libraries from tens of thousands of lines of redundant code to a few pages of relatively simple code. Perhaps best of all, we can bring the March of Progress full circle, providing the succinct (and popular!) syntax of printf and scanf for all of C++, providing the type safety that we expect from the language. Although we haven't explored it in detail yet, we've also found that variadic templates are very powerful tools for template metaprogramming.

//: Where can we learn more about how to use them?

Gregor: The best source of information on variadic templates is in the introduction and proposal on the variadic templates web page: http://www.generic-programming.org/~dgregor/cpp/variadic-templates.html.

The introduction gives a short description of the implementation of a completely type-safe printf using variadic templates. The (much longer) proposal provides annotated implementations of several interesting facilities that make heavy use of variadic templates. Like all language features, the best way to understand a feature is to try it out: the examples in the proposal are a good starting point.

//: This sounds like a language extension that can't be implemented with a library. Is this a compiler mod? Which compiler? How can we get it to play with?

Gregor: Variadic templates cannot be implemented purely in a library, so I've implemented them in the GNU C++ compiler. Patches against the latest version of GCC are available from http://www.generic-programming.org/~dgregor/cpp/variadic-templates.html. I encourage anyone interested in variadic templates to give the compiler a try: even after thinking about variadic templates for four years, it wasn't until I got to play with them that I really understood how they worked. Of course, I welcome any feedback!

//: So when will this be part of the official GCC release?

Gregor: I expect to officially submit the variadic templates patches to GCC in the very near future. After that, the decision of when to ship variadic templates is in the hands of the GCC maintainers. The good news is that variadic templates have been discussed before on the GCC mailing lists, and there is an open feature request from one of the maintainers for its inclusion. And unlike our other GCC hack, the implementation of variadic templates is quite small and quite stable. Optimistically, I think we could see variadic template support in the official GCC 4.2.1 or 4.3.0.

//: You are on the C++ Standards committee. Does this mean that we'll see VTs become part of the C++ Standard?

Gregor: I hope so. I will bring the latest variadic templates proposal to the upcoming C++ committee meeting in Portland, but the C++ committee as a whole decides what will go into the next C++ standard. Having a complete implementation in GCC helps greatly (implementability is the first major hurdle for a proposal), but the biggest factor for acceptance is whether the community wants this feature in the language. In particular, variadic templates have always been viewed as a niche feature for expert library developers. Do you like variadic templates? Write your local C++ committee representative or show your support on comp.std.c++!

//: Who do you think authored the Shakespearean canon?

Gregor: Alas, I think the truth of the matter is that William Shakespeare was "merely" a brilliant man, and any authorship questions are unnecessary drama. In truth, I am more interested in the mathematical side of things, and the story of Nicolar Bourbaki.

and or not

noreply@blogger.com (Jon) — Tue, 15 Aug 2006 04:25:00 +0000

I was looking at some of my code the other day with a co-worker. He noticed that I wasn't using the && or || operators and rarely the ! operator. Instead I was using "and," "or," and "not."

I pointed out that I find them much clearer and easier to understand. Since programming for clarity is one of my top goals, it is a no brainer for me to use English words in place of more cryptic symbols.

He agreed and asked what header he had to include to use this symbols and was surpised when I told him that no header is needed. These are not gasp! macros. All of these are reserved words and part of the core language for Standard C++.

You can start using this words right now. And I encourage you to do so.

Bjarne Stroustrup on Teaching C++

noreply@blogger.com (Jon) — Sun, 13 Aug 2006 04:07:00 +0000

//: You left Bell Labs to accept a position at Texas A&M working with !eek! college students. How long ago did you do this and why?

Stroustrup: I left New Jersey for Texas more than three years ago.

Students aren't "!eek!". Teaching was one of the reasons I went to academia. Had I not wanted to teach, I could have stayed at AT&T Labs - my job there was full-time research. I felt that I - after 25 years of research and application - had something pretty unique to teach the students. Unfortunately, the average professor have never practiced what they preach and that sometimes weakens the message they send.

It was time for a change. How many people today have stayed in one job for 25 years? It was the most varied of "jobs" and actually, I still do part of it because I didn't sever my connection with AT&T Labs completely (they didn't allow me to :-) and there are continuation in my projects. Academia is different from industrial research in many ways, some good, some not so good, but it is different, and "different" is stimulating.

Texas A&M university is one of the few major US universities that is currently going through a period of major expansion - in quality and quantity. For example, our CS department hired 4 new assistent professors this year. You can see and feel the rapid improvement of department . It is great to be part of an improving and expanding organization! This year, I have papers in POPL and OOPSLA with colleagues - for good and bad, writing papers is a much more central part of academic life than the life of an industrial researcher.

//: What level of students do you teach?

Stroustrup: I teach freshmen and graduates. Currently, I teach my graduate students practical language design through case studies from the C++0x effort. Before that, I was focussing on the software frameworks for distributed programming (CORBA, .Net, J2EE). I think that graduate students know a lot about the science of computer science, but too little about the theory and practice of constructing quality software. For example, they tend to know their algorithms, data structures, and machine architectures, but not how to combine the knowledge from those academic fields into maintainable and well-preforming software at a real-world scale.

So, with my freshmen, I teach what I plan to be the basis for a more effective approach to designing and implementing software. Together with experienced colleagues, I have taught a first programming course for engineering freshmen, which from this fall will also become the standard first course for computer science freshmen.

We are completely overhauling our undergraduate curriculum, and I expect the graduate curriculum will have to be revised to keep up.

//: What have you learned from observing students as they learn C++?

Stroustrup: They are bright, but mistaught. The high schools have drilled them more than educated them and given them an unrealistic idea of what it takes to succeed in today's world. Most think that doing well is to regurgitate information and to be able to compute the answer to a question that you have seen in many slightly different versions before! Real search for answers and synthesis of systems from parts seems very novel to most. Most - being bright (most of our engineering students were near the top of their class) - also found it too easy to succeed in highschool. They therefore are surprised that in university it takes more work and smarter work just to be average!

None of this has much to do with C++, but the most important aspect of teaching freshment is to reajust their expectation of what is required. We would do them a severe disservice if we allowed them not to grow.

Fortunately - being bright and ambitious - many seem to be stimulated by the new challenges and approaches.

//: Has this changed the way you feel about C++ or its future? What changes to the standard language or library might we see because of what you've learned while teaching?

Stroustrup: My view has not been fundamentally changed, but some views have been reinforced. I felt that C++ had become too "expert friendly" and unnecessily hard to teach. I hope to deal with some of that in C++0x, but it is a tough task because of course everyone voting in the standards committees is an expert of some sort, so attention naturally shifts towards what helps experts. I constantly try to yank their attention back to novices - "novices of all backgrounds" because as long as we keep learning we are all novices at something.

For concrete examples, see my writings on C++0x.

//: For awhile, Java was all the rage in college curriculums. Has that changed or are college grads with C++ knowledge going to be getting rare?

Stroustrup: I don't have the global view to answer that question with any certainty, but it seems that most students have some knowledge of C++. C++ still dominates the "harder" areas where performance (time or space) is important or where the distance between Java and the machine is a problem. I have seen a few school switch to C++ recently and a lot of embedded systems projects (mostly in industry) move to C++. The apparent shortage of C++ programmers is partly an increased demand and a mismatch between what is taught (fairly mondane PC projects) and where the increase in C++ usage occur (demanding, large, high-performance, high-reliabily applications).

For a short list of C++ applications, see the list on my home page.

Interestingly, we (I personally and TAMU CS) have had quiet a few requests from industry (big name companies) to increase our emphasis on software development skills and skills that prepare the students to work closer to the hardware. That, of course means C++ and I'm keen to make sure that it means modern C++ rather than glorified assembly code expressed in C style.

//: There are a number of good C++ books for professionals (including several that have been written or edited by you), but the story is different for C++ text books. What is your opinion of the C++ text books currently on offer? What do you use in your classes? Might we see a text book by Bjarne Stroustrup in the future?

Stroustrup: I have not been impressed by the current crop of C++ books for beginners (the books by Francis Glassborow and Koenig&Moo are exceptions, but address niche markets), so yes, I had to construct the materials for my beginning programming course from scratch. Of course I use C++. This is likely to become available as a book next year after being field tested on a few hundred freshmen for a couple of years.

I call my approach "depth first". The aim is to get to writing realistc code as soon as possible (e.g. file processing is week 6 and GUI is week 8) together with an emphasis on correctness and maintainability.

We teach the basic use of the STL together with the basics of its implementation and general principles.

Fundamentals are important in this time of rapid change because fundamentals is what changes the least.

//: Who do you think authored the Shakespearean canon?

Stroustrup: No opinions. I'm not really a Shakespeare buff. I like history better; try the world's oldest blog.