Forgot your password?
typodupeerror
Programming IT Technology

Stroustrup Says New C++ Standard Delayed Until 2010 Or Later 501

Posted by timothy
from the esperanto-wasn't-built-in-a-day dept.
wandazulu writes "At the end of an article written by the creator of C++, where he talks about removing a feature from the new C++ standard, he drops a bombshell: The new C++ standard (typically referred to as C++0x) has been delayed until 2010 or later. What does this mean? No new C++ features like threads, proper enum classes, or hash tables. C++0x is dead, long live C++1x!"
This discussion has been archived. No new comments can be posted.

Stroustrup Says New C++ Standard Delayed Until 2010 Or Later

Comments Filter:
  • Namespace (Score:5, Funny)

    by Quiet_Desperation (858215) on Thursday July 23, 2009 @02:53PM (#28798423)

    C++0x

    Yes, well, that just rolls off the tongue, doesn't it?

    Maybe he can get one of those hieroglyphs like Prince.

  • C++0A (Score:5, Funny)

    by gr8_phk (621180) on Thursday July 23, 2009 @02:55PM (#28798451)
    Or C++0x0A no need to change the name.
  • Not a bombshell (Score:5, Informative)

    by shutdown -p now (807394) on Thursday July 23, 2009 @02:57PM (#28798491) Journal

    It's not a bombshell by a long measure. Anyone who had been tracking C++0x standardization process (reading comp.std.c++, and WG papers [open-std.org]) knows that the goal of getting the standard out by 2010 was fairly unrealistic, mostly because of concepts [open-std.org]. The joke that "x" in C++0x is actually a hex digit and not decimal has been around for several years now.

  • by cowdung (702933) on Thursday July 23, 2009 @02:57PM (#28798493)

    The latest version of Cobol (eagerly expected by 6 people) will also be delayed till January 2011.

  • by Anonymous Coward on Thursday July 23, 2009 @02:59PM (#28798525)

    The headline completely misses the central part of the article and focuses on a very minor point. Everyone has known for quite a while that C++0x would actually be C++1x. There's only a few months left in 2009, so there's absolutely no surprise there. The real meat of the article is that support for "concepts", a key (and arguably the most anticipated) part of C++0x, is being dropped. That's a major disappointment to many people, including Stroustrup.

    • by ardor (673957) on Thursday July 23, 2009 @03:02PM (#28798565)

      Yeah, but it is reasonable. Concepts are a complex feature, and C++ is an (overly) complex language. Do you really want to hold back all the other very important features like lambda, rvalue references, variadic templates, type deduction etc. just because of concepts?

      • by wowbagger (69688) on Thursday July 23, 2009 @03:40PM (#28799125) Homepage Journal

        "Do you really want to hold back all the other very important features like lambda, rvalue references, variadic templates, type deduction etc. just because of concepts?"

        Unfortunately, without concepts, many of the templates that would make features like those REALLY powerful aren't implementable due to silly things like the compiler insisting upon being able to instantiate member functions that don't make sense for a class and won't be used, just because there isn't a means to tell the compiler "and if this member doesn't make sense, just don't instantiate it, and throw an error IF AND ONLY IF somebody tries to use it." (and yes, I know about SFINAE, but that gets REALLY UGLY to do).

        I've been bit by this, where I ended up having to create two completely separate template classes, one for objects that don't have sub-members and one for objects that do, just because I couldn't tell the compiler "Look, if operator . doesn't exist for this method, then don't worry about it!"

        That said: I will say, I felt that some of the implementation details of concepts felt "forced" to me, in the same way that the streams library feels "forced": they "hacked" (in the bad way) the library in using language semantics that weren't a good fit.

        <sigh/> - I hope the extra time will allow them to put a bit more polish on how you actually express things, and make it feel less "forced"....

      • by jpmorgan (517966) on Thursday July 23, 2009 @05:05PM (#28800239) Homepage
        Absolutely. C++ is a very complex language, and concepts were a feature that was going to be critical in reducing that complexity.
  • Oh, please. (Score:5, Insightful)

    by jcr (53032) <jcr&mac,com> on Thursday July 23, 2009 @03:12PM (#28798713) Journal

    No new C++ features like threads, proper enum classes, or hash tables

    Cause one thing C++ sure doesn't have is enough features, right?

    -jcr

    • Re: (Score:3, Insightful)

      don't like new features, DONT USE THEM, this is one of the few cases where teh new version will not degrade in performance if you ignore the new features!

  • by MobyDisk (75490) on Thursday July 23, 2009 @03:20PM (#28798831) Homepage

    I haven't been following C++0x, but after reading the C++0x FAQ [att.com] I am very pleased. It really fills a lot of the simple, practical holes in the language.

    I think the success of C# is part of why these things are being considered. For example, C# recently added an advanced form of initializer lists - which is now in C++0x. Another example is the scoping of enums, which has long been a pain. Many coding standards require enums to be ALL_CAPS_WITH_UNDER_SCORES because they don't obey scoping rules: this is fixed. NULL is now replaced with nullptr, which is a minor improvement that looks much like how this was done in C++/CLI. (That's the bastardized C++ for .NET). Namespace cleanups, foreach, ... the list is huge, and it looks like C++ is "borrowing back" from Java and C#.

    Competition is good.

    I know that everything I just listed probably exists in many other languages, but C# and Java are very prominent in enterprise development, and are making huge gains. I will be very very glad to see a real ISO standard gaining ground again.

    • by StormReaver (59959) on Thursday July 23, 2009 @04:35PM (#28799845)

      but C# and Java are very prominent in enterprise development, and are making huge gains.

      When discussing languages with coworkers, I've frequently opined that C# is the best thing to have happened to Java in many years. Java had stagnated for a long time without any competitive threat to its domain, which eventually caused me to stop developing in it entirely and focus on C++/Qt.

      A couple years ago, I looked into it again out of curiosity, and saw how far it had come since the introduction of a credible competitor (C#). Swing (it's GUI system, for those who aren't familiar with it) had gotten fast, printing turned from a lame dog into a sports car, and the core language had gained features it lacked until they appeared in C#.

      As much as I despise Microsoft, the competition has been fantastic for Java.

      • Re: (Score:3, Insightful)

        by jez9999 (618189)

        I'd still lurrrrve to see properties in Java.

      • by shutdown -p now (807394) on Thursday July 23, 2009 @07:35PM (#28801851) Journal

        A couple years ago, I looked into it again out of curiosity, and saw how far it had come since the introduction of a credible competitor (C#). Swing (it's GUI system, for those who aren't familiar with it) had gotten fast, printing turned from a lame dog into a sports car, and the core language had gained features it lacked until they appeared in C#.

        Unfortunately, it's still lagging behind. Java may have gotten autoboxing, enums and varargs because C# had them, but in the meantime C# got lambdas (which are arguably far more important in the big scheme of things, and definitely have a bigger impact on how one writes code). And lately, Java language evolution looks like it has stagnated.

        Of course, there's Scala to consider. If only someone with deep pockets would back it...

    • Re: (Score:3, Insightful)

      by Bluesman (104513)

      I read the FAQ and I can't shake the feeling that C++0x is a joke that someone's taken way too far.

      It's kind of like how I believe pop icons like Britney Spears are famous because of music industry execs betting they can make anybody famous and then trying to one-up each other when it works.

      Anyway, my favorite part:

      "Try to imagine what the superset of C99, C#, Java, Haskell, Lisp, Python, and Ada would look like."

      I imagine it would look very similar to Common Lisp.

  • by Demonantis (1340557) on Thursday July 23, 2009 @03:22PM (#28798871)
    C++0x is a goofy name no wonder no one wants to work hard on it. How would you like that on your resume. C+=2 is much more consistent with the language and is much easier to read.
  • who cares? (Score:5, Insightful)

    by speedtux (1307149) on Thursday July 23, 2009 @03:24PM (#28798909)

    C++ has reached staggering complexity already; I don't think adding another 40 pages of complicated features is going to make the language any better.

  • by SpyPlane (733043) on Thursday July 23, 2009 @03:26PM (#28798941)

    I've been following C++0x for a long time now, and have been looking forward to it, but now I'm not so sure I'll ever use it. I was looking forward to Concepts more than anything and with that gone, it seems like a extremely minor upgrade. Also, even when the spec does come out, how many years before we can trust that most compilers can use it effectively... two, three? Then after we've been using it for a while, how long before books come out that tell us that we've been using it all wrong and we have to start over (ie: the Exceptional " " and Effective " " books from Sutter and Meyers)?

    Okay, so I can use C++0x well in 10 years, okay I'll probably be so burned out by then I'll be a manager, or I will have convinced someone to let us use D for embedded work and something managed for everything else.

    • by shutdown -p now (807394) on Thursday July 23, 2009 @04:06PM (#28799473) Journal

      I've been following C++0x for a long time now, and have been looking forward to it, but now I'm not so sure I'll ever use it. I was looking forward to Concepts more than anything and with that gone, it seems like a extremely minor upgrade.

      I would disagree on this part. I'm already using some C++0x features actively in production code, and I can say that they are well worth it. Lambdas are extremely handy as they finally let you use STL (and Boost) algorithms properly without lots of unneeded hand-waving. This may sound a minor thing, but remember how things have changed in C# world when anonymous delegates were introduced in C# 2.0, and their syntax simplified in 3.0? All of a sudden, everyone shifted to functional ("LINQ") techniques of writing code, abandoning hand-coded loops. The same thing happens here.

      The second big part is rvalue references. They really do give major performance benefits for STL containers, especially of user-defined types (as smart implementations of C++03 already optimize their containers for standard types to avoid copy by using swap instead - but they can only legally do it for types they control...).

      One other thing. C++0x may take a while to be released, but you'll see quite a few of its features in production-quality compilers before the spec is finalized. I've already pointed out that some are in VC++2010. There's even more in newer g++ versions (IIRC, they implement all that stuff, and also variadic templates). I've also seen mention of rvalue references and lambdas in the feature list of the most recent C++Builder release. All in all, this means that you'll have them at your disposal within a year or so one way or another.

  • by frank_adrian314159 (469671) on Thursday July 23, 2009 @03:43PM (#28799181) Homepage

    They can't release a new standard until they figure out a way to keep the language from collapsing under its own weight, forming a black hole that would destroy the solar system.

  • by Animats (122034) on Thursday July 23, 2009 @03:51PM (#28799297) Homepage

    Some years ago, the C++ committee went off into template la-la land. Most of the work there focuses on template features that will be used by few, and used correctly by fewer.

    Templates are useful, but "generic programming", doing arbitrary computation at compile time with templates, was a terrible idea. Templates can be abused as a recursive term-rewriting system, and through some clever and obscure tricks, recursive computations can be run at compile time. As a programming language, this trick is awful; awful from a syntax point of view, awful from an understandability point of view, and awful from a debugging point of view. If you need to do work at compile time, there have been much better approaches. LISP "macros" were standard LISP, not a second language. And even they created such a mess that Scheme had to be invented to clean out the language.

    Orignally, templates were conceived as a saner way to do what C programmers did with macros, providing a way to have some type independence at compile time. But the template crowd got out of control.

    The obsession with templates has led to a neglect of things C++ really needed, like better memory safety (C++ still has buffer overflows, and most of the security holes today stem from this), and better approaches to concurrency (the compiler has no idea what locks what, and it needs to know). Anything that wasn't template-related tended to be ignored by the committee.

    The result of this failure has been C++ spinoffs - Java, C#, etc. Even Objective C has made a comeback in the Apple world. C++ has never even been able to displace C, twenty years on.

    I've written a lot of C++, and I'm disgusted with this mess.

    • Re: (Score:3, Interesting)

      by alphabetsoup (953829)

      Templates are what makes programming in C++ a joy compared to other languages. And concepts would have completed the generic programming framework in C++. Concepts are like typechecking for templates. With templates + concepts, programming in C++ would have been almost as elegant as Haskell, except 10 times faster.

      Without generic programming you not have typesafe containers, no smart pointers, no typesafe variadic functions. In fact templates have almost replaced OOP in C++ - libraries like ATL use template

  • Any topic (Score:4, Insightful)

    by BigJClark (1226554) on Thursday July 23, 2009 @05:06PM (#28800247)

    Any topic that involves geeks and C++ is just asking for flame wars, I'll submit my name to the mix.

    Although I've been coding in c++ for more years than half of you have been alive, and am rather biased, I feel good programmers write good code independent of the language they use.
  • by loufoque (1400831) on Thursday July 23, 2009 @07:07PM (#28801573)

    C++0x adds syntactic sugar, no more.
    I'm actually relieved to see concepts dropped, that was probably the biggest useless sugar ever (axioms were not just sugar, but they were the part less ready for inclusion anyway). Everything concepts can do can already be done in C++03 with SFINAE with expressions (which, thankfully, was required explicitly in C++0x unlike C++03 which is quite vague on that topic).

    Lambdas are monomorphic, thus useless. Even a DSEL can do better. Worse, even MACROS can do better (since there is no stupid limit on templates being declared at file scope anymore).
    Rvalue references is just broken magic; relying on NRVO works just fine to implement move semantics and is not as senseless.

    The only real update that comes with C++0x is fixing the standard library so that it doesn't require stuff it doesn't need. Nothing developers haven't already solved by implementing their alternative to the standard library.

    Yet, C++ remains the most awesome language ever.
    Too bad the committee isn't working on actually useful additions, such as virtual templates, which would allow it to compete with dynamic typed languages such as Python.

  • by tp_xyzzy (1575867) on Thursday July 23, 2009 @09:34PM (#28802729)

    Every time I try to start using some other language, it fails. Mostly because other languages do not provide necessary tools to build correct programs.
      1) java failed to support variables in stack, and the whole VM/GC thing is horrible.
      2) haskell failed in supporting for-loops (MapM_ is not exactly the same thing)
      3) erlang failed when it made it too difficult to use existing libraries made with some other language
      4) python failed when it's performance is not very good
      5) C# failed because it's from microsoft
      6) C failed because of it's lack of support for abstractions

    So I keep coming back to c++ every time. It provides combination of performance, low level programming, high level programming, good abstractions, rich tools to build your programs, proper tools for debugging your programs, plenty of libraries available, caveats are well known and workarounds exists, and it keeps working year after year without any compability problems in all supported environments.

    C++0x dropping concepts is a big news. This is because c++ is important. It also means that the concepts proposal was not good enough. Only the best proposals will survive. If concepts needs to go, then they go. C++ is too important to get ruin by proposals that do not work or leads programmers to deadends. Concepts looked like a fine proposal at first, but seems it was still not good enough.

    This might make other languages think they're progressing faster and providing new features faster. The other languages are still struggling to provide even basic support for things that programmers need. It's not the new features that the languages provide that determines if the language is useful. It's what the language fails to provide that counts. If there are big gaps in it's support, the tool is just unusable for use.

  • by Eskarel (565631) on Friday July 24, 2009 @12:58AM (#28803689)
    is that it's losing it's niche.

    The advantages of C and C++ have always been the speed of execution, and it's ability to get really close to the hardware. The problem now is that the speed of execution advantage is fading. Interpreted byte code languages like Java and C# are getting faster and faster, and they byte code has always made them more portable. Add to that that the extra complexity of C++ is often unnecessary, and you start reaching a point where more and more applications which would once have been written in C++ are now being written in C# or Java, this trend is only likely to continue with more and more applications moving onto the web, and continued improvements in the byte code languages themselves.

    There is certainly still a need for C and C++, they are really the only viable languages for writing device drivers and certain core OS components, not to mention all the interpreters necessary for running all these byte code languages. The problem, as I see it, and I'm by no means an expert, is that C++ is continually trying to compete with languages like Java, which it will never be able to functionally do without giving up all of the things which make it powerful and which java can't do. Java is powerful because you don't have to worry about all the things you don't really care about, and C++ is powerful because when you do need to care about them you have the level of control you need(C# tried to allow both, but it doesn't really work that way). The more libraries and features you add to C++ to make it like java, the more complex and bloated you make it, and you're still chasing an unachievable goal because you can't make C++ into Java and you wouldn't really want to.

    I'm not sure why the language is going in this direction, but it seems to me better to use C and C++ where they're appropriate and use Java/C# where they're appropriate and to stop trying to create some jack of all trades language which can't exist.

APL is a write-only language. I can write programs in APL, but I can't read any of them. -- Roy Keir

Working...