Debugging HTML
Learnwebdevelopment/Core/Stylingbasics
Learn_web_development/Core/Styling_basics
Writing HTML is fine, but what if something goes wrong, and you can't work out where the error in the code is? This article will introduce you to some tools that can help you find and fix errors in HTML.
| Prerequisites: | Basic HTML familiarity, as covered in Basic HTML Syntax. Text-level semantics such as headings and paragraphs and lists. Structural HTML. |
|---|---|
| Learning outcomes: |
|
Debugging isn't scary
When writing code of some kind, everything is fine, until that dreaded moment when an error occurs — you've done something wrong, so your code doesn't work — either not at all, or not quite how you wanted it to. For example, the following shows an error reported when trying to compile a simple program written in the Rust language.

Here, the error message is relatively easy to understand — "unterminated double quote string". If you look at the listing, you can probably see how println!(Hello, world!"); might logically be missing a double quote. However, error messages can quickly get more complicated and less easy to interpret as programs get bigger, and even simple cases can look a little intimidating to someone who doesn't know anything about Rust.
Debugging doesn't have to be scary though — the key to being comfortable with writing and debugging any code is familiarity with both the language and the associated tools.
HTML and debugging
HTML is not as complicated to understand as Rust. HTML is not compiled into a different form before parsing (it is interpreted, not compiled). And HTML's element syntax is arguably a lot easier to understand than a "real programming language" like Rust, JavaScript, or Python.
The way that browsers parse HTML is a lot more permissive than how most programming languages are parsed, which is both a good and a bad thing.
But first of all, what do we mean by permissive? Well, generally when you do something wrong in code, there are two main types of error that you'll come across:
- Syntax errors: These are typos in your code that cause the program not to run, like the Rust error shown earlier. These are usually easy to fix as long as you are familiar with the language's syntax and know what the error messages mean.
- Logic errors: These are errors where the syntax is actually correct, but the code is not doing what you intended it to, meaning that the program runs incorrectly. These are often harder to fix than syntax errors, as there isn't an error message to direct you to the source of the error.
HTML itself doesn't suffer from syntax errors because browsers parse it permissively, meaning that the page still displays even if there are syntax errors in the source code. Browsers have built-in rules to state how to interpret incorrectly-written HTML markup (often called invalid or badly-formed markup), changing it automatically to some valid markup.
For example, the following HTML snippet contains incorrectly nested elements:
```html example-bad
I didn't expect to find the next-door neighbor's cat here!
The closing `</strong>` tag should be before the closing `</em>` tag, but it is not — it is after it.
If you load this HTML into a browser then look at the [rendered DOM](/docs/Learn_web_development/Getting_started/Web_standards/How_browsers_load_websites#handling_html), you'll see that the nesting has been corrected by the browser:
```html example-good
<p>
I didn't expect to find the
<em>next-door neighbor's <strong>cat</strong></em> here!
</p>
So why is this both good and bad? Well, in this case the browser has created the intended result, but as you'll see later on, this is not always the case. You'll always get something running, but the browser doesn't always get it right, which can cause problems. It is better to write correct markup in the first place.
[!NOTE] HTML is parsed permissively because when the web was first created, it was decided that getting content published was more important than making sure the syntax was absolutely correct. The web would probably not be as popular as it is today if it had been more strict from the very beginning.
So how do you find markup errors? Later on we will show you how to find errors in HTML using a tool called the HTML validator, but first we will show you how to inspect your HTML manually using a DOM inspector, and then explore what kinds of markup errors you might be looking for, and how the browser might interpret those.
Using the DOM inspector
All modern browsers have a set of developer tools (devtools) built into them, which provide a set of functionality for examining the webpage loaded into the current tab. These can show you what HTML is rendered in the page, what CSS is applied to each DOM node, what JavaScript is running in the page, and more. They also allow you to edit the currently-running code and see the effect live on the page.
You can open the devtools in a similar way in each browser — see How to open the devtools in your browser to learn how.
For this article, the only relevant devtools function is the DOM inspector, which shows the currently-rendered HTML DOM and allows you to edit it. Let's look at this now:
- Open the devtools in your browser.
- Open the DOM inspector. It is in the same place in each browser — the first tab in the devtools at the start of the row. In Firefox it is labeled Inspector, while in Safari, Edge, and Chrome it is labeled Elements. This should be the tab selected by default when you first open the devtools, but select it if it isn't.
- Examine the DOM tree structure shown in the tab, and note how you can click the little expansion arrows at the start of each DOM node to expand and collapse them and reveal their descendant nodes. You can also use the up and down cursor keys to move up and down the nodes, and the right and left cursor keys to expand and collapse the nodes.
- Also try hovering over the nodes (or selecting them with the cursor keys) and note how the currently-hovered (or selected) element is highlighted in the viewport.
- You can also edit the rendered DOM. We won't use the editing functionality in this article, but take some time to look up how to do this if you are curious.
Your turn: Studying HTML using the DOM inspector
In this section, you'll study some code using the DOM inspector and see how the browser handles common markup errors.
- First, save the following HTML file listing as
debug-example.html, somewhere on your local machine. This demo is deliberately written with some built-in errors for us to explore.
```html-nolint
HTML debugging examples
What causes errors in HTML?
- Unclosed elements: If an element is not closed properly,then its effect can spread to areas you didn't intend
- Badly nested elements: Nesting elements properly is also very important for code behaving correctly. strong strong emphasized? what is this?
- Unclosed attributes: Another common source of HTML problems. Let's look at an example: link to Mozilla homepage
If you can't work out what every error message means, don't worry about it. A good strategy is to fix a few errors at a time, then revalidate your HTML after each set of fixes to show what errors are left. Sometimes, fixing an earlier error will also get rid of other error messages — several errors can often be caused by a single problem, in a domino effect.
You will know when all your errors are fixed when you see a nice little green banner telling you there are no errors to report. At the time of writing, it said "Document checking completed. No errors or warnings to show."
Summary
So there we have it, an introduction to debugging HTML, which should give you some useful skills to count on when debugging HTML, but also CSS and JavaScript code later on in the course. This also marks the end of the Structuring content with HTML module.
Your next step is to start learning about styling the web in our CSS styling basics module.
Learn_web_development/Core/Styling_basics