There are already two compilers that support C++ modules:

 - Clang: http://clang.llvm.org/docs/Modules.html
 - MS VS 2015: http://blogs.msdn.com/b/vcblog/archive/2015/12/03/c-modules-in-vs-2015-update-1.aspx

When starting a new project now, what should I pay attention to in order to be able to adopt the modules feature when it is eventually released in my compiler?

Is it possible to use modules and still maintain compatibility with older compilers that do not support it?

How should I write my C++ to be prepared for C++ modules?

I ran today against a quite subtle issue I&#39;d like to have your opinion on.

Consider the following garden-variety shared-body-idiom class:

    struct S
    {
        S() : p_impl(new impl) {}
    private:
        struct impl;
        boost::shared_ptr&lt;impl&gt; p_impl;
    };
The fun appears when you try to put those into vectors in the following way:

    std::vector&lt;S&gt; v(42);
Now, with MSVC 8 at least, all the elements in `v` share the same `impl` member. Actually, what causes this is the `vector` constructor:

    template &lt;typename T, typename A = ...&gt;
    class vector
    {
        vector(size_t n, const T&amp; x = T(), const A&amp; a = A());
        ...
    };
Under the scenes, only one `S` object gets default constructed, the `n` elements of the `vector` are copied from it.

Now, with C++11, there are rvalue references. So it cannot work like this. If a `vector` is constructed as
    
    std::vector&lt;S&gt; v(42);
then most likely, implementations will chose to default construct the `n` objects inside the vector, since copy construction may not be available. This would be a breaking change in this case.

My question is:

 1. Does the C++03 standard mandates that `std::vector` must have a constructor defined as above, ie. with a default argument ? In particular is there a guarantee that the entries of the vector object get copied instead of default constructed ?
 2. What does the C++11 standard say about this same point ?
 3. I see this as a possibility for a breaking change between C++03 and C+11. Has this issue been investigated ? Solved ?

*PS: Please no comments about the default constructor of the class `S` above. It was this or implementing some form of lazy construction.*

std::vector, default construction, C++11 and breaking changes

I am a little confused.

1. Oracle says Java 8 is highly compatible with Java 7 (backward). But, what possibilities exist that Java 8 program can be run on Java 7 successfully (SE/EE)?

2. If point one was true, Java 8 applications will be deployed and executed on a Java 7 server support? for example, Tomcat 8 or WildFly?



Can program developed with Java 8 be run on Java 7?

Greetings all,

This has confused me ever since I first started coding in C#.  My goal is to create an assembly that will run on the most recent .NET framework the user has, whatever that may be.  I don&#39;t want to require .NET 4 to be installed, but I want to use it if the user has it, and more importantly, I want it to still work if the user has _only_ .NET 4 and nothing below.  I&#39;m beginning to suspect this is not even possible.

I don&#39;t really understand what I&#39;m selecting when I change the &quot;Target Framework&quot; in Visual Studio.  Does that mean &quot;will be compatible with this version and up&quot;?  Or &quot;will be compatible with only this version&quot;?  It seems like it&#39;s the latter so far; my tests in virtual machines show .NET 4 targeted assemblies failing without .NET 4, and .NET 3.5 targeted assemblies failing without .NET 3.5.  Is there no way to set this so I can achieve maximum compatibility?

UPDATE: To clarify, I have a program that targets .NET 2.  The posters here seem to indicate that it should load with .NET 4.  But in an environment with only .NET 4 and nothing before it, it fails to load.

UPDATE2: Okay, figured it out, but it&#39;s far more complex than the posters here seem to think.  I&#39;m opening a different question to discuss the intricacies, but the short version is, you need an app.config with `&lt;supportedRuntime version=&quot;v4.0&quot; /&gt;` in it if you want to run non-.NET 4 assemblies on .NET 4.  They won&#39;t load without it.

What does it really mean to target a framework, and how do I maximize compatibility?

The question is if can I use safely Visual Studio 2012 to edit projects properties, add and remove solutions, references, all related to NET 4.0 Framework.

I remember in the past some files might be &quot;corrupted&quot;, while Visual Studio 2010 changed some Visual Studio 2008 csproj information (xml file).

If some tags are added/removed in VS2012, then the csproj would be incompatible to VS2010 developers.

Does anyone have some information if it is safe to use this new IDE without damaging files? 
Are VS2012 csprojs &quot;backward compatible&quot; with VS2010?

Is Visual Studio 2012 csproj backward compatible with 2010?

I do most of my programming in Python 3.x on Windows 7, but now I need to use the Python Imaging Library (PIL), ImageMagick, and wxPython, all of which require Python 2.x.

Can I have both Python 2.x and Python 3.x installed in Windows 7? When I run a script, how would I &quot;choose&quot; which version of Python should run it? Will the aforementioned programs be able to handle multiple versions of Python installed at once? I have searched for hours and hours for how to do this to no avail.

Thanks.

How to install both Python 2.x and Python 3.x in Windows

What is the best way to take advantage of the new auto layout features of iOS 6 while still providing compability with older devices on earlier versions of iOS?

Enabling auto layout in iOS 6 while remaining backwards compatible with iOS 5

Python has at least six ways of formatting a string:

    In [1]: world = &quot;Earth&quot;
    
    # method 1a
    In [2]: &quot;Hello, %s&quot; % world
    Out[2]: &#39;Hello, Earth&#39;

    # method 1b
    In [3]: &quot;Hello, %(planet)s&quot; % {&quot;planet&quot;: world}
    Out[3]: &#39;Hello, Earth&#39;

    # method 2a
    In [4]: &quot;Hello, {0}&quot;.format(world)
    Out[4]: &#39;Hello, Earth&#39;
    
    # method 2b
    In [5]: &quot;Hello, {planet}&quot;.format(planet=world)
    Out[5]: &#39;Hello, Earth&#39;
 
    # method 2c
    In [6]: f&quot;Hello, {world}&quot;
    Out[6]: &#39;Hello, Earth&#39;

    In [7]: from string import Template
    
    # method 3
    In [8]: Template(&quot;Hello, $planet&quot;).substitute(planet=world)
    Out[8]: &#39;Hello, Earth&#39;

A brief history of the different methods:

* `printf`-style formatting has been around since Pythons infancy
* The `Template` class was introduced in Python 2.4
* The `format` method was introduced in Python 2.6 
* `f`-strings were introduced in Python 3.6

My questions are:

* Is `printf`-style formatting deprecated or going to be deprecated?
* In the `Template class`, is the `substitute` method deprecated or going to be deprecated? (I&#39;m not talking about `safe_substitute`, which as I understand it offers unique capabilities)

Similar questions and why I think they&#39;re not duplicates:

* https://stackoverflow.com/q/5082452/974555 — treats only methods 1 and 2, and asks which one is better; my question is explicitly about deprecation in the light of the Zen of Python

* https://stackoverflow.com/q/8395925/974555 — treats only methods 1a and 1b in the question, 1 and 2 in the answer, and also nothing about deprecation

* https://stackoverflow.com/q/11630106/974555 — mostly about methods 1 and 3, and doesn&#39;t address deprecation

* https://stackoverflow.com/q/1763184/974555 — answer mentions that *the original &#39;%&#39; approach is planned to be deprecated*. But what&#39;s the difference between *planned to be deprecated*, *pending deprecation* and actual *deprecation*? And the `printf`-style method doesn&#39;t raise even a `PendingDeprecationWarning`, so is this really going to be deprecated? This post is also quite old, so the information may be outdated.

## See also
 * [PEP 502: String Interpolation - Extended Discussion](https://www.python.org/dev/peps/pep-0502/)
 * [String Formatter](https://docs.python.org/2/library/string.html#string.Formatter)

Python&#39;s many ways of string formatting — are the older ones (going to be) deprecated?

I&#39;m working on a mobile phone web app and I have several text fields that could benefit from `&lt;input type=&quot;tel&quot;/&gt;`. iPhones will adjust the keyboard for the user, but I&#39;m worried about breaking backwards compatibility. What I&#39;m hoping is that browsers/phone that support this can assist the user and other browser will fall back to a standard text field? Is this an acceptable practice? Does it even work?

Is it okay to use &lt;input type=&quot;tel&quot;/&gt; now?

I&#39;m trying to create a universal iPhone app, but it uses a class defined only in a newer version of the SDK. The framework exists on older systems, but a class defined in the framework doesn&#39;t.

I know I want to use some kind of weak linking, but any documentation I can find talks about runtime checks for function existence - how do I check that a class exists?

Weak Linking - check if a class exists and use that class

I have learned that Python 3 is not backwards compatible.

Will it not affect a lot of applications using older versions of Python?

How did the developers of Python 3 not think it was absolutely necessary to make it backwards compatible?

Why is Python 3 not backwards compatible?

**Backward** binary compatibility (or **downward** compatibility) - an ability of clients built with an old version of library API to run on a new one ([wiki][1]).

**Upward** binary compatibility (or **forward** compatibility) - an ability of clients built with a new version of library API to run on old one ([wiki][2]).

The general Sun&#39;s document about JDK [Incompatibilities in J2SE 5.0 since 1.4.2][3] (and [Java SE 6 compatibility with J2SE 5.0][4] too) describes the compatibility of JDK as following:

&gt; JDK 5.0 is **upwards** binary-compatible with Java 2 SDK, v1.4.2 except for the incompatibilities listed below. This means that, except for the noted incompatibilities, **class files built with version 1.4.2 compilers will run correctly in JDK 5.0**.

I suppose that documentation writers have **mixed up** terms &quot;upward&quot; and &quot;backward&quot; compatibility in this sentence. They describe a &quot;backward&quot; compatibility, but call this feature as &quot;upward&quot; compatibility.

Is this a typo, mistake or intended term here?
Is JDK &quot;upward&quot; or &quot;backward&quot; compatible?

  [1]: http://en.wikipedia.org/wiki/Backward_compatibility
  [2]: http://en.wikipedia.org/wiki/Forward_compatibility
  [3]: http://java.sun.com/j2se/1.5.0/compatibility.html
  [4]: http://www.oracle.com/technetwork/java/javase/compatibility-137541.html



Is JDK &quot;upward&quot; or &quot;backward&quot; compatible?

I have renamed a python class that is part of a library. I am willing to leave a possibility to use its previous name for some time but would like to warn user that it&#39;s deprecated and will be removed in the future.

I think that to provide backward compatibility it will be enough to use an alias like that:

    class NewClsName:
        pass

    OldClsName = NewClsName

I have no idea how to mark the `OldClsName` as deprecated in an elegant way. Maybe I could make `OldClsName` a function which emits a warning (to logs) and constructs the `NewClsName` object from its parameters (using `*args` and `**kvargs`) but it doesn&#39;t seem elegant enough (or maybe it is?).

However, I don&#39;t know how Python standard library deprecation warnings work. I imagine that there may be some nice magic to deal with deprecation, e.g. allowing treating it as errors or silencing depending on some interpreter&#39;s command line option.

The question is: How to warn users about using an obsolete class alias (or obsolete class in general).

**EDIT**: The function approach doesn&#39;t work for me (I already gave it a try) because the class has some class methods (factory methods) which can&#39;t be called when the `OldClsName` is defined as a function. Following code won&#39;t work:

    class NewClsName(object):
        @classmethod
        def CreateVariant1( cls, ... ):
            pass

        @classmethod
        def CreateVariant2( cls, ... ):
            pass

    def OldClsName(*args, **kwargs):
        warnings.warn(&quot;The &#39;OldClsName&#39; class was renamed [...]&quot;,
                      DeprecationWarning )
        return NewClsName(*args, **kwargs)

    OldClsName.CreateVariant1( ... )

Because of:

    AttributeError: &#39;function&#39; object has no attribute &#39;CreateVariant1&#39;

Is inheritance my only option? To be honest, it doesn&#39;t look very clean to me - it affects class hierarchy through introduction of unnecessary derivation. Additionally, `OldClsName is not NewClsName` what is not an issue in most cases but may be a problem in case of poorly written code using the library.

I could also create a dummy, unrelated `OldClsName` class and implement a constructor as well as wrappers for all class methods in it, but it is even worse solution, in my opinion.

How to warn about class (name) deprecation

From examples provided on the Android Developer pages I see that new Views, like the `RecyclerView`, are backward compatible (`android.support.v7.widget.RecyclerView`).

Are all the new things introduced in Material Design backward compatible (to which version)?

Material Design backward compatibility

I&#39;d like to be able to create a function like:

    class A {
      private String extraVar;
      public String myFormat(String format, Object ... args){
        return String.format(format, extraVar, args);
      }
    }

The problem here is that `args` is treated as `Object[]` in the method `myFormat`, and thus is a single argument to `String.format`, while I&#39;d like every single `Object` in `args` to be passed as a new argument. Since `String.format` is also a method with variable arguments, this should be possible.

If this is not possible, is there a method like `String.format(String format, Object[] args)`? In that case I could prepend `extraVar` to `args` using a new array and pass it to that method.


All Backwards Compatibility Solutions on Gang of Coders

Total of 15 Backwards Compatibility Solutions