Cost of font-family vs font-weight - css

Question

I've inherited a code project wherein the fonts are not set up in the most sensible way. The site uses a few weights of the Proxima Nova font.
Instead of binding these font files to the same font family (i.e. font-family: "Proxima Nova"), a new font-family is created for each weight of the Proxima Nova font.
In practice, what this means is that in order to change the font weight, you write font-family: "Proxima Nova Bold" instead of font-weight: 700.
I am curious to know if this has consequences other than the obvious legibility problems. The more technical the answer, the better.
EDIT:
Here is an example to illustrate what my preferred method is, in case there's something wrong with how I do things:
#font-face {
font-family: 'Ubuntu';
src: url('Ubuntu-RI-webfont.eot');
src: url('Ubuntu-RI-webfont.eot?#iefix') format('embedded-opentype'),
url('Ubuntu-RI-webfont.woff') format('woff'),
url('Ubuntu-RI-webfont.ttf') format('truetype'),
url('Ubuntu-RI-webfont.svg#UbuntuItalic') format('svg');
font-weight: normal;
font-style: italic;
}
#font-face {
font-family: 'Ubuntu';
src: url('Ubuntu-B-webfont.eot');
src: url('Ubuntu-B-webfont.eot?#iefix') format('embedded-opentype'),
url('Ubuntu-B-webfont.woff') format('woff'),
url('Ubuntu-B-webfont.ttf') format('truetype'),
url('Ubuntu-B-webfont.svg#UbuntuBold') format('svg');
font-weight: 700;
font-style: normal;
}
Another example: #font-face: Only using one font-family with different font-weights?

Answer 1

Short answer: no.
The properties you specify in a #font-face rule are used to resolve "the font-... values tuple" to "the actual font resource on the network indicated by src", so whether you declare your font as:
#font-face {
/* identifying font-... values: 1 */
font-family: SillyBoldItalicSmallcaps;
/* font resource to use when values match: */
src: url(./font-bold-italic-SC.woff) format("WOFF");
}
and then resolve it with some document CSS using:
.rulename {
/* values to use to find a specific font resource: 1 */
font-family: SillyBoldItalicSmallcaps;
}
(where the tuple {font-family} is matched against the declared tuple) or whether you declare your font as:
#font-face {
/* identifying font-... values: 4 */
font-family: MyFont;
font-weight: bold;
font-style: italic;
font-variant: smallcaps;
/* font resource to use when values match: */
src: url(./font-bold-italic-SC.woff) format("WOFF");
}
and then resolve it with some document CSS using:
.rulename {
/* values to use to find a specific font resource: 4 */
font-family: MyFont;
font-weight: bold;
font-style: italic;
font-variant: smallcaps;
}
(where the tuple {font-family,font-weight,font-style,font-variant} is matched against the declared tuple) there is no difference in the actual resource found by the CSS engine based on the font-... values you provided. Both end up finding the ./font-bold-italic-sc.WOFF font for styling the text: the core mechanic is the same in both cases, in that we "resolve a font-... values tuple to the declared resource that matches that values tuple". The important thing to note is that in both cases the tuples are unique. In the first case because the font-family is a uniquely identifying string, in the second case because while the font-family may no longer be uniquely identifying, the additional property values yield a unique combination that can resolve to a single font resource.
The only real difference is that the latter makes life considerably easier when it comes to development and maintenance (the end result is identical as far as the consuming client is concerned). And ease translates directly into improved efficient, better code, lower cost, and a whole slew of things that all translate into "we should be doing it this way".

Answer 2

It is often a result of the actual font file encoding and not related to any usage. Some font vendors do not package their fonts into one nice, easy family. But instead the foundry itself splits each weight into a new file. (I dislike this, but it's not really that uncommon.)
I believe that Proxima Nova is one such font -- where each weight is a separate file and not part of one "family" file.