The HTTP Protocol
You can't start developing for the web without knowing the fundamentals.
This module talks about the HTTP protocol used to request resources from
the server. We'll explore the details of what is used for a browser and
for a server to make sure the communication is legitimate.
- Http Verbs and their Meaning
- Request and Response Headers
- Interpreting Status Codes
- Caching Resources
The structure of a web page is created on HTML. We'll have a look at basic
elements like input fields, divs,... to make sure the content is
structured in the way we want.
- Anatomy of a page
- How a page is parsed
- Some important HTML elements
- Styling and Behavior
- LAB - HTML Fundamentals
Working with forms is one of the most important aspects in HTML
development. It makes it possible for the user to send data to the server
- Form Elements
- How Forms Work
- Useful Attributes and Functions
- LAB - HTML Forms
Modern HTML includes a variety of semantic tags that make it easier for
things like screen readers and search engine to understand our webpages.
In this module we take a look at those elements and their benefits.
- The need for meaningful elements
- Headers, content and footers
- Articles and sections
- Navigation elements
- Meaningful figures
- Dates and time
- LAB - HTML Semantics
A web page only looks nice when we start styling it. HTML is great to get
all of our content on the page, but when we want to change the font, the
colors, the location of everything we need some way to target these
properties. CSS is the language we'll use to make sure the browser renders
the page in the way we want to. We'll start with some basic selectors and
learn how to use them efficiently.
- Styling websites using CSS
- CSS Selectors
- Understanding Inheritance & Cascading behavior
- Choosing the right unit
- LAB - CSS Fundamentals
Principles of Web Design
Web design isn't just about knowing CSS, it's about creating good looking,
easy to use applications. In this chapter, we'll take a look at some of
the fundamental principles designers use to turn a good design into a
- Layout and Composition
- User Experience
One of the hardest parts of CSS is making sure that every element is
located at the correct position. This chapter will explain the layout flow
and basic options.
- Understanding the Box Model
- LAB - CSS Positioning
CSS Positioning Advanced
When familiar with css positioning basics, we can now look at some more
advanced, flexible layout types. This chapter will explain some more
advanced page layout strategies.
- Flex Box
- Page layout strategies
- LAB - CSS Positioning Advanced
Responsive Web Design with Bootstrap
Your web site needs to look fabulous on any device; whether it's a laptop,
tablet or phone. Bootstrap, a popular framework for creating responsive
sites, will help you to achive this.
- Normalizing and Resetting
- The Grid System
- Utility classes
- Customizing look and feel
- Components: navigation, popovers ...
- LAB - Responsive web design with Bootstrap
and more important in other areas as well. In this module we'll take a
first look at the language and how to make our lives easier by using it
- What is ECMAScript?
- Picking the right Libraries
- Developer Tools
can be a very tricky language, so we'll try to explain a couple of its
quirks as well. This way, we can avoid surprises later.
- Using Variables
- Primitives and Objects
- Functions: more powerful than you'd expect
- Understanding Scope
- Strict Mode
- Error Handling
- Best Practices
In this module, we will learn how to add client-side interactivity to our
can manipulate it, as well as handling user events in the browser.
- Understanding the DOM
- DOM Selection and Manipulation
- Event Handling
Collections are a big part of OO programming, they allow you to map
one-to-many or many-to-many relationships, as well as let you work with
sets of data. In this module, we'll take a look at the different types of
- Storing multiple values in Arrays
- Useful Functions and Operators
- Using Objects as Maps
- Sets, Maps and Others
- LAB - Collections
work on that data. We'll take a closer look in this module.
- Class syntax
- Using Properties to encapsulate your fields
- The 'this' keyword explained
- LAB - Constructors and Classes
keep the UI responsive while running a lot of code. In this module we'll
see how to make our code run asynchronously.
- Using Callbacks
- Event Handling
- Working with Promises
- Async and Await
- LAB - Dealing with Async Code
and Gulp and npm, you need those. And definitely use Babel. It's soo
good... If your face looks like a big question mark right now, that's
It's easy to get lost in the overwhelming amount of tools and best
practices. In this module we'll create some clarity about these tools and
- Using Libraries
- Content Delivery Networks
- Getting Libraries with npm
- Modules versus the Global Object
- Using Task Runners like Gulp
- Bundling and Minification Tools like WebPack
- PolyFills and Transpilers like Babel and TypeScript
- Tools for Code Quality
- LAB - Structuring an Application
This module is about communicating with the backend. REST allows
client-server communication using HTTP.
- Verbs and URLs
- XML and JSON format
- Example with node.js and Express
- LAB - REST Services
Client-side Service Consumption with Vue.js
By using AJAX we can call server-side actions from our client-side code
and process the results in a quick, user-friendly manner. In this chapter
you will also get an introduction to a popular data binding framework:
Vue.js. We will see how we can talk to a REST API from this framework.
- Getting data using AJAX
- Fetch API
- External Libraries
- Vue.js Essentials
- Loading Data in a Vue Application
- LAB - Consuming REST Services