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
struct
s 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...