Lessons

Short programming lessons in plain words, from Novice to Master, with code, key terms and cheat sheets. Search every lesson.

• .http Files in Visual Studio (Journeyman): An .http file holds requests written as plain text, one after another, separated by ###. Visual Studio sends each one with a click and shows the response's status, headers and body, so you can test an API without leaving your project.
• A Dev Server and Build with Vite (Journeyman): Vite gives a web project a dev server that shows every change the moment you save, and a build that bundles your code and packages into a small dist folder ready to put online.
• A First Look at CSS (Novice): CSS is the language that decides how a page looks, and one link line in the head connects your page to a stylesheet, such as the ready-made one this course gives you.
• A Simple API Client (Journeyman): Wrap an API in a client class, the way a DAO wraps a table. It's given an HttpClient, has one async method per endpoint, and turns 404 into null or false, so the rest of the program never sees a URL, a status code or JSON.
• Absolute (Apprentice): Absolute positioning takes an element out of the page's flow and places it relative to its nearest positioned ancestor, usually a parent with position relative.
• Abstraction in Art (Novice): Abstraction means leaving out the details you don't need, shown through examples from art, math, language and the animal kingdom.
• Abstraction in C#: an overview (Apprentice): In code, abstraction means working with an object through the few things that matter to you, and ignoring the rest. Base classes already do this; abstract classes and interfaces take it further.
• Adding Abstraction (Journeyman): Mark a base class abstract when it's too general to create on its own. An abstract class can't be created with new, and its abstract methods have no body, so every concrete derived class must override them.
• Adding and Removing Items (Apprentice): Grow and shrink an array as things change, adding and removing items at the end with push and pop, at the front with unshift and shift, and in the middle with splice.
• Adding Pictures (Novice): The img element puts a picture on your page, with src saying which picture file to show and alt saying in words what the picture tells the reader.
• Adding Test Classes (Apprentice): Add an MSTest test project beside your app, give it a reference to the app, and add a test class for each class you test.
• ADO.NET Objects (Journeyman): Use SqlConnection to connect, SqlCommand to run SQL, and SqlDataReader to read rows, choosing ExecuteReader, ExecuteScalar or ExecuteNonQuery for each kind of statement.
• Alt Text That Helps (Apprentice): Write alt text by what each picture is for, so a page still makes sense to someone who can't see its pictures, and add captions everyone can read.
• Appending to a File (Journeyman): To add to the end of a file instead of replacing it, open a StreamWriter with append set to true, or use File.AppendAllText. Either creates the file if it isn't there yet.
• ARIA: When HTML Isn't Enough (Freelancer): ARIA attributes change what a screen reader announces, never how an element behaves, so you use them only where HTML has no element or attribute for the job, such as naming an icon-only button.
• Arithmetic and Expressions in C# (Novice): Calculate in C# with + - * / and %, know why 5 / 4 is 1, and work out an expression in the order C# does.
• Array Basics (Novice): Create C# arrays, read and change their elements by index starting at 0, and use Length to find the last one.
• Arrays (Apprentice): A JavaScript array works like a C# List<T>. It grows and shrinks with push, pop, shift and unshift, and has length, includes and indexOf. Its filter, map, find and reduce methods do the jobs of LINQ's Where, Select, First and Sum.
• Arrays of Objects (Apprentice): An array of objects is a list of records, like a stack of filled-in forms, and it's how programs keep search results, carts and listings that you read, loop over and update.
• Arrow Functions (Apprentice): An arrow function is JavaScript's lambda, written (a, b) => a + b, almost exactly like C#. One parameter needs no parentheses, a body in braces needs a return, and an object returned on its own needs parentheses around it.
• Article, Section and Aside (Apprentice): Inside the main content, mark up each piece that stands on its own as an article, each themed group with its own heading as a section, and related extras as an aside, using one short test for each.
• Async and Await (Journeyman): JavaScript has async and await too, working just like C#'s. An async function can await a promise, such as fetch's, and read like ordinary code, with try and catch for errors. Use it to load data into the page and send a form to an API.
• async and await (Journeyman): async and await let you write code that waits for promises as if it were a recipe, one step under another, with try and catch for the steps that fail.
• Attribute Selectors (Apprentice): Attribute selectors reach elements by what their tags say, such as every checkbox, the song that's playing now, every link to a PDF or every link that leaves your site, with no class added.
• Attributes (Novice): Attributes add information to an element, such as its language, a tooltip or a name for it, written in the start tag as a name, an equals sign and a value in quotes.
• Authentication vs Authorization (Apprentice): Authentication asks who you are; authorization asks what you're allowed to do. A web app proves who you are once, at sign-in, then remembers you with a cookie on every request after.
• Autocomplete and Phone Keyboards (Journeyman): The autocomplete, inputmode and enterkeyhint attributes let a browser fill in what it already knows and give a phone the right keyboard, so a form takes seconds instead of minutes.
• Auto-Properties and Read-Only Properties (Apprentice): Write short auto-properties, make a property read-only to the outside with private set or get-only, and calculate a property from others.
• Bold, Italic and What They Mean (Novice): The strong, em, b, i and small elements all change how text looks, but each one says something different about what the words mean, so you choose them by meaning, not by looks.
• Booleans and Comparisons (Novice): Ask yes-or-no questions about your values with comparisons such as === and >=, and keep the true or false answer in a well-named boolean.
• Bootstrap and Tailwind: What a Framework Gives You and What It Costs (Journeyman): The same library event card built in plain CSS, in Bootstrap 5.3.8 and in Tailwind CSS 4.3.3 shows what a CSS framework gives you (speed, consistency, ready-made parts), what it costs (download size, look-alike sites, new names) and how your own CSS makes it yours.
• box-sizing: Making Width Mean What You Think (Apprentice): By default a box's width leaves out its padding and border, so it comes out wider than you asked; box-sizing border-box makes the width you write the width you get.
• Browser Defaults and a Small Reset (Apprentice): Every browser styles a page before your CSS arrives, with big headings, blue underlined links and margins you never wrote, and a short modern reset tames the defaults that get in your way without throwing away the useful ones.
• Bubbling and Event Delegation (Journeyman): A click travels up from the element it happened on through every parent, so one listener on a list can handle every button inside it, even buttons added later.
• Built-in Validation (Apprentice): A few HTML attributes let the browser check a form's answers before it sends them, so people fix a missing email or a short ZIP code right away, with no JavaScript.
• But Arrays Can Be Tedious (Apprentice): Arrays can't grow or shrink, so adding, inserting and removing elements means making new arrays and shifting values by hand.
• Buttons (Apprentice): A button's type decides what it does in a form, submit, reset or nothing at all, and a button with no type sends the form, which surprises people.
• C# Data Types (Novice): Every C# variable has a data type that decides what it can hold: whole numbers, decimals, money, single characters, text, or true and false.
• C# vs JavaScript: an overview (Novice): JavaScript was made for browsers in 1995 and is standardized as ECMAScript. It looks like C#, with braces, if and for, but it's a different language. It runs in every browser, and in Node.js outside one.
• calc(), min() and max(): Math in CSS (Journeyman): calc() does arithmetic with sizes, even mixing units such as 100% and 2rem, and min() and max() pick the smaller or the larger of two sizes, so a box fits a phone and a wide screen with no media query at all.
• Calculations in Columns (Apprentice): Work out new values as you query, with arithmetic on a row's columns and joined text, and give each calculated column a name.
• Calculations vs Aggregations (Apprentice): A calculation works within one row and returns a value for every row; an aggregation works across many rows and returns one value for all of them.
• Calling a Stored Procedure from C# (Journeyman): In ADO.NET, put the procedure's name in a SqlCommand, set its CommandType to StoredProcedure, and add each parameter by name. Then read the results as from any query.
• Canceling Events (Journeyman): A handler can cancel what the browser would do next, such as sending a form that failed validation, by calling preventDefault() on the event object the browser passes in.
• Captions and Subtitles (Journeyman): A track element adds captions or subtitles to a video from a small text file you can write by hand, so people who can't hear it, or don't speak its language, can still follow along.
• Cascade Layers with @layer (Journeyman): Cascade layers sort your rules into ranked groups such as reset, base, components and utilities, so a rule in a later layer wins whatever its selector, and specificity fights and !important stop being the way styles get settled.
• CASE / WHEN in T-SQL (Journeyman): CASE picks a value by conditions, like if and else if. Use it to label rows, to count only the rows that match with SUM(CASE ...), and to sort in a custom order.
• Changing Roles (Apprentice): Through the day, people treat Chloe as a student, a singer or an athlete. Each sees only the role it needs. Polymorphism shifts focus in the same way.
• Checkboxes, Radio Buttons and Fieldsets (Apprentice): Radio buttons let a visitor pick exactly one choice and checkboxes any number, and a fieldset with a legend groups them so everyone, screen-reader users too, knows what each choice answers.
• Checking a Form with JavaScript (Journeyman): Let the browser check a form with required, min and type, ask it in code with checkValidity(), add rules of your own with setCustomValidity(), and show each error next to its field where everyone, screen reader users included, can find it.
• Classes: Blueprints for Objects (Apprentice): A class is a blueprint for objects of one kind, with a constructor that fills in each new object and methods they all share, and new builds an object from it.
• Clean Code with ESLint and Prettier (Journeyman): ESLint reads your code and flags likely mistakes, like an unused variable or a == that should be ===, and Prettier formats every file the same way, so you set them up once with a flat config and npm scripts and let VS Code run them as you save.
• Client-Side Validation (Apprentice): Browsers check HTML attributes such as required on their own; ASP.NET Core's validation scripts check your model's data annotations in the browser, from the data-val attributes the tag helpers write.
• Closures at Work: Private State and Factories (Journeyman): Put closures to work to keep a count that no other code can change, to build as many independent counters as you need with a factory function, and to make a function that runs only once.
• Closures: Functions That Remember (Journeyman): A closure is a function together with the variables it could see where it was made, so it keeps using them after the function that made them has finished.
• Color That Works: Palettes and Contrast (Journeyman): A small palette (a brand color, neutrals, an accent, and success and error colors) makes a site look like one brand, and text that meets a contrast ratio of 4.5 to 1, with meaning never shown by color alone, makes it readable for everyone.
• Color: Names, Hex, rgb() and hsl() (Novice): CSS colors text with the color property and fills the area behind it with background-color, and it writes each color as a name, a hex code, rgb() or hsl(), with an alpha value when the color should be see-through.
• Combinators: Descendant, Child and Sibling (Apprentice): Combinators let one selector reach elements by where they sit on the page's family tree, inside another element, directly under it, right after it or anywhere after it, with no class needed.
• Combining Conditions with And, Or and Not (Apprentice): The logical operators && (and), || (or) and ! (not) join small true-or-false checks into one condition, so a single if can follow a real rule with several parts.
• Common Aggregate Functions (Apprentice): COUNT counts rows or values, SUM adds them, AVG averages them, and MIN and MAX find the smallest and largest. All but COUNT(*) skip NULL.
• Common DOM Interactions (Apprentice): Once you have an element, you change its text with textContent, its HTML with innerHTML, its look with style, and its CSS classes with classList.
• Common HTTP Status Codes (Apprentice): The status codes a REST API uses most, 200, 201, 204, 400, 401, 403, 404 and 500, and what each tells the client.
• Common Layout Bugs and How to Fix Them (Journeyman): The seven layout bugs almost everyone meets, from a page that scrolls sideways to a z-index that won't work, each with its symptom, its cause and the fix that removes the cause instead of hiding it.
• Common LINQ Methods (Journeyman): The LINQ methods you'll use every day. Where, OrderBy, ThenBy and Select filter, sort and reshape; Count, Sum, Average, Min, Max, Any, All and GroupBy summarize; First, FirstOrDefault, Take, Skip and Distinct pick items.
• Common Sense Design (Journeyman): Design tables from the questions the data must answer. Learn from Northwind's design - one subject per table, columns at their smallest useful size, a primary key in every table, and foreign keys to link them.
• Common String Tasks (Apprentice): Combine string methods to do everyday jobs, cleaning up input, reformatting names and phone numbers, padding, reversing and building long strings.
• Common Terminal Commands (Novice): The terminal commands you'll use most (pwd, cd, ls, mkdir, touch, cp, mv and rm) for moving around and managing files and folders.
• Common T-SQL Functions (Apprentice): T-SQL's built-in functions work on one row at a time. Join and change text, put a value in place of NULL, and pull apart dates and round numbers.
• Common UML Diagrams (Apprentice): UML is a shared way of drawing software. A use case diagram shows who uses the system and for what, a class diagram shows the classes and how they're related, and a sequence diagram shows the messages that pass between parts, in order. Sketch them to think and to explain.
• Components (Apprentice): Build a page from Bootstrap's ready-made components (buttons, navbars, cards, tables, forms, alerts and carousels) by copying their HTML and changing the content.
• Configure the Project for SQL Server (Journeyman): Add the Microsoft.Data.SqlClient package to a C# project, write a connection string for your local SQL Server, and keep it in appsettings.json.
• Constructor Injection (Journeyman): A class asks for its dependencies in its constructor and keeps them in readonly fields. Whoever creates it passes them in, so a test can pass a fake.
• Container Queries: Components That Fit Their Space (Freelancer): A container query changes a component's style by the width of the box it sits in instead of the width of the screen, so one product card can be stacked in a narrow sidebar and side by side in a wide spot on the same page.
• Controllers and Actions (Journeyman): A controller is a class whose public methods, its actions, answer requests. Learn how the default route picks one from the address, where parameters come from, and what an action can return.
• Conventional and Attribute Routing (Journeyman): Conventional routing builds every address from one pattern; attribute routing gives each action its own address with [Route] and [HttpGet]. Constraints such as {id:int} decide which addresses match.
• Converting Data Types in C# (Apprentice): C# converts a smaller type to a larger one for you; anything else you convert yourself, with a cast, the Convert class, or Parse for text.
• Cookie Authentication and [Authorize] (Journeyman): Turn on cookie authentication in Program.cs, sign users in with claims and SignInAsync, protect actions with [Authorize] and roles, and show who's signed in with User.
• Counting with for (Novice): A for loop puts its start, its condition and its step in one line, so counting up, counting down or counting by any step reads at a glance, and break and continue let you stop early or skip a pass.
• Create Database Scripts in T-SQL (Journeyman): Turn a design into a script that builds it - CREATE DATABASE, CREATE TABLE with types, NOT NULL, IDENTITY and DEFAULT, and constraints for primary keys, foreign keys, UNIQUE and CHECK.
• Creating an API Controller (Journeyman): An API controller derives from ControllerBase, is marked [ApiController], and gets its address from [Route]. It asks for its DAO through an interface registered in Program.cs, and its actions return data that ASP.NET Core sends as JSON.
• Creating an MVC Project (Apprentice): Create an ASP.NET Core MVC project, run it in the browser, and find your way around its folders and Program.cs.
• Creating Stored Procedures (Journeyman): A stored procedure is a named, saved batch of SQL that takes parameters. Create one with CREATE OR ALTER PROCEDURE, give parameters defaults, and run it with EXEC.
• Creating the LogService (Journeyman): Build a LogService that appends one time-stamped line per entry to a file named for the day, such as logs\errors\20260314.log. It asks for an IClock so tests can choose the date, and it never lets a logging problem crash the app.
• CSS (Novice): A CSS rule finds elements with a selector (by element name, class or id) and formats them with the properties inside its curly braces, such as color, border, width and display.
• CSS Grid: Rows and Columns (Apprentice): CSS Grid turns a box into an ice cube tray of rows and columns, so a photo gallery, a product page or a calendar lines up both ways at once with a few lines of CSS.
• CSS Nesting (Journeyman): CSS nesting lets you write a rule inside another rule, so a component's parts, its hover state and its media queries live together in one place instead of scattered through the file.
• CSS Performance: What Slows a Page, and Critical CSS (Freelancer): See why a stylesheet holds up the first paint, find unused CSS with the Coverage panel, animate transform instead of layout, skip off-screen work with content-visibility, inline the critical CSS, and measure the result with Lighthouse.
• Custom Properties: Variables in CSS (Apprentice): A custom property gives a value such as a brand color a name you choose, once, and every rule that reads it with var() follows when that one value changes.
• Dapper or EF Core? (Journeyman): Dapper gives full control of the SQL with very little to learn; EF Core writes the SQL, tracks changes and follows relationships. Choose Dapper when the SQL matters most and EF Core when the objects do, and keep to one per project unless there's a reason.
• Data Access Objects (Journeyman): Gather all the SQL for one table into a Data Access Object (DAO), so the rest of the program asks for models and never sees the database.
• Data Annotations and ModelState (Journeyman): Put validation rules on the model with data annotations such as [Required], [StringLength] and [Range]; check ModelState.IsValid in the action; add your own errors with AddModelError; and show the messages with validation tag helpers.
• Data in Transit vs Data at Rest (Apprentice): Stored data is at rest, and data moving between places, such as over a network or from a query, is in transit.
• Database Diagrams in SSMS (Journeyman): SSMS draws a database's tables and the foreign keys between them. Make a diagram of Northwind, read its keys and relationship lines, and know when to draw one.
• Database Relationships: an overview (Apprentice): The three kinds of relationship between tables (one-to-many, one-to-one and many-to-many) and how a diagram shows each.
• DbContext and Entities (Journeyman): EF Core maps entity classes to tables, matching names by convention. A DbContext class lists a DbSet for each table and holds the connection. In ASP.NET Core, register it with AddDbContext and UseSqlServer, and controllers ask for it like any other service.
• Debounce and Throttle (Freelancer): Debounce waits for a pause before it runs a function, throttle runs it at most once every so often, and an AbortController cancels a request that's out of date, so a busy page stays fast and shows the right answer.
• Debugging Layouts with Developer Tools (Journeyman): A seven-step routine for "why does it look like that?", using the Computed pane, the box model diagram, the flex and grid overlays, switching rules off, forcing :hover and :focus, and the outline trick.
• Debugging with Breakpoints (Apprentice): A debugger pauses your program at a breakpoint, lets you run it one line at a time, and shows every variable's value as you go, in VS Code for Node and in the browser's DevTools for a page, so you can see the line where a value goes wrong.
• Defining an Object (Apprentice): An object's responsibilities split into what it knows (its state) and what it does (its behavior), and a class is the blueprint that describes both.
• Defining Interfaces (Journeyman): Define an interface with the interface keyword, a name starting with I, and members with no bodies. A class implements it by listing it after the colon, after its base class, and writing every member as public.
• DELETE (Journeyman): DELETE removes the item at an address. It sends no body; the action deletes by the id from the route and answers 204 No Content, or 404 Not Found when there was nothing to delete.
• Deleting Data (Apprentice): Remove rows with DELETE FROM ... WHERE, test the WHERE first, and delete in the order the foreign keys allow.
• Description Lists (Apprentice): A description list pairs names with their meanings or values, such as a glossary or a menu with prices, using dl for the list, dt for each name and dd for what it means.
• Design Tokens: a Small Design System (Journeyman): Design tokens are a short list of custom properties for a site's colors, type sizes, spacing, corners and shadows, named by their job, so every component is built from the same decisions and one change restyles them all.
• Designing a User Experience (Apprentice): The UI is what users see; the UX is how it feels to get something done. Start from what users want to do, plan the flow and sketch a wireframe before writing code, then make every screen clear, consistent, honest about what's happening, and usable by everyone. Then watch real people try it.
• Destructuring (Apprentice): Destructuring unpacks the values you need from an object or an array into variables in one line, with defaults for anything missing and new names when you want them.
• Details and Summary: Show and Hide (Apprentice): The details and summary elements make a section that opens and closes when it's clicked, such as an FAQ answer or a quiz answer, with no JavaScript and with keyboard support built in.
• Developer Tools (Apprentice): Every browser has built-in developer tools that show any element on a page, its HTML and every CSS rule applied to it, so you can find out why a page looks the way it does.
• Developer Tools: Inspecting a Page (Apprentice): Every browser has built-in developer tools that show the page as the browser built it, so you can find any element, see what the browser repaired, and try changes safely.
• Dictionaries in C# (Apprentice): A Dictionary<TKey, TValue> stores values under unique keys, so you can look one up by its label instead of its position.
• Div and Span: Boxes with No Meaning (Apprentice): Div and span are plain boxes that say nothing about what they hold, so you use them to group or style content only when no meaningful element fits, and you learn to spot the "div soup" that happens when they're used for everything.
• Do-While Loop (Apprentice): Run a block of code at least once, then repeat it while a condition is true, with C#'s do-while loop.
• Drawing the Page from Your Data (Journeyman): Keep what the page shows in an array, write one render function that draws the page from it, and have every listener change the data and call render, so the page and the data never disagree.
• Dropdowns, Text Areas and Suggestions (Apprentice): A select makes a dropdown list of options, a textarea gives room for a longer answer, and a datalist suggests answers while still letting the visitor type their own.
• DRY Code in C# (Novice): When several classes repeat the same properties and methods, the code breaks the DRY rule (Don't Repeat Yourself). One class that does everything isn't the answer either.
• Elements and Tags (Novice): Every web page is built from elements, boxes with a start tag, content and an end tag, that fit inside each other like boxes inside boxes.
• Elements, Tags and Attributes (Novice): A web page is content with labels on it, called tags, and once you can read the labels you know exactly what your CSS will style.
• Embedding Maps and Videos with iframe (Journeyman): An iframe shows a piece of another website, such as a YouTube video or a map, inside your page, and a few attributes keep it accessible, fast and safe.
• Equality and Truthy Values (Apprentice): JavaScript has a loose == that converts types before comparing and a strict === that doesn't, and it treats every value as truthy or falsy in a condition, so you learn which to use and where 0 and empty text trip people up.
• Example: a Product DAO (Journeyman): A complete ProductDao for Northwind, with methods to get, search, add, update and delete products, all with parameters and one mapping method.
• Exceptions in C# (Apprentice): When something goes wrong at run time, C# throws an exception, and the program crashes unless code catches it. Prevent what you can check for; catch what you can't, most specific type first; and throw your own when a method can't do what it's asked.
• Execute: Insert, Update and Delete (Journeyman): Execute runs INSERT, UPDATE and DELETE and returns how many rows changed. To get a new row's id back, query it with QuerySingle<int>.
• Exercise: A Fan Page for Your Favorite Band (Novice): Build a two-page fan site for a band you love, with a heading outline, paragraphs, a link to the band's site, jump-to links and an album page linked both ways, and let the tests check every heading and link.
• Exercise: A Game High-Score Board (Apprentice): Build the Galaxy Blasters arcade's high-score board from plain-text data, with a countdown list, a scores table with a caption, header cells and a totals row, and a description list, and let the tests check its structure.
• Exercise: A Mobile-First Taco Truck Page (Journeyman): Style Sol Taco Truck's ready-made page mobile first, with a one-column phone layout, two min-width breakpoints in rem and a truck photo that fills its box, and let the tests check each part.
• Exercise: A Pet Adoption Page (Novice): Write Paws & Whiskers' whole "Meet Biscuit" page from a content sheet, with a skeleton, structure elements, a pet-card class and a linked stylesheet with two rules, and let the tests check every part.
• Exercise: A Photo Gallery Grid (Journeyman): Lay out Trail Photo Club's page with CSS Grid, from named page areas to a gallery that fits any width, a photo of the month that covers four cells and cards lined up with subgrid, and let the tests check each step.
• Exercise: A Pizza Order Form (Apprentice): Build Slice of Heaven Pizza's online order form with radio buttons, checkboxes, a dropdown, typed inputs and a text area, then send it and see exactly what the kitchen receives.
• Exercise: A Podcast Episode Page (Journeyman): Build the page for a bike-repair podcast's episode, with an audio player, a transcript, a captioned video and a map, and let the tests check each part.
• Exercise: A Reusable Review Card (Freelancer): Build Pixel Palace's reviews page with a banner in declarative shadow DOM, a review card layout written once and used four times, and star ratings from a ready-made custom element, then explain two repairs the parser made, and let the tests check it all.
• Exercise: A Song Request Form (Apprentice): Build the request form for a local radio station, with four labeled text boxes and a submit button, then send it by GET and by POST and record exactly what it sent, while the tests check every box and label.
• Exercise: A Trivia Night Page (Apprentice): Build the page for a pizzeria's trivia night, with answers that open on a click, house rules in a popover, the date in a time element and a quote from last month's winners, and let the tests and the validator check it.
• Exercise: A Weekend Trip Guide (Apprentice): Build a three-page weekend guide to a lakeside town, with pictures, alt text, links between the pages and a ready-made stylesheet, then put it online and send someone the link.
• Exercise: Abstraction (Journeyman): Finish a city bike share. Make Vehicle an abstract class that every kind of vehicle prices for itself, give the electric ones the IChargeable contract, and write a RideService that gets its time from an IClock.
• Exercise: Aggregating Data (Journeyman): Twelve questions about Northwind, answered with COUNT, SUM, AVG, MIN, MAX, GROUP BY and HAVING, each with the result to expect.
• Exercise: an Angular Client for a Web API (Journeyman): Give your products API a front end. A service calls the API with HttpClient; a component lists the products, filters them by category, deletes them and adds new ones, and says so when something fails. Ten tests answer for a pretend API, so they need nothing running.
• Exercise: An Animated Game Start Screen (Journeyman): Bring Star Hopper's start screen to life with twinkling stars, a title that slides in, buttons that lift on hover and focus and a looping loading bar, then calm it all for reduced motion, while the tests check every rule.
• Exercise: an API Client (Journeyman): Write a ProductClient for your products API, with one async method per endpoint, 404s turned into null or false, and a low-stock report built with LINQ. Tests give it a fake API, so they need nothing running.
• Exercise: Arcade Token Counters (Journeyman): Write the Starlight Arcade's token counters, prize-ticket machine and once-only welcome bonus, each keeping its count private in a closure, and let the tests check each one.
• Exercise: Arrays and Loops (Apprentice): Solve 17 problems with arrays and loops (filling, searching, totaling, finding the highest and lowest, reversing) and check each with tests.
• Exercise: Audit the Movie Theater Page (Journeyman): Run a full accessibility audit on the Starlight Cinema's showtimes page, log the ten barriers you find, fix the HTML, and let the tests confirm every fix.
• Exercise: Badges and a Sticky Header (Apprentice): Pin New! badges to the corners of Paws & Whiskers' pet cards, lay an overlay over a photo, make the header stick and the Adopt today button stay on screen, and choose what sits in front, while the tests check every rule.
• Exercise: Band Fan Page (Apprentice): Put a band's tour on its fan page with JavaScript, building a line for each upcoming show from an array, marking the sold-out ones and counting what's left, with tests for the data and a checklist for the page.
• Exercise: Bike Cards That Fit Anywhere (Journeyman): Make one Spoke & Chain bike card fit three kinds of spots, a wide feature, a catalog column and a narrow sidebar, with named containers, @container rules and a fluid title, and let the tests check each part.
• Exercise: Bike Rental Prices (Apprentice): Finish four functions for a bike rental shop, using conditions, the conditional operator and a for loop, and let the tests check every price, bike size and group receipt.
• Exercise: BooksPlus (Journeyman): Turn a new ASP.NET Core MVC project into a small bookstore website for BooksPlus, with featured books, a list, details, search and a form that adds a book, and run tests that request every page.
• Exercise: Bookstore Search (Freelancer): Make a bookstore's search box fast and safe, writing a debounce function tested with fake timers, a search that finds books by title or author, and results drawn with textContent, so a title made of HTML shows as text.
• Exercise: Bootstrap (Apprentice): Build a four-page bookstore with Bootstrap 5, with a navbar, a carousel, a table of books with a paging button group, and two forms, and check it at every screen size.
• Exercise: Build-It Pizzeria (Journeyman): Design a database for a build-your-own pizzeria from its menu and order slips, write the script that builds and fills it, and answer the owner's questions with queries.
• Exercise: Classes (Apprentice): Write six classes from a specification (Rectangle, Circle, MathTest, Printer, Elevator and Airplane), choosing each property's access, and let the tests check them.
• Exercise: Coffee Shop Receipt (Novice): Finish six small functions that work out a coffee shop receipt's subtotal, tax, tip and lines, using numbers, strings, comparisons and conversions, and let the tests check each one.
• Exercise: Collections (Apprentice): Solve 14 problems with List<T> and Dictionary<TKey, TValue> (filtering, searching, counting, looking up and combining) and check each one with tests.
• Exercise: Connecting an App (Journeyman): Write the Data Access Objects for the BooksPlus bookstore (categories, books and customers) with ADO.NET, and run tests that check them against your own database.
• Exercise: Cookies and Pizza (Apprentice): Plan a party in JavaScript. Write functions with default parameters for cookies and boxes, then use filter, map, find, sort and reduce with arrow functions to pick pizzas, price an order and describe it, with tests run by Node.
• Exercise: Dependency Injection (Journeyman): Write a cinema box office that is given its clock and price list, sells each seat once with a HashSet, keeps a waiting list in a Queue, and undoes sales with a Stack.
• Exercise: Dog Breed Explorer (Journeyman): Finish an animal shelter's dog breed explorer, writing the functions that read the Dog CEO API's breed list, build a photo's address and load a photo with friendly errors, with offline tests for the functions and a checklist for the page's loading, empty and error states.
• Exercise: File I/O (Journeyman): Read a school's grades from a CSV file with mistakes in it, log every line you can't read with your own LogService, write an honor roll, and add new students to the end of a file.
• Exercise: First Styles (Novice): Give The Daily Grind's menu its look with five CSS rules from the owner's style guide, and run the exercise checks for the first time to see each rule pass.
• Exercise: Fix the Broken Recipe Blog (Freelancer): Find and fix five layout bugs on a recipe blog's home page with the developer tools, write down the cause of each, and let the checks confirm every fix.
• Exercise: Fix the Coffee Shop Page (Novice): Find and fix six mistakes in a coffee shop's home page, using the developer tools to see what the browser made of it, until every test passes.
• Exercise: Fix the Frustrating Sign-Up Form (Journeyman): Fix Peak Fitness's frustrating sign-up form with real labels, the right types, autocomplete, hints and required fields marked in words, then let the checks and a keyboard-only run prove it works.
• Exercise: From Div Soup to Semantic HTML (Apprentice): Rewrite the Maple Street Library's div-soup news page with header, nav, main, article, section, aside and footer, without changing a word, and watch its ready-made stylesheet and its checks reward every region you mark up.
• Exercise: Fun Run Sign-Ups (Apprentice): Finish seven functions that tidy a 5K fun run's messy sign-ups, from names and bib numbers to missing shirt sizes, donations and emergency contacts, and save and load the list as JSON, with tests that check each one.
• Exercise: Game Night Project Setup (Journeyman): Take a working but messy Game Night scoreboard and set it up like a professional project, with npm scripts, ESLint, Prettier and a .gitignore, until npm run lint, npm run format:check and the tests all pass.
• Exercise: Game Score Functions (Apprentice): Write the four functions that keep score in a small video game, from points for coins to the end-of-level line, and let the tests check each one.
• Exercise: High-Score Leaderboard (Journeyman): Finish six functions that turn an arcade game's high-score list into its top 3, display lines, totals and a numbered leaderboard, using map, filter, reduce and sort, and let the tests check each one.
• Exercise: Inheritance (Apprentice): Finish a café menu's Drink and Pastry classes so they inherit from MenuItem, with constructors that call base(...), an overridden Price and an overridden ToString().
• Exercise: Joins (Journeyman): Twelve questions about Northwind that each need more than one table, answered with inner and outer joins, a self join, sub-queries and CASE, each with the result to expect.
• Exercise: Load a Partial View with fetch (Journeyman): Give BooksPlus a search that updates as you type. Move the results into a partial view, add an action that returns just that partial, and write the JavaScript that fetches it on every keystroke, while the plain search form keeps working.
• Exercise: Make the Food Truck Page Shine (Journeyman): Write the head of a food truck's page, with a real title and description, a link preview, a canonical link and structured data, and let the tests and two validators check it.
• Exercise: Methods and Conditions (Apprentice): Write 13 methods for three small businesses, using parameters, return values and conditions, and check each one with tests.
• Exercise: Modifying Data (Apprentice): Add a category, products, yourself and a customer's order to Northwind, then update and delete them, with scripts that use variables and transactions.
• Exercise: MVC with Dapper (Journeyman): Grow the BooksPlus website - Dapper and dependency injection, attribute routes, a paged grid of partial-view cards, a validated Add a Book form for administrators only, and recently viewed books in the session.
• Exercise: Northwind Web API (Journeyman): Build Northwind's products API. Write an async controller with GET (all, by category, by id), POST, PUT and DELETE, each answering the right status code, and set up Program.cs to register the DAO and handle errors in one place.
• Exercise: Organize the Board Game Café's Styles (Journeyman): Sort Meeple's 260-line stylesheet into four cascade layers, nest the rules that belong together and remove every !important, while a check compares every style on the page with the original to prove nothing changed.
• Exercise: Pet Adoption Profiles (Apprentice): Finish five functions for a pet adoption site, building profile lines with destructuring and safe copies with spread, and let the tests check each one.
• Exercise: Pizza Order Tracker (Journeyman): Write the order tracker for a busy pizza shop with async and await, Promise.all and Promise.any, from one order through the oven to the fastest free driver, and let the tests check each piece.
• Exercise: Polymorphism (Journeyman): Write a café Order that holds any mix of menu items in one List<MenuItem>, and works out the total, a meal-deal discount and the receipt, letting each item price itself.
• Exercise: Reading List (Journeyman): Make a reading-list page work, reading its add-book form, refusing a book with no title or 0 pages with a message next to the field, and saving the list in localStorage so it's still there tomorrow, with tests for the rules and a checklist for the page.
• Exercise: Recipe Filters (Journeyman): Bring the Weeknight Recipes page to life, drawing its cards from data, filtering them with buttons, opening each card's steps with one delegated listener and closing them with Escape, and let the tests and a checklist confirm it works.
• Exercise: Recipe Scaler (Journeyman): Finish a recipe scaler split into modules, which converts cups to milliliters, scales a recipe from 4 servings to 10 and refuses bad servings with a ServingsError, and let the tests check each piece and each error.
• Exercise: Redesign the Farmers Market Page (Journeyman): Redesign the Saturday Farmers Market's cluttered event page with a type scale in rem, readable line lengths and line heights, a palette that passes 4.5 to 1 contrast, rem spacing and soft vendor cards, and let ten checks measure each part.
• Exercise: Refactor the Library's Events Page (Freelancer): Rename a library events page's id selectors and long chains to flat BEM classes, move its helpers into a utilities layer, and keep the page looking exactly the same while six checks confirm it.
• Exercise: Rewrite a DAO with Dapper (Journeyman): Use Dapper to rewrite the BooksPlus DAOs from the Connecting an App exercise, add a rename and a lookup by a list of ids, and pass the same tests with a fraction of the code.
• Exercise: Road-Trip Playlist (Apprentice): Finish five functions that keep a road-trip playlist up to date, adding and removing songs, totaling the play time and checking for a song, and let the tests check each one.
• Exercise: Shopping List and Calculator (Apprentice): Bring a web page to life with JavaScript. Add items to a shopping list, cross them off and remove them, keep a live count, and build a calculator that shows its result or an error, all with event handlers and DOM changes, and no page reloads.
• Exercise: SnackShack (Journeyman): Answer a snack bar owner's questions with LINQ. What's cheap, what's in each category, what sells best, what never sells, how much came in each day, and one page of the menu at a time, each in one chain of methods.
• Exercise: Space Fleet (Journeyman): Finish the classes behind a space shooter's fleet, a Ship with private shields, a Fighter that extends it and a Fleet that reports who can fly, and let the tests check each one.
• Exercise: Speed Up the Travel Blog (Journeyman): Make a slow travel blog fast and friendly to screen readers, with alt text by purpose, width and height, lazy loading, srcset and a picture element, and measure the difference.
• Exercise: Strings (Apprentice): Build HTML and XML from strings, format and rearrange people's names, and try seven bonus word problems, with tests that check each method.
• Exercise: Style a Playlist Without Adding Classes (Apprentice): Style the Road Trip Mix playlist with eight rules that reach every part through combinators, attribute selectors, pseudo-classes, pseudo-elements and :has(), without adding a single class, and let the checks confirm each one.
• Exercise: The Daily Specials (Novice): Print The Daily Grind's chalkboard of daily specials with console.log, fix a line with a mistake in it and switch a sold-out item off with a comment, and let the tests check every line.
• Exercise: The Festival Lineup (Journeyman): Lay out the Summer Sound festival's home page with flexbox, a nav bar with the logo left and the links right, a welcome message centered both ways and a row of headliner cards that wraps to fit any screen, and let the tests check every part.
• Exercise: The Taco Truck Menu (Novice): Give Sol Taco Truck's ready-made menu page its look (a color palette, a web font for the headings, readable body text, prices and labels that stand out, and a chalkboard behind the truck's name), and let the tests check each step.
• Exercise: Themeable Buttons and Cards (Journeyman): Rebuild The Daily Grind's buttons, menu card and sign-up field on design tokens defined on :root, then give them a dark theme that changes only the tokens, and let the tests check both themes.
• Exercise: Ticket Booth Tests (Freelancer): Write the Vitest tests for a movie theater's working ticket booth, from its prices and discounts to its page, and prove they're good by catching three bugs the check plants in the code.
• Exercise: Trading Cards (Apprentice): Turn three plain Forest Friends cards into real-looking trading cards with border-box, rem spacing, borders, rounded corners and auto margins, and let the tests check each part.
• Exercise: Tribute Page and Flexbox (Apprentice): Build a three-page tribute website with semantic HTML and CSS, then practice layout in our games Flex Freight and Grid Town and use it on your site.
• Exercise: Tune Up a Slow Page (Journeyman): Fix the Movie Night Club page's HTML so it loads faster on a phone, and prove it with the Network panel, a Lighthouse report and the tests.
• Exercise: Variables and Data Types (Novice): Solve 28 small problems with variables, data types and expressions, and check every answer with tests.
• Exercise: Views, Procedures and Functions (Journeyman): Ten problems that create views, stored procedures and functions in Northwind and then use them, each with the result to expect.
• Exercise: Why Won't It Change? (Apprentice): Find out why five of a bike shop's styles lose, fix each one without !important, and write one line saying why it lost, until every test passes.
• Exercise: Workout Interval Timer (Journeyman): Build the engine of a workout interval timer, a plan of work and rest, a clock display and a countdown that runs on setInterval, and let tests with a pretend clock check it in a split second.
• Exercise: Writing Unit Tests (Apprentice): Three finished classes each hide one bug. Plan scenarios from their requirements, write MSTest tests that find the bugs, and fix the code.
• Exercise: Your First Web Page (Novice): Make a web page announcing a neighborhood game night, watch it update in the browser as you save, and run the five checks that tell you it has everything a page needs.
• Extract Transform Load (Apprentice): ETL (Extract, Transform, Load) takes data from a source, reshapes it in a series of small steps, and stores it at a destination.
• Factory Method (Journeyman): A factory method makes an object for you, so the code that uses it doesn't name the class it gets. A simple factory picks the class in one switch, instead of in every caller; the Gang of Four's Factory Method lets each subclass decide what to create. ASP.NET Core's registrations with a lambda are factories too.
• Fetch (Apprentice): The browser's fetch function sends HTTP requests from JavaScript and returns a promise of the response. Chain .then to read the JSON, check response.ok before trusting it, and pass an options object to POST, PUT or DELETE.
• Fields vs Properties (Apprentice): A property looks like a field from outside but runs code inside, so a class can let others read and set a value while it checks every change.
• File, FileInfo and Path (Apprentice): File and Directory check for, create, list, copy and delete files and folders. FileInfo describes one file. Path builds paths with Path.Combine and takes them apart, without touching the disk.
• Files and Folders for a Website (Novice): A website is a folder of files, so give each site its own folder, name every file in lowercase with hyphens instead of spaces, make index.html the front page and keep pictures in an images folder.
• Finding Things in an Array (Apprentice): Ask an array questions instead of writing a loop for each one, with includes and indexOf for an exact value, and find, findIndex, some and every for any test you write.
• Finishing Touches: Rounded Corners, Shadows and Gradients (Apprentice): border-radius rounds corners, a soft layered box-shadow lifts a card off the page, linear-gradient() and radial-gradient() blend colors in a background, and opacity fades a whole element, and each looks best used sparingly.
• Fixed (Apprentice): Fixed positioning places an element relative to the browser window, so it stays on screen while the page scrolls.
• Flexbox Alignment: justify-content and align-items (Apprentice): justify-content spaces flex items along the main axis, align-items and align-self line them up across it, the two together center anything both ways, and an auto margin pushes one item to the far end.
• Flexbox or Grid? Choosing the Right Tool (Journeyman): Flexbox lines things up in one direction and lets the content set the sizes, grid lays out rows and columns you plan first, and positioning lifts one thing on top, so three questions tell you which fits each part of a page.
• Flexbox Sizing: flex-grow, flex-shrink and flex-basis (Journeyman): Each flex item starts from its flex-basis, flex-grow shares out the leftover space like splitting a bill, flex-shrink decides who gives up room when it's tight, flex: 1 sets all three at once, and min-width: 0 lets a long line of text shrink.
• Flexbox Wrapping and gap (Journeyman): flex-wrap lets flex items move onto a new line when they run out of room, gap puts even space between them, align-content places the lines, flex: 1 1 15rem makes a card row that fits any screen, and order changes what the eye sees but not what the keyboard follows.
• FlexBox: an overview (Apprentice): Setting display to flex on an element lines up its children side by side in a row, and flex-direction can turn that row into a column.
• Flexbox: Lining Things Up in a Row or a Column (Apprentice): One line of CSS, display: flex, lines up an element's children in a row, flex-direction turns the row into a column, and the main and cross axes name the two directions every other flexbox property works along.
• Fluid Type and Spacing with clamp() (Journeyman): clamp() keeps a size between a minimum and a maximum and lets it grow smoothly in between, so headings and spacing fit a phone and a wide screen without a single breakpoint, while still following the reader's zoom.
• Fonts and Text: Family, Size, Weight and Spacing (Novice): A handful of text properties (font-family with fallbacks, font-size, font-weight, font-style, line-height, text-align, text-transform, letter-spacing and text-decoration) turn plain words into text people can read at a glance.
• For Loop (Novice): Count through a range of numbers, or through an array's indexes forward, backward or in steps, with C#'s for loop.
• Foreach Loop (Apprentice): Visit every element of an array without an index using C#'s foreach loop, and leave a loop early with break or skip ahead with continue.
• Form Events (Apprentice): Form controls send their own events, for the moments a visitor types, changes a value, moves between fields or sends the form, so you can pick the one that fires exactly when you need it.
• Full Example (Journeyman): A complete console program that reads the connection string from appsettings.json, queries Northwind's categories, and prints a report.
• Function Expressions and Arrow Functions (Apprentice): A function can be stored in a variable like any other value, arrow functions (=>) write small functions in a line, and default values fill in the arguments a caller leaves out.
• Functions as Values: Callbacks (Apprentice): In JavaScript a function is a value you can hand to another function, which calls it for you; that handed-over function is a callback, and it's how sorting, timers and buttons work.
• Generalization vs Specialization (Apprentice): Generalization moves what similar classes share into a base class; specialization keeps what makes each one different in its derived class.
• GET (Journeyman): GET reads data. One [HttpGet] action returns the whole collection, and an [HttpGet("{id}")] action returns one item, its id taken from the address. ASP.NET Core sends what they return as JSON, with 200 OK.
• GET and POST Actions (Journeyman): A search form sends a GET request with a query string; a form that saves data sends a POST. Pair a GET action that shows the form with a POST action that saves it, redirect afterward, and protect it with an anti-forgery token.
• Getting Data with fetch (Apprentice): fetch sends a request to a web API and gives back a promise of the response; await it, then await response.json() to turn the JSON answer into a JavaScript value your page can use.
• Git (Novice): Git keeps a history of your code, so you can go back to an earlier version, and on Windows it comes as Git for Windows, with Git Bash to type its commands in.
• GitHub (Novice): GitHub keeps your Git repositories online, where you back up your work, get practice code and share it, and Git Credential Manager signs you in to it from Git Bash.
• Grid (Journeyman): CSS Grid lays a container's children out in rows and columns at once, with column widths you set in fr, % or px, gaps between the cells, and items that can span more than one cell.
• Grids That Fill the Space: repeat(), minmax() and auto-fit (Journeyman): One line of CSS, repeat(auto-fit, minmax(14rem, 1fr)), makes a gallery that shows one column on a phone, four on a laptop and more on a wide screen, with no media query at all.
• Grouping Aggregations (Journeyman): GROUP BY splits the rows into groups and runs the aggregates once per group. Every column in the SELECT that isn't aggregated must be in the GROUP BY.
• Handling Errors with try, catch and finally (Apprentice): try runs code that might fail, catch takes over when it does and gets an error object with a name and a message, and finally runs either way, so one bad value doesn't stop your whole program.
• Handling Global Exceptions in ASP.NET Core (Freelancer): AddProblemDetails and UseExceptionHandler catch every exception an action doesn't, log it, and answer with a tidy 500 problem details response that never shows the stack trace. An IExceptionHandler can answer chosen exceptions with a better status, such as 409 Conflict.
• Hashing and Encryption (Journeyman): Hashing is one-way, a fingerprint you can check but never undo, so it's for passwords. Encryption is two-way with a key, so it's for data you need back. A password hash needs a random salt and many rounds, which is what PBKDF2 and ASP.NET Core's PasswordHasher do for you.
• HashSet (Journeyman): A HashSet<T> holds each value once, answers "is it in here?" fast, and has no index or guaranteed order. Add tells you whether a value was new.
• HAVING (Journeyman): WHERE filters rows before they're grouped; HAVING filters the groups afterward, by their aggregates. Know which to use, and the order a query's clauses run in.
• Header, Nav, Main and Footer (Apprentice): Mark up the four big parts of almost every web page (its top, its menu, its main content and its bottom) with header, nav, main and footer, so screen readers and search engines can find their way around it.
• Headings and the Page Outline (Novice): Headings from h1 to h6 give a page an outline, like a book's title, chapters and sections, so readers and screen readers can find their way around it.
• Hierarchy, Alignment and Whitespace (Apprentice): A page looks designed when the most important thing is seen first, everything lines up on a few shared edges, and space groups the things that belong together, and CSS sets all three with size, weight, color, text-align, padding and margin.
• Hints and Error Messages Everyone Can Use (Journeyman): Hints tied to their fields with aria-describedby, required fields marked in words, error messages that say how to fix the problem, and one column in a sensible order make a form everyone can finish.
• Hoisting, var and the Temporal Dead Zone (Journeyman): Before JavaScript runs a scope it notes every declaration in it, which is why a function can be called above the line that makes it, why var gives undefined there, and why let and const stop with an error instead.
• Hooks for CSS: the class and id Attributes (Novice): The class attribute gives a label that many elements can share and the id attribute names one element, and together they are the hooks CSS uses to style exactly the parts you mean.
• How a Browser Shows a Page (Novice): When you type a web address, your browser sends a request to a web server, the server sends back the page's HTML in a response, and the browser draws it; View Source shows you that HTML.
• How a Form Sends Data (Apprentice): A form turns each answer into a name=value pair and sends the pairs to the address in its action, inside the address itself with GET or inside the request with POST.
• How a Page Loads (Journeyman): Watch the browser read a page from top to bottom and fetch every file it names, then measure the page's size and speed the way a visitor on a phone feels them.
• How the Browser Parses HTML (Freelancer): The browser reads your HTML file one character at a time, breaks it into tokens, builds a tree of nodes from them, and quietly repairs your mistakes along the way, so you can tell why a page shows what it shows.
• How the Layers Work Together (Novice): Follow one pizza order from a tap on the screen, through the API and the database and back again, to see how the front end, the back end and the database work as one app.
• How This Course Works (Novice): How CSS in Depth works on ask-codey.com, from reading a lesson and running its exercise checks to mastering a skill and passing a module assessment.
• How This Course Works (Novice): How JavaScript in Depth works on ask-codey.com, from reading a lesson and running its code to exercises, chapter checks, module assessments and the projects you build.
• How to read a URL (Novice): A URL has five parts (protocol, domain name, port, path and query string), and each one tells the web server something about the request.
• HTML (Novice): HTML builds a page from elements, each an opening tag, content and a closing tag, and whether an element is block, inline or inline-block decides how it takes up room on the page.
• HTML (Novice): HTML is the structure of a web page and CSS is its finish, the way a house has framing and paint, and good CSS needs solid HTML underneath it.
• HTTP Status Codes: an overview (Apprentice): Every response starts with a status code that says how the request went. By default an ASP.NET Core API answers 200 when an action returns, and 500 when it throws, so an action has to choose a better code, such as 404, on purpose.
• HttpClient Basics (Journeyman): HttpClient sends HTTP requests from C#. Give it a base address, await GetAsync for a response, check its status code, and read its body. A failed status is an answer to handle; a server that can't be reached throws an HttpRequestException.
• HttpClient in Angular (Journeyman): Call your Web API from a service with HttpClient's get, post, put and delete, each typed with the model it returns. Angular provides HttpClient on its own. While developing, a proxy sends the app's /api requests on to the API, so the browser sees one origin.
• Icons, Stylesheets and Resource Hints (Journeyman): Use the head's link tags to give a page its tab icon and its stylesheet, and to tell the browser early about the few files it needs first.
• If (Novice): Run code only when a condition is true, with if, if-else and else if, and write conditions with C#'s comparison operators.
• Image Dimensions and Lazy Loading (Journeyman): Stop a page from jumping while its pictures load with width and height, let pictures further down wait with loading="lazy", and give the first picture priority.
• Image Formats and File Size (Apprentice): Learn why a photo straight from your phone is far bigger than a page needs, and which file format fits each picture, from JPEG and PNG to SVG, WebP and AVIF.
• Imperative (Apprentice): In the imperative style, your JavaScript finds an element and attaches a handler to it with addEventListener, so the HTML holds no JavaScript at all.
• Inheritance and Constructors (Journeyman): When a base class has a constructor with parameters, every derived class must call it with base(...). The base class's constructor always runs first.
• Inheritance in C# (Apprentice): A derived class names its base class after a colon. It inherits every member of the base class, but its code can use only the public and protected ones, never the private ones; and every class inherits from object in the end.
• Inheritance Review (Apprentice): A quick look back at inheritance in C#. A derived class names its base class after a colon, inherits its members, adds its own, and overrides the base class's virtual methods.
• Inheritance with extends and super (Journeyman): A class that extends another starts with everything the parent has, calls super to let the parent set up its part, and can add methods or override the parent's with its own version.
• Inheritance: What Children Get from Their Parents (Apprentice): Some properties, mostly text ones such as color and font, pass from an element to everything inside it, while box properties such as border and padding stay put, and a few keywords let you choose.
• INNER JOIN (Journeyman): INNER JOIN combines two tables on a matching column, keeping only rows that match. Table aliases keep it short, and the joined columns can be filtered, grouped and sorted like any others.
• Input Types for Email, Numbers, Dates and More (Apprentice): One attribute, type, tells the browser what kind of answer an input is for, so a phone shows the right keyboard and the browser checks some answers for you.
• Inserting Data (Apprentice): Add rows to a table with INSERT INTO, name the columns you fill, let identity columns number new rows, and respect the table's keys.
• Interface Definition (Apprentice): The word "interface" is both a noun and a verb, and software uses both meanings.
• Introducing the DOM: an overview (Novice): When the browser loads a page, it turns the HTML into the DOM, a tree of objects with one for each element, and JavaScript reads and changes the page through that tree.
• Introduction to Arrays (Novice): An array keeps many values of the same type together in one fixed-size container, like eggs in a carton.
• Introduction to Inheritance in C#: an overview (Apprentice): Inheritance lets one class build on another. An archer is a character, so Archer inherits everything Character has, and adds what only archers have.
• Introduction to List<T> (Apprentice): A List<T> holds values of one type and grows and shrinks for you; the T says which type, like int or string.
• Introduction to Methods: an overview (Novice): A method is a named block of reusable code; you've been calling them since your first program.
• IP Addresses and Ports (Novice): An IP address finds the computer, and a port finds the program on it. Meet localhost, the ports the web uses, and the ports your own apps listen on.
• Iterator (Journeyman): The Iterator pattern lets code walk through a collection without knowing how it's stored. In C#, foreach works on anything that implements IEnumerable<T>, which hands out an IEnumerator<T> with MoveNext and Current. Write one by hand to see how it works, then let yield return write it for you.
• JavaScript on a Web Page (Novice): Load a JavaScript file into a ready-made web page with a script tag, open the page with Live Preview, and use the browser's Console to see what the script prints, read its errors and try a line of JavaScript.
• Joining Multiple Tables (Journeyman): Joins chain: each JOIN adds one more table, linked by its key to a table already in the query. A many-to-many link goes through its associative table, and a table can even join to itself.
• Joining Tables in T-SQL: an overview (Apprentice): A join puts related rows from two tables side by side, matched on their key columns. An inner join keeps only matches; an outer join also keeps the rows with no match.
• JSON Web Tokens (Journeyman): A JSON Web Token is a signed note an API gives you at sign-in: header, payload and signature, joined with dots. Anyone can read the payload, but nobody can change it without the key, so the API can trust the claims in it, such as who you are and your role, until it expires.
• JSON: Data You Can Save and Send (Apprentice): JSON is the text format the web uses to save and send data, and JSON.stringify and JSON.parse turn your objects and arrays into JSON text and back, as long as the text follows JSON's strict rules.
• Justify Content (Apprentice): The justify-content property on a flex container decides where the extra space goes, so its items can sit at the start, the end, the center or spread out.
• Keeping Pages Safe: XSS and innerHTML (Journeyman): When a page puts someone else's text into innerHTML, that text can become code that runs in every visitor's browser, so you show it with textContent and createElement instead, and you keep secrets off the front end altogether.
• Keeping Up with HTML (Journeyman): HTML grows a little every few months, so learn where its rules are written, how MDN and Baseline tell you whether a feature works in every browser, and how to use a new feature without leaving anyone behind.
• Keyboard Use and Focus (Journeyman): Everything on a page should work with the keyboard alone, and it does when you use real links, buttons and form fields in a sensible order, add a skip link, and keep the focus ring visible.
• Keyboard Users and Accessible Controls (Journeyman): Build controls that work for people who use a keyboard or a screen reader, with real buttons, aria-pressed and aria-expanded that match what the page shows, and an Escape key that closes what's open and puts focus back.
• Keyframe Animations (Journeyman): A keyframe animation describes motion as a few key moments in a @keyframes rule and plays it with the animation property, so a spinner turns, a title slides in and a Start button pulses with no reader action needed.
• Lambda Expressions (Apprentice): A lambda expression is a small method with no name, written where it's used, such as name => name.Length > 4. Pass one to a method like FindAll, RemoveAll or Sort, and that method runs it on each item.
• Layers: Models, Services, Controllers (Journeyman): Apps are split into layers (controllers, services, data access and models), each with one job, each handed the layer below it through its constructor.
• Light and Dark Themes with prefers-color-scheme (Journeyman): A dark theme is the same page with new token values: you redefine the color tokens in a prefers-color-scheme media query, set color-scheme, and every component follows the reader's light or dark setting.
• Link Previews with Open Graph (Journeyman): Open Graph tags in a page's head decide the card a chat app or social site shows when someone pastes your link, with its title, description and picture.
• Links Between Your Own Pages (Apprentice): A relative path gives directions from the page you are on to another page of your own site, into a folder or back up with ../, so your links keep working wherever the site lives.
• Links to Other Sites (Novice): The a element with an href attribute turns words into a link to any page on the web, and good link text tells people where the link goes before they follow it.
• Links Within a Page, Email and Phone Links (Apprentice): An id marks a spot on a page and a link to the hash sign and that id jumps straight to it, while mailto and tel links start an email or a phone call.
• Loading Scripts: defer, async and Modules (Journeyman): Load a script without holding up the page, and choose defer, async or type="module" by what the script needs.
• Loading, Empty and Error States (Journeyman): A page that loads data has four states, loading, success, empty and error, and it should say which one it's in, so people never stare at a blank screen or a page that quietly broke.
• Locating DOM elements (Apprentice): Most searches start at the document, the whole page, where getElementById finds an element by its id, querySelector finds the first match for a CSS selector, and querySelectorAll finds every match.
• Logging Exceptions in C#: an overview (Journeyman): A log is a file of time-stamped lines recording what an app did and what went wrong, so you can find out later. Apps log to plain text files because they're fast, simple, and keep working when everything else fails.
• Look Inside Any Page with Developer Tools (Novice): Open the browser's developer tools on any page, find every CSS rule applied to an element, read what a crossed-out line means, and try a change live before you copy it into your stylesheet.
• Looping Through an Array (Apprentice): Visit every item of an array with a for loop, a for...of loop or forEach, and use a loop to add up or count things, such as a playlist's total play time.
• Losing this, and How Arrow Functions Help (Journeyman): When you hand a method to other code as a callback, it loses the object before the dot and this goes missing, and an arrow function or bind gives it back.
• Making Decisions with if and else (Novice): An if statement runs a block of code only when its condition is true, else gives the other path, and else if chooses between several, so your program can react to what's going on.
• Manipulating the DOM Structure (Apprentice): createElement makes a new element, appendChild puts it inside a parent so it shows on the page, and remove takes an element off the page.
• Many-to-Many (Journeyman): Why two tables can't link many-to-many directly, and how an associative (junction) table between them turns it into two one-to-many relationships.
• map and filter (Apprentice): map turns every item of an array into something new, filter keeps only the items that pass a test, and chained together they turn raw data into exactly the list a screen needs.
• Mapping Data to Models: an overview (Journeyman): Instead of using each row the moment it's read, copy it into a model object, so the program can keep and reuse the data after the reader is gone.
• Mapping Rows to Models (Journeyman): Read each row of a query into a new model object, handle NULL columns, and collect the objects in a List<T>.
• Margin, Padding and Border in Practice (Apprentice): Write padding and margin in one line with the clockwise shorthands, frame a box with border and border-radius, center it with auto margins, and know why two margins can turn into one.
• Media Queries and Breakpoints (Journeyman): A media query applies CSS only when a condition is true, such as a screen at least 40rem wide, a dark theme or a mouse that can hover, and breakpoints go where your content needs them.
• Methods and this (Apprentice): A method is a function that belongs to an object, and inside it the word this means the object before the dot, so one method can work on whichever object calls it.
• Methods on a Class (Apprentice): Write instance methods that use and change an object's state safely, keep its rules inside the class, and know when a method should be static.
• Missing Values: null, undefined, ?. and ?? (Apprentice): Real data has holes, so learn the difference between undefined and null, read a property that might be missing with ?., and give a missing value a default with ?? instead of ||.
• Mobile First: Start Small, Then Add Room (Journeyman): Mobile-first CSS writes the phone layout as the base styles and uses min-width media queries to add columns as the screen grows, which takes less CSS than shrinking a desktop layout down.
• Mobile-First Layouts with Bootstrap (Journeyman): Build pages that work on a phone first, then widen. Bootstrap's row-cols classes, cards, a collapsing navbar and pagination turn a Razor loop into a responsive product grid.
• Model Binding a Form (Journeyman): ASP.NET Core fills an action's parameters, even a whole Product, from the request by matching names. asp-for writes inputs whose names match the model, and ModelState says when a value didn't fit.
• Model Binding and Validation: an overview (Apprentice): Never trust what a form sends. Validate on the server every time, and in the browser too for quick feedback; ASP.NET Core does both from one set of rules on the model.
• Model Review (Journeyman): Write a model class with one property for each column, choosing C# types that match the SQL types, and nullable types for columns that allow NULL.
• Modern Selectors: :is(), :where() and :has() (Journeyman): The :is() and :where() pseudo-classes shorten long selector lists, :where() with no specificity at all, and :has() styles an element by what it contains, so a page can react to a click with no JavaScript.
• Modules: import and export (Apprentice): A module is a file that shares only what it exports; another file imports it by name (a named export) or under a name it picks (the default export), and a package.json in Node or type="module" on a page makes it run.
• Motion That Respects the Reader: prefers-reduced-motion (Journeyman): Motion can make some people dizzy or sick, so a prefers-reduced-motion media query stops the loops and calms the movement for every reader who asks for less, while keeping the motion that helps.
• Multiple Conditions (Apprentice): Combine conditions with && (and), || (or) and ! (not), and group them with parentheses so they mean what you intend.
• MVC Partials with fetch: an overview (Journeyman): An MVC page can reload just one part of itself. JavaScript fetches the new part's HTML from an action that returns a partial view, and swaps it in. That's the MVC way to do what an API and JSON do for a JavaScript-built page.
• Naming Things: BEM and Component Classes (Journeyman): BEM names every class after the component it belongs to, as block__element--modifier, so selectors stay flat and low-scoring and anyone on a team can find, change and reuse a component's styles.
• Network Communication in C#: an overview (Novice): Programs talk to each other by sending messages over a network, even when both run on the same computer. Your C# app already does this with SQL Server; a browser does it with a web app.
• Non-Form Events (Apprentice): Any element on a page can respond to the mouse, such as a click or a press of a mouse button, so even a plain div or table row can react to the user.
• Normal Flow and the display Property (Apprentice): Before you move anything, the browser already lays out every page by the same rules, blocks stacking like bricks and inline boxes flowing like words, and the display and overflow properties let you change how a box takes part.
• Normalization (Journeyman): Normalization splits data into tables so each fact is stored once. Spot the problems repeated data causes, and apply the first three normal forms.
• npm and Packages (Journeyman): npm is an app store for code that comes with Node.js; you'll describe a project in package.json, install packages into node_modules, tell dependencies from devDependencies, and run the project's commands as npm scripts.
• Numbers and Math (Novice): Work out totals, remainders and powers with JavaScript's arithmetic operators, in the order JavaScript does, and round money so it shows as dollars and cents.
• One-to-Many (Apprentice): How a one-to-many relationship links many child rows to one parent row through a foreign key, like a customer and their orders.
• One-to-One (Apprentice): How a one-to-one relationship uses the child table's primary key as its foreign key, and why you would move rarely used data into its own table.
• Ordered and Unordered Lists (Novice): HTML has two everyday lists, an unordered list for items whose order doesn't matter and an ordered list for steps and rankings, with each item in its own list item.
• Organizing Code into Methods (Apprentice): Write your own C# methods with parameters and return values, call them with arguments, and keep each one to a single job.
• OUTER JOIN (Journeyman): LEFT JOIN keeps every row of the first table, matched or not; RIGHT JOIN keeps every row of the second; FULL OUTER JOIN keeps both. Rows with no match get NULL, which also lets you find what's missing.
• Overriding Methods (Journeyman): A base class marks a method virtual so derived classes may change it; a derived class replaces it with override, and can still run the base version with base.MethodName().
• Paragraphs, Line Breaks and Special Characters (Novice): Paragraphs hold a page's words, the browser squeezes extra spaces and line breaks into one space, and character references let you show characters that HTML would otherwise misread.
• Parameters and Mapping to Models (Journeyman): Pass parameters as an anonymous object or a model, with property names that match the @ names; lists become IN lists. Columns map to properties by name, so alias any column that doesn't match.
• Parameters and Return Values (Novice): Parameters let a function take in different values each time you call it, and return hands a result back to the code that called it.
• Passing a Model to a View (Journeyman): An action hands its view a model with View(model); the view names the model's type with @model and reads it through Model. ViewData carries small extras, such as the page title.
• Pictures from CSS: Background Images (Novice): background-image puts a decorative picture behind an element's content, on top of its background-color, and background-repeat, background-size and background-position decide whether it tiles, how big it is and where it sits.
• Placing Items: Lines, Spans and Named Areas (Journeyman): Put any grid item exactly where you want it, by the numbered lines around its cells or by drawing the whole page as named areas, so a featured photo can fill four cells and a sidebar can sit beside the main content.
• Planning Unit Tests (Apprentice): Plan tests from the requirements, as a table of scenarios. Each scenario changes one thing, and the edges (at a limit, just inside it, just past it) find the most bugs.
• Polymorphism in C#: an overview (Apprentice): Polymorphism means "many forms". An object can be seen in more than one way, and code can work with whichever way it needs.
• Polymorphism with Base Classes (Journeyman): A base class variable or list can hold any derived object, and calling a virtual method runs each object's own override. Use is to reach a derived class's own members.
• Polymorphism with Interfaces (Freelancer): An interface can be a variable's, parameter's or list's type, so it can hold objects of unrelated classes that keep the same contract. Depending on an interface, such as IClock, lets a test pass any fake that implements it.
• Popovers and Dialogs (Journeyman): A popover is a note that pops up over the page from a button and closes with Esc or a click outside, and a modal dialog is a box that blocks the page until the visitor closes it, both with no JavaScript.
• Positioning: fixed and sticky (Apprentice): Keep a "chat with us" button on screen with position fixed, keep a header or a table's headings in reach with position sticky, and choose the right one of the five position values for any part of a page.
• Positioning: relative and absolute (Apprentice): Nudge an element from its normal place with position relative, and pin one to a corner of its parent with position absolute, the pattern behind every badge, close button and photo caption on the web.
• POST (Journeyman): POST creates a new item from the JSON in the request body. The DAO inserts it and returns it with its new id, and the action answers 201 Created with CreatedAtAction, which also says where the new item lives. Invalid bodies get 400 automatically.
• Practice: Creating Methods (Apprentice): Replace the football program's copied blocks with one method that takes each team's scores as parameters.
• Practice: The Need for Methods (Novice): Extend a program that prints college football scores by copying and pasting its code, and see the problems copying causes.
• Private Fields, Getters and Setters (Journeyman): A private field keeps an object's data out of reach of other code, a getter lets that code read it, a setter checks a new value before storing it, and static members belong to the class itself.
• Promises: then, catch and finally (Journeyman): A promise is a value that arrives later, like the buzzer a pizza shop hands you, and then, catch and finally say what to do when it works, when it fails, and either way.
• Prototypes: What Classes Are Made Of (Freelancer): Underneath every class, each object is linked to a prototype object that holds the shared methods, and JavaScript finds a property by walking that chain of links until it finds it or runs out.
• Pseudo-Classes: :hover, :focus-visible, :nth-child() and More (Apprentice): Pseudo-classes select elements by their state, such as hovered, focused, checked or disabled, or by their position, such as first, last or every other, and :not() leaves some out.
• Pseudo-Elements: ::before, ::after and ::marker (Apprentice): Pseudo-elements style a part of an element, or add decoration before or after it, such as a play icon, a quote mark, a list's numbers, a text box's placeholder or highlighted text, without changing the HTML.
• PUT (Journeyman): PUT replaces an item with the one in the request body, its id taken from the address. The DAO updates the row and hands back the category as it was saved, and the action answers 200 OK with it, or 404 Not Found when there's no such item.
• Put Your App Online with GitHub Pages (Journeyman): Build your Vite app into a dist folder, upload what's inside it to a GitHub repository through the website, switch on GitHub Pages, and check the live link, so anyone can use your app from an address you can share.
• Put Your Page Online for Free (Novice): Put your page on the web for free with GitHub Pages, uploading its files in the browser with no Git needed, so anyone you send the link to can see it.
• Put Your Site Online for Free (Apprentice): GitHub Pages puts a folder of web pages online for free, at an address anyone can open, and you can do it all by uploading files on github.com.
• Query and QuerySingle (Journeyman): Query<T> reads many rows into objects; QuerySingle, QuerySingleOrDefault, QueryFirst and QueryFirstOrDefault read one; ExecuteScalar<T> reads one value. Pick by how many rows you expect.
• Query Syntax vs Method Syntax (Journeyman): LINQ can also be written in query syntax, from ... where ... orderby ... select, which reads like SQL. The compiler turns it into the same method calls. Method syntax is more common, and some methods, such as Count and First, have no query keyword.
• Querying a Database with ADO.NET: an overview (Journeyman): Every database query from C# takes three steps, connect, run the SQL, read the results, and each step has its own ADO.NET object.
• Querying and Saving with EF Core (Journeyman): Query a DbSet with LINQ, finished by an async method such as ToListAsync, and EF Core runs it as SQL. Add, change or remove entities, then call SaveChangesAsync, and EF Core writes the INSERT, UPDATE or DELETE for you.
• Queues (Journeyman): A Queue<T> hands values back in the order they arrived, first in, first out. Enqueue adds to the back of the line, Dequeue takes from the front, and Peek looks without taking.
• Quotes, Dates, Code and More (Apprentice): HTML has small elements that say what a piece of text is, such as a quote, a date, an abbreviation, a key to press or a price that changed, so browsers, search engines and screen readers can treat it right.
• Razor Syntax and Tag Helpers (Journeyman): Mix C# into HTML with Razor's @ expressions, code blocks, if and foreach, and let tag helpers such as asp-action and asp-route-id write your links.
• Reading a File in C# (Apprentice): Read a text file like a tiny database. Open it, go through it line by line with File.ReadLines or a StreamReader, split each CSV line into an object, and close it with using, all inside a try and catch.
• Reading JSON into Models (Journeyman): GetFromJsonAsync and ReadFromJsonAsync turn an API's JSON into your own model objects, matching names whatever their capitals. PostAsJsonAsync and PutAsJsonAsync send objects as JSON. Check the answer's status, and read the saved item from a 201 or a PUT's 200.
• Reading What People Type (Apprentice): Read what a visitor typed, ticked and chose in a form with value and checked, turn text into numbers, and collect a whole form at once with form.elements or FormData.
• reduce (Journeyman): reduce walks through an array carrying a running total, so a whole list of scores, prices or plays boils down to one answer, such as a total, a count or a best score.
• Registering Services (Journeyman): Register your classes with ASP.NET Core's service container in Program.cs - as singleton, scoped or transient - and it creates them and hands them to every controller that asks in its constructor.
• Relative (Apprentice): Relative positioning moves an element away from its own normal place, and keeps the space it would have used.
• Remembering Data with localStorage (Apprentice): Make a page remember things between visits with localStorage, save whole lists with JSON, start cleanly when nothing is saved yet, and know what sessionStorage and cookies are for and what must never be stored in the browser.
• Repeating with while (Novice): A while loop repeats a block of code for as long as its condition stays true, which fits any job where you can't know in advance how many times it will take, as long as something inside the loop lets it end.
• Request / Response (Apprentice): The browser sends a request and the server sends back one response, and the server does not remember earlier requests.
• Responding to Clicks with addEventListener (Apprentice): An event is something that happens on the page, such as a click, and addEventListener tells the browser which of your functions to run each time it happens.
• Responding to Events: an overview (Apprentice): An event is something that happens on a page, such as a click, and your code responds to it by giving the browser a function to run each time it happens.
• Responsive Design and the Viewport (Apprentice): A responsive page fits whatever screen it's on, and it starts with one line in the head, the viewport line, plus knowing what breaks on a phone and how to see it with device mode.
• Responsive Images with srcset and sizes (Journeyman): Offer the same photo in several widths with srcset, tell the browser how wide it will be shown with sizes, and let each phone, laptop and sharp screen download the file it needs.
• Responsive Images: max-width, object-fit and srcset (Journeyman): Make pictures fit any screen with max-width, aspect-ratio and object-fit in CSS, and send each screen a picture of the right size and crop with srcset, sizes, picture and lazy loading in the HTML.
• Returning ActionResult<T> (Journeyman): ActionResult<T> lets an action return either its data or a status code result, such as NotFound(). Return the item to answer 200 with it, or a helper such as NotFound(), BadRequest() or Conflict() to answer with that status instead.
• Route Values and the Query String (Journeyman): Values reach an action from the route (/products/7) or the query string (?page=2). Choose which with the address's meaning, give optional values defaults, and use [FromRoute] and [FromQuery] to be explicit.
• Scope: Where a Variable Can Be Seen (Apprentice): Scope is the part of a program where a variable can be seen and used, and knowing its three kinds (global, function and block) explains a whole family of "is not defined" errors and values that won't change.
• SDLC (Novice): The five phases of the software development lifecycle (requirements, design, code, test, deploy), and how Agile and test-driven development change their order.
• Securing a Web API with JWT Bearer (Journeyman): Give the categories API users. Register and login endpoints check passwords with PasswordHasher and hand back a signed JSON Web Token; AddJwtBearer checks the token on every request, and [Authorize] with roles decides who may add, change and delete. The signing key lives in user secrets.
• Seeding and Importing Data (Journeyman): A new database starts empty. Seed scripts fill in the data every copy needs, written so they can run again safely. Imports bring in data from elsewhere, such as a supplier's CSV file. Check every row, add the good ones in one transaction, and report the rest by line number.
• SELECT in T-SQL: an overview (Novice): A SELECT statement asks the database a question and gets back a table of answers; T-SQL is SQL Server's version of SQL.
• SELECT Query Structure (Novice): A SELECT statement is built from clauses that always appear in the same order; this chapter uses SELECT, FROM, WHERE and ORDER BY.
• Semantic HTML (Apprentice): Semantic elements such as strong, nav, main and footer say what their content means, so the HTML describes the content and CSS handles the formatting.
• Sending Data with fetch (Journeyman): To send data to an API, give fetch a second argument with method POST, a Content-Type header that says the body is JSON, and a body made with JSON.stringify; and know that CORS, the API's rule about which sites may call it, decides whether a page can call it at all.
• Session State (Journeyman): Session state keeps small values on the server for one visitor between requests, such as recently viewed products, found through a session cookie. Turn it on, then SetString, GetString and SetInt32.
• Setup: Install Git, Git Bash, and connect to GitHub (Novice): Install Git for Windows, make Git Bash your terminal, create a GitHub account, and tell Git who you are.
• Setup: Install Node.js (Novice): Install the long-term support version of Node.js and npm, which you will use for JavaScript and front-end frameworks.
• Setup: Install SQL Server 2025 and SSMS (Novice): Install SQL Server 2025 Developer and SQL Server Management Studio 22, and connect to your server with Windows authentication.
• Setup: Install the .NET 10 SDK (Novice): Install the .NET 10 SDK with winget, and check from Git Bash that the dotnet command works.
• Setup: Install Visual Studio 2026 (Novice): Install Visual Studio 2026 Community with the two workloads this course uses, and open it for the first time.
• Setup: Install VS Code (Novice): Install Visual Studio Code with winget, then open it, a file, or a whole folder from the terminal.
• Setup: Verify your setup (Novice): Check every tool, then write a C# program, commit it with Git, push it to GitHub, and run a query in SQL Server.
• Setup: VS Code, a Browser and Node.js (Novice): Install VS Code with Live Server, a current browser and Node.js on Windows 11 or macOS, then open The Daily Grind's menu page and watch it reload every time you save.
• Setup: VS Code, a Browser and Node.js (Novice): Install VS Code, the Live Server extension and Node.js on Windows 11 or macOS, check them from VS Code's terminal, and open your first page in a browser that reloads when you save.
• Setup: VS Code, a Browser and Node.js (Novice): Install VS Code, Node.js and the Live Preview extension on Windows 11 or macOS, make a folder for the course, and check from VS Code's terminal that Node.js is ready.
• Setup: Windows Terminal and winget (Novice): Check that Windows Terminal and winget are ready, so you can install every other bootcamp tool.
• Simple SELECT Query (Novice): SELECT * FROM a table returns every column and every row, the quickest way to see what a table holds.
• Software Interfaces (Apprentice): A software interface is a contract between pieces of code. It lists what a class can do, never how, so code can use any class that keeps the contract. .NET is full of them, such as IEnumerable<T>.
• Solving Multiple Inheritance (Journeyman): A C# class can have only one base class, which avoids the confusion of inheriting two versions of the same method. Instead, it can implement as many interfaces as it needs, since an interface brings a contract, not code.
• Sorting Arrays (Apprentice): sort puts an array in order, but it compares items as text unless you give it a compare function, and it changes the array itself, so toSorted is the way to get a sorted copy and keep the original.
• Specificity: Scoring a Selector (Apprentice): Specificity is the score the browser gives every selector, in three columns, and comparing two scores column by column tells you which rule wins before you refresh.
• Specifying Columns (Novice): List the columns you want, in the order you want them, and rename them in the result with AS.
• Spread and Rest (Apprentice): Assigning an object to a new variable doesn't copy it, so this lesson shows how spread makes real copies and merges, and how rest gathers any number of values into one.
• SQL Server Management Studio (Novice): Create the course's sample databases in SSMS, find your way around Object Explorer, and run your first queries.
• Stacking: z-index and What Sits on Top (Journeyman): When boxes overlap, the browser stacks them like papers on a desk, and z-index, positioning and stacking contexts decide which one ends up on top, including why z-index 9999 sometimes still loses.
• Stacks (Journeyman): A Stack<T> hands values back newest first, last in, first out. Push adds to the top, Pop takes from the top, and Peek looks without taking. Undo is the classic use.
• Static (Apprentice): Static is the default position, where elements sit in the normal flow of the page and top and left don't move them.
• Static vs Dynamic Typing (Novice): In C#, a variable's type is fixed when it's declared. In JavaScript, variables have no type; values do, and a variable can hold any of them. Declare with const by default, let when the value changes, and never var.
• Static Websites (Apprentice): A static website is built from hand-written HTML files, so the path in a page's URL is the path to that file on the server.
• Sticky (Apprentice): A sticky element scrolls with the page until it reaches its top offset, then stays put until its parent scrolls away.
• String Interpolation (Novice): Build strings by putting values straight into the text with quot;...{value}...", and format numbers, money and columns as you go.
• String Methods (Apprentice): String methods such as trim, toLowerCase, slice, replaceAll, split, join and padStart tidy and reshape text, and each one hands back a new string while the original stays as it was.
• Strings and Template Literals (Novice): Store text in strings, build messages from your values with template literals, and tidy and search text with length, trim, toUpperCase and includes.
• Structure Elements: header, nav, main, section and footer (Novice): Structure elements such as header, nav, main and footer label the big parts of a page by what they are, which helps people using screen readers, search engines, and you when you style each part.
• Structured Data with JSON-LD (Freelancer): A JSON-LD block in a page's head describes a business to search engines as labeled facts (its name, address, location and hours), using the shared schema.org vocabulary.
• Subgrid: Lining Up Cards (Freelancer): With grid-template-rows: subgrid, cards in a row share their parent grid's rows, so every card's title, text and button line up across the row however long each card's text is.
• Summary (Journeyman): Abstraction is a goal; the abstract keyword is one C# tool for reaching it. Choose an ordinary, virtual or abstract method by whether derived classes keep, may change or must write it.
• Summary (Apprentice): Compare with === and !==, never == and !=, which convert types first. In a condition, false, 0, an empty string, null, undefined and NaN count as false, and everything else as true. A cheat sheet of C# and its JavaScript equivalents.
• Switch (Apprentice): Pick one of many blocks of code by the value of a single variable with C#'s switch statement, including shared cases and a default.
• switch and the Conditional Operator (Apprentice): A switch statement matches one value against a list of exact choices, and the conditional operator ? : picks one of two values in a single line, so a long chain of else ifs can say what it means.
• Switch Expressions and the Conditional Operator (Apprentice): Choose a value, rather than run a block, with C#'s conditional operator for two choices and a switch expression for many.
• Table Headers, Sections and Spanning Cells (Journeyman): Bigger tables group their rows into a head, a body and a foot, tell each header cell what it labels with scope, and merge cells across columns or rows with colspan and rowspan.
• Tables for Data (Apprentice): A table holds data you read both across a row and down a column, built from rows of header and data cells with a caption that says what the table shows, and it's never used to lay out a page.
• Tasks, async and await (Journeyman): A Task is work that finishes later. An async method can await a task, which frees its thread while it waits for a database or the network, so a web server can keep serving other requests. Await every async call, and name async methods with Async.
• Templates, Slots and Custom Elements (Freelancer): Write a layout once with a template and named slots, give a card its own layout with declarative shadow DOM and no JavaScript, and use custom elements such as a star rating from a ready-made script.
• Test-Driven Development (Apprentice): In test-driven development you write a failing test first, then just enough code to pass it, then tidy up. Follow three short cycles that build a shipping calculator.
• Testing a Page for Accessibility (Journeyman): A repeatable accessibility check takes about fifteen minutes, keyboard only, a screen reader, Lighthouse and axe, 200% zoom and captions, and it finds the barriers a person meets and a tool misses.
• Testing a Page with jsdom (Freelancer): jsdom is a browser without a screen that runs inside your tests, so Vitest can build a little page, click its buttons with dispatchEvent and check what the page says, in a moment and without opening a browser.
• Testing Edge Cases, Errors and Async Code (Freelancer): Bugs hide at the limits, in the errors and in the code that waits, so this lesson tests all three with Vitest, using toThrow, resolves and rejects, and fake timers that skip ahead in time.
• Text Inputs and Labels (Apprentice): A text input is a one-line box with a name for the data it sends, and a label tied to it by for and id tells everyone, screen readers included, what the box is for.
• The Back End (Novice): The back end is the code that runs on a server, keeping the rules of the business and answering the front end through an API, and in this course you'll write it in C# with ASP.NET Core.
• The Box Model: Content, Padding, Border and Margin (Novice): Every element on a page is a box with four layers, content, padding, border and margin, and knowing them is how you control every bit of space on a page.
• The Cascade: How the Browser Picks a Winner (Apprentice): When two CSS rules set the same property on the same element, the browser runs the same tie-breaker contest every time, and knowing its rounds tells you why a style won or lost.
• The CSS You Need for JavaScript (Novice): Read a CSS rule's selector, properties and values, pick elements by tag name, class, id or what they're inside, and see how a class added or removed by JavaScript changes the way an element looks.
• The Database (Novice): The database is where an app keeps its data so it can be found again in an instant, and in this course you'll design SQL Server databases and question them in T-SQL.
• The Event Loop, in Pictures (Journeyman): The call stack runs one function at a time, finished timers wait their turn in the task queue, and the event loop moves the next one onto the stack only when the stack is empty, which is why setTimeout(fn, 0) runs after the code around it.
• The Event Object (Apprentice): Every listener is handed an event object that says what just happened, so one function can tell which button was clicked, which element it landed on, and which key was pressed.
• The Front End (Novice): The front end is the part of an app people see and touch, built with HTML, CSS and JavaScript and, in this course, Angular, and a front-end developer makes it clear, fast and enjoyable on every screen.
• The Grid System (Apprentice): Lay out a page in Bootstrap's 12-column grid of containers, rows and columns, and make the layout change at each screen size with breakpoints.
• The HTML You Need for JavaScript (Novice): Read a web page the way JavaScript sees it, as elements with tags, attributes and content nested inside each other, with an id or a class on the ones your code needs to find.
• The JavaScript Runtime (Novice): What a JavaScript runtime is, and how the browser loads a page's HTML, CSS and JavaScript and runs the script.
• The MSTest Framework (Apprentice): MSTest is Microsoft's testing framework for .NET. A test runner finds and runs your tests; a test class holds the tests for one class, in a test project of its own.
• The MVC Pattern in ASP.NET Core (Apprentice): MVC splits a web app into models that carry data, views that turn it into HTML, and controllers that answer requests. Follow one request through all three.
• The Page Skeleton (Novice): Every HTML page starts from the same skeleton, the doctype, an html element with a head and a body, and knowing what each line does saves you from strange bugs.
• The Page Skeleton, and Three Places CSS Can Go (Novice): Every web page shares the same skeleton, a head for information about the page and a body for what people see, and CSS can go in three places in it, of which a linked stylesheet is the one real sites use.
• The Picture Element (Journeyman): Use picture and source to offer smaller AVIF and WebP files with a JPEG backup, and to show phones a tighter crop of a photo than big screens get.
• The Power of CSS (Novice): CSS Zen Garden shows one HTML page styled many completely different ways, proof of how much CSS alone can change.
• The Request / Response Pattern (Journeyman): A web request and its response are simple text messages, each made of a header and an optional body.
• Throwing Your Own Errors (Journeyman): When a function gets a value it can't use, throw new Error with a message that says what was wrong, make your own error class with extends Error for the problems your program knows about, and return a value instead when there's no mistake to report.
• Timers: setTimeout and setInterval (Apprentice): setTimeout runs a function once after a delay, setInterval runs it again and again, and clearTimeout and clearInterval cancel them with the ID each timer hands back.
• Titles, Descriptions and Search Results (Apprentice): A few lines in a page's head decide what its search result says, so write a title and a description that tell a searcher this is the page they want.
• TOP and ORDER BY (Novice): Sort a query's results with ORDER BY, ascending or descending, by one column or several, and keep only the first rows with TOP.
• Transactions (Apprentice): Group changes into a transaction so they all happen or none do, and use ROLLBACK as a safety net while you work.
• Transforms: Move, Turn and Grow (Apprentice): Transforms slide, turn and resize an element with translate, rotate and scale without moving anything around it, which makes them the tool for a button that lifts, a card that tilts or a badge that grows.
• Transitions: Smooth Changes (Apprentice): A transition makes a change in CSS happen smoothly over a short time instead of in one jump, so a button that changes color on hover or focus eases into its new look.
• Type That Reads Well: Scale, Line Length and Pairing (Journeyman): Text reads well when its sizes come from a type scale in rem, its lines hold about 45 to 75 characters, its line height suits body text and headings, and the page uses two fonts at most.
• Type, Class and ID Selectors (Novice): A selector tells the browser which elements a rule styles (every element of one kind, every element with a class, or the one element with an id), and commas let one rule style several selections at once.
• Types and Converting Between Them (Apprentice): Tell numbers, strings and booleans apart with typeof, turn text into numbers and back with Number() and String(), and know why '5' + 3 is '53' and where NaN comes from.
• Types of Filters (Apprentice): Filter numbers and dates with comparison operators, text with LIKE patterns, lists with IN, ranges with BETWEEN, and missing values with IS NULL.
• Types of Sub-Queries (Journeyman): A sub-query is a query inside another query, in parentheses. An uncorrelated one runs once on its own; a correlated one uses the outer query's row and runs once per row.
• Understanding the String Class (Novice): A C# string is a read-only sequence of characters; read them by index, write special characters with escape sequences, and understand why strings never change.
• Unit Testing: an overview (Novice): What a unit test is, and why small classes with clear responsibilities can be tested on their own.
• Units: px, rem, em, % and Viewport Units (Apprentice): Every size in CSS needs a unit, and choosing the right one, px, rem, em, %, vw or vh, decides whether your page grows with the reader's text, fits its space and stays readable.
• Up Next: How JavaScript Really Works (Apprentice): See how much real data you can handle after Module 2, meet the My Music Wrapped project where you'll show it, and get a first look at the ideas Module 3 explains, starting with a function that remembers.
• Up Next: JavaScript in the Browser (Apprentice): Module 3 gave you the tools for bigger programs (closures, classes, your own errors, the debugger and modules); this lesson shows which one fits which job, the Virtual Pet project that uses them all, and how Module 4 puts your code in charge of a web page.
• Up Next: Waiting for Data (Apprentice): See how much of a web page you can now control, meet the Photo Gallery project where you'll show it, and find out why a page freezes when code waits the wrong way, and what Module 5's timers, promises and fetch change.
• Up Next: Working Like a Professional (Journeyman): See what your code can wait for after Module 5, meet the Trivia Night project where you'll build a timed game with live questions, and get a first look at Module 6, starting with a test that catches a bug before a player does.
• Up Next: Working with Data (Novice): See how much you can do after Module 1, meet the Rock, Paper, Scissors game where you'll show it, and get a first look at the lists and records Module 2 teaches.
• Updating Data (Apprentice): Change existing rows with UPDATE ... SET, always limited by a WHERE that you've tested first with a SELECT.
• Useful String Methods (Apprentice): Find text with IndexOf, LastIndexOf, Contains, StartsWith and EndsWith, and cut and reshape it with Substring, Split, ToUpper, ToLower, Trim and Replace.
• User Interfaces (Novice): A smart home's thermostat, wall panel, phone app and voice assistant show how many user interfaces can control the same software.
• User-Defined Functions in T-SQL (Journeyman): Write your own functions. A scalar function returns one value and works inside any query; a table-valued function returns rows and works like a table that takes parameters.
• Using File Explorer (Novice): Navigate Windows folders, show file extensions and hidden files, and read a folder's path two ways.
• Using Multiple Condition Filters (Apprentice): Combine conditions in a WHERE clause with AND, OR and NOT, and use parentheses so they're checked the way you mean.
• Using the fetch API (Journeyman): Catch the pager's clicks with one listener on the pager, cancel them with preventDefault, fetch the partial's HTML with fetch and response.text, and put it in the page with innerHTML. The links keep working when JavaScript doesn't run.
• Utility Classes (Apprentice): Adjust spacing, color, text, borders and flex layout with Bootstrap's small, single-purpose utility classes, without writing CSS.
• Utility Classes and Utility-First CSS (Journeyman): A utility class does one small job, such as .text-center or .mt-4, and a few of them in a utilities layer handle one-off tweaks without new rules, while utility-first frameworks build whole pages from thousands of them.
• Validating Your Page (Apprentice): The W3C Nu HTML Checker reads your page against HTML's rules and lists every mistake with its line number, so you can find and fix what the browser quietly covered up.
• Variables with let and const (Novice): A variable gives a value a name so your program can remember it, and let or const says whether that value is allowed to change.
• Video and Audio (Apprentice): The video and audio elements put the browser's own player on your page, with play, pause, volume and full screen built in, for any video or sound file you give them.
• Views in T-SQL (Journeyman): A view is a saved query with a name. Query it like a table, and the long join inside is written once. Create it with CREATE OR ALTER VIEW, in a batch of its own.
• Visual Studio (Novice): Find your way around Visual Studio 2026, from solutions and projects to running a program and stepping through it with the debugger.
• Waiting for Several Things at Once (Freelancer): Promise.all, Promise.allSettled, Promise.race and Promise.any start several slow jobs together and wait for all of them, every answer, the first to finish or the first success.
• Web APIs with Controllers: an overview (Apprentice): REST is the common way to design a web API. Each kind of data is a resource with its own address, and the HTTP method says what to do with it. GET, POST, PUT and DELETE match SELECT, INSERT, UPDATE and DELETE, each with its usual status code.
• Web Fonts: Using Any Font You Like (Apprentice): A web font is a font file the browser downloads with your page, loaded with a Google Fonts link or your own @font-face rule, so every visitor sees the font you chose even when their device doesn't have it.
• What a Screen Reader Hears (Journeyman): A screen reader announces each part of a page by its role, its name and its state, all read from your HTML, and the developer tools show you exactly what it will say.
• What a Web API Is (Apprentice): A web API is a server that answers requests sent to its addresses, and every request and answer has the same parts: a URL with a path and query string, a method, a status code and, usually, JSON.
• What Arrays Solve (Apprentice): A quick review of what arrays do well, fast access by position, one name for a group, and easy looping, before meeting their limits.
• What is a Constructor? (Apprentice): A constructor runs when an object is created and gives it the starting values it needs; use this to tell a field from a parameter of the same name.
• What is a Database? (Novice): A database is an organized place where an application stores its information so it can manage it and find it again quickly.
• What is a Dependency (Apprentice): A dependency is an object a class needs to do its job. When a class creates its own dependencies with new, it's wired to them for good, and hard to test.
• What is a Design Pattern (Apprentice): A design pattern is a proven, named answer to a problem that keeps coming up in software design. Patterns are grouped as creational, structural and behavioral, and you've already used several without knowing their names: Singleton, Iterator, Observer, Dependency Injection and the DAO.
• What is a Development Stack? (Novice): A development stack is the set of tools a team picks for each layer of an app, and this lesson compares several well-known stacks before naming the one you'll learn in this bootcamp.
• What is a Full Stack Developer? (Novice): A full-stack developer can build a feature from the screen people tap, through the code on the server, down to the data it keeps, and this bootcamp teaches you to do exactly that with C#.
• What Is a Function (Novice): A function is a named set of steps you write once and run whenever you need it, by calling its name.
• What is a Variable (Novice): A variable is a named place where your program remembers a value, so it can use it again later.
• What Is an Array (Novice): An array keeps a whole list of values, such as the songs on a road-trip playlist, under one name, and you reach each one by its position, counting from 0.
• What Is an Object (Novice): An object keeps everything about one thing together under labels, like a form with labeled boxes, so you can read, change and list a pet's name, age and more by name.
• What is an Object? (Novice): Every object has a responsibility; finding the objects in a problem, and the job of each, is the first step in designing a program.
• What is an ORM? (Journeyman): An ORM (object-relational mapper) moves data between C# objects and database tables. Dapper is a micro-ORM, where you write the SQL and it fills the objects. Entity Framework Core is a full ORM, where you write LINQ and it writes the SQL, and also tracks and saves your changes.
• What is an RDBMS (Novice): A relational database management system (RDBMS) such as SQL Server stores data in tables of rows and columns, and links the tables with primary and foreign keys.
• What is ASP.NET Core (Novice): ASP.NET Core is .NET's framework for the web. It listens for requests, runs your C# to answer each one, and sends back a page built for that request.
• What is Bootstrap? (Novice): Bootstrap is a free CSS framework of ready-made styles and components; add it to a page with two lines from a CDN and start using its classes.
• What is LINQ? (Journeyman): LINQ is ETL for the data in your program. Start from any collection, chain methods such as Where, OrderBy and Select that each transform the items, and finish with ToList, Count or First. A query runs when its results are used.
• What Semantic HTML Means (Apprentice): Semantic elements such as strong, nav, main and footer say what their content is, so the HTML describes the content and CSS handles how it looks.
• What You Can Build with CSS (Novice): CSS is what turns a plain page of words into a site people enjoy using, and this course takes you from your first rule to seven projects you can put online and show off.
• What You Can Build with HTML (Novice): HTML is underneath every website, many email newsletters and e-books, and even apps on your TV and computer; this course takes you from your first page to a website for a local business.
• What You Can Build with JavaScript (Novice): JavaScript runs in every web browser and, with Node.js, on computers and servers too, so it powers games, maps, chat apps, browser extensions and the six projects you'll build in this course.
• When fetch Fails (Journeyman): fetch rejects only when no answer arrives at all, so check response.ok for answers like 404 and 500, catch network errors and timeouts (AbortSignal.timeout) with try/catch, and turn each one into a message a person understands.
• WHERE in T-SQL: an overview (Novice): A WHERE clause keeps only the rows that match a condition, such as the customers in one country.
• Where to Go Next (Journeyman): A look back at what you can now build with JavaScript, the two projects that put it all together (the Typing Speed Game and an app of your own), and how to choose your next step among TypeScript, a framework and Node.js on the server.
• Where to Use Sub-Queries (Journeyman): A sub-query can stand in for a value, a list or a table. Use it in WHERE with =, IN, NOT IN or EXISTS, as a column in the SELECT, or as a table in the FROM.
• While Loop (Novice): Repeat a block of code for as long as a condition stays true with C#'s while loop, and make sure the loop can end.
• Who Accessibility Helps (Apprentice): Accessibility means people can use your page however they browse, and it helps far more people than you might think, from a screen-reader user to someone holding a baby in one arm.
• Why Code Can't Stop and Wait (Apprentice): JavaScript runs one line at a time on one thread, so code that stands and waits freezes the whole page; asynchronous code starts a wait, carries on, and finishes the job later.
• Why Dapper (Journeyman): Dapper is a small library that keeps your SQL but writes the ADO.NET code around it for you - opening the connection, adding parameters, and turning rows into objects.
• Why Do We Need Data Storage? (Novice): Applications keep their data in a database to have it in one place, keep it accurate and secure, manage it quickly, and grow as the data grows.
• Why the Server Checks Again (Journeyman): The browser's checks help people fill in a form, but anyone can switch them off, so the server that receives the answers must check every one again.
• Will It Work Everywhere? Browser Support and @supports (Journeyman): Check whether a CSS feature works in your readers' browsers with Baseline and caniuse.com, then use it safely with fallbacks the cascade gives you for free, @supports, and progressive enhancement.
• Windows Setup for C#: an overview (Novice): Meet the Windows tools a C# developer uses every day, and the order in which you will install them.
• Windows Terminal and Git Bash (Novice): A terminal is the window you type in and a shell is the program that runs your commands, and the bootcamp uses the Git Bash shell inside Windows Terminal.
• winget (Novice): winget, the Windows Package Manager, installs and updates software with one typed command.
• Working with Elements: an overview (Apprentice): Once you've found an element, JavaScript can read it and change it, from its text and CSS classes to which elements are on the page at all.
• Working with Files in C#: an overview (Apprentice): A program finds a file by its path. An absolute path starts at the drive; a relative path starts at the program's current folder, which in Visual Studio is the build folder, so data files are copied there.
• Working with Functions (Apprentice): A JavaScript function is declared with the function keyword, and has no return type and no parameter types. A missing argument is undefined, an extra one is ignored, and a function with no return gives undefined. Functions are values, too.
• Working with List<T> (Apprentice): Add, insert, read, find, remove, sort and loop through the items of a C# List<T>.
• Working with Objects in C#: an overview (Novice): Object-oriented programming models software on the things around us, objects that each know some facts and do some jobs.
• Working with the Terminal (Windows): an overview (Novice): Git Bash shows the same folders as File Explorer, as text you type, starting from your home folder (~) and the ls command.
• Working with User Input (Journeyman): Use what a user types in a query safely with SqlCommand parameters, and see why building SQL from their text opens the door to SQL injection.
• Writing a File: StreamWriter's Defaults (Journeyman): A StreamWriter writes text to a file the way Console writes to the screen. By default it creates the file, or replaces one that's already there. Close it with using, so everything written reaches the disk.
• Writing Log Entries (Journeyman): Create one LogService for errors and one for ordinary events, each with its own folder. In a catch block, log the exception's type and message with the file or record involved, and tell the user something helpful.
• Writing Tests (Apprentice): Name each test for its scenario, write it in three parts (Arrange, Act, Assert), check results with MSTest's Assert methods, and run one test for many inputs with DataRow.
• Writing the Class in C# (Apprentice): Turn a class design into C# with private fields and public methods, then create objects with new and call their methods.
• Your First C# Program (Novice): Write and run your first C# program, first as a single file with dotnet run, then as a project in the terminal and in Visual Studio.
• Your First CSS Rule (Novice): Write your first CSS rules on a coffee shop's menu, learn the name of every part (selector, declaration, property and value), and see what the browser does with a typo.
• Your First JavaScript Program (Novice): Write a program that prints a coffee shop's specials with console.log, run it with node, leave notes in it with comments, and read the error message when something goes wrong.
• Your First Minimal API (Apprentice): A minimal API maps each address and method straight to a lambda in Program.cs, with MapGet, MapPost, MapPut and MapDelete. The lambda's parameters come from the route and the body, and Results.NotFound(), Results.Created() and friends choose the status code.
• Your First Tests with Vitest (Journeyman): A unit test is a few lines of code that check one piece of your code and shout when it breaks, and Vitest's describe, it and expect let you write one, run it and read the result.
• Your Road Through This Course (Novice): The bootcamp's four modules build the stack one layer at a time, from your first line of C# to a secure Angular app talking to your own web API and database, online in Azure.