In this article by Alex Libby, Gaurav Gupta, and Asoj Talesra, the authors of the book, Responsive Web Design with HTML5 and CSS3 Essentials we will cover the basic elements of responsive web design (RWD).
Getting started with Responsive Web Design
If one had to describe Responsive Web Design in a sentence, then responsive design describes how the content is displayed across various screens and devices, such as mobiles, tablets, phablets or desktops. To understand what this means, let’s use water as an example. The property of water is that it takes the shape of the container in which it is poured.
It is an approach in which a website or a webpage adjusts the layout according to the size or resolution of the screen dynamically. This ensures that the users get the best experience while using the website.
We develop a single website that uses a single code base. This will contain fluid, flexible images, proportion-based grids, fluid images or videos and CSS3 media queries to work across multiple devices and device resolutions—the key to making them work is the use of percentage values in place of fixed units, such as pixels or ems-based sizes.
The best part of this is that we can use this technique without the knowledge or need of server based/backend solutions—to see it in action, we can use Packt’s website as an example. Go ahead and browse to https://www.packtpub.com/web-development/mastering-html5-forms; this is what we will see as a desktop view:
The mobile view for the same website shows this if viewed on a smaller device:
We can clearly see the same core content is being displayed (that is, an image of the book, the buy button, pricing details and information about the book), but element such as the menu have been transformed into a single drop down located in the top left corner. This is what responsive web design is all about—producing a flexible design that adapts according to which device we choose to use in a format that suits the device being used.
Understanding the elements of RWD
Now that we’ve been introduced to RWD, it’s important to understand some of the elements that make up the philosophy of what we know as flexible design. A key part of this is understanding the viewport or visible screen estate available to us—in addition, there are several key elements that make up RWD.
There are several key elements involved—in addition to viewports, these center around viewports, flexible media, responsive text and grids, and media queries. We will cover each in more detail later in the book, but for now, let’s have a quick overview of the elements that make up RWD.
Controlling the viewport
A key part of RWD is working with the viewport, or visible content area on a device. If we’re working with desktops, then it is usually the resolution; this is not the case for mobile devices.
There is a temptation to reach for JavaScript (or a library, such as jQuery) to set values, such as viewport width or height: there is no need, as we can do this using CSS:
<meta name="viewport" content="width=device-width">Or by using this directive:
<meta name="viewport" content="width=device-width, initial-scale=1">This means that the browser should render the width of the page to the same width as the browser window—if, for example, the latter is 480px, then the width of the page will be 480px. To see what a difference not setting a viewport can have, take a look at this example screenshot:
This example was created from displaying some text in Chrome, in iPhone 6 Plus emulation mode, but without a viewport. Now, let’s take a look at the same text, but this time with a viewport directive set:
Even though this is a simple example, do you notice any difference? Yes, the title color has changed, but more importantly the width of our display has increased. This is all part of setting a viewport—browsers frequently assume we want to view content as if we’re on a desktop PC. If we don’t tell it that the viewport area has been shrunken in size, it will try to shoe horn all of the content into a smaller size, which doesn’t work very well!
It’s critical therefore that we set the right viewport for our design and that we allow it to scale up or down in size, irrespective of the device—we will explore this in more detail.
Creating flexible grids
When designing responsive websites, we can either create our own layout or use a grid system already created for use, such as Bootstrap. The key here though is ensuring that the mechanics of our layout sizes and spacing are set according to the content we want to display for our users, and that when the browser is resized in width, it realigns itself correctly.
For many developers, the standard unit of measure has been pixel values; a key part of responsive design is to make the switch to using percentage and em (or preferably rem) units. The latter scale better than standard pixels, although there is a certain leap of faith needed to get accustomed to working with the replacements!
Making media responsive
A key part of our layout is, of course, images and text—the former though can give designers a bit of a headache, as it is not enough to simply use large images and set overflow: hidden to hide the parts that are not visible!
Images in a responsive website must be as flexible as the grid used to host them—for some, this may be a big issue if the website is very content-heavy; now is a good time to consider if some of that content is no longer needed, and can be removed from the website. We can, of course simply apply display: none to any image which shouldn’t be displayed, according to the viewport set. This isn’t a good idea though, as content still has to be downloaded before styles can be applied; it means we’re downloading more than is necessary! Instead, we should assess the level of content, make sure it is fully optimized, and apply percentage values so it can be resized automatically to a suitable size when the browser viewport changes.
Constructing suitable breakpoints
With content and media in place, we must turn our attention to media queries—there is a temptation to create queries that suit specific devices, but this can become a maintenance headache.
We can avoid the headache by designing queries based on where the content breaks, rather than for specific devices—the trick to this is to start small and gradually enhance the experience, with the use of media queries:
<link rel="stylesheet" media="(max-device-width: 320px)" href="mobile.css" />
<link rel="stylesheet" media="(min-width: 1600px)" href="widescreen.css" />We should aim for around 75 characters per line, to maintain an optimal length for our content.
Introducing flexible grid layouts
For many years, designers have built layouts of different types—they may be as simple as a calling card website, right through to a theme for a content management system, such as WordPress or Joomla. The meteoric rise of accessing the Internet through different devices means that we can no longer create layouts that are tied to specific devices or sizes—we must be flexible!
To achieve this flexibility requires us to embrace a number of changes in our design process – the first being the type of layout we should create. A key part of this is the use of percentage values to define our layouts; rather than create something from ground up, we can make use of a predefined grid system that has been tried and tested, as a basis for future designs.
The irony is that there are lots of grid systems vying for our attention, so without further ado, let’s make a start by exploring the different types of layouts, and how they compare to responsive designs.
Understanding the different layout types
A problem that has been faced by web designers for some years is the type of layout their website should use—should it be fluid, fixed width, have the benefits of being elastic or a hybrid version that draws on the benefits of a mix of these layouts?
The type of layout we choose use will of course depend on client requirements—making it a fluid layout means we are effectively one step closer to making it responsive: the difference being that the latter uses media queries to allow resizing of content for different devices, not just normal desktops!
To understand the differences, and how responsive layouts compare, let’s take a quick look at each in turn:
- Fixed-Width layouts: These are constrained to a fixed with; a good size is around 960px, as this can be split equally into columns, with no remainder. The downside is the fixed width makes assumptions about the available viewport area, and that if the screen is too small or large, it results in scrolling or lots of which affects the user experience.
- Fluid layouts: Instead of using static values, we use percentage-based units; it means that no matter what the size of the browser window, our website will adjust accordingly. This removes the problems that surround fixed layouts at a stroke.
- Elastic layouts: They are similar to fluid layouts, but the constraints are measure by type or font size, using em or rem units; these are based on the defined font size, so 16px is 1 rem, 32px is 2 rem, and so on. These layouts allow for decent readability, with lines of 45-70 characters; font sizes are resized automatically. We may still see scrollbars appear in some instances, or experience some odd effects, if we zoom our page content.
- Hybrid layouts: They combine a mix of two or more of these different layout types; this allows us to choose static widths for some elements whilst others remain elastic or fluid.
In comparison, responsive layouts take fluid layouts a step further, by using media queries to not only make our designs resize automatically, but present different views of our content on multiple devices.
Exploring the benefits of flexible grid layouts
Now that we’ve been introduced to grid layouts as a tenet of responsive design, it’s a good opportunity to explore why we should use them. Creating a layout from scratch can be time-consuming, and need lots of testing—there are some real benefits from using a grid layout:
- Grids make for a simpler design: Instead of trying to develop the proverbial wheel, we can focus on providing the content instead; the infrastructure will have already been tested by the developer and other users.
- They provide for a visually appealing design: Many people prefer content to be displayed in columns, so grid layouts make good use of this concept, to help organize content on the page.
- Grids can of course adapt to different size viewports: The system they use makes it easier to display a single codebase on multiple devices, which reduces the effort required for developers to maintain and webmasters to manage.
- Grids help with the display of adverts: Google has been known to favor websites which display genuine content and not those where it believes the sole purpose of the website is for ad generation; we can use the grid to define specific area for adverts, without getting in the way of natural content.
All in all, it makes sense to familiarize ourselves with grid layouts—the temptation is of course to use an existing library. There is nothing wrong with this, but to really get the benefit out of using them, it’s good to understand some of the basics around the mechanics of grid layouts, and how this can help with the construction of our website.
Making media responsive
Our journey through the basics of adding responsive capabilities to a website has so far touched on how we make our layouts respond automatically to changes – it’s time for us to do the same to media!
If your first thought is that we need lots of additional functionality to make media responsive, then I am sorry to disappoint—it’s much easier, and requires zero additional software to do it! Yes, all we need is just a text editor and a browser. I’ll use my favorite editor, Sublime Text, but you can use whatever works for you.
Over the course of this chapter, we will take a look in turn at images, video, audio and text, and we’ll see how with some simple changes, we can make each of them responsive. Let’s kick off our journey first, with a look at making image content responsive.
Creating fluid images
It is often said that images speak a thousand words. We can express a lot more with media than we can using words. This is particularly true for website selling products—a clear, crisp image clearly paints a better picture than a poor quality one!
When constructing responsive websites, we need our images to adjust in size automatically—to see why this is important, go ahead and extract coffee.html from a copy of the code download that accompanies this book, and run it in a browser. Try resizing the window—we should see something akin to this:
It doesn’t look great, does it? Leaving aside my predilection for nature’s finest bean drink (that is, coffee!), we can’t have images that don’t resize properly, so let’s take a look at what is involved to make this happen:
- Go ahead and extract a copy of coffee.html and save it to our project area.
- We also need our image. This is in the img folder; save a copy to the img folder in our project area.
- In a new text file, add the following code, saving it as coffee.css:
img { max-width: 100%; height: auto; } - Revert back to coffee.html. You will see line 6 is currently commented out; remove the comment tags.
- Save the file, then preview it in a browser. If all is well, we will still see the same image as before, but this time try resizing it.
This time around, our image grows or shrinks automatically, depending on the size of our browser window:
Although our image does indeed fit better, there are a couple of points we should be aware of, when using this method:
- Sometimes you might see !important set as a property against the height attribute when working with responsive images; this isn’t necessary, unless you’re setting sizes in a website where image sizes may be overridden at a later date.
- We’ve set max-width to 100% as a minimum. You may also need to set a width value too, to be sure that your images do not become too big and break your layout.
This is an easy technique to use, although there is a downside that can trip us up—spot what it is? If we use a high quality image, its file size will be hefty. We can’t expect users of mobile devices to download it, can we?
Don’t worry though—there is a great alternative that has quickly gained popularity amongst browsers; we can use the <picture> element to control what is displayed, depending on the size of the available window.
Implementing the <picture> element
In a nutshell, responsive images are images that are displayed their optimal form on a page, depending on the device your website is being viewed from. This can mean several things:
- You want to show a separate image asset based on the user’s physical screen size—this might be a 13.5 inch laptop, or a 5inch mobile phone screen.
- You want to show a separate image based on the resolution of the device, or using the device-pixel ratio (which is the ratio of device pixels to CSS pixels).
- You want to show an image in a specified image format (WebP, for example) if the browser supports it.
Traditionally, we might have used simple scripting to achieve this, but it is at the risk of potentially downloading multiple images or none at all, if the script loads after images have loaded, or if we don’t specify any image in our HTML and want the script to take care of loading images.
Making video responsive
Flexible videos are somewhat more complex than images. The HTML5 <video> maintains its aspect ratio just like images, and therefore we can apply the same CSS principle to make it responsive:
video {
max-width: 100%;
height: auto !important;
}Until relatively recently, there have been issues with HTML5 video—this is due in the main to split support for codecs, required to run HTML video. The CSS required to make a HTML5 video is very straightforward, but using it directly presents a few challenges:
- Hosting video is bandwidth intensive and expensive
- Streaming requires complex hardware support in addition to video
- It is not easy to maintain a consistent look and feel across different formats and platforms
For many, a better alternative is to host the video through a third-party service such as YouTube—we can let them worry about bandwidth issues and providing a consistent look and feel; we just have to make it fit on the page! This requires a little more CSS styling to make it work, so let’s dig in and find out what is involved.
We clearly need a better way to manage responsive images! A relatively new tag for HTML5 is perfect for this job: <picture>. We can use this in one of three different ways, depending on whether we want to resize an existing image, display a larger one, or show a high-resolution version of the image. Implementing the <picture> element.
In a nutshell, responsive images are images that are displayed their optimal form on a page, depending on the device your website is being viewed from. This can mean several things:
- You want to show a separate image asset based on the user’s physical screen size—this might be a 13.5 inch laptop, or a 5inch mobile phone screen
- You want to show a separate image based on the resolution of the device, or using the device-pixel ratio (which is the ratio of device pixels to CSS pixels)
- You want to show an image in a specified image format (WebP, for example) if the browser supports it
Traditionally, we might have used simple scripting to achieve this, but it is at the risk of potentially downloading multiple images or none at all, if the script loads after images have loaded, or if we don’t specify any image in our HTML and want the script to take care of loading images.
We clearly need a better way to manage responsive images! A relatively new tag for HTML5 is perfect for this job: <picture>. We can use this in one of three different ways, depending on whether we want to resize an existing image, display a larger one, or show a high-resolution version of the image.
Making text fit on screen
When building websites, it goes without saying but our designs clearly must start somewhere—this is usually with adding text. It’s therefore essential that we allow for this in our responsive designs at the same time.
Now is a perfect opportunity to explore how to do this—although text is not media in the same way as images or video, it is still content that has to be added at some point to our pages! With this in mind, let’s dive in and explore how we can make our text responsive.
Sizing with em units
When working on non-responsive websites, it’s likely that sizes will be quoted in pixel values – it’s a perfectly acceptable way of working. However, if we begin to make our websites responsive, then content won’t resize well using pixel values—we have to use something else.
There are two alternatives – em or rem units. The former is based on setting a base font size that in most browsers defaults to 16px; in this example, the equivalent pixel sizes are given in the comments that follow each rule:
h1 { font-size: 2.4em; } /* 38px */
p { line-height: 1.4em; } /* 22px */Unfortunately there is an inherent problem with using em units—if we nest elements, then font sizes will be compounded, as em units are calculated relative to its parent. For example, if the font size of a list element is set at 1.4em (22px), then the font size of a list within a list becomes 30.8em (1.4 x 22px).
To work around these issues, we can use rem values as a replacement—these are calculated from the root element, in place of the parent element. If you look carefully throughout many of the demos created for this book, you will see rem units being used to define the sizes of elements in that demo.
Using rem units as a replacement
The rem (or root em) unit is set to be relative to the root, instead of the parent – it means that we eliminate any issue with compounding at a stroke, as our reference point remains constant, and is not affected by other elements on the page.
The downside of this is support—rem units are not supported in IE7 or 8, so if we still have to support these browsers, then we must fall back to using pixel or em values instead. This of course raises the question—should we still support these browsers, or is their usage of our website so small, as to not be worth the effort required to update our code?
If the answer is that we must support IE8 or below, then we can take a hybrid approach—we can set both pixel/em and rem values at the same time in our code, thus:
.article-body {
font-size: 1.125rem; /* 18 / 16 */
font-size: 18px;
}
.caps, figure, footer {
font-size: 0.875rem; /* 14 / 16 */
font-size: 14px;
}Notice how we set rem values first? Browsers which support rem units will use these first; any that don’t can automatically fall back to using pixel or em values instead.
Exploring some examples
Open a browser—let’s go and visit some websites.
Now, you may think I’ve lost my marbles, but stay with me: I want to show you a few examples. Let’s take a look at a couple of example websites at different screen widths—how about this example, from my favorite coffee company, Starbucks:
Try resizing the browser window—if you get small enough, you will see something akin to this:
Now, what was the point of all that, I hear you ask? Well, it’s simple—all of them use media queries in some form or other; CSS Tricks uses the queries built into WordPress, Packt’s website is hosted using Drupal, and Starbuck’s website is based around the Handlebars template system.
The key here is that all use media queries to determine what should be displayed—throughout the course of this chapter, we’ll explore using them in more detail, and see how we can use them to better manage content in responsive websites. Let’s make a start with exploring their make up in more detail.
Understanding media queries
The developer Bruce Lee sums it up perfectly, when liking the effects of media queries to how water acts in different containers:
“Empty your mind, be formless, shapeless – like water. Now you put water in a cup, it becomes the cup; you put water into a bottle it becomes the bottle; you put it in a teapot it becomes the teapot. Now water can flow or it can crash. Be water, my friend.”
We can use media queries to apply different CSS styles, based on available screen estate or specific device characteristics. These might include, but not be limited to the type of display, screen resolution or display density. Media queries work on the basis of testing to see if certain conditions are true, using this format:
@media [not|only] [mediatype] and ([media feature]) {
// CSS code;
}We can use a similar principle to determine if entire style sheets should be loaded, instead of individual queries:
<link rel="stylesheet" media="mediatype and|only|not (media feature)" href="myStyle.css">Seems pretty simple, right? The great thing about media queries is that we don’t need to download or install any additional software to use or create them – we can build most of them in the browser directly.
Removing the need for breakpoints
Up until now, we’ve covered how we can use breakpoints to control what is displayed, and when, according to which device is being used. Let’s assume you’re working on a project for a client, and have created a series of queries that use values such as 320px, 480px, 768px, and 1024px to cover support for a good range of devices.
No matter what our design looks like, we will always be faced with two issues, if we focus on using specific screen viewports as the basis for controlling our designs:
- Keeping up with the sheer number of devices that are available
- The inflexibility of limiting our screen width
So hold on: we’re creating breakpoints, yet this can end up causing us more problems? If we’re finding ourselves creating lots of media queries that address specific problems (in addition to standard ones), then we will start to lose the benefits of a responsive website—instead we should re-examine our website, to understand why the design isn’t working and see if we can’t tweak it so as to remove the need for the custom query.
Ultimately our website and target devices will dictate what is required—a good rule of thumb is if we are creating more custom queries than a standard bunch of 4-6 breakpoints, then perhaps it is time to recheck our design!
As an alternative to working with specific screen sizes, there is a different approach we can take, which is to follow the principle of adaptive design, and not responsive design. Instead of simply specifying a number of fixed screen sizes (such as for the iPhone 6 Plus or a Samsung Galaxy unit), we build our designs around the point at which the design begins to fail.
Why? The answer is simple—the idea here is to come up with different bands, where designs will work between a lower and upper value, instead of simply specifying a query that checks for fixed screen sizes that are lower or above certain values.
Understanding the importance of speed
The advent of using different devices to access the internet means speed is critical – the time it takes to download content from hosting servers, and how quickly the user can interact with the website are key to the success of any website.
Why it is important to focus on the performance of our website on the mobile devices or those devices with lesser screen resolution? There are several reasons for this—they include:
- 80 percent of internet users owns a smartphone
- Around 90 percent of users go online through a mobile device, with 48% of users using search engines to research new products
- Approximately 72 percent users abandon a website if the loading time is more than 5-6 seconds
- Mobile digital media time is now significantly higher than compared to desktop use
If we do not consider statistics such as these, then we may go ahead and construct our website, but end up with a customer losing both income and market share, if we have not fully considered the extent of where our website should work. Coupled with this is the question of performance – if our website is slow, then this will put customers off, and contribute to lost sales.
A study performed by San Francisco-based Kissmetrics shows that mobile users wait between 6 to 10 seconds before they close the website and lose faith in it. At the same time, tests performed by Guy Podjarny for the Mediaqueri.es website (http://mediaqueri.es) indicate that we’re frequently downloading the same content for both large and small screens—this is entirely unnecessary, when with some simple changes, we can vary content to better suit desktop PCs or mobile devices!
So what can we do? Well, before we start exploring where to make changes, let’s take a look at some of the reasons why websites run slowly.
Understanding why pages load slowly
Although we may build a great website that works well across multiple devices, it’s still no good if it is slow! Every website will of course operate differently, but there are a number of factors to allow for, which can affect page (and website) speed:
- Downloading data unnecessarily: On a responsive website, we may hide elements that are not displayed on smaller devices; the use of display: none in code means that we still download content, even though we’re not showing it on screen, resulting in slower websites and higher bandwidth usage.
- Downloading images before shrinking them: If we have not optimized our website with properly sized images, then we may end up downloading images that are larger than necessary on a mobile device. We can of course make them fluid by using percentage-based size values, but this places extra demand on the server and browser to resize them.
- A complicated DOM in use on the website: When creating a responsive website, we have to add in a layer of extra code to manage different devices; this makes the DOM more complicated, and slow our website down. It is therefore imperative that we’re not adding in any unnecessary elements that require additional parsing time by the browser.
- Downloading media or feeds from external sources: It goes without saying that these are not under our control; if our website is dependent on them, then the speed of our website will be affected if these external sources fail.
- Use of Flash: Websites that rely on heavy use of Flash will clearly be slower to access than those that don’t use the technology. It is worth considering if our website really needs to use it; recent changes by Adobe mean that Flash as a technology is being retired in favor of animation using other means such as HTML5 Canvas or WebGL.
There is one point to consider that we’ve not covered in this list—the average size of a page has significantly increased since the dawn of the Internet in the mid-nineties. Although these figures may not be 100% accurate, they still give a stark impression of how things have changed:
- 1995: At that time the average page size used to be around 14.1 KB in size. The reason for it can be that it contained around 2 or 3 objects. That means just 2 or 3 calls to server on which the website was hosted.
- 2008: The average page size increased to around 498 KB in size, with an average use of around 70 objects that includes changes to CSS, images and JavaScript. Although this is tempered with the increased use of broadband, not everyone can afford fast access, so we will lose customers if our website is slow to load.
All is not lost though—there are some tricks we can use to help optimize the performance of our websites.
Testing website compatibility
At this stage, our website would be optimized, and tested for performance—but what about compatibility?
Although the wide range of available browsers has remained relatively static (at least for the ones in mainstream use), the functionality they offer is constantly changing—it makes it difficult for developers and designers to handle all of the nuances required to support each browser.
In addition, the wide range makes it costly to support—in an ideal world, we would support every device available, but this is impossible; instead, we must use analytical software to determine which devices are being used, and therefore worthy of support.
Working out a solution
If we test our website on a device such as an iPhone 6, then there is a good chance it will work as well on other Apple devices, such as iPads. The same can be said for testing on a mobile device such as a Samsung Galaxy S4—we can use this principle to help prioritize support for particular mobile devices, if they require more tweaks to be made than for other devices.
Ultimately though, we must use analytical software to determine who visits our website; the information such as browser, source, OS and device used will help determine what our target audience should be. This does not mean we completely neglect other devices; we can ensure they work with our website, but this will not be a priority during development.
A key point of note is that we should not attempt to support every device – this is too costly to manage, and we would never keep up with all of the devices available for sale! Instead, we can use our analytics software to determine which devices are being used by our visitors; we can then test a number of different properties:
- Screen size: This should encompass a variety of different resolutions for desktop and mobile devices.
- Connection speed: Testing across different connection speeds will help us understand how the website behaves, and identify opportunities or weaknesses where we may need to effect changes.
- Pixel density: Some devices will support higher a pixel density, which allows them to display higher resolution images or content; this will make it easier to view and fix any issues with displaying content.
- Interaction style: The ability to view the Internet across different devices means that we should consider how our visitors interact with the website: is it purely on a desktop, or do they use tablets, smartphones or gaming-based devices? It’s highly likely that the former two will be used to an extent, but the latter is not likely to feature as highly.
Once we’ve determined which devices we should be supporting, then there are a range of tools available for us to use, to test browser compatibility. These include physical devices (ideal, but expensive to maintain), emulators or online services (these can be commercial, or free). Let’s take a look at a selection of what is available, to help us test compatibility.
Exploring tools available for testing
When we test a mobile or responsive website, there are factors which we need to consider before we start testing, to help deliver a website which looks consistent across all the devices and browsers. These factors include:
- Does the website look good?
- Are there any bugs or defects?
- Is our website really responsive?
To help test our websites, we can use any one of several tools (either paid or free)—a key point to note though is that we can already get a good idea of how well our websites work, by simply using the Developer toolbar that is available in most browsers!
Viewing with Chrome
We can easily emulate a mobile device within Chrome, by pressing Ctrl + Shift + M; Chrome displays a toolbar at the top of the window, which allows us to select different devices:
If we click on the menu entry (currently showing iPhone 6 Plus), and change it to Edit, we can add new devices; this allows us to set specific dimensions, user agent strings and whether the device supports high-resolution images:
Although browsers can go some way to providing an indication of how well our website works, they can only provide a limited view – sometimes we need to take things a step further and use commercial solutions to test our websites across multiple browsers at the same time. Let’s take a look at some of the options available commercially.
Exploring our options
If you’ve spent any time developing code, then there is a good chance you may already be aware of Browserstack (from https://www.browserstack.com)—other options include the following:
- GhostLab: https://www.vanamco.com/ghostlab/
- Muir: http://labs.iqfoundry.com/
- CrossBrowserTesting: http://www.crossbrowsertesting.com/
If however all we need to do is check our website for its level of responsiveness, then we don’t need to use paid options – there are a number of websites that allow us to check, without needing to installing plugins or additional tools:
- Am I Responsive: http://ami.responsive.is
- ScreenQueries: http://screenqueri.es
- Cybercrab’s screen check facility: http://cybercrab.com/screencheck
- Remy Sharp’s check website: http://responsivepx.com
We can also use bookmarklets to check to see how well our websites work on different devices – a couple of examples to try are at http://codebomber.com/jquery/resizer and http://responsive.victorcoulon.fr/; it is worth noting that current browsers already include this functionality, making the bookmarklets less attractive as an option.
We have now reached the end of our journey through the essentials of creating responsive websites with nothing more than plain HTML and CSS code. We hope you have enjoyed it as much as we have with writing, and that it helps you make a start into the world of responsive design using little more than plain HTML and CSS.
Summary
This article covers the elements of RWD and introduces us to the different flexible grid layouts.
