[SOUND] Now that we've looked at some principles and

have a background on typography, we'll get into how to

achieve good typography on the web in the next few stages.

In the previous stage, we learned how to choose and

serve up font families on the web.

In this session, we'll start with the basics of a font family's weight and

styles like bold and italics.

First, it will be good to mention here that faux bold and

faux italic are faux pas, which simply translates to, don 't do them.

Faux bold or faux italic means it's a false bold or a fake italic.

These can occur when you only have one weight and style of a typeface.

CSS has the ability to fake the bold or italic style of that web font.

But believe me, it ain't pretty and it can hinder legibility.

Without a bold web font called in CSS,

a faux bold is created by thickening up the original web font.

This can create issues with legibility as counters close up,

dark patches of color can appear, and letters get distorted.

Type designers carefully craft their bold weights to correct these issues.

Without an italic web font called in CSS, faux italics are created by obliquing or

slanting the original web font to a certain degree.

At first glance, you might think this looks okay, but let's take a closer look.

Italic versions of serif typefaces are actually created in a more cursive style.

They're not just slanted versions of their regular or roaming counter parts.

They're condensed sum and

often in their letter forms are entirely different altogether.

Notice the changes here.

Such as how the crossbar on the E becomes more fluid.

Or how the F elegantly descends below the baseline.

Because italics are often used for emphasis on the web,

true italics can better emphasize words or phrases than faux italics because of this.

For sans serifs, this cursive nature is less accentuated.

So you might think you can get away with a faux.

But you can't.

Any time you oblique a font, the weight of the letter forms gets

unevenly distributed which creates uneven color.

Also, certain layers can change entirely in a true italic.

Such as a two story Roman a changing to a one story italic a.

Again, type designers meticulously build italic versions of their

fonts correcting these issues.

So be sure to utilize web fonts that have bold and

italics, instead of trying to fake it.

This not only gives the user a better experience, but

it also creates better legibility and readability.

Be aware, too, that some typefaces online are sold as having italics.

But really, they're just uncorrected oblique versions of their fonts.

This is why when choosing a typeface you want to make sure it's

well built with all necessary weights and styles.

Now that we understand that,

let's talk about implementing various weights and styles.

Sometimes typefaces have a basic array of weights like normal and bold.

But other times, a family of fonts can range from thin to light to normal to

semi-bold to bold to black.

We know we can use normal or bold values for those two corresponding weights.

But what can we do for all the others?

CSS has the ability to call different weights through its font weight property.

For those weights outside your basic normal and bold, the best way to

call them is by setting a numerical value in their font weight property.

Weights can be assigned a numerical value ranging from 100, 200, 300 and

so forth to 900, giving us nine potential weights for one font family.

Let's look at a workspace I've set up for style linking with open sans.

I've already downloaded the family from Font Squirrel and

have uploaded the web fonts to our work space and

built a style sheet calling the web fonts through the @font-face declaration.

We've seen how to do this before.

But here, let's pay attention to the font weights and styles.

The family name is set as open sans which will stay the same for all of these.

But I've left the font weight and style properties blank so we can fill those in.

I've also made some comments letting me know which ones are which based on

the different URLs.

First, let's start to define the normal and

bold styles as those will give us reference to the others.

The normal style corresponds to a font weight of 400.

So we'll go to our normal style and add 400 here.

And we know that the font style is normal.

The bold weight corresponds to a font weight of 700.

So we can add that in here and add our font style as normal.

If we were to write 700 or bold here, those terms are interchangeable.

Same with 400 and normal.

So you're able to write either of those.

Great.

Now that we have that accomplished, let's look at the others.

The lightweight falls right between the normal at 400.

So let's head over to that.

And we'll set it at 300, because it's right below 400.

And we'll do our font style as normal.

And then the light italic will be the same thing as 300.

And then we'll do a font style of italic.

For our normal italic, we'll add 400 here, and a font style of italic.

Now let's move on to semi-bold.

We have a choice to make.

Semi-bold falls between normal and bold.

But there's two available numerical values of 500 or 600.

Because semi-bold leans closer to a bolder look,

let's choose 600 and set up its styles.

So we'll use 600, normal for it's font style.

And we'll do 600 for it's weight.

And italic for this one.

We can move on to extra bold, because bold's already been complete.

We'll just want to set up it's italic style.

Now we're at extra bold.

Since it's right above bold, we'll give it a weight of 800 and

a font style of normal for this one.

And then 800 and a font style of italic for this last one.

All right.

Now I've set up the body to be open sans at the normal or 400 weight.

We also have some classes to show you how you can call and

assign a weight to each class.

You can call these classes whatever you like.

I've just labeled them here as the intended font style that it

should be showing.

Now I've also used the font weight property to call the proper weight for

that font style.

Now, we'll save and head over to our HTML to check it out.

Here, we have a similar set up, except for

there's more terms because there's more styles here.

So we have open sans light,

and our class should be light, open sans light italic, and

our class should be light italic, and so forth all the way to open sans extra bold.

So, now that we have that, we'll view our work space and see how it turned out.

Our work space is set up because we're using two different styles.

And for this first one, I'm using the @font-face and

we'll later look at the Google Fonts one.

So we'll click that.

And it looks great.

Open Sans is displaying correctly on the computer, and

its weights are set up properly along with its italics.

You'd always wanna check to make sure these aren't just faux weights or

faux styles by seeing if the italic a you know,

has that one story a versus the two story a and so forth.

In places like Type Kit or

Google Fonts, where you are utilizing a hosted service to call your web fonts.

The service has already set all this up on their end and will provide you

with a numerical value for your CSS, which corresponds to the weight.

For example, on Google Fonts, we see that

the corresponding weight values follow the name like we've seen before.

We also see the numerical values we selected when self-hosting line up

with the values that are selected here.

To cover our bases, let's quickly see how to build the same example web page,

except this time, with Google Fonts.

I'll select all of our open sans weights and styles.

In a real world situation, this and

the previ example would be somewhat impractical, because calling so

many fonts can slow page load times as we see our meter is almost in the red.

But since we're looking at just how to understand this with our weights and

styles, it's okay in this learning environment.

I'll grab the snippet of code here.

And add it to the head of my HTML right before the style sheet.

I'll click Save.

Now let's go check out our CSS.

Our font family is set at Open Sans because that was what Google provided.

And then our weights are set up in the same way with light at 300,

semi-bold at 600, and so forth.

And these are just the classes that are setting called in our HTML here,

like bold, bold italic, and so forth.

We'll hit save and go preview that work space.

This time we're choosing the Google fonts one.

And great.

It worked. We

see that we have multiple weight showing here.

And each weight is correctly set up to its corresponding weight.

So you see we've accomplished the same web page,

except utilize Google font as a hosting service.

As you can see, this requires a lot less work and code than self-hosting, but

it gives you less customization.

Lastly, it should be noted that in Internet Explorer 8, the style linking

method for self-hosting web fonts can only call a total of four weights and styles.

If your target audience utilizes those browsers and you need more weights.

Then you'll need to tweak the code a bit.

So check out the combined method in the @font-face declaration article by

Laura Franz from the teachers notes.

If you're using a web font hosting service,

then they handle much of that on their end.

So you dont have to worry about browser support for multiple weights and styles.

Great. I hope you now understand how to

set up and call different weights and styles through CSS for your font families.

And whether you're self-hosting or using a hosted service, you should be good to go.

In the next video, we'll look at font size and line height.