Current Curriculum

A quick introduction and welcome to the course with some key information to get started.

The grand vision of the course as of March 2021.

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.

Getting your Windows 10 computer ready to code.

Setting up your OSX/Mac computer for code.

Getting a Linux system ready, or using Windows Subsystem for Linux.

Learning to use enough PowerShell to complete the course.

A quick introduction to bash if you run Linux, WSL, or OSX.

The general technical help resources available for you as a customer of the course.

What you should be doing next.

Introducing basic terminology for HTML.

A quick reference of the major HTML tags you'll use the most.

Learn about how attributes modify tags, and aren't used much anymore.

Learn how to link to another HTML document.

A list of the major attributes on tags you'll most likely use.

Explain the Document Object Model and how nested tags work.

Focus on tables for tabular data.

Focus on forms for collecting information from the user and submitting it.

An explanation of using your own tags, why that's the easiest way to work, followed by a challenge.

Bridging from HTML to CSS and how CSS walks the tag tree.

The relationship between CSS and HTML.

Setting up the JavaScript gear you need to use.

The initial format for a CSS rule, and how selectors work.

An initial set of useful properties for CSS that should cover 90% of your uses.

Using monochrome values instead of color codes to simplify your process.

Using variables to simplify CSS and making changes easier.

Introducing Flexbox for consistent modern layout.

Introduction to using CSS grids for uniform layout.

Breaking away from blockstart.css to create the final look of the subject website from Exercise 9.

I explain a process for taking your front end ideas (or copy subjects) from nothing to working user interface using blockstart.css.

Getting the software you need to finish this module.

Your very first JavaScript program.

How to comment out parts of your code and write help for your future self.

Doing simple math and creating displayable text in strings.

Variables for storing and referencing information.

Constants are variables that you claim will not change.

When you write a string how do you put a string in it?

Asking a person for input from the terminal.

Accepting input from the user as command line options on your script.

Reading files with the fs (filesystem) module.

Combining reading files with accepting command line arguments.

Creating small pieces of code and jumping to them with functions.

Combining everything learned so far with functions, files, and variables in one.

Packing a group of related files into a single component called a module.

The start of logic comparison operations.

The introduction of branching with if and else.

The concept of repeating a block of code with a while-loop.

Lists of data and enumerating them with a for-loop.

Studying Arrays even more and becoming proficient at nesting them.

First step with objects just for key/value data.

Creating a little game to combine everything learned thus far.

Going from Data Objects and Functions to Object Oriented Programming.

Using the new ES6 style of classes is much better than the last exercise's classes.

Learning about the concept of inheritance in OOP.

Creating an OOP version of our little game.

Studying a complex use of functions calling their self to do a loop.

Processing Arrays with handy functions and callbacks like map and reduce.

You can chain sequences of functions together to perform more complex sequences of operations.

The concept of scope in ES6 vs. older JavaScript and why you should use let and const instead of var.

A more complicated technique to push your understanding of callbacks and filters.

This exercise covers the many, many, many ways that JavaScript handles asynchronous events.

The final exercise covers the use of import and modern ES6 modules.

A series of projects that practice what you've learned so far.

Learn about Promises while learning about CSV parsing.

Learn about RegExp while learning about parsing log files.

Learn more about the fs module while replicating ls.

Learn about directory traversal while replicating find.

Apply what you've learned so far to a static blog generator.

Learn how to learn another project's API while making your blog more dynamic.

Learn about database access from JavaScript using knex.js and testing.

Apply what you've learned so far to create a database backed full stack application.

Apply what you've learned so far to add comments to your blog.

Revisit the TODO app to learn about web applications that access JSON APIs.

Introducing the module and getting Svelte setup.

Creating your first .svelte file.

How to get your variables into the HTML.

How updating your variables with equality updates the DOM.

The classic if-statement and each-block in Svelte.

Controlling when things happen using onMount and await.

Handling event from the browser with on: syntax.

Bidirectional variable binding with bind:

Applying what you know to a real project.

Working on the next UI elements for the project.

Making the UI interact with a JSON API.

Introducing the module and getting Svelte setup.

Breaking up your UIs with discrete components.

How Svelte (probably) loads your code.

Adding export properties to your components.

Creating events from your components with dispatch.

Binding components, and a trick for getting at functions.

Loading components dynamically rather than with a tag.

Binding CSS classes to components (or anything) based on variables.

Allowing components to have child elements with slots.

Using components in the example app.

Finalizing the application using everything you know so far.

A quick introduction to SQL databases with knex.js.

Starting off with tables, columns, and rows in SQL.

Creating a table scheme with SQL.

The different column (data) types in SQLite3.

The Create, Read, Update, and Delete basics.

How SQL tables and queries translate into JavaScript objects.

Using primary keys to link tables and how they get indexed.

The two primary ways tables are related.

A special kind of relation that's not common, but very useful.

How to migrate a database to change its schema and/or data.

A final challenge to analyze a database and migrate it to change it.