Learn JavaScript the Hard Way

This is a large course that will eventually be a complete course in web development from nothing to your own commercial website. Learning to create a professional commercial website is a valuable educational experience, even if your goal is to never make money online.

NOTE: This course is in early access. It's not complete but does teach all of JavaScript that's relevant to the rest of the course.

Course Contents

This course contains the following modules and lessons. Every course offers free samples of the first 10 lessons so you can decide if you want to take the course, and excerpts from all lessons after that.

• 01: Welcome to The Course
  
  A quick introduction and welcome to the course with some key information to get started.
• 02: Course Motivation and Overview
  
  The grand vision of the course as of March 2021.
• 03: Common Misconceptions About Programming
  
  Learning a programming language is different from other things you've learned. In this exercise I give you helpful tips on how to better succeed.
• 04: Setup for Windows
  
  Getting your Windows 10 computer ready to code.
• 05: Setup for OSX
  
  Setting up your OSX/Mac computer for code.
• 06: Setup for Linux or WSL
  
  Getting a Linux system ready, or using Windows Subsystem for Linux.
• 07: PowerShell Basics
  
  Learning to use enough PowerShell to complete the course.
• 08: Bash Basics
  
  A quick introduction to bash if you run Linux, WSL, or OSX.
• 09: Available Help Resources
  
  The general technical help resources available for you as a customer of the course.
• 10: Next Steps
  
  What you should be doing next.

• 01: Elements
  
  Introducing basic terminology for HTML.
• 02: Tags in Detail
  
  A quick reference of the major HTML tags you'll use the most.
• 03: Attributes
  
  Learn about how attributes modify tags, and aren't used much anymore.
• 04: Links
  
  Learn how to link to another HTML document.
• 05: Important Attributes
  
  A list of the major attributes on tags you'll most likely use.
• 06: The DOM
  
  Explain the Document Object Model and how nested tags work.
• 07: Tables
  
  Focus on tables for tabular data.
• 08: Forms
  
  Focus on forms for collecting information from the user and submitting it.
• 09: Custom Tags
  
  An explanation of using your own tags, why that's the easiest way to work, followed by a challenge.
• 10: Simple Layouts with Blockstart
  
  Bridging from HTML to CSS using blockstart.css

• 01: CSS and HTML
  
  The relationship between CSS and HTML.
• 02: The Setup
  
  Setting up the JavaScript gear you need to use.
• 03: Rule Sets
  
  The initial format for a CSS rule, and how selectors work.
• 04: Simple Styling
  
  An initial set of useful properties for CSS that should cover 90% of your uses.
• 05: Value (Not Color) Codes
  
  Using monochrome values instead of color codes to simplify your process.
• 06: Variables
  
  Using variables to simplify CSS and making changes easier.
• 07: Flexbox Basics
  
  Introducing Flexbox for consistent modern layout.
• 08: Grid Basics
  
  Introduction to using CSS grids for uniform layout.
• 09: A Frontend Development Process
  
  I explain a process for taking your front end ideas (or copy subjects) from nothing to working user interface using blockstart.css.
• 10: Frontend Development Process Stages 3 and 4
  
  Breaking away from blockstart.css to create the final look of the subject website from Exercise 9.

• 00: Gearing Up
  
  Getting the software you need to finish this module.
• 01: A First Program
  
  Your very first JavaScript program.
• 02: Comments
  
  How to comment out parts of your code and write help for your future self.
• 03: Simple Math and Strings
  
  Doing simple math and creating displayable text in strings.
• 04: Variables
  
  Variables for storing and referencing information.
• 05: Constants
  
  Constants are variables that you claim will not change.
• 06: Escape Sequences
  
  When you write a string how do you put a string in it?
• 07: Prompting Input
  
  Asking a person for input from the terminal.
• 08: Command Line Arguments
  
  Accepting input from the user as command line options on your script.
• 09: Files
  
  Reading files with the fs (filesystem) module.
• 10: Files, Args, and Variables
  
  Combining reading files with accepting command line arguments.
• 11: Functions
  
  Creating small pieces of code and jumping to them with functions.
• 12: Functions, Files, Variables
  
  Combining everything learned so far with functions, files, and variables in one.
• 13: Modules
  
  Packing a group of related files into a single component called a module.
• 14: True and False Tests
  
  The start of logic comparison operations.
• 15: If and Else
  
  The introduction of branching with if and else.
• 16: While Loops
  
  The concept of repeating a block of code with a while-loop.
• 17: Sequences and For Loops
  
  Lists of data and enumerating them with a for-loop.
• 18: More Arrays
  
  Studying Arrays even more and becoming proficient at nesting them.
• 19: Data Objects
  
  First step with objects just for key/value data.
• 20: First Game
  
  Creating a little game to combine everything learned thus far.
• 21: Simple OOP
  
  Going from Data Objects and Functions to Object Oriented Programming.
• 22: More Complex OOP
  
  Using the new ES6 style of classes is much better than the last exercise's classes.
• 23: Inheritance
  
  Learning about the concept of inheritance in OOP.
• 24: OOP Game
  
  Creating an OOP version of our little game.
• 25: Functions and Recursion
  
  Studying a complex use of functions calling their self to do a loop.
• 26: Transforming Data
  
  Processing Arrays with handy functions and callbacks like map and reduce.
• 27: Applying Functions
  
  You can chain sequences of functions together to perform more complex sequences of operations.
• 28: Scope and Closures
  
  The concept of scope in ES6 vs. older JavaScript and why you should use let and const instead of var.
• 29: Partial Application
  
  A more complicated technique to push your understanding of callbacks and filters.
• 30: Callbacks, Events, Promises and Async
  
  This exercise covers the many, many, many ways that JavaScript handles asynchronous events.
• 31: Modules and `import`
  
  The final exercise covers the use of import and modern ES6 modules.

• 00: Introduction
  
  The basics of Web Development.
• 01: Processing Directories of Files
  
  Processing Directories of Files
• 02: Dynamically Loading Modules
  
  Dynamically Loading Modules
• 03: A Static Blog Generator
  
  A Static Blog Generator
• 04: A Blog Server
  
  A Blog Server
• 05: Creating a Comment Form
  
  Creating a Comment Form
• 06: Alpine.js Crash Course
  
  Alpine.js Crash Course
• 07: Better Comments with Alpine.js
  
  Better Comments with Alpine.js
• 08: The SQL Crash Course
  
  The SQL Crash Course
• 09: SQL Normalization
  
  SQL Normalization
• 10: SQL Relationships
  
  SQL Relationships
• 11: Basic SQL with Knex.js
  
  Basic SQL with Knex.js
• 12: Storing Comments in SQL
  
  Storing Comments in SQL
• 13: Form Validation
  
  Form Validation
• 14: Better Password Storage
  
  Better Password Storage
• 15: Dynamically Loaded Server
  
  Dynamically Loaded Server
• 16: Going Further
  
  Going Further