Why does 'std::vector<int> b{2};' create a 1-element vector, and not a 2-element one?

Yes, this behaviour is intended, according to §13.3.1.7 Initialization by list-initialization

When objects of non-aggregate class type T are list-initialized (8.5.4), overload resolution selects the constructor in two phases:

— Initially, the candidate functions are the initializer-list constructors (8.5.4) of the class T and the argument list consists of the initializer list as a single argument.

— If no viable initializer-list constructor is found, overload resolution is performed again, where the candidate functions are all the constructors of the class T and the argument list consists of the elements of the initializer list.

As to "the whole purpose of uniform intialization"... "Uniform initialization" is a marketing term, and not a very good description. The standard has all the usual forms of initialization plus list-initialization, but no "uniform initialization". List initialization is not meant to be the ultimate form of initialization, it's just another tool in the utility belt.

Uniform initialization doesn't mean what you think it does. It was added to make initialization more uniform amongst the types in C++. The reasoning is this:

typedef struct dog_ {
   float height;
   int weight;
} dog;
int main() { 
    dog Spot = { 25.6, 45};
    dog Data[3] = { Spot, {6.5, 7} };
    std::array<dog, 2> data = { { Spot, {6.5, 7} } }; //only in C++ obviously
    return 0;
}

This is valid C and C++ code, and has been for many many years. It was really convenient, but you had to remember that this only worked with POD types. People have complained for a long time that there is no way to do std::vector<int> data = { 3, 7, 4, 1, 8};, but some classes (std::array) were written in weird ways to allow initializer list constructors.

So for C++11, the committee made it so that we could make vector and other cool classes do this too. This made construction of all types more uniform, so that we can use {} to initialize via constructors, and also from value lists. The problem you are running into, is that the constructor overload with an std::initializer_list<int> is the best match, and will be selected first. As such, std::vector<int> b{2}; does not mean call the constructor that takes an int, instead it means create a vector from this list of int values. In that light, it makes perfect sense that it would create a vector containing a single value of 2. To call a different constructor, you'll have to use the () syntax so C++ knows you don't want to initialize from a list.

The standard states that the initializer list constructor takes precedence over the others. This is just one case where it isn't possible do just replace () with {}. There are others, for example {} initialization does not allow narrowing conversions.