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 (goats.com), 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.map(), 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/id_rsa.pub
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
Storybook
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)
ReactDOM.renderToString()
Year 2, Week #6
CSS-in-JS and css modules
React dangerouselySetInnerHTML
Markdown
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
Favicons
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: ADD COLUMN, DEFAULT, NOT NULL
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
Redux
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
Semver
hashing passwords with bcrypt
SQL: IF NOT EXISTS
SQL: TIMESTAMP type and CURRENT_TIMESTAMP
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...