The Pro-Webdev Mega Bundle

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.

• 00: Introduction
  
  Go is a Great Beginner Language
• 01: Gearing Up
  
  Gearing Up
• 02: Important Basic Information
  
  Notes on basic computer knowledge you need.
• 03: Building a First Program
  
  Building a First Program
• 04: How to Write Code
  
  How to Write Code
• 05: Basic Syntax: Packages
  
  Basic Syntax: Packages
• 06: Basic Syntax: Variables
  
  Basic Syntax: Variables
• 07: Basic Syntax: Types
  
  Basic Syntax: Types
• 08: Flow Control: If
  
  Flow Control: If
• 9: Flow Control: for
  
  Flow Control: for-loop
• 10: Flow Control: switch
  
  Flow Control: switch
• 11: Basic Syntax: Functions
  
  Basic Syntax: Functions
• 12: Flow Control: defer
  
  Flow Control: defer
• 13: Error Handling
  
  Error Handling
• 14: Reading Input
  
  Reading Input
• 15: Project: Adventure Game
  
  Project: Adventure Game

• 16: The Type System: Structs
  
  The Type System: Structs
• 17: The Type System: Arrays and Slices
  
  The Type System: Arrays and Slices
• 18: The Type System: Maps
  
  The Type System: Maps
• 19: The Type System: Closures
  
  The Type System: Closures
• 20: Pointers
  
  Pointers
• 21: `struct` and Methods: Basics
  
  Struct and Methods: Basics
• 22: Struct and Methods: Type Assertions and Switches
  
  Struct and Methods: Type Assertions and Switches
• 23: Struct and Methods: Interfaces
  
  Struct and Methods: Interfaces
• 24: Reading and Writing Files
  
  Reading and Writing Files
• 25: The Amazing Struct Tags
  
  The Amazing Struct Tags
• 26: Processing Data
  
  Processing Data
• 27: Rogue Part 0: The Screen
  
  The Beginning of Rogue
• 28: Rogue Part 1: Mazes and Enemies
  
  Rogue Part 1: Matrix and Curses
• 29: Rogue Part 2: Pathing Enemies
  
  Rogue Part 2: Pathing Enemies
• 30: Rogue Part 3: Finishing Touches
  
  Rogue Part 3: Enemy Pathing

• 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.