HTC Homework 💻

Year 1, Week #4

bash: ~ shortcut for the home directory (or just cd)

bash: tab completion for faster shelling

bash: history (concept and command)

bash: echo command - send stuff to standard out

bash: redirecting stdandard out to files with > and >>

bash: pipes | - send standard out of a program to standard in of another

bash: sending signals to running processes <Ctrl-D> and <Ctrl-C>

Year 1, Week #5

bash: shell expansions with *, ?, and [...]

network protocols TCP and UDP

Year 1, Week #6

bash: variadic commands take any number of arguments mkdir foo bar baz

bash: concatenating (joining) files with cat command

bash: read fixed number of lines from file beginning with head, (head -n 50 <file>)

bash: read fixed number of lines from file end with tail, (tail -n 50 <file>)

bash: follow stuff added to files with tail --follow <file> or tail -f <file>

Year 1, Week #7

bash: cp command for copying files

bash: sudo for running a command as super user

http protocol basics - request, response, status codes, headers

Year 1, Week #8

bash: preferences and customization of your shell with ~/.bashrc

bash: vi mode for editing text while typing in shell

bash: variables NAME=Jared, echo Hello $JARED

bash: get last command exit code with $?

bash: writing bash scripts

sed: simple stream editor for operating line-by-line on text in unix-y environments

regex: introduction to regex

regex: basic meta-characters - ., ^, $, *, _, ?

Year 1, Week #9

regex: alternation with | char - /(goat|llama)pack/

regex: backreferences - replacing groups captured with parenthases

regex: flags - g (global - match more than one), i (case insensitive)

the concept of types in computer programming - booleans, strings, numbers, etc.

Year 1, Week #10

regex: character class, e.g. [aeioy] matches any vowel

regex: character class ranges like [A-Z] and [0-9]

html: introduction to the HTML markup "language"

html: tags and attributes

html: basic tags - <p>, <h1>-<h6>

html: boilerplate for a well-formed html document

html: document-structure tags: <!DOCTYPE html>, <html>, <head>, and <body>

Year 1, Week #11

web servers: basics of requests, response, nginx, and web root

urls: uniform resource locators, scheme (http or https)

urls: registerable domains (, top-level domains (.com), and subdomains

vim: d delete, c change, y yank (copy), v visual mode (select)

vim: text objects - w word, p paragraph, t html tag

vim: motions i inner, a around

vim: combining operators caw, dit, vip, etc.

regex: \d to match a digit

regex: matching a specific number of something with {x} or {x,y} - {3}, {3,5}

html: list tags <ul> unordered list, <ol> ordered list, <li> list item

Year 1, Week #12

vim: moving up to and onto characters with t<char> and f<char>

vim: searching for and moving to found patterns with /<search>

vim: move by paragraph with { and }

vim: repeat last edit with .

regex: \w to match word-like characters

regex: \b to match a word boundary

regex: ? after quantifier (* or +) to make it lazy: /[abc]*?/

html: <div> (generic block-level), <span> (generic inline), and <table> elements

html: styling elements with the style attribute <p style="color: red">

Year 1, Week #13

vim: C and D for operating to the end of the current line

regex: \s to match whitespace, \S to match non-whitespace

regex: \D to match non digits

regex: \W to match non wordlike characters

html: id and class attributes <p id="foo" class="bar">

css: introduction to CSS, including rule-sets, declarations, and <style> tags

js: introduction to javascript

js: basic primitive types and variables

js: executing node files with node <filename>

js: REPLs (Read Evaluate Print Loop) - in browser and node

Year 1, Week #14

vim: splitting the vim window with split <filename> and vsplit

css: display inline-block

css: float and clear

css: external stylesheets - <link href="./main.css" rel="stylesheet">

unix: processes - pid (process id) and ppid (parent process id)

js: intro to arrays and bracket notation

js: intro to objects and dot notation

js: introduction to functions

node: process global variable process.env, process.stdout, etc

node: accessing command-line (shell) arguments with process.argv

Year 1, Week #15

js: functions are first class values in js

js: pure functions vs side-effects

js: scope

css: position property - static, relative, absolute

css: absolutely posititioning elements with top/left/right/bottom

css: stacking elements with z-index

Year 1, Week #16

vim: handy stuff - ea, bi, cc, gk, gj

bash: cd **-** - go back to last directory

bash: chmod command for setting permissions (aka access control list)

js: setTimeout(<fn>, <delay-ms>) run a function after a delay

web js: <script> tags

web js: document object model (DOM) intro

web js: get nodes from DOM with document.querySeletor(<selector>)

web js: handle simple click events by attaching functions to element.onclick

Year 1, Week #17

no new stuff this week, only review

Year 1, Week #18

vim: marks (local and global) - m<letter> and <backtick><letter>

js: control flow with if / else if / else

js: comparing values with ===, <, >, <=, >=`

web js: dom scripting basics

web js: creating elements with document.createElement(<tag-name>)

web js: inserting nodes with node.appendChile(<element>)

web js: setting node attribues with node.setAttribute(<attr>, <val>)

Year 1, Week #19

js: OR and AND logical operators: ||, &&

js: concept of closure - functions that remember their "birth" scope

js: c-style for loop for (let i = 0, i < x; i++) {...}

js dom-scripting: listening for events with <element>.addEventListener()

Year 1, Week #20

unix/bash: $PATH variable - list of directories to find executable programs

unix/bash: shebang #!/usr/local/bin/node

js: regular expresssions in javascript - str.match() and str.replace()

js (browsers): prompt function for clunkily getting user-input

css: vw and vh - viewport width and viewport height units

css: background images

css: bg image properties: background-image, background-repeat, background-position

css: bg image properties (cont): background-size, background-attachment

Year 1, Week #21

css: deep dive on flexbox

flexbox: flex-direction, justify-content, align-items, align-self

flexbox: flex-grow, flex-basis, order, flex-wrap, align-content

Year 1, Week #22

css: css specificity

css: child combinator - .foo > p { color: red; }

css: media queries - @media(min-width: 768px) {...}

js: array length property [1,3,5].length // <- 3

Year 1, Week #23

js: function expressions: let sayHi = () => console.log('hi');

js: function declarations: function sayHi() { console.log('hi'); }

js: objects - methods vs properties

js: string methods: str.toLowerCase(), str.includes(), str.split()

js: more string methods: str.startsWith(), str.endsWith(),

js: array methods: arr.push(), arr.pop(), arr.join(), arr.includes()

Js: more array methods:, arr.filter(), arr.forEach(), arr.slice()

Year 1, Week #24

vim: <Ctrl-o> and <Ctrl-i> to go back/forth between jumps

js: Array.concat() method for joining two or more arrays

html: forms and form elements

html: form tags: <form>, <input />, <textarea />, <select>

html: form input types: checkbox, number, radio

html: form placeholders, form element name attribute

submitting forms to web servers with http method GET and POST

Year 1, Week #25

js: Array.reduce()

js: primitive vs. non-primitive types

js: function arguments - "pass by reference" and "pass by value"

js: old-style code sharing in the browser with window.NAMESPACE

node: commonjs code sharing with require() and module.exports

node: __dirname and __filename & other vars passed to node files

node: require() resolution strategy

Year 1, Week #26

introduction to git

git: basic commands: git init, git status, git add, git commit

git: basic commands: git diff, git branch, git checkout, git log

Year 1, Week #27

git: understanding HEAD

git: git merge <other-branch>

git: fast-forward merges, and merge commits

git: resolving git conflicts

git: git log options - --all, --oneline, --graph

git: shorcuts - git commit -am, `git checkout -b <new-branch>

css: :hover pseudo-class for styling hovered elements

Year 1, Week #28

vim: visual block mode

vim: o and gv

git: get checkout -- <file>

git: get reset HEAD <file>

git: get reset [--hard] <sha>

node: require() resolution - bare strings, core modules, and npm modules

node: core fs module for filesystem work

Year 1, Week #29

vim: incrementing and decrementing numbers with <Ctrl-x>, <Ctrl-a>

js: var, let, and const

git: all about git remotes

git: git clone <remote>, git fetch <remote>, git pull <remote>

git: git remote add <nickname> <url>

git: git remote rename <old-name> <new-name>

git: git push <remote> <branch> [--force]

css: margin and padding shorthand margin: 5px 0 3px 1px;

css: combining selectors with ,: .foo, span { color: red; }

css: rgb(), rgba(), and opacity: <num>;

css: psuedo-elements ::before and ::after

Year 1, Week #30

JSON format

git: checkout branch from remote repo: git checkout -b foo origin/foo

git: ignoring files with .gitignore

git: git stash command

git: git rebase <other-branch> - non-interactive rebase

git: git rebase -i <sha> - interactive rebase

js: anonymous functions

js: arrow functions const add = (x, y) => x + y;

Year 1, Week #31

ssh and ssh keys overview

the ~/.ssh folder

default ssh keys: ~/.ssh/id_rsa and ~/.ssh/

ssh authorized_keys, known_hosts, and config file

hosted git websites: GitHub and GitLab

Pull requests (PR) / Merge requests (MR)

Year 1, Week #32

shell/bash reverse history search - <Ctrl+r>

shell/bash history substitution - ^<find>^<replace>, e.g. ^vim^cat

introduction to VSCODE

vscode keyboard shortcuts

Year 1, Week #33

semantic html tags: <header>, <nav>, <footer>

more semantic html tags: <section>, <main>, <article>, <aside>

web servers: request, response, client, server

node: http core module for writing web servers (the hard way)

node: express npm module for writing web servers (easier)

Year 1, Week #34

npm - npm init, npm install, package.json, package-lock.json

npm scripts - npm run start, npm run dev, etc

js: classes and this: class Person { constructor() {} }

js: class inheritance with the extend keyword: class Foo extends Bar {}

js: unit testing with jest - expect(...), it(...), test(...)

Year 1, Week #35

js: template literals

js: destructuring - let { name } = person; let [, title] = book;

js: sorting arrays - [3, 20, 5].sort((a, b) => a - b);

Summer 1, Week #1

introduction to Typescript

node's async philosophy, nodeback or errback style

Summer 1, Week #2

typescript void and undefined types

typescript true and false and string literal types

typescript tuples and object types

typescript structural typing (vs nominal typing)

js ES Modules export function foo() {}

Summer 1, Week #3

js es modules named imports import { foo } from './foo';

js es modules default imports_ import foo from './foo';

js Promises let promise = new Promise(executorFn);

js chaining promises promise.then().then().catch()

js fetch - window.fetch() (browser) and node-fetch (node)

Summer 1, Week #4

js while loops while (x < 5) {...}

js case statement

js break keyword - break out of a for/while loop, or case

js symbols - new Symbol('foo');

js generators - function* myGenerator() { yield 1; }

js iterables and Symbol.iterator

js async/await - async function load() { await fetch('/'); }

Year 2, Week #1

introduction to React

js ternary let name = hasBeard ? 'jared' : 'willow';

js destructuring function args ({ foo, bar }) => {...}

typescript generic types Array<string> Promise<Response>

Year 2, Week #2

React: mapping over arrays in JSX

React: event handlers onClick and friends

React: useState() intro - state management

React: useEffect() intro - side effects

React: Fragments <></>

React: style prop <div style={{ color: red }} />

Year 2, Week #3

js spread syntax { ...someObject } [...someArray]

js object shorthand { name, age, hasBeard }

js boolean type coercion aka truthy and falsy

js logical OR operator ||

js object bracket notation fern['bites-kids'] = true

js object helper methods Object.keys() and Object.values()

Year 2, Week #4


importing CSS files into React Component files

Year 2, Week #5

IIFI (immediately invoked function expression)

ASI javascript (Automatic Semicolon Insertion)

SPA (single page application) pros and cons

SEO (search engine optimization)

SSG (static site generator)


Year 2, Week #6

CSS-in-JS and css modules

React dangerouselySetInnerHTML


Misc: npx, TTFB (Time to First Byte), React hydration

Year 2, Week #7

CSS variables --main-bg: hotpink;

listening for keyboard events in React

returning cleanup functions from useEffect fns

Year 2, Week #8

git: upstream and origin conventional remotes

Year 2, Week #9

css: webfonts, web-safe fonts, @font-face, .woff format

css: transitions with transition-property, transition-duration, etc.

js: npm classnames package

typescript: type narrowing

Year 2, Week #10

unix: ps command - process status ps aux | grep 4040

unix: kill command - kill a process kill -9 <pid>

js: rest parameters - function foo(...strs: string[]) {}

typescript: index signatures - { [key: string]: string; }

react: form input elements managed with useState()

Year 2, Week #11

css position - static, relative, absolute, fixed, sticky

css psuedo-classes - :link, :visited, :active, :focus

css psuedo-classes - :first-child, :last-child, :nth-child()

typescript type-widening and as const

Year 2, Week #12

css: object-fit and object-position

html: srcset and sizes for responsive images

js: === and value vs reference equality

react: gotchas with using arrays and objects in state

Year 2, Week #13

all about browser cookies

js: creating, reading, deleting cookies with document.cookie

html/css: using Font Awesome icon font to creat icons

Year 2, Week #14

js: localStorage and sessionStorage

recursion, recursive strategy for solving problems, base case, etc.

Year 2, Week #15

js: Error objects, throwing errors, try/catch blocks

ts: composite types (types made of other types)

ts: generics - generic types, generic functions, etc.

css: calc() function

css: box-sizing property

Year 2, Week #16

html: anchor element extras - linking to page sections, emails, phone numbers

css: scroll-behavior: smooth for smooth scrolling to page locations

js: CORS - Cross Origin Resource Sharing, OPTIONS, preflight, Access-Control-<*> headers

npm: npm lifecycle scripts pre<scriptname>, post<scriptname>

node: using environment variables with process.env

Year 2, Week #17

js: static properties and methods

js: instanceof keyword

js: .toString() method for controlling object > string conversion

js: getters and setters

ts: access modifiers - public, protected, private

Year 2, Week #18

js: customizing window.fetch() requests: methods, headers, and body

REST apis, rest-ful resources and endpoints for APIs

Year 2, Week #19

js: nullish coalescing operator ??

js: supplying default values when destructuring

react: supplying default values for props

js: all about dates and times with the Date object

Year 2, Week #20

react: conditionally rendering components

Year 2, Week #21

html: basic responsive images

js: Object.entries()

css: linear gradients

css: multiple background images

Year 2, Week #22

git: ignoring already-added files, git rm [--force]

javascript: optional chaining operator foo?.bar?.baz

node: Express node webserver library

npm: regular vs development dependencies devDependencies

npm/typescript: third-party types with @types/* Definitely Typed

Year 2, Week #23

sql: introducing databases and SQL

Year 2, Week #24

Environment variables and .env files

Summer 2, Week #1

vim: macros

overview of the go programming language

Summer 2, Week #2

programming languages: operators (unary, binary, ternary; prefix, postfix, infix)

ts: non-null assertion operator !

ts: interfaces vs types

ts: implementing interfaces

Summer 2, Week #3

"Hello world" in assembly language

"Hello world" in C

Summer 2, Week #4


TS: abstract classes

C: compilers, hello world

Year 3, Week #1

C: Preprocessor directives: #include and #define

C: Basic types: int, float, char, and the sizeof operator

C: variables, initialization/assignment, mutability, and const

C: printf basics

a very brief into to make

Year 3, Week #2

Javascript: Set and Map

Typescript Enums

Year 3, Week #3

SQL: mysqldump, a tool for exporting/dumping databases


SQL: foreign key relationships

Year 3, Week #4

SQL: JOIN basics

C: Pointer basics, functions that take pointers

Year 3, Week #5

C: Debugging with VSCode

Year 3, Week #6

Diagramming monkey recursive Pratt parsing

Year 3, Week #7

VSCode Rest Client Extension

Year 3, Week #8

C: "strings"

C: Command line arguments (argv and argc)

Year 3, Week #9


Year 3, Week #10

Dependency Injection & Test Mocks

Year 3, Week #11

Introduction to Netlify

typedef in C

structs in C

Year 3, Week #12

pm2 info for daemonizing applications

helping jest play nice with import.meta.env

Year 3, Week #13

pointer arithmetic in C

Year 3, Week #14


hashing passwords with bcrypt



Year 3, Week #15

No description...

Year 3, Week #16

No description...

Year 3, Week #17

No description...

Year 3, Week #18

No description...

Year 3, Week #19

No description...

Year 3, Week #20

No description...

Year 3, Week #21

No description...

Year 3, Week #22

No description...

Year 3, Week #23

No description...

Year 3, Week #24

No description...

Year 3, Week #24

No description...