From c167ee263dbfb6f263cefea70536dd1d17ee7e77 Mon Sep 17 00:00:00 2001 From: Bryan C Guner <66654881+bgoonz@users.noreply.github.com> Date: Fri, 9 Apr 2021 18:28:44 -0400 Subject: [PATCH] Create README.md --- README.md | 17754 ++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 17754 insertions(+) create mode 100644 README.md diff --git a/README.md b/README.md new file mode 100644 index 000000000..4fe871aeb --- /dev/null +++ b/README.md @@ -0,0 +1,17754 @@ + +- [Lambda Resources Website)](#lambda-resources-website) + + +# Lambda Resources Website) + +``` + +├── [hi](./0-notes) +├── [hi](./1-projects) +│ ├── [hi](./A_arrays_solution) +│ ├── [hi](./A_conditionals_solution) +│ ├── [hi](./A_executing_code_solution) +│ ├── [hi](./A_functions_solution) +│ ├── [hi](./A_loops_solution) +│ ├── [hi](./A_nested_loops_solution) +│ ├── [hi](./Atomic-Design-Solution-master) +│ │ └── dogs) +│ │ ├── [hi](./public) +│ │ └── src) +│ │ ├── [hi](./atoms) +│ │ ├── [hi](./molecules) +│ │ ├── [hi](./organisms) +│ │ ├── [hi](./pages) +│ │ └── templates) +│ ├── [hi](./B_arrays_solution) +│ ├── [hi](./Basic-JavaScript-master) +│ │ ├── [hi](./src) +│ │ └── tests) +│ ├── [hi](./B_expressions_solution) +│ ├── [hi](./B_functions_solution) +│ ├── [hi](./B_loops_solution) +│ ├── [hi](./B_two_dimensional_arrays_solution) +│ ├── [hi](./C_arrays_solution) +│ ├── [hi](./C_functions_solution) +│ ├── [hi](./Client-Auth-Solution-master) +│ │ ├── [hi](./public) +│ │ └── src) +│ │ ├── [hi](./actions) +│ │ ├── [hi](./components) +│ │ │ └── HOC) +│ │ └── reducers) +│ ├── [hi](./C_loops_solution) +│ ├── [hi](./C_more_problems_solution) +│ ├── [hi](./Components-BEM-Solution-master) +│ │ ├── [hi](./components) +│ │ │ ├── [hi](./Box) +│ │ │ ├── [hi](./Dropdown) +│ │ │ └── Section) +│ │ └── markups) +│ ├── [hi](./Components-Constructors-Solution-master) +│ │ ├── [hi](./components) +│ │ │ ├── [hi](./Box) +│ │ │ ├── [hi](./Dropdown) +│ │ │ ├── [hi](./Section) +│ │ │ └── Tabs) +│ │ └── markups) +│ ├── [hi](./C_variables_solution) +│ ├── [hi](./Data-Structures-master) +│ │ ├── [hi](./avl_tree) +│ │ ├── [hi](./binary_search_tree) +│ │ ├── [hi](./doubly_linked_list) +│ │ ├── [hi](./heap) +│ │ ├── [hi](./lru_cache) +│ │ ├── [hi](./queue) +│ │ ├── [hi](./singly_linked_list) +│ │ └── stack) +│ ├── [hi](./DOM-JavaScript-mini-Solution-master) +│ │ └── components) +│ │ ├── [hi](./Box) +│ │ ├── [hi](./Header) +│ │ ├── [hi](./List) +│ │ ├── [hi](./Nav) +│ │ ├── [hi](./Section) +│ │ └── Tabs) +│ ├── [hi](./D_string_indexing_and_methods_solution) +│ ├── [hi](./HTML-CSS-mini-Solution-master) +│ │ └── components) +│ │ ├── [hi](./Box) +│ │ ├── [hi](./Header) +│ │ └── Section) +│ ├── [hi](./Intro-Python-II-master) +│ │ ├── [hi](./examples) +│ │ └── src) +│ ├── [hi](./Intro-Python-I-master) +│ │ └── src) +│ ├── [hi](./Intro-to-C-master) +│ │ ├── [hi](./fizzbuzz) +│ │ │ └── tests) +│ │ ├── [hi](./hangman) +│ │ ├── [hi](./malloc) +│ │ │ └── tests) +│ │ ├── [hi](./pointers) +│ │ │ └── tests) +│ │ ├── [hi](./queue) +│ │ │ └── tests) +│ │ ├── [hi](./quicksort) +│ │ │ └── tests) +│ │ ├── [hi](./strings) +│ │ │ └── tests) +│ │ ├── [hi](./structs) +│ │ │ └── tests) +│ │ └── utils) +│ ├── [hi](./JavaScript-III-master) +│ │ └── assignments) +│ ├── [hi](./JS-Exercise-Classes) +│ │ └── test) +│ ├── [hi](./LS-Data-Structures-II-Solution-master) +│ │ ├── [hi](./src) +│ │ └── tests) +│ ├── [hi](./LS-Data-Structures-I-Solution-master) +│ │ ├── [hi](./src) +│ │ └── tests) +│ ├── [hi](./master) +│ ├── [hi](./Mongo-Mini-II-Solution-master) +│ ├── [hi](./nested-data-exercises-master) +│ │ ├── [hi](./data) +│ │ └── test) +│ ├── [hi](./Node-Express-Gmaps-Solution-Day-II-master) +│ │ └── src) +│ │ ├── [hi](./controllers) +│ │ └── models) +│ ├── [hi](./Node-Express-Gmaps-Solution-Day-I-master) +│ │ └── src) +│ │ ├── [hi](./controllers) +│ │ └── models) +│ ├── [hi](./_Pet-Projects) +│ │ └── whack-a-mole) +│ ├── [hi](./Python-OOP-Toy-master) +│ │ └── src) +│ ├── [hi](./React-Todo-Solution-master) +│ │ ├── [hi](./public) +│ │ └── src) +│ │ └── tests) +│ ├── [hi](./Relational-Databases-master) +│ ├── [hi](./solutions) +│ ├── [hi](./Sprint-Challenge--Intro-Python-master) +│ │ └── src) +│ │ ├── [hi](./cityreader) +│ │ ├── [hi](./comp) +│ │ └── oop) +│ ├── [hi](./webapi-ii-challenge-master) +│ │ └── data) +│ │ ├── [hi](./migrations) +│ │ └── seeds) +│ └── web-guided-project-testing-web-apps-solution-main) +│ ├── [hi](./public) +│ └── src) +│ └── components) +├── [hi](./2-resources) +│ ├── [hi](./Atomic-Design-Solution-master) +│ │ └── dogs) +│ │ ├── [hi](./public) +│ │ └── src) +│ │ ├── [hi](./atoms) +│ │ ├── [hi](./molecules) +│ │ ├── [hi](./organisms) +│ │ ├── [hi](./pages) +│ │ └── templates) +│ ├── [hi](./__CHEAT-SHEETS) +│ │ ├── [hi](./All) +│ │ ├── [hi](./guided-cheatsheets) +│ │ │ ├── [hi](./auto-generate-boilerplate) +│ │ │ │ └── test2) +│ │ │ └── test.html) +│ │ └── pdf) +│ │ ├── [hi](./css) +│ │ ├── [hi](./css.html) +│ │ ├── [hi](./database) +│ │ ├── [hi](./database.html) +│ │ ├── [hi](./data-structures) +│ │ ├── [hi](./data-structures.html) +│ │ ├── [hi](./engineering) +│ │ ├── [hi](./engineering.html) +│ │ ├── [hi](./general-comp-sci) +│ │ ├── [hi](./git) +│ │ ├── [hi](./git.html) +│ │ ├── [hi](./html) +│ │ ├── [hi](./html.html) +│ │ ├── [hi](./java) +│ │ ├── [hi](./java.html) +│ │ ├── [hi](./javascript) +│ │ ├── [hi](./javascript.html) +│ │ ├── [hi](./linux) +│ │ ├── [hi](./linux.html) +│ │ ├── [hi](./math) +│ │ ├── [hi](./math.html) +│ │ ├── [hi](./misc) +│ │ ├── [hi](./misc.html) +│ │ ├── [hi](./python) +│ │ ├── [hi](./python.html) +│ │ ├── [hi](./ruby) +│ │ ├── [hi](./ruby.html) +│ │ ├── [hi](./unsorted) +│ │ ├── [hi](./web) +│ │ └── web.html) +│ ├── [hi](./Client-Auth-Solution-master) +│ │ ├── [hi](./public) +│ │ └── src) +│ │ ├── [hi](./actions) +│ │ ├── [hi](./components) +│ │ │ └── HOC) +│ │ └── reducers) +│ ├── [hi](./Components-BEM-Solution-master) +│ │ ├── [hi](./components) +│ │ │ ├── [hi](./Box) +│ │ │ ├── [hi](./Dropdown) +│ │ │ └── Section) +│ │ └── markups) +│ ├── [hi](./Components-Constructors-Solution-master) +│ │ ├── [hi](./components) +│ │ │ ├── [hi](./Box) +│ │ │ ├── [hi](./Dropdown) +│ │ │ ├── [hi](./Section) +│ │ │ └── Tabs) +│ │ └── markups) +│ ├── [hi](./DOM-JavaScript-mini-Solution-master) +│ │ └── components) +│ │ ├── [hi](./Box) +│ │ ├── [hi](./Header) +│ │ ├── [hi](./List) +│ │ ├── [hi](./Nav) +│ │ ├── [hi](./Section) +│ │ └── Tabs) +│ ├── [hi](./HTML-CSS-mini-Solution-master) +│ │ └── components) +│ │ ├── [hi](./Box) +│ │ ├── [hi](./Header) +│ │ └── Section) +│ ├── [hi](./JavaScript-I-master) +│ │ └── assignments) +│ ├── [hi](./LS-Data-Structures-II-Solution-master) +│ │ ├── [hi](./src) +│ │ └── tests) +│ ├── [hi](./LS-Data-Structures-I-Solution-master) +│ │ ├── [hi](./src) +│ │ └── tests) +│ ├── [hi](./Node-Express-Gmaps-Solution-Day-II-master) +│ │ └── src) +│ │ ├── [hi](./controllers) +│ │ └── models) +│ ├── [hi](./Node-Express-Gmaps-Solution-Day-I-master) +│ │ └── src) +│ │ ├── [hi](./controllers) +│ │ └── models) +│ ├── [hi](./_Past-Projects) +│ │ └── LambdaSchool-master) +│ │ ├── [hi](./31d1) +│ │ ├── [hi](./aa-score) +│ │ │ ├── [hi](./public) +│ │ │ └── src) +│ │ ├── [hi](./Administration) +│ │ │ ├── [hi](./certs) +│ │ │ ├── [hi](./marketing) +│ │ │ ├── [hi](./studying) +│ │ │ └── zoom) +│ │ ├── [hi](./bw1-tl) +│ │ │ ├── [hi](./admin) +│ │ │ ├── [hi](./api) +│ │ │ ├── [hi](./auth) +│ │ │ ├── [hi](./database) +│ │ │ │ ├── [hi](./migrations) +│ │ │ │ └── seeds) +│ │ │ ├── [hi](./middleware) +│ │ │ ├── [hi](./todos) +│ │ │ └── volunteer) +│ │ ├── [hi](./css) +│ │ ├── [hi](./evoingram.github.io) +│ │ ├── [hi](./JavaScript30) +│ │ │ ├── [hi](./01) +│ │ │ │ └── sounds) +│ │ │ ├── [hi](./02) +│ │ │ ├── [hi](./03) +│ │ │ ├── [hi](./04) +│ │ │ ├── [hi](./05) +│ │ │ ├── [hi](./06) +│ │ │ ├── [hi](./07) +│ │ │ ├── [hi](./08) +│ │ │ ├── [hi](./09) +│ │ │ ├── [hi](./10) +│ │ │ ├── [hi](./11) +│ │ │ ├── [hi](./12) +│ │ │ ├── [hi](./13) +│ │ │ ├── [hi](./14) +│ │ │ ├── [hi](./15) +│ │ │ ├── [hi](./16) +│ │ │ ├── [hi](./17) +│ │ │ ├── [hi](./18) +│ │ │ ├── [hi](./19) +│ │ │ ├── [hi](./20) +│ │ │ ├── [hi](./21) +│ │ │ ├── [hi](./22) +│ │ │ ├── [hi](./23) +│ │ │ ├── [hi](./24) +│ │ │ ├── [hi](./25) +│ │ │ ├── [hi](./26) +│ │ │ ├── [hi](./27) +│ │ │ ├── [hi](./28) +│ │ │ ├── [hi](./29) +│ │ │ └── 30) +│ │ ├── [hi](./labs) +│ │ │ ├── [hi](./backend) +│ │ │ ├── [hi](./frontend) +│ │ │ ├── [hi](./last journal entry) +│ │ │ └── video-to-next-group) +│ │ ├── [hi](./m1) +│ │ │ ├── [hi](./11b1) +│ │ │ │ ├── [hi](./design-files) +│ │ │ │ ├── [hi](./Git-Flow-Practice) +│ │ │ │ ├── [hi](./great-idea) +│ │ │ │ │ ├── [hi](./css) +│ │ │ │ │ └── img) +│ │ │ │ ├── [hi](./great-idea-website) +│ │ │ │ │ ├── [hi](./css) +│ │ │ │ │ └── img) +│ │ │ │ └── Web26Git) +│ │ │ ├── [hi](./11c1) +│ │ │ │ ├── [hi](./design-files) +│ │ │ │ ├── [hi](./great-idea-website) +│ │ │ │ │ ├── [hi](./css) +│ │ │ │ │ └── img) +│ │ │ │ └── User-Interface) +│ │ │ ├── [hi](./11d1) +│ │ │ │ ├── [hi](./design-files) +│ │ │ │ ├── [hi](./great-idea) +│ │ │ │ │ ├── [hi](./css) +│ │ │ │ │ └── img) +│ │ │ │ └── UI-III-Flexbox) +│ │ │ ├── [hi](./12a1) +│ │ │ │ ├── [hi](./css) +│ │ │ │ ├── [hi](./design-files) +│ │ │ │ ├── [hi](./img) +│ │ │ │ └── responsive-web-design-I) +│ │ │ ├── [hi](./12b1) +│ │ │ │ ├── [hi](./dimension) +│ │ │ │ │ ├── [hi](./assets) +│ │ │ │ │ │ └── sass) +│ │ │ │ │ └── html5up-dimension) +│ │ │ │ │ └── assets) +│ │ │ │ │ └── sass) +│ │ │ │ └── solidstate) +│ │ │ │ └── assets) +│ │ │ │ └── sass) +│ │ │ ├── [hi](./12c1) +│ │ │ │ ├── [hi](./css) +│ │ │ │ └── less) +│ │ │ ├── [hi](./12d1) +│ │ │ │ ├── [hi](./css) +│ │ │ │ ├── [hi](./design-files) +│ │ │ │ ├── [hi](./img) +│ │ │ │ └── less) +│ │ │ ├── [hi](./13a1) +│ │ │ │ └── assignments) +│ │ │ ├── [hi](./13b1) +│ │ │ │ └── assignments) +│ │ │ ├── [hi](./13c1) +│ │ │ │ └── assignments) +│ │ │ ├── [hi](./13d1) +│ │ │ │ ├── [hi](./new) +│ │ │ │ │ └── test) +│ │ │ │ └── old) +│ │ │ │ └── assignments) +│ │ │ ├── [hi](./13e1) +│ │ │ │ └── challenges) +│ │ │ ├── [hi](./14a1) +│ │ │ │ └── Marketing-page) +│ │ │ ├── [hi](./SC-ACSS) +│ │ │ └── Sprint-Challenge--Advanced-CSS) +│ │ ├── [hi](./m2) +│ │ │ ├── [hi](./21a1) +│ │ │ │ ├── [hi](./css) +│ │ │ │ ├── [hi](./design-files) +│ │ │ │ ├── [hi](./img) +│ │ │ │ ├── [hi](./js) +│ │ │ │ └── stretch-assignment) +│ │ │ │ └── digital_timer) +│ │ │ ├── [hi](./21b1) +│ │ │ ├── [hi](./21c1) +│ │ │ │ ├── [hi](./Article) +│ │ │ │ ├── [hi](./assets) +│ │ │ │ ├── [hi](./css) +│ │ │ │ ├── [hi](./Header) +│ │ │ │ ├── [hi](./LESS) +│ │ │ │ └── Menu) +│ │ │ ├── [hi](./21d1) +│ │ │ │ ├── [hi](./assets) +│ │ │ │ └── GitHubCard) +│ │ │ ├── [hi](./21e1) +│ │ │ │ ├── [hi](./assets) +│ │ │ │ │ └── carousel) +│ │ │ │ ├── [hi](./components) +│ │ │ │ │ ├── [hi](./Cards) +│ │ │ │ │ ├── [hi](./Carousel) +│ │ │ │ │ ├── [hi](./Header) +│ │ │ │ │ ├── [hi](./Tabs) +│ │ │ │ │ └── TopBar) +│ │ │ │ ├── [hi](./CSS) +│ │ │ │ └── LESS) +│ │ │ ├── [hi](./22a1) +│ │ │ │ ├── [hi](./public) +│ │ │ │ └── src) +│ │ │ ├── [hi](./22b1) +│ │ │ │ ├── [hi](./design-files) +│ │ │ │ ├── [hi](./public) +│ │ │ │ └── src) +│ │ │ │ ├── [hi](./components) +│ │ │ │ │ ├── [hi](./ButtonComponents) +│ │ │ │ │ │ ├── [hi](./NumberButtons) +│ │ │ │ │ │ ├── [hi](./OperatorButtons) +│ │ │ │ │ │ └── SpecialButtons) +│ │ │ │ │ └── DisplayComponents) +│ │ │ │ └── Img) +│ │ │ ├── [hi](./22c1) +│ │ │ │ ├── [hi](./public) +│ │ │ │ ├── [hi](./reactstrap-project) +│ │ │ │ │ ├── [hi](./public) +│ │ │ │ │ └── src) +│ │ │ │ └── src) +│ │ │ ├── [hi](./22e1) +│ │ │ │ └── starwars) +│ │ │ │ ├── [hi](./public) +│ │ │ │ └── src) +│ │ │ │ └── components) +│ │ │ ├── [hi](./23a1) +│ │ │ │ ├── [hi](./public) +│ │ │ │ └── src) +│ │ │ │ └── components) +│ │ │ ├── [hi](./23a2) +│ │ │ │ └── images) +│ │ │ ├── [hi](./23b1) +│ │ │ │ └── client) +│ │ │ │ ├── [hi](./public) +│ │ │ │ └── src) +│ │ │ │ └── Movies) +│ │ │ ├── [hi](./23c1) +│ │ │ │ ├── [hi](./public) +│ │ │ │ ├── [hi](./src) +│ │ │ │ │ └── CustomHooks) +│ │ │ │ └── team-builder) +│ │ │ ├── [hi](./23d1) +│ │ │ │ ├── [hi](./public) +│ │ │ │ └── src) +│ │ │ │ └── CustomHooks) +│ │ │ ├── [hi](./23d2) +│ │ │ │ ├── [hi](./public) +│ │ │ │ └── src) +│ │ │ ├── [hi](./23e1) +│ │ │ │ ├── [hi](./public) +│ │ │ │ └── src) +│ │ │ │ └── components) +│ │ │ └── 24a1) +│ │ │ ├── [hi](./public) +│ │ │ │ └── img) +│ │ │ └── src) +│ │ │ └── components) +│ │ │ └── old pages) +│ │ ├── [hi](./m3) +│ │ │ ├── [hi](./31a1) +│ │ │ │ ├── [hi](./public) +│ │ │ │ └── src) +│ │ │ │ └── components) +│ │ │ │ └── TodoComponents) +│ │ │ ├── [hi](./31a2) +│ │ │ │ ├── [hi](./public) +│ │ │ │ └── src) +│ │ │ ├── [hi](./31b1) +│ │ │ │ ├── [hi](./public) +│ │ │ │ └── src) +│ │ │ │ └── components) +│ │ │ ├── [hi](./31c1) +│ │ │ │ ├── [hi](./public) +│ │ │ │ └── src) +│ │ │ │ ├── [hi](./components) +│ │ │ │ └── hooks) +│ │ │ ├── [hi](./31d1) +│ │ │ │ ├── [hi](./public) +│ │ │ │ └── src) +│ │ │ │ ├── [hi](./components) +│ │ │ │ └── hooks) +│ │ │ ├── [hi](./31e1) +│ │ │ │ └── client) +│ │ │ │ ├── [hi](./public) +│ │ │ │ └── src) +│ │ │ │ ├── [hi](./components) +│ │ │ │ └── hooks) +│ │ │ ├── [hi](./32a1) +│ │ │ │ ├── [hi](./public) +│ │ │ │ └── src) +│ │ │ │ ├── [hi](./components) +│ │ │ │ ├── [hi](./contexts) +│ │ │ │ └── sass) +│ │ │ ├── [hi](./32b1) +│ │ │ │ ├── [hi](./public) +│ │ │ │ └── src) +│ │ │ │ ├── [hi](./components) +│ │ │ │ └── reducers) +│ │ │ ├── [hi](./32c1) +│ │ │ │ ├── [hi](./public) +│ │ │ │ └── src) +│ │ │ │ ├── [hi](./actions) +│ │ │ │ ├── [hi](./components) +│ │ │ │ └── reducers) +│ │ │ ├── [hi](./32d1) +│ │ │ │ ├── [hi](./public) +│ │ │ │ └── src) +│ │ │ │ ├── [hi](./actions) +│ │ │ │ ├── [hi](./components) +│ │ │ │ ├── [hi](./fonts) +│ │ │ │ ├── [hi](./img) +│ │ │ │ └── reducers) +│ │ │ ├── [hi](./32e1) +│ │ │ │ └── smurfs) +│ │ │ │ ├── [hi](./public) +│ │ │ │ └── src) +│ │ │ │ ├── [hi](./actions) +│ │ │ │ ├── [hi](./components) +│ │ │ │ └── reducers) +│ │ │ ├── [hi](./33a1) +│ │ │ │ ├── [hi](./public) +│ │ │ │ └── src) +│ │ │ │ ├── [hi](./controls) +│ │ │ │ ├── [hi](./dashboard) +│ │ │ │ └── display) +│ │ │ ├── [hi](./33b1) +│ │ │ │ └── friends) +│ │ │ │ ├── [hi](./public) +│ │ │ │ └── src) +│ │ │ │ ├── [hi](./actions) +│ │ │ │ ├── [hi](./components) +│ │ │ │ ├── [hi](./reducers) +│ │ │ │ └── utils) +│ │ │ ├── [hi](./33d1) +│ │ │ │ └── client) +│ │ │ │ ├── [hi](./public) +│ │ │ │ └── src) +│ │ │ │ └── Movies) +│ │ │ └── 33e1) +│ │ │ └── client) +│ │ │ ├── [hi](./public) +│ │ │ └── src) +│ │ │ ├── [hi](./actions) +│ │ │ ├── [hi](./components) +│ │ │ ├── [hi](./reducers) +│ │ │ └── utils) +│ │ ├── [hi](./m4) +│ │ │ ├── [hi](./41a1) +│ │ │ │ └── data) +│ │ │ │ ├── [hi](./migrations) +│ │ │ │ └── seeds) +│ │ │ ├── [hi](./41a2) +│ │ │ │ └── data) +│ │ │ │ ├── [hi](./migrations) +│ │ │ │ └── seeds) +│ │ │ ├── [hi](./41b1) +│ │ │ │ ├── [hi](./data) +│ │ │ │ │ ├── [hi](./migrations) +│ │ │ │ │ └── seeds) +│ │ │ │ └── hubs) +│ │ │ ├── [hi](./41b2) +│ │ │ │ └── data) +│ │ │ │ ├── [hi](./migrations) +│ │ │ │ └── seeds) +│ │ │ ├── [hi](./41c1) +│ │ │ │ ├── [hi](./data) +│ │ │ │ │ ├── [hi](./migrations) +│ │ │ │ │ └── seeds) +│ │ │ │ ├── [hi](./hubs) +│ │ │ │ └── messages) +│ │ │ ├── [hi](./41c2) +│ │ │ │ ├── [hi](./data) +│ │ │ │ │ ├── [hi](./migrations) +│ │ │ │ │ └── seeds) +│ │ │ │ ├── [hi](./posts) +│ │ │ │ └── users) +│ │ │ ├── [hi](./41d1) +│ │ │ │ ├── [hi](./api) +│ │ │ │ └── data) +│ │ │ │ └── migrations) +│ │ │ ├── [hi](./41e1) +│ │ │ │ ├── [hi](./data) +│ │ │ │ │ ├── [hi](./helpers) +│ │ │ │ │ ├── [hi](./migrations) +│ │ │ │ │ └── seeds) +│ │ │ │ └── routers) +│ │ │ ├── [hi](./41e1app) +│ │ │ │ ├── [hi](./public) +│ │ │ │ └── src) +│ │ │ │ └── components) +│ │ │ ├── [hi](./42a1) +│ │ │ │ ├── [hi](./data) +│ │ │ │ │ ├── [hi](./migrations) +│ │ │ │ │ └── seeds) +│ │ │ │ ├── [hi](./dbintro) +│ │ │ │ ├── [hi](./migrations) +│ │ │ │ └── posts) +│ │ │ ├── [hi](./42a2) +│ │ │ │ ├── [hi](./data) +│ │ │ │ │ ├── [hi](./migrations) +│ │ │ │ │ └── seeds) +│ │ │ │ └── routers) +│ │ │ ├── [hi](./42b1) +│ │ │ │ ├── [hi](./api) +│ │ │ │ ├── [hi](./data) +│ │ │ │ └── fruits) +│ │ │ ├── [hi](./42b2) +│ │ │ │ ├── [hi](./api) +│ │ │ │ ├── [hi](./data) +│ │ │ │ │ ├── [hi](./migrations) +│ │ │ │ │ └── seeds) +│ │ │ │ └── routers) +│ │ │ ├── [hi](./42c1) +│ │ │ │ ├── [hi](./data) +│ │ │ │ │ ├── [hi](./migrations) +│ │ │ │ │ └── seeds) +│ │ │ │ └── users) +│ │ │ ├── [hi](./42c2) +│ │ │ │ ├── [hi](./data) +│ │ │ │ │ ├── [hi](./migrations) +│ │ │ │ │ └── seeds) +│ │ │ │ └── schemes) +│ │ │ ├── [hi](./42d1) +│ │ │ │ └── data) +│ │ │ │ └── seeds) +│ │ │ ├── [hi](./42d2) +│ │ │ │ ├── [hi](./data) +│ │ │ │ │ ├── [hi](./migrations) +│ │ │ │ │ └── seeds) +│ │ │ │ └── recipes) +│ │ │ ├── [hi](./42e1) +│ │ │ │ ├── [hi](./data) +│ │ │ │ │ ├── [hi](./migrations) +│ │ │ │ │ └── seeds) +│ │ │ │ └── projects) +│ │ │ ├── [hi](./43a1) +│ │ │ │ ├── [hi](./api) +│ │ │ │ ├── [hi](./auth) +│ │ │ │ ├── [hi](./authintro) +│ │ │ │ ├── [hi](./database) +│ │ │ │ │ └── migrations) +│ │ │ │ ├── [hi](./__MACOSX) +│ │ │ │ │ └── authintro) +│ │ │ │ └── users) +│ │ │ ├── [hi](./43a2) +│ │ │ │ ├── [hi](./api) +│ │ │ │ ├── [hi](./auth) +│ │ │ │ ├── [hi](./database) +│ │ │ │ │ └── migrations) +│ │ │ │ └── users) +│ │ │ ├── [hi](./43b1) +│ │ │ │ ├── [hi](./api) +│ │ │ │ ├── [hi](./auth) +│ │ │ │ ├── [hi](./database) +│ │ │ │ │ └── migrations) +│ │ │ │ └── users) +│ │ │ ├── [hi](./43b2) +│ │ │ │ ├── [hi](./api) +│ │ │ │ ├── [hi](./auth) +│ │ │ │ ├── [hi](./database) +│ │ │ │ │ └── migrations) +│ │ │ │ ├── [hi](./sessions) +│ │ │ │ └── users) +│ │ │ ├── [hi](./43c1) +│ │ │ │ ├── [hi](./api) +│ │ │ │ ├── [hi](./auth) +│ │ │ │ ├── [hi](./database) +│ │ │ │ │ └── migrations) +│ │ │ │ ├── [hi](./jwts) +│ │ │ │ └── users) +│ │ │ ├── [hi](./43c2) +│ │ │ │ ├── [hi](./api) +│ │ │ │ ├── [hi](./auth) +│ │ │ │ ├── [hi](./config) +│ │ │ │ ├── [hi](./database) +│ │ │ │ │ └── migrations) +│ │ │ │ ├── [hi](./__MACOSX) +│ │ │ │ │ └── sessions) +│ │ │ │ └── users) +│ │ │ ├── [hi](./43d1) +│ │ │ │ ├── [hi](./api) +│ │ │ │ ├── [hi](./data) +│ │ │ │ │ ├── [hi](./migrations) +│ │ │ │ │ └── seeds) +│ │ │ │ └── hobbits) +│ │ │ ├── [hi](./43d1a) +│ │ │ │ └── ls) +│ │ │ ├── [hi](./43d2) +│ │ │ │ ├── [hi](./api) +│ │ │ │ ├── [hi](./cohorts) +│ │ │ │ ├── [hi](./database) +│ │ │ │ │ ├── [hi](./migrations) +│ │ │ │ │ └── seeds) +│ │ │ │ └── students) +│ │ │ └── 43e1) +│ │ │ ├── [hi](./43e1) +│ │ │ │ ├── [hi](./public) +│ │ │ │ └── src) +│ │ │ │ └── components) +│ │ │ ├── [hi](./api) +│ │ │ ├── [hi](./auth) +│ │ │ ├── [hi](./database) +│ │ │ │ └── migrations) +│ │ │ └── jokes) +│ │ ├── [hi](./m5) +│ │ │ ├── [hi](./51a1) +│ │ │ │ └── src) +│ │ │ │ └── employeeApp) +│ │ │ ├── [hi](./51b1) +│ │ │ │ └── src) +│ │ │ │ └── collections) +│ │ │ │ └── src) +│ │ │ │ └── collections) +│ │ │ ├── [hi](./51c1) +│ │ │ │ └── transportation) +│ │ │ │ └── src) +│ │ │ │ └── transport) +│ │ │ ├── [hi](./51d1) +│ │ │ │ ├── [hi](./bin) +│ │ │ │ │ └── src) +│ │ │ │ │ ├── [hi](./main) +│ │ │ │ │ │ ├── [hi](./java) +│ │ │ │ │ │ │ └── com) +│ │ │ │ │ │ │ └── lambdaschool) +│ │ │ │ │ │ │ └── webemployees3) +│ │ │ │ │ │ └── resources) +│ │ │ │ │ └── test) +│ │ │ │ │ └── java) +│ │ │ │ │ └── com) +│ │ │ │ │ └── lambdaschool) +│ │ │ │ │ └── webemployees3) +│ │ │ │ └── src) +│ │ │ │ ├── [hi](./main) +│ │ │ │ │ ├── [hi](./java) +│ │ │ │ │ │ └── com) +│ │ │ │ │ │ └── lambdaschool) +│ │ │ │ │ │ └── j51d1) +│ │ │ │ │ └── resources) +│ │ │ │ │ └── static) +│ │ │ │ └── test) +│ │ │ │ └── java) +│ │ │ │ └── com) +│ │ │ │ └── lambdaschool) +│ │ │ │ └── webemployees3) +│ │ │ ├── [hi](./51d2) +│ │ │ │ ├── [hi](./src) +│ │ │ │ │ ├── [hi](./main) +│ │ │ │ │ │ ├── [hi](./java) +│ │ │ │ │ │ │ └── com) +│ │ │ │ │ │ │ └── lambdaschool) +│ │ │ │ │ │ │ └── j51d2) +│ │ │ │ │ │ └── resources) +│ │ │ │ │ └── test) +│ │ │ │ │ └── java) +│ │ │ │ │ └── com) +│ │ │ │ │ └── lambdaschool) +│ │ │ │ │ └── j51d2) +│ │ │ │ └── target) +│ │ │ │ └── classes) +│ │ │ ├── [hi](./51e1) +│ │ │ │ └── src) +│ │ │ │ ├── [hi](./main) +│ │ │ │ │ ├── [hi](./java) +│ │ │ │ │ │ └── com) +│ │ │ │ │ │ └── lambdaschool) +│ │ │ │ │ │ └── j51e1) +│ │ │ │ │ └── resources) +│ │ │ │ └── test) +│ │ │ │ └── java) +│ │ │ │ └── com) +│ │ │ │ └── lambdaschool) +│ │ │ │ └── j51e1) +│ │ │ ├── [hi](./52b1) +│ │ │ │ └── assets) +│ │ │ ├── [hi](./52c1) +│ │ │ │ └── src) +│ │ │ │ ├── [hi](./main) +│ │ │ │ │ ├── [hi](./java) +│ │ │ │ │ │ └── com) +│ │ │ │ │ │ └── lambdaschool) +│ │ │ │ │ │ └── j52c1) +│ │ │ │ │ │ ├── [hi](./controllers) +│ │ │ │ │ │ ├── [hi](./models) +│ │ │ │ │ │ ├── [hi](./repos) +│ │ │ │ │ │ └── services) +│ │ │ │ │ └── resources) +│ │ │ │ └── test) +│ │ │ │ └── java) +│ │ │ │ └── com) +│ │ │ │ └── lambdaschool) +│ │ │ │ └── j52c1) +│ │ │ ├── [hi](./52c2) +│ │ │ │ └── src) +│ │ │ │ ├── [hi](./main) +│ │ │ │ │ ├── [hi](./java) +│ │ │ │ │ │ └── com) +│ │ │ │ │ │ └── lambdaschool) +│ │ │ │ │ │ └── j52c2) +│ │ │ │ │ │ ├── [hi](./controllers) +│ │ │ │ │ │ ├── [hi](./models) +│ │ │ │ │ │ ├── [hi](./repos) +│ │ │ │ │ │ └── services) +│ │ │ │ │ └── resources) +│ │ │ │ └── test) +│ │ │ │ └── java) +│ │ │ │ └── com) +│ │ │ │ └── lambdaschool) +│ │ │ │ └── j52c2) +│ │ │ ├── [hi](./52d1) +│ │ │ │ └── oauth) +│ │ │ │ ├── [hi](./oauth2) +│ │ │ │ │ └── src) +│ │ │ │ │ ├── [hi](./main) +│ │ │ │ │ │ ├── [hi](./java) +│ │ │ │ │ │ │ └── com) +│ │ │ │ │ │ │ └── lambdaschool) +│ │ │ │ │ │ │ └── usermodel) +│ │ │ │ │ │ │ ├── [hi](./config) +│ │ │ │ │ │ │ ├── [hi](./controllers) +│ │ │ │ │ │ │ ├── [hi](./exceptions) +│ │ │ │ │ │ │ ├── [hi](./handlers) +│ │ │ │ │ │ │ ├── [hi](./logging) +│ │ │ │ │ │ │ ├── [hi](./models) +│ │ │ │ │ │ │ ├── [hi](./repository) +│ │ │ │ │ │ │ ├── [hi](./services) +│ │ │ │ │ │ │ └── view) +│ │ │ │ │ │ └── resources) +│ │ │ │ │ │ └── info) +│ │ │ │ │ └── test) +│ │ │ │ │ ├── [hi](./java) +│ │ │ │ │ │ └── com) +│ │ │ │ │ │ └── lambdaschool) +│ │ │ │ │ │ └── usermodel) +│ │ │ │ │ │ ├── [hi](./controllers) +│ │ │ │ │ │ └── services) +│ │ │ │ │ └── resources) +│ │ │ │ └── oauth2 - initial) +│ │ │ │ └── src) +│ │ │ │ ├── [hi](./main) +│ │ │ │ │ ├── [hi](./java) +│ │ │ │ │ │ └── com) +│ │ │ │ │ │ └── lambdaschool) +│ │ │ │ │ │ ├── [hi](./authenticatedusers) +│ │ │ │ │ │ │ ├── [hi](./config) +│ │ │ │ │ │ │ ├── [hi](./controller) +│ │ │ │ │ │ │ ├── [hi](./model) +│ │ │ │ │ │ │ ├── [hi](./repository) +│ │ │ │ │ │ │ ├── [hi](./service) +│ │ │ │ │ │ │ └── view) +│ │ │ │ │ │ └── usermodel) +│ │ │ │ │ │ ├── [hi](./config) +│ │ │ │ │ │ ├── [hi](./controllers) +│ │ │ │ │ │ ├── [hi](./exceptions) +│ │ │ │ │ │ ├── [hi](./handlers) +│ │ │ │ │ │ ├── [hi](./logging) +│ │ │ │ │ │ ├── [hi](./models) +│ │ │ │ │ │ ├── [hi](./repository) +│ │ │ │ │ │ ├── [hi](./services) +│ │ │ │ │ │ └── view) +│ │ │ │ │ └── resources) +│ │ │ │ │ └── info) +│ │ │ │ └── test) +│ │ │ │ └── java) +│ │ │ │ └── com) +│ │ │ │ └── lambdaschool) +│ │ │ │ ├── [hi](./authenticatedusers) +│ │ │ │ └── usermodel) +│ │ │ ├── [hi](./53a1) +│ │ │ │ ├── [hi](./oauth2ExceptionLogging-final) +│ │ │ │ │ └── src) +│ │ │ │ │ └── main) +│ │ │ │ │ ├── [hi](./java) +│ │ │ │ │ │ └── com) +│ │ │ │ │ │ └── lambdaschool) +│ │ │ │ │ │ └── oauth2) +│ │ │ │ │ │ ├── [hi](./config) +│ │ │ │ │ │ ├── [hi](./controllers) +│ │ │ │ │ │ ├── [hi](./exceptions) +│ │ │ │ │ │ ├── [hi](./handlers) +│ │ │ │ │ │ ├── [hi](./logging) +│ │ │ │ │ │ ├── [hi](./models) +│ │ │ │ │ │ ├── [hi](./repository) +│ │ │ │ │ │ ├── [hi](./services) +│ │ │ │ │ │ └── view) +│ │ │ │ │ └── resources) +│ │ │ │ ├── [hi](./src) +│ │ │ │ │ ├── [hi](./main) +│ │ │ │ │ │ ├── [hi](./java) +│ │ │ │ │ │ │ └── com) +│ │ │ │ │ │ │ └── lambdaschool) +│ │ │ │ │ │ │ └── authenticatedusers) +│ │ │ │ │ │ │ ├── [hi](./config) +│ │ │ │ │ │ │ ├── [hi](./controller) +│ │ │ │ │ │ │ ├── [hi](./exceptions) +│ │ │ │ │ │ │ ├── [hi](./handlers) +│ │ │ │ │ │ │ ├── [hi](./model) +│ │ │ │ │ │ │ ├── [hi](./repository) +│ │ │ │ │ │ │ ├── [hi](./service) +│ │ │ │ │ │ │ └── view) +│ │ │ │ │ │ └── resources) +│ │ │ │ │ │ └── info) +│ │ │ │ │ └── test) +│ │ │ │ │ └── java) +│ │ │ │ │ └── com) +│ │ │ │ │ └── lambdaschool) +│ │ │ │ │ ├── [hi](./authenticatedusers) +│ │ │ │ │ └── usermodel) +│ │ │ │ └── target) +│ │ │ │ └── classes) +│ │ │ │ └── info) +│ │ │ ├── [hi](./53b1) +│ │ │ │ ├── [hi](./clientrestaurants) +│ │ │ │ │ └── src) +│ │ │ │ │ ├── [hi](./main) +│ │ │ │ │ │ ├── [hi](./java) +│ │ │ │ │ │ │ └── com) +│ │ │ │ │ │ │ └── lambda) +│ │ │ │ │ │ │ └── clientrestaurants) +│ │ │ │ │ │ │ ├── [hi](./client) +│ │ │ │ │ │ │ └── model) +│ │ │ │ │ │ └── resources) +│ │ │ │ │ └── test) +│ │ │ │ │ └── java) +│ │ │ │ │ └── com) +│ │ │ │ │ └── lambda) +│ │ │ │ │ └── clientrestaurants) +│ │ │ │ ├── [hi](./restaurants-initial) +│ │ │ │ │ ├── [hi](./src) +│ │ │ │ │ │ └── main) +│ │ │ │ │ │ ├── [hi](./java) +│ │ │ │ │ │ │ └── com) +│ │ │ │ │ │ │ └── lambdaschool) +│ │ │ │ │ │ │ └── restaurants) +│ │ │ │ │ │ │ ├── [hi](./config) +│ │ │ │ │ │ │ ├── [hi](./controller) +│ │ │ │ │ │ │ ├── [hi](./model) +│ │ │ │ │ │ │ ├── [hi](./repos) +│ │ │ │ │ │ │ └── service) +│ │ │ │ │ │ └── resources) +│ │ │ │ │ │ └── info) +│ │ │ │ │ └── target) +│ │ │ │ │ ├── [hi](./classes) +│ │ │ │ │ │ ├── [hi](./com) +│ │ │ │ │ │ │ └── lambdaschool) +│ │ │ │ │ │ │ └── restaurants) +│ │ │ │ │ │ │ ├── [hi](./config) +│ │ │ │ │ │ │ ├── [hi](./controller) +│ │ │ │ │ │ │ ├── [hi](./model) +│ │ │ │ │ │ │ ├── [hi](./repos) +│ │ │ │ │ │ │ └── service) +│ │ │ │ │ │ └── info) +│ │ │ │ │ ├── [hi](./failsafe-reports) +│ │ │ │ │ ├── [hi](./maven-archiver) +│ │ │ │ │ ├── [hi](./maven-status) +│ │ │ │ │ │ └── maven-compiler-plugin) +│ │ │ │ │ │ ├── [hi](./compile) +│ │ │ │ │ │ │ └── default-compile) +│ │ │ │ │ │ └── testCompile) +│ │ │ │ │ │ └── default-testCompile) +│ │ │ │ │ └── surefire-reports) +│ │ │ │ └── restaurants-pagesswagger) +│ │ │ │ ├── [hi](./src) +│ │ │ │ │ └── main) +│ │ │ │ │ ├── [hi](./java) +│ │ │ │ │ │ └── com) +│ │ │ │ │ │ └── lambdaschool) +│ │ │ │ │ │ └── restaurants) +│ │ │ │ │ │ ├── [hi](./config) +│ │ │ │ │ │ ├── [hi](./controller) +│ │ │ │ │ │ ├── [hi](./exception) +│ │ │ │ │ │ ├── [hi](./model) +│ │ │ │ │ │ ├── [hi](./repos) +│ │ │ │ │ │ └── service) +│ │ │ │ │ └── resources) +│ │ │ │ │ ├── [hi](./info) +│ │ │ │ │ └── templates) +│ │ │ │ └── target) +│ │ │ │ ├── [hi](./classes) +│ │ │ │ │ ├── [hi](./info) +│ │ │ │ │ └── templates) +│ │ │ │ ├── [hi](./heroku) +│ │ │ │ │ └── app) +│ │ │ │ ├── [hi](./maven-archiver) +│ │ │ │ └── maven-status) +│ │ │ │ └── maven-compiler-plugin) +│ │ │ │ ├── [hi](./compile) +│ │ │ │ │ └── default-compile) +│ │ │ │ └── testCompile) +│ │ │ │ └── default-testCompile) +│ │ │ ├── [hi](./53c1) +│ │ │ │ ├── [hi](./restaurants-initial) +│ │ │ │ │ └── src) +│ │ │ │ │ └── main) +│ │ │ │ │ ├── [hi](./java) +│ │ │ │ │ │ └── com) +│ │ │ │ │ │ └── lambdaschool) +│ │ │ │ │ │ └── restaurants) +│ │ │ │ │ │ ├── [hi](./config) +│ │ │ │ │ │ ├── [hi](./controller) +│ │ │ │ │ │ ├── [hi](./model) +│ │ │ │ │ │ ├── [hi](./repos) +│ │ │ │ │ │ └── service) +│ │ │ │ │ └── resources) +│ │ │ │ │ └── info) +│ │ │ │ └── restaurants-testing) +│ │ │ │ └── src) +│ │ │ │ ├── [hi](./main) +│ │ │ │ │ ├── [hi](./java) +│ │ │ │ │ │ └── com) +│ │ │ │ │ │ └── lambdaschool) +│ │ │ │ │ │ └── restaurants) +│ │ │ │ │ │ ├── [hi](./config) +│ │ │ │ │ │ ├── [hi](./controller) +│ │ │ │ │ │ ├── [hi](./model) +│ │ │ │ │ │ ├── [hi](./repos) +│ │ │ │ │ │ └── service) +│ │ │ │ │ └── resources) +│ │ │ │ │ └── info) +│ │ │ │ └── test) +│ │ │ │ ├── [hi](./java) +│ │ │ │ │ └── com) +│ │ │ │ │ └── lambdaschool) +│ │ │ │ │ └── restaurants) +│ │ │ │ │ ├── [hi](./controller) +│ │ │ │ │ └── service) +│ │ │ │ └── resources) +│ │ │ └── 53d1) +│ │ │ ├── [hi](./JS-FrontEnd-by-jheinz1999) +│ │ │ │ ├── [hi](./public) +│ │ │ │ └── src) +│ │ │ │ └── components) +│ │ │ └── StartHere) +│ │ │ └── src) +│ │ │ ├── [hi](./main) +│ │ │ │ ├── [hi](./java) +│ │ │ │ │ └── com) +│ │ │ │ │ └── lambdaschool) +│ │ │ │ │ └── starthere) +│ │ │ │ │ ├── [hi](./config) +│ │ │ │ │ ├── [hi](./controllers) +│ │ │ │ │ ├── [hi](./exceptions) +│ │ │ │ │ ├── [hi](./handlers) +│ │ │ │ │ ├── [hi](./logging) +│ │ │ │ │ ├── [hi](./models) +│ │ │ │ │ ├── [hi](./repository) +│ │ │ │ │ ├── [hi](./services) +│ │ │ │ │ └── view) +│ │ │ │ └── resources) +│ │ │ │ └── info) +│ │ │ └── test) +│ │ │ ├── [hi](./java) +│ │ │ │ └── com) +│ │ │ │ └── lambdaschool) +│ │ │ │ └── starthere) +│ │ │ │ ├── [hi](./controllers) +│ │ │ │ └── services) +│ │ │ └── resources) +│ │ ├── [hi](./m6) +│ │ │ ├── [hi](./61a1) +│ │ │ │ └── src) +│ │ │ ├── [hi](./61b1) +│ │ │ │ ├── [hi](./examples) +│ │ │ │ └── src) +│ │ │ ├── [hi](./61c1) +│ │ │ │ └── src) +│ │ │ │ ├── [hi](./cityreader) +│ │ │ │ │ └── __pycache__) +│ │ │ │ ├── [hi](./comp) +│ │ │ │ │ └── __pycache__) +│ │ │ │ └── oop) +│ │ │ │ └── __pycache__) +│ │ │ ├── [hi](./62a1) +│ │ │ │ ├── [hi](./avl_tree) +│ │ │ │ ├── [hi](./benchmarks) +│ │ │ │ ├── [hi](./binary_search_tree) +│ │ │ │ ├── [hi](./doubly_linked_list) +│ │ │ │ ├── [hi](./heap) +│ │ │ │ ├── [hi](./lru_cache) +│ │ │ │ ├── [hi](./queue) +│ │ │ │ ├── [hi](./queue_and_stack) +│ │ │ │ ├── [hi](./singly_linked_list) +│ │ │ │ └── stack) +│ │ │ ├── [hi](./62b1) +│ │ │ │ ├── [hi](./names) +│ │ │ │ ├── [hi](./reverse) +│ │ │ │ └── ring_buffer) +│ │ │ ├── [hi](./63a1) +│ │ │ │ └── src) +│ │ │ │ ├── [hi](./iterative_sorting) +│ │ │ │ └── searching) +│ │ │ ├── [hi](./63b1) +│ │ │ │ └── src) +│ │ │ │ └── recursive_sorting) +│ │ │ │ └── __pycache__) +│ │ │ ├── [hi](./63c1) +│ │ │ │ ├── [hi](./eating_cookies) +│ │ │ │ ├── [hi](./knapsack) +│ │ │ │ │ └── data) +│ │ │ │ ├── [hi](./making_change) +│ │ │ │ ├── [hi](./moving_zeroes) +│ │ │ │ ├── [hi](./product_of_all_other_numbers) +│ │ │ │ ├── [hi](./recipe_batches) +│ │ │ │ ├── [hi](./rock_paper_scissors) +│ │ │ │ ├── [hi](./single_number) +│ │ │ │ ├── [hi](./sliding_window_max) +│ │ │ │ │ └── data) +│ │ │ │ └── stock_prices) +│ │ │ └── 63d1) +│ │ │ ├── [hi](./recursive_count_th) +│ │ │ ├── [hi](./robot_sort) +│ │ │ └── Short-Answer) +│ │ ├── [hi](./m7) +│ │ │ ├── [hi](./71a1) +│ │ │ │ ├── [hi](./applications) +│ │ │ │ │ ├── [hi](./crack_caesar) +│ │ │ │ │ ├── [hi](./expensive_seq) +│ │ │ │ │ ├── [hi](./histo) +│ │ │ │ │ ├── [hi](./lookup_table) +│ │ │ │ │ ├── [hi](./markov) +│ │ │ │ │ ├── [hi](./no_dups) +│ │ │ │ │ ├── [hi](./sumdiff) +│ │ │ │ │ └── word_count) +│ │ │ │ └── hashtable) +│ │ │ ├── [hi](./71e1) +│ │ │ │ └── hashtables) +│ │ │ │ ├── [hi](./ex1) +│ │ │ │ ├── [hi](./ex2) +│ │ │ │ ├── [hi](./ex3) +│ │ │ │ ├── [hi](./ex4) +│ │ │ │ └── ex5) +│ │ │ ├── [hi](./72a1) +│ │ │ │ ├── [hi](./objectives) +│ │ │ │ │ ├── [hi](./breadth-first-search) +│ │ │ │ │ │ └── img) +│ │ │ │ │ ├── [hi](./connected-components) +│ │ │ │ │ │ └── img) +│ │ │ │ │ ├── [hi](./depth-first-search) +│ │ │ │ │ │ └── img) +│ │ │ │ │ ├── [hi](./graph-intro) +│ │ │ │ │ │ └── img) +│ │ │ │ │ ├── [hi](./graph-representations) +│ │ │ │ │ │ └── img) +│ │ │ │ │ └── randomness) +│ │ │ │ └── projects) +│ │ │ │ ├── [hi](./adventure) +│ │ │ │ │ └── maps) +│ │ │ │ ├── [hi](./ancestor) +│ │ │ │ ├── [hi](./graph) +│ │ │ │ └── social) +│ │ │ ├── [hi](./73a1) +│ │ │ │ ├── [hi](./asm) +│ │ │ │ └── ls8) +│ │ │ │ └── examples) +│ │ │ └── 74a1) +│ │ ├── [hi](./node_modules) +│ │ ├── [hi](./src) +│ │ │ ├── [hi](./iterative_sorting) +│ │ │ └── searching) +│ │ ├── [hi](./summary) +│ │ │ ├── [hi](./certifications) +│ │ │ │ ├── [hi](./IBM zOS) +│ │ │ │ └── Oracle Autonomous DB) +│ │ │ │ ├── [hi](./1 Overview) +│ │ │ │ ├── [hi](./2 Provisioning and Connectivity) +│ │ │ │ ├── [hi](./3 Migration and Data Loding into Autonomous DB) +│ │ │ │ ├── [hi](./4 Migrating and Data Loading) +│ │ │ │ ├── [hi](./5 Monitoring Autonomous DB) +│ │ │ │ └── 6 Tools Reporting Analytics) +│ │ │ ├── [hi](./cobol) +│ │ │ │ ├── [hi](./COBOL example programs_files) +│ │ │ │ ├── [hi](./COBOL Programming Course_files) +│ │ │ │ └── COBOL Programming Exercises_files) +│ │ │ ├── [hi](./complete) +│ │ │ │ ├── [hi](./Decks) +│ │ │ │ └── notes-books) +│ │ │ ├── [hi](./general) +│ │ │ ├── [hi](./interviewing) +│ │ │ ├── [hi](./Node Express Knex) +│ │ │ │ └── Create Back End Guide) +│ │ │ ├── [hi](./testing) +│ │ │ └── typescript) +│ │ └── tlbw) +│ │ └── client) +│ │ ├── [hi](./public) +│ │ └── src) +│ │ ├── [hi](./components) +│ │ │ ├── [hi](./context) +│ │ │ │ └── strainsSelectContext) +│ │ │ └── strains) +│ │ └── imgs) +│ ├── [hi](./React-Todo-Solution-master) +│ │ ├── [hi](./public) +│ │ └── src) +│ │ └── tests) +│ ├── [hi](./_Sprint-Resources) +│ │ └── Sprint Challenge Study Guide - Unit 1, Sprint 1) +│ ├── [hi](./_Templates-Frameworks-And-Official-Repos) +│ │ ├── [hi](./ant-design-master) +│ │ │ ├── [hi](./components) +│ │ │ │ ├── [hi](./affix) +│ │ │ │ │ ├── [hi](./demo) +│ │ │ │ │ ├── [hi](./style) +│ │ │ │ │ └── __tests__) +│ │ │ │ │ └── __snapshots__) +│ │ │ │ ├── [hi](./alert) +│ │ │ │ │ ├── [hi](./demo) +│ │ │ │ │ ├── [hi](./style) +│ │ │ │ │ └── __tests__) +│ │ │ │ │ └── __snapshots__) +│ │ │ │ ├── [hi](./anchor) +│ │ │ │ │ ├── [hi](./demo) +│ │ │ │ │ ├── [hi](./style) +│ │ │ │ │ └── __tests__) +│ │ │ │ │ └── __snapshots__) +│ │ │ │ ├── [hi](./auto-complete) +│ │ │ │ │ ├── [hi](./demo) +│ │ │ │ │ ├── [hi](./style) +│ │ │ │ │ └── __tests__) +│ │ │ │ │ └── __snapshots__) +│ │ │ │ ├── [hi](./avatar) +│ │ │ │ │ ├── [hi](./demo) +│ │ │ │ │ ├── [hi](./style) +│ │ │ │ │ └── __tests__) +│ │ │ │ │ └── __snapshots__) +│ │ │ │ ├── [hi](./back-top) +│ │ │ │ │ ├── [hi](./demo) +│ │ │ │ │ ├── [hi](./style) +│ │ │ │ │ └── __tests__) +│ │ │ │ │ └── __snapshots__) +│ │ │ │ ├── [hi](./badge) +│ │ │ │ │ ├── [hi](./demo) +│ │ │ │ │ ├── [hi](./style) +│ │ │ │ │ └── __tests__) +│ │ │ │ │ └── __snapshots__) +│ │ │ │ ├── [hi](./breadcrumb) +│ │ │ │ │ ├── [hi](./demo) +│ │ │ │ │ ├── [hi](./style) +│ │ │ │ │ └── __tests__) +│ │ │ │ │ └── __snapshots__) +│ │ │ │ ├── [hi](./button) +│ │ │ │ │ ├── [hi](./demo) +│ │ │ │ │ ├── [hi](./style) +│ │ │ │ │ └── __tests__) +│ │ │ │ │ └── __snapshots__) +│ │ │ │ ├── [hi](./calendar) +│ │ │ │ │ ├── [hi](./demo) +│ │ │ │ │ ├── [hi](./locale) +│ │ │ │ │ ├── [hi](./style) +│ │ │ │ │ └── __tests__) +│ │ │ │ │ └── __snapshots__) +│ │ │ │ ├── [hi](./card) +│ │ │ │ │ ├── [hi](./demo) +│ │ │ │ │ ├── [hi](./style) +│ │ │ │ │ └── __tests__) +│ │ │ │ │ └── __snapshots__) +│ │ │ │ ├── [hi](./carousel) +│ │ │ │ │ ├── [hi](./demo) +│ │ │ │ │ ├── [hi](./style) +│ │ │ │ │ └── __tests__) +│ │ │ │ │ └── __snapshots__) +│ │ │ │ ├── [hi](./cascader) +│ │ │ │ │ ├── [hi](./demo) +│ │ │ │ │ ├── [hi](./style) +│ │ │ │ │ └── __tests__) +│ │ │ │ │ └── __snapshots__) +│ │ │ │ ├── [hi](./checkbox) +│ │ │ │ │ ├── [hi](./demo) +│ │ │ │ │ ├── [hi](./style) +│ │ │ │ │ └── __tests__) +│ │ │ │ │ └── __snapshots__) +│ │ │ │ ├── [hi](./col) +│ │ │ │ │ └── style) +│ │ │ │ ├── [hi](./collapse) +│ │ │ │ │ ├── [hi](./demo) +│ │ │ │ │ ├── [hi](./style) +│ │ │ │ │ └── __tests__) +│ │ │ │ │ └── __snapshots__) +│ │ │ │ ├── [hi](./comment) +│ │ │ │ │ ├── [hi](./demo) +│ │ │ │ │ ├── [hi](./style) +│ │ │ │ │ └── __tests__) +│ │ │ │ │ └── __snapshots__) +│ │ │ │ ├── [hi](./config-provider) +│ │ │ │ │ ├── [hi](./demo) +│ │ │ │ │ ├── [hi](./style) +│ │ │ │ │ └── __tests__) +│ │ │ │ │ └── __snapshots__) +│ │ │ │ ├── [hi](./date-picker) +│ │ │ │ │ ├── [hi](./demo) +│ │ │ │ │ ├── [hi](./generatePicker) +│ │ │ │ │ ├── [hi](./locale) +│ │ │ │ │ ├── [hi](./style) +│ │ │ │ │ └── __tests__) +│ │ │ │ │ └── __snapshots__) +│ │ │ │ ├── [hi](./descriptions) +│ │ │ │ │ ├── [hi](./demo) +│ │ │ │ │ ├── [hi](./style) +│ │ │ │ │ └── __tests__) +│ │ │ │ │ └── __snapshots__) +│ │ │ │ ├── [hi](./divider) +│ │ │ │ │ ├── [hi](./demo) +│ │ │ │ │ ├── [hi](./style) +│ │ │ │ │ └── __tests__) +│ │ │ │ │ └── __snapshots__) +│ │ │ │ ├── [hi](./drawer) +│ │ │ │ │ ├── [hi](./demo) +│ │ │ │ │ ├── [hi](./style) +│ │ │ │ │ └── __tests__) +│ │ │ │ │ └── __snapshots__) +│ │ │ │ ├── [hi](./dropdown) +│ │ │ │ │ ├── [hi](./demo) +│ │ │ │ │ ├── [hi](./style) +│ │ │ │ │ └── __tests__) +│ │ │ │ │ └── __snapshots__) +│ │ │ │ ├── [hi](./empty) +│ │ │ │ │ ├── [hi](./demo) +│ │ │ │ │ ├── [hi](./style) +│ │ │ │ │ └── __tests__) +│ │ │ │ │ └── __snapshots__) +│ │ │ │ ├── [hi](./form) +│ │ │ │ │ ├── [hi](./demo) +│ │ │ │ │ ├── [hi](./hooks) +│ │ │ │ │ ├── [hi](./style) +│ │ │ │ │ └── __tests__) +│ │ │ │ │ └── __snapshots__) +│ │ │ │ ├── [hi](./grid) +│ │ │ │ │ ├── [hi](./demo) +│ │ │ │ │ ├── [hi](./hooks) +│ │ │ │ │ ├── [hi](./style) +│ │ │ │ │ └── __tests__) +│ │ │ │ │ └── __snapshots__) +│ │ │ │ ├── [hi](./icon) +│ │ │ │ │ ├── [hi](./demo) +│ │ │ │ │ ├── [hi](./style) +│ │ │ │ │ └── __tests__) +│ │ │ │ ├── [hi](./image) +│ │ │ │ │ ├── [hi](./demo) +│ │ │ │ │ ├── [hi](./style) +│ │ │ │ │ └── __tests__) +│ │ │ │ │ └── __snapshots__) +│ │ │ │ ├── [hi](./input) +│ │ │ │ │ ├── [hi](./demo) +│ │ │ │ │ ├── [hi](./style) +│ │ │ │ │ └── __tests__) +│ │ │ │ │ └── __snapshots__) +│ │ │ │ ├── [hi](./input-number) +│ │ │ │ │ ├── [hi](./demo) +│ │ │ │ │ ├── [hi](./style) +│ │ │ │ │ └── __tests__) +│ │ │ │ │ └── __snapshots__) +│ │ │ │ ├── [hi](./layout) +│ │ │ │ │ ├── [hi](./demo) +│ │ │ │ │ ├── [hi](./style) +│ │ │ │ │ └── __tests__) +│ │ │ │ │ └── __snapshots__) +│ │ │ │ ├── [hi](./list) +│ │ │ │ │ ├── [hi](./demo) +│ │ │ │ │ ├── [hi](./style) +│ │ │ │ │ └── __tests__) +│ │ │ │ │ └── __snapshots__) +│ │ │ │ ├── [hi](./locale) +│ │ │ │ ├── [hi](./locale-provider) +│ │ │ │ │ ├── [hi](./style) +│ │ │ │ │ └── __tests__) +│ │ │ │ │ └── __snapshots__) +│ │ │ │ ├── [hi](./mentions) +│ │ │ │ │ ├── [hi](./demo) +│ │ │ │ │ ├── [hi](./style) +│ │ │ │ │ └── __tests__) +│ │ │ │ │ └── __snapshots__) +│ │ │ │ ├── [hi](./menu) +│ │ │ │ │ ├── [hi](./demo) +│ │ │ │ │ ├── [hi](./style) +│ │ │ │ │ └── __tests__) +│ │ │ │ │ └── __snapshots__) +│ │ │ │ ├── [hi](./message) +│ │ │ │ │ ├── [hi](./demo) +│ │ │ │ │ ├── [hi](./hooks) +│ │ │ │ │ ├── [hi](./style) +│ │ │ │ │ └── __tests__) +│ │ │ │ │ └── __snapshots__) +│ │ │ │ ├── [hi](./modal) +│ │ │ │ │ ├── [hi](./demo) +│ │ │ │ │ ├── [hi](./style) +│ │ │ │ │ ├── [hi](./__tests__) +│ │ │ │ │ │ └── __snapshots__) +│ │ │ │ │ └── useModal) +│ │ │ │ ├── [hi](./notification) +│ │ │ │ │ ├── [hi](./demo) +│ │ │ │ │ ├── [hi](./hooks) +│ │ │ │ │ ├── [hi](./style) +│ │ │ │ │ └── __tests__) +│ │ │ │ │ └── __snapshots__) +│ │ │ │ ├── [hi](./overview) +│ │ │ │ ├── [hi](./page-header) +│ │ │ │ │ ├── [hi](./demo) +│ │ │ │ │ ├── [hi](./style) +│ │ │ │ │ └── __tests__) +│ │ │ │ │ └── __snapshots__) +│ │ │ │ ├── [hi](./pagination) +│ │ │ │ │ ├── [hi](./demo) +│ │ │ │ │ ├── [hi](./style) +│ │ │ │ │ └── __tests__) +│ │ │ │ │ └── __snapshots__) +│ │ │ │ ├── [hi](./popconfirm) +│ │ │ │ │ ├── [hi](./demo) +│ │ │ │ │ ├── [hi](./style) +│ │ │ │ │ └── __tests__) +│ │ │ │ │ └── __snapshots__) +│ │ │ │ ├── [hi](./popover) +│ │ │ │ │ ├── [hi](./demo) +│ │ │ │ │ ├── [hi](./style) +│ │ │ │ │ └── __tests__) +│ │ │ │ │ └── __snapshots__) +│ │ │ │ ├── [hi](./progress) +│ │ │ │ │ ├── [hi](./demo) +│ │ │ │ │ ├── [hi](./style) +│ │ │ │ │ └── __tests__) +│ │ │ │ │ └── __snapshots__) +│ │ │ │ ├── [hi](./radio) +│ │ │ │ │ ├── [hi](./demo) +│ │ │ │ │ ├── [hi](./style) +│ │ │ │ │ └── __tests__) +│ │ │ │ │ └── __snapshots__) +│ │ │ │ ├── [hi](./rate) +│ │ │ │ │ ├── [hi](./demo) +│ │ │ │ │ ├── [hi](./style) +│ │ │ │ │ └── __tests__) +│ │ │ │ │ └── __snapshots__) +│ │ │ │ ├── [hi](./result) +│ │ │ │ │ ├── [hi](./demo) +│ │ │ │ │ ├── [hi](./style) +│ │ │ │ │ └── __tests__) +│ │ │ │ │ └── __snapshots__) +│ │ │ │ ├── [hi](./row) +│ │ │ │ │ └── style) +│ │ │ │ ├── [hi](./select) +│ │ │ │ │ ├── [hi](./demo) +│ │ │ │ │ ├── [hi](./style) +│ │ │ │ │ ├── [hi](./__tests__) +│ │ │ │ │ │ └── __snapshots__) +│ │ │ │ │ └── utils) +│ │ │ │ ├── [hi](./skeleton) +│ │ │ │ │ ├── [hi](./demo) +│ │ │ │ │ ├── [hi](./style) +│ │ │ │ │ └── __tests__) +│ │ │ │ │ └── __snapshots__) +│ │ │ │ ├── [hi](./slider) +│ │ │ │ │ ├── [hi](./demo) +│ │ │ │ │ ├── [hi](./style) +│ │ │ │ │ └── __tests__) +│ │ │ │ │ └── __snapshots__) +│ │ │ │ ├── [hi](./space) +│ │ │ │ │ ├── [hi](./demo) +│ │ │ │ │ ├── [hi](./style) +│ │ │ │ │ └── __tests__) +│ │ │ │ │ └── __snapshots__) +│ │ │ │ ├── [hi](./spin) +│ │ │ │ │ ├── [hi](./demo) +│ │ │ │ │ ├── [hi](./style) +│ │ │ │ │ └── __tests__) +│ │ │ │ │ └── __snapshots__) +│ │ │ │ ├── [hi](./statistic) +│ │ │ │ │ ├── [hi](./demo) +│ │ │ │ │ ├── [hi](./style) +│ │ │ │ │ └── __tests__) +│ │ │ │ │ └── __snapshots__) +│ │ │ │ ├── [hi](./steps) +│ │ │ │ │ ├── [hi](./demo) +│ │ │ │ │ ├── [hi](./style) +│ │ │ │ │ └── __tests__) +│ │ │ │ │ └── __snapshots__) +│ │ │ │ ├── [hi](./style) +│ │ │ │ │ ├── [hi](./color) +│ │ │ │ │ ├── [hi](./core) +│ │ │ │ │ │ └── motion) +│ │ │ │ │ ├── [hi](./mixins) +│ │ │ │ │ └── themes) +│ │ │ │ ├── [hi](./switch) +│ │ │ │ │ ├── [hi](./demo) +│ │ │ │ │ ├── [hi](./style) +│ │ │ │ │ └── __tests__) +│ │ │ │ │ └── __snapshots__) +│ │ │ │ ├── [hi](./table) +│ │ │ │ │ ├── [hi](./demo) +│ │ │ │ │ ├── [hi](./hooks) +│ │ │ │ │ │ └── useFilter) +│ │ │ │ │ ├── [hi](./style) +│ │ │ │ │ └── __tests__) +│ │ │ │ │ └── __snapshots__) +│ │ │ │ ├── [hi](./tabs) +│ │ │ │ │ ├── [hi](./demo) +│ │ │ │ │ ├── [hi](./style) +│ │ │ │ │ └── __tests__) +│ │ │ │ │ └── __snapshots__) +│ │ │ │ ├── [hi](./tag) +│ │ │ │ │ ├── [hi](./demo) +│ │ │ │ │ ├── [hi](./style) +│ │ │ │ │ └── __tests__) +│ │ │ │ │ └── __snapshots__) +│ │ │ │ ├── [hi](./__tests__) +│ │ │ │ │ └── __snapshots__) +│ │ │ │ ├── [hi](./timeline) +│ │ │ │ │ ├── [hi](./demo) +│ │ │ │ │ ├── [hi](./style) +│ │ │ │ │ └── __tests__) +│ │ │ │ │ └── __snapshots__) +│ │ │ │ ├── [hi](./time-picker) +│ │ │ │ │ ├── [hi](./demo) +│ │ │ │ │ ├── [hi](./locale) +│ │ │ │ │ ├── [hi](./style) +│ │ │ │ │ └── __tests__) +│ │ │ │ │ └── __snapshots__) +│ │ │ │ ├── [hi](./tooltip) +│ │ │ │ │ ├── [hi](./demo) +│ │ │ │ │ ├── [hi](./style) +│ │ │ │ │ └── __tests__) +│ │ │ │ │ └── __snapshots__) +│ │ │ │ ├── [hi](./transfer) +│ │ │ │ │ ├── [hi](./demo) +│ │ │ │ │ ├── [hi](./style) +│ │ │ │ │ └── __tests__) +│ │ │ │ │ └── __snapshots__) +│ │ │ │ ├── [hi](./tree) +│ │ │ │ │ ├── [hi](./demo) +│ │ │ │ │ ├── [hi](./style) +│ │ │ │ │ ├── [hi](./__tests__) +│ │ │ │ │ │ └── __snapshots__) +│ │ │ │ │ └── utils) +│ │ │ │ ├── [hi](./tree-select) +│ │ │ │ │ ├── [hi](./demo) +│ │ │ │ │ ├── [hi](./style) +│ │ │ │ │ └── __tests__) +│ │ │ │ │ └── __snapshots__) +│ │ │ │ ├── [hi](./typography) +│ │ │ │ │ ├── [hi](./demo) +│ │ │ │ │ ├── [hi](./style) +│ │ │ │ │ └── __tests__) +│ │ │ │ │ └── __snapshots__) +│ │ │ │ ├── [hi](./upload) +│ │ │ │ │ ├── [hi](./demo) +│ │ │ │ │ ├── [hi](./style) +│ │ │ │ │ ├── [hi](./__tests__) +│ │ │ │ │ │ └── __snapshots__) +│ │ │ │ │ └── UploadList) +│ │ │ │ ├── [hi](./_util) +│ │ │ │ │ ├── [hi](./hooks) +│ │ │ │ │ └── __tests__) +│ │ │ │ └── version) +│ │ │ │ └── style) +│ │ │ ├── [hi](./docs) +│ │ │ │ ├── [hi](./react) +│ │ │ │ └── spec) +│ │ │ ├── [hi](./scripts) +│ │ │ │ └── previewEditor) +│ │ │ ├── [hi](./site) +│ │ │ │ └── theme) +│ │ │ │ ├── [hi](./static) +│ │ │ │ └── template) +│ │ │ │ ├── [hi](./Color) +│ │ │ │ ├── [hi](./Content) +│ │ │ │ │ └── Demo) +│ │ │ │ ├── [hi](./Home) +│ │ │ │ │ ├── [hi](./Banner) +│ │ │ │ │ └── DesignPage) +│ │ │ │ ├── [hi](./Icon) +│ │ │ │ ├── [hi](./IconDisplay) +│ │ │ │ ├── [hi](./Layout) +│ │ │ │ │ └── Header) +│ │ │ │ └── Resources) +│ │ │ │ └── Articles) +│ │ │ ├── [hi](./tests) +│ │ │ │ ├── [hi](./dekko) +│ │ │ │ ├── [hi](./matchers) +│ │ │ │ ├── [hi](./__mocks__) +│ │ │ │ │ └── rc-util) +│ │ │ │ │ └── lib) +│ │ │ │ ├── [hi](./shared) +│ │ │ │ └── __snapshots__) +│ │ │ └── typings) +│ │ └── material-components-web-master) +│ │ ├── [hi](./docs) +│ │ │ ├── [hi](./code) +│ │ │ ├── [hi](./codelabs) +│ │ │ ├── [hi](./contribute) +│ │ │ └── open_source) +│ │ ├── [hi](./packages) +│ │ │ ├── [hi](./material-components-web) +│ │ │ ├── [hi](./mdc-animation) +│ │ │ │ └── test) +│ │ │ ├── [hi](./mdc-auto-init) +│ │ │ │ └── test) +│ │ │ ├── [hi](./mdc-banner) +│ │ │ │ ├── [hi](./images) +│ │ │ │ └── test) +│ │ │ ├── [hi](./mdc-base) +│ │ │ │ └── test) +│ │ │ ├── [hi](./mdc-button) +│ │ │ │ ├── [hi](./images) +│ │ │ │ └── test) +│ │ │ ├── [hi](./mdc-card) +│ │ │ │ ├── [hi](./images) +│ │ │ │ └── test) +│ │ │ ├── [hi](./mdc-checkbox) +│ │ │ │ ├── [hi](./images) +│ │ │ │ └── test) +│ │ │ ├── [hi](./mdc-chips) +│ │ │ │ ├── [hi](./action) +│ │ │ │ │ └── test) +│ │ │ │ ├── [hi](./chip) +│ │ │ │ │ └── test) +│ │ │ │ ├── [hi](./chip-set) +│ │ │ │ │ └── test) +│ │ │ │ └── deprecated) +│ │ │ │ ├── [hi](./chip) +│ │ │ │ │ └── test) +│ │ │ │ ├── [hi](./chip-set) +│ │ │ │ │ └── test) +│ │ │ │ ├── [hi](./test) +│ │ │ │ └── trailingaction) +│ │ │ │ └── test) +│ │ │ ├── [hi](./mdc-circular-progress) +│ │ │ │ └── test) +│ │ │ ├── [hi](./mdc-data-table) +│ │ │ │ ├── [hi](./images) +│ │ │ │ └── test) +│ │ │ ├── [hi](./mdc-density) +│ │ │ ├── [hi](./mdc-dialog) +│ │ │ │ ├── [hi](./images) +│ │ │ │ └── test) +│ │ │ ├── [hi](./mdc-dom) +│ │ │ │ └── test) +│ │ │ ├── [hi](./mdc-drawer) +│ │ │ │ ├── [hi](./dismissible) +│ │ │ │ │ └── test) +│ │ │ │ ├── [hi](./images) +│ │ │ │ ├── [hi](./modal) +│ │ │ │ │ └── test) +│ │ │ │ └── test) +│ │ │ ├── [hi](./mdc-elevation) +│ │ │ │ └── test) +│ │ │ ├── [hi](./mdc-fab) +│ │ │ │ ├── [hi](./images) +│ │ │ │ └── test) +│ │ │ ├── [hi](./mdc-feature-targeting) +│ │ │ ├── [hi](./mdc-floating-label) +│ │ │ │ └── test) +│ │ │ ├── [hi](./mdc-form-field) +│ │ │ │ └── test) +│ │ │ ├── [hi](./mdc-icon-button) +│ │ │ │ └── test) +│ │ │ ├── [hi](./mdc-image-list) +│ │ │ │ └── test) +│ │ │ ├── [hi](./mdc-layout-grid) +│ │ │ ├── [hi](./mdc-linear-progress) +│ │ │ │ └── test) +│ │ │ ├── [hi](./mdc-line-ripple) +│ │ │ │ └── test) +│ │ │ ├── [hi](./mdc-list) +│ │ │ │ ├── [hi](./images) +│ │ │ │ └── test) +│ │ │ ├── [hi](./mdc-menu) +│ │ │ │ └── test) +│ │ │ ├── [hi](./mdc-menu-surface) +│ │ │ │ └── test) +│ │ │ ├── [hi](./mdc-notched-outline) +│ │ │ │ └── test) +│ │ │ ├── [hi](./mdc-progress-indicator) +│ │ │ ├── [hi](./mdc-radio) +│ │ │ │ ├── [hi](./images) +│ │ │ │ └── test) +│ │ │ ├── [hi](./mdc-ripple) +│ │ │ │ └── test) +│ │ │ ├── [hi](./mdc-rtl) +│ │ │ │ └── test) +│ │ │ ├── [hi](./mdc-segmented-button) +│ │ │ │ ├── [hi](./segment) +│ │ │ │ │ └── test) +│ │ │ │ └── segmented-button) +│ │ │ │ └── test) +│ │ │ ├── [hi](./mdc-select) +│ │ │ │ ├── [hi](./helper-text) +│ │ │ │ │ └── test) +│ │ │ │ ├── [hi](./icon) +│ │ │ │ │ └── test) +│ │ │ │ └── test) +│ │ │ ├── [hi](./mdc-shape) +│ │ │ │ └── test) +│ │ │ ├── [hi](./mdc-slider) +│ │ │ │ ├── [hi](./images) +│ │ │ │ └── test) +│ │ │ ├── [hi](./mdc-snackbar) +│ │ │ │ └── test) +│ │ │ ├── [hi](./mdc-switch) +│ │ │ │ ├── [hi](./images) +│ │ │ │ └── test) +│ │ │ ├── [hi](./mdc-tab) +│ │ │ │ └── test) +│ │ │ ├── [hi](./mdc-tab-bar) +│ │ │ │ └── test) +│ │ │ ├── [hi](./mdc-tab-indicator) +│ │ │ │ └── test) +│ │ │ ├── [hi](./mdc-tab-scroller) +│ │ │ │ └── test) +│ │ │ ├── [hi](./mdc-textfield) +│ │ │ │ ├── [hi](./character-counter) +│ │ │ │ │ └── test) +│ │ │ │ ├── [hi](./helper-text) +│ │ │ │ │ └── test) +│ │ │ │ ├── [hi](./icon) +│ │ │ │ │ └── test) +│ │ │ │ ├── [hi](./images) +│ │ │ │ └── test) +│ │ │ ├── [hi](./mdc-theme) +│ │ │ │ └── test) +│ │ │ ├── [hi](./mdc-tooltip) +│ │ │ │ ├── [hi](./images) +│ │ │ │ └── test) +│ │ │ ├── [hi](./mdc-top-app-bar) +│ │ │ │ ├── [hi](./fixed) +│ │ │ │ │ └── test) +│ │ │ │ ├── [hi](./images) +│ │ │ │ ├── [hi](./short) +│ │ │ │ │ └── test) +│ │ │ │ ├── [hi](./standard) +│ │ │ │ │ └── test) +│ │ │ │ └── test) +│ │ │ ├── [hi](./mdc-touch-target) +│ │ │ │ └── test) +│ │ │ └── mdc-typography) +│ │ │ └── test) +│ │ ├── [hi](./scripts) +│ │ │ ├── [hi](./build) +│ │ │ ├── [hi](./documentation) +│ │ │ └── webpack) +│ │ └── testing) +│ │ ├── [hi](./dom) +│ │ ├── [hi](./featuretargeting) +│ │ └── helpers) +│ └── web-guided-project-testing-web-apps-solution-main) +│ ├── [hi](./public) +│ └── src) +│ └── components) +├── [hi](./3-misc) +│ ├── [hi](./articles-from-interwebs) +│ │ └── Jquery-tips-n-tricks_files) +│ ├── [hi](./Beginner) +│ │ ├── [hi](./capSentence) +│ │ ├── [hi](./chunkArray) +│ │ ├── [hi](./factorial) +│ │ ├── [hi](./falsyBouncer) +│ │ ├── [hi](./fibonacci) +│ │ ├── [hi](./fizzBuzz) +│ │ ├── [hi](./hammingDistance) +│ │ ├── [hi](./isAnagram) +│ │ ├── [hi](./longestWord) +│ │ ├── [hi](./maxRecurringChar) +│ │ ├── [hi](./mergeArrays) +│ │ ├── [hi](./palindromeChecker) +│ │ ├── [hi](./reverseString) +│ │ ├── [hi](./searchReplace) +│ │ ├── [hi](./vowelsCounter) +│ │ └── whereIBelong) +│ ├── [hi](./node-web-scraper-master) +│ │ └── node-web-scraper-master) +│ └── SandboxSQL-master) +│ └── SandboxSQL-master) +│ ├── [hi](./iOS) +│ │ ├── [hi](./Base.lproj) +│ │ └── Images.xcassets) +│ │ └── AppIcon.appiconset) +│ ├── [hi](./SQLSandbox.xcodeproj) +│ │ ├── [hi](./project.xcworkspace) +│ │ │ ├── [hi](./xcshareddata) +│ │ │ └── xcuserdata) +│ │ │ ├── [hi](./pcottle.xcuserdatad) +│ │ │ └── tom.xcuserdatad) +│ │ ├── [hi](./xcshareddata) +│ │ │ └── xcschemes) +│ │ └── xcuserdata) +│ │ ├── [hi](./pcottle.xcuserdatad) +│ │ │ └── xcschemes) +│ │ └── tom.xcuserdatad) +│ │ └── xcschemes) +│ └── src) +│ └── js) +│ ├── [hi](./actions) +│ ├── [hi](./constants) +│ ├── [hi](./data) +│ ├── [hi](./dispatcher) +│ ├── [hi](./query) +│ ├── [hi](./stores) +│ ├── [hi](./__tests__) +│ ├── [hi](./tokens) +│ ├── [hi](./utils) +│ └── views) +├── [hi](./4-test-prep) +│ └── Study-Guides) +├── [hi](./5-websites) +│ └── lambda-prep) +│ ├── [hi](./javascript-practice) +│ │ ├── [hi](./00_expressions_variables) +│ │ │ ├── [hi](./exercises) +│ │ │ │ ├── [hi](./A_executing_code_exercise) +│ │ │ │ ├── [hi](./B_expressions_exercise) +│ │ │ │ ├── [hi](./C_variables_exercise) +│ │ │ │ └── D_string_indexing_and_methods_exercise) +│ │ │ └── solutions) +│ │ ├── [hi](./01_conditionals) +│ │ │ ├── [hi](./exercises) +│ │ │ │ └── A_conditionals_exercise) +│ │ │ └── solutions) +│ │ ├── [hi](./02_functions) +│ │ │ ├── [hi](./exercises) +│ │ │ │ ├── [hi](./A_functions_exercise) +│ │ │ │ ├── [hi](./B_functions_exercise) +│ │ │ │ └── C_functions_exercise) +│ │ │ └── solutions) +│ │ ├── [hi](./03_loops) +│ │ │ ├── [hi](./exercises) +│ │ │ │ ├── [hi](./A_loops_exercise) +│ │ │ │ ├── [hi](./B_loops_exercise) +│ │ │ │ └── C_loops_exercise) +│ │ │ └── solutions) +│ │ ├── [hi](./04_arrays) +│ │ │ ├── [hi](./exercises) +│ │ │ │ ├── [hi](./A_arrays_exercise) +│ │ │ │ ├── [hi](./B_arrays_exercise) +│ │ │ │ └── C_arrays_exercise) +│ │ │ └── solutions) +│ │ ├── [hi](./05_nesting) +│ │ │ ├── [hi](./exercises) +│ │ │ │ ├── [hi](./A_nested_loops_exercise) +│ │ │ │ ├── [hi](./B_two_dimensional_arrays_exercise) +│ │ │ │ └── C_more_problems_exercise) +│ │ │ └── solutions) +│ │ ├── [hi](./06_decomposition_pattern) +│ │ │ ├── [hi](./A_decomposing_problems_exercise) +│ │ │ ├── [hi](./B_decomposing_problems_exercise) +│ │ │ └── C_decomposing_problems_exercise) +│ │ ├── [hi](./07_objects) +│ │ │ ├── [hi](./A_objects_exercise) +│ │ │ ├── [hi](./B_objects_exercise) +│ │ │ └── C_objects_exercise) +│ │ ├── [hi](./08_higher_order_functions) +│ │ │ ├── [hi](./A_native_callback_methods_exercise) +│ │ │ └── B_native_callback_methods_exercise) +│ │ ├── [hi](./-ALL-JS-Files) +│ │ └── simple-side-bar) +│ │ ├── [hi](./css) +│ │ └── vendor) +│ │ ├── [hi](./bootstrap) +│ │ │ ├── [hi](./css) +│ │ │ └── js) +│ │ └── jquery) +│ ├── [hi](./markdown) +│ ├── [hi](./readme) +│ │ └── README_files) +│ └── _Resources) +│ ├── [hi](./node_modules) +│ │ ├── [hi](./jquery) +│ │ │ ├── [hi](./dist) +│ │ │ ├── [hi](./external) +│ │ │ │ └── sizzle) +│ │ │ │ └── dist) +│ │ │ └── src) +│ │ │ ├── [hi](./ajax) +│ │ │ │ └── var) +│ │ │ ├── [hi](./attributes) +│ │ │ ├── [hi](./core) +│ │ │ │ └── var) +│ │ │ ├── [hi](./css) +│ │ │ │ └── var) +│ │ │ ├── [hi](./data) +│ │ │ │ └── var) +│ │ │ ├── [hi](./deferred) +│ │ │ ├── [hi](./deprecated) +│ │ │ ├── [hi](./effects) +│ │ │ ├── [hi](./event) +│ │ │ ├── [hi](./exports) +│ │ │ ├── [hi](./manipulation) +│ │ │ │ └── var) +│ │ │ ├── [hi](./queue) +│ │ │ ├── [hi](./traversing) +│ │ │ │ └── var) +│ │ │ └── var) +│ │ ├── [hi](./loadashes6) +│ │ │ └── lodash) +│ │ │ └── fp) +│ │ ├── [hi](./mout) +│ │ │ ├── [hi](./array) +│ │ │ ├── [hi](./collection) +│ │ │ ├── [hi](./date) +│ │ │ │ └── i18n) +│ │ │ ├── [hi](./doc) +│ │ │ ├── [hi](./function) +│ │ │ ├── [hi](./lang) +│ │ │ ├── [hi](./math) +│ │ │ ├── [hi](./number) +│ │ │ ├── [hi](./object) +│ │ │ ├── [hi](./queryString) +│ │ │ ├── [hi](./random) +│ │ │ ├── [hi](./src) +│ │ │ │ ├── [hi](./array) +│ │ │ │ ├── [hi](./collection) +│ │ │ │ ├── [hi](./date) +│ │ │ │ │ └── i18n) +│ │ │ │ ├── [hi](./function) +│ │ │ │ ├── [hi](./lang) +│ │ │ │ ├── [hi](./math) +│ │ │ │ ├── [hi](./number) +│ │ │ │ ├── [hi](./object) +│ │ │ │ ├── [hi](./queryString) +│ │ │ │ ├── [hi](./random) +│ │ │ │ ├── [hi](./string) +│ │ │ │ └── time) +│ │ │ ├── [hi](./string) +│ │ │ └── time) +│ │ └── web-dev-utils) +│ │ ├── [hi](./bootstrap-4.3.1-dist) +│ │ │ ├── [hi](./css) +│ │ │ └── js) +│ │ ├── [hi](./GIT-HTML-PREVIEW-TOOL) +│ │ │ └── GIT-HTML-PREVIEW-TOOL-master) +│ │ ├── [hi](./images) +│ │ ├── [hi](./Markdown-Templates) +│ │ │ └── Markdown-Templates-master) +│ │ │ ├── [hi](./html-readmes) +│ │ │ └── images) +│ │ ├── [hi](./personal-utilities) +│ │ │ ├── [hi](./Auto-table-Of-Contents) +│ │ │ ├── [hi](./copy-2-clip) +│ │ │ ├── [hi](./css) +│ │ │ ├── [hi](./js) +│ │ │ └── prism) +│ │ └── TexTools) +│ │ └── TexTools-master) +│ │ ├── [hi](./backup-stable-build) +│ │ │ ├── [hi](./css) +│ │ │ └── js) +│ │ ├── [hi](./css) +│ │ ├── [hi](./js) +│ │ └── sandbox) +│ └── Precourse-master) +│ ├── [hi](./Lesson01-Git) +│ ├── [hi](./Lesson02-HTML-CSS) +│ │ └── homework) +│ ├── [hi](./Lesson03-CSS-Positioning) +│ │ └── homework) +│ │ └── assets) +│ ├── [hi](./Lesson04-JS-I) +│ │ └── homework) +│ │ └── tests) +│ ├── [hi](./Lesson05-JS-II) +│ │ └── homework) +│ │ └── tests) +│ ├── [hi](./Lesson06-JS-III) +│ │ └── homework) +│ │ └── tests) +│ ├── [hi](./Lesson07-JS-IV) +│ │ └── homework) +│ │ └── tests) +│ ├── [hi](./Lesson08-JS-V) +│ │ └── homework) +│ │ └── tests) +│ ├── [hi](./Lesson09-JS-VI) +│ │ └── homework) +│ │ └── tests) +│ ├── [hi](./Lesson10-JS-VII) +│ │ └── homework) +│ │ └── tests) +│ ├── [hi](./Lesson11-JS-VIII) +│ │ └── homework) +│ │ └── tests) +│ ├── [hi](./Lesson12-DOM) +│ │ └── homework) +│ │ ├── [hi](./assets) +│ │ └── __tests__) +│ └── Precourse-master) +│ ├── [hi](./Lesson01-Git) +│ ├── [hi](./Lesson02-HTML-CSS) +│ │ └── homework) +│ ├── [hi](./Lesson03-CSS-Positioning) +│ │ └── homework) +│ │ └── assets) +│ ├── [hi](./Lesson04-JS-I) +│ │ └── homework) +│ │ └── tests) +│ ├── [hi](./Lesson05-JS-II) +│ │ └── homework) +│ │ └── tests) +│ ├── [hi](./Lesson06-JS-III) +│ │ └── homework) +│ │ └── tests) +│ ├── [hi](./Lesson07-JS-IV) +│ │ └── homework) +│ │ └── tests) +│ ├── [hi](./Lesson08-JS-V) +│ │ └── homework) +│ │ └── tests) +│ ├── [hi](./Lesson09-JS-VI) +│ │ └── homework) +│ │ └── tests) +│ ├── [hi](./Lesson10-JS-VII) +│ │ └── homework) +│ │ └── tests) +│ ├── [hi](./Lesson11-JS-VIII) +│ │ └── homework) +│ │ └── tests) +│ └── Lesson12-DOM) +│ └── homework) +│ ├── [hi](./assets) +│ └── __tests__) +├── [hi](./about) +│ └── Using Canvas 27a0cf2408124ad19a3802565bd24de6) +│ └── How are courses structured in Canvas How do I know 3dfccdd4ff5f462dacde3b358c627e60) +├── [hi](./assets) +│ ├── [hi](./AUDIO-VISUALIZER) +│ │ ├── [hi](./Box2D) +│ │ │ ├── [hi](./assets) +│ │ │ └── libs) +│ │ ├── [hi](./Gary Ad) +│ │ │ ├── [hi](./Baked) +│ │ │ │ └── sounds) +│ │ │ └── Raw) +│ │ ├── [hi](./GaryPewPew) +│ │ │ ├── [hi](./Animate) +│ │ │ ├── [hi](./js) +│ │ │ └── sounds) +│ │ ├── [hi](./js) +│ │ ├── [hi](./MusicViz) +│ │ │ └── js) +│ │ ├── [hi](./MusicViz2) +│ │ │ ├── [hi](./js) +│ │ │ └── sounds) +│ │ ├── [hi](./Performance) +│ │ │ ├── [hi](./Context2DLog) +│ │ │ ├── [hi](./FauxCanvas) +│ │ │ ├── [hi](./framerate) +│ │ │ │ ├── [hi](./assets) +│ │ │ │ └── js) +│ │ │ ├── [hi](./Snowmark) +│ │ │ │ ├── [hi](./css) +│ │ │ │ └── js) +│ │ │ └── Zombie) +│ │ │ └── images) +│ │ ├── [hi](./Planetary Gary) +│ │ │ ├── [hi](./Animate) +│ │ │ ├── [hi](./assets) +│ │ │ │ ├── [hi](./images) +│ │ │ │ └── sounds) +│ │ │ ├── [hi](./js) +│ │ │ └── libs) +│ │ └── sounds) +│ ├── [hi](./fonts) +│ ├── [hi](./footer) +│ ├── [hi](./images) +│ ├── [hi](./jquery) +│ │ ├── [hi](./dist) +│ │ ├── [hi](./external) +│ │ │ └── sizzle) +│ │ │ └── dist) +│ │ └── src) +│ │ ├── [hi](./ajax) +│ │ │ └── var) +│ │ ├── [hi](./attributes) +│ │ ├── [hi](./core) +│ │ │ └── var) +│ │ ├── [hi](./css) +│ │ │ └── var) +│ │ ├── [hi](./data) +│ │ │ └── var) +│ │ ├── [hi](./deferred) +│ │ ├── [hi](./deprecated) +│ │ ├── [hi](./effects) +│ │ ├── [hi](./event) +│ │ ├── [hi](./exports) +│ │ ├── [hi](./manipulation) +│ │ │ └── var) +│ │ ├── [hi](./queue) +│ │ ├── [hi](./traversing) +│ │ │ └── var) +│ │ └── var) +│ ├── [hi](./loadashes6) +│ │ └── lodash) +│ │ └── fp) +│ ├── [hi](./might-delete) +│ │ └── _MARKDOWN) +│ ├── [hi](./mout) +│ │ ├── [hi](./array) +│ │ ├── [hi](./collection) +│ │ ├── [hi](./date) +│ │ │ └── i18n) +│ │ ├── [hi](./doc) +│ │ ├── [hi](./function) +│ │ ├── [hi](./lang) +│ │ ├── [hi](./math) +│ │ ├── [hi](./number) +│ │ ├── [hi](./object) +│ │ ├── [hi](./queryString) +│ │ ├── [hi](./random) +│ │ ├── [hi](./src) +│ │ │ ├── [hi](./array) +│ │ │ ├── [hi](./collection) +│ │ │ ├── [hi](./date) +│ │ │ │ └── i18n) +│ │ │ ├── [hi](./function) +│ │ │ ├── [hi](./lang) +│ │ │ ├── [hi](./math) +│ │ │ ├── [hi](./number) +│ │ │ ├── [hi](./object) +│ │ │ ├── [hi](./queryString) +│ │ │ ├── [hi](./random) +│ │ │ ├── [hi](./string) +│ │ │ └── time) +│ │ ├── [hi](./string) +│ │ └── time) +│ ├── [hi](./past-student-repos) +│ │ ├── [hi](./data_struct_and_algo-master) +│ │ │ └── logs) +│ │ ├── [hi](./Data-Structures-and-Algorithms-master) +│ │ │ ├── [hi](./assets) +│ │ │ └── src) +│ │ │ ├── [hi](./algorithms) +│ │ │ │ ├── [hi](./strings) +│ │ │ │ │ └── knuth-morris-pratt) +│ │ │ │ └── tree) +│ │ │ │ ├── [hi](./breadth-first-search) +│ │ │ │ └── depth-first-search) +│ │ │ ├── [hi](./analysis-of-algorithms) +│ │ │ │ └── asymptotic-notation) +│ │ │ └── data-structures) +│ │ │ ├── [hi](./graph) +│ │ │ ├── [hi](./linked_lists) +│ │ │ └── tree) +│ │ │ ├── [hi](./binary-search-tree) +│ │ │ └── binary-tree) +│ │ ├── [hi](./Data-Structures-master) +│ │ │ ├── [hi](./avl_tree) +│ │ │ ├── [hi](./binary_search_tree) +│ │ │ ├── [hi](./doubly_linked_list) +│ │ │ ├── [hi](./heap) +│ │ │ ├── [hi](./javascript) +│ │ │ │ └── tests) +│ │ │ ├── [hi](./lru_cache) +│ │ │ ├── [hi](./python) +│ │ │ │ ├── [hi](./binary_search_tree) +│ │ │ │ ├── [hi](./doubly_linked_list) +│ │ │ │ ├── [hi](./heap) +│ │ │ │ ├── [hi](./linked_list) +│ │ │ │ └── queue) +│ │ │ └── queue) +│ │ ├── [hi](./Data-Structures-Notes-master) +│ │ │ ├── [hi](./BST_and_Heaps) +│ │ │ ├── [hi](./Doubly_Linked_List) +│ │ │ ├── [hi](./Interview_Problems) +│ │ │ └── Linked_Lists) +│ │ ├── [hi](./dev-portfolio-master) +│ │ │ ├── [hi](./public) +│ │ │ ├── [hi](./src) +│ │ │ │ ├── [hi](./components) +│ │ │ │ │ └── ~reusables) +│ │ │ │ │ ├── [hi](./atoms) +│ │ │ │ │ ├── [hi](./molecules) +│ │ │ │ │ └── variables) +│ │ │ │ ├── [hi](./global-scss) +│ │ │ │ └── views) +│ │ │ │ ├── [hi](./1-Intro) +│ │ │ │ ├── [hi](./2-About) +│ │ │ │ ├── [hi](./3-Skills) +│ │ │ │ ├── [hi](./4-Projects) +│ │ │ │ ├── [hi](./5-Resume) +│ │ │ │ └── 6-Contact) +│ │ │ └── tests_setup) +│ │ │ └── __mocks__) +│ │ ├── [hi](./DOM-II-master) +│ │ ├── [hi](./_DS-Python) +│ │ │ ├── [hi](./Algorithms-I-Notes-master) +│ │ │ │ └── practice_algs) +│ │ │ └── Algorithms-master) +│ │ │ ├── [hi](./climbing_stairs) +│ │ │ ├── [hi](./knapsack) +│ │ │ │ └── data) +│ │ │ ├── [hi](./making_change) +│ │ │ ├── [hi](./recipe_batches) +│ │ │ ├── [hi](./rock_paper_scissors) +│ │ │ └── stock_prices) +│ │ ├── [hi](./feelscollective-master) +│ │ │ ├── [hi](./css) +│ │ │ ├── [hi](./fonts) +│ │ │ │ ├── [hi](./icomoon) +│ │ │ │ └── open-iconic) +│ │ │ ├── [hi](./images) +│ │ │ ├── [hi](./js) +│ │ │ └── scss) +│ │ ├── [hi](./five-master) +│ │ │ └── FiveFeed) +│ │ │ ├── [hi](./lambda) +│ │ │ ├── [hi](./lambda-src) +│ │ │ └── src) +│ │ │ ├── [hi](./components) +│ │ │ │ └── unused) +│ │ │ ├── [hi](./fonts) +│ │ │ ├── [hi](./icons) +│ │ │ ├── [hi](./images) +│ │ │ ├── [hi](./pages) +│ │ │ └── shared) +│ │ ├── [hi](./Graphs-master) +│ │ │ ├── [hi](./javascript) +│ │ │ │ ├── [hi](./guided-demo) +│ │ │ │ │ ├── [hi](./graphs-1) +│ │ │ │ │ │ └── src) +│ │ │ │ │ └── graphs-2) +│ │ │ │ │ └── src) +│ │ │ │ ├── [hi](./objectives) +│ │ │ │ │ ├── [hi](./breadth-first-search) +│ │ │ │ │ │ └── img) +│ │ │ │ │ ├── [hi](./connected-components) +│ │ │ │ │ │ └── img) +│ │ │ │ │ ├── [hi](./depth-first-search) +│ │ │ │ │ │ └── img) +│ │ │ │ │ └── graph-intro) +│ │ │ │ │ └── img) +│ │ │ │ └── projects) +│ │ │ │ └── graph) +│ │ │ │ ├── [hi](./public) +│ │ │ │ └── src) +│ │ │ ├── [hi](./objectives) +│ │ │ │ ├── [hi](./breadth-first-search) +│ │ │ │ │ └── img) +│ │ │ │ ├── [hi](./connected-components) +│ │ │ │ │ └── img) +│ │ │ │ ├── [hi](./depth-first-search) +│ │ │ │ │ └── img) +│ │ │ │ ├── [hi](./graph-intro) +│ │ │ │ │ └── img) +│ │ │ │ ├── [hi](./graph-representations) +│ │ │ │ │ └── img) +│ │ │ │ └── randomness) +│ │ │ ├── [hi](./projects) +│ │ │ │ ├── [hi](./adventure) +│ │ │ │ ├── [hi](./ancestor) +│ │ │ │ ├── [hi](./graph) +│ │ │ │ └── social) +│ │ │ └── python) +│ │ │ ├── [hi](./guided-demo) +│ │ │ │ ├── [hi](./graphs-1) +│ │ │ │ │ └── src) +│ │ │ │ └── graphs-2) +│ │ │ │ └── src) +│ │ │ └── projects) +│ │ │ └── graph) +│ │ │ └── src) +│ │ ├── [hi](./Graphs-Notes-master) +│ │ │ ├── [hi](./img) +│ │ │ ├── [hi](./lecture1) +│ │ │ ├── [hi](./lecture2) +│ │ │ ├── [hi](./lecture3) +│ │ │ └── lecture4) +│ │ ├── [hi](./Hash-Tables-Notes-master) +│ │ ├── [hi](./homepage-master) +│ │ │ ├── [hi](./css) +│ │ │ ├── [hi](./fonts) +│ │ │ ├── [hi](./images) +│ │ │ └── js) +│ │ │ ├── [hi](./backstretch) +│ │ │ ├── [hi](./bootstrap) +│ │ │ ├── [hi](./easing) +│ │ │ ├── [hi](./magnific-popup) +│ │ │ ├── [hi](./owl-carousel) +│ │ │ ├── [hi](./uitotop) +│ │ │ └── wow) +│ │ ├── [hi](./HTTP-AJAX-II-master) +│ │ │ ├── [hi](./app) +│ │ │ │ ├── [hi](./public) +│ │ │ │ └── src) +│ │ │ │ └── components) +│ │ │ └── server) +│ │ ├── [hi](./HTTP-AJAX-master) +│ │ │ └── friends) +│ │ │ ├── [hi](./public) +│ │ │ └── src) +│ │ │ ├── [hi](./actions) +│ │ │ ├── [hi](./components) +│ │ │ └── reducers) +│ │ ├── [hi](./_Individual-Projects) +│ │ │ ├── [hi](./Advanced-Form-Management-Guided-master) +│ │ │ │ └── app) +│ │ │ │ ├── [hi](./public) +│ │ │ │ └── src) +│ │ │ │ └── components) +│ │ │ │ └── Notes) +│ │ │ ├── [hi](./Bootstrap-I-master) +│ │ │ │ ├── [hi](./css) +│ │ │ │ ├── [hi](./_example-resume) +│ │ │ │ │ ├── [hi](./css) +│ │ │ │ │ ├── [hi](./img) +│ │ │ │ │ └── js) +│ │ │ │ ├── [hi](./img) +│ │ │ │ ├── [hi](./js) +│ │ │ │ └── less) +│ │ │ ├── [hi](./Components-BEM-master) +│ │ │ │ ├── [hi](./components) +│ │ │ │ │ ├── [hi](./Box) +│ │ │ │ │ └── Section) +│ │ │ │ └── markups) +│ │ │ ├── [hi](./Components-Constructors-master) +│ │ │ │ ├── [hi](./components) +│ │ │ │ │ └── Tabs) +│ │ │ │ └── markups) +│ │ │ ├── [hi](./Computer-Architecture-Notes-master) +│ │ │ │ ├── [hi](./lectureI) +│ │ │ │ ├── [hi](./lectureII) +│ │ │ │ ├── [hi](./lectureIII) +│ │ │ │ └── lectureIV) +│ │ │ ├── [hi](./Course_and_Book_Notes-master) +│ │ │ │ ├── [hi](./Algorithm Design Manual) +│ │ │ │ │ ├── [hi](./Chapter 1) +│ │ │ │ │ ├── [hi](./Chapter 10) +│ │ │ │ │ ├── [hi](./Chapter 2) +│ │ │ │ │ ├── [hi](./Chapter 3) +│ │ │ │ │ ├── [hi](./Chapter 4) +│ │ │ │ │ ├── [hi](./Chapter 5) +│ │ │ │ │ ├── [hi](./Chapter 6) +│ │ │ │ │ ├── [hi](./Chapter 7) +│ │ │ │ │ ├── [hi](./Chapter 8) +│ │ │ │ │ └── Chapter 9) +│ │ │ │ ├── [hi](./Computer_Science_Distilled) +│ │ │ │ ├── [hi](./Lambda_Notes) +│ │ │ │ │ ├── [hi](./Authentication) +│ │ │ │ │ ├── [hi](./Computer_Architecture) +│ │ │ │ │ ├── [hi](./Data_Structures_and_Algorithms) +│ │ │ │ │ ├── [hi](./DevOps) +│ │ │ │ │ ├── [hi](./Graphs) +│ │ │ │ │ ├── [hi](./Mongo) +│ │ │ │ │ ├── [hi](./Operating_Systems) +│ │ │ │ │ ├── [hi](./Security) +│ │ │ │ │ ├── [hi](./Testing) +│ │ │ │ │ └── Theory_of_Computation) +│ │ │ │ ├── [hi](./Programming_Foundations) +│ │ │ │ ├── [hi](./The_C_Programming_Language) +│ │ │ │ │ └── Chapter_1) +│ │ │ │ ├── [hi](./Think Like a Programmer) +│ │ │ │ │ ├── [hi](./Chapter 1) +│ │ │ │ │ ├── [hi](./Chapter 2) +│ │ │ │ │ └── Chapter 3) +│ │ │ │ └── YoutubeVideos) +│ │ │ ├── [hi](./JavaScript-III-master) +│ │ │ │ └── assignments) +│ │ │ ├── [hi](./JavaScript-II-master) +│ │ │ │ └── assignments) +│ │ │ ├── [hi](./JavaScript-I-master) +│ │ │ │ └── assignments) +│ │ │ └── JavaScript-IV-master) +│ │ │ └── assignments) +│ │ ├── [hi](./Intro-Python-master) +│ │ │ └── src) +│ │ │ ├── [hi](./day-1-toy) +│ │ │ ├── [hi](./days-2-4-adv) +│ │ │ ├── [hi](./mini-challenge) +│ │ │ └── python-example) +│ │ ├── [hi](./Intro-to-C-master) +│ │ │ ├── [hi](./first) +│ │ │ ├── [hi](./fizzbuzz) +│ │ │ │ └── tests) +│ │ │ ├── [hi](./hangman) +│ │ │ ├── [hi](./malloc) +│ │ │ │ └── tests) +│ │ │ ├── [hi](./pointers) +│ │ │ │ └── tests) +│ │ │ ├── [hi](./queue) +│ │ │ │ └── tests) +│ │ │ ├── [hi](./quicksort) +│ │ │ │ └── tests) +│ │ │ ├── [hi](./strings) +│ │ │ │ └── tests) +│ │ │ ├── [hi](./structs) +│ │ │ │ └── tests) +│ │ │ └── utils) +│ │ ├── [hi](./JavaScript-I-Guided-master) +│ │ ├── [hi](./lambda-demo-project-master) +│ │ │ ├── [hi](./api) +│ │ │ ├── [hi](./public) +│ │ │ └── src) +│ │ ├── [hi](./lambda-lecture-notes-main) +│ │ │ ├── [hi](./3-1-advanced-react) +│ │ │ │ ├── [hi](./images) +│ │ │ │ └── pdf) +│ │ │ ├── [hi](./3-2-advanced-state-mangement) +│ │ │ │ └── images) +│ │ │ └── 3-3-advanced-web-applications) +│ │ │ └── images) +│ │ ├── [hi](./Lambda-School-Instruction-Notes-master) +│ │ │ ├── [hi](./10. Data Persistence in Web APIs) +│ │ │ │ └── assets) +│ │ │ ├── [hi](./11. Authentication) +│ │ │ └── 12. Testing) +│ │ ├── [hi](./Lambda-School-master) +│ │ │ ├── [hi](./Week 1) +│ │ │ │ ├── [hi](./Sprint-Challenge User-Interface) +│ │ │ │ │ ├── [hi](./css) +│ │ │ │ │ ├── [hi](./design-files) +│ │ │ │ │ └── img) +│ │ │ │ ├── [hi](./User Interface I HTML Markup) +│ │ │ │ ├── [hi](./User-Interface II Innovation) +│ │ │ │ │ ├── [hi](./design-files) +│ │ │ │ │ └── great-idea-website) +│ │ │ │ │ ├── [hi](./css) +│ │ │ │ │ └── img) +│ │ │ │ ├── [hi](./User Interface III Services Page) +│ │ │ │ │ ├── [hi](./design-files) +│ │ │ │ │ └── great-idea) +│ │ │ │ │ ├── [hi](./css) +│ │ │ │ │ └── img) +│ │ │ │ └── User Interface I Project 2 - Sweet Eats Bakery) +│ │ │ ├── [hi](./Week 10) +│ │ │ │ ├── [hi](./Car-Sales) +│ │ │ │ │ ├── [hi](./public) +│ │ │ │ │ └── src) +│ │ │ │ │ ├── [hi](./actions) +│ │ │ │ │ ├── [hi](./components) +│ │ │ │ │ │ ├── [hi](./CSS) +│ │ │ │ │ │ └── TodoComponents) +│ │ │ │ │ ├── [hi](./images) +│ │ │ │ │ └── reducers) +│ │ │ │ ├── [hi](./React-Redux-App) +│ │ │ │ │ ├── [hi](./public) +│ │ │ │ │ │ └── images) +│ │ │ │ │ └── src) +│ │ │ │ │ ├── [hi](./actions) +│ │ │ │ │ ├── [hi](./components) +│ │ │ │ │ ├── [hi](./images) +│ │ │ │ │ └── reducers) +│ │ │ │ ├── [hi](./react-shopping-cart) +│ │ │ │ │ ├── [hi](./public) +│ │ │ │ │ └── src) +│ │ │ │ │ ├── [hi](./components) +│ │ │ │ │ ├── [hi](./context) +│ │ │ │ │ └── sass) +│ │ │ │ ├── [hi](./reducer-todo) +│ │ │ │ │ ├── [hi](./public) +│ │ │ │ │ └── src) +│ │ │ │ │ ├── [hi](./components) +│ │ │ │ │ │ ├── [hi](./CSS) +│ │ │ │ │ │ └── TodoComponents) +│ │ │ │ │ ├── [hi](./images) +│ │ │ │ │ └── reducers) +│ │ │ │ └── Sprint-Challenge-State-Management-Smurfs) +│ │ │ │ └── smurfs) +│ │ │ │ ├── [hi](./public) +│ │ │ │ └── src) +│ │ │ │ ├── [hi](./actions) +│ │ │ │ ├── [hi](./components) +│ │ │ │ ├── [hi](./reducers) +│ │ │ │ └── REFERENCES) +│ │ │ │ ├── [hi](./components) +│ │ │ │ └── images) +│ │ │ ├── [hi](./Week 11) +│ │ │ │ ├── [hi](./Auth-Friends) +│ │ │ │ │ └── friends) +│ │ │ │ │ ├── [hi](./public) +│ │ │ │ │ └── src) +│ │ │ │ │ ├── [hi](./actions) +│ │ │ │ │ ├── [hi](./axios) +│ │ │ │ │ ├── [hi](./components) +│ │ │ │ │ └── reducers) +│ │ │ │ ├── [hi](./HTTP-Movies-Assignment) +│ │ │ │ │ └── client) +│ │ │ │ │ ├── [hi](./public) +│ │ │ │ │ └── src) +│ │ │ │ │ └── Movies) +│ │ │ │ ├── [hi](./react-bubbles) +│ │ │ │ │ └── client) +│ │ │ │ │ ├── [hi](./public) +│ │ │ │ │ ├── [hi](./References) +│ │ │ │ │ │ ├── [hi](./actions) +│ │ │ │ │ │ ├── [hi](./components) +│ │ │ │ │ │ └── reducers) +│ │ │ │ │ └── src) +│ │ │ │ │ ├── [hi](./actions) +│ │ │ │ │ ├── [hi](./axios) +│ │ │ │ │ ├── [hi](./components) +│ │ │ │ │ └── reducers) +│ │ │ │ └── webtesting-iii-challenge) +│ │ │ │ ├── [hi](./public) +│ │ │ │ └── src) +│ │ │ │ ├── [hi](./controls) +│ │ │ │ ├── [hi](./dashboard) +│ │ │ │ └── display) +│ │ │ │ └── __snapshots__) +│ │ │ ├── [hi](./Week 12 - FoodieFun) +│ │ │ ├── [hi](./Week 13) +│ │ │ │ ├── [hi](./node-api1-project) +│ │ │ │ │ └── data) +│ │ │ │ │ ├── [hi](./migrations) +│ │ │ │ │ └── seeds) +│ │ │ │ ├── [hi](./webapi-challenge-sprint) +│ │ │ │ │ ├── [hi](./data) +│ │ │ │ │ │ ├── [hi](./helpers) +│ │ │ │ │ │ ├── [hi](./migrations) +│ │ │ │ │ │ └── seeds) +│ │ │ │ │ └── routes) +│ │ │ │ │ └── middleware) +│ │ │ │ ├── [hi](./webapi-ii-challenge) +│ │ │ │ │ ├── [hi](./comments) +│ │ │ │ │ ├── [hi](./data) +│ │ │ │ │ │ ├── [hi](./migrations) +│ │ │ │ │ │ └── seeds) +│ │ │ │ │ └── posts) +│ │ │ │ └── webapi-iii-challenge) +│ │ │ │ ├── [hi](./data) +│ │ │ │ │ ├── [hi](./migrations) +│ │ │ │ │ └── seeds) +│ │ │ │ ├── [hi](./global-middleware) +│ │ │ │ ├── [hi](./posts) +│ │ │ │ │ └── middleware) +│ │ │ │ └── users) +│ │ │ │ └── middleware) +│ │ │ ├── [hi](./Week 14) +│ │ │ │ ├── [hi](./node-db3-challenge) +│ │ │ │ │ ├── [hi](./data) +│ │ │ │ │ │ ├── [hi](./migrations) +│ │ │ │ │ │ └── seeds) +│ │ │ │ │ └── schemes) +│ │ │ │ ├── [hi](./node-db4) +│ │ │ │ │ └── data) +│ │ │ │ │ ├── [hi](./helpers) +│ │ │ │ │ ├── [hi](./migrations) +│ │ │ │ │ └── seeds) +│ │ │ │ ├── [hi](./node-db-challenge-sprint) +│ │ │ │ │ ├── [hi](./data) +│ │ │ │ │ │ ├── [hi](./migrations) +│ │ │ │ │ │ └── seeds) +│ │ │ │ │ └── routers) +│ │ │ │ ├── [hi](./webdb-i-challenge) +│ │ │ │ │ └── data) +│ │ │ │ │ ├── [hi](./migrations) +│ │ │ │ │ └── seeds) +│ │ │ │ └── webdb-ii-challenge) +│ │ │ │ └── data) +│ │ │ │ ├── [hi](./migrations) +│ │ │ │ └── seeds) +│ │ │ ├── [hi](./Week 15) +│ │ │ │ ├── [hi](./node-server-testing-challenge) +│ │ │ │ ├── [hi](./Sprint-Challenge-Authentication) +│ │ │ │ │ ├── [hi](./api) +│ │ │ │ │ ├── [hi](./auth) +│ │ │ │ │ ├── [hi](./database) +│ │ │ │ │ │ └── migrations) +│ │ │ │ │ └── jokes) +│ │ │ │ ├── [hi](./webauth-i-challenge) +│ │ │ │ │ ├── [hi](./data) +│ │ │ │ │ │ ├── [hi](./migrations) +│ │ │ │ │ │ └── seeds) +│ │ │ │ │ ├── [hi](./restricted) +│ │ │ │ │ └── users) +│ │ │ │ └── webauth-iii-challenge) +│ │ │ │ ├── [hi](./data) +│ │ │ │ │ ├── [hi](./migrations) +│ │ │ │ │ └── seeds) +│ │ │ │ ├── [hi](./restricted) +│ │ │ │ └── users) +│ │ │ ├── [hi](./Week 16 - Mentor Me) +│ │ │ ├── [hi](./Week 17 - 25 Future Hope) +│ │ │ ├── [hi](./Week 2) +│ │ │ │ ├── [hi](./Digital Resume) +│ │ │ │ │ ├── [hi](./css) +│ │ │ │ │ ├── [hi](./img) +│ │ │ │ │ └── less) +│ │ │ │ ├── [hi](./Fun Bus) +│ │ │ │ │ ├── [hi](./css) +│ │ │ │ │ ├── [hi](./design-files) +│ │ │ │ │ ├── [hi](./img) +│ │ │ │ │ └── less) +│ │ │ │ ├── [hi](./Portfolio) +│ │ │ │ │ ├── [hi](./assets) +│ │ │ │ │ │ ├── [hi](./css) +│ │ │ │ │ │ │ └── images) +│ │ │ │ │ │ │ └── ie) +│ │ │ │ │ │ ├── [hi](./js) +│ │ │ │ │ │ ├── [hi](./sass) +│ │ │ │ │ │ │ └── libs) +│ │ │ │ │ │ └── webfonts) +│ │ │ │ │ └── images) +│ │ │ │ ├── [hi](./Resposnive-Web-Design) +│ │ │ │ │ ├── [hi](./css) +│ │ │ │ │ ├── [hi](./design-files) +│ │ │ │ │ └── img) +│ │ │ │ └── Sprint Challenge) +│ │ │ │ ├── [hi](./css) +│ │ │ │ ├── [hi](./design-files) +│ │ │ │ ├── [hi](./img) +│ │ │ │ └── less) +│ │ │ ├── [hi](./Week 3) +│ │ │ │ ├── [hi](./JavaScript-I) +│ │ │ │ │ └── assignments) +│ │ │ │ ├── [hi](./JavaScript-II) +│ │ │ │ │ └── assignments) +│ │ │ │ ├── [hi](./JavaScript-III) +│ │ │ │ │ └── assignments) +│ │ │ │ ├── [hi](./JavaScript-IV) +│ │ │ │ │ └── assignments) +│ │ │ │ └── Sprint-Challenge) +│ │ │ │ └── challenges) +│ │ │ ├── [hi](./Week 4 - Local Voter Guide) +│ │ │ │ ├── [hi](./css) +│ │ │ │ ├── [hi](./images) +│ │ │ │ └── less) +│ │ │ ├── [hi](./Week 5) +│ │ │ │ ├── [hi](./DOM-I) +│ │ │ │ │ ├── [hi](./css) +│ │ │ │ │ ├── [hi](./design-files) +│ │ │ │ │ ├── [hi](./img) +│ │ │ │ │ ├── [hi](./js) +│ │ │ │ │ └── stretch-assignment) +│ │ │ │ │ └── digital_timer) +│ │ │ │ ├── [hi](./DOM-II) +│ │ │ │ │ ├── [hi](./css) +│ │ │ │ │ ├── [hi](./img) +│ │ │ │ │ ├── [hi](./js) +│ │ │ │ │ ├── [hi](./less) +│ │ │ │ │ └── stretch-assignment) +│ │ │ │ ├── [hi](./github-usercard) +│ │ │ │ │ ├── [hi](./assets) +│ │ │ │ │ └── GitHubCard) +│ │ │ │ ├── [hi](./Newsfeed-Components) +│ │ │ │ │ ├── [hi](./Article) +│ │ │ │ │ ├── [hi](./assets) +│ │ │ │ │ ├── [hi](./css) +│ │ │ │ │ ├── [hi](./Header) +│ │ │ │ │ ├── [hi](./LESS) +│ │ │ │ │ └── Menu) +│ │ │ │ └── Sprint-Challenge-Applied-Javascript) +│ │ │ │ ├── [hi](./assets) +│ │ │ │ │ └── carousel) +│ │ │ │ ├── [hi](./components) +│ │ │ │ │ ├── [hi](./Cards) +│ │ │ │ │ ├── [hi](./Carousel) +│ │ │ │ │ ├── [hi](./Header) +│ │ │ │ │ ├── [hi](./Tabs) +│ │ │ │ │ └── TopBar) +│ │ │ │ ├── [hi](./CSS) +│ │ │ │ └── LESS) +│ │ │ ├── [hi](./Week 6) +│ │ │ │ ├── [hi](./lambda-calculator) +│ │ │ │ │ ├── [hi](./design-files) +│ │ │ │ │ ├── [hi](./public) +│ │ │ │ │ └── src) +│ │ │ │ │ ├── [hi](./components) +│ │ │ │ │ │ ├── [hi](./ButtonComponents) +│ │ │ │ │ │ │ ├── [hi](./NumberButtons) +│ │ │ │ │ │ │ ├── [hi](./OperatorButtons) +│ │ │ │ │ │ │ └── SpecialButtons) +│ │ │ │ │ │ └── DisplayComponents) +│ │ │ │ │ └── Img) +│ │ │ │ ├── [hi](./nasa-photo-of-the-day) +│ │ │ │ │ ├── [hi](./public) +│ │ │ │ │ └── src) +│ │ │ │ ├── [hi](./react-american-football-scoreboard) +│ │ │ │ │ ├── [hi](./public) +│ │ │ │ │ └── src) +│ │ │ │ └── Sprint-Challenge-React-Wars) +│ │ │ │ ├── [hi](./public) +│ │ │ │ └── src) +│ │ │ │ └── components) +│ │ │ ├── [hi](./Week 7) +│ │ │ │ ├── [hi](./React-Router-Basic-Nav) +│ │ │ │ │ ├── [hi](./public) +│ │ │ │ │ └── src) +│ │ │ │ │ └── components) +│ │ │ │ ├── [hi](./React-Router-Movies) +│ │ │ │ │ ├── [hi](./client) +│ │ │ │ │ │ ├── [hi](./public) +│ │ │ │ │ │ └── src) +│ │ │ │ │ │ └── Movies) +│ │ │ │ │ ├── [hi](./public) +│ │ │ │ │ └── src) +│ │ │ │ │ └── Movies) +│ │ │ │ ├── [hi](./Sprint-Challenge-Single-Page-Apps) +│ │ │ │ │ ├── [hi](./public) +│ │ │ │ │ └── src) +│ │ │ │ │ └── components) +│ │ │ │ ├── [hi](./team-builder) +│ │ │ │ │ ├── [hi](./public) +│ │ │ │ │ └── src) +│ │ │ │ └── User-Onboarding) +│ │ │ │ ├── [hi](./public) +│ │ │ │ └── src) +│ │ │ ├── [hi](./Week 8 - Water My Plants) +│ │ │ └── Week 9) +│ │ │ ├── [hi](./dark-mode) +│ │ │ │ ├── [hi](./public) +│ │ │ │ └── src) +│ │ │ │ ├── [hi](./components) +│ │ │ │ └── hooks) +│ │ │ ├── [hi](./Github-User-Card) +│ │ │ │ └── src) +│ │ │ │ ├── [hi](./components) +│ │ │ │ ├── [hi](./images) +│ │ │ │ └── styles) +│ │ │ ├── [hi](./React-Todo) +│ │ │ │ └── src) +│ │ │ │ ├── [hi](./components) +│ │ │ │ │ ├── [hi](./CSS) +│ │ │ │ │ └── TodoComponents) +│ │ │ │ ├── [hi](./images) +│ │ │ │ └── styles) +│ │ │ └── Sprint-Challenge-Advanced-React) +│ │ │ └── client) +│ │ │ ├── [hi](./public) +│ │ │ └── src) +│ │ │ └── components) +│ │ │ └── hooks) +│ │ ├── [hi](./LambdaSchool-master) +│ │ │ ├── [hi](./31d1) +│ │ │ ├── [hi](./aa-score) +│ │ │ │ ├── [hi](./public) +│ │ │ │ └── src) +│ │ │ ├── [hi](./Administration) +│ │ │ │ ├── [hi](./certs) +│ │ │ │ ├── [hi](./marketing) +│ │ │ │ ├── [hi](./studying) +│ │ │ │ └── zoom) +│ │ │ ├── [hi](./bw1-tl) +│ │ │ │ ├── [hi](./admin) +│ │ │ │ ├── [hi](./api) +│ │ │ │ ├── [hi](./auth) +│ │ │ │ ├── [hi](./database) +│ │ │ │ │ ├── [hi](./migrations) +│ │ │ │ │ └── seeds) +│ │ │ │ ├── [hi](./middleware) +│ │ │ │ ├── [hi](./todos) +│ │ │ │ └── volunteer) +│ │ │ ├── [hi](./css) +│ │ │ ├── [hi](./JavaScript30) +│ │ │ │ ├── [hi](./01) +│ │ │ │ │ └── sounds) +│ │ │ │ ├── [hi](./02) +│ │ │ │ ├── [hi](./03) +│ │ │ │ ├── [hi](./04) +│ │ │ │ ├── [hi](./05) +│ │ │ │ ├── [hi](./06) +│ │ │ │ ├── [hi](./07) +│ │ │ │ ├── [hi](./08) +│ │ │ │ ├── [hi](./09) +│ │ │ │ ├── [hi](./10) +│ │ │ │ ├── [hi](./11) +│ │ │ │ ├── [hi](./12) +│ │ │ │ ├── [hi](./13) +│ │ │ │ ├── [hi](./14) +│ │ │ │ ├── [hi](./15) +│ │ │ │ ├── [hi](./16) +│ │ │ │ ├── [hi](./17) +│ │ │ │ ├── [hi](./18) +│ │ │ │ ├── [hi](./19) +│ │ │ │ ├── [hi](./20) +│ │ │ │ ├── [hi](./21) +│ │ │ │ ├── [hi](./22) +│ │ │ │ ├── [hi](./23) +│ │ │ │ ├── [hi](./24) +│ │ │ │ ├── [hi](./25) +│ │ │ │ ├── [hi](./26) +│ │ │ │ ├── [hi](./27) +│ │ │ │ ├── [hi](./28) +│ │ │ │ ├── [hi](./29) +│ │ │ │ └── 30) +│ │ │ ├── [hi](./labs) +│ │ │ │ ├── [hi](./last journal entry) +│ │ │ │ └── video-to-next-group) +│ │ │ ├── [hi](./m1) +│ │ │ │ ├── [hi](./11b1) +│ │ │ │ │ ├── [hi](./design-files) +│ │ │ │ │ ├── [hi](./great-idea) +│ │ │ │ │ │ ├── [hi](./css) +│ │ │ │ │ │ └── img) +│ │ │ │ │ └── great-idea-website) +│ │ │ │ │ ├── [hi](./css) +│ │ │ │ │ └── img) +│ │ │ │ ├── [hi](./11c1) +│ │ │ │ │ ├── [hi](./design-files) +│ │ │ │ │ └── great-idea-website) +│ │ │ │ │ ├── [hi](./css) +│ │ │ │ │ └── img) +│ │ │ │ ├── [hi](./11d1) +│ │ │ │ │ ├── [hi](./design-files) +│ │ │ │ │ └── great-idea) +│ │ │ │ │ ├── [hi](./css) +│ │ │ │ │ └── img) +│ │ │ │ ├── [hi](./12a1) +│ │ │ │ │ ├── [hi](./css) +│ │ │ │ │ ├── [hi](./design-files) +│ │ │ │ │ └── img) +│ │ │ │ ├── [hi](./12b1) +│ │ │ │ │ ├── [hi](./dimension) +│ │ │ │ │ │ ├── [hi](./assets) +│ │ │ │ │ │ │ └── sass) +│ │ │ │ │ │ └── html5up-dimension) +│ │ │ │ │ │ └── assets) +│ │ │ │ │ │ └── sass) +│ │ │ │ │ └── solidstate) +│ │ │ │ │ └── assets) +│ │ │ │ │ └── sass) +│ │ │ │ ├── [hi](./12c1) +│ │ │ │ │ ├── [hi](./css) +│ │ │ │ │ └── less) +│ │ │ │ ├── [hi](./12d1) +│ │ │ │ │ ├── [hi](./css) +│ │ │ │ │ ├── [hi](./design-files) +│ │ │ │ │ ├── [hi](./img) +│ │ │ │ │ └── less) +│ │ │ │ ├── [hi](./13a1) +│ │ │ │ │ └── assignments) +│ │ │ │ ├── [hi](./13b1) +│ │ │ │ │ └── assignments) +│ │ │ │ ├── [hi](./13c1) +│ │ │ │ │ └── assignments) +│ │ │ │ ├── [hi](./13d1) +│ │ │ │ │ ├── [hi](./new) +│ │ │ │ │ │ └── test) +│ │ │ │ │ └── old) +│ │ │ │ │ └── assignments) +│ │ │ │ └── 13e1) +│ │ │ │ └── challenges) +│ │ │ ├── [hi](./m2) +│ │ │ │ ├── [hi](./21a1) +│ │ │ │ │ ├── [hi](./css) +│ │ │ │ │ ├── [hi](./design-files) +│ │ │ │ │ ├── [hi](./img) +│ │ │ │ │ ├── [hi](./js) +│ │ │ │ │ └── stretch-assignment) +│ │ │ │ │ └── digital_timer) +│ │ │ │ ├── [hi](./21b1) +│ │ │ │ ├── [hi](./21c1) +│ │ │ │ │ ├── [hi](./Article) +│ │ │ │ │ ├── [hi](./assets) +│ │ │ │ │ ├── [hi](./css) +│ │ │ │ │ ├── [hi](./Header) +│ │ │ │ │ ├── [hi](./LESS) +│ │ │ │ │ └── Menu) +│ │ │ │ ├── [hi](./21d1) +│ │ │ │ │ ├── [hi](./assets) +│ │ │ │ │ └── GitHubCard) +│ │ │ │ ├── [hi](./21e1) +│ │ │ │ │ ├── [hi](./assets) +│ │ │ │ │ │ └── carousel) +│ │ │ │ │ ├── [hi](./components) +│ │ │ │ │ │ ├── [hi](./Cards) +│ │ │ │ │ │ ├── [hi](./Carousel) +│ │ │ │ │ │ ├── [hi](./Header) +│ │ │ │ │ │ ├── [hi](./Tabs) +│ │ │ │ │ │ └── TopBar) +│ │ │ │ │ ├── [hi](./CSS) +│ │ │ │ │ └── LESS) +│ │ │ │ ├── [hi](./22a1) +│ │ │ │ │ ├── [hi](./public) +│ │ │ │ │ └── src) +│ │ │ │ ├── [hi](./22b1) +│ │ │ │ │ ├── [hi](./design-files) +│ │ │ │ │ ├── [hi](./public) +│ │ │ │ │ └── src) +│ │ │ │ │ ├── [hi](./components) +│ │ │ │ │ │ ├── [hi](./ButtonComponents) +│ │ │ │ │ │ │ ├── [hi](./NumberButtons) +│ │ │ │ │ │ │ ├── [hi](./OperatorButtons) +│ │ │ │ │ │ │ └── SpecialButtons) +│ │ │ │ │ │ └── DisplayComponents) +│ │ │ │ │ └── Img) +│ │ │ │ ├── [hi](./22c1) +│ │ │ │ │ ├── [hi](./public) +│ │ │ │ │ └── src) +│ │ │ │ ├── [hi](./22e1) +│ │ │ │ │ └── starwars) +│ │ │ │ │ ├── [hi](./public) +│ │ │ │ │ └── src) +│ │ │ │ ├── [hi](./23a1) +│ │ │ │ │ ├── [hi](./public) +│ │ │ │ │ └── src) +│ │ │ │ │ └── components) +│ │ │ │ ├── [hi](./23a2) +│ │ │ │ │ └── images) +│ │ │ │ ├── [hi](./23b1) +│ │ │ │ │ └── client) +│ │ │ │ │ ├── [hi](./public) +│ │ │ │ │ └── src) +│ │ │ │ │ └── Movies) +│ │ │ │ ├── [hi](./23c1) +│ │ │ │ │ ├── [hi](./public) +│ │ │ │ │ ├── [hi](./src) +│ │ │ │ │ │ └── CustomHooks) +│ │ │ │ │ └── team-builder) +│ │ │ │ ├── [hi](./23d1) +│ │ │ │ │ ├── [hi](./public) +│ │ │ │ │ └── src) +│ │ │ │ │ └── CustomHooks) +│ │ │ │ ├── [hi](./23d2) +│ │ │ │ │ ├── [hi](./public) +│ │ │ │ │ └── src) +│ │ │ │ ├── [hi](./23e1) +│ │ │ │ │ ├── [hi](./public) +│ │ │ │ │ └── src) +│ │ │ │ │ └── components) +│ │ │ │ └── 24a1) +│ │ │ │ ├── [hi](./public) +│ │ │ │ │ └── img) +│ │ │ │ └── src) +│ │ │ │ └── components) +│ │ │ │ └── old pages) +│ │ │ ├── [hi](./m3) +│ │ │ │ ├── [hi](./31a1) +│ │ │ │ │ ├── [hi](./public) +│ │ │ │ │ └── src) +│ │ │ │ │ └── components) +│ │ │ │ │ └── TodoComponents) +│ │ │ │ ├── [hi](./31a2) +│ │ │ │ │ ├── [hi](./public) +│ │ │ │ │ └── src) +│ │ │ │ ├── [hi](./31b1) +│ │ │ │ │ ├── [hi](./public) +│ │ │ │ │ └── src) +│ │ │ │ │ └── components) +│ │ │ │ ├── [hi](./31c1) +│ │ │ │ │ ├── [hi](./public) +│ │ │ │ │ └── src) +│ │ │ │ │ ├── [hi](./components) +│ │ │ │ │ └── hooks) +│ │ │ │ ├── [hi](./31d1) +│ │ │ │ │ ├── [hi](./public) +│ │ │ │ │ └── src) +│ │ │ │ │ ├── [hi](./components) +│ │ │ │ │ └── hooks) +│ │ │ │ ├── [hi](./31e1) +│ │ │ │ │ └── client) +│ │ │ │ │ ├── [hi](./public) +│ │ │ │ │ └── src) +│ │ │ │ │ ├── [hi](./components) +│ │ │ │ │ └── hooks) +│ │ │ │ ├── [hi](./32a1) +│ │ │ │ │ ├── [hi](./public) +│ │ │ │ │ └── src) +│ │ │ │ │ ├── [hi](./components) +│ │ │ │ │ ├── [hi](./contexts) +│ │ │ │ │ └── sass) +│ │ │ │ ├── [hi](./32b1) +│ │ │ │ │ ├── [hi](./public) +│ │ │ │ │ └── src) +│ │ │ │ │ ├── [hi](./components) +│ │ │ │ │ └── reducers) +│ │ │ │ ├── [hi](./32c1) +│ │ │ │ │ ├── [hi](./public) +│ │ │ │ │ └── src) +│ │ │ │ │ ├── [hi](./actions) +│ │ │ │ │ ├── [hi](./components) +│ │ │ │ │ └── reducers) +│ │ │ │ ├── [hi](./32d1) +│ │ │ │ │ ├── [hi](./public) +│ │ │ │ │ └── src) +│ │ │ │ │ ├── [hi](./actions) +│ │ │ │ │ ├── [hi](./components) +│ │ │ │ │ ├── [hi](./fonts) +│ │ │ │ │ ├── [hi](./img) +│ │ │ │ │ └── reducers) +│ │ │ │ ├── [hi](./32e1) +│ │ │ │ │ └── smurfs) +│ │ │ │ │ ├── [hi](./public) +│ │ │ │ │ └── src) +│ │ │ │ │ ├── [hi](./actions) +│ │ │ │ │ ├── [hi](./components) +│ │ │ │ │ └── reducers) +│ │ │ │ ├── [hi](./33a1) +│ │ │ │ │ ├── [hi](./public) +│ │ │ │ │ └── src) +│ │ │ │ │ ├── [hi](./controls) +│ │ │ │ │ ├── [hi](./dashboard) +│ │ │ │ │ └── display) +│ │ │ │ ├── [hi](./33b1) +│ │ │ │ │ └── friends) +│ │ │ │ │ ├── [hi](./public) +│ │ │ │ │ └── src) +│ │ │ │ │ ├── [hi](./actions) +│ │ │ │ │ ├── [hi](./components) +│ │ │ │ │ ├── [hi](./reducers) +│ │ │ │ │ └── utils) +│ │ │ │ ├── [hi](./33d1) +│ │ │ │ │ └── client) +│ │ │ │ │ ├── [hi](./public) +│ │ │ │ │ └── src) +│ │ │ │ │ └── Movies) +│ │ │ │ └── 33e1) +│ │ │ │ └── client) +│ │ │ │ ├── [hi](./public) +│ │ │ │ └── src) +│ │ │ │ ├── [hi](./actions) +│ │ │ │ ├── [hi](./components) +│ │ │ │ ├── [hi](./reducers) +│ │ │ │ └── utils) +│ │ │ ├── [hi](./m4) +│ │ │ │ ├── [hi](./41a1) +│ │ │ │ │ └── data) +│ │ │ │ │ ├── [hi](./migrations) +│ │ │ │ │ └── seeds) +│ │ │ │ ├── [hi](./41a2) +│ │ │ │ │ └── data) +│ │ │ │ │ ├── [hi](./migrations) +│ │ │ │ │ └── seeds) +│ │ │ │ ├── [hi](./41b1) +│ │ │ │ │ ├── [hi](./data) +│ │ │ │ │ │ ├── [hi](./migrations) +│ │ │ │ │ │ └── seeds) +│ │ │ │ │ └── hubs) +│ │ │ │ ├── [hi](./41b2) +│ │ │ │ │ └── data) +│ │ │ │ │ ├── [hi](./migrations) +│ │ │ │ │ └── seeds) +│ │ │ │ ├── [hi](./41c1) +│ │ │ │ │ ├── [hi](./data) +│ │ │ │ │ │ ├── [hi](./migrations) +│ │ │ │ │ │ └── seeds) +│ │ │ │ │ ├── [hi](./hubs) +│ │ │ │ │ └── messages) +│ │ │ │ ├── [hi](./41c2) +│ │ │ │ │ ├── [hi](./data) +│ │ │ │ │ │ ├── [hi](./migrations) +│ │ │ │ │ │ └── seeds) +│ │ │ │ │ ├── [hi](./posts) +│ │ │ │ │ └── users) +│ │ │ │ ├── [hi](./41d1) +│ │ │ │ │ ├── [hi](./api) +│ │ │ │ │ └── data) +│ │ │ │ │ └── migrations) +│ │ │ │ ├── [hi](./41e1) +│ │ │ │ │ ├── [hi](./data) +│ │ │ │ │ │ ├── [hi](./helpers) +│ │ │ │ │ │ ├── [hi](./migrations) +│ │ │ │ │ │ └── seeds) +│ │ │ │ │ └── routers) +│ │ │ │ ├── [hi](./41e1app) +│ │ │ │ │ ├── [hi](./public) +│ │ │ │ │ └── src) +│ │ │ │ │ └── components) +│ │ │ │ ├── [hi](./42a1) +│ │ │ │ │ ├── [hi](./data) +│ │ │ │ │ │ ├── [hi](./migrations) +│ │ │ │ │ │ └── seeds) +│ │ │ │ │ └── posts) +│ │ │ │ ├── [hi](./42a2) +│ │ │ │ │ ├── [hi](./data) +│ │ │ │ │ │ ├── [hi](./migrations) +│ │ │ │ │ │ └── seeds) +│ │ │ │ │ └── routers) +│ │ │ │ ├── [hi](./42b1) +│ │ │ │ │ ├── [hi](./api) +│ │ │ │ │ ├── [hi](./data) +│ │ │ │ │ └── fruits) +│ │ │ │ ├── [hi](./42b2) +│ │ │ │ │ ├── [hi](./api) +│ │ │ │ │ ├── [hi](./data) +│ │ │ │ │ │ ├── [hi](./migrations) +│ │ │ │ │ │ └── seeds) +│ │ │ │ │ └── routers) +│ │ │ │ ├── [hi](./42c1) +│ │ │ │ │ ├── [hi](./data) +│ │ │ │ │ │ ├── [hi](./migrations) +│ │ │ │ │ │ └── seeds) +│ │ │ │ │ └── users) +│ │ │ │ ├── [hi](./42c2) +│ │ │ │ │ ├── [hi](./data) +│ │ │ │ │ │ ├── [hi](./migrations) +│ │ │ │ │ │ └── seeds) +│ │ │ │ │ └── schemes) +│ │ │ │ ├── [hi](./42d1) +│ │ │ │ │ └── data) +│ │ │ │ │ └── seeds) +│ │ │ │ ├── [hi](./42d2) +│ │ │ │ │ ├── [hi](./data) +│ │ │ │ │ │ ├── [hi](./migrations) +│ │ │ │ │ │ └── seeds) +│ │ │ │ │ └── recipes) +│ │ │ │ ├── [hi](./42e1) +│ │ │ │ │ ├── [hi](./data) +│ │ │ │ │ │ ├── [hi](./migrations) +│ │ │ │ │ │ └── seeds) +│ │ │ │ │ └── projects) +│ │ │ │ ├── [hi](./43a1) +│ │ │ │ │ ├── [hi](./api) +│ │ │ │ │ ├── [hi](./auth) +│ │ │ │ │ ├── [hi](./database) +│ │ │ │ │ │ └── migrations) +│ │ │ │ │ ├── [hi](./__MACOSX) +│ │ │ │ │ │ └── authintro) +│ │ │ │ │ └── users) +│ │ │ │ ├── [hi](./43a2) +│ │ │ │ │ ├── [hi](./api) +│ │ │ │ │ ├── [hi](./auth) +│ │ │ │ │ ├── [hi](./database) +│ │ │ │ │ │ └── migrations) +│ │ │ │ │ └── users) +│ │ │ │ ├── [hi](./43b1) +│ │ │ │ │ ├── [hi](./api) +│ │ │ │ │ ├── [hi](./auth) +│ │ │ │ │ ├── [hi](./database) +│ │ │ │ │ │ └── migrations) +│ │ │ │ │ └── users) +│ │ │ │ ├── [hi](./43b2) +│ │ │ │ │ ├── [hi](./api) +│ │ │ │ │ ├── [hi](./auth) +│ │ │ │ │ ├── [hi](./database) +│ │ │ │ │ │ └── migrations) +│ │ │ │ │ └── users) +│ │ │ │ ├── [hi](./43c1) +│ │ │ │ │ ├── [hi](./api) +│ │ │ │ │ ├── [hi](./auth) +│ │ │ │ │ ├── [hi](./database) +│ │ │ │ │ │ └── migrations) +│ │ │ │ │ └── users) +│ │ │ │ ├── [hi](./43c2) +│ │ │ │ │ ├── [hi](./api) +│ │ │ │ │ ├── [hi](./auth) +│ │ │ │ │ ├── [hi](./config) +│ │ │ │ │ ├── [hi](./database) +│ │ │ │ │ │ └── migrations) +│ │ │ │ │ ├── [hi](./__MACOSX) +│ │ │ │ │ │ └── sessions) +│ │ │ │ │ └── users) +│ │ │ │ ├── [hi](./43d1) +│ │ │ │ │ ├── [hi](./api) +│ │ │ │ │ ├── [hi](./data) +│ │ │ │ │ │ ├── [hi](./migrations) +│ │ │ │ │ │ └── seeds) +│ │ │ │ │ └── hobbits) +│ │ │ │ ├── [hi](./43d2) +│ │ │ │ │ ├── [hi](./api) +│ │ │ │ │ ├── [hi](./cohorts) +│ │ │ │ │ ├── [hi](./database) +│ │ │ │ │ │ ├── [hi](./migrations) +│ │ │ │ │ │ └── seeds) +│ │ │ │ │ └── students) +│ │ │ │ └── 43e1) +│ │ │ │ ├── [hi](./43e1) +│ │ │ │ │ ├── [hi](./public) +│ │ │ │ │ └── src) +│ │ │ │ │ └── components) +│ │ │ │ ├── [hi](./api) +│ │ │ │ ├── [hi](./auth) +│ │ │ │ ├── [hi](./database) +│ │ │ │ │ └── migrations) +│ │ │ │ └── jokes) +│ │ │ ├── [hi](./m5) +│ │ │ │ ├── [hi](./51a1) +│ │ │ │ │ └── src) +│ │ │ │ │ └── employeeApp) +│ │ │ │ ├── [hi](./51b1) +│ │ │ │ │ └── src) +│ │ │ │ │ └── collections) +│ │ │ │ │ └── src) +│ │ │ │ │ └── collections) +│ │ │ │ ├── [hi](./51c1) +│ │ │ │ │ └── transportation) +│ │ │ │ │ └── src) +│ │ │ │ │ └── transport) +│ │ │ │ ├── [hi](./51d1) +│ │ │ │ │ ├── [hi](./bin) +│ │ │ │ │ │ └── src) +│ │ │ │ │ │ ├── [hi](./main) +│ │ │ │ │ │ │ ├── [hi](./java) +│ │ │ │ │ │ │ │ └── com) +│ │ │ │ │ │ │ │ └── lambdaschool) +│ │ │ │ │ │ │ │ └── webemployees3) +│ │ │ │ │ │ │ └── resources) +│ │ │ │ │ │ └── test) +│ │ │ │ │ │ └── java) +│ │ │ │ │ │ └── com) +│ │ │ │ │ │ └── lambdaschool) +│ │ │ │ │ │ └── webemployees3) +│ │ │ │ │ └── src) +│ │ │ │ │ ├── [hi](./main) +│ │ │ │ │ │ ├── [hi](./java) +│ │ │ │ │ │ │ └── com) +│ │ │ │ │ │ │ └── lambdaschool) +│ │ │ │ │ │ │ └── j51d1) +│ │ │ │ │ │ └── resources) +│ │ │ │ │ │ └── static) +│ │ │ │ │ └── test) +│ │ │ │ │ └── java) +│ │ │ │ │ └── com) +│ │ │ │ │ └── lambdaschool) +│ │ │ │ │ └── webemployees3) +│ │ │ │ ├── [hi](./51d2) +│ │ │ │ │ └── src) +│ │ │ │ │ ├── [hi](./main) +│ │ │ │ │ │ ├── [hi](./java) +│ │ │ │ │ │ │ └── com) +│ │ │ │ │ │ │ └── lambdaschool) +│ │ │ │ │ │ │ └── j51d2) +│ │ │ │ │ │ └── resources) +│ │ │ │ │ └── test) +│ │ │ │ │ └── java) +│ │ │ │ │ └── com) +│ │ │ │ │ └── lambdaschool) +│ │ │ │ │ └── j51d2) +│ │ │ │ ├── [hi](./51e1) +│ │ │ │ │ └── src) +│ │ │ │ │ ├── [hi](./main) +│ │ │ │ │ │ ├── [hi](./java) +│ │ │ │ │ │ │ └── com) +│ │ │ │ │ │ │ └── lambdaschool) +│ │ │ │ │ │ │ └── j51e1) +│ │ │ │ │ │ └── resources) +│ │ │ │ │ └── test) +│ │ │ │ │ └── java) +│ │ │ │ │ └── com) +│ │ │ │ │ └── lambdaschool) +│ │ │ │ │ └── j51e1) +│ │ │ │ ├── [hi](./52b1) +│ │ │ │ │ └── assets) +│ │ │ │ ├── [hi](./52c1) +│ │ │ │ │ └── src) +│ │ │ │ │ ├── [hi](./main) +│ │ │ │ │ │ ├── [hi](./java) +│ │ │ │ │ │ │ └── com) +│ │ │ │ │ │ │ └── lambdaschool) +│ │ │ │ │ │ │ └── j52c1) +│ │ │ │ │ │ │ ├── [hi](./controllers) +│ │ │ │ │ │ │ ├── [hi](./models) +│ │ │ │ │ │ │ ├── [hi](./repos) +│ │ │ │ │ │ │ └── services) +│ │ │ │ │ │ └── resources) +│ │ │ │ │ └── test) +│ │ │ │ │ └── java) +│ │ │ │ │ └── com) +│ │ │ │ │ └── lambdaschool) +│ │ │ │ │ └── j52c1) +│ │ │ │ ├── [hi](./52c2) +│ │ │ │ │ └── src) +│ │ │ │ │ ├── [hi](./main) +│ │ │ │ │ │ ├── [hi](./java) +│ │ │ │ │ │ │ └── com) +│ │ │ │ │ │ │ └── lambdaschool) +│ │ │ │ │ │ │ └── j52c2) +│ │ │ │ │ │ │ ├── [hi](./controllers) +│ │ │ │ │ │ │ ├── [hi](./models) +│ │ │ │ │ │ │ ├── [hi](./repos) +│ │ │ │ │ │ │ └── services) +│ │ │ │ │ │ └── resources) +│ │ │ │ │ └── test) +│ │ │ │ │ └── java) +│ │ │ │ │ └── com) +│ │ │ │ │ └── lambdaschool) +│ │ │ │ │ └── j52c2) +│ │ │ │ ├── [hi](./52d1) +│ │ │ │ │ └── oauth) +│ │ │ │ │ ├── [hi](./oauth2) +│ │ │ │ │ │ └── src) +│ │ │ │ │ │ ├── [hi](./main) +│ │ │ │ │ │ │ ├── [hi](./java) +│ │ │ │ │ │ │ │ └── com) +│ │ │ │ │ │ │ │ └── lambdaschool) +│ │ │ │ │ │ │ │ └── usermodel) +│ │ │ │ │ │ │ │ ├── [hi](./config) +│ │ │ │ │ │ │ │ ├── [hi](./controllers) +│ │ │ │ │ │ │ │ ├── [hi](./exceptions) +│ │ │ │ │ │ │ │ ├── [hi](./handlers) +│ │ │ │ │ │ │ │ ├── [hi](./logging) +│ │ │ │ │ │ │ │ ├── [hi](./models) +│ │ │ │ │ │ │ │ ├── [hi](./repository) +│ │ │ │ │ │ │ │ ├── [hi](./services) +│ │ │ │ │ │ │ │ └── view) +│ │ │ │ │ │ │ └── resources) +│ │ │ │ │ │ │ └── info) +│ │ │ │ │ │ └── test) +│ │ │ │ │ │ ├── [hi](./java) +│ │ │ │ │ │ │ └── com) +│ │ │ │ │ │ │ └── lambdaschool) +│ │ │ │ │ │ │ └── usermodel) +│ │ │ │ │ │ │ ├── [hi](./controllers) +│ │ │ │ │ │ │ └── services) +│ │ │ │ │ │ └── resources) +│ │ │ │ │ └── oauth2 - initial) +│ │ │ │ │ └── src) +│ │ │ │ │ ├── [hi](./main) +│ │ │ │ │ │ ├── [hi](./java) +│ │ │ │ │ │ │ └── com) +│ │ │ │ │ │ │ └── lambdaschool) +│ │ │ │ │ │ │ ├── [hi](./authenticatedusers) +│ │ │ │ │ │ │ │ ├── [hi](./config) +│ │ │ │ │ │ │ │ ├── [hi](./controller) +│ │ │ │ │ │ │ │ ├── [hi](./model) +│ │ │ │ │ │ │ │ ├── [hi](./repository) +│ │ │ │ │ │ │ │ ├── [hi](./service) +│ │ │ │ │ │ │ │ └── view) +│ │ │ │ │ │ │ └── usermodel) +│ │ │ │ │ │ │ ├── [hi](./config) +│ │ │ │ │ │ │ ├── [hi](./controllers) +│ │ │ │ │ │ │ ├── [hi](./exceptions) +│ │ │ │ │ │ │ ├── [hi](./handlers) +│ │ │ │ │ │ │ ├── [hi](./logging) +│ │ │ │ │ │ │ ├── [hi](./models) +│ │ │ │ │ │ │ ├── [hi](./repository) +│ │ │ │ │ │ │ ├── [hi](./services) +│ │ │ │ │ │ │ └── view) +│ │ │ │ │ │ └── resources) +│ │ │ │ │ │ └── info) +│ │ │ │ │ └── test) +│ │ │ │ │ └── java) +│ │ │ │ │ └── com) +│ │ │ │ │ └── lambdaschool) +│ │ │ │ │ ├── [hi](./authenticatedusers) +│ │ │ │ │ └── usermodel) +│ │ │ │ ├── [hi](./53a1) +│ │ │ │ │ ├── [hi](./oauth2ExceptionLogging-final) +│ │ │ │ │ │ └── src) +│ │ │ │ │ │ └── main) +│ │ │ │ │ │ ├── [hi](./java) +│ │ │ │ │ │ │ └── com) +│ │ │ │ │ │ │ └── lambdaschool) +│ │ │ │ │ │ │ └── oauth2) +│ │ │ │ │ │ │ ├── [hi](./config) +│ │ │ │ │ │ │ ├── [hi](./controllers) +│ │ │ │ │ │ │ ├── [hi](./exceptions) +│ │ │ │ │ │ │ ├── [hi](./handlers) +│ │ │ │ │ │ │ ├── [hi](./logging) +│ │ │ │ │ │ │ ├── [hi](./models) +│ │ │ │ │ │ │ ├── [hi](./repository) +│ │ │ │ │ │ │ ├── [hi](./services) +│ │ │ │ │ │ │ └── view) +│ │ │ │ │ │ └── resources) +│ │ │ │ │ └── src) +│ │ │ │ │ ├── [hi](./main) +│ │ │ │ │ │ ├── [hi](./java) +│ │ │ │ │ │ │ └── com) +│ │ │ │ │ │ │ └── lambdaschool) +│ │ │ │ │ │ │ └── authenticatedusers) +│ │ │ │ │ │ │ ├── [hi](./config) +│ │ │ │ │ │ │ ├── [hi](./controller) +│ │ │ │ │ │ │ ├── [hi](./exceptions) +│ │ │ │ │ │ │ ├── [hi](./handlers) +│ │ │ │ │ │ │ ├── [hi](./model) +│ │ │ │ │ │ │ ├── [hi](./repository) +│ │ │ │ │ │ │ ├── [hi](./service) +│ │ │ │ │ │ │ └── view) +│ │ │ │ │ │ └── resources) +│ │ │ │ │ │ └── info) +│ │ │ │ │ └── test) +│ │ │ │ │ └── java) +│ │ │ │ │ └── com) +│ │ │ │ │ └── lambdaschool) +│ │ │ │ │ ├── [hi](./authenticatedusers) +│ │ │ │ │ └── usermodel) +│ │ │ │ ├── [hi](./53b1) +│ │ │ │ │ ├── [hi](./clientrestaurants) +│ │ │ │ │ │ └── src) +│ │ │ │ │ │ ├── [hi](./main) +│ │ │ │ │ │ │ ├── [hi](./java) +│ │ │ │ │ │ │ │ └── com) +│ │ │ │ │ │ │ │ └── lambda) +│ │ │ │ │ │ │ │ └── clientrestaurants) +│ │ │ │ │ │ │ │ ├── [hi](./client) +│ │ │ │ │ │ │ │ └── model) +│ │ │ │ │ │ │ └── resources) +│ │ │ │ │ │ └── test) +│ │ │ │ │ │ └── java) +│ │ │ │ │ │ └── com) +│ │ │ │ │ │ └── lambda) +│ │ │ │ │ │ └── clientrestaurants) +│ │ │ │ │ ├── [hi](./restaurants-initial) +│ │ │ │ │ │ └── src) +│ │ │ │ │ │ └── main) +│ │ │ │ │ │ ├── [hi](./java) +│ │ │ │ │ │ │ └── com) +│ │ │ │ │ │ │ └── lambdaschool) +│ │ │ │ │ │ │ └── restaurants) +│ │ │ │ │ │ │ ├── [hi](./config) +│ │ │ │ │ │ │ ├── [hi](./controller) +│ │ │ │ │ │ │ ├── [hi](./model) +│ │ │ │ │ │ │ ├── [hi](./repos) +│ │ │ │ │ │ │ └── service) +│ │ │ │ │ │ └── resources) +│ │ │ │ │ │ └── info) +│ │ │ │ │ └── restaurants-pagesswagger) +│ │ │ │ │ └── src) +│ │ │ │ │ └── main) +│ │ │ │ │ ├── [hi](./java) +│ │ │ │ │ │ └── com) +│ │ │ │ │ │ └── lambdaschool) +│ │ │ │ │ │ └── restaurants) +│ │ │ │ │ │ ├── [hi](./config) +│ │ │ │ │ │ ├── [hi](./controller) +│ │ │ │ │ │ ├── [hi](./exception) +│ │ │ │ │ │ ├── [hi](./model) +│ │ │ │ │ │ ├── [hi](./repos) +│ │ │ │ │ │ └── service) +│ │ │ │ │ └── resources) +│ │ │ │ │ ├── [hi](./info) +│ │ │ │ │ └── templates) +│ │ │ │ ├── [hi](./53c1) +│ │ │ │ │ ├── [hi](./restaurants-initial) +│ │ │ │ │ │ └── src) +│ │ │ │ │ │ └── main) +│ │ │ │ │ │ ├── [hi](./java) +│ │ │ │ │ │ │ └── com) +│ │ │ │ │ │ │ └── lambdaschool) +│ │ │ │ │ │ │ └── restaurants) +│ │ │ │ │ │ │ ├── [hi](./config) +│ │ │ │ │ │ │ ├── [hi](./controller) +│ │ │ │ │ │ │ ├── [hi](./model) +│ │ │ │ │ │ │ ├── [hi](./repos) +│ │ │ │ │ │ │ └── service) +│ │ │ │ │ │ └── resources) +│ │ │ │ │ │ └── info) +│ │ │ │ │ └── restaurants-testing) +│ │ │ │ │ └── src) +│ │ │ │ │ ├── [hi](./main) +│ │ │ │ │ │ ├── [hi](./java) +│ │ │ │ │ │ │ └── com) +│ │ │ │ │ │ │ └── lambdaschool) +│ │ │ │ │ │ │ └── restaurants) +│ │ │ │ │ │ │ ├── [hi](./config) +│ │ │ │ │ │ │ ├── [hi](./controller) +│ │ │ │ │ │ │ ├── [hi](./model) +│ │ │ │ │ │ │ ├── [hi](./repos) +│ │ │ │ │ │ │ └── service) +│ │ │ │ │ │ └── resources) +│ │ │ │ │ │ └── info) +│ │ │ │ │ └── test) +│ │ │ │ │ ├── [hi](./java) +│ │ │ │ │ │ └── com) +│ │ │ │ │ │ └── lambdaschool) +│ │ │ │ │ │ └── restaurants) +│ │ │ │ │ │ ├── [hi](./controller) +│ │ │ │ │ │ └── service) +│ │ │ │ │ └── resources) +│ │ │ │ └── 53d1) +│ │ │ │ ├── [hi](./JS-FrontEnd-by-jheinz1999) +│ │ │ │ │ ├── [hi](./public) +│ │ │ │ │ └── src) +│ │ │ │ │ └── components) +│ │ │ │ └── StartHere) +│ │ │ │ └── src) +│ │ │ │ ├── [hi](./main) +│ │ │ │ │ ├── [hi](./java) +│ │ │ │ │ │ └── com) +│ │ │ │ │ │ └── lambdaschool) +│ │ │ │ │ │ └── starthere) +│ │ │ │ │ │ ├── [hi](./config) +│ │ │ │ │ │ ├── [hi](./controllers) +│ │ │ │ │ │ ├── [hi](./exceptions) +│ │ │ │ │ │ ├── [hi](./handlers) +│ │ │ │ │ │ ├── [hi](./logging) +│ │ │ │ │ │ ├── [hi](./models) +│ │ │ │ │ │ ├── [hi](./repository) +│ │ │ │ │ │ ├── [hi](./services) +│ │ │ │ │ │ └── view) +│ │ │ │ │ └── resources) +│ │ │ │ │ └── info) +│ │ │ │ └── test) +│ │ │ │ ├── [hi](./java) +│ │ │ │ │ └── com) +│ │ │ │ │ └── lambdaschool) +│ │ │ │ │ └── starthere) +│ │ │ │ │ ├── [hi](./controllers) +│ │ │ │ │ └── services) +│ │ │ │ └── resources) +│ │ │ ├── [hi](./m6) +│ │ │ │ ├── [hi](./61a1) +│ │ │ │ │ └── src) +│ │ │ │ ├── [hi](./61b1) +│ │ │ │ │ ├── [hi](./examples) +│ │ │ │ │ └── src) +│ │ │ │ ├── [hi](./61c1) +│ │ │ │ │ └── src) +│ │ │ │ │ ├── [hi](./cityreader) +│ │ │ │ │ ├── [hi](./comp) +│ │ │ │ │ └── oop) +│ │ │ │ ├── [hi](./62a1) +│ │ │ │ │ ├── [hi](./avl_tree) +│ │ │ │ │ ├── [hi](./benchmarks) +│ │ │ │ │ ├── [hi](./binary_search_tree) +│ │ │ │ │ ├── [hi](./doubly_linked_list) +│ │ │ │ │ ├── [hi](./heap) +│ │ │ │ │ ├── [hi](./lru_cache) +│ │ │ │ │ ├── [hi](./queue) +│ │ │ │ │ ├── [hi](./queue_and_stack) +│ │ │ │ │ ├── [hi](./singly_linked_list) +│ │ │ │ │ └── stack) +│ │ │ │ ├── [hi](./62b1) +│ │ │ │ │ ├── [hi](./names) +│ │ │ │ │ ├── [hi](./reverse) +│ │ │ │ │ └── ring_buffer) +│ │ │ │ ├── [hi](./63a1) +│ │ │ │ │ └── src) +│ │ │ │ │ ├── [hi](./iterative_sorting) +│ │ │ │ │ └── searching) +│ │ │ │ ├── [hi](./63b1) +│ │ │ │ │ └── src) +│ │ │ │ │ └── recursive_sorting) +│ │ │ │ ├── [hi](./63c1) +│ │ │ │ │ ├── [hi](./eating_cookies) +│ │ │ │ │ ├── [hi](./knapsack) +│ │ │ │ │ │ └── data) +│ │ │ │ │ ├── [hi](./making_change) +│ │ │ │ │ ├── [hi](./moving_zeroes) +│ │ │ │ │ ├── [hi](./product_of_all_other_numbers) +│ │ │ │ │ ├── [hi](./recipe_batches) +│ │ │ │ │ ├── [hi](./rock_paper_scissors) +│ │ │ │ │ ├── [hi](./single_number) +│ │ │ │ │ ├── [hi](./sliding_window_max) +│ │ │ │ │ │ └── data) +│ │ │ │ │ └── stock_prices) +│ │ │ │ └── 63d1) +│ │ │ │ ├── [hi](./recursive_count_th) +│ │ │ │ ├── [hi](./robot_sort) +│ │ │ │ └── Short-Answer) +│ │ │ ├── [hi](./m7) +│ │ │ │ ├── [hi](./71a1) +│ │ │ │ │ ├── [hi](./applications) +│ │ │ │ │ │ ├── [hi](./crack_caesar) +│ │ │ │ │ │ ├── [hi](./expensive_seq) +│ │ │ │ │ │ ├── [hi](./histo) +│ │ │ │ │ │ ├── [hi](./lookup_table) +│ │ │ │ │ │ ├── [hi](./markov) +│ │ │ │ │ │ ├── [hi](./no_dups) +│ │ │ │ │ │ ├── [hi](./sumdiff) +│ │ │ │ │ │ └── word_count) +│ │ │ │ │ └── hashtable) +│ │ │ │ ├── [hi](./71e1) +│ │ │ │ │ └── hashtables) +│ │ │ │ │ ├── [hi](./ex1) +│ │ │ │ │ ├── [hi](./ex2) +│ │ │ │ │ ├── [hi](./ex3) +│ │ │ │ │ ├── [hi](./ex4) +│ │ │ │ │ └── ex5) +│ │ │ │ ├── [hi](./72a1) +│ │ │ │ │ ├── [hi](./objectives) +│ │ │ │ │ │ ├── [hi](./breadth-first-search) +│ │ │ │ │ │ │ └── img) +│ │ │ │ │ │ ├── [hi](./connected-components) +│ │ │ │ │ │ │ └── img) +│ │ │ │ │ │ ├── [hi](./depth-first-search) +│ │ │ │ │ │ │ └── img) +│ │ │ │ │ │ ├── [hi](./graph-intro) +│ │ │ │ │ │ │ └── img) +│ │ │ │ │ │ ├── [hi](./graph-representations) +│ │ │ │ │ │ │ └── img) +│ │ │ │ │ │ └── randomness) +│ │ │ │ │ └── projects) +│ │ │ │ │ ├── [hi](./adventure) +│ │ │ │ │ │ └── maps) +│ │ │ │ │ ├── [hi](./ancestor) +│ │ │ │ │ ├── [hi](./graph) +│ │ │ │ │ └── social) +│ │ │ │ ├── [hi](./73a1) +│ │ │ │ │ ├── [hi](./asm) +│ │ │ │ │ └── ls8) +│ │ │ │ │ └── examples) +│ │ │ │ └── 74a1) +│ │ │ ├── [hi](./src) +│ │ │ │ ├── [hi](./iterative_sorting) +│ │ │ │ └── searching) +│ │ │ ├── [hi](./summary) +│ │ │ │ ├── [hi](./certifications) +│ │ │ │ │ ├── [hi](./IBM zOS) +│ │ │ │ │ └── Oracle Autonomous DB) +│ │ │ │ │ ├── [hi](./1 Overview) +│ │ │ │ │ ├── [hi](./2 Provisioning and Connectivity) +│ │ │ │ │ ├── [hi](./3 Migration and Data Loding into Autonomous DB) +│ │ │ │ │ ├── [hi](./4 Migrating and Data Loading) +│ │ │ │ │ ├── [hi](./5 Monitoring Autonomous DB) +│ │ │ │ │ └── 6 Tools Reporting Analytics) +│ │ │ │ ├── [hi](./cobol) +│ │ │ │ │ ├── [hi](./COBOL example programs_files) +│ │ │ │ │ ├── [hi](./COBOL Programming Course_files) +│ │ │ │ │ └── COBOL Programming Exercises_files) +│ │ │ │ ├── [hi](./complete) +│ │ │ │ │ ├── [hi](./Decks) +│ │ │ │ │ └── notes-books) +│ │ │ │ ├── [hi](./general) +│ │ │ │ ├── [hi](./interviewing) +│ │ │ │ ├── [hi](./Node Express Knex) +│ │ │ │ │ └── Create Back End Guide) +│ │ │ │ ├── [hi](./testing) +│ │ │ │ └── typescript) +│ │ │ └── tlbw) +│ │ │ └── client) +│ │ │ ├── [hi](./public) +│ │ │ └── src) +│ │ │ ├── [hi](./components) +│ │ │ │ ├── [hi](./context) +│ │ │ │ │ └── strainsSelectContext) +│ │ │ │ └── strains) +│ │ │ └── imgs) +│ │ ├── [hi](./_misc) +│ │ │ └── Blockchain-Notes-master) +│ │ │ └── communication_gp) +│ │ ├── [hi](./Mongo-I-master) +│ │ │ └── src) +│ │ │ ├── [hi](./controllers) +│ │ │ ├── [hi](./models) +│ │ │ └── routes) +│ │ ├── [hi](./_MOST-USEFUL) +│ │ │ └── Boilerplate-master) +│ │ │ ├── [hi](./Apollo) +│ │ │ │ ├── [hi](./client) +│ │ │ │ ├── [hi](./imports) +│ │ │ │ │ ├── [hi](./api) +│ │ │ │ │ └── ui) +│ │ │ │ └── server) +│ │ │ ├── [hi](./Express-MongoDB) +│ │ │ │ └── src) +│ │ │ │ ├── [hi](./config) +│ │ │ │ ├── [hi](./controllers) +│ │ │ │ └── __tests__) +│ │ │ ├── [hi](./React-Redux) +│ │ │ │ └── src) +│ │ │ │ ├── [hi](./actions) +│ │ │ │ ├── [hi](./assets) +│ │ │ │ ├── [hi](./containers) +│ │ │ │ ├── [hi](./reducers) +│ │ │ │ └── tests) +│ │ │ │ ├── [hi](./__mock__) +│ │ │ │ └── __tests__) +│ │ │ │ └── __snapshots__) +│ │ │ └── TypeGraphQL) +│ │ ├── [hi](./Node-Blog-master) +│ │ │ ├── [hi](./api) +│ │ │ │ ├── [hi](./post) +│ │ │ │ ├── [hi](./tag) +│ │ │ │ └── user) +│ │ │ ├── [hi](./config) +│ │ │ ├── [hi](./data) +│ │ │ │ ├── [hi](./helpers) +│ │ │ │ ├── [hi](./migrations) +│ │ │ │ └── seeds) +│ │ │ └── routers) +│ │ ├── [hi](./portfolio-main) +│ │ │ ├── [hi](./components) +│ │ │ ├── [hi](./pages) +│ │ │ ├── [hi](./public) +│ │ │ │ └── static) +│ │ │ │ ├── [hi](./favicons) +│ │ │ │ └── images) +│ │ │ ├── [hi](./scripts) +│ │ │ ├── [hi](./styles) +│ │ │ └── utils) +│ │ ├── [hi](./Precourse-master) +│ │ │ ├── [hi](./Lesson10-JS-VII) +│ │ │ │ └── homework) +│ │ │ │ └── tests) +│ │ │ ├── [hi](./Lesson11-JS-VIII) +│ │ │ │ └── homework) +│ │ │ │ └── tests) +│ │ │ ├── [hi](./Lesson12-DOM) +│ │ │ │ └── homework) +│ │ │ │ ├── [hi](./assets) +│ │ │ │ └── __tests__) +│ │ │ ├── [hi](./Lesson1-Git) +│ │ │ ├── [hi](./Lesson2-HTML-CSS) +│ │ │ │ └── homework) +│ │ │ ├── [hi](./Lesson3-CSS-Positioning) +│ │ │ │ └── homework) +│ │ │ │ └── assets) +│ │ │ ├── [hi](./Lesson4-JS-I) +│ │ │ │ └── homework) +│ │ │ │ └── tests) +│ │ │ ├── [hi](./Lesson5-JS-II) +│ │ │ │ └── homework) +│ │ │ │ └── tests) +│ │ │ ├── [hi](./Lesson6-JS-III) +│ │ │ │ └── homework) +│ │ │ │ └── tests) +│ │ │ ├── [hi](./Lesson7-JS-IV) +│ │ │ │ └── homework) +│ │ │ │ └── tests) +│ │ │ ├── [hi](./Lesson8-JS-V) +│ │ │ │ └── homework) +│ │ │ │ └── tests) +│ │ │ └── Lesson9-JS-VI) +│ │ │ └── homework) +│ │ │ └── tests) +│ │ ├── [hi](./Python-II-Notes-master) +│ │ │ └── src) +│ │ ├── [hi](./Python-master) +│ │ │ ├── [hi](./arithmetic_analysis) +│ │ │ │ └── image_data) +│ │ │ ├── [hi](./backtracking) +│ │ │ ├── [hi](./bit_manipulation) +│ │ │ ├── [hi](./blockchain) +│ │ │ ├── [hi](./boolean_algebra) +│ │ │ ├── [hi](./cellular_automata) +│ │ │ ├── [hi](./ciphers) +│ │ │ ├── [hi](./compression) +│ │ │ │ └── image_data) +│ │ │ ├── [hi](./computer_vision) +│ │ │ ├── [hi](./conversions) +│ │ │ ├── [hi](./data_structures) +│ │ │ │ ├── [hi](./binary_tree) +│ │ │ │ ├── [hi](./disjoint_set) +│ │ │ │ ├── [hi](./hashing) +│ │ │ │ │ └── number_theory) +│ │ │ │ ├── [hi](./heap) +│ │ │ │ ├── [hi](./linked_list) +│ │ │ │ ├── [hi](./queue) +│ │ │ │ ├── [hi](./stacks) +│ │ │ │ └── trie) +│ │ │ ├── [hi](./digital_image_processing) +│ │ │ │ ├── [hi](./dithering) +│ │ │ │ ├── [hi](./edge_detection) +│ │ │ │ ├── [hi](./filters) +│ │ │ │ ├── [hi](./histogram_equalization) +│ │ │ │ │ ├── [hi](./image_data) +│ │ │ │ │ └── output_data) +│ │ │ │ ├── [hi](./image_data) +│ │ │ │ ├── [hi](./resize) +│ │ │ │ └── rotation) +│ │ │ ├── [hi](./divide_and_conquer) +│ │ │ ├── [hi](./dynamic_programming) +│ │ │ ├── [hi](./electronics) +│ │ │ ├── [hi](./file_transfer) +│ │ │ │ └── tests) +│ │ │ ├── [hi](./fuzzy_logic) +│ │ │ ├── [hi](./genetic_algorithm) +│ │ │ ├── [hi](./geodesy) +│ │ │ ├── [hi](./graphics) +│ │ │ ├── [hi](./graphs) +│ │ │ │ └── tests) +│ │ │ ├── [hi](./hashes) +│ │ │ ├── [hi](./knapsack) +│ │ │ │ └── tests) +│ │ │ ├── [hi](./linear_algebra) +│ │ │ │ └── src) +│ │ │ ├── [hi](./machine_learning) +│ │ │ │ ├── [hi](./forecasting) +│ │ │ │ └── lstm) +│ │ │ ├── [hi](./maths) +│ │ │ │ ├── [hi](./images) +│ │ │ │ └── series) +│ │ │ ├── [hi](./matrix) +│ │ │ │ └── tests) +│ │ │ ├── [hi](./networking_flow) +│ │ │ ├── [hi](./neural_network) +│ │ │ ├── [hi](./other) +│ │ │ ├── [hi](./project_euler) +│ │ │ │ ├── [hi](./problem_001) +│ │ │ │ ├── [hi](./problem_002) +│ │ │ │ ├── [hi](./problem_003) +│ │ │ │ ├── [hi](./problem_004) +│ │ │ │ ├── [hi](./problem_005) +│ │ │ │ ├── [hi](./problem_006) +│ │ │ │ ├── [hi](./problem_007) +│ │ │ │ ├── [hi](./problem_008) +│ │ │ │ ├── [hi](./problem_009) +│ │ │ │ ├── [hi](./problem_010) +│ │ │ │ ├── [hi](./problem_011) +│ │ │ │ ├── [hi](./problem_012) +│ │ │ │ ├── [hi](./problem_013) +│ │ │ │ ├── [hi](./problem_014) +│ │ │ │ ├── [hi](./problem_015) +│ │ │ │ ├── [hi](./problem_016) +│ │ │ │ ├── [hi](./problem_017) +│ │ │ │ ├── [hi](./problem_018) +│ │ │ │ ├── [hi](./problem_019) +│ │ │ │ ├── [hi](./problem_020) +│ │ │ │ ├── [hi](./problem_021) +│ │ │ │ ├── [hi](./problem_022) +│ │ │ │ ├── [hi](./problem_023) +│ │ │ │ ├── [hi](./problem_024) +│ │ │ │ ├── [hi](./problem_025) +│ │ │ │ ├── [hi](./problem_026) +│ │ │ │ ├── [hi](./problem_027) +│ │ │ │ ├── [hi](./problem_028) +│ │ │ │ ├── [hi](./problem_029) +│ │ │ │ ├── [hi](./problem_030) +│ │ │ │ ├── [hi](./problem_031) +│ │ │ │ ├── [hi](./problem_032) +│ │ │ │ ├── [hi](./problem_033) +│ │ │ │ ├── [hi](./problem_034) +│ │ │ │ ├── [hi](./problem_035) +│ │ │ │ ├── [hi](./problem_036) +│ │ │ │ ├── [hi](./problem_037) +│ │ │ │ ├── [hi](./problem_038) +│ │ │ │ ├── [hi](./problem_039) +│ │ │ │ ├── [hi](./problem_040) +│ │ │ │ ├── [hi](./problem_041) +│ │ │ │ ├── [hi](./problem_042) +│ │ │ │ ├── [hi](./problem_043) +│ │ │ │ ├── [hi](./problem_044) +│ │ │ │ ├── [hi](./problem_045) +│ │ │ │ ├── [hi](./problem_046) +│ │ │ │ ├── [hi](./problem_047) +│ │ │ │ ├── [hi](./problem_048) +│ │ │ │ ├── [hi](./problem_049) +│ │ │ │ ├── [hi](./problem_050) +│ │ │ │ ├── [hi](./problem_051) +│ │ │ │ ├── [hi](./problem_052) +│ │ │ │ ├── [hi](./problem_053) +│ │ │ │ ├── [hi](./problem_054) +│ │ │ │ ├── [hi](./problem_055) +│ │ │ │ ├── [hi](./problem_056) +│ │ │ │ ├── [hi](./problem_057) +│ │ │ │ ├── [hi](./problem_058) +│ │ │ │ ├── [hi](./problem_059) +│ │ │ │ ├── [hi](./problem_062) +│ │ │ │ ├── [hi](./problem_063) +│ │ │ │ ├── [hi](./problem_064) +│ │ │ │ ├── [hi](./problem_065) +│ │ │ │ ├── [hi](./problem_067) +│ │ │ │ ├── [hi](./problem_069) +│ │ │ │ ├── [hi](./problem_070) +│ │ │ │ ├── [hi](./problem_071) +│ │ │ │ ├── [hi](./problem_072) +│ │ │ │ ├── [hi](./problem_074) +│ │ │ │ ├── [hi](./problem_075) +│ │ │ │ ├── [hi](./problem_076) +│ │ │ │ ├── [hi](./problem_077) +│ │ │ │ ├── [hi](./problem_080) +│ │ │ │ ├── [hi](./problem_081) +│ │ │ │ ├── [hi](./problem_085) +│ │ │ │ ├── [hi](./problem_086) +│ │ │ │ ├── [hi](./problem_087) +│ │ │ │ ├── [hi](./problem_089) +│ │ │ │ ├── [hi](./problem_091) +│ │ │ │ ├── [hi](./problem_097) +│ │ │ │ ├── [hi](./problem_099) +│ │ │ │ ├── [hi](./problem_101) +│ │ │ │ ├── [hi](./problem_102) +│ │ │ │ ├── [hi](./problem_107) +│ │ │ │ ├── [hi](./problem_112) +│ │ │ │ ├── [hi](./problem_113) +│ │ │ │ ├── [hi](./problem_119) +│ │ │ │ ├── [hi](./problem_120) +│ │ │ │ ├── [hi](./problem_123) +│ │ │ │ ├── [hi](./problem_125) +│ │ │ │ ├── [hi](./problem_129) +│ │ │ │ ├── [hi](./problem_135) +│ │ │ │ ├── [hi](./problem_173) +│ │ │ │ ├── [hi](./problem_174) +│ │ │ │ ├── [hi](./problem_180) +│ │ │ │ ├── [hi](./problem_188) +│ │ │ │ ├── [hi](./problem_191) +│ │ │ │ ├── [hi](./problem_203) +│ │ │ │ ├── [hi](./problem_206) +│ │ │ │ ├── [hi](./problem_207) +│ │ │ │ ├── [hi](./problem_234) +│ │ │ │ ├── [hi](./problem_301) +│ │ │ │ └── problem_551) +│ │ │ ├── [hi](./quantum) +│ │ │ ├── [hi](./scheduling) +│ │ │ ├── [hi](./scripts) +│ │ │ ├── [hi](./searches) +│ │ │ ├── [hi](./sorts) +│ │ │ ├── [hi](./strings) +│ │ │ ├── [hi](./traversals) +│ │ │ └── web_programming) +│ │ ├── [hi](./react-carousel-master) +│ │ │ ├── [hi](./public) +│ │ │ └── src) +│ │ │ └── assets) +│ │ ├── [hi](./react-design-patterns-and-best-practices-master) +│ │ │ ├── [hi](./chapter-03) +│ │ │ │ └── reusable-components) +│ │ │ │ ├── [hi](./src) +│ │ │ │ │ └── components) +│ │ │ │ └── stories) +│ │ │ ├── [hi](./chapter-04) +│ │ │ │ ├── [hi](./container-presentational) +│ │ │ │ │ └── src) +│ │ │ │ │ └── components) +│ │ │ │ │ └── geolocation) +│ │ │ │ └── higher-order-components) +│ │ │ │ └── src) +│ │ │ │ └── components) +│ │ │ ├── [hi](./chapter-05) +│ │ │ │ ├── [hi](./data-fetching) +│ │ │ │ │ └── src) +│ │ │ │ │ └── components) +│ │ │ │ ├── [hi](./data-flow) +│ │ │ │ │ └── src) +│ │ │ │ │ └── components) +│ │ │ │ └── react-refetch) +│ │ │ │ └── src) +│ │ │ │ └── components) +│ │ │ ├── [hi](./chapter-06) +│ │ │ │ ├── [hi](./controlled-components) +│ │ │ │ │ └── src) +│ │ │ │ │ └── components) +│ │ │ │ ├── [hi](./css-transition-group) +│ │ │ │ │ └── src) +│ │ │ │ │ └── components) +│ │ │ │ ├── [hi](./event-switch) +│ │ │ │ │ └── src) +│ │ │ │ │ └── components) +│ │ │ │ ├── [hi](./json-schema) +│ │ │ │ │ └── src) +│ │ │ │ │ └── components) +│ │ │ │ ├── [hi](./react-motion) +│ │ │ │ │ └── src) +│ │ │ │ │ └── components) +│ │ │ │ ├── [hi](./refs-dom) +│ │ │ │ │ └── src) +│ │ │ │ │ └── components) +│ │ │ │ ├── [hi](./refs-instance) +│ │ │ │ │ └── src) +│ │ │ │ │ └── components) +│ │ │ │ ├── [hi](./svg) +│ │ │ │ │ └── src) +│ │ │ │ │ └── components) +│ │ │ │ └── uncontrolled-components) +│ │ │ │ └── src) +│ │ │ │ └── components) +│ │ │ ├── [hi](./chapter-07) +│ │ │ │ ├── [hi](./css-modules) +│ │ │ │ ├── [hi](./inline-styles) +│ │ │ │ │ └── src) +│ │ │ │ │ └── components) +│ │ │ │ ├── [hi](./radium) +│ │ │ │ │ └── src) +│ │ │ │ │ └── components) +│ │ │ │ └── styled-components) +│ │ │ │ └── src) +│ │ │ │ └── components) +│ │ │ ├── [hi](./chapter-08) +│ │ │ │ ├── [hi](./data-fetching) +│ │ │ │ │ └── src) +│ │ │ │ ├── [hi](./next) +│ │ │ │ │ └── pages) +│ │ │ │ └── server-side-rendering) +│ │ │ │ └── src) +│ │ │ ├── [hi](./chapter-09) +│ │ │ │ ├── [hi](./constants-props) +│ │ │ │ │ └── src) +│ │ │ │ │ └── components) +│ │ │ │ ├── [hi](./creating-functions) +│ │ │ │ │ └── src) +│ │ │ │ │ └── components) +│ │ │ │ ├── [hi](./good-design) +│ │ │ │ │ └── src) +│ │ │ │ │ └── components) +│ │ │ │ └── keys) +│ │ │ │ └── src) +│ │ │ │ └── components) +│ │ │ ├── [hi](./chapter-10) +│ │ │ │ ├── [hi](./enzyme) +│ │ │ │ ├── [hi](./higher-order-components) +│ │ │ │ │ └── __snapshots__) +│ │ │ │ ├── [hi](./jest) +│ │ │ │ ├── [hi](./mocha) +│ │ │ │ │ └── test) +│ │ │ │ ├── [hi](./page-object) +│ │ │ │ └── real-world) +│ │ │ │ └── __snapshots__) +│ │ │ └── chapter-11) +│ │ │ ├── [hi](./index-as-key) +│ │ │ │ └── src) +│ │ │ │ └── components) +│ │ │ ├── [hi](./initializing-state) +│ │ │ │ └── src) +│ │ │ │ └── components) +│ │ │ └── mutating-state) +│ │ │ └── src) +│ │ │ └── components) +│ │ ├── [hi](./React-Todo-master) +│ │ │ ├── [hi](./public) +│ │ │ └── src) +│ │ │ └── components) +│ │ │ └── TodoComponents) +│ │ ├── [hi](./Relational-Databases-master) +│ │ │ └── solutions) +│ │ ├── [hi](./Server-Testing-master) +│ │ ├── [hi](./Sorting-master) +│ │ │ └── src) +│ │ │ ├── [hi](./iterative_sorting) +│ │ │ ├── [hi](./recursive_sorting) +│ │ │ └── searching) +│ │ ├── [hi](./Sprint-Challenge--Graphs-master) +│ │ │ ├── [hi](./img) +│ │ │ └── src) +│ │ ├── [hi](./Sprint-Challenge--JavaScript-master) +│ │ │ ├── [hi](./challenges) +│ │ │ ├── [hi](./src) +│ │ │ └── tests) +│ │ ├── [hi](./Sprint-Challenge-Node-Express-master) +│ │ │ ├── [hi](./data) +│ │ │ │ ├── [hi](./helpers) +│ │ │ │ ├── [hi](./migrations) +│ │ │ │ └── seeds) +│ │ │ ├── [hi](./express) +│ │ │ │ ├── [hi](./public) +│ │ │ │ └── src) +│ │ │ └── routes) +│ │ ├── [hi](./Sprint-Challenge-RDBMS-master) +│ │ │ ├── [hi](./data) +│ │ │ │ ├── [hi](./migrations) +│ │ │ │ └── seeds) +│ │ │ └── routes) +│ │ ├── [hi](./sql-lab-master) +│ │ │ └── img) +│ │ ├── [hi](./Static-Pages-master) +│ │ ├── [hi](./web-guided-project-HTTP-main) +│ │ │ ├── [hi](./client) +│ │ │ │ └── src) +│ │ │ │ └── components) +│ │ │ └── server) +│ │ └── Whiteboard-Pairing-master) +│ │ ├── [hi](./BalancedBinaryTree) +│ │ ├── [hi](./BalancedBrackets) +│ │ ├── [hi](./BitcoinTrading) +│ │ ├── [hi](./BSTFromArray) +│ │ ├── [hi](./ClimbingStairs) +│ │ ├── [hi](./CountingVotes) +│ │ ├── [hi](./DepthFirstSearch) +│ │ ├── [hi](./FindRotationPoint) +│ │ ├── [hi](./IntegerPairs) +│ │ ├── [hi](./KthToLastNode) +│ │ ├── [hi](./LargestContiguousSum) +│ │ ├── [hi](./LargestStack) +│ │ ├── [hi](./LinkedListPalindrome) +│ │ ├── [hi](./MatrixSpiralCopy) +│ │ ├── [hi](./MergingTwoPackages) +│ │ ├── [hi](./MinHeap) +│ │ ├── [hi](./MinJumps) +│ │ ├── [hi](./NthFibonacci) +│ │ ├── [hi](./OneWayFlight) +│ │ ├── [hi](./ProductOfAllOtherNumbers) +│ │ ├── [hi](./QueueWithTwoStacks) +│ │ ├── [hi](./ReverseLinkedList) +│ │ ├── [hi](./RingBuffer) +│ │ ├── [hi](./RobotPaths) +│ │ ├── [hi](./RockPaperScissors) +│ │ ├── [hi](./RotateImage) +│ │ ├── [hi](./SetOfStacks) +│ │ ├── [hi](./SortStack) +│ │ ├── [hi](./SortTopScores) +│ │ ├── [hi](./TemperatureTracker) +│ │ ├── [hi](./TimePlanner) +│ │ └── ValidateBinaryTree) +│ └── web-dev-utils) +│ ├── [hi](./bootstrap-4.3.1-dist) +│ │ ├── [hi](./css) +│ │ └── js) +│ ├── [hi](./GIT-HTML-PREVIEW-TOOL) +│ │ └── GIT-HTML-PREVIEW-TOOL-master) +│ ├── [hi](./Markdown-Templates) +│ │ └── Markdown-Templates-master) +│ │ └── images) +│ ├── [hi](./personal-utilities) +│ │ ├── [hi](./Auto-table-Of-Contents) +│ │ ├── [hi](./copy-2-clip) +│ │ ├── [hi](./css) +│ │ ├── [hi](./extract-css) +│ │ │ ├── [hi](./css) +│ │ │ ├── [hi](./img) +│ │ │ └── js) +│ │ ├── [hi](./js) +│ │ └── prism) +│ └── TexTools) +│ └── TexTools-master) +│ ├── [hi](./backup-stable-build) +│ │ ├── [hi](./css) +│ │ └── js) +│ ├── [hi](./css) +│ ├── [hi](./js) +│ └── sandbox) +├── [hi](./Documentation) +├── [hi](./screenshot-preview) +│ ├── [hi](./examples) +│ └── src) +└── WEEKS) + ├── [hi](./wk1) + │ ├── [hi](./0-notes) + │ │ ) + │ │ │ ├── [hi](./closures_files) + │ │ │ ├── [hi](./Farm to Table_files) + │ │ │ ├── [hi](./func-scope_files) + │ │ │ ├── [hi](./git-quiz_files) + │ │ │ └── Quiz_Git_files) + │ │ ) + │ │ │ ├── [hi](./flexbox-explained_files) + │ │ │ └── notes_files) + │ │ ) + │ ├── [hi](./1-projects) + │ │ │ ├── [hi](./User_Interface_I_HTML_Markup) + │ │ │ └── User_Interface_I__Project_2_-_Sweet_Eats_Bakery) + │ │ ) + │ │ │ └── web-module-project-intro-css) + │ │ │ ├── [hi](./assets) + │ │ │ └── design) + │ │ │ └── refactor-d3-proj-w-flex) + │ │ │ ├── [hi](./assets) + │ │ │ └── design) + │ │ ) + │ ├── [hi](./2-resources) + │ │ ├── [hi](./agenda_files) + │ │ ) + │ ├── [hi](./3-misc) + │ │ ) + │ └── 4-test-prep) + │ └── Study-Guides) + ├── [hi](./wk10) + │ ├── [hi](./0-notes) + │ │ ) + │ ├── [hi](./1-projects) + │ │ ) + │ ├── [hi](./2-resources) + │ │ ) + │ ├── [hi](./3-misc) + │ │ ) + │ └── 4-test-prep) + │ └── Study-Guides) + ├── [hi](./wk11) + │ ├── [hi](./0-notes) + │ │ ) + │ ├── [hi](./1-projects) + │ │ ) + │ ├── [hi](./2-resources) + │ │ ) + │ ├── [hi](./3-misc) + │ │ ) + │ └── 4-test-prep) + │ └── Study-Guides) + ├── [hi](./wk12) + │ ├── [hi](./0-notes) + │ │ ) + │ ├── [hi](./1-projects) + │ │ ) + │ ├── [hi](./2-resources) + │ │ ) + │ ├── [hi](./3-misc) + │ │ ) + │ └── 4-test-prep) + │ └── Study-Guides) + ├── [hi](./wk14) + │ ├── [hi](./0-notes) + │ │ ) + │ ├── [hi](./1-projects) + │ │ ) + │ ├── [hi](./2-resources) + │ │ ) + │ ├── [hi](./3-misc) + │ │ ) + │ └── 4-test-prep) + │ └── Study-Guides) + ├── [hi](./wk15) + │ ├── [hi](./0-notes) + │ │ ) + │ ├── [hi](./1-projects) + │ │ ) + │ ├── [hi](./2-resources) + │ │ ) + │ ├── [hi](./3-misc) + │ │ ) + │ └── 4-test-prep) + │ └── Study-Guides) + ├── [hi](./wk16) + │ ├── [hi](./0-notes) + │ │ ) + │ ├── [hi](./1-projects) + │ │ ) + │ ├── [hi](./2-resources) + │ │ ) + │ ├── [hi](./3-misc) + │ │ ) + │ └── 4-test-prep) + │ └── Study-Guides) + ├── [hi](./wk17) + │ ├── [hi](./0-notes) + │ │ ) + │ ├── [hi](./1-projects) + │ │ ) + │ ├── [hi](./2-resources) + │ │ ) + │ ├── [hi](./3-misc) + │ │ ) + │ └── 4-test-prep) + │ └── Study-Guides) + ├── [hi](./wk18) + │ ├── [hi](./0-notes) + │ │ ) + │ ├── [hi](./1-projects) + │ │ ) + │ ├── [hi](./2-resources) + │ │ ) + │ ├── [hi](./3-misc) + │ │ ) + │ └── 4-test-prep) + │ └── Study-Guides) + ├── [hi](./wk19) + │ ├── [hi](./0-notes) + │ │ ) + │ ├── [hi](./1-projects) + │ │ ) + │ ├── [hi](./2-resources) + │ │ ) + │ ├── [hi](./3-misc) + │ │ ) + │ └── 4-test-prep) + │ └── Study-Guides) + ├── [hi](./wk2) + │ ├── [hi](./0-notes) + │ │ ) + │ ├── [hi](./1-projects) + │ │ ) + │ ├── [hi](./2-resources) + │ │ ) + │ ├── [hi](./3-misc) + │ │ ) + │ └── 4-test-prep) + │ └── Study-Guides) + ├── [hi](./wk20) + │ ├── [hi](./0-notes) + │ │ ) + │ ├── [hi](./1-projects) + │ │ ) + │ ├── [hi](./2-resources) + │ │ ) + │ ├── [hi](./3-misc) + │ │ ) + │ └── 4-test-prep) + │ └── Study-Guides) + ├── [hi](./wk3) + │ ├── [hi](./0-notes) + │ │ ) + │ ├── [hi](./1-projects) + │ │ ) + │ ├── [hi](./2-resources) + │ │ ) + │ ├── [hi](./3-misc) + │ │ ) + │ └── 4-test-prep) + │ └── Study-Guides) + ├── [hi](./wk4) + │ ├── [hi](./0-notes) + │ │ ) + │ ├── [hi](./1-projects) + │ │ ) + │ ├── [hi](./2-resources) + │ │ ) + │ ├── [hi](./3-misc) + │ │ ) + │ └── 4-test-prep) + │ └── Study-Guides) + ├── [hi](./wk5) + │ ├── [hi](./0-notes) + │ │ ) + │ ├── [hi](./1-projects) + │ │ ) + │ ├── [hi](./2-resources) + │ │ ) + │ ├── [hi](./3-misc) + │ │ ) + │ └── 4-test-prep) + │ └── Study-Guides) + ├── [hi](./wk6) + │ ├── [hi](./0-notes) + │ │ ) + │ ├── [hi](./1-projects) + │ │ ) + │ ├── [hi](./2-resources) + │ │ ) + │ ├── [hi](./3-misc) + │ │ ) + │ └── 4-test-prep) + │ └── Study-Guides) + ├── [hi](./wk7) + │ ├── [hi](./0-notes) + │ │ ) + │ ├── [hi](./1-projects) + │ │ ) + │ ├── [hi](./2-resources) + │ │ ) + │ ├── [hi](./3-misc) + │ │ ) + │ └── 4-test-prep) + │ └── Study-Guides) + ├── [hi](./wk8) + │ ├── [hi](./0-notes) + │ │ ) + │ ├── [hi](./1-projects) + │ │ ) + │ ├── [hi](./2-resources) + │ │ ) + │ ├── [hi](./3-misc) + │ │ ) + │ └── 4-test-prep) + │ └── Study-Guides) + └── wk9) + ├── [hi](./0-notes) + │ ) + │) + ├── [hi](./1-projects) + │ ) + │) + ├── [hi](./2-resources) + │ ) + │) + ├── [hi](./3-misc) + │ ) + │) + └── 4-test-prep) + └── Study-Guides) + +4660 directories) + +``` + +## Contents + +* _**`Platforms`**_ +* _**`Programming Languages`**_ +* _**`Front-End Development`**_ +* _**`Back-End Development`**_ +* _**`Computer Science`**_ +* _**`Big Data`**_ +* _**`Theory`**_ +* _**`Books`**_ +* _**`Editors`**_ +* _**`Gaming`**_ +* _**`Development Environment`**_ +* _**`Entertainment`**_ +* _**`Databases`**_ +* _**`Media`**_ +* _**`Learn`**_ +* _**`Security`**_ +* _**`Content Management Systems`**_ +* _**`Hardware`**_ +* _**`Business`**_ +* _**`Work`**_ +* _**`Networking`**_ +* _**`Decentralized Systems`**_ +* _**`Higher Education`**_ +* _**`Events`**_ +* _**`Testing`**_ +* _**`Miscellaneous`**_ +* _**`Related`**_ + + + +--- + +# WEB DEV RESOURCES: + +--- + +## Platforms) + +* [Node.js](https://github.com/sindresorhus/awesome-nodejs#readme) - Async non-blocking event-driven JavaScript runtime built on Chrome's V8 JavaScript engine.) + * [Cross-Platform](https://github.com/bcoe/awesome-cross-platform-nodejs#readme) - Writing cross-platform code on Node.js.) +* [Frontend Development](https://github.com/dypsilon/frontend-dev-bookmarks#readme)) +* [iOS](https://github.com/vsouza/awesome-ios#readme) - Mobile operating system for Apple phones and tablets.) +* [Android](https://github.com/JStumpp/awesome-android#readme) - Mobile operating system developed by Google.) +* [IoT & Hybrid Apps](https://github.com/weblancaster/awesome-IoT-hybrid#readme)) +* [Electron](https://github.com/sindresorhus/awesome-electron#readme) - Cross-platform native desktop apps using JavaScript/HTML/CSS.) +* [Cordova](https://github.com/busterc/awesome-cordova#readme) - JavaScript API for hybrid apps.) +* [React Native](https://github.com/jondot/awesome-react-native#readme) - JavaScript framework for writing natively rendering mobile apps for iOS and Android.) +* [Xamarin](https://github.com/XamSome/awesome-xamarin#readme) - Mobile app development IDE, testing, and distribution.) +* [Linux](https://github.com/inputsh/awesome-linux#readme)) + * [Containers](https://github.com/Friz-zy/awesome-linux-containers#readme)) + * [eBPF](https://github.com/zoidbergwill/awesome-ebpf#readme) - Virtual machine that allows you to write more efficient and powerful tracing and monitoring for Linux systems.) + * [Arch-based Projects](https://github.com/PandaFoss/Awesome-Arch#readme) - Linux distributions and projects based on Arch Linux.) +* [macOS](https://github.com/iCHAIT/awesome-macOS#readme) - Operating system for Apple's Mac computers.) + * [Command-Line](https://github.com/herrbischoff/awesome-macos-command-line#readme)) + * [Screensavers](https://github.com/agarrharr/awesome-macos-screensavers#readme)) + * [Apps](https://github.com/jaywcjlove/awesome-mac#readme)) + * [Open Source Apps](https://github.com/serhii-londar/open-source-mac-os-apps#readme)) +* [watchOS](https://github.com/yenchenlin/awesome-watchos#readme) - Operating system for the Apple Watch.) +* [JVM](https://github.com/deephacks/awesome-jvm#readme)) +* [Salesforce](https://github.com/mailtoharshit/awesome-salesforce#readme)) +* [Amazon Web Services](https://github.com/donnemartin/awesome-aws#readme)) +* [Windows](https://github.com/Awesome-Windows/Awesome#readme)) +* [IPFS](https://github.com/ipfs/awesome-ipfs#readme) - P2P hypermedia protocol.) +* [Fuse](https://github.com/fuse-compound/awesome-fuse#readme) - Mobile development tools.) +* [Heroku](https://github.com/ianstormtaylor/awesome-heroku#readme) - Cloud platform as a service.) +* [Raspberry Pi](https://github.com/thibmaek/awesome-raspberry-pi#readme) - Credit card-sized computer aimed at teaching kids programming, but capable of a lot more.) +* [Qt](https://github.com/JesseTG/awesome-qt#readme) - Cross-platform GUI app framework.) +* [WebExtensions](https://github.com/fregante/Awesome-WebExtensions#readme) - Cross-browser extension system.) +* [RubyMotion](https://github.com/motion-open-source/awesome-rubymotion#readme) - Write cross-platform native apps for iOS, Android, macOS, tvOS, and watchOS in Ruby.) +* [Smart TV](https://github.com/vitalets/awesome-smart-tv#readme) - Create apps for different TV platforms.) +* [GNOME](https://github.com/Kazhnuz/awesome-gnome#readme) - Simple and distraction-free desktop environment for Linux.) +* [KDE](https://github.com/francoism90/awesome-kde#readme) - A free software community dedicated to creating an open and user-friendly computing experience.) +* [.NET](https://github.com/quozd/awesome-dotnet#readme)) + * [Core](https://github.com/thangchung/awesome-dotnet-core#readme)) + * [Roslyn](https://github.com/ironcev/awesome-roslyn#readme) - Open-source compilers and code analysis APIs for C\# and VB.NET languages.) +* [Amazon Alexa](https://github.com/miguelmota/awesome-amazon-alexa#readme) - Virtual home assistant.) +* [DigitalOcean](https://github.com/jonleibowitz/awesome-digitalocean#readme) - Cloud computing platform designed for developers.) +* [Flutter](https://github.com/Solido/awesome-flutter#readme) - Google's mobile SDK for building native iOS and Android apps from a single codebase written in Dart.) +* [Home Assistant](https://github.com/frenck/awesome-home-assistant#readme) - Open source home automation that puts local control and privacy first.) +* [IBM Cloud](https://github.com/victorshinya/awesome-ibmcloud#readme) - Cloud platform for developers and companies.) +* [Firebase](https://github.com/jthegedus/awesome-firebase#readme) - App development platform built on Google Cloud Platform.) +* [Robot Operating System 2.0](https://github.com/fkromer/awesome-ros2#readme) - Set of software libraries and tools that help you build robot apps.) +* [Adafruit IO](https://github.com/adafruit/awesome-adafruitio#readme) - Visualize and store data from any device.) +* [Cloudflare](https://github.com/irazasyed/awesome-cloudflare#readme) - CDN, DNS, DDoS protection, and security for your site.) +* [Actions on Google](https://github.com/ravirupareliya/awesome-actions-on-google#readme) - Developer platform for Google Assistant.) +* [ESP](https://github.com/agucova/awesome-esp#readme) - Low-cost microcontrollers with WiFi and broad IoT applications.) +* [Deno](https://github.com/denolib/awesome-deno#readme) - A secure runtime for JavaScript and TypeScript that uses V8 and is built in Rust.) +* [DOS](https://github.com/balintkissdev/awesome-dos#readme) - Operating system for x86-based personal computers that was popular during the 1980s and early 1990s.) +* [Nix](https://github.com/nix-community/awesome-nix#readme) - Package manager for Linux and other Unix systems that makes package management reliable and reproducible.) +) +## Programming Languages) +) +* [JavaScript](https://github.com/sorrycc/awesome-javascript#readme)) + * [Promises](https://github.com/wbinnssmith/awesome-promises#readme)) + * [Standard Style](https://github.com/standard/awesome-standard#readme) - Style guide and linter.) + * [Must Watch Talks](https://github.com/bolshchikov/js-must-watch#readme)) + * [Tips](https://github.com/loverajoel/jstips#readme)) + * [Network Layer](https://github.com/Kikobeats/awesome-network-js#readme)) + * [Micro npm Packages](https://github.com/parro-it/awesome-micro-npm-packages#readme)) + * [Mad Science npm Packages](https://github.com/feross/awesome-mad-science#readme) - Impossible sounding projects that exist.) + * [Maintenance Modules](https://github.com/maxogden/maintenance-modules#readme) - For npm packages.) + * [npm](https://github.com/sindresorhus/awesome-npm#readme) - Package manager.) + * [AVA](https://github.com/avajs/awesome-ava#readme) - Test runner.) + * [ESLint](https://github.com/dustinspecker/awesome-eslint#readme) - Linter.) + * [Functional Programming](https://github.com/stoeffel/awesome-fp-js#readme)) + * [Observables](https://github.com/sindresorhus/awesome-observables#readme)) + * [npm scripts](https://github.com/RyanZim/awesome-npm-scripts#readme) - Task runner.) + * [30 Seconds of Code](https://github.com/30-seconds/30-seconds-of-code#readme) - Code snippets you can understand in 30 seconds.) + * [Ponyfills](https://github.com/Richienb/awesome-ponyfills#readme) - Like polyfills but without overriding native APIs.) +* [Swift](https://github.com/matteocrippa/awesome-swift#readme) - Apple's compiled programming language that is secure, modern, programmer-friendly, and fast.) + * [Education](https://github.com/hsavit1/Awesome-Swift-Education#readme)) + * [Playgrounds](https://github.com/uraimo/Awesome-Swift-Playgrounds#readme)) +* [Python](https://github.com/vinta/awesome-python#readme) - General-purpose programming language designed for readability.) + * [Asyncio](https://github.com/timofurrer/awesome-asyncio#readme) - Asynchronous I/O in Python 3.) + * [Scientific Audio](https://github.com/faroit/awesome-python-scientific-audio#readme) - Scientific research in audio/music.) + * [CircuitPython](https://github.com/adafruit/awesome-circuitpython#readme) - A version of Python for microcontrollers.) + * [Data Science](https://github.com/krzjoa/awesome-python-data-science#readme) - Data analysis and machine learning.) + * [Typing](https://github.com/typeddjango/awesome-python-typing#readme) - Optional static typing for Python.) + * [MicroPython](https://github.com/mcauser/awesome-micropython#readme) - A lean and efficient implementation of Python 3 for microcontrollers.) +* [Rust](https://github.com/rust-unofficial/awesome-rust#readme)) +* [Haskell](https://github.com/krispo/awesome-haskell#readme)) +* [PureScript](https://github.com/passy/awesome-purescript#readme)) +* [Go](https://github.com/avelino/awesome-go#readme)) +* [Scala](https://github.com/lauris/awesome-scala#readme)) + * [Scala Native](https://github.com/tindzk/awesome-scala-native#readme) - Optimizing ahead-of-time compiler for Scala based on LLVM.) +* [Ruby](https://github.com/markets/awesome-ruby#readme)) +* [Clojure](https://github.com/razum2um/awesome-clojure#readme)) +* [ClojureScript](https://github.com/hantuzun/awesome-clojurescript#readme)) +* [Elixir](https://github.com/h4cc/awesome-elixir#readme)) +* [Elm](https://github.com/sporto/awesome-elm#readme)) +* [Erlang](https://github.com/drobakowski/awesome-erlang#readme)) +* [Julia](https://github.com/svaksha/Julia.jl#readme) - High-level dynamic programming language designed to address the needs of high-performance numerical analysis and computational science.) +* [Lua](https://github.com/LewisJEllis/awesome-lua#readme)) +* [C](https://github.com/inputsh/awesome-c#readme)) +* [C/C++](https://github.com/fffaraz/awesome-cpp#readme) - General-purpose language with a bias toward system programming and embedded, resource-constrained software.) +* [R](https://github.com/qinwf/awesome-R#readme) - Functional programming language and environment for statistical computing and graphics.) + * [Learning](https://github.com/iamericfletcher/awesome-r-learning-resources#readme)) +* [D](https://github.com/dlang-community/awesome-d#readme)) +* [Common Lisp](https://github.com/CodyReichert/awesome-cl#readme) - Powerful dynamic multiparadigm language that facilitates iterative and interactive development.) + * [Learning](https://github.com/GustavBertram/awesome-common-lisp-learning#readme)) +* [Perl](https://github.com/hachiojipm/awesome-perl#readme)) +* [Groovy](https://github.com/kdabir/awesome-groovy#readme)) +* [Dart](https://github.com/yissachar/awesome-dart#readme)) +* [Java](https://github.com/akullpp/awesome-java#readme) - Popular secure object-oriented language designed for flexibility to "write once, run anywhere".) + * [RxJava](https://github.com/eleventigers/awesome-rxjava#readme)) +* [Kotlin](https://github.com/KotlinBy/awesome-kotlin#readme)) +* [OCaml](https://github.com/ocaml-community/awesome-ocaml#readme)) +* [ColdFusion](https://github.com/seancoyne/awesome-coldfusion#readme)) +* [Fortran](https://github.com/rabbiabram/awesome-fortran#readme)) +* [PHP](https://github.com/ziadoz/awesome-php#readme) - Server-side scripting language.) + * [Composer](https://github.com/jakoch/awesome-composer#readme) - Package manager.) +* [Pascal](https://github.com/Fr0sT-Brutal/awesome-pascal#readme)) +* [AutoHotkey](https://github.com/ahkscript/awesome-AutoHotkey#readme)) +* [AutoIt](https://github.com/J2TeaM/awesome-AutoIt#readme)) +* [Crystal](https://github.com/veelenga/awesome-crystal#readme)) +* [Frege](https://github.com/sfischer13/awesome-frege#readme) - Haskell for the JVM.) +* [CMake](https://github.com/onqtam/awesome-cmake#readme) - Build, test, and package software.) +* [ActionScript 3](https://github.com/robinrodricks/awesome-actionscript3#readme) - Object-oriented language targeting Adobe AIR.) +* [Eta](https://github.com/sfischer13/awesome-eta#readme) - Functional programming language for the JVM.) +* [Idris](https://github.com/joaomilho/awesome-idris#readme) - General purpose pure functional programming language with dependent types influenced by Haskell and ML.) +* [Ada/SPARK](https://github.com/ohenley/awesome-ada#readme) - Modern programming language designed for large, long-lived apps where reliability and efficiency are essential.) +* [Q\#](https://github.com/ebraminio/awesome-qsharp#readme) - Domain-specific programming language used for expressing quantum algorithms.) +* [Imba](https://github.com/koolamusic/awesome-imba#readme) - Programming language inspired by Ruby and Python and compiles to performant JavaScript.) +* [Vala](https://github.com/desiderantes/awesome-vala#readme) - Programming language designed to take full advantage of the GLib and GNOME ecosystems, while preserving the speed of C code.) +* [Coq](https://github.com/coq-community/awesome-coq#readme) - Formal language and environment for programming and specification which facilitates interactive development of machine-checked proofs.) +* [V](https://github.com/vlang/awesome-v#readme) - Simple, fast, safe, compiled language for developing maintainable software.) +) +## Front-End Development) +) +* [ES6 Tools](https://github.com/addyosmani/es6-tools#readme)) +* [Web Performance Optimization](https://github.com/davidsonfellipe/awesome-wpo#readme)) +* [Web Tools](https://github.com/lvwzhen/tools#readme)) +* [CSS](https://github.com/awesome-css-group/awesome-css#readme) - Style sheet language that specifies how HTML elements are displayed on screen.) + * [Critical-Path Tools](https://github.com/addyosmani/critical-path-css-tools#readme)) + * [Scalability](https://github.com/davidtheclark/scalable-css-reading-list#readme)) + * [Must-Watch Talks](https://github.com/AllThingsSmitty/must-watch-css#readme)) + * [Protips](https://github.com/AllThingsSmitty/css-protips#readme)) + * [Frameworks](https://github.com/troxler/awesome-css-frameworks#readme)) +* [React](https://github.com/enaqx/awesome-react#readme) - App framework.) + * [Relay](https://github.com/expede/awesome-relay#readme) - Framework for building data-driven React apps.) + * [React Hooks](https://github.com/glauberfc/awesome-react-hooks#readme) - A new feature that lets you use state and other React features without writing a class.) +* [Web Components](https://github.com/mateusortiz/webcomponents-the-right-way#readme)) +* [Polymer](https://github.com/Granze/awesome-polymer#readme) - JavaScript library to develop Web Components.) +* [Angular](https://github.com/PatrickJS/awesome-angular#readme) - App framework.) +* [Backbone](https://github.com/sadcitizen/awesome-backbone#readme) - App framework.) +* [HTML5](https://github.com/diegocard/awesome-html5#readme) - Markup language used for websites & web apps.) +* [SVG](https://github.com/willianjusten/awesome-svg#readme) - XML-based vector image format.) +* [Canvas](https://github.com/raphamorim/awesome-canvas#readme)) +* [KnockoutJS](https://github.com/dnbard/awesome-knockout#readme) - JavaScript library.) +* [Dojo Toolkit](https://github.com/petk/awesome-dojo#readme) - JavaScript toolkit.) +* [Inspiration](https://github.com/NoahBuscher/Inspire#readme)) +* [Ember](https://github.com/ember-community-russia/awesome-ember#readme) - App framework.) +* [Android UI](https://github.com/wasabeef/awesome-android-ui#readme)) +* [iOS UI](https://github.com/cjwirth/awesome-ios-ui#readme)) +* [Meteor](https://github.com/Urigo/awesome-meteor#readme)) +* [BEM](https://github.com/sturobson/BEM-resources#readme)) +* [Flexbox](https://github.com/afonsopacifer/awesome-flexbox#readme)) +* [Web Typography](https://github.com/deanhume/typography#readme)) +* [Web Accessibility](https://github.com/brunopulis/awesome-a11y#readme)) +* [Material Design](https://github.com/sachin1092/awesome-material#readme)) +* [D3](https://github.com/wbkd/awesome-d3#readme) - Library for producing dynamic, interactive data visualizations.) +* [Emails](https://github.com/jonathandion/awesome-emails#readme)) +* [jQuery](https://github.com/petk/awesome-jquery#readme) - Easy to use JavaScript library for DOM manipulation.) + * [Tips](https://github.com/AllThingsSmitty/jquery-tips-everyone-should-know#readme)) +* [Web Audio](https://github.com/notthetup/awesome-webaudio#readme)) +* [Offline-First](https://github.com/pazguille/offline-first#readme)) +* [Static Website Services](https://github.com/agarrharr/awesome-static-website-services#readme)) +* [Cycle.js](https://github.com/cyclejs-community/awesome-cyclejs#readme) - Functional and reactive JavaScript framework.) +* [Text Editing](https://github.com/dok/awesome-text-editing#readme)) +* [Motion UI Design](https://github.com/fliptheweb/motion-ui-design#readme)) +* [Vue.js](https://github.com/vuejs/awesome-vue#readme) - App framework.) +* [Marionette.js](https://github.com/sadcitizen/awesome-marionette#readme) - App framework.) +* [Aurelia](https://github.com/aurelia-contrib/awesome-aurelia#readme) - App framework.) +* [Charting](https://github.com/zingchart/awesome-charting#readme)) +* [Ionic Framework 2](https://github.com/candelibas/awesome-ionic#readme)) +* [Chrome DevTools](https://github.com/ChromeDevTools/awesome-chrome-devtools#readme)) +* [PostCSS](https://github.com/jdrgomes/awesome-postcss#readme) - CSS tool.) +* [Draft.js](https://github.com/nikgraf/awesome-draft-js#readme) - Rich text editor framework for React.) +* [Service Workers](https://github.com/TalAter/awesome-service-workers#readme)) +* [Progressive Web Apps](https://github.com/TalAter/awesome-progressive-web-apps#readme)) +* [choo](https://github.com/choojs/awesome-choo#readme) - App framework.) +* [Redux](https://github.com/brillout/awesome-redux#readme) - State container for JavaScript apps.) +* [webpack](https://github.com/webpack-contrib/awesome-webpack#readme) - Module bundler.) +* [Browserify](https://github.com/browserify/awesome-browserify#readme) - Module bundler.) +* [Sass](https://github.com/Famolus/awesome-sass#readme) - CSS preprocessor.) +* [Ant Design](https://github.com/websemantics/awesome-ant-design#readme) - Enterprise-class UI design language.) +* [Less](https://github.com/LucasBassetti/awesome-less#readme) - CSS preprocessor.) +* [WebGL](https://github.com/sjfricke/awesome-webgl#readme) - JavaScript API for rendering 3D graphics.) +* [Preact](https://github.com/preactjs/awesome-preact#readme) - App framework.) +* [Progressive Enhancement](https://github.com/jbmoelker/progressive-enhancement-resources#readme)) +* [Next.js](https://github.com/unicodeveloper/awesome-nextjs#readme) - Framework for server-rendered React apps.) +* [lit-html](https://github.com/web-padawan/awesome-lit-html#readme) - HTML templating library for JavaScript.) +* [JAMstack](https://github.com/automata/awesome-jamstack#readme) - Modern web development architecture based on client-side JavaScript, reusable APIs, and prebuilt markup.) +* [WordPress-Gatsby](https://github.com/henrikwirth/awesome-wordpress-gatsby#readme) - Web development technology stack with WordPress as a back end and Gatsby as a front end.) +* [Mobile Web Development](https://github.com/myshov/awesome-mobile-web-development#readme) - Creating a great mobile web experience.) +* [Storybook](https://github.com/lauthieb/awesome-storybook#readme) - Development environment for UI components.) +* [Blazor](https://github.com/AdrienTorris/awesome-blazor#readme) - .NET web framework using C\#/Razor and HTML that runs in the browser with WebAssembly.) +* [PageSpeed Metrics](https://github.com/csabapalfi/awesome-pagespeed-metrics#readme) - Metrics to help understand page speed and user experience.) +* [Tailwind CSS](https://github.com/aniftyco/awesome-tailwindcss#readme) - Utility-first CSS framework for rapid UI development.) +* [Seed](https://github.com/seed-rs/awesome-seed-rs#readme) - Rust framework for creating web apps running in WebAssembly.) +* [Web Performance Budget](https://github.com/pajaydev/awesome-web-performance-budget#readme) - Techniques to ensure certain performance metrics for a website.) +* [Web Animation](https://github.com/sergey-pimenov/awesome-web-animation#readme) - Animations in the browser with JavaScript, CSS, SVG, etc.) +* [Yew](https://github.com/jetli/awesome-yew#readme) - Rust framework inspired by Elm and React for creating multi-threaded frontend web apps with WebAssembly.) +* [Material-UI](https://github.com/nadunindunil/awesome-material-ui#readme) - Material Design React components for faster and easier web development.) +* [Building Blocks for Web Apps](https://github.com/componently-com/awesome-building-blocks-for-web-apps#readme) - Standalone features to be integrated into web apps.) +* [Svelte](https://github.com/TheComputerM/awesome-svelte#readme) - App framework.) +* [Design systems](https://github.com/klaufel/awesome-design-systems#readme) - Collection of reusable components, guided by rules that ensure consistency and speed.) +) +## Back-End Development) +) +* [Flask](https://github.com/mjhea0/awesome-flask#readme) - Python framework.) +* [Docker](https://github.com/veggiemonk/awesome-docker#readme)) +* [Vagrant](https://github.com/iJackUA/awesome-vagrant#readme) - Automation virtual machine environment.) +* [Pyramid](https://github.com/uralbash/awesome-pyramid#readme) - Python framework.) +* [Play1 Framework](https://github.com/PerfectCarl/awesome-play1#readme)) +* [CakePHP](https://github.com/friendsofcake/awesome-cakephp#readme) - PHP framework.) +* [Symfony](https://github.com/sitepoint-editors/awesome-symfony#readme) - PHP framework.) + * [Education](https://github.com/pehapkari/awesome-symfony-education#readme)) +* [Laravel](https://github.com/chiraggude/awesome-laravel#readme) - PHP framework.) + * [Education](https://github.com/fukuball/Awesome-Laravel-Education#readme)) + * [TALL Stack](https://github.com/blade-ui-kit/awesome-tall-stack#readme) - Full-stack development solution featuring libraries built by the Laravel community.) +* [Rails](https://github.com/gramantin/awesome-rails#readme) - Web app framework for Ruby.) + * [Gems](https://github.com/hothero/awesome-rails-gem#readme) - Packages.) +* [Phalcon](https://github.com/phalcon/awesome-phalcon#readme) - PHP framework.) +* [Useful `.htaccess` Snippets](https://github.com/phanan/htaccess#readme)) +* [nginx](https://github.com/fcambus/nginx-resources#readme) - Web server.) +* [Dropwizard](https://github.com/stve/awesome-dropwizard#readme) - Java framework.) +* [Kubernetes](https://github.com/ramitsurana/awesome-kubernetes#readme) - Open-source platform that automates Linux container operations.) +* [Lumen](https://github.com/unicodeveloper/awesome-lumen#readme) - PHP micro-framework.) +* [Serverless Framework](https://github.com/pmuens/awesome-serverless#readme) - Serverless computing and serverless architectures.) +* [Apache Wicket](https://github.com/PhantomYdn/awesome-wicket#readme) - Java web app framework.) +* [Vert.x](https://github.com/vert-x3/vertx-awesome#readme) - Toolkit for building reactive apps on the JVM.) +* [Terraform](https://github.com/shuaibiyy/awesome-terraform#readme) - Tool for building, changing, and versioning infrastructure.) +* [Vapor](https://github.com/Cellane/awesome-vapor#readme) - Server-side development in Swift.) +* [Dash](https://github.com/ucg8j/awesome-dash#readme) - Python web app framework.) +* [FastAPI](https://github.com/mjhea0/awesome-fastapi#readme) - Python web app framework.) +* [CDK](https://github.com/kolomied/awesome-cdk#readme) - Open-source software development framework for defining cloud infrastructure in code.) +* [IAM](https://github.com/kdeldycke/awesome-iam#readme) - User accounts, authentication and authorization.) +) +## Computer Science) +) +* [University Courses](https://github.com/prakhar1989/awesome-courses#readme)) +* [Data Science](https://github.com/academic/awesome-datascience#readme)) + * [Tutorials](https://github.com/siboehm/awesome-learn-datascience#readme)) +* [Machine Learning](https://github.com/josephmisiti/awesome-machine-learning#readme)) + * [Tutorials](https://github.com/ujjwalkarn/Machine-Learning-Tutorials#readme)) + * [ML with Ruby](https://github.com/arbox/machine-learning-with-ruby#readme) - Learning, implementing, and applying Machine Learning using Ruby.) + * [Core ML Models](https://github.com/likedan/Awesome-CoreML-Models#readme) - Models for Apple's machine learning framework.) + * [H2O](https://github.com/h2oai/awesome-h2o#readme) - Open source distributed machine learning platform written in Java with APIs in R, Python, and Scala.) + * [Software Engineering for Machine Learning](https://github.com/SE-ML/awesome-seml#readme) - From experiment to production-level machine learning.) + * [AI in Finance](https://github.com/georgezouq/awesome-ai-in-finance#readme) - Solving problems in finance with machine learning.) + * [JAX](https://github.com/n2cholas/awesome-jax#readme) - Automatic differentiation and XLA compilation brought together for high-performance machine learning research.) +* [Speech and Natural Language Processing](https://github.com/edobashira/speech-language-processing#readme)) + * [Spanish](https://github.com/dav009/awesome-spanish-nlp#readme)) + * [NLP with Ruby](https://github.com/arbox/nlp-with-ruby#readme)) + * [Question Answering](https://github.com/seriousran/awesome-qa#readme) - The science of asking and answering in natural language with a machine.) + * [Natural Language Generation](https://github.com/tokenmill/awesome-nlg#readme) - Generation of text used in data to text, conversational agents, and narrative generation applications.) +* [Linguistics](https://github.com/theimpossibleastronaut/awesome-linguistics#readme)) +* [Cryptography](https://github.com/sobolevn/awesome-cryptography#readme)) + * [Papers](https://github.com/pFarb/awesome-crypto-papers#readme) - Theory basics for using cryptography by non-cryptographers.) +* [Computer Vision](https://github.com/jbhuang0604/awesome-computer-vision#readme)) +* [Deep Learning](https://github.com/ChristosChristofidis/awesome-deep-learning#readme) - Neural networks.) + * [TensorFlow](https://github.com/jtoy/awesome-tensorflow#readme) - Library for machine intelligence.) + * [TensorFlow.js](https://github.com/aaronhma/awesome-tensorflow-js#readme) - WebGL-accelerated machine learning JavaScript library for training and deploying models.) + * [TensorFlow Lite](https://github.com/margaretmz/awesome-tensorflow-lite#readme) - Framework that optimizes TensorFlow models for on-device machine learning.) + * [Papers](https://github.com/terryum/awesome-deep-learning-papers#readme) - The most cited deep learning papers.) + * [Education](https://github.com/guillaume-chevalier/awesome-deep-learning-resources#readme)) +* [Deep Vision](https://github.com/kjw0612/awesome-deep-vision#readme)) +* [Open Source Society University](https://github.com/ossu/computer-science#readme)) +* [Functional Programming](https://github.com/lucasviola/awesome-functional-programming#readme)) +* [Empirical Software Engineering](https://github.com/dspinellis/awesome-msr#readme) - Evidence-based research on software systems.) +* [Static Analysis & Code Quality](https://github.com/analysis-tools-dev/static-analysis#readme)) +* [Information Retrieval](https://github.com/harpribot/awesome-information-retrieval#readme) - Learn to develop your own search engine.) +* [Quantum Computing](https://github.com/desireevl/awesome-quantum-computing#readme) - Computing which utilizes quantum mechanics and qubits on quantum computers.) +) +## Big Data) +) +* [Big Data](https://github.com/onurakpolat/awesome-bigdata#readme)) +* [Public Datasets](https://github.com/awesomedata/awesome-public-datasets#readme)) +* [Hadoop](https://github.com/youngwookim/awesome-hadoop#readme) - Framework for distributed storage and processing of very large data sets.) +* [Data Engineering](https://github.com/igorbarinov/awesome-data-engineering#readme)) +* [Streaming](https://github.com/manuzhang/awesome-streaming#readme)) +* [Apache Spark](https://github.com/awesome-spark/awesome-spark#readme) - Unified engine for large-scale data processing.) +* [Qlik](https://github.com/ambster-public/awesome-qlik#readme) - Business intelligence platform for data visualization, analytics, and reporting apps.) +* [Splunk](https://github.com/sduff/awesome-splunk#readme) - Platform for searching, monitoring, and analyzing structured and unstructured machine-generated big data in real-time.) +) +## Theory) +) +* [Papers We Love](https://github.com/papers-we-love/papers-we-love#readme)) +* [Talks](https://github.com/JanVanRyswyck/awesome-talks#readme)) +* [Algorithms](https://github.com/tayllan/awesome-algorithms#readme)) + * [Education](https://github.com/gaerae/awesome-algorithms-education#readme) - Learning and practicing.) +* [Algorithm Visualizations](https://github.com/enjalot/algovis#readme)) +* [Artificial Intelligence](https://github.com/owainlewis/awesome-artificial-intelligence#readme)) +* [Search Engine Optimization](https://github.com/marcobiedermann/search-engine-optimization#readme)) +* [Competitive Programming](https://github.com/lnishan/awesome-competitive-programming#readme)) +* [Math](https://github.com/rossant/awesome-math#readme)) +* [Recursion Schemes](https://github.com/passy/awesome-recursion-schemes#readme) - Traversing nested data structures.) +) +## Books) +) +* [Free Programming Books](https://github.com/EbookFoundation/free-programming-books#readme)) +* [Go Books](https://github.com/dariubs/GoBooks#readme)) +* [R Books](https://github.com/RomanTsegelskyi/rbooks#readme)) +* [Mind Expanding Books](https://github.com/hackerkid/Mind-Expanding-Books#readme)) +* [Book Authoring](https://github.com/TalAter/awesome-book-authoring#readme)) +* [Elixir Books](https://github.com/sger/ElixirBooks#readme)) +) +## Editors) +) +* [Sublime Text](https://github.com/dreikanter/sublime-bookmarks#readme)) +* [Vim](https://github.com/mhinz/vim-galore#readme)) +* [Emacs](https://github.com/emacs-tw/awesome-emacs#readme)) +* [Atom](https://github.com/mehcode/awesome-atom#readme) - Open-source and hackable text editor.) +* [Visual Studio Code](https://github.com/viatsko/awesome-vscode#readme) - Cross-platform open-source text editor.) +) +## Gaming) +) +* [Game Development](https://github.com/ellisonleao/magictools#readme)) +* [Game Talks](https://github.com/hzoo/awesome-gametalks#readme)) +* [Godot](https://github.com/Calinou/awesome-godot#readme) - Game engine.) +* [Open Source Games](https://github.com/leereilly/games#readme)) +* [Unity](https://github.com/RyanNielson/awesome-unity#readme) - Game engine.) +* [Chess](https://github.com/hkirat/awesome-chess#readme)) +* [LÖVE](https://github.com/love2d-community/awesome-love2d#readme) - Game engine.) +* [PICO-8](https://github.com/pico-8/awesome-PICO-8#readme) - Fantasy console.) +* [Game Boy Development](https://github.com/gbdev/awesome-gbdev#readme)) +* [Construct 2](https://github.com/WebCreationClub/awesome-construct#readme) - Game engine.) +* [Gideros](https://github.com/stetso/awesome-gideros#readme) - Game engine.) +* [Minecraft](https://github.com/bs-community/awesome-minecraft#readme) - Sandbox video game.) +* [Game Datasets](https://github.com/leomaurodesenv/game-datasets#readme) - Materials and datasets for Artificial Intelligence in games.) +* [Haxe Game Development](https://github.com/Dvergar/awesome-haxe-gamedev#readme) - A high-level strongly typed programming language used to produce cross-platform native code.) +* [libGDX](https://github.com/rafaskb/awesome-libgdx#readme) - Java game framework.) +* [PlayCanvas](https://github.com/playcanvas/awesome-playcanvas#readme) - Game engine.) +* [Game Remakes](https://github.com/radek-sprta/awesome-game-remakes#readme) - Actively maintained open-source game remakes.) +* [Flame](https://github.com/flame-engine/awesome-flame#readme) - Game engine for Flutter.) +* [Discord Communities](https://github.com/mhxion/awesome-discord-communities#readme) - Chat with friends and communities.) +* [CHIP-8](https://github.com/tobiasvl/awesome-chip-8#readme) - Virtual computer game machine from the 70s.) +* [Games of Coding](https://github.com/michelpereira/awesome-games-of-coding#readme) - Learn a programming language by making games.) +) +## Development Environment) +) +* [Quick Look Plugins](https://github.com/sindresorhus/quick-look-plugins#readme) - For macOS.) +* [Dev Env](https://github.com/jondot/awesome-devenv#readme)) +* [Dotfiles](https://github.com/webpro/awesome-dotfiles#readme)) +* [Shell](https://github.com/alebcay/awesome-shell#readme)) +* [Fish](https://github.com/jorgebucaran/awsm.fish#readme) - User-friendly shell.) +* [Command-Line Apps](https://github.com/agarrharr/awesome-cli-apps#readme)) +* [ZSH Plugins](https://github.com/unixorn/awesome-zsh-plugins#readme)) +* [GitHub](https://github.com/phillipadsmith/awesome-github#readme) - Hosting service for Git repositories.) + * [Browser Extensions](https://github.com/stefanbuck/awesome-browser-extensions-for-github#readme)) + * [Cheat Sheet](https://github.com/tiimgreen/github-cheat-sheet#readme)) + * [Pinned Gists](https://github.com/matchai/awesome-pinned-gists#readme) - Dynamic pinned gists for your GitHub profile.) +* [Git Cheat Sheet & Git Flow](https://github.com/arslanbilal/git-cheat-sheet#readme)) +* [Git Tips](https://github.com/git-tips/tips#readme)) +* [Git Add-ons](https://github.com/stevemao/awesome-git-addons#readme) - Enhance the `git` CLI.) +* [Git Hooks](https://github.com/compscilauren/awesome-git-hooks#readme) - Scripts for automating tasks during `git` workflows.) +* [SSH](https://github.com/moul/awesome-ssh#readme)) +* [FOSS for Developers](https://github.com/tvvocold/FOSS-for-Dev#readme)) +* [Hyper](https://github.com/bnb/awesome-hyper#readme) - Cross-platform terminal app built on web technologies.) +* [PowerShell](https://github.com/janikvonrotz/awesome-powershell#readme) - Cross-platform object-oriented shell.) +* [Alfred Workflows](https://github.com/alfred-workflows/awesome-alfred-workflows#readme) - Productivity app for macOS.) +* [Terminals Are Sexy](https://github.com/k4m4/terminals-are-sexy#readme)) +* [GitHub Actions](https://github.com/sdras/awesome-actions#readme) - Create tasks to automate your workflow and share them with others on GitHub.) +) +## Entertainment) +) +* [Science Fiction](https://github.com/sindresorhus/awesome-scifi#readme) - Scifi.) +* [Fantasy](https://github.com/RichardLitt/awesome-fantasy#readme)) +* [Podcasts](https://github.com/ayr-ton/awesome-geek-podcasts#readme)) +* [Email Newsletters](https://github.com/zudochkin/awesome-newsletters#readme)) +* [IT Quotes](https://github.com/victorlaerte/awesome-it-quotes#readme)) +) +## Databases) +) +* [Database](https://github.com/numetriclabz/awesome-db#readme)) +* [MySQL](https://github.com/shlomi-noach/awesome-mysql#readme)) +* [SQLAlchemy](https://github.com/dahlia/awesome-sqlalchemy#readme)) +* [InfluxDB](https://github.com/mark-rushakoff/awesome-influxdb#readme)) +* [Neo4j](https://github.com/neueda/awesome-neo4j#readme)) +* [MongoDB](https://github.com/ramnes/awesome-mongodb#readme) - NoSQL database.) +* [RethinkDB](https://github.com/d3viant0ne/awesome-rethinkdb#readme)) +* [TinkerPop](https://github.com/mohataher/awesome-tinkerpop#readme) - Graph computing framework.) +* [PostgreSQL](https://github.com/dhamaniasad/awesome-postgres#readme) - Object-relational database.) +* [CouchDB](https://github.com/quangv/awesome-couchdb#readme) - Document-oriented NoSQL database.) +* [HBase](https://github.com/rayokota/awesome-hbase#readme) - Distributed, scalable, big data store.) +* [NoSQL Guides](https://github.com/erictleung/awesome-nosql-guides#readme) - Help on using non-relational, distributed, open-source, and horizontally scalable databases.) +* [Contexture](https://github.com/chrislatorres/awesome-contexture#readme) - Abstracts queries/filters and results/aggregations from different backing data stores like ElasticSearch and MongoDB.) +* [Database Tools](https://github.com/mgramin/awesome-db-tools#readme) - Everything that makes working with databases easier.) +* [Grakn](https://github.com/graknlabs/awesome#readme) - Logical database to organize large and complex networks of data as one body of knowledge.) +) +## Media) +) +* [Creative Commons Media](https://github.com/shime/creative-commons-media#readme)) +* [Fonts](https://github.com/brabadu/awesome-fonts#readme)) +* [Codeface](https://github.com/chrissimpkins/codeface#readme) - Text editor fonts.) +* [Stock Resources](https://github.com/neutraltone/awesome-stock-resources#readme)) +* [GIF](https://github.com/davisonio/awesome-gif#readme) - Image format known for animated images.) +* [Music](https://github.com/ciconia/awesome-music#readme)) +* [Open Source Documents](https://github.com/44bits/awesome-opensource-documents#readme)) +* [Audio Visualization](https://github.com/willianjusten/awesome-audio-visualization#readme)) +* [Broadcasting](https://github.com/ebu/awesome-broadcasting#readme)) +* [Pixel Art](https://github.com/Siilwyn/awesome-pixel-art#readme) - Pixel-level digital art.) +* [FFmpeg](https://github.com/transitive-bullshit/awesome-ffmpeg#readme) - Cross-platform solution to record, convert and stream audio and video.) +* [Icons](https://github.com/notlmn/awesome-icons#readme) - Downloadable SVG/PNG/font icon projects.) +* [Audiovisual](https://github.com/stingalleman/awesome-audiovisual#readme) - Lighting, audio and video in professional environments.) +) +## Learn) +) +* [CLI Workshoppers](https://github.com/therebelrobot/awesome-workshopper#readme) - Interactive tutorials.) +* [Learn to Program](https://github.com/karlhorky/learn-to-program#readme)) +* [Speaking](https://github.com/matteofigus/awesome-speaking#readme)) +* [Tech Videos](https://github.com/lucasviola/awesome-tech-videos#readme)) +* [Dive into Machine Learning](https://github.com/hangtwenty/dive-into-machine-learning#readme)) +* [Computer History](https://github.com/watson/awesome-computer-history#readme)) +* [Programming for Kids](https://github.com/HollyAdele/awesome-programming-for-kids#readme)) +* [Educational Games](https://github.com/yrgo/awesome-educational-games#readme) - Learn while playing.) +* [JavaScript Learning](https://github.com/micromata/awesome-javascript-learning#readme)) +* [CSS Learning](https://github.com/micromata/awesome-css-learning#readme) - Mainly about CSS - the language and the modules.) +* [Product Management](https://github.com/dend/awesome-product-management#readme) - Learn how to be a better product manager.) +* [Roadmaps](https://github.com/liuchong/awesome-roadmaps#readme) - Gives you a clear route to improve your knowledge and skills.) +* [YouTubers](https://github.com/JoseDeFreitas/awesome-youtubers#readme) - Watch video tutorials from YouTubers that teach you about technology.) +) +## Security) +) +* [Application Security](https://github.com/paragonie/awesome-appsec#readme)) +* [Security](https://github.com/sbilly/awesome-security#readme)) +* [CTF](https://github.com/apsdehal/awesome-ctf#readme) - Capture The Flag.) +* [Malware Analysis](https://github.com/rshipp/awesome-malware-analysis#readme)) +* [Android Security](https://github.com/ashishb/android-security-awesome#readme)) +* [Hacking](https://github.com/carpedm20/awesome-hacking#readme)) +* [Honeypots](https://github.com/paralax/awesome-honeypots#readme) - Deception trap, designed to entice an attacker into attempting to compromise the information systems in an organization.) +* [Incident Response](https://github.com/meirwah/awesome-incident-response#readme)) +* [Vehicle Security and Car Hacking](https://github.com/jaredthecoder/awesome-vehicle-security#readme)) +* [Web Security](https://github.com/qazbnm456/awesome-web-security#readme) - Security of web apps & services.) +* [Lockpicking](https://github.com/fabacab/awesome-lockpicking#readme) - The art of unlocking a lock by manipulating its components without the key.) +* [Cybersecurity Blue Team](https://github.com/fabacab/awesome-cybersecurity-blueteam#readme) - Groups of individuals who identify security flaws in information technology systems.) +* [Fuzzing](https://github.com/cpuu/awesome-fuzzing#readme) - Automated software testing technique that involves feeding pseudo-randomly generated input data.) +* [Embedded and IoT Security](https://github.com/fkie-cad/awesome-embedded-and-iot-security#readme)) +* [GDPR](https://github.com/bakke92/awesome-gdpr#readme) - Regulation on data protection and privacy for all individuals within EU.) +* [DevSecOps](https://github.com/TaptuIT/awesome-devsecops#readme) - Integration of security practices into [DevOps](https://en.wikipedia.org/wiki/DevOps).) +) +## Content Management Systems) +) +* [Umbraco](https://github.com/umbraco-community/awesome-umbraco#readme)) +* [Refinery CMS](https://github.com/refinerycms-contrib/awesome-refinerycms#readme) - Ruby on Rails CMS.) +* [Wagtail](https://github.com/springload/awesome-wagtail#readme) - Django CMS focused on flexibility and user experience.) +* [Textpattern](https://github.com/drmonkeyninja/awesome-textpattern#readme) - Lightweight PHP-based CMS.) +* [Drupal](https://github.com/nirgn975/awesome-drupal#readme) - Extensible PHP-based CMS.) +* [Craft CMS](https://github.com/craftcms/awesome#readme) - Content-first CMS.) +* [Sitecore](https://github.com/MartinMiles/Awesome-Sitecore#readme) - .NET digital marketing platform that combines CMS with tools for managing multiple websites.) +* [Silverstripe CMS](https://github.com/wernerkrauss/awesome-silverstripe-cms#readme) - PHP MVC framework that serves as a classic or headless CMS.) +) +## Hardware) +) +* [Robotics](https://github.com/Kiloreux/awesome-robotics#readme)) +* [Internet of Things](https://github.com/HQarroum/awesome-iot#readme)) +* [Electronics](https://github.com/kitspace/awesome-electronics#readme) - For electronic engineers and hobbyists.) +* [Bluetooth Beacons](https://github.com/rabschi/awesome-beacon#readme)) +* [Electric Guitar Specifications](https://github.com/gitfrage/guitarspecs#readme) - Checklist for building your own electric guitar.) +* [Plotters](https://github.com/beardicus/awesome-plotters#readme) - Computer-controlled drawing machines and other visual art robots.) +* [Robotic Tooling](https://github.com/protontypes/awesome-robotic-tooling#readme) - Free and open tools for professional robotic development.) +* [LIDAR](https://github.com/szenergy/awesome-lidar#readme) - Sensor for measuring distances by illuminating the target with laser light.) +) +## Business) +) +* [Open Companies](https://github.com/opencompany/awesome-open-company#readme)) +* [Places to Post Your Startup](https://github.com/mmccaff/PlacesToPostYourStartup#readme)) +* [OKR Methodology](https://github.com/domenicosolazzo/awesome-okr#readme) - Goal setting & communication best practices.) +* [Leading and Managing](https://github.com/LappleApple/awesome-leading-and-managing#readme) - Leading people and being a manager in a technology company/environment.) +* [Indie](https://github.com/mezod/awesome-indie#readme) - Independent developer businesses.) +* [Tools of the Trade](https://github.com/cjbarber/ToolsOfTheTrade#readme) - Tools used by companies on Hacker News.) +* [Clean Tech](https://github.com/nglgzz/awesome-clean-tech#readme) - Fighting climate change with technology.) +* [Wardley Maps](https://github.com/wardley-maps-community/awesome-wardley-maps#readme) - Provides high situational awareness to help improve strategic planning and decision making.) +* [Social Enterprise](https://github.com/RayBB/awesome-social-enterprise#readme) - Building an organization primarily focused on social impact that is at least partially self-funded.) +* [Engineering Team Management](https://github.com/kdeldycke/awesome-engineering-team-management#readme) - How to transition from software development to engineering management.) +* [Developer-First Products](https://github.com/agamm/awesome-developer-first#readme) - Products that target developers as the user.) +) +## Work) +) +* [Slack](https://github.com/matiassingers/awesome-slack#readme) - Team collaboration.) + * [Communities](https://github.com/filipelinhares/awesome-slack#readme)) +* [Remote Jobs](https://github.com/lukasz-madon/awesome-remote-job#readme)) +* [Productivity](https://github.com/jyguyomarch/awesome-productivity#readme)) +* [Niche Job Boards](https://github.com/tramcar/awesome-job-boards#readme)) +* [Programming Interviews](https://github.com/DopplerHQ/awesome-interview-questions#readme)) +* [Code Review](https://github.com/joho/awesome-code-review#readme) - Reviewing code.) +* [Creative Technology](https://github.com/j0hnm4r5/awesome-creative-technology#readme) - Businesses & groups that specialize in combining computing, design, art, and user experience.) +) +## Networking) +) +* [Software-Defined Networking](https://github.com/sdnds-tw/awesome-sdn#readme)) +* [Network Analysis](https://github.com/briatte/awesome-network-analysis#readme)) +* [PCAPTools](https://github.com/caesar0301/awesome-pcaptools#readme)) +* [Real-Time Communications](https://github.com/rtckit/awesome-rtc#readme) - Network protocols for near simultaneous exchange of media and data.) +) +## Decentralized Systems) +) +* [Bitcoin](https://github.com/igorbarinov/awesome-bitcoin#readme) - Bitcoin services and tools for software developers.) +* [Ripple](https://github.com/vhpoet/awesome-ripple#readme) - Open source distributed settlement network.) +* [Non-Financial Blockchain](https://github.com/machinomy/awesome-non-financial-blockchain#readme) - Non-financial blockchain applications.) +* [Mastodon](https://github.com/tleb/awesome-mastodon#readme) - Open source decentralized microblogging network.) +* [Ethereum](https://github.com/ttumiel/Awesome-Ethereum#readme) - Distributed computing platform for smart contract development.) +* [Blockchain AI](https://github.com/steven2358/awesome-blockchain-ai#readme) - Blockchain projects for artificial intelligence and machine learning.) +* [EOSIO](https://github.com/DanailMinchev/awesome-eosio#readme) - A decentralized operating system supporting industrial-scale apps.) +* [Corda](https://github.com/chainstack/awesome-corda#readme) - Open source blockchain platform designed for business.) +* [Waves](https://github.com/msmolyakov/awesome-waves#readme) - Open source blockchain platform and development toolset for Web 3.0 apps and decentralized solutions.) +* [Substrate](https://github.com/substrate-developer-hub/awesome-substrate#readme) - Framework for writing scalable, upgradeable blockchains in Rust.) +) +## Higher Education) +) +* [Computational Neuroscience](https://github.com/eselkin/awesome-computational-neuroscience#readme) - A multidisciplinary science which uses computational approaches to study the nervous system.) +* [Digital History](https://github.com/maehr/awesome-digital-history#readme) - Computer-aided scientific investigation of history.) +* [Scientific Writing](https://github.com/writing-resources/awesome-scientific-writing#readme) - Distraction-free scientific writing with Markdown, reStructuredText and Jupyter notebooks.) +) +## Events) +) +* [Creative Tech Events](https://github.com/danvoyce/awesome-creative-tech-events#readme) - Events around the globe for creative coding, tech, design, music, arts and cool stuff.) +* [Events in Italy](https://github.com/ildoc/awesome-italy-events#readme) - Tech-related events in Italy.) +* [Events in the Netherlands](https://github.com/awkward/awesome-netherlands-events#readme) - Tech-related events in the Netherlands.) +) +## Testing) +) +* [Testing](https://github.com/TheJambo/awesome-testing#readme) - Software testing.) +* [Visual Regression Testing](https://github.com/mojoaxel/awesome-regression-testing#readme) - Ensures changes did not break the functionality or style.) +* [Selenium](https://github.com/christian-bromann/awesome-selenium#readme) - Open-source browser automation framework and ecosystem.) +* [Appium](https://github.com/SrinivasanTarget/awesome-appium#readme) - Test automation tool for apps.) +* [TAP](https://github.com/sindresorhus/awesome-tap#readme) - Test Anything Protocol.) +* [JMeter](https://github.com/aliesbelik/awesome-jmeter#readme) - Load testing and performance measurement tool.) +* [k6](https://github.com/k6io/awesome-k6#readme) - Open-source, developer-centric performance monitoring and load testing solution.) +* [Playwright](https://github.com/mxschmitt/awesome-playwright#readme) - Node.js library to automate Chromium, Firefox and WebKit with a single API.) +* [Quality Assurance Roadmap](https://github.com/fityanos/awesome-quality-assurance-roadmap#readme) - How to start & build a career in software testing.) +) +## Miscellaneous) +) +* [JSON](https://github.com/burningtree/awesome-json#readme) - Text based data interchange format.) + * [GeoJSON](https://github.com/tmcw/awesome-geojson#readme)) + * [Datasets](https://github.com/jdorfman/awesome-json-datasets#readme)) +* [CSV](https://github.com/secretGeek/awesomeCSV#readme) - A text file format that stores tabular data and uses a comma to separate values.) +* [Discounts for Student Developers](https://github.com/AchoArnold/discount-for-student-dev#readme)) +* [Radio](https://github.com/kyleterry/awesome-radio#readme)) +* [Awesome](https://github.com/sindresorhus/awesome#readme) - Recursion illustrated.) +* [Analytics](https://github.com/onurakpolat/awesome-analytics#readme)) +* [REST](https://github.com/marmelab/awesome-rest#readme)) +* [Continuous Integration and Continuous Delivery](https://github.com/cicdops/awesome-ciandcd#readme)) +* [Services Engineering](https://github.com/mmcgrana/services-engineering#readme)) +* [Free for Developers](https://github.com/ripienaar/free-for-dev#readme)) +* [Answers](https://github.com/cyberglot/awesome-answers#readme) - Stack Overflow, Quora, etc.) +* [Sketch](https://github.com/diessica/awesome-sketch#readme) - Design app for macOS.) +* [Boilerplate Projects](https://github.com/melvin0008/awesome-projects-boilerplates#readme)) +* [Readme](https://github.com/matiassingers/awesome-readme#readme)) +* [Design and Development Guides](https://github.com/NARKOZ/guides#readme)) +* [Software Engineering Blogs](https://github.com/kilimchoi/engineering-blogs#readme)) +* [Self Hosted](https://github.com/awesome-selfhosted/awesome-selfhosted#readme)) +* [FOSS Production Apps](https://github.com/DataDaoDe/awesome-foss-apps#readme)) +* [Gulp](https://github.com/alferov/awesome-gulp#readme) - Task runner.) +* [AMA](https://github.com/sindresorhus/amas#readme) - Ask Me Anything.) + * [Answers](https://github.com/stoeffel/awesome-ama-answers#readme)) +* [Open Source Photography](https://github.com/ibaaj/awesome-OpenSourcePhotography#readme)) +* [OpenGL](https://github.com/eug/awesome-opengl#readme) - Cross-platform API for rendering 2D and 3D graphics.) +* [GraphQL](https://github.com/chentsulin/awesome-graphql#readme)) +* [Transit](https://github.com/CUTR-at-USF/awesome-transit#readme)) +* [Research Tools](https://github.com/emptymalei/awesome-research#readme)) +* [Data Visualization](https://github.com/fasouto/awesome-dataviz#readme)) +* [Social Media Share Links](https://github.com/vinkla/shareable-links#readme)) +* [Microservices](https://github.com/mfornos/awesome-microservices#readme)) +* [Unicode](https://github.com/jagracey/Awesome-Unicode#readme) - Unicode standards, quirks, packages and resources.) + * [Code Points](https://github.com/Codepoints/awesome-codepoints#readme)) +* [Beginner-Friendly Projects](https://github.com/MunGell/awesome-for-beginners#readme)) +* [Katas](https://github.com/gamontal/awesome-katas#readme)) +* [Tools for Activism](https://github.com/drewrwilson/toolsforactivism#readme)) +* [Citizen Science](https://github.com/dylanrees/citizen-science#readme) - For community-based and non-institutional scientists.) +* [MQTT](https://github.com/hobbyquaker/awesome-mqtt#readme) - "Internet of Things" connectivity protocol.) +* [Hacking Spots](https://github.com/daviddias/awesome-hacking-locations#readme)) +* [For Girls](https://github.com/cristianoliveira/awesome4girls#readme)) +* [Vorpal](https://github.com/vorpaljs/awesome-vorpal#readme) - Node.js CLI framework.) +* [Vulkan](https://github.com/vinjn/awesome-vulkan#readme) - Low-overhead, cross-platform 3D graphics and compute API.) +* [LaTeX](https://github.com/egeerardyn/awesome-LaTeX#readme) - Typesetting language.) +* [Economics](https://github.com/antontarasenko/awesome-economics#readme) - An economist's starter kit.) +* [Funny Markov Chains](https://github.com/sublimino/awesome-funny-markov#readme)) +* [Bioinformatics](https://github.com/danielecook/Awesome-Bioinformatics#readme)) +* [Cheminformatics](https://github.com/hsiaoyi0504/awesome-cheminformatics#readme) - Informatics techniques applied to problems in chemistry.) +* [Colorful](https://github.com/Siddharth11/Colorful#readme) - Choose your next color scheme.) +* [Steam](https://github.com/scholtzm/awesome-steam#readme) - Digital distribution platform.) +* [Bots](https://github.com/hackerkid/bots#readme) - Building bots.) +* [Site Reliability Engineering](https://github.com/dastergon/awesome-sre#readme)) +* [Empathy in Engineering](https://github.com/KimberlyMunoz/empathy-in-engineering#readme) - Building and promoting more compassionate engineering cultures.) +* [DTrace](https://github.com/xen0l/awesome-dtrace#readme) - Dynamic tracing framework.) +* [Userscripts](https://github.com/bvolpato/awesome-userscripts#readme) - Enhance your browsing experience.) +* [Pokémon](https://github.com/tobiasbueschel/awesome-pokemon#readme) - Pokémon and Pokémon GO.) +* [ChatOps](https://github.com/exAspArk/awesome-chatops#readme) - Managing technical and business operations through a chat.) +* [Falsehood](https://github.com/kdeldycke/awesome-falsehood#readme) - Falsehoods programmers believe in.) +* [Domain-Driven Design](https://github.com/heynickc/awesome-ddd#readme) - Software development approach for complex needs by connecting the implementation to an evolving model.) +* [Quantified Self](https://github.com/woop/awesome-quantified-self#readme) - Self-tracking through technology.) +* [SaltStack](https://github.com/hbokh/awesome-saltstack#readme) - Python-based config management system.) +* [Web Design](https://github.com/nicolesaidy/awesome-web-design#readme) - For digital designers.) +* [Creative Coding](https://github.com/terkelg/awesome-creative-coding#readme) - Programming something expressive instead of something functional.) +* [No-Login Web Apps](https://github.com/aviaryan/awesome-no-login-web-apps#readme) - Web apps that work without login.) +* [Free Software](https://github.com/johnjago/awesome-free-software#readme) - Free as in freedom.) +* [Framer](https://github.com/podo/awesome-framer#readme) - Prototyping interactive UI designs.) +* [Markdown](https://github.com/BubuAnabelas/awesome-markdown#readme) - Markup language.) +* [Dev Fun](https://github.com/mislavcimpersak/awesome-dev-fun#readme) - Funny developer projects.) +* [Healthcare](https://github.com/kakoni/awesome-healthcare#readme) - Open source healthcare software for facilities, providers, developers, policy experts, and researchers.) +* [Magento 2](https://github.com/DavidLambauer/awesome-magento2#readme) - Open Source eCommerce built with PHP.) +* [TikZ](https://github.com/xiaohanyu/awesome-tikz#readme) - Graph drawing packages for TeX/LaTeX/ConTeXt.) +* [Neuroscience](https://github.com/analyticalmonk/awesome-neuroscience#readme) - Study of the nervous system and brain.) +* [Ad-Free](https://github.com/johnjago/awesome-ad-free#readme) - Ad-free alternatives.) +* [Esolangs](https://github.com/angrykoala/awesome-esolangs#readme) - Programming languages designed for experimentation or as jokes rather than actual use.) +* [Prometheus](https://github.com/roaldnefs/awesome-prometheus#readme) - Open-source monitoring system.) +* [Homematic](https://github.com/homematic-community/awesome-homematic#readme) - Smart home devices.) +* [Ledger](https://github.com/sfischer13/awesome-ledger#readme) - Double-entry accounting on the command-line.) +* [Web Monetization](https://github.com/thomasbnt/awesome-web-monetization#readme) - A free open web standard service that allows you to send money directly in your browser.) +* [Uncopyright](https://github.com/johnjago/awesome-uncopyright#readme) - Public domain works.) +* [Crypto Currency Tools & Algorithms](https://github.com/Zheaoli/awesome-coins#readme) - Digital currency where encryption is used to regulate the generation of units and verify transfers.) +* [Diversity](https://github.com/folkswhocode/awesome-diversity#readme) - Creating a more inclusive and diverse tech community.) +* [Open Source Supporters](https://github.com/zachflower/awesome-open-source-supporters#readme) - Companies that offer their tools and services for free to open source projects.) +* [Design Principles](https://github.com/robinstickel/awesome-design-principles#readme) - Create better and more consistent designs and experiences.) +* [Theravada](https://github.com/johnjago/awesome-theravada#readme) - Teachings from the Theravada Buddhist tradition.) +* [inspectIT](https://github.com/inspectit-labs/awesome-inspectit#readme) - Open source Java app performance management tool.) +* [Open Source Maintainers](https://github.com/nayafia/awesome-maintainers#readme) - The experience of being an open source maintainer.) +* [Calculators](https://github.com/xxczaki/awesome-calculators#readme) - Calculators for every platform.) +* [Captcha](https://github.com/ZYSzys/awesome-captcha#readme) - A type of challenge-response test used in computing to determine whether or not the user is human.) +* [Jupyter](https://github.com/markusschanta/awesome-jupyter#readme) - Create and share documents that contain code, equations, visualizations and narrative text.) +* [FIRST Robotics Competition](https://github.com/andrewda/awesome-frc#readme) - International high school robotics championship.) +* [Humane Technology](https://github.com/humanetech-community/awesome-humane-tech#readme) - Open source projects that help improve society.) +* [Speakers](https://github.com/karlhorky/awesome-speakers#readme) - Conference and meetup speakers in the programming and design community.) +* [Board Games](https://github.com/edm00se/awesome-board-games#readme) - Table-top gaming fun for all.) +* [Software Patreons](https://github.com/uraimo/awesome-software-patreons#readme) - Fund individual programmers or the development of open source projects.) +* [Parasite](https://github.com/ecohealthalliance/awesome-parasite#readme) - Parasites and host-pathogen interactions.) +* [Food](https://github.com/jzarca01/awesome-food#readme) - Food-related projects on GitHub.) +* [Mental Health](https://github.com/dreamingechoes/awesome-mental-health#readme) - Mental health awareness and self-care in the software industry.) +* [Bitcoin Payment Processors](https://github.com/alexk111/awesome-bitcoin-payment-processors#readme) - Start accepting Bitcoin.) +* [Scientific Computing](https://github.com/nschloe/awesome-scientific-computing#readme) - Solving complex scientific problems using computers.) +* [Amazon Sellers](https://github.com/ScaleLeap/awesome-amazon-seller#readme)) +* [Agriculture](https://github.com/brycejohnston/awesome-agriculture#readme) - Open source technology for farming and gardening.) +* [Product Design](https://github.com/matttga/awesome-product-design#readme) - Design a product from the initial concept to production.) +* [Prisma](https://github.com/catalinmiron/awesome-prisma#readme) - Turn your database into a GraphQL API.) +* [Software Architecture](https://github.com/simskij/awesome-software-architecture#readme) - The discipline of designing and building software.) +* [Connectivity Data and Reports](https://github.com/stevesong/awesome-connectivity-info#readme) - Better understand who has access to telecommunication and internet infrastructure and on what terms.) +* [Stacks](https://github.com/stackshareio/awesome-stacks#readme) - Tech stacks for building different apps and features.) +* [Cytodata](https://github.com/cytodata/awesome-cytodata#readme) - Image-based profiling of biological phenotypes for computational biologists.) +* [IRC](https://github.com/davisonio/awesome-irc#readme) - Open source messaging protocol.) +* [Advertising](https://github.com/cenoura/awesome-ads#readme) - Advertising and programmatic media for websites.) +* [Earth](https://github.com/philsturgeon/awesome-earth#readme) - Find ways to resolve the climate crisis.) +* [Naming](https://github.com/gruhn/awesome-naming#readme) - Naming things in computer science done right.) +* [Biomedical Information Extraction](https://github.com/caufieldjh/awesome-bioie#readme) - How to extract information from unstructured biomedical data and text.) +* [Web Archiving](https://github.com/iipc/awesome-web-archiving#readme) - An effort to preserve the Web for future generations.) +* [WP-CLI](https://github.com/schlessera/awesome-wp-cli#readme) - Command-line interface for WordPress.) +* [Credit Modeling](https://github.com/mourarthur/awesome-credit-modeling#readme) - Methods for classifying credit applicants into risk classes.) +* [Ansible](https://github.com/KeyboardInterrupt/awesome-ansible#readme) - A Python-based, open source IT configuration management and automation platform.) +* [Biological Visualizations](https://github.com/keller-mark/awesome-biological-visualizations#readme) - Interactive visualization of biological data on the web.) +* [QR Code](https://github.com/aureooms/awesome-qr-code#readme) - A type of matrix barcode that can be used to store and share a small amount of information.) +* [Veganism](https://github.com/sdassow/awesome-veganism#readme) - Making the plant-based lifestyle easy and accessible.) +* [Translations](https://github.com/mbiesiad/awesome-translations#readme) - The transfer of the meaning of a text from one language to another.) +) +## Related) +) +* [All Awesome Lists](https://github.com/topics/awesome) - All the Awesome lists on GitHub.) +* [Awesome Indexed](https://awesome-indexed.mathew-davies.co.uk/) - Search the Awesome dataset.) +* [Awesome Search](https://awesomelists.top/) - Quick search for Awesome lists.) +* [StumbleUponAwesome](https://github.com/basharovV/StumbleUponAwesome) - Discover random pages from the Awesome dataset using a browser extension.) +* [Awesome CLI](https://github.com/umutphp/awesome-cli) - A simple command-line tool to dive into Awesome lists.) +* [Awesome Viewer](http://awesome.digitalbunker.dev/) - A visualizer for all of the above Awesome lists.) +) + Created 1 minute ago \| Updated 58 seconds ago) +) + + +---- + +
1-projects/Atomic-Design-Solution-master/dogs/ + +### [1-projects/Atomic-Design-Solution-master/dogs/README.md](1-projects/Atomic-Design-Solution-master/dogs/README.md) + + +**Table of Contents** *generated with [DocToc](https://github.com/thlorenz/doctoc)* + +- [Table of Contents](#table-of-contents) +- [Updating to New Releases](#updating-to-new-releases) +- [Sending Feedback](#sending-feedback) +- [Folder Structure](#folder-structure) +- [Available Scripts](#available-scripts) + - [`npm start`](#npm-start) + - [`npm test`](#npm-test) + - [`npm run build`](#npm-run-build) + - [`npm run eject`](#npm-run-eject) +- [Supported Browsers](#supported-browsers) +- [Supported Language Features and Polyfills](#supported-language-features-and-polyfills) +- [Syntax Highlighting in the Editor](#syntax-highlighting-in-the-editor) +- [Displaying Lint Output in the Editor](#displaying-lint-output-in-the-editor) +- [Debugging in the Editor](#debugging-in-the-editor) + - [Visual Studio Code](#visual-studio-code) + - [WebStorm](#webstorm) +- [Formatting Code Automatically](#formatting-code-automatically) +- [Changing the Page ``](#changing-the-page-title) +- [Installing a Dependency](#installing-a-dependency) +- [Importing a Component](#importing-a-component) + - [`Button.js`](#buttonjs) + - [`DangerButton.js`](#dangerbuttonjs) +- [Code Splitting](#code-splitting) + - [`moduleA.js`](#moduleajs) + - [`App.js`](#appjs) + - [With React Router](#with-react-router) +- [Adding a Stylesheet](#adding-a-stylesheet) + - [`Button.css`](#buttoncss) + - [`Button.js`](#buttonjs-1) +- [Post-Processing CSS](#post-processing-css) +- [Adding a CSS Preprocessor (Sass, Less etc.)](#adding-a-css-preprocessor-sass-less-etc) +- [Adding Images, Fonts, and Files](#adding-images-fonts-and-files) +- [Using the `public` Folder](#using-the-public-folder) + - [Changing the HTML](#changing-the-html) + - [Adding Assets Outside of the Module System](#adding-assets-outside-of-the-module-system) + - [When to Use the `public` Folder](#when-to-use-the-public-folder) +- [Using Global Variables](#using-global-variables) +- [Adding Bootstrap](#adding-bootstrap) + - [Using a Custom Theme](#using-a-custom-theme) +- [Adding Flow](#adding-flow) +- [Adding a Router](#adding-a-router) +- [Adding Custom Environment Variables](#adding-custom-environment-variables) + - [Referencing Environment Variables in the HTML](#referencing-environment-variables-in-the-html) + - [Adding Temporary Environment Variables In Your Shell](#adding-temporary-environment-variables-in-your-shell) + - [Windows (cmd.exe)](#windows-cmdexe) + - [Windows (Powershell)](#windows-powershell) + - [Linux, macOS (Bash)](#linux-macos-bash) + - [Adding Development Environment Variables In `.env`](#adding-development-environment-variables-in-env) + - [What other `.env` files can be used?](#what-other-env-files-can-be-used) + - [Expanding Environment Variables In `.env`](#expanding-environment-variables-in-env) +- [Can I Use Decorators?](#can-i-use-decorators) +- [Fetching Data with AJAX Requests](#fetching-data-with-ajax-requests) +- [Integrating with an API Backend](#integrating-with-an-api-backend) + - [Node](#node) + - [Ruby on Rails](#ruby-on-rails) +- [Proxying API Requests in Development](#proxying-api-requests-in-development) + - ["Invalid Host Header" Errors After Configuring Proxy](#invalid-host-header-errors-after-configuring-proxy) + - [Configuring the Proxy Manually](#configuring-the-proxy-manually) + - [Configuring a WebSocket Proxy](#configuring-a-websocket-proxy) +- [Using HTTPS in Development](#using-https-in-development) + - [Windows (cmd.exe)](#windows-cmdexe-1) + - [Windows (Powershell)](#windows-powershell-1) + - [Linux, macOS (Bash)](#linux-macos-bash-1) +- [Generating Dynamic `<meta>` Tags on the Server](#generating-dynamic-meta-tags-on-the-server) +- [Pre-Rendering into Static HTML Files](#pre-rendering-into-static-html-files) +- [Injecting Data from the Server into the Page](#injecting-data-from-the-server-into-the-page) +- [Running Tests](#running-tests) + - [Filename Conventions](#filename-conventions) + - [Command Line Interface](#command-line-interface) + - [Version Control Integration](#version-control-integration) + - [Writing Tests](#writing-tests) + - [Testing Components](#testing-components) + - [`src/setupTests.js`](#srcsetuptestsjs) + - [Using Third Party Assertion Libraries](#using-third-party-assertion-libraries) + - [Initializing Test Environment](#initializing-test-environment) + - [`src/setupTests.js`](#srcsetuptestsjs-1) + - [Focusing and Excluding Tests](#focusing-and-excluding-tests) + - [Coverage Reporting](#coverage-reporting) + - [Configuration](#configuration) + - [Continuous Integration](#continuous-integration) + - [On CI servers](#on-ci-servers) + - [Travis CI](#travis-ci) + - [CircleCI](#circleci) + - [On your own environment](#on-your-own-environment) + - [Windows (cmd.exe)](#windows-cmdexe-2) + - [Windows (Powershell)](#windows-powershell-2) + - [Linux, macOS (Bash)](#linux-macos-bash-2) + - [Disabling jsdom](#disabling-jsdom) + - [Snapshot Testing](#snapshot-testing) + - [Editor Integration](#editor-integration) +- [Debugging Tests](#debugging-tests) + - [Debugging Tests in Chrome](#debugging-tests-in-chrome) + - [Debugging Tests in Visual Studio Code](#debugging-tests-in-visual-studio-code) +- [Developing Components in Isolation](#developing-components-in-isolation) + - [Getting Started with Storybook](#getting-started-with-storybook) + - [Getting Started with Styleguidist](#getting-started-with-styleguidist) +- [Publishing Components to npm](#publishing-components-to-npm) +- [Making a Progressive Web App](#making-a-progressive-web-app) + - [Opting Out of Caching](#opting-out-of-caching) + - [Offline-First Considerations](#offline-first-considerations) + - [Progressive Web App Metadata](#progressive-web-app-metadata) +- [Analyzing the Bundle Size](#analyzing-the-bundle-size) +- [Deployment](#deployment) + - [Static Server](#static-server) + - [Other Solutions](#other-solutions) + - [Serving Apps with Client-Side Routing](#serving-apps-with-client-side-routing) + - [Building for Relative Paths](#building-for-relative-paths) + - [Serving the Same Build from Different Paths](#serving-the-same-build-from-different-paths) + - [Azure](#azure) + - [Firebase](#firebase) + - [GitHub Pages](#github-pages) + - [Step 1: Add `homepage` to `package.json`](#step-1-add-homepage-to-packagejson) + - [Step 2: Install `gh-pages` and add `deploy` to `scripts` in `package.json`](#step-2-install-gh-pages-and-add-deploy-to-scripts-in-packagejson) + - [Step 3: Deploy the site by running `npm run deploy`](#step-3-deploy-the-site-by-running-npm-run-deploy) + - [Step 4: Ensure your project's settings use `gh-pages`](#step-4-ensure-your-projects-settings-use-gh-pages) + - [Step 5: Optionally, configure the domain](#step-5-optionally-configure-the-domain) + - [Notes on client-side routing](#notes-on-client-side-routing) + - [Heroku](#heroku) + - [Resolving Heroku Deployment Errors](#resolving-heroku-deployment-errors) + - ["Module not found: Error: Cannot resolve 'file' or 'directory'"](#module-not-found-error-cannot-resolve-file-or-directory) + - ["Could not find a required file."](#could-not-find-a-required-file) + - [Netlify](#netlify) + - [Now](#now) + - [S3 and CloudFront](#s3-and-cloudfront) + - [Surge](#surge) +- [Advanced Configuration](#advanced-configuration) +- [Troubleshooting](#troubleshooting) + - [`npm start` doesn't detect changes](#npm-start-doesnt-detect-changes) + - [`npm test` hangs on macOS Sierra](#npm-test-hangs-on-macos-sierra) + - [`npm run build` exits too early](#npm-run-build-exits-too-early) + - [`npm run build` fails on Heroku](#npm-run-build-fails-on-heroku) + - [Moment.js locales are missing](#momentjs-locales-are-missing) + - [`npm run build` fails to minify](#npm-run-build-fails-to-minify) +- [Alternatives to Ejecting](#alternatives-to-ejecting) +- [Something Missing?](#something-missing) + +<!-- END doctoc generated TOC please keep comment here to allow auto update --> + + +</details><details> <summary>1-projects/Atomic-Design-Solution-master/</summary> + +### [1-projects/Atomic-Design-Solution-master/README.md](1-projects/Atomic-Design-Solution-master/README.md) +<!-- START doctoc generated TOC please keep comment here to allow auto update --> +<!-- DON'T EDIT THIS SECTION, INSTEAD RE-RUN doctoc TO UPDATE --> +**Table of Contents** *generated with [DocToc](https://github.com/thlorenz/doctoc)* + +- [Client Side Routing - HTTP - Atomic Design](#client-side-routing---http---atomic-design) + - [Topics](#topics) + - [Description](#description) + - [Instructions](#instructions) + - [Resources](#resources) + - [Post-assignment Resouces:](#post-assignment-resouces) + +<!-- END doctoc generated TOC please keep comment here to allow auto update --> + +# Client Side Routing - HTTP - Atomic Design + +## Topics + * Routing with React Router + * Axios for making HTTP requests + * JavaScript Promises + * Atomic Design + +## Description +In this `create-react-app` initialized app, you will be working with the provided UI library, which has been developed based on `Atomic Design` principles. This is not the only way to design and organize your components, but it will serve as an example of a very strong option. + +The app you will be finishing is an app that lists a few dog breeds, shows an image, and provides links to view their sub-breeds. + +## Instructions +You are given the `atoms`, `molecules`, `organisms`, and `templates` needed to build out this app. You will just need to consume them in your pages `Breeds.js` and `SubBreeds.js`. All of your HTTP requests should be made from inside of the page files. + +* Requirements for `Breeds.js` + * Title should be "Breeds" + * Show a list of dog breeds + * Each list item should be a link to a `SubBreed` page that shows the sub-breed details + * Show an image of the first dog breed in the list, with that breed as a title for the image + * use the provided method `filterBreeds` or any modification of it to limit the list (This is to make sure that the breeds we show actually have sub-breeds. Make sure you still make the initial get requests for the list of dogs first though as part of the assignment exercise) + +* Requirements for `SubBreeds.js` + * Title should be "Sub-breeds" + * Subtitle should be the given breed + * Show a list of sub-breeds for the given breed + * Show an image of the first sub-breed in the list, with that sub-breed as a title for the image + +## Resources + * Dog Breed API: https://dog.ceo/dog-api/ + * Atomic Design: http://bradfrost.com/blog/post/atomic-web-design/ + +## Post-assignment Resouces: + * Component Folder Pattern: https://medium.com/styled-components/component-folder-pattern-ee42df37ec68 + * Modified Atomic Design: https://medium.com/@yejodido/atomic-components-managing-dynamic-react-components-using-atomic-design-part-1-5f07451f261f + + + + + + +</details><details> <summary>1-projects/Basic-JavaScript-master/</summary> + +### [1-projects/Basic-JavaScript-master/README.md](1-projects/Basic-JavaScript-master/README.md) +<!-- START doctoc generated TOC please keep comment here to allow auto update --> +<!-- DON'T EDIT THIS SECTION, INSTEAD RE-RUN doctoc TO UPDATE --> +**Table of Contents** *generated with [DocToc](https://github.com/thlorenz/doctoc)* + +- [Basic JavaScript + ES6](#basic-javascript--es6) + - [Project Description](#project-description) + - [Instructions](#instructions) + +<!-- END doctoc generated TOC please keep comment here to allow auto update --> + +# Basic JavaScript + ES6 +* ES6 +* Const vs Let vs Var +* Lambda/Arrow functions +* Object Destructuring + +### Project Description +* This project should be very familiar to you. You have already suffered through the logic behind a lot of these expressions/functions. +* We're excited to give you something you've already worked on, but to now just convert the code into ES6 syntax. +* Learning to program is all about repetition. So teaching you a new concept with material that you've already learned will help you solidify the material and also teach you new concepts along the way. +* Project files 1 - 3 are all that need to be completed for this assignment. And Project-4 is *Extra Credit*. +* Please have fun! + +### Instructions +* Fork and clone this repo. +* `cd` into this project and Run the command `npm i` to install needed node packages. +* Run the command `npm test` to run the tests. +* Work through the files and make the tests pass. +* Submit a pull request when you are finished and we will review your code. + + + + + +</details><details> <summary>1-projects/Client-Auth-Solution-master/</summary> + +### [1-projects/Client-Auth-Solution-master/README.md](1-projects/Client-Auth-Solution-master/README.md) +<!-- START doctoc generated TOC please keep comment here to allow auto update --> +<!-- DON'T EDIT THIS SECTION, INSTEAD RE-RUN doctoc TO UPDATE --> +**Table of Contents** *generated with [DocToc](https://github.com/thlorenz/doctoc)* + +- [LS-Client-Auth](#ls-client-auth) + - [Packages](#packages) + - [Topics](#topics) + - [Assignment](#assignment) + +<!-- END doctoc generated TOC please keep comment here to allow auto update --> + +# LS-Client-Auth + +## Packages + +* `redux-thunk` +* `cors` + +## Topics + +* Redux Thunk +* localStorage +* axios's config object +* http headers + + +## Assignment + +Clone down this project. Run `npm i`. +Start your MongoDB server by running `mongod` from the command line. +Start the server (on the solution branch) of the LS-Auth repository. + +Complete the SignUp component. When the user fills out the form you should send and +axios POST request to the server to save the user to the database. If successful then you +should save the provided JWT to localStorage and then redirect the user to `/users`. +User the existing code as a reference. + +You will also need to make sure that your server is using the `cors` middleware. +Instructions for adding cors: +* `npm i --save cors` +* `const cors = require('cors');` +* `app.use(cors());` + + + + + +</details><details> <summary>1-projects/Components-BEM-Solution-master/</summary> + +### [1-projects/Components-BEM-Solution-master/README.md](1-projects/Components-BEM-Solution-master/README.md) +<!-- START doctoc generated TOC please keep comment here to allow auto update --> +<!-- DON'T EDIT THIS SECTION, INSTEAD RE-RUN doctoc TO UPDATE --> +**Table of Contents** *generated with [DocToc](https://github.com/thlorenz/doctoc)* + +- [**COMPONENTS-BEM**](#components-bem) +- [Resources](#resources) + +<!-- END doctoc generated TOC please keep comment here to allow auto update --> + +**COMPONENTS-BEM** +---------------------------------- + +Topics: +* Naming Conventions +* BEM +* Constructors with ES6 class syntax + +You will be turning the wireframes provided in the markups directory into a page. + +Using BEM, create the page with three components: `Section`, `Box`, and `Dropdown`. +Using ES6 class constructors, complete the `Dropdown` component functionality. + +Here is some Lorem Ipsum text: + +`Lorem ipsum dolor sit amet, consectetur adipiscing elit. Fusce risus nibh, gravida nec felis quis, facilisis facilisis lectus. Nulla ac orci pretium, condimentum orci quis, accumsan nisi. Aliquam erat volutpat. Curabitur cursus mattis libero, at viverra risus hendrerit quis. Fusce imperdiet tristique tortor non tincidunt. Mauris accumsan urna nec augue feugiat porta. Proin vitae magna in ex malesuada laoreet eget a nulla. Aliquam tristique et elit at consequat. In hac habitasse platea dictumst.` + + +## Resources + BEM: http://getbem.com/naming/ + + Constructors (and factory function): https://medium.com/javascript-scene/javascript-factory-functions-vs-constructor-functions-vs-classes-2f22ceddf33e + + + + +</details><details> <summary>1-projects/Components-Constructors-Solution-master/</summary> + +### [1-projects/Components-Constructors-Solution-master/README.md](1-projects/Components-Constructors-Solution-master/README.md) +<!-- START doctoc generated TOC please keep comment here to allow auto update --> +<!-- DON'T EDIT THIS SECTION, INSTEAD RE-RUN doctoc TO UPDATE --> +**Table of Contents** *generated with [DocToc](https://github.com/thlorenz/doctoc)* + +- [**COMPONENTS-CONSTURCTORS**](#components-consturctors) +- [Description](#description) +- [Resources](#resources) + +<!-- END doctoc generated TOC please keep comment here to allow auto update --> + +**COMPONENTS-CONSTURCTORS** +---------------------------------- + +Topics: +* Naming Conventions +* BEM +* Constructors with ES6 class syntax + +You will be building on your prior work from Components-BEM by adding a `Tabs` component. + +The HTML and CSS for the Tabs component and instance are provided so that you may add your prior work around it. If you have not finished Components-BEM, ask you TA for the solution. + +You may need to adjust some of the naming for the usuage of `Box` in the HTML provided if it's different in your implementation. + +## Description + The `Tabs` component should be a grouping of links and associated items. Only one item is shown at a time, and each item is shown when its corresponding link is clicked. You should default to the first link and item upon page load. + + You will also be doing a more complex query with `querySelector` and Data Attributes. It's a great challenge to try to work out on your own. If it's holding you back too much, you may ask your TA for the solution to that query. + +## Resources + + Data Attributes: https://developer.mozilla.org/en-US/docs/Learn/HTML/Howto/Use_data_attributes + + BEM: http://getbem.com/naming/ + + Constructors (and factory function): https://medium.com/javascript-scene/javascript-factory-functions-vs-constructor-functions-vs-classes-2f22ceddf33e + + + + +</details><details> <summary>1-projects/Data-Structures-master/</summary> + +### [1-projects/Data-Structures-master/Data_Structures_Questions.md](1-projects/Data-Structures-master/Data_Structures_Questions.md) +<!-- START doctoc generated TOC please keep comment here to allow auto update --> +<!-- DON'T EDIT THIS SECTION, INSTEAD RE-RUN doctoc TO UPDATE --> +**Table of Contents** *generated with [DocToc](https://github.com/thlorenz/doctoc)* + +- [Stack](#stack) +- [Queue](#queue) +- [Doubly Linked List](#doubly-linked-list) +- [Binary Search Tree](#binary-search-tree) +- [Heap](#heap) + +<!-- END doctoc generated TOC please keep comment here to allow auto update --> + +Answer the following questions for each of the data structures you implemented as part of this project. + +## Stack + +1. What is the runtime complexity of `push` using a list? + +2. What is the runtime complexity of `push` using a linked list? + +3. What is the runtime complexity of `pop` using a list? + +4. What is the runtime complexity of `pop` using a linked list? + +5. What is the runtime complexity of `len` using a list? + +6. What is the runtime complexity of `len` using a linked list? + +## Queue + +1. What is the runtime complexity of `enqueue` using a list? + +2. What is the runtime complexity of `enqueue` using a linked list? + +3. What is the runtime complexity of `dequeue` using a list? + +4. What is the runtime complexity of `dequeue` using a linked list? + +5. What is the runtime complexity of `len` using a list? + +6. What is the runtime complexity of `len` using a linked list? + +## Doubly Linked List + +1. What is the runtime complexity of `ListNode.insert_after`? + +2. What is the runtime complexity of `ListNode.insert_before`? + +3. What is the runtime complexity of `ListNode.delete`? + +4. What is the runtime complexity of `DoublyLinkedList.add_to_head`? + +5. What is the runtime complexity of `DoublyLinkedList.remove_from_head`? + +6. What is the runtime complexity of `DoublyLinkedList.add_to_tail`? + +7. What is the runtime complexity of `DoublyLinkedList.remove_from_tail`? + +8. What is the runtime complexity of `DoublyLinkedList.move_to_front`? + +9. What is the runtime complexity of `DoublyLinkedList.move_to_end`? + +10. What is the runtime complexity of `DoublyLinkedList.delete`? + + a. Compare the runtime of the doubly linked list's `delete` method with the worst-case runtime of the JS `Array.splice` method. Which method generally performs better? + +## Binary Search Tree + +1. What is the runtime complexity of `insert`? + +2. What is the runtime complexity of `contains`? + +3. What is the runtime complexity of `get_max`? + +4. What is the runtime complexity of `for_each`? + +## Heap + +1. What is the runtime complexity of `_bubble_up`? + +2. What is the runtime complexity of `_sift_down`? + +3. What is the runtime complexity of `insert`? + +4. What is the runtime complexity of `delete`? + +5. What is the runtime complexity of `get_max`? + + + + + +### [1-projects/Data-Structures-master/FAQ.md](1-projects/Data-Structures-master/FAQ.md) + +<!-- START doctoc generated TOC please keep comment here to allow auto update --> +<!-- DON'T EDIT THIS SECTION, INSTEAD RE-RUN doctoc TO UPDATE --> +**Table of Contents** *generated with [DocToc](https://github.com/thlorenz/doctoc)* + +- [Data Structures FAQ](#data-structures-faq) + - [Contents](#contents) + - [General](#general) + - [My imports aren't working, help!](#my-imports-arent-working-help) + - [What are real-world use-cases for a Queue data structure?](#what-are-real-world-use-cases-for-a-queue-data-structure) + - [What are real-world use-cases for a Stack data structure?](#what-are-real-world-use-cases-for-a-stack-data-structure) + - [What are real-world use-cases for a Linked List data structure?](#what-are-real-world-use-cases-for-a-linked-list-data-structure) + - [How are Linked-Lists different than an Array?](#how-are-linked-lists-different-than-an-array) + - [I've always been able to add as much as I want to an Array and take things out from the beginning, end, or anywhere else. It's never been a problem before, why are we bothering with all of this?](#ive-always-been-able-to-add-as-much-as-i-want-to-an-array-and-take-things-out-from-the-beginning-end-or-anywhere-else--its-never-been-a-problem-before-why-are-we-bothering-with-all-of-this) + - [What are real-world use-cases for a LRU Cache?](#what-are-real-world-use-cases-for-a-lru-cache) + - [What is the dictionary being used for in the LRU Cache?](#what-is-the-dictionary-being-used-for-in-the-lru-cache) + - [What are real-world use-cases for a Binary Search Tree data structure?](#what-are-real-world-use-cases-for-a-binary-search-tree-data-structure) + - [How is the root element of a Binary Search Tree decided?](#how-is-the-root-element-of-a-binary-search-tree-decided) + - [What is the difference between Breadth First and Depth First?](#what-is-the-difference-between-breadth-first-and-depth-first) + - [What is the difference between a Search and a Traversal?](#what-is-the-difference-between-a-search-and-a-traversal) + +<!-- END doctoc generated TOC please keep comment here to allow auto update --> + +# Data Structures FAQ +## Contents +### General + +#### My imports aren't working, help! +Python can be tricky with how imports work and can vary from environment to environment. If you are having trouble, the easiest solution is to copy the file you want to import into the same folder as the file you want to import it into and use `from file import class`. + +This is not a best practice for a real application, but it is acceptable for this exercise. Just remember that this may mean if you want to change or update your code, you will have to do it in multiple places. + +#### What are real-world use-cases for a Queue data structure? +Queues are used anywhere in which you want to work with data `First in First Out` (FIFO). Server requests, without any prioritization, are handled this way. We'll also use it to conduct a breadth first traversal and breadth first search. + +#### What are real-world use-cases for a Stack data structure? +Stacks are used when you want to work with data `Last in First Out` (LIFO or FILO). They're used in processor architecture, undo logic, and depth first searches and traversals. + +#### What are real-world use-cases for a Linked List data structure? +Linked Lists can be used to create `queues` and `stacks`. They're also a key part of resolving collisions in hash tables, which we'll learn more about in a few weeks. + +#### How are Linked-Lists different than an Array? +Both linked lists and arrays are linear data structures. An array is the most space efficient type of storage possible and has great time complexity for most operations. Logically, the array is linear in structure, and it is stored in a linear segment of memory. It is accessed by starting at the memory address of the pointer and counting forward the number of bits resulting from the `index` times the size of the data type. One weakness is the time complexity of operations that take data out of anywhere but the end and another is changing the size of the array. + +A linked list is not as efficient for storage because each element requires a pointer to the next, and in a doubly-linked list, previous element. It is also more difficult to access the elements. Because there's no index, you must loop through the list to search for the item you want, which is O(n). However, a linked list does not require a contiguous block of memory. It has 0(1) to remove or add items anywhere in the list. + +Generally speaking, it's usually best to use an array unless you expect to frequently add and remove items from anywhere other than the end. In that case, it's better to use a linked list. + +#### I've always been able to add as much as I want to an Array and take things out from the beginning, end, or anywhere else. It's never been a problem before, why are we bothering with all of this? +We're looking under the hood! High level languages like Python abstract away most of the inner workings of everything we do. Most of the time this is a good thing and most of the time it doesn't matter. However, we're professional engineers and sometimes we need to solve problems where the details can have a major impact on success or failure. Think about your car. Do you know exactly how much weight you can put in it? Probably not, nor do you need to. But if you find yourself needing to put a load of bags of concrete in the trunk it suddenly becomes very important. As an engineer, you'll be expected to understand when the details do and do not matter. + +#### What are real-world use-cases for a LRU Cache? +An LRU cache is an efficient type of caching system that keeps recently used items and when the cache becomes full, pushes out the least recently used item in the cache. It can be used any time a subset of data is used frequently that needs to be pulled from a source with a long lookup time. For example, cacheing the most frequently accessed items from a database on a remote server. + +#### What is the dictionary being used for in the LRU Cache? +We can't access items in a linked list directly because linked lists are not indexed. To see if an item is already in the cache, we'd need to loop through the cache at O(n). By also adding a dictionary to organize the nodes that are already present in memory, we index the linked list for a very small overhead cost. + +#### What are real-world use-cases for a Binary Search Tree data structure? +A BST in the way that is being implemented for this Sprint is a bit too simple to see any real-world use-cases. There are many (more complex) variants of BSTs that do see production use. One very notable variant is the [B-tree](https://en.wikipedia.org/wiki/B-tree), which is a self-balancing ordered variant of the BST. B-trees play a critical role in database and file system indexing. Other notable variants include the AVL tree, which is a self-balancing BST and the prefix tree, which is specialized for handling text. + +#### How is the root element of a Binary Search Tree decided? +The first element added to a BST is the root of the tree. However, doing it this way means that it's a very simple matter to end up with a lopsided BST. If we simply insert a monotonically ascending or descending sequence of values, then the tree would essentially flatten down to a linked list, and we'd lose all the benefits that a BST is supposed to confer. Self-balancing variants of the BST exist in order to alleviate this exact problem. + +#### What is the difference between Breadth First and Depth First? +In depth first, we pick one path at each branch and keep going forward until we hit a dead end, then backtrack and take the first branch we find. In breadth first, we go by layers, one row deeper each time. This means that we jump around a bit. + +#### What is the difference between a Search and a Traversal? +A search and a traversal are processed exactly the same. The difference is that we stop a search when we find what we were looking for, or when all nodes have been visited without finding it. In a traversal, we always keep going until we've visited every node. + + + +</details><details> <summary>1-projects/Data-Structures-master/heap/</summary> + +### [1-projects/Data-Structures-master/heap/README.md](1-projects/Data-Structures-master/heap/README.md) +<!-- START doctoc generated TOC please keep comment here to allow auto update --> +<!-- DON'T EDIT THIS SECTION, INSTEAD RE-RUN doctoc TO UPDATE --> +**Table of Contents** *generated with [DocToc](https://github.com/thlorenz/doctoc)* + +- [Stretch Goal: Heaps](#stretch-goal-heaps) + - [Max Heaps](#max-heaps) + - [Generic Heaps](#generic-heaps) + +<!-- END doctoc generated TOC please keep comment here to allow auto update --> + +# Stretch Goal: Heaps + +## Max Heaps +* Should have the methods `insert`, `delete`, `get_max`, `_bubble_up`, and `_sift_down`. + * `insert` adds the input value into the heap; this method should ensure that the inserted value is in the correct spot in the heap + * `delete` removes and returns the 'topmost' value from the heap; this method needs to ensure that the heap property is maintained after the topmost element has been removed. + * `get_max` returns the maximum value in the heap _in constant time_. + * `get_size` returns the number of elements stored in the heap. + * `_bubble_up` moves the element at the specified index "up" the heap by swapping it with its parent if the parent's value is less than the value at the specified index. + * `_sift_down` grabs the indices of this element's children and determines which child has a larger value. If the larger child's value is larger than the parent's value, the child element is swapped with the parent. + +![Image of a Heap in Tree form](https://upload.wikimedia.org/wikipedia/commons/thumb/3/38/Max-Heap.svg/501px-Max-Heap.svg.png) + +![Image of a Heap in Array form](https://upload.wikimedia.org/wikipedia/commons/thumb/d/d2/Heap-as-array.svg/603px-Heap-as-array.svg.png) + +## Generic Heaps +A max heap is pretty useful, but what's even more useful is to have our heap be generic such that the user can define their own priority function and pass it to the heap to use. + +Augment your heap implementation so that it exhibits this behavior. If no comparator function is passed in to the heap constructor, it should default to being a max heap. Also change the name of the `get_max` function to `get_priority`. + +You can test your implementation against the tests in `test_generic_heap.py`. The test expects your augmented heap implementation lives in a file called `generic_heap.py`. Feel free to change the import statement to work with your file structure or copy/paste your implementation into a file with the expected name. + + + + +</details><details> <summary>1-projects/Data-Structures-master/</summary> + +### [1-projects/Data-Structures-master/README.md](1-projects/Data-Structures-master/README.md) +<!-- START doctoc generated TOC please keep comment here to allow auto update --> +<!-- DON'T EDIT THIS SECTION, INSTEAD RE-RUN doctoc TO UPDATE --> +**Table of Contents** *generated with [DocToc](https://github.com/thlorenz/doctoc)* + +- [Data Structures](#data-structures) + - [Completion Requirements](#completion-requirements) + - [Stacks](#stacks) + - [Queues](#queues) + - [Doubly Linked Lists](#doubly-linked-lists) + - [Binary Search Trees](#binary-search-trees) + - [Stretch Goals](#stretch-goals) + - [LRU Cache](#lru-cache) + - [AVL Tree](#avl-tree) + +<!-- END doctoc generated TOC please keep comment here to allow auto update --> + +# Data Structures + +Topics: + * Singly Linked Lists + * Queues and Stacks + * Doubly Linked Lists + * Binary Search Trees + * Related Code Challenge Problems + +Stretch Goals: + * LRU Cache + * Heaps + * AVL Trees + +## Completion Requirements + * Module 1: Implement the Stack and Queue classes using built-in Python lists and the Node and LinkedList classes you created during the Module 1 Guided Project. + * Module 2: Implement the Doubly Linked List class + * Module 3: Implement the Binary Search Tree class + * Module 4: Implement traversal methods on Binary Search Trees + + > NOTE: The quickest and easiest way to reliably import a file in Python is to just copy and paste the file you want to import into the same directory as the file that wants to import. This obviously isn't considered best practice, but it is the most reliable way to do it across all platforms. If the import isn't working, feel free to try this method. + +### Stacks +* Should have the methods: `push`, `pop`, and `len`. + * `push` adds an item to the top of the stack. + * `pop` removes and returns the element at the top of the stack + * `len` returns the number of elements in the stack. + +### Queues + * Has the methods: `enqueue`, `dequeue`, and `len`. + * `enqueue` adds an element to the back of the queue. + * `dequeue` removes and returns the element at the front of the queue. + * `len` returns the number of elements in the queue. + +![Image of Queue](https://upload.wikimedia.org/wikipedia/commons/thumb/5/52/Data_Queue.svg/600px-Data_Queue.svg.png) + +### Doubly Linked Lists + * The `ListNode` class, which represents a single node in the doubly-linked list, has already been implemented for you. Inspect this code and try to understand what it is doing to the best of your ability. + * The `DoublyLinkedList` class itself should have the methods: `add_to_head`, `add_to_tail`, `remove_from_head`, `remove_from_tail`, `move_to_front`, `move_to_end`, `delete`, and `get_max`. + * `add_to_head` replaces the head of the list with a new value that is passed in. + * `add_to_tail` replaces the tail of the list with a new value that is passed in. + * `remove_from_head` removes the head node and returns the value stored in it. + * `remove_from_tail` removes the tail node and returns the value stored in it. + * `move_to_front` takes a reference to a node in the list and moves it to the front of the list, shifting all other list nodes down. + * `move_to_end` takes a reference to a node in the list and moves it to the end of the list, shifting all other list nodes up. + * `delete` takes a reference to a node in the list and removes it from the list. The deleted node's `previous` and `next` pointers should point to each afterwards. + * `get_max` returns the maximum value in the list. + * The `head` property is a reference to the first node and the `tail` property is a reference to the last node. + +![Image of Doubly Linked List](https://upload.wikimedia.org/wikipedia/commons/thumb/5/5e/Doubly-linked-list.svg/610px-Doubly-linked-list.svg.png) + +### Binary Search Trees +* Should have the methods `insert`, `contains`, `get_max`. + * `insert` adds the input value to the binary search tree, adhering to the rules of the ordering of elements in a binary search tree. + * `contains` searches the binary search tree for the input value, returning a boolean indicating whether the value exists in the tree or not. + * `get_max` returns the maximum value in the binary search tree. + * `for_each` performs a traversal of _every_ node in the tree, executing the passed-in callback function on each tree node value. There is a myriad of ways to perform tree traversal; in this case any of them should work. + +![Image of Binary Search Tree](https://upload.wikimedia.org/wikipedia/commons/thumb/d/da/Binary_search_tree.svg/300px-Binary_search_tree.svg.png) + +--- + +Once you've gotten the tests passing, it's time to analyze the runtime complexity of your `get` and `set` operations. There's a way to get both operations down to sub-linear time. In fact, we can get them each down to constant time by picking the right data structures to use. + +Here are you some things to think about with regards to optimizing your implementation: If you opted to use a dictionary to work with key-value pairs, we know that dictionaries give us constant access time, which is great. It's cheap and efficient to fetch pairs. A problem arises though from the fact that dictionaries don't have any way of remembering the order in which key-value pairs are added. But we definitely need something to remember the order in which pairs are added. Can you think of some ways to get around this constraint? + +## Stretch Goals + +### LRU Cache +An LRU (Least Recently Used) cache is an in-memory storage structure that adheres to the [Least Recently Used](https://en.wikipedia.org/wiki/Cache_replacement_policies#Least_recently_used_(LRU)) caching strategy. + +In essence, you can think of an LRU cache as a data structure that keeps track of the order in which elements (which take the form of key-value pairs) it holds are added and updated. The cache also has a max number of entries it can hold. This is important because once the cache is holding the max number of entries, if a new entry is to be inserted, another pre-existing entry needs to be evicted from the cache. Because the cache is using a least-recently used strategy, the oldest entry (the one that was added/updated the longest time ago) is removed to make space for the new entry. + +So what operations will we need on our cache? We'll certainly need some sort of `set` operation to add key-value pairs to the cache. Newly-set pairs will get moved up the priority order such that every other pair in the cache is now one spot lower in the priority order that the cache maintains. The lowest-priority pair will get removed from the cache if the cache is already at its maximal capacity. Additionally, in the case that the key already exists in the cache, we simply want to overwrite the old value associated with the key with the newly-specified value. + +We'll also need a `get` operation that fetches a value given a key. When a key-value pair is fetched from the cache, we'll go through the same priority-increase dance that also happens when a new pair is added to the cache. + +Note that the only way for entries to be removed from the cache is when one needs to be evicted to make room for a new one. Thus, there is no explicit `remove` method. + +Given the above spec, try to get a working implementation that passes the tests. What data structure(s) might be good candidates with which to build our cache on top of? Hint: Since our cache is going to be storing key-value pairs, we might want to use a structure that is adept at handling those. + +### AVL Tree +An AVL tree (Georgy Adelson-Velsky and Landis' tree, named after the inventors) is a self-balancing binary search tree. In an AVL tree, the heights of the two child subtrees of any node differ by at most one; if at any time they differ by more than one, rebalancing is done to restore this property. + +We define balance factor for each node as : +``` +balanceFactor = height(left subtree) - height(right subtree) +``` + +The balance factor of any node of an AVL tree is in the integer range [-1,+1]. If after any modification in the tree, the balance factor becomes less than −1 or greater than +1, the subtree rooted at this node is unbalanced, and a rotation is needed. + +![AVL tree rebalancing](https://s3.amazonaws.com/hr-challenge-images/0/1436854305-b167cc766c-AVL_Tree_Rebalancing.svg.png) + +Implement an AVL Tree class that exhibits the aforementioned behavior. The tree's `insert` method should perform the same logic as what was implemented for the binary search tree, with the caveat that upon inserting a new element into the tree, it will then check to see if the tree needs to be rebalanced. + +How does the time complexity of the AVL Tree's insertion method differ from the binary search tree's? + + + + + +</details><details> <summary>1-projects/DOM-JavaScript-mini-Solution-master/</summary> + +### [1-projects/DOM-JavaScript-mini-Solution-master/README.md](1-projects/DOM-JavaScript-mini-Solution-master/README.md) + + + + + +</details><details> <summary>1-projects/HTML-CSS-mini-Solution-master/</summary> + +### [1-projects/HTML-CSS-mini-Solution-master/README.md](1-projects/HTML-CSS-mini-Solution-master/README.md) +<!-- START doctoc generated TOC please keep comment here to allow auto update --> +<!-- DON'T EDIT THIS SECTION, INSTEAD RE-RUN doctoc TO UPDATE --> +**Table of Contents** *generated with [DocToc](https://github.com/thlorenz/doctoc)* + +- [**HTML/CSS mini**](#htmlcss-mini) +- [Extra Credit](#extra-credit) + +<!-- END doctoc generated TOC please keep comment here to allow auto update --> + +**HTML/CSS mini** +---------------------------------- + +Topics: +* Box Model +* Flex Box +* BEM Naming Conventions +* Extra Credit: Media Queries + +You will be turning the provided wireframe into a page. For your first implementation, use only box model rules. Half way through the alotted time, refactor what you have to use flexbox. Make your second solution on a second branch. + +You're provided with an index.html file and a styles.css file to begin with, but you're welcome to restructure as you see fit. The mockups are also in the mockup folder for your reference. The full width version is the first you'll be implementing. The mid and small are for extra credit. + +<a src="https://docs.google.com/document/d/1db_gVHonRIAjozSZ7NFsqghJ5B7gdGWgRF0c-3oIGdA/edit?usp=sharing"><strong>Box Model Study Guide</strong></a> + +<img src="./mockups/full_width.png"/> + +## Extra Credit + * Make your Box Model solution responsive to browser resizing using media queries. + <a src="https://docs.google.com/document/d/15ucW3PUI3mBPq85gUF_TrVmm9W3HM8LZ6VxhZKZdDqE/edit?usp=sharing"><strong>Media Query Min & Max Width Quick Reference</strong></a> +<img src="./mockups/mid_width.png" style="width: 500px; display: inline-block;" /> +<img src="./mockups/small_width.png" style="width: 300px; display: inline-block;" /> + + + + + +</details><details> <summary>1-projects/Intro-Python-I-master/</summary> + +### [1-projects/Intro-Python-I-master/FAQ.md](1-projects/Intro-Python-I-master/FAQ.md) +<!-- START doctoc generated TOC please keep comment here to allow auto update --> +<!-- DON'T EDIT THIS SECTION, INSTEAD RE-RUN doctoc TO UPDATE --> +**Table of Contents** *generated with [DocToc](https://github.com/thlorenz/doctoc)* + +- [FAQ](#faq) + - [Contents](#contents) + - [General CS](#general-cs) + - [General Python](#general-python) + - [Pipenv](#pipenv) + - [Object-Oriented Programming](#object-oriented-programming) + - [Python Scoping](#python-scoping) + - [Types](#types) + - [Questions](#questions) + - [What are some things we can do to prepare for CS?](#what-are-some-things-we-can-do-to-prepare-for-cs) + - [Why is there such a debate between OOP and functional programming, and why should we care?](#why-is-there-such-a-debate-between-oop-and-functional-programming-and-why-should-we-care) + - [In regard to the code challenge solution, why is the '+' operator being used to concatenate strings? I thought we were supposed to use the join() method in Python?](#in-regard-to-the-code-challenge-solution-why-is-the--operator-being-used-to-concatenate-strings-i-thought-we-were-supposed-to-use-the-join-method-in-python) + - [How do you get out of the Python built-in `help`?](#how-do-you-get-out-of-the-python-built-in-help) + - [Are there any helpful VS Code extensions that are recommend for using with Python?](#are-there-any-helpful-vs-code-extensions-that-are-recommend-for-using-with-python) + - [I'm on Windows; what command do I use to run Python?](#im-on-windows-what-command-do-i-use-to-run-python) + - [What version of Python do I need?](#what-version-of-python-do-i-need) + - [Do I need to use pipenv?](#do-i-need-to-use-pipenv) + - [How do I get out of the Python REPL?](#how-do-i-get-out-of-the-python-repl) + - [What does "REPL" mean?](#what-does-repl-mean) + - [I'm on a Mac and when I run Python it says I'm on version 2.7. Why?](#im-on-a-mac-and-when-i-run-python-it-says-im-on-version-27-why) + - [Does Python use tabs or spaces?](#does-python-use-tabs-or-spaces) + - [How do I convert an iterator into a list?](#how-do-i-convert-an-iterator-into-a-list) + - [Does Python have hoisting?](#does-python-have-hoisting) + - [Does scoping work similar to other languages?](#does-scoping-work-similar-to-other-languages) + - [Can you return a reference to a function from another function? Or store it in a variable?](#can-you-return-a-reference-to-a-function-from-another-function-or-store-it-in-a-variable) + - [Can you use boolean shortcut assignments?](#can-you-use-boolean-shortcut-assignments) + - [Can you do anonymous functions?](#can-you-do-anonymous-functions) + - [Is a dict like a JavaScript object?](#is-a-dict-like-a-javascript-object) + - [What are all those method names with double underscores around them?](#what-are-all-those-method-names-with-double-underscores-around-them) + - [How do I get a value from a dict?](#how-do-i-get-a-value-from-a-dict) + - [When do we run pipenv shell?](#when-do-we-run-pipenv-shell) + - [How do I get out of the pipenv shell?](#how-do-i-get-out-of-the-pipenv-shell) + - [How do I install additional packages from pipenv?](#how-do-i-install-additional-packages-from-pipenv) + - [Is it possible to use system-wide packages from inside the virtual environment?](#is-it-possible-to-use-system-wide-packages-from-inside-the-virtual-environment) + - [Where are good Python docs?](#where-are-good-python-docs) + - [Which linter?](#which-linter) + - [Can you dynamically add new methods/properties to class through other functions? Or must all properties/methods be declared at once?](#can-you-dynamically-add-new-methodsproperties-to-class-through-other-functions-or-must-all-propertiesmethods-be-declared-at-once) + - [Following this flow: 1) class Dog is created with attributes size and weight. 2) New instance called Snoopy of class Dog is created. 3) Class Dog gets the method bark() dynamically added to it. Question: will Snoopy now have access to bark() method?](#following-this-flow-1-class-dog-is-created-with-attributes-size-and-weight-2-new-instance-called-snoopy-of-class-dog-is-created-3-class-dog-gets-the-method-bark-dynamically-added-to-it-question-will-snoopy-now-have-access-to-bark-method) + - [If a subclass inherits from two superclasses with a method of the same name, which method will the subclass use?](#if-a-subclass-inherits-from-two-superclasses-with-a-method-of-the-same-name-which-method-will-the-subclass-use) + - [How to handle multiple inheritance and why/when to do it in the first place?](#how-to-handle-multiple-inheritance-and-whywhen-to-do-it-in-the-first-place) + - [Why use tuples instead of lists?](#why-use-tuples-instead-of-lists) + - [What's the difference between __repr__ and __str__?](#whats-the-difference-between-__repr__-and-__str__) + - [How does `sys.argv` work?](#how-does-sysargv-work) + - [How do I concatenate two arrays into a single array?](#how-do-i-concatenate-two-arrays-into-a-single-array) + - [What are some ways to learn a new language?](#what-are-some-ways-to-learn-a-new-language) + - [Why test code frequently?](#why-test-code-frequently) + - [Why isn't official documentation more helpful than Stack Overflow?](#why-isnt-official-documentation-more-helpful-than-stack-overflow) + - [During an interview, what do I do if I can't remember the exact syntax?](#during-an-interview-what-do-i-do-if-i-cant-remember-the-exact-syntax) + +<!-- END doctoc generated TOC please keep comment here to allow auto update --> + +# FAQ + +<!-- TODO +positional args vs keyword ards +What's the difference between inheritance and polymorphism? +--> + +## Contents + +### General CS + +* [What are some things we can do to prepare for CS?](#q100) +* [What are some ways to learn a new language?](#q3600) +* [Why test code frequently?](#q3700) +* [Why isn't official documentation more helpful than Stack Overflow?](#q3800) +* [During an interview, what do I do if I can't remember the exact syntax?](#q3900) + +### General Python + +* [In regard to the code challenge solution, why is the '+' operator being used to concatenate strings? I thought we were supposed to use the join() method in Python?](#q300) +* [How do you get out of the Python built-in `help`?](#q400) +* [Are there any helpful VS Code extensions that are recommend for using with Python?](#q500) +* [I'm on Windows; what command do I use to run Python?](#q600) +* [What version of Python do I need?](#q700) +* [How do I get out of the Python REPL?](#q900) +* [What does "REPL" mean?](#q1000) +* [I'm on a Mac and when I run Python it says I'm on version 2.7. Why?](#q1100) +* [Does Python use tabs or spaces?](#q1200) +* [Can you use boolean shortcut assignments?](#q1700) +* [Can you do anonymous functions?](#q1800) +* [What are all those method names with double underscores around them?](#q2000) +* [Where are good Python docs?](#q2600) +* [Which linter?](#q2700) +* [What's the difference between __repr__ and __str__?](#q3300) +* [How does `sys.argv` work?](#q3400) + +### Pipenv + +* [Do I need to use pipenv?](#q800) +* [When do we run pipenv shell?](#q2200) +* [How do I get out of the pipenv shell?](#q2300) +* [How do I install additional packages from pipenv?](#q2400) +* [Is it possible to use system-wide packages from inside the virtual environment?](#q2500) + +### Object-Oriented Programming + +* [Why is there such a debate between OOP and functional programming, and why should we care?](#q200) +* [Following this flow: 1) class Dog is created with attributes size and weight. 2) New instance called Snoopy of class Dog is created. 3) Class Dog gets the method bark() dynamically added to it. Question: will Snoopy now have access to bark() method?](#q2900) +* [Can you dynamically add new methods/properties to class through other functions? Or must all properties/methods be declared at once?](#q2800) +* [If a subclass inherits from two superclasses with a method of the same name, which method will the subclass use?](#q3000) +* [How to handle multiple inheritance and why/when to do it in the first place?](#q3100) + +### Python Scoping + +* [Does Python have hoisting?](#q1400) +* [Does scoping work similar to other languages?](#q1500) +* [Can you return a reference to a function from another function? Or store it in a variable?](#q1600) +* [Can you do anonymous functions?](#q1800) + +### Types + +* [How do I convert an iterator into a list?](#q1300) +* [Is a dict like a JavaScript object?](#q1900) +* [How do I get a value from a dict?](#q2100) +* [Why use tuples instead of lists?](#q3200) +* [How do I concatenate two arrays into a single array?](#q3500) + +## Questions + +<a name="q100"></a> +### What are some things we can do to prepare for CS? + +* [CS Wiki](https://github.com/LambdaSchool/CS-Wiki/wiki) +* [Polya's Problem Solving Techniques](https://github.com/LambdaSchool/CS-Wiki/wiki/Polya%27s-Problem-Solving-Techniques) +* [Solving Programming Problems](https://github.com/LambdaSchool/CS-Wiki/wiki/Solving-Programming-Problems) +* [CS Reading List](https://github.com/LambdaSchool/CS-Wiki/wiki/Computer-Science-Reading-List) +* [How to Google effectively](https://github.com/LambdaSchool/CS-Wiki/wiki/How-to-Google-Effectively) +* [How to read specs and code](https://github.com/LambdaSchool/CS-Wiki/wiki/How-to-Read-Specifications-and-Code) +* [Command line primer](https://github.com/LambdaSchool/CS-Wiki/wiki/Command-Line-Primer) +* [Coding style guidelines](https://github.com/LambdaSchool/CS-Wiki/wiki/CS-Coding-Style-Guidelines) + +------------------------------------------------------------------------ + +<a name="q200"></a> +### Why is there such a debate between OOP and functional programming, and why should we care? + +There are a lot of [programming +paradigms](https://en.wikipedia.org/wiki/Programming_paradigm) and they all have +their strengths and weaknesses when it comes to solving different types of +problems. + +People can be quite opinionated about their favorites, but it's important to +remember that no one language or paradigm is the right tool for all jobs. And, +additionally, that virtually all problems can be solved in any of the +declarative or imperative paradigms. (Some might produce cleaner, more elegant +code for a particular problem.) + +Paradigms are the hardest thing to learn because you often have to take all the +knowledge you have about solving a problem in another paradigm and throw it out +the window. You have to learn new patterns and techniques to be effective. + +But we encourage this kind of learning because most popular languages are to +some degree _multi-paradigm_, and the more techniques you know from more +paradigms, the more effective you are in that multi-paradigm langage. + +------------------------------------------------------------------------ + +<a name="q300"></a> +### In regard to the code challenge solution, why is the '+' operator being used to concatenate strings? I thought we were supposed to use the join() method in Python? + +Using `join()` to join large numbers of strings is definitely faster in Python +than using the `+` operator to do it. The reason is that every time you `join()` +or use the `+` operator, a new string is created. So if you only have to +`join()` once, versus using `+` hundreds of times, you'll run faster. + +That said, if you want to use the `join()` approach, you'll have to have all +your strings in a list, which uses more memory than just having the two or three +that you need at a time to use `+`. So there's a tradeoff. + +Another tradeoff might be in readability. It might be easier to read the `+` +version. That's worth something. + +Finally, if `+` is fast enough for this case, it might not be worth the time to +bother with making a list of strings to `join()`. + +* [Speed comparison with different ways of concatenating strings](https://waymoot.org/home/python_string/) + +------------------------------------------------------------------------ + +<a name="q400"></a> +### How do you get out of the Python built-in `help`? + +Hit `q` for "quit". + +It's a common command in Unix "pagers" (programs that show documents a page at a +time). + +------------------------------------------------------------------------ + +<a name="q500"></a> +### Are there any helpful VS Code extensions that are recommend for using with Python? + +* [Official VS Code Python Extension](https://code.visualstudio.com/docs/languages/python) + +------------------------------------------------------------------------ + +<a name="q600"></a> +### I'm on Windows; what command do I use to run Python? + +If you're running in PowerShell or cmd, use: + +``` +py +``` + +If in bash, use `python` or `python3`. + +------------------------------------------------------------------------ + +<a name="q700"></a> +### What version of Python do I need? + +You should have version 3.7 or higher. Test with: + +```shell +python --version +``` + +------------------------------------------------------------------------ + +<a name="q800"></a> +### Do I need to use pipenv? + +You should. Good Python devs know how. + +------------------------------------------------------------------------ + +<a name="q900"></a> +### How do I get out of the Python REPL? + +Hit `CTRL-D`. This is the way End-Of-File is signified in Unix-likes. + +------------------------------------------------------------------------ + +<a name="q1000"></a> +### What does "REPL" mean? + +_Read, Evaluate, Print Loop_. + +It reads your input, evaluates it, and prints the result. And loops. + +------------------------------------------------------------------------ + +<a name="q1100"></a> +### I'm on a Mac and when I run Python it says I'm on version 2.7. Why? + +Macs come with version 2.7 by default. You'll need to install version 3. + +And preferable use `pipenv` after that. + +------------------------------------------------------------------------ + +<a name="q1200"></a> +### Does Python use tabs or spaces? + +[PEP 8](https://www.python.org/dev/peps/pep-0008/) says four spaces. + +------------------------------------------------------------------------ + +<a name="q1300"></a> +### How do I convert an iterator into a list? + +Cast it: + +```python +list(range(5)) +``` + +produces: + +```python +[0, 1, 2, 3, 4] +``` + +------------------------------------------------------------------------ + +<a name="q1400"></a> +### Does Python have hoisting? + +No. + +* [What is hoisting?](https://developer.mozilla.org/en-US/docs/Glossary/Hoisting) + +------------------------------------------------------------------------ + +<a name="q1500"></a> +### Does scoping work similar to other languages? + +Generally, and also not really. Variables are either global or function-local. + +Since there are no declarations, there's no block-level scope. + +It is similar to `var` in JavaScript. + +------------------------------------------------------------------------ + +<a name="q1600"></a> +### Can you return a reference to a function from another function? Or store it in a variable? + +Yes. Functions are [first-class citizens](https://en.wikipedia.org/wiki/First-class_citizen). + +------------------------------------------------------------------------ + +<a name="q1700"></a> +### Can you use boolean shortcut assignments? + +Yes, you can. This is common in Perl and JavaScript, but it's not particularly [idiomatic](https://en.wikipedia.org/wiki/Programming_idiom) in Python. + +```python +x = SomethingFalsey or 5 +``` + +------------------------------------------------------------------------ + +<a name="q1800"></a> +### Can you do anonymous functions? + +You can use `lambda` for simple functions: + +```python +adder = lambda x, y: x + y + +adder(4, 5) # 9 + +do_some_math(4, 5, lambda x, y: y - x) +``` + +------------------------------------------------------------------------ + +<a name="q1900"></a> +### Is a dict like a JavaScript object? + +Sort of. + +The syntax is different, though. In Python you must use `[]` notation to access elements. And you must use `"` around the key names. + +------------------------------------------------------------------------ + +<a name="q2000"></a> +### What are all those method names with double underscores around them? + +Those are function you typically don't need to use, but can override or call if you wish. + +Most commonly used are: + +* `__init__()` is the constructor for objects +* `__str__()` returns a string representation of the object +* `__repr__()` returns a string representation of the object, for debugging + +------------------------------------------------------------------------ + +<a name="q2100"></a> +### How do I get a value from a dict? + +```python +d = { + "a": 2, + "b": 3 +} + +print(d["a"]) +``` + +You don't use dot notation. + +------------------------------------------------------------------------ + +<a name="q2200"></a> +### When do we run pipenv shell? + +`pipenv shell` puts you into your work environment. When you're ready to work, or run the code, or install new dependencies, you should be in your pipenv shell. + +------------------------------------------------------------------------ + +<a name="q2300"></a> +### How do I get out of the pipenv shell? + +Type `exit`. + +------------------------------------------------------------------------ + +<a name="q2400"></a> +### How do I install additional packages from pipenv? + +```shell +pipenv install packagename +``` + +------------------------------------------------------------------------ + +<a name="q2500"></a> +### Is it possible to use system-wide packages from inside the virtual environment? + +This is [not recommended](https://pipenv.readthedocs.io/en/latest/diagnose/#no-module-named-module-name). + +------------------------------------------------------------------------ + +<a name="q2600"></a> +### Where are good Python docs? + +* [Official documentation](https://docs.python.org/3/) tutorial and library reference. + +The official docs might be hard to read at first, but you'll get used to them +quickly + +------------------------------------------------------------------------ + +<a name="q2700"></a> +### Which linter? + +Pylint or Flake8. The latter seems to be a bit more popular. + +------------------------------------------------------------------------ + +<a name="q2800"></a> +### Can you dynamically add new methods/properties to class through other functions? Or must all properties/methods be declared at once? + +You can add them dynamically at runtime, but you have to add them to the class itself: + +```python +class Foo(): + pass + +f = Foo() + +Foo.x = 12 # Dynamically add property to class + +f.x == 12 # True! + +def a_method(self): + print("Hi") + +Foo.hi = a_method # Dynamically add method to class + +f.hi() # Prints "Hi" +``` + +This is not a common thing to see in Python, however. + +------------------------------------------------------------------------ + +<a name="q2900"></a> +### Following this flow: 1) class Dog is created with attributes size and weight. 2) New instance called Snoopy of class Dog is created. 3) Class Dog gets the method bark() dynamically added to it. Question: will Snoopy now have access to bark() method? + +Yes. + +------------------------------------------------------------------------ + +<a name="q3000"></a> +### If a subclass inherits from two superclasses with a method of the same name, which method will the subclass use? + +The answer to this is twofold: + +1. Lots of devs and shops frown on multiple inheritance, so maybe just don't do + it. + ([Discussion](https://softwareengineering.stackexchange.com/questions/218458/is-there-any-real-reason-multiple-inheritance-is-hated)) + +2. As for the order in which methods of the same name are resolved, check out + the [MRO Algorithm](https://en.wikipedia.org/wiki/C3_linearization) which is + what Python uses. + + +------------------------------------------------------------------------ + +<a name="q3100"></a> +### How to handle multiple inheritance and why/when to do it in the first place? + +```python +class Base1: + pass + +class Base2: + pass + +class Derived(Base1, Base2): # Multiple inheritance + pass +``` + +Sometimes multiple inheritance can lead to elegant solutions when a subclass +needs attributes from multiple, otherwise-unrelated parent classes. + +However, [a lot of people find it's not worth the +trouble](https://softwareengineering.stackexchange.com/questions/218458/is-there-any-real-reason-multiple-inheritance-is-hated)) +and opt for other solutions, like composition. + +------------------------------------------------------------------------ + +<a name="q3200"></a> +### Why use tuples instead of lists? + +* Tuples are immutable. There's a school of thought that says bugs can be reduced if you make as many things immutable as you can. +* Tuples are faster than lists to access. +* Some tuples (containing primitive types), can be used as `dict` keys. + +------------------------------------------------------------------------ + +<a name="q3300"></a> +### What's the difference between __repr__ and __str__? + +Generally speaking, `__repr__` is the string a dev would want to see if they +dumped an object to the screen. `__str__` is the string a user would want to see +if the object were `print()`ed. + +The output of `__repr__` should be _valid Python code that can reproduce the +object_. + +```python +class Goat: + def __init__(self, leg_count): + self.leg_count = leg_count + + def __repr__(self): + return f'Goat(leg_count={self.leg_count})' + + def __str__(self): + return f'a goat with {self.leg_count} legs' +``` + +In action: + +```python +>>> g = Goat(4) +>>> str(g) +'a goat with 4 legs' +>>> g +Goat(leg_count=4) +>>> Goat(leg_count=4) # output of __repr__ makes a clone of that object! +Goat(leg_count=4) +``` + +------------------------------------------------------------------------ + +<a name="q3400"></a> +### How does `sys.argv` work? + +It's a list that holds _command line arguments_. This is a way for a user to run +your program and specify different behavior from the command line. + +Here's a small program that prints the command line arguments: + +```python +import sys + +for i in range(len(sys.argv)): + print(f'Argument #{i} is: {sys.argv[i]}') +``` + +and here's some output, assuming you named the script `foo.py`: + +```screen +$ python foo.py +Argument #0 is: foo.py +``` + +```screen +$ python foo.py antelope buffalo +Argument #0 is: foo.py +Argument #1 is: antelope +Argument #2 is: buffalo +``` + +Note that the 0th element in the list is the name of the program. + +Here's another program that prints up to whatever number the user specifies: + +```python +import sys + +for i in range(int(sys.argv[1])): + print(i+1) +``` + +Example runs: + +```screen +$ python foo.py 2 +1 +2 +``` + +```screen +$ python foo.py 4 +1 +2 +3 +4 +``` + +------------------------------------------------------------------------ + +<a name="q3500"></a> +### How do I concatenate two arrays into a single array? + +Use `extend()`. + +```python +a = [1, 2, 3] +b = [4, 5, 6] + +a.extend(b) + +print(a) # [ 1, 2, 3, 4, 5, 6 ] +``` + +------------------------------------------------------------------------ + +<a name="q3600"></a> +### What are some ways to learn a new language? + +* Figure out how variables and functions work. +* Build small toy programs to test individual features. +* Build a larger project that exercises many features. +* Don't get frustrated! Treat the problem like a curiosity, a thing to be studied. +* Do small tutorials or code-alongs. +* Find docs you like. +* Learn the differences between this language and one you know. +* Learn this language's way of doing the things you know. + +Things to look for in the new language: + +* Collections (arrays, vectors, dictionaries) +* Data types +* Iterators +* Flow control (if, while, loops, etc) +* Functions +* etc. + +------------------------------------------------------------------------ + +<a name="q3700"></a> +### Why test code frequently? + +It's often better to make progress in small increments than to write a bunch of +stuff and test it in one go. + +Also, it's easier to stay motivated if you spend 10 minutes getting a first +version going, even if it's missing 99% of its features, and then starting to +iterate on that. + +------------------------------------------------------------------------ + +<a name="q3800"></a> +### Why isn't official documentation more helpful than Stack Overflow? + +Often official documentation is more geared toward being a concise reference. +Stack Overflow is more of an example-based learning environment. + +Sometimes you need to know the specific details. In those cases, you can dig +into the spec, with all it's lawyerly language, and try to decipher what it is +you have to do. + +Other times, you just need a getting-started example, and Stack Overflow is +great for that. + +Both types of documentation have their purpose. + +------------------------------------------------------------------------ + +<a name="q3900"></a> +### During an interview, what do I do if I can't remember the exact syntax? + +Just say so. + +"I can't remember how to add an element to the end of the list in Python... is +it `push()`? In any case, we'll call the function here that does that." + +(Turns out it's `append()` in Python, but being honest and describing what it is +your're trying to do will get you 99% of the way there in an interview.) + + + + + +### [1-projects/Intro-Python-I-master/README.md](1-projects/Intro-Python-I-master/README.md) + +<!-- START doctoc generated TOC please keep comment here to allow auto update --> +<!-- DON'T EDIT THIS SECTION, INSTEAD RE-RUN doctoc TO UPDATE --> +**Table of Contents** *generated with [DocToc](https://github.com/thlorenz/doctoc)* + +- [Intro to Python I](#intro-to-python-i) + - [Techniques for learning new languages](#techniques-for-learning-new-languages) + - [Resources](#resources) + - [Getting started](#getting-started) + - [Goals](#goals) + - [Summary](#summary) + - [Instructions](#instructions) + - [Stretch Goals](#stretch-goals) + +<!-- END doctoc generated TOC please keep comment here to allow auto update --> + +# Intro to Python I + +_Note: This project spans two modules (modules 1 and 2). You should roughly try to finish the first half of the problems during module 1 and the second half of the problems during module 2._ + +It's time to learn a new language! Python! + +Python is a popular, easy-to-use programming language that has significant +traction in the field. + +Remember the goal is _learning to learn_, so keep track of what works for you +and what doesn't as you go through the process of exploring Python. + +## Techniques for learning new languages + +* Try to relate things you already know in another language (e.g. what an + _array_ is) to the corresponding things in Python (e.g. a _list_) and how to + use them. + +* Write a bunch of "toy programs" that demonstrate different key features of the + language + +* Explore the standard library that's available for the language. Skim it + briefly for now--the idea isn't to memorize everything but to file away + generally what functionality is available. + +* Write a more substantial toy program that uses a variety of the features. + +Again, keep track of what works for you. Try different things to see what works +best for learning new languages. + +## Resources + +* [Installing Python 3](https://github.com/LambdaSchool/CS-Wiki/wiki/Installing-Python-3) +* [JavaScript<->Python cheatsheet](https://github.com/LambdaSchool/CS-Wiki/wiki/Javascript-Python-cheatsheet) +* [How to read Specs and Code](https://github.com/LambdaSchool/CS-Wiki/wiki/How-to-Read-Specifications-and-Code) +* [Python 3 standard library](https://docs.python.org/3.6/library/) + +## Getting started + +Make sure you have Python 3 installed. You can check this by running `python3 --version` in your terminal and ensuring that it returns a version string that is at least 3.6.5. + +## Goals + +* Learn the basic syntax and structure of Python + +## Summary + +* Implement a number of tiny Python programs that demonstrate Python syntax and + language concepts. + +## Instructions + +_Note: This project spans two modules (modules 1 and 2). You should roughly try to finish the first half of the problems during module 1 and the second half of the problems during module 2._ + +Each directory inside the `src/` directory presents exercises revolving around a +particular concept in Python. Not all of these concepts are unique to Python (in +fact, most probably aren't). This means that you can leverage knowledge you've +obtained via exposure to other programming languages towards learning Python. + +The suggested order for going through each of the directories is: + +* `hello` -- Hello world +* `bignum` -- Print some big numbers +* `datatypes` -- Experiment with type conversion +* `modules` -- Learn to import from modules +* `printing` -- Formatted print output +* `lists` -- Python's version of arrays +* `tuples` -- Immutable lists typically for heterogenous data +* `slices` -- Accessing parts of lists +* `comprehensions` -- List comprehensions +* `dictionaries` -- Dictionaries +* `functions` -- Functions +* `args` -- Arguments and Keyword Arguments +* `scopes` -- Global, Local, and Non-Local scope +* `file_io` -- Read and write from files +* `cal` -- Experiment with module imports and implement a text-based calendar +* `classes` -- Classes and objects + +## Stretch Goals + +1. One of Python's main philosophical tenets is its emphasis on readability. To + that end, the Python community has standardized around a style guide called + [PEP 8](https://www.python.org/dev/peps/pep-0008/). Take a look at it and + then go over the code you've written and make sure it adheres to what PEP 8 + recommends. Alternatively, PEP 8 linters exist for most code editors (you can + find instructions on installing a Python linter for VSCode + [here](https://code.visualstudio.com/docs/python/linting)). Try installing + one for your editor! + +2. Rewrite code challenges you've solved before or projects you've implemented + before in a different language in Python. Start getting in as much practice + with the language as possible! + +3. Write a program to determine if a number, given on the command line, is prime. + + 1. How can you optimize this program? + 2. Implement [The Sieve of + Eratosthenes](https://en.wikipedia.org/wiki/Sieve_of_Eratosthenes), one + of the oldest algorithms known (ca. 200 BC). + + +</details><details> <summary>1-projects/Intro-Python-II-master/</summary> + +### [1-projects/Intro-Python-II-master/FAQ.md](1-projects/Intro-Python-II-master/FAQ.md) +<!-- START doctoc generated TOC please keep comment here to allow auto update --> +<!-- DON'T EDIT THIS SECTION, INSTEAD RE-RUN doctoc TO UPDATE --> +**Table of Contents** *generated with [DocToc](https://github.com/thlorenz/doctoc)* + +- [FAQ](#faq) + +<!-- END doctoc generated TOC please keep comment here to allow auto update --> + +# FAQ + +[Refer to the FAQ in Intro-Python-I](https://github.com/LambdaSchool/Intro-Python-I/blob/master/FAQ.md). + + + + +### [1-projects/Intro-Python-II-master/object_reference_hints.md](1-projects/Intro-Python-II-master/object_reference_hints.md) + +Remember that multiple variables can refer to the same object. + +In the diagram below, there are only 2 `Room` objects, total. (There are more in the game, obviously, but in this diagram, there are 2.) + +There are 5 variables. 3 of them point to the one Room object that is the foyer: + +* `room['foyer']` +* `room['outside'].n_to` +* `player.location` + +The remaining 2 point to the one Room object that is the outside: + +* `room['outside']` +* `room['foyer'].s_to` + +``` +room['outside'] -> Room("Outside Cave Entrance") + ^ + | + room['foyer'].s_to + + +room['foyer'] -> Room("Foyer") <- player.location + ^ + | + room['outside'].n_to +``` + +If you want to move the player (who is in the foyer in the diagram) to another room, you just need to reassign that to any variable that points to that other room. + +So if the player is in the foyer and types `s` to go south, we could set: + +``` +player.location = room['foyer'].s_to # we were in the foyer, then went south +``` + +and after that, the variable references would look like this, with player location pointing to the outside object: + +``` + player.location + | + v +room['outside'] -> Room("Outside Cave Entrance") + ^ + | + room['foyer'].s_to + + +room['foyer'] -> Room("Foyer") + ^ + | + room['outside'].n_to +``` + +_Assigning doesn't copy the object. It just makes another reference to the same object._ + + +### [1-projects/Intro-Python-II-master/README.md](1-projects/Intro-Python-II-master/README.md) + +<!-- START doctoc generated TOC please keep comment here to allow auto update --> +<!-- DON'T EDIT THIS SECTION, INSTEAD RE-RUN doctoc TO UPDATE --> +**Table of Contents** *generated with [DocToc](https://github.com/thlorenz/doctoc)* + +- [Intro to Python II](#intro-to-python-ii) + - [What We're Building](#what-were-building) + - [Goals](#goals) + - [MVP](#mvp) + - [Day 1 MVP](#day-1-mvp) + - [Day 2 MVP](#day-2-mvp) + - [Specification](#specification) + - [Stretch Goals](#stretch-goals) + +<!-- END doctoc generated TOC please keep comment here to allow auto update --> + +# Intro to Python II + +Up to this point, you've gotten your feet wet by working on a bunch of small Python programs. In this module, we're going to continue to solidify your Python chops by implementing a full-featured project according to a provided specification. + + +## What We're Building +[What's an Adventure Game? ![vid](https://tk-assets.lambdaschool.com/7928cdb4-b8a3-45a6-b231-5b9d1fc1e002_ScreenShot2019-03-22at5.47.28PM.png)](https://youtu.be/WaZccFqJUT8) + + +## Goals + +* Put your Python basics into practice by implementing a text adventure game + +* Practice writing code that conforms to a specification + + +## MVP + +### Day 1 MVP + +* Create the input command parser in `adv.py` which allows the program to receive player input and commands to move to rooms + in the four cardinal directions. +* Fill out Player and Room classes in `player.py` and `room.py` + +### Day 2 MVP + +* Make rooms able to hold multiple items +* Make the player able to carry multiple items +* Add items to the game that the user can carry around +* Add `get [ITEM_NAME]` and `drop [ITEM_NAME]` commands to the parser + +## Specification + +The `/src` directory contains the files `adv.py`, which is where the main logic for the game should live, `room.py`, which will contain the definition of the Room class, and `player.py`, which will contain the definition of the Player class. + + +* Add a REPL parser to `adv.py` that accepts directional commands to move the player + * After each move, the REPL should print the name and description of the player's current room + * Valid commands are `n`, `s`, `e` and `w` which move the player North, South, East or West + * The parser should print an error if the player tries to move where there is no room. + +* Put the Room class in `room.py` based on what you see in `adv.py`. + + * The room should have `name` and `description` attributes. + + * The room should also have `n_to`, `s_to`, `e_to`, and `w_to` attributes + which point to the room in that respective direction. + +* Put the Player class in `player.py`. + * Players should have a `name` and `current_room` attributes + + +* Create a file called `item.py` and add an `Item` class in there. + + * The item should have `name` and `description` attributes. + + * Hint: the name should be one word for ease in parsing later. + + * This will be the _base class_ for specialized item types to be declared + later. + +* Add the ability to add items to rooms. + + * The `Room` class should be extended with a `list` that holds the `Item`s + that are currently in that room. + + * Add functionality to the main loop that prints out all the items that are + visible to the player when they are in that room. + +* Add capability to add `Item`s to the player's inventory. The inventory can + also be a `list` of items "in" the player, similar to how `Item`s can be in a + `Room`. + +* Add a new type of sentence the parser can understand: two words. + + * Until now, the parser could just understand one sentence form: + + `verb` + + such as "n" or "q". + + * But now we want to add the form: + + `verb` `object` + + such as "take coins" or "drop sword". + + * Split the entered command and see if it has 1 or 2 words in it to determine + if it's the first or second form. + +* Implement support for the verb `get` followed by an `Item` name. This will be + used to pick up `Item`s. + + * If the user enters `get` or `take` followed by an `Item` name, look at the + contents of the current `Room` to see if the item is there. + + * If it is there, remove it from the `Room` contents, and add it to the + `Player` contents. + + * If it's not there, print an error message telling the user so. + + * Add an `on_take` method to `Item`. + + * Call this method when the `Item` is picked up by the player. + + * `on_take` should print out "You have picked up [NAME]" when you pick up an item. + + * The `Item` can use this to run additional code when it is picked up. + + * Add an `on_drop` method to `Item`. Implement it similar to `on_take`. + +* Implement support for the verb `drop` followed by an `Item` name. This is the + opposite of `get`/`take`. + +* Add the `i` and `inventory` commands that both show a list of items currently + carried by the player. + + +## Stretch Goals + +In arbitrary order: + +* Add more rooms + +* Add scoring + +* Subclass items into treasures + +* Add a subclass to `Item` called `LightSource`. + + * During world creation, add a `lamp` `LightSource` to a convenient `Room`. + + * Override `on_drop` in `LightSource` that tells the player "It's not wise to + drop your source of light!" if the player drops it. (But still lets them drop + it.) + + * Add an attribute to `Room` called `is_light` that is `True` if the `Room` is + naturally illuminated, or `False` if a `LightSource` is required to see what + is in the room. + + * Modify the main loop to test if there is light in the `Room` (i.e. if + `is_light` is `True` **or** there is a `LightSource` item in the `Room`'s + contents **or** if there is a `LightSource` item in the `Player`'s contents). + + * If there is light in the room, display name, description, and contents as + normal. + + * If there isn't, print out "It's pitch black!" instead. + + * Hint: `isinstance` might help you figure out if there's a `LightSource` + among all the nearby `Item`s. + + * Modify the `get`/`take` code to print "Good luck finding that in the dark!" if + the user tries to pick up an `Item` in the dark. + +* Add methods to notify items when they are picked up or dropped + +* Add light and darkness to the game + +* Add more items to the game. + +* Add a way to win. + +* Add more to the parser. + + * Remember the last `Item` mentioned and substitute that if the user types + "it" later, e.g. + + ``` + take sword + drop it + ``` + + * Add `Item`s with adjectives, like "rusty sword" and "silver sword". + + * Modify the parser to handle commands like "take rusty sword" as well as + "take sword". + + * If the user is in a room that contains both the rusty sword _and_ silver + sword, and they type "take sword", the parser should say, "I don't know + which you mean: rusty sword or silver sword." + +* Modify the code that calls `on_take` to check the return value. If `on_take` + returns `False`, then don't continue picking up the object. (I.e. prevent the + user from picking it up.) + + * This enables you to add logic to `on_take` to code things like "don't allow + the user to pick up the dirt unless they're holding the shovel. + +* Add monsters. + +* Add the `attack` verb that allows you to specify a monster to attack. + +* Add an `on_attack` method to the monster class. + +* Similar to the `on_take` return value modification, above, have `on_attack` + prevent the attack from succeeding unless the user possesses a `sword` item. + +* Come up with more stretch goals! The sky's the limit! + + +</details><details> <summary>1-projects/Intro-to-C-master/</summary> + +### [1-projects/Intro-to-C-master/FAQ.md](1-projects/Intro-to-C-master/FAQ.md) +<!-- START doctoc generated TOC please keep comment here to allow auto update --> +<!-- DON'T EDIT THIS SECTION, INSTEAD RE-RUN doctoc TO UPDATE --> +**Table of Contents** *generated with [DocToc](https://github.com/thlorenz/doctoc)* + +- [Intro to C FAQ](#intro-to-c-faq) + - [Contents](#contents) + - [Common Errors](#common-errors) + - [General C](#general-c) + - [Strings](#strings) + - [Structs](#structs) + - [Types](#types) + - [Arrays](#arrays) + - [Pointers](#pointers) + - [Heap, Stack, Dynamic Memory](#heap-stack-dynamic-memory) + - [Questions](#questions) + - [`runtests.sh: $'\r': command not found` or `Syntax error: word unexpected (expecting "do")`](#runtestssh-%5Cr-command-not-found-or-syntax-error-word-unexpected-expecting-do) + - [`runtests.sh: 3: 56059 Segmentation fault: 11 $VALGRIND`](#runtestssh-3-56059-segmentation-fault-11--valgrind) + - [Mac: `malformed object` error when running `make tests`](#mac-malformed-object-error-when-running-make-tests) + - [Should I bother fixing compiler warnings?](#should-i-bother-fixing-compiler-warnings) + - [Can I accidentally destroy my computer running C code?](#can-i-accidentally-destroy-my-computer-running-c-code) + - [Is a `struct` comparable to something in Python or JS? Is it like a class?](#is-a-struct-comparable-to-something-in-python-or-js-is-it-like-a-class) + - [Can you have default parameters in the structs?](#can-you-have-default-parameters-in-the-structs) + - [Why does unsigned char type accept a number when it's clearly referring to a character?](#why-does-unsigned-char-type-accept-a-number-when-its-clearly-referring-to-a-character) + - [When I pass an array as an argument to a function, when do I use pointer notation and when do I use array notation ?](#when-i-pass-an-array-as-an-argument-to-a-function-when-do-i-use-pointer-notation-and-when-do-i-use-array-notation-) + - [Why do functions tend to return pointers to structs, and not just copies of the struct?](#why-do-functions-tend-to-return-pointers-to-structs-and-not-just-copies-of-the-struct) + - [Why do we subtract '0' from a char to convert it from ASCII to a numeric value?](#why-do-we-subtract-0-from-a-char-to-convert-it-from-ascii-to-a-numeric-value) + - [When do I need a pointer to a pointer?](#when-do-i-need-a-pointer-to-a-pointer) + - [Do other languages use pointers?](#do-other-languages-use-pointers) + - [What's the difference between "`int *x`" and "`int* x`"?](#whats-the-difference-between-int-x-and-int-x) + - [What does the "implicit declaration of function" warning mean?](#what-does-the-implicit-declaration-of-function-warning-mean) + - [What's the difference between `puts()`, `fprintf()`, and `printf()`?](#whats-the-difference-between-puts-fprintf-and-printf) + - [Why does `025 == 21`?](#why-does-025--21) + - [What is the "true dev workflow" in C?](#what-is-the-true-dev-workflow-in-c) + - [Does C have garbage collection?](#does-c-have-garbage-collection) + - [Why is C code faster than other languages?](#why-is-c-code-faster-than-other-languages) + - [What is a segmentation fault and how do I stop it?](#what-is-a-segmentation-fault-and-how-do-i-stop-it) + - [What happens if my program exits but I forgot to `free()` some memory I allocated?](#what-happens-if-my-program-exits-but-i-forgot-to-free-some-memory-i-allocated) + - [What's the difference between a `float` and a `double`, or between an `int` and a `long`?](#whats-the-difference-between-a-float-and-a-double-or-between-an-int-and-a-long) + - [Can you use `+` to concatenate two strings?](#can-you-use--to-concatenate-two-strings) + - [Are variables automatically initialized to zero when I declare them?](#are-variables-automatically-initialized-to-zero-when-i-declare-them) + - [What type should I use to hold numbers bigger than an `int` can hold?](#what-type-should-i-use-to-hold-numbers-bigger-than-an-int-can-hold) + - [What VS Code plugins are good for C development?](#what-vs-code-plugins-are-good-for-c-development) + - [What are some additional C resources?](#what-are-some-additional-c-resources) + - [How do I get the debugger working?](#how-do-i-get-the-debugger-working) + - [How do I print a pointer with `printf`?](#how-do-i-print-a-pointer-with-printf) + - [Does C have closures?](#does-c-have-closures) + - [If I look at an uninitialized variable, will the garbage in it ever be leftover data from another process?](#if-i-look-at-an-uninitialized-variable-will-the-garbage-in-it-ever-be-leftover-data-from-another-process) + - [How many levels of indirection can you have with pointers? `int******`?](#how-many-levels-of-indirection-can-you-have-with-pointers-int) + - [What's the `incompatible integer to pointer conversion` error?](#whats-the-incompatible-integer-to-pointer-conversion-error) + - [Are there any other ways besides `malloc()` to store things on the heap?](#are-there-any-other-ways-besides-malloc-to-store-things-on-the-heap) + - [For string literals like `"Hello"`, are those stored on the stack or heap?](#for-string-literals-like-hello-are-those-stored-on-the-stack-or-heap) + - [Is the C stack like the stack data structure?](#is-the-c-stack-like-the-stack-data-structure) + - [Is the C heap like a binary heap data structure?](#is-the-c-heap-like-a-binary-heap-data-structure) + - [What are `stdin`, `stdout`, and `stderr`?](#what-are-stdin-stdout-and-stderr) + - [How do I know which header files to `#include` for any particular function?](#how-do-i-know-which-header-files-to-include-for-any-particular-function) + - [When do I have to explicitly cast a type to another type?](#when-do-i-have-to-explicitly-cast-a-type-to-another-type) + - [Is `realloc()` the same as calling `malloc()`, copying the data over, then calling `free()` on the original pointer?](#is-realloc-the-same-as-calling-malloc-copying-the-data-over-then-calling-free-on-the-original-pointer) + - [What happens if I `free()` a `NULL` pointer?](#what-happens-if-i-free-a-null-pointer) + - [What are bits, bytes, kilobytes, megabytes, and all that?](#what-are-bits-bytes-kilobytes-megabytes-and-all-that) + - [In C, can we assume an `int` is 32 bits?](#in-c-can-we-assume-an-int-is-32-bits) + - [What's the difference between `#include` with double quotes and `#include` with angle brackets?](#whats-the-difference-between-include-with-double-quotes-and-include-with-angle-brackets) + - [Should I declare a pointer to a thing, or just declare the thing?](#should-i-declare-a-pointer-to-a-thing-or-just-declare-the-thing) + - [Is there a difference between `exit()` and `return`?](#is-there-a-difference-between-exit-and-return) + - [Why does `strcmp()` return `0` when strings match? Since `0` means "false" in C, that seems backwards.](#why-does-strcmp-return-0-when-strings-match-since-0-means-false-in-c-that-seems-backwards) + - [What is "undefined behavior" in C?](#what-is-undefined-behavior-in-c) + - [When you free a pointer, does it get set to `NULL` automatically?](#when-you-free-a-pointer-does-it-get-set-to-null-automatically) + - [How do I write preprocessor macros with `#define`?](#how-do-i-write-preprocessor-macros-with-define) + - [What is an `undefined symbol` linker error?](#what-is-an-undefined-symbol-linker-error) + - [How do I make my own header files and what do I put in them?](#how-do-i-make-my-own-header-files-and-what-do-i-put-in-them) + - [How do I make my own Makefile?](#how-do-i-make-my-own-makefile) + - [Why are there so many `printf()` variants? How do I know which one to use?](#why-are-there-so-many-printf-variants-how-do-i-know-which-one-to-use) + - [Why is `main()` always at the bottom of the file?](#why-is-main-always-at-the-bottom-of-the-file) + - [Why does `main()` return `0`? What does the return value mean?](#why-does-main-return-0-what-does-the-return-value-mean) + - [Do we have to have a `main()`? Can there be more than one?](#do-we-have-to-have-a-main-can-there-be-more-than-one) + - [Can `main()` return `void`? What about `main()` with no parameters?](#can-main-return-void-what-about-main-with-no-parameters) + - [Do we need a semicolon at the end of every line?](#do-we-need-a-semicolon-at-the-end-of-every-line) + - [Can a pointer point to more than one thing? What about to arrays and `struct`s?](#can-a-pointer-point-to-more-than-one-thing-what-about-to-arrays-and-structs) + - [If variables are stored in memory, where are pointers stored?](#if-variables-are-stored-in-memory-where-are-pointers-stored) + +<!-- END doctoc generated TOC please keep comment here to allow auto update --> + +# Intro to C FAQ + +## Contents + +### Common Errors + +* [`runtests.sh: $'\r': command not found` or `Syntax error: word unexpected (expecting "do")`](#q100) +* [`runtests.sh: 56059 Segmentation fault: 11 $VALGRIND`](#q200) +* [Mac: `malformed object` error when running `make tests`](#q300) +* [What does the "implicit declaration of function" warning mean?](#q1500) +* [What is a segmentation fault and how do I stop it?](#q2100) +* [What's the `incompatible integer to pointer conversion` error?](#q3400) +* [What is an `undefined symbol` linker error?](#q5300) +* [What is "undefined behavior" in C?](#q5000) +* [Should I bother fixing compiler warnings?](#q400) + +### General C + +* [Can I accidentally destroy my computer running C code?](#q500) +* [Why do we subtract '0' from a char to convert it from ASCII to a numeric value?](#q1100) +* [What's the difference between `puts()`, `fprintf()`, and `printf()`?](#q1600) +* [Why does `025 == 21`?](#q1700) +* [What is the "true dev workflow" in C?](#q1800) +* [Does C have garbage collection?](#q1900) +* [Why is C code faster than other languages?](#q2000) +* [Are variables automatically initialized to zero when I declare them?](#q2500) +* [What VS Code plugins are good for C development?](#q2700) +* [What are some additional C resources?](#q2800) +* [How do I get the debugger working?](#q2900) +* [Does C have closures?](#q3100) +* [If I look at an uninitialized variable, will the garbage in it ever be leftover data from another process?](#q3200) +* [What are `stdin`, `stdout`, and `stderr`?](#q3900) +* [How do I know which header files to `#include` for any particular function?](#q4000) +* [What are bits, bytes, kilobytes, megabytes, and all that?](#q4400) +* [What's the difference between `#include` with double quotes and `#include` with angle brackets?](#q4600) +* [Why does `main()` return `0`? What does the return value mean?](#q5800) +* [Is there a difference between `exit()` and `return`?](#q4800) +* [What is "undefined behavior" in C?](#q5000) +* [How do I write preprocessor macros with `#define`?](#q5200) +* [How do I make my own header files and what do I put in them?](#q5400) +* [How do I make my own Makefile?](#q5500) +* [Why are there so many `printf()` variants? How do I know which one to use?](#q5600) +* [Why is `main()` always at the bottom of the file?](#q5700) +* [Do we have to have a `main()`? Can there be more than one?](#q5900) +* [Can `main()` return `void`? What about `main()` with no parameters?](#q6000) +* [Do we need a semicolon at the end of every line?](#q6100) + +### Strings + +* [Can you use `+` to concatenate two strings?](#q2400) +* [For string literals like `"Hello"`, are those stored on the stack or heap?](#q3600) +* [Why does `strcmp()` return `0` when strings match? Since `0` means "false" in C, that seems backwards.](#q4900) + +### Structs + +* [Is a `struct` comparable to something in Python or JS? Is it like a class?](#q600) +* [Can you have default parameters in the structs?](#q700) +* [Why do functions tend to return pointers to structs, and not just copies of the struct?](#q1000) + +### Types + +* [Why does unsigned char type accept a number when it's clearly referring to a character?](#q800) +* [What's the difference between a `float` and a `double`, or between an `int` and a `long`?](#q2300) +* [What type should I use to hold numbers bigger than an `int` can hold?](#q2600) +* [When do I have to explicitly cast a type to another type?](#q4100) +* [In C, can we assume an `int` is 32 bits?](#q4500) + +### Arrays + +* [When I pass an array as an argument to a function, when do I use pointer notation and when do I use array notation ?](#q900) + +### Pointers + +* [When I pass an array as an argument to a function, when do I use pointer notation and when do I use array notation ?](#q900) +* [Why do functions tend to return pointers to structs, and not just copies of the struct?](#q1000) +* [When do I need a pointer to a pointer?](#q1200) +* [Do other languages use pointers?](#q1300) +* [What's the difference between "`int *x`" and "`int* x`"?](#q1400) +* [How do I print a pointer with `printf`?](#q3000) +* [How many levels of indirection can you have with pointers? `int******`?](#q3300) +* [What's the `incompatible integer to pointer conversion` error?](#q3400) +* [Should I declare a pointer to a thing, or just declare the thing?](#q4700) +* [When you free a pointer, does it get set to `NULL` automatically?](#q5100) +* [Can a pointer pointer to more than one thing? What about to arrays and `struct`s?](#q6200) +* [If variables are stored in memory, where are pointers stored?](#q6300) + +### Heap, Stack, Dynamic Memory + +* [What happens if my program exits but I forgot to `free()` some memory I allocated?](#q2200) +* [Are there any other ways besides `malloc()` to store things on the heap?](#q3500) +* [Is the C stack like the stack data structure?](#q3700) +* [Is the C heap like a binary heap data structure?](#q3800) +* [Is `realloc()` the same as calling `malloc()`, copying the data over, then calling `free()` on the original pointer?](#q4200) +* [What happens if I `free()` a `NULL` pointer?](#q4300) +* [When you free a pointer, does it get set to `NULL` automatically?](#q5100) + +## Questions + +<a name="q100"></a> +### `runtests.sh: $'\r': command not found` or `Syntax error: word unexpected (expecting "do")` + +If you see this error: + +```shell +Running unit tests: +: not foundtests.sh: 2: ./tests/runtests.sh: +./tests/runtests.sh: 4: ./tests/runtests.sh: Syntax error: word unexpected (expecting "do") +``` + +You have two options: + +1. Open the file `tests/runtests.sh` in VS Code in whatever subproject folder + you're working in, e.g. `fizzbuzz`. Click on the lower right of the screen + where it says `CRLF`. Choose `LF`. Save the file. Then the error should go + away. + +2. You can do this from the command line with the `tr` command: + +```shell +cd tests +cat runtests.sh | tr -d '\r' > runtests.tmp +mv runtests.tmp runtests.sh +``` + +The root of the problem is a setting in git that causes all newlines (LF) to +be converted to carriage-return/newline (CRLF). The script `runtests.sh` is a +_bash script_ that bash runs, and bash *hates* `\r` and pukes everywhere. + +To cause git to _not_ do newline conversion for future clones, run the +following: + +``` +git config --global core.autocrlf false +``` + +------------------------------------------------------------------------ + +<a name="q200"></a> +### `runtests.sh: 3: 56059 Segmentation fault: 11 $VALGRIND` + +This means you got a segfault in your program. See [What is a segmentation fault +and how do I stop it?](#what-is-segfault) + +------------------------------------------------------------------------ + +<a name="q300"></a> +### Mac: `malformed object` error when running `make tests` + +This is caused by an older version of the `ar` and `ranlib` packages being installed. +Sometimes these conflict with the versions installed with xcode. + +If running MacPorts: + +``` +sudo port selfupdate +sudo port upgrade cctools +``` + +If running Brew: + +``` +sudo brew update +sudo brew upgrade gcc +``` + +------------------------------------------------------------------------ + +<a name="q400"></a> +### Should I bother fixing compiler warnings? + +YES! + +In C, a warning is the compiler saying, "I can build that, and I will, but it's +probably going to do something really messed up that you don't want." + +There are only a few warnings you can safely ignore. + +If you're _absolutely sure_ the "unused variable" warning is OK, then you could ignore it. Or, better, add a line of code that silences the warning: + +```c +void foo(int a) +{ + (void)a; // Do nothing, but at least the compiler will be quiet +``` + +------------------------------------------------------------------------ + +<a name="q500"></a> +### Can I accidentally destroy my computer running C code? + +Nope! Not with a modern OS. + +If you're running MS-DOS, then sure, you can do all kinds of things. +I once accidentally blew away all my BIOS settings with a program I +wrote and my computer wouldn't boot. + +But Windows, Linux, macOS, BSD, or any other mainstream OS from this century all +offer memory and resource protection that prevents you from changing memory +you're not supposed to, or wiping out a disk you're not supposed to, etc. + +The worst you'll see is a `Segmentation fault` message which means your program +tried to do something bad and the OS killed it. + +------------------------------------------------------------------------ + +<a name="q600"></a> +### Is a `struct` comparable to something in Python or JS? Is it like a class? + +It's like a class, except with only data (fields, properties) attached to it. +There are no methods (functions) associated with it. + +If you _really_ want to pretend that you have methods on a `struct`, you can add +them as fields that are _pointers to functions_. The syntax is pretty obtuse, +and it's not a natural or idiomatic thing to do in C. + +Example: + +```c +struct animal { + char *name; + + // make_sound is a pointer to a function with no parameters that returns void + void (*make_sound)(void); +} + +// Note how bleat() matches the signature for make_sound(), above +void bleat(void) +{ + printf("Baaaahhhh!\n"); +} + +int main(void) +{ + struct animal goat; + + // C doesn't have the concept of a constructor, so we have to do it by hand: + + goat.name = "goat"; + goat.make_sound = bleat; + + // Call the "method": + + goat.make_sound(); // Baaaahhhh! +} +``` + +------------------------------------------------------------------------ + +<a name="q700"></a> +### Can you have default parameters in the structs? + +No. The best you can do is have a helper function set the defaults. + +```c +void foo_default(struct foo *f) +{ + f->a = 10; // Set defaults + f->b = 20; + f->c = 30; +} +``` + +```c +struct foo x; + +foo_default(&x); // Set defaults + +x.a = 99; // Override default +``` + +When you declare a `struct`, you can also use an initializer to set the field +values: + +```c +struct foo x = { .a = 10, .b = 20, .c = 30 }; +``` + +------------------------------------------------------------------------ + +<a name="q800"></a> +### Why does unsigned char type accept a number when it's clearly referring to a character? + +Deep down, computers just deal in numbers (`1`s and `0`s). They don't know what +a character is. We humans have come up with a system wherein a number +_represents_ a certain character. For example, we've agreed that `A` is `65`. + +(For information on what number represents what character, look up more detail +on [ASCII](https://en.wikipedia.org/wiki/ASCII) encoding, or its modern superset +[UTF-8](https://en.wikipedia.org/wiki/UTF-8).) + +With that in mind, C really only deals in numbers. Even when you put a character +in single quotes, it's still just a number. The only difference is in how we +_interpret_ that number. That is, is it a value, like 65, or is it a character, +like `A`? + +```c +unsigned char c = 'A'; + +printf("%c\n", c); // Prints "A" +printf("%d\n", c); // Prints 65 +``` + +```c +unsigned char c = 'A'; +int x = c + 10; + +printf("%d", x); // Prints 75, since 'A' == 65 +``` + +In C, whenever you have a character in single quotes like `'A'`, the compiler +treats it just like you'd put the number `65` there. (Or `66` for `'B'`, and so +on.) + +The only difference between `unsigned char` and `unsigned int` is the number of +bytes that are used to represent the number. A `char` is onGe byte, and an `int` +is typically 4 bytes (but not always). + +You can think of these additional bytes as analogous to adding more digits to +your numbers. The more digits you have, the more range you can store. Two +decimal digits only gets you from 0 to 99, but 8 digits gets you from 0 to +99999999. Similarly, one byte only gets you from 0 to 255, but 4 bytes gets you +from 0 to 4,294,967,295. + +If you never needed numbers larger than 255, you could use `unsigned char` for +all your variables! (But since modern computers are at least as fast with `int`s +as they are with `char`s, people just use `int`s.) + +------------------------------------------------------------------------ + +<a name="q900"></a> +### When I pass an array as an argument to a function, when do I use pointer notation and when do I use array notation ? + +It's a little-known FunFact that C doesn't actually pass entire arrays to +functions. It only passes pointers to the first element in that array. + +```c +int a[2000]; + +// "a" is a pointer to the first element in the array. +// It's the same as &(a[0]). +foo(a); +``` + +So when you declare your function, you can do any of these: + +```c +void foo(int *a) +``` +```c +void foo(int a[]) +``` +```c +void foo(int a[1]) +``` +```c +void foo(int a[2000]) +``` +```c +void foo(int a[999999999]) +``` + +and it treats them all as if you'd used: + +```c +void foo(int *a) +``` + +There's a difference if you want to use multidimensional arrays. You must +declare all the dimensions except the first one, which is optional. The compiler +needs to know the other dimensions so it can do its array indexing computations +correctly. + +```c +int foo(int x[][30]) // 30 wide +{ + return x[2][4]; +} + +int main(void) +{ + int a[10][30]; // 30 wide + + foo(a); +``` + +This only applies for multidimensional arrays. For 1-dimensional arrays, the +rule still applies; you still need to specify all dimensions except the first +one... but since there is only one, you never need to specify it. + +------------------------------------------------------------------------ + +<a name="q1000"></a> +### Why do functions tend to return pointers to structs, and not just copies of the struct? + +It's possible to do this: + +```c +struct foo my_func(void) +{ + struct foo f; + + f.x = 10; + + return f; // Return a copy of f +} +``` + +as opposed to: + +```c +struct foo *my_func(void) +{ + struct foo *p = malloc(sizeof(struct foo)); + + p->x = 10; + + return p; // Return a copy of p +} +``` + +But in C, it's more idiomatic to return a copy of the pointer to the memory +allocated than it is to return a copy of the `struct` itself. + +Part of the reason for this is that it takes time to copy data. A `struct` can +be very large depending on how many fields it has in it, but your average +pointer is only 8 bytes. + +Since every time you `return` a thing, a copy of that thing gets made, it is +faster to copy a pointer than it is to copy a `struct` of any non-trivial size. + +Finally, note that this variant always invokes undefined behavior and should +never be used: + +```c +struct foo *my_func(void) +{ + struct foo f; + + f.x = 10; + + return &f; // Return a copy of a pointer to f +} +``` + +The reason is because `f` vaporizes as soon as the function returns (since it's +just a local variable), so any pointers to it are invalid. + +------------------------------------------------------------------------ + +<a name="q1100"></a> +### Why do we subtract '0' from a char to convert it from ASCII to a numeric value? + +The code typically looks like this: + +```c +char c = '2'; // ASCII '2' + +int v = c - '0'; // Convert into numeric value 2 + +printf("%d\n", v); // prints decimal 2 +``` + +Remember that in C, a `char` is like a small `int`, and when you have a +character in single quotes like `'2'`, C replaces that with the +[ASCII](https://en.wikipedia.org/wiki/ASCII) value of that character. + +In the case of our example, the ASCII value of `'2'` is `50`. And we want to +convert that to the numeric value `2`. So we clearly have to subtract `48` from +it, since `50 - 48 = 2`. But why the `'0'`, then? + +Here's part of the ASCII table, just the numbers: + +|Character|ASCII value| +|:-------:|:---------:| +| `'0'` | 48 | +| `'1'` | 49 | +| `'2'` | 50 | +| `'3'` | 51 | +| `'4'` | 52 | +| `'5'` | 53 | +| `'6'` | 54 | +| `'7'` | 55 | +| `'8'` | 56 | +| `'9'` | 57 | + +It's no coincidence it's done this way. Turns out that if you subtract `48` from +any ASCII character that is a digit, you'll end up with the numeric value of +that ASCII character. + +Example: `'7'` is value `55` (from the table), compute `55 - 48` and you get +`7`. + +And since `'0'` is `48`, it's become idiomatic in C to convert ASCII digits to +values by subtracting `'0'` from them. + +------------------------------------------------------------------------ + +<a name="q1200"></a> +### When do I need a pointer to a pointer? + +There are a few reasons you might need one, but the most common is when you pass +a pointer to a function, and the function needs to modify the pointer. + +Let's take a step back and see when you just need to use a pointer. + +```c +void foo(int a) +{ + a = 12; +} + +int main(void) +{ + int x = 30; + + printf("%d\n", x); // prints 30 + + foo(x); + + printf("%d\n", x); // prints 30 again--not 12! Why? +} +``` + +In the above example, `foo()` wants to modify the value of `x` back in main. +But, alas, it can only modify the value of `a`. When you call a function, all +arguments get _copied_ into their respective parameters. `a` is merely a _copy_ +of `x`, so modifying `a` has no effect on `x`. + +What if we want to modify `x` from `foo()`, though? This is where we have to use +a pointer. + +```c +void foo(int *a) +{ + *a = 12; // Set the thing `a` points at to 12 +} + +int main(void) +{ + int x = 30; + + printf("%d\n", x); // prints 30 + + foo(&x); + + printf("%d\n", x); // prints 12! +} +``` + +In this example, `foo()` gets a copy of a pointer to `x`. (Everything gets +copied into the parameters when you make a call, even pointers.) + +Then it changes the thing the pointer points to to `12`. That pointer was +pointing to `x` back in main, so it changes `x`'s value to `12`. + +Great! + +So what about pointers to pointers? It's the same idea. Let's do a broken +example: + +```c +void alloc_ints(int *p, int count) +{ + p = malloc(sizeof(int) * count); // Allocate space for ints +} + +int main(void) +{ + int *q = NULL; + + alloc_ints(q, 10); // Alloc space for 10 ints + + printf("%p\n", q); // Prints NULL still!! + + q[2] = 10; // UNDEFINED BEHAVIOR, CRASH? +} +``` + +What happened? + +When we call `alloc_ints()`, a _copy_ of `q` is made in `p`. We then assign into +`p` with the `malloc()`, but since `p` is just a copy of `q`, `q` is unaffected. + +It's just like our first version of `foo()`, above. + +Solution? We need to pass a pointer to `q` to `alloc_ints()` so that +`alloc_ints()` can modify the value of `q`. + +But `q` is already a pointer! It's an `int *`! So when we take the address-of it +(AKA get a pointer to it), we'll end up with a pointer to a pointer, or an `int +**`! + +```c +void alloc_ints(int **p, int count) +{ + // Allocate space for ints, store the result in the thing that + // `p` points to, namely `q`: + + *p = malloc(sizeof(int) * count); +} + +int main(void) +{ + int *q = NULL; + + alloc_ints(&q, 10); // Alloc space for 10 ints + + printf("%p\n", q); // Prints some big number, good! + + q[2] = 10; // works! +} +``` + +Success! + +------------------------------------------------------------------------ + +<a name="q1300"></a> +### Do other languages use pointers? + +Most all of them do, but some are more explicit about it than others. In +languages like Go, C, C++, and Rust, you have to use the proper operators when +using pointers and references. + +But languages like JavaScript and Python do a lot of that stuff behind your +back. Take this Python example: + +```python +class Foo: + def __init__(self, x): + self.x = x + +def bar(a): + a.x = 12 # Sets `f.x` to 12--why? + + a = None # Does NOT destroy `f`--why not? + + +f = Foo(2) + +print(f.x) # Prints 2 + +bar(f) + +print(f.x) # Prints 12--why? +``` + +Let's look what happened there. We made a new object `f`, and we passed that +object to function `bar()`, which modified its `x` property. + +After enough time with Python, we learn that it passes objects _by reference_. +This is another way of saying it's using pointers behind your back. Behind the +scenes in Python, `a` is a pointer to `f`. + +That's why when we modify `a.x`, it actually modifies `f.x`. + +And it's also why when we set `a` to `None`, it doesn't change `f` at all. `a` +is just a pointer to `f`, not `f` itself. + +Let's look at the C version of that Python program. This works exactly the same way: + +```c +#include <stdio.h> + +struct foo { + int x; +}; + +void bar(struct foo *a) +{ + a->x = 12; // Sets f.x to 12--why? + + a = NULL; // Does NOT destroy `f`--why not? +} + +int main(void) +{ + struct foo f = { 2 }; + + printf("%d\n", f.x); // Prints 2 + + bar(&f); + + printf("%d\n", f.x); // Prints 12--why? +} +``` + +`a` is a pointer to `f`. So we when do `a->x`, we're saying "set the `x` +property on the thing that `a` points to". + +And when we set `a` to `NULL`, it's just modifying `a`, not the thing that `a` +points to (namely `f`). + +------------------------------------------------------------------------ + +<a name="q1400"></a> +### What's the difference between "`int *x`" and "`int* x`"? + +Syntactically, nothing. They're equivalent. + +That said, the recommendation is that you use the form `int *x`. + +Here's why. These two lines are equivalent: + +```c +int* x, y; +``` + +```c +int *x, y; +``` + +In both of them, `x` is type `int*`, and `y` is type `int`. But by putting the +asterisk right next to the `int`, it makes it look like both `x` and `y` are of +type `int*`, when in fact only `x` is. + +If we reverse the order of `x` and `y`, we must necessarily move the asterisk +with `x`: + +```c +int y, *x; // Also equivalent to the previous two examples +``` + +It's idiomatic to keep the asterisk tucked up next to the variable that's the +pointer. + +------------------------------------------------------------------------ + +<a name="q1500"></a> +### What does the "implicit declaration of function" warning mean? + +This is the compiler saying "Hey, you're calling a function but I haven't seen a +declaration for that function yet." Basically you're calling a function before +you've declared it. + +If you're calling a library function like `printf()` or a syscall like `stat()`, +the most common cause of this warning is failure to `#include` the header file +associated with that function. Check the `man` page for exactly which. + +But what if you're getting the error on one of your own functions? Again, it +means you're calling that function before you've declared it. + +But what does _declared_ mean? + +A declaration can either be a function definition, or a function prototype. + +Let's look at a broken example: + +```c +#include <stdio.h> + +int main(void) +{ + foo(); // Implicit declaration warning!! +} + +void foo(void) +{ + printf("Foo!\n"); +} +``` + +In that example, `main()` calls `foo()`, but the compiler hasn't seen a +declaration of `foo()` yet. We can fix it by defining `foo()` _before_ `main()`: + +```c +#include <stdio.h> + +// Just moved foo()'s definition before main(), that's all + +void foo(void) +{ + printf("Foo!\n"); +} + +int main(void) +{ + foo(); // No problem! +} +``` + +You can also use a _function prototype_ to declare a function before it is used, +like so: + +```c +#include <stdio.h> + +void foo(void); // This is the prototype! It's a declaration of foo(). + +int main(void) +{ + foo(); // No problem +} + +void foo(void) // This is the definition of foo() +{ + printf("Foo!\n"); +} +``` + +Prototypes for functions that are callable from other source files typically +go in header files, and then those other source files `#include` them. + +For functions that aren't used outside the current `.c` file (e.g. little helper +functions that no other file will even need to call), those usually are either +defined at the top of the file before their first call. If that's inconvenient, +a prototype can be placed at the top of the `.c` file, instead. + +------------------------------------------------------------------------ + +<a name="q1600"></a> +### What's the difference between `puts()`, `fprintf()`, and `printf()`? + +`puts()` simply outputs a string. It does no formatting of variables. Its only +argument is a single string. Additionally, it prints a newline at the end for +you. + +```c +// This prints "Hello, world %d!" and then a newline: +puts("Hello, world %d!"); +``` + +`printf()` does formatted output of variables, and strings as well. It's a +superset of `puts()`, in that way. + +```c +int x = 12; + +// This prints "Hello, world 12!\n": +printf("Hello, world %d!\n", x); +``` + +`fprintf()` is just like `printf()`, except it allows you to print to an open file. + +```c +FILE *fp = fopen("foo.txt", "w"); +int x = 12; + +// This writes "Hello, world 12!\n" to the file "foo.txt": +fprintf(fp, "Hello, world %d!\n", x); +``` + +Incidentally, there's already a file open for you called `stdout` (_standard +output_) which normally prints to the screen. These two lines are equivalent: + +```c +printf("Hello, world!\n"); +fprintf(stdout, "Hello, world!\n"); // Same thing! +``` + +There's another already-opened file called `stderr` (_standard error_) that is +typically used to print error messages. Example: + +```c +if (argc != 2) { + fprintf(stderr, "You must specify a command line argument!\n"); + exit(1); +} +``` + +------------------------------------------------------------------------ + +<a name="q1700"></a> +### Why does `025 == 21`? + +In C, any time you have a plain leading `0` on front of a number, the compiler +thinks your number is _base-8_ or _octal_. + +Converting `025` to decimal can be done like so: + +`2*8 + 5*1 = 16 + 5 = 21` + +Octal is rarely used in practice, and it's common for new C programmers to put +`0` in front of a number in error. + +One of the last common places to see octal numbers is in [Unix file +permissions](https://en.wikipedia.org/wiki/File_system_permissions#Numeric_notation). + +------------------------------------------------------------------------ + +<a name="q1800"></a> +### What is the "true dev workflow" in C? + +There is none. + +Initially, it was in a Unix-like system probably using +[Makefiles](https://en.wikipedia.org/wiki/Makefile) to build the software. This +is the system we use at Lambda. + +And modern C development under Unix still follows this pattern, except maybe +using [autotools](https://en.wikipedia.org/wiki/GNU_Build_System) or +[CMake](https://en.wikipedia.org/wiki/CMake). + +But dev for specific platforms like Windows probably happens in [Visual +Studio](https://en.wikipedia.org/wiki/Microsoft_Visual_Studio) instead of using +`make` and the rest of it. + +------------------------------------------------------------------------ + +<a name="q1900"></a> +### Does C have garbage collection? + +Nope! + +When it comes to freeing up memory that is no longer needed by the program, +there are basically two schools of thought: + +* Have the programmer manually manage that memory by explicitly allocating and + freeing it. (C's `malloc()` and `free()` functions.) +* Have the runtime automatically manage all that for you. (Garbage collection, + automatic reference counting, etc.) + +C is too low-level to automatically manage memory usage for you. + +One exception is that C automatically allocates and frees _local variables_ just +like other languages you're used to. You don't have to explicitly call `free()` +for locals (and it's an error to do so). You must call free for any and all +pointers to data that you got back from `malloc()` when you're done with them. + +Also, when a program exits, all memory associated with it is freed by the OS, +whether locals or `malloc()`d data. + +------------------------------------------------------------------------ + +<a name="q2000"></a> +### Why is C code faster than other languages? + +The big thing is _interpreted_ versus _compiled_. + +Python and JavaScript are interpreted languages, which means another program +runs your program. It's software running software. So you run python code with +the `python` program and JavaScript code with `node`, for example. + +So in that case, we have the CPU running `python`, and the Python running your +Python program. Python is the middleman, and that takes execution time. + +C is a compiled language. The compiler takes your C code, and produces machine +code. The CPU runs it directly. No middleman, so it's faster. + +But other languages are compiled (like Go, Swift, Rust, C++, and so on). Why is +C faster than them, typically? + +It's because C is a no-frills, minimalist language. The code you write in C is +actually quite close to the machine code that gets produced by the compiler, so +it doesn't have to do a lot of things behind your back. + +Additionally, people have been working on optimizing the output from C compilers +for over 45 years. That's a big head start over other languages. + +------------------------------------------------------------------------ + +<a name="what-is-segfault"></a><a name="q2100"></a> +### What is a segmentation fault and how do I stop it? + +It means you've accessed some memory you weren't supposed to. The OS killed your +process to prevent it from doing so. + +The trick is to find the line that's causing the problem. If you get a debugger +installed, this can really help. + +In lieu of that, use well-positioned `printf` calls to figure out what the last +thing your program does before it crashes. + +The bug almost certainly has to do with pointers or arrays (which are just +pointers behind syntactic sugar). + +Maybe you're accessing a `NULL` pointer, or an array out of bounds, or modifying +something you're not allowed to modify. + +------------------------------------------------------------------------ + +<a name="q2200"></a> +### What happens if my program exits but I forgot to `free()` some memory I allocated? + +All memory associated with a process is freed when the program exits, even if +you forgot to `free()` it. + +It's considered shoddy programming to not `free()` all the things you +`malloc()`d, though. The OS will free it, but it's bad style to rely on that. + +------------------------------------------------------------------------ + +<a name="q2300"></a> +### What's the difference between a `float` and a `double`, or between an `int` and a `long`? + +It's all about the range of numbers you want to be able to store. + +`double` can hold a more precise number than a `float`. + +A `float` might only be precise up to `3.14159`, but a `double` could hold +`3.1416925358979`, for example. + +Likewise, an `int` might only be able to hold numbers up to 2 billion or so, but +a `long` could hold much larger numbers. + +Use as little as you need. If a `float` or `int` can do the job, use them. If +you need more precision or larger numbers, step up to the next larger type. + +------------------------------------------------------------------------ + +<a name="q2400"></a> +### Can you use `+` to concatenate two strings? + +No. + +The reason is that strings are represented as `char*` types, and adding two +`char*`s together is not a defined operation in C. + +Use the `strcat()` function in `<string.h>` to concatenate one string onto +another. + +------------------------------------------------------------------------ + +<a name="q2500"></a> +### Are variables automatically initialized to zero when I declare them? + +No. + +Always explicitly initialize your variables, whether they be pointers or regular +types. If you don't, random garbage will be in them when you use them. + +> Exception: local variable declared with `static` storage class (this concept +> is out of scope for Lambda) and global variables get initialized to zero +> automatically. But it's still good form to explicitly initialize them. + +------------------------------------------------------------------------ + +<a name="q2600"></a> +### What type should I use to hold numbers bigger than an `int` can hold? + +If you don't need negative numbers, try `unsigned int`. + +If that's not enough, try `long`. + +If that's not big enough, try `long long` (yes, that's a real thing). + +If those aren't enough, try `unsigned long long`. + +If you just need big numbers, but not a lot of precision, you can use `double` or `long double`. + +If you need big numbers _and_ a lot of precision _and_ none of the above are big +enough, check out the [GNU Multiple Precision library](https://gmplib.org/). It +does arbitrary precision arithmetic to as much precision as you have RAM. + +------------------------------------------------------------------------ + +<a name="q2700"></a> +### What VS Code plugins are good for C development? + +"C/C++ IntelliSense, debugging, and code browsing" by Microsoft is a good one. + +------------------------------------------------------------------------ + +<a name="q2800"></a> +### What are some additional C resources? + +A great C book is _The C Programming Language_ Second Edition, by Kernighan [the +"g" is silent] and Ritchie. It's affectionately referred to simply as _K&R2_. + +A less great book that is free online is [Beej's Guide to C +Programming](https://beej.us/guide/bgc/). + +A good, comprehensive FAQ is the [comp.lang.c FAQ](http://c-faq.com/). + +There's no "one true source" of C info online, unfortunately. + +Googling `printf example`, for example, will get you good results. + +Googling `man printf` will bring up the `man` page for `printf`. + +------------------------------------------------------------------------ + +<a name="q2900"></a> +### How do I get the debugger working? + +The commonly-used debugger is called `gdb` (GNU Debugger). + +Lambda's own Brian Ruff got it working on the Mac, and made a +[video](https://youtu.be/BgMOqjdpy5Y) covering it. + +[These +instructions](https://www.thegeekstuff.com/2010/03/debug-c-program-using-gdb/) +are reported good for WSL on Windows. + +[The CS Wiki +page](https://github.com/LambdaSchool/CS-Wiki/wiki/C-and-Cpp-Debugging-in-VS-Code) +might help, but it's slightly outdated since VS Code is in heavy development. + +[This video](https://www.youtube.com/watch?v=aWIs6Kv1MvE) is reported good, as +well. + +If you're not seeing program output in the `Output` tab, try adding this to your +`launch.json`: + +```json +"externalConsole": true +``` + +We recommend Googling for `vscode gdb setup macos`, substituting whatever +platform you're on for `macos` and setting the search date range to be recent. + +------------------------------------------------------------------------ + +<a name="q3000"></a> +### How do I print a pointer with `printf`? + +Use the `%p` format specifier. This will print the value of the pointer (i.e. +the memory address), not what it's pointing to (i.e. the value stored at that +memory address.) + +In practice, pointers are rarely printed except for debugging. + +------------------------------------------------------------------------ + +<a name="q3100"></a> +### Does C have closures? + +No, not in the way that you're used to from higher-level languages. What C does have that essentially acts as a poor man's closure is function pointers. These are literally what their name implies: pointers to functions. + +The standard library implementation of the quicksort sorting algorithm provides a good example of this. It's function signature is +``` +void qsort(void *base, size_t nitems, size_t size, int (*compare)(const void *, const void *)) +``` + +The parameter to notice is the `int (*compare)(const void *, const void *)`. This is a function pointer, mainly denoted by the asterisk in front of the function name all wrapped in parentheses and followed by another set of parentheses containing a parameter signature. + +This signature is saying that the `qsort` function, in addition to the other parameters it receives, also receives a pointer to a function that receives two `const void *`s and returns an `int`. + +Function pointers are used to fulfill the same use case as closures. They can be used to pass some dynamic logic into another function. In the case of `qsort`, the function pointer points to a function that specifies how the comparison for the sorting should be done. + +------------------------------------------------------------------------ + +<a name="q3200"></a> +### If I look at an uninitialized variable, will the garbage in it ever be leftover data from another process? + +Not on a modern OS. It would be a security risk, so the OS makes sure this never +happens. + +------------------------------------------------------------------------ + +<a name="q3300"></a> +### How many levels of indirection can you have with pointers? `int******`? + +It's effectively unlimited. But the more you have, the less readable your code +is. + +In real life: + +* 99.8% (roughly) of pointer usage is single indirection, like `int*`. +* 1.5% (roughly) is double indirection, like `char**`. +* And the remaining 0.5% is the rest of it. + +------------------------------------------------------------------------ + +<a name="q3400"></a> +### What's the `incompatible integer to pointer conversion` error? + +This means you have a type mismatch in your assignment. + +One side of the `=` has pointer type, and the other side has integer type. + +If you have a pointer in your assignment, both side of the `=` must be the same +pointer type. + +Maybe you meant to take the address of the right hand side? Or dereference the +right hand side? + +------------------------------------------------------------------------ + +<a name="q3500"></a> +### Are there any other ways besides `malloc()` to store things on the heap? + +Short answer: no. + +(We're assuming that by `malloc()` we mean `malloc()`, `calloc()`, and +`realloc()`.) + +The longer answer is that you can make a syscall and request more RAM from the +operating system. In practice, this is very rare; people just call `malloc()`. + +In Unix, that syscall is `brk()` (or `sbrk()`). The behavior of this call is a bit strange no + +------------------------------------------------------------------------ + +<a name="q3600"></a> +### For string literals like `"Hello"`, are those stored on the stack or heap? + +Neither. + +Consider it to be stored in such a way that it is perpetually accessible from +the entire program for the entire run and is never freed. So sort of like the +heap. + +This code is just fine: + +```c +char *hello(void) +{ + char *s = "hello!"; + + return s; +} +``` + +`s` is a local variable that is set to point to the string `"hello!"`, and `s` +is deallocated as soon as the function returns. But the data `s` points to +(namely the `"hello!"`) persists for the entire life of the program and is never +freed. + +It's not actually on the heap, though. The C memory map looks like this, +typically: + +``` ++--------------------+ +| Stack | +| | | +| v | ++- - - - - - - - - - + +| | +| | +| | ++- - - - - - - - - - + +| ^ | +| | | +| Heap | ++--------------------+ +| Uninitialized data | ++--------------------+ +| Initialized data | +| (Read-Write) | ++--------------------+ +| Initialized data | +| (Read-Only) | ++--------------------+ +| Program code | ++--------------------+ +``` + +Constant strings are found in the read-only initialized data section of memory. + +If you try to write to one, your program will likely crash: + +```c +char *s = "Hello!"; + +*s = 'B'; // segfault! +``` + +------------------------------------------------------------------------ + +<a name="q3700"></a> +### Is the C stack like the stack data structure? + +Yup! It's used by C to allocate space for local variables when you call functions. + +When you return from a function, all those local variables are popped off the +stack and thrown away. (Which is why local variables only last as long as the +function!) + +------------------------------------------------------------------------ + +<a name="q3800"></a> +### Is the C heap like a binary heap data structure? + +No--it's just a name collision. + +Just assume the heap is a big, contiguous chunk of memory. It can be used for +whatever, but in C, it is typically managed by `malloc()` and `free()` so that +we don't have to worry about it. + +------------------------------------------------------------------------ + +<a name="q3900"></a> +### What are `stdin`, `stdout`, and `stderr`? + +These are the three files that are automatically opened for a process when it is first created. + +|Stream | File Name | Device | +|-----------------|:---------:|:--------:| +| Standard Input | `stdin` | Keyboard | +| Standard Output | `stdout` | Screen | +| Standard Error | `stderr` | Screen | + +`stderr` is typically used specifically for error messages, even though it goes +to the same place as `stdout`. (The idea is that you can redirect all normal +output to one place, and all error output to another place. Or suppress normal +output while allowing error output.) + +------------------------------------------------------------------------ + +<a name="q4000"></a> +### How do I know which header files to `#include` for any particular function? + +Check the man page for the function in question. It'll show it in the _Synopsis_ +section. + +Example for `printf()`: + +> **SYNOPSIS** +> ```c +> #include <stdio.h> +> ``` +> ```c +> int +> printf(const char * restrict format, ...); +> ``` + +Note that if you type `man` on the command line for a particular function, you +might a manual page for another command that isn't the C function. In that case, +you have to specify the proper _section_ of the manual for the function. + +Try section 3 for library functions, and section 2 for syscalls. + +Example looking for `printf()` in section 3: + +```shell +man 3 printf +``` + +And section 2 for the `mkdir()` syscall: + +```shell +man 2 mkdir +``` + +------------------------------------------------------------------------ + +<a name="q4100"></a> +### When do I have to explicitly cast a type to another type? + +Barely ever. + +C is pretty good about conversions, and you should be able to build almost +everything without casting. + +What if you need constant types? + +```c +// Print a double: +// (Floating point constants are double by default.) +printf("%lf\n", 3.14); + +// Print a float: +printf("%f\n", 3.14f); + +// Print a long double +printf("%Lf\n", 3.14L); + +// Print a long integer: +printf("%ld\n", 99L); + +// Print a long long integer: +printf("%lld\n", 99LL); + +// Produce a floating result of a calculation by making sure at least +// one of the operands is a float: +float sort_of_pi = 22.0f / 7; +double double_pi = 22.0 / 7; +``` + +What if you need to cast a void pointer? + +```c +void foo(void *p) +{ + // convert p to a char* + char *q = p; + + // Don't need to cast return value from malloc + int *z = malloc(sizeof(int) * 100); +``` + +Some exceptions: + +```c +void foo(int a) +{ + // Cast an unused variable to type void to suppress compiler warnings: + (void)a; + + // If the compiler is warning about an unused return value: + (void)printf("Hello, world!\n"); + + // Cast to a char pointer to iterate over bytes of an object: + // (C99 6.3.2.3 paragraph 7 allows this.) + float f = 3.14; + unsigned char *c = (unsigned char *)&f; + + for (unsigned i = 0; i < sizeof f; i++) { + printf("%02x ", c[i]); + } + printf("\n"); +``` + +------------------------------------------------------------------------ + +<a name="q4200"></a> +### Is `realloc()` the same as calling `malloc()`, copying the data over, then calling `free()` on the original pointer? + +Effectively, yes, it's the same. Practically, you should use `realloc()`. + +`realloc()` might be more efficient because in some cases it might not have to +copy. + +If you grow the space and `realloc()` knows there's extra unused memory right +after the existing space, it will simply tack that addition space onto the end +of the memory region and not bother moving the data. + +Also, if you shrink the space, `realloc()` will likely not copy the data. It'll +just truncate it. + +------------------------------------------------------------------------ + +<a name="q4300"></a> +### What happens if I `free()` a `NULL` pointer? + +Nothing. It's a [no-op](https://en.wikipedia.org/wiki/NOP_(code)). + +Basically, inside the library code for `free()`, there's something that looks +like this: + +```c +void free(void *ptr) +{ + if (ptr == NULL) { + return; + } +``` + +According to the [C99 +spec](http://www.open-std.org/jtc1/sc22/wg14/www/docs/n1124.pdf) section +7.20.3.2p2: + +> The `free` function causes the space pointed to by `ptr `to be deallocated, +> that is, made available for further allocation. **If `ptr` is a null pointer, +> no action occurs**. Otherwise, if the argument does not match a pointer +> earlier returned by the `calloc`, `malloc`, or `realloc` function, or if the +> space has been deallocated by a call to `free` or `realloc`, the behavior is +> undefined. + +------------------------------------------------------------------------ + +<a name="q4400"></a> +### What are bits, bytes, kilobytes, megabytes, and all that? + +A [_bit_](https://www.youtube.com/watch?v=_fGujzulsas) is a single `1` or `0`. +That's all the numbers it can represent. + +A _nibble_ is 4 bits. It can represent numbers from `0b0000` to `0b1111` (binary +numbers), which is equivalen to `0` to `15` in decimal. + +A _byte_ is 8 bits. It can represent numbers from `0b00000000` to `0b11111111`, +or `0` to `255` decimal. (Historically, bytes could be other numbers of bits, +but on all modern systems, it's always 8 bits. _Octet_ is another term for a +number that is specifically 8 bits long.) + +A _kilobyte_ is 1024 bytes. (1024 is 2<sup>10</sup>.) + +A _megabyte_ is 1024 kilobytes (1,048,576 bytes). + +A _gigabyte_ is 1024 megabytes (1,073,741,824 bytes). + +A _terabyte_ is 1024 gigabytes (1,099,511,627,776 bytes). + +A _petabyte_ is 1024 terabytes (1,125,899,906,842,624 bytes). + +If you're used to [SI unit +prefixes](https://en.wikipedia.org/wiki/International_System_of_Units#Prefixes), +you might be wondering why in computers _kilo_ means 1024 instead of 1000 like +it normally does. In short, it's for historic reasons. 1024 was close enough, so +computer programmers adopted the SI prefixes, albeit with a slightly different +value. + +And that gets confusing. When I say _kilobyte_, do I mean 1000 bytes or 1024 bytes? + +In almost every single case, _kilobyte_ means 1024 bytes. (Hard drive and SSD +sizes are sometimes an exception to this rule.) + +To remove the ambiguity, you can use a [binary +prefix](https://en.wikipedia.org/wiki/Binary_prefix), where you'd say _kibibyte_ +if you specifically meant 1024 bytes. + +That said, in conversation, if someone says _kilobyte_, odds are extremely high +they mean 1024 bytes, not 1000 bytes. _kibibyte_ is uncommonly used in +conversation. + +------------------------------------------------------------------------ + +<a name="q4500"></a> +### In C, can we assume an `int` is 32 bits? + +No. + +You can assume an `int` is _at least_ 16 bits (2 bytes). + +There is only one type that has a guaranteed size: `sizeof(char)` will always be +`1` byte. (Same for `unsigned char` and `signed char`.) + +Never write code that hardcodes or assumes the size of anything other than +`char`. **Always** use `sizeof` to get the size. + +There's a [great Wikipedia article](https://en.wikipedia.org/wiki/C_data_types) +that lists the minimum sizes of the types. If you want your code to be portable +to other compilers and systems, choose a type with a minimum size that works for +the numbers you need to hold. + +------------------------------------------------------------------------ + +<a name="q4600"></a> +### What's the difference between `#include` with double quotes and `#include` with angle brackets? + +In general, use double quotes for your own header files, and angle brackets for +built-in system header files like `<stdio.h>`. + +When you `#include "foo.h"`, it looks for `foo.h` in the same directory as the +source file doing the including. + +You can also use relative paths, and it'll look relative to the including source file: + +```c +#include "../bar.h" +#include "somedir/baz.h" +``` + +When you `#include <frotz.h>`, it looks in the _system include directories_ for +the header file. This is where all the built-in header files are installed. On +Unix machines, this tends to be the `/usr/include` directory, but it depends on +the OS and compiler. + +------------------------------------------------------------------------ + +<a name="q4700"></a> +### Should I declare a pointer to a thing, or just declare the thing? + +It depends on if you want a thing or not, or if you just want to point to +another, **already-existing** thing. + +If there is not an already-existing thing, then making a pointer doesn't make +sense. There's no existing thing for it to point to. + +This does not declare an `int`: + +```c +int *p; +``` + +There's no `int` there. We have an `int` pointer, but it's uninitialized, so it +points to garbage and can't be used. + +So the question to ask is, "Do I already have an existing thing that I can point +to? And if so, do I want to point to it?" If the answer to either is "no", then +don't use a pointer. + +Example: + +```c +int a = 12; // here's an existing thing +``` + +So the answer to the first part of the question is yes. And do we want a pointer +to it? Sure, why not? + +```c +int *p = &a; // and there's a pointer to it +``` + +------------------------------------------------------------------------ + +<a name="q4800"></a> +### Is there a difference between `exit()` and `return`? + +If you're in the `main()` function, then no. + +If you're in any other function, then yes. + +`exit()` always exits the running process, no matter where you call it from. + +If you're in `main()`, `return` also exits the running process. + +If you're in any other function, `return` just returns from that function. + +------------------------------------------------------------------------ + +<a name="q4900"></a> +### Why does `strcmp()` return `0` when strings match? Since `0` means "false" in C, that seems backwards. + +`strcmp()` returns the _difference_ between two strings. If the strings are the +same, there is zero difference, so it returns zero. + +This gives `strcmp()` a little extra power over just returning a boolean +true/false value. + +For example, if you run this: + +```c +strcmp("Antelope", "Buffalo"); +``` + +it will return less-than zero because "Antelope" is alphabetically less than +"Buffalo". + +So not only can it tell you if the strings are the same, it can tell you their +relative sort order. And that means you can pass it in as the comparator +function to the library built-in `qsort()` function. + +------------------------------------------------------------------------ + +<a name="ub"></a><a name="q5000"></a> +### What is "undefined behavior" in C? + +There are a number of things you're allowed to do in C where the compiler is +allowed to produce code that can have any indeterminate effect. It could work, +it could crash, it could sort of work, it could crash sometimes and not others, +it could crash on some machines and not others. + +When you write code that does that, we say the code has _undefined behavior_. + +[Wikipedia has a number of practical +examples](https://en.wikipedia.org/wiki/Undefined_behavior), and if you look in +the [C99 Language Specification, Annex +J.2](http://www.open-std.org/jtc1/sc22/wg14/www/docs/n1124.pdf) you can get a +list of _all_ the things you can do that cause undefined behavior. + +At Lambda, the most common things you can do to get UB is using bad pointer references. + +* Accessing memory you've already `free()`d. +* Freeing memory more than once. +* Accessing an array off the end of its bounds. +* Dereferencing a pointer that points to garbage. +* Dereferencing a `NULL` pointer. +* Returning a pointer to a local variable and dereferencing that. + +GCC with `-Wall -Wextra` should warn on a lot of these. This is why it's +_really_ important to fix all those warnings. + +------------------------------------------------------------------------ + +<a name="q5100"></a> +### When you free a pointer, does it get set to `NULL` automatically? + +No. + +Furthermore, `free()` can't do that even if it wanted to. + +```c +int *p = malloc(100 * sizeof(int)); + +free(p); +``` + +When we call `free()`, it gets a _copy_ of the pointer we pass in. (**All** +functions **always** get _copies_ of **all** arguments you pass in.) As such, +`free()` could set its copy of `p` to `NULL`, but that doesn't affect our +original `p`. + +`p` remains whatever value was in it until we set it to something else. + +```c +int *p = malloc(100 * sizeof(int)); + +free(p); + +p = NULL; // NOW p is NULL +``` + +(Note that it's [undefined behavior](#ub) to _dereference_ a pointer after +you've `free()`d it. But it's still OK to change that pointer's value.) + +------------------------------------------------------------------------ + +<a name="q5200"></a> +### How do I write preprocessor macros with `#define`? + +You've probably already seen simple cases of `#define` like this: + +```c +#define antelopes 10 + +int main(void) +{ + printf("Antelopes: %d\n", antelopes); // prints 10 +``` + +What's actually happening here is the _preprocessor_ runs through the code +before the compiler ever sees it. It manipulates the above code to read: + +```c +int main(void) +{ + printf("Antelopes: %d\n", 10); // prints 10 +``` + +and _then_ hands it off to the compiler. The compiler itself knows nothing about +`#define`. + +These `#define` _macros_ can also accept parameters that make them behave like +functions in a way. + +Example: + +```c +#define square(x) x * x // Not quite Right. See below. + +int main(void) +{ + printf("9 squared is %d\n", square(9)); +``` + +Then the preprocessor generates this code for the compiler: + +```c +int main(void) +{ + printf("9 squared is %d\n", 9 * 9); +``` + +It just substitutes the parameters in as-is. + +Another example: + +```c +#define square(x) x * x // Not quite Right. See below. + +int main(void) +{ + printf("3 + 2 squared is %d\n", square(3 + 2)); +``` + +Then the preprocessor generates this code for the compiler, merely substituting +in exactly what the dev entered as an argument: + +```c +int main(void) +{ + printf("3 + 2 squared is %d\n", 3 + 2 * 3 + 2); +``` + +Except that prints `11`, when it should print `25` (3 + 2 is 5, and 5 squared is +25)! We have a bug! + +Of course, this has to do with the order of operations. We wrote: + +```c +3 + 2 * 3 + 2 +``` + +when what we really wanted was: + +```c +(3 + 2) * (3 + 2) +``` + +For this reason, you should **always** put extra parentheses around the macro +body, and around every parameter in the body: + +```c +#define square(x) ((x) * (x)) +``` + +And now the expansion of our line will be: + +```c +((3 + 2) * (3 + 2)) +``` + +That will work in all expected cases. + +------------------------------------------------------------------------ + +<a name="q5300"></a> +### What is an `undefined symbol` linker error? + +This happens when you've called a function, and the _linker_ can't find it in +any of the source files or libraries that you're using. + +Do you have a warning about an implicit function declaration from the compiler +before this error? If so, fix that first. + +If not, it could be that you haven't specified all the source files needed on +the command line. If you have two sources `one.c` and `two.c`, and one calls +functions that are in the other, then you have to pass both into the compiler: + +``` +gcc -Wall -Wextra -o myexe one.c two.c +``` + +Alternately, is there a `Makefile` present? If so, the author of the software +probably intends for you to use that to build the project, rather than trying to +figure out the command line on your own. + +Try just running: + +``` +make +``` + +and seeing if that works. Make will show you the command lines it's running to +make the build happen so that you don't have to. + +The linker is part of the entire compilation system. Basically, the compiler +takes your C source files, makes sure they're syntactically correct, and turns +them into things called _object files_, one per source file. These object files +might refer to functions that they don't contain, like `printf()`, for example. + +Then the linker takes all the object files and libraries and puts them together +into a single binary executable that you can run. It makes sure that all the +functions used are present in the files specified. + +(Normally this whole process takes place behind the scenes and you don't have to +think about it. Sometimes Makefiles will generate object files that you might +see, e.g. `foo.o`. `.o` is the extension for object files on Unix, or `.obj` in +Windows.) + +If the linker can't find a function in any of the object files or libraries, it +pukes out an error. It can't call a function if it can't find it. + +In this example, the code calls a function `foobaz()`, but the linker can't find +that in any of the object files: + +``` +Undefined symbols for architecture x86_64: + "_foobaz", referenced from: + _main in foo-133c47.o +ld: symbol(s) not found for architecture x86_64 +clang: error: linker command failed with exit code 1 (use -v to see invocation) +``` + +(Ignore the leading underscores on the function names.) + +To fix, we need to figure out which file `foobaz()` is defined in, and make sure +to pass that filename to the compiler when we build. + +------------------------------------------------------------------------ + +<a name="q5400"></a> +### How do I make my own header files and what do I put in them? + +If you have a `.c` file and you want to be able to use functions, `#define`s, or +globals from that file in another file, you'll need to make a _header file_ +(`.h` file) to hold the function prototypes, `#define`s, and references to any +globals. + +Example: + +```c +// square.c + +long square(long x) +{ + return x * x; +} +``` + +If you want to use `square()` from a different file, you need a way for that +file to know the `square()` function declaration so the compiler can check to +see that you're using it correctly. + +For that, we need a corresponding `.h` file: + +```c +// square.h + +#ifndef SQUARE_H // Prevent multiple #includes +#define SQUARE_H + +// Function prototypes +extern long square(long x); + +#endif +``` + +The `#ifndef SQUARE_H` is called the _guard macro_, and is there to prevent the +header file from being included multiple times. (This can be a problem if you +have header files that include other header files in a cycle.) `#ifndef` means +"if not defined". Basically, `SQUARE_H` is acting as a boolean that gets set the +first time through and so prevents the content of the header file from being +included again. + +All header files have wrappers like that. The name of the preprocessor variable +is conventionally `FILENAME_H`, but could be anything as long as it's unique in +the project. + +The keyword `extern` indicates to the compiler that the function in question is +not defined here; it is defined in another file. In this header file, `extern` +is the default _storage class_ for functions, so it's redundant. But it's really +common to see in any case. + +Now that we have a header file, we can `#include` that from somewhere else. Use +double quotes in the `#include` to indicate that the compiler should look in the +current directory for the header file. + +```c +#include "square.h" + +int main(void) +{ + int x = square(5); +``` + +When you build, you must specify all `.c` files on the command line: + +``` +gcc -Wall -Wextra -o main main.c square.c +``` + +------------------------------------------------------------------------ + +<a name="q5500"></a> +### How do I make my own Makefile? + +**IMPORTANT: Any lines shown _indented_ in any Makefile _must_ begin with a +single TAB character! Spaces will _not_ work. If you use spaces to indent, +you'll likely see a `Missing separator` error when you try to `make`.** + +```make +myexecutable: mysource1.c mysource2.c + gcc -Wall -Wextra -o myexecutable mysource1.c mysource2.c +``` + +The above Makefile says: + +"If `mysource1.c` or `mysource2.c` are _newer_ than `myexecutable`, then run the +following commands in the indented block below this line." + +And by "newer", we mean they have a more up-to-date timestamp, i.e. they've been +saved more recently than `myexecutable` has been created. + +If any of the sources are newer than the executable, the executable should be +rebuilt to get it up to date. And that's what make does. + +We say that `myexecutable` _depends on_ `mysource1.c` and `mysource2.c`. If +either of those dependencies change, `myexecutable` must be rebuilt. + +This also works: + +```make +myexecutable: mysource1.c mysource2.c + gcc -Wall -Wextra -o $@ $^ +``` + +`$@` is a make _macro_ that means "substitute whatever is left of the `:` right +here" (in this example, `myexecutable`). + +`$^` is a make macro that means "substitute whatever is to the right of the `:` +right here" (in this example, `mysource1.c mysource2.c`). + +You can also define constants: + +```make +SRCS=mysource1.c mysource2.c +TARGET=myexecutable + +$(TARGET): $(SRCS) + gcc -Wall -Wextra -o $@ $^ +``` + +You can have multiple _recipes_ per Makefile: + +```make +target1: source1.c + gcc -Wall -Wextra -o $@ $^ + +target2: source2.c + gcc -Wall -Wextra -o $@ $^ +``` + +If you type `make`, it will build the first _target_ in the file by default. A +target is a file that is generated by running `make`, i.e. a file to the left of +a `:`. You can also make specific targets by specifying them on the command line: + +```shell +$ make target1 +gcc -Wall -Wextra -o target1 source1.c +$ make target2 +gcc -Wall -Wextra -o target2 source2.c +``` + +If you want all targets to get built by default, you can put a dummy first +target in that depends on the other targets. This target is called `all` by +convention. It typically doesn't run any commands and is only there to set up +the dependency hierarchy with the other recipes. + +```make +# Recipe `all` depends on `target1` and `target2`: +all: target1 target2 + +target1: source1.c + gcc -Wall -Wextra -o $@ $^ + +target2: source2.c + gcc -Wall -Wextra -o $@ $^ + +.PHONY: all +``` + +That `.PHONY: all` line is a GNU make extension that indicates that `all` is not +a real file. Normally targets refer to real files, and make will check to see if +that file exists on disk or not before trying to build it. But in this case, +`all` is not a file; it's just recipe we're using to get all targets to build by +default. + +* [GNU make documentation](https://www.gnu.org/software/make/manual/make.html) + +------------------------------------------------------------------------ + +<a name="q5600"></a> +### Why are there so many `printf()` variants? How do I know which one to use? + +The way to approach it is when you think, "I need something just like +`printf()`, except instead of to the screen, it prints to _x_," then you look in +the man page and see if there's a `printf()` variant that suits your needs. + +The first letters let you know what speciality each one has: + +* `printf()`: stock, no frills. +* `fprintf()`: "file printf"; print to a specified `FILE*` instead of to `stdout`. +* `sprintf()`: "string printf"; print to a string instead of to `stdout`. +* `snprintf()`: "string printf, with a limited count"; print to a string instead + of to `stdout`, and also specify the maximum number of characters that + `snprintf()` is allowed to store in the buffer. This is good to protect + against buffer overruns, and there's a valid argument that you should _never_ + use `sprintf()`, preferring `snprintf()` instead. +* `vprintf()`: "variadic printf"; anything that starts with a `v` in `printf` + land has to do with [variadic + functions](https://www.gnu.org/software/libc/manual/html_node/Variadic-Functions.html), + i.e. functions with argument lists of variable lengths. These are out of scope + at Lambda. +* etc. + +------------------------------------------------------------------------ + +<a name="q5700"></a> +### Why is `main()` always at the bottom of the file? + +C has the feature that you have to _declare_ a function before you can use it. +So any functions `main()` needs have to be declared before `main()`, which means +"above" it in the file. + +You can also declare functions with _prototypes_ and then put the definition of +`main()` before the definition of the other functions. + +It's more common for C devs to put `main()` at the bottom of the file that +contains it, and C devs expect it that way, but it's not wrong or frowned upon +to use prototypes to put it at the top instead. + +------------------------------------------------------------------------ + +<a name="q5800"></a> +### Why does `main()` return `0`? What does the return value mean? + +It doesn't _have_ to. The return value from `main()` is the _exit status_ of the +process. This is passed back to the program that first launched your program, so +it can do different things based on the exit status of your program. + +Think of it like a way for an exiting program to pass a small piece of +information (an integer) back to the program that spawned it. + +`0` by convention means "success". Non-zero means "failure". The idea there is +that there's typically only one way for a program to succeed, but many ways for +it to fail, and you can communicate those different ways with different exit +codes. + +Note that you can also use the `exit()` call, passing an exit status code to it +as an argument. Using `return` in `main()` is equivalent to calling `exit()`. + +In bash, you can look at the exit status of the previous command by `echo`ing +the `$?` shell variable. In the following example, we use `grep` incorrectly, +and it exits with status `2` to indicate that. Whereas we use `ls` correctly, +and it exits with successful status `0`: + +```shell +$ grep +usage: grep [-abcDEFGHhIiJLlmnOoqRSsUVvwxZ] [-A num] [-B num] [-C[num]] + [-e pattern] [-f file] [--binary-files=value] [--color=when] + [--context[=num]] [--directories=action] [--label] [--line-buffered] + [--null] [pattern] [file ...] +$ echo $? +2 +$ ls -d . +. +$ echo $? +0 +``` + +At the OS level, `fork()` is used to create a new process, and `wait()` is used +to get the exit status back from that process. + +------------------------------------------------------------------------ + +<a name="q5900"></a> +### Do we have to have a `main()`? Can there be more than one? + +Only if you want to have a program that you can run. When you first launch a +program, it looks for a function called `main`. + +There can only be one `main()` in a program. (There can only be one of any +function, for that matter.) + +It could be that individual files don't have a `main()` in them, but when the +whole project it built, `main()` is brought in from another source file. + +Also, there's a thing called a +[library](https://en.wikipedia.org/wiki/Library_(computing)) which is a +collection of functionality that your program makes use of, but doesn't have a +`main()`, itself. Your program has the `main()`, and it just _calls_ routines +that are in the library. + +[The C Standard Library](https://en.wikipedia.org/wiki/C_standard_library) is a +library that holds all the standard C functionality (e.g. `printf()`, `sqrt()`, +etc.) but doesn't have a `main()` of its own. Other programs simply use the +library. + +------------------------------------------------------------------------ + +<a name="q6000"></a> +### Can `main()` return `void`? What about `main()` with no parameters? + +No. The function signature for `main()` must be one of the following: + +```c +int main(void) +int main(int argc, char *argv[]) +int main(int argc, char **argv) +``` + +Note that the second two are equivalent. Use the first form if you don't need to +process command line arguments. + +Historically, these were also equivalent, but the second form is now obsolete: + +```c +int main(void) // OK +int main() // Obsolete +``` + +------------------------------------------------------------------------ + +<a name="q6100"></a> +### Do we need a semicolon at the end of every line? + +Yes. + +Or, more technically, at the end of every statement or expression. + +C won't fill them in automatically like JavaScript will. + +------------------------------------------------------------------------ + +<a name="q6200"></a> +### Can a pointer point to more than one thing? What about to arrays and `struct`s? + +A pointer is a memory address. A single memory address, a single index number +into your memory array. + +As such, it can only point to a single byte in memory. + +For single-byte and multi-byte entities, the pointer _always points to the first +first byte of that entity_. + +If you have an `int` made up of 4 bytes, a pointer to that `int` points to the +address in memory of the first byte of that `int`. + +If you have a `struct`, it points to the first byte of that `struct`. + +If you have an array of a zillion `struct`s, it points to the first byte of the +0th `struct` in that array. + +------------------------------------------------------------------------ + +<a name="q6300"></a> +### If variables are stored in memory, where are pointers stored? + +Pointers themselves are variables. + +Variables are stored in memory. + +Therefore pointers are also stored in memory. + +Remember that a pointer is just an index into memory. It's just a number; in +fact it's an integer number. We can store integer numbers in memory without a +hassle. + +The only difference between a pointer and an integer is that you can dereference +the pointer to see what it's pointing to. You can't dereference an integer. In +memory, they're both just stored as numbers. + +------------------------------------------------------------------------ + + + + + +</details><details> <summary>1-projects/Intro-to-C-master/fizzbuzz/</summary> + +### [1-projects/Intro-to-C-master/fizzbuzz/README.md](1-projects/Intro-to-C-master/fizzbuzz/README.md) +<!-- START doctoc generated TOC please keep comment here to allow auto update --> +<!-- DON'T EDIT THIS SECTION, INSTEAD RE-RUN doctoc TO UPDATE --> +**Table of Contents** *generated with [DocToc](https://github.com/thlorenz/doctoc)* + +- [Functions in C](#functions-in-c) + - [Implementing fizzbuzz](#implementing-fizzbuzz) + +<!-- END doctoc generated TOC please keep comment here to allow auto update --> + +# Functions in C + +Functions in C are not much different from functions in JavaScript. Probably the most notable difference, at least from a syntactic point of view, is that you need to specify types on all your variables and input parameters, along with needing to specify the return type of the function. Remember, C is a _strongly_ typed language, as opposed to JavaScript which is a _loosely_ typed language where types are entirely inferred by the interpreter. The C compiler ensures that you specify your types and that your code is consistent with the types you specify. + +Here is a non-comprehensive list of C data types: [https://codeforwin.org/2015/05/list-of-all-format-specifiers-in-c-programming.html](https://codeforwin.org/2015/05/list-of-all-format-specifiers-in-c-programming.html) + +To reiterate, you might declare a function in C like this: +```c + int foo(int param1, int param2) + { + ... + return 0; + } +``` +This function signature states that it receives two integer parameters and returns an integer. + +Here's another example: +```c + void bar(int[]) + { + ... + } +``` +This function signature states that it receives a single integer array and doesn't return anything. You'll often see this kind of function signature when you want the function to simply mutate the input and/or print the contents of the input. + +For printing output, you'll want to use the `printf` function, which is included in the `stdlib` library. + +## Implementing fizzbuzz + +Your first task is going to be writing good ol' fizzbuzz in C! Your `fizzbuzz` function should receive some integer n, then loop up till n, printing out "Fizz" if the current iteration i is divisible by 3, "Buzz" if it's divisible by 5, or "FizzBuzz" if it is divisible by both 3 and 5. Additionally, for each iteration where nothing is printed, your function should increment a counter and return the result of that counter at the end of its execution. + +Navigate to the `fizzbuzz.c` file. You'll write your code in there. When you want to test it, type `make tests` into your terminal (make sure you're doing this from the directory where the `Makefile` is located), which will run the `Makefile` and compile your program and, if the compilation was successful, run the tests for it as well. + + + + + +</details><details> <summary>1-projects/Intro-to-C-master/hangman/</summary> + +### [1-projects/Intro-to-C-master/hangman/README.md](1-projects/Intro-to-C-master/hangman/README.md) +<!-- START doctoc generated TOC please keep comment here to allow auto update --> +<!-- DON'T EDIT THIS SECTION, INSTEAD RE-RUN doctoc TO UPDATE --> +**Table of Contents** *generated with [DocToc](https://github.com/thlorenz/doctoc)* + +- [Hangman](#hangman) + - [Objective](#objective) + - [How your Program Should Work](#how-your-program-should-work) + - [How to Tackle the Problem](#how-to-tackle-the-problem) + - [Rules of Hangman](#rules-of-hangman) + +<!-- END doctoc generated TOC please keep comment here to allow auto update --> + +# Hangman + +## Objective +Write a program that allows you play a game of Hangman. All of your code can be written in the `hangman.c` file. + +## How your Program Should Work +The main loop of the program prints the current state of the game and then waits for input from the player. When the player types in input (either a single letter guess or a word guess), the game checks if the letter is one that is in the target word or if the word guess matches the target word. If the guess is correct, the game state updates accordingly by revealing the guess as part of the target word. If the guess is incorrect, the game state updates accordingly by showing that letter in the 'incorrect guesses' list and adding another limb to the hangman drawing. + +You'll compile your program with +``` +gcc -o hangman hangman.c +``` +This will create an executable called `hangman` that you'll execute with the command `./hangman` once you've successfully compiled the program. + +For this implementation, your program should receive a single word parameter; that will be the word that the player is trying to guess. So running your program might look like this +``` +./hangman antidisestablishmentarianism +``` +This will start the game loop, which will then continue running until the player wins, the player loses, or the player exits the game. + +## How to Tackle the Problem +This problem can be broken down into many subproblems. Each subproblem can be further broken down into chunks that you can think about how to implement in code. These include, but are not limited to, the following: + - [ ] Reading input from the user and recording it properly + - [ ] Figuring out how to parse command line arguments + - [ ] Properly recording game state + - [ ] Keeping track of all letters/words that have been inputted + - [ ] Recording the incorrect guesses + - [ ] Printing the proper UI given the game's current state + - [ ] Implementing the ability to accept both single letter guesses as well as entire word guesses + - [ ] Having the game UI respond appropriately when a player makes a correct / incorrect guess + - [ ] Adding the ability for the user to exit the game by typing in the proper keyword + +## Rules of Hangman +Just in case you happen to be someone who _doesn't_ know the rules of Hangman, we'll list them here. + +The game has you guess a word. You're given 8 strikes. If you guess an incorrect letter (that you haven't already guessed before), or take a stab at guessing the entire word and don't get the correct word, that's one strike. The game keeps track of each letter that you've guessed. You win the game when you guess the correct word. + + + + + + +</details><details> <summary>1-projects/Intro-to-C-master/malloc/</summary> + +### [1-projects/Intro-to-C-master/malloc/README.md](1-projects/Intro-to-C-master/malloc/README.md) +<!-- START doctoc generated TOC please keep comment here to allow auto update --> +<!-- DON'T EDIT THIS SECTION, INSTEAD RE-RUN doctoc TO UPDATE --> +**Table of Contents** *generated with [DocToc](https://github.com/thlorenz/doctoc)* + +- [Dynamic Memory](#dynamic-memory) + - [Working with Void Pointers Directly](#working-with-void-pointers-directly) + +<!-- END doctoc generated TOC please keep comment here to allow auto update --> + +# Dynamic Memory + +Remember that a few modules ago when we were talking about arrays in C being entirely static? That's a pretty big limitation since we're forced to know up front what kind of data we want to store in the array and how much data there is before we can fit it into an array. We aren't psychics here. How do we get around this? + +The answer to that is the `malloc` function. Its signature is this: +```c + void *malloc(size_t size); +``` +A `size_t` type is nothing more than a really large int for representing large sizes. The other thing to note is that the `malloc` function returns a `void` pointer. The `void` type simply means the type could be anything; essentially, we don't know the type up front. So `malloc` returns us a pointer of unspecified type that points to a chunk of memory with the specified size. + +Well, if there's this `void` type, what's to stop us from just declaring everything as a `void` type? The drawback to the `void` type is that the compiler then can't infer much of anything about the data that a void pointer points to. It can't determine how much data a `void` pointer is pointing to, plus `void` pointers cannot be dereferenced until they are _cast_ (their type is changed) to a known type. Basically, it won't be able to provide us nearly as many compile-time protections as it can if we have all of our types declared. The moral of the story is that the `void` type should only be used when you actually do not know the type of the data up front. `malloc` returning a `void` pointer is a great use-case for this. + +Here are some pretty typical `malloc` calls: +```c + int *100_ints = malloc(100 * sizeof(int)); + + char *50_chars = malloc(51); +``` +The first `malloc` call allocates enough space for 100 ints. The `malloc` call initially returns a `void` pointer, but it then gets _cast_ to an `int` pointer on the left-hand side. You'll also note that we're using the `sizeof` operator in order to find the size of an individual integer, and then multiplying by the number of integers we're looking to store in order to get the total amount of memory we need. We have to do this because integers are not stored in a single byte, and integer sizes may fluctuate from platform to platform. + +With the second `malloc` call, you'll see we don't do that. We're still performing the cast to a `char` pointer, but there's no call to the `sizeof` operator. This is because `char`s each fit within a single byte, so 51 bytes will hold 51 `char`s, which is exactly what we want. Once we have a pointer to the `malloc`'d memory, we can work with it exactly how we've been working with pointers. + +So, we still need to know how much data we want to fit inside this chunk of `malloc`'d memory, which still isn't all that helpful since that's still a hefty limitation. There exist other library functions, such as `realloc`, which can receive a pointer to `malloc`d memory and then resize that chunk of memory, but for this module we're just going to stick with `malloc`. + +We'll talk about one of the main usages of `malloc` in the next module. + +## Working with Void Pointers Directly + +Getting a void pointer back from a `malloc` call isn't the only time we'll need to deal with void pointers. Sometimes we'll need to explicitly cast a void pointer that's already referring some data, unlike the chunk of memory we're getting back from `malloc` call, which starts off empty and uninitialized. + +A common use-case for void pointers is when we want to write a function that is generic over types, i.e., it doesn't care what the types of its inputs are. Let's assume we have the following function signature: + +```c +void foo(void *a, void *b); +``` + +Here, `foo` takes two void pointers, which will contain some data of a certain type, but `foo` either doesn't know what those types are or doesn't care. If we want to do something with these two void pointers though, we'll have to explicitly cast them to some actual type we can work with. We can do that like this: + +```c +char *cast_a = (char *) a; +char *cast_b = (char *) b; +``` + +Here we cast both void pointers to be char pointers. Note that this doesn't actually transform the data these two pointers point to, we aren't changing the underlying data's type. We just need to temporarily assign a concrete type to these pointers so that we can do something with them inside our `foo` function. + +We pick `char *`s here because the `char` type is guaranteed by the C specification to be one byte each. This is desirable because it's the most granular type we can pick. If we're going to be touching some memory and not treating as the type that it actually is, then to avoid any sort of memory corruption, we want to be as granular as possible when handling that underlying data, hence the usage or chars and not some other type. + + + + +</details><details> <summary>1-projects/Intro-to-C-master/pointers/</summary> + +### [1-projects/Intro-to-C-master/pointers/README.md](1-projects/Intro-to-C-master/pointers/README.md) +<!-- START doctoc generated TOC please keep comment here to allow auto update --> +<!-- DON'T EDIT THIS SECTION, INSTEAD RE-RUN doctoc TO UPDATE --> +**Table of Contents** *generated with [DocToc](https://github.com/thlorenz/doctoc)* + +- [Pointers](#pointers) + - [Differences between arrays and pointers](#differences-between-arrays-and-pointers) + - [Declaring pointers](#declaring-pointers) + - [Pointer Arithmetic](#pointer-arithmetic) + - [Use cases of pointers](#use-cases-of-pointers) + +<!-- END doctoc generated TOC please keep comment here to allow auto update --> + +# Pointers + +From the perspective of C, your entire computer is nothing more than a giant array of memory into which values can be written. Given this analogy, when we're dealing with arrays, how do we access some value stored inside of said array? + +We do it with indices that point to a specific spot in the array. As it turns out, pointers in C are simply just that: indices into the giant array of memory that is your computer. More formally, a pointer is a memory address that tells the program where to go and find some variable value. + +Those funky asterisks you might have seen already indicate a pointer (you might have heard them referred to as _references_ in other languages). Let's look at the function signature we had for the `reverse_string` function you wrote in the `strings` module: +```c +char *reverse_string(char s[]) +{ + ... +} +``` +The `char *` that is in the spot where the return type of the function usually goes is saying that this function will return a pointer to an array of characters. + +It turns out that pointers and arrays in C are very much interconnected, so much so that it's pretty difficult to separate the topic of pointers from arrays. Every pointer points to the first spot of a contiguous portion of memory, and as we've already established, C pretty much just treats your computer as a giant array of memory. + +Indeed, there are many similarities between how you work with arrays and how you work with pointers. However, let's first talk about the _differences_ between them. + +## Differences between arrays and pointers + +Even though C let's you work with pointers and arrays in many of the same ways, don't think of them as synonomous. C's `sizeof` operator allows us to find the size of something in bytes. Let's say for example we had the following array: +```c + int integers[] = { 9, 49, 1, 6, 10, 15 }; +``` +Calling `sizeof(integers)` gets us the total amount of data in the array. Then let's say we had a pointer to the same chunk of data: +```c + int *pointer_to_integers = integers; +``` +So we have an array named `integers` and a pointer called `pointer_to_integers` that points to the same spot in memory where the `integers` array is stored. If we were to call `sizeof(pointer_to_integers)`, we would actually get back the size of the pointer, not the size of the data it's pointing to. + +There are a few other such sorts of edge cases, but for the most part they're pretty nuanced. So while, again, you shouldn't be thinking of pointers being arrays and vice versa, you would interface with them in many of the same ways. + +## Declaring pointers + +As showcased above, declaring a pointer is as simple as putting an asterisk after the type declaration of a variable. This signifies that we have a pointer to the declared type with the specified name. + +```c +/* Declaring two ints x and y, and an int array z */ +int x = 1, y = 2, z[10]; +int *ip; /* ip is a pointer to an int */ + +ip = &x; /* ip now points to x */ +y = *ip; /* y is now 1 */ +*ip = 0; /* x is now 0 */ +ip = &z[0]; /* ip now points to z[0] */ +``` + +There's nothing new going on in the first two lines of this block. Starting at the third line with `ip = &x;`, we see the `&` operator. This means we're grabbing the _address_ of the variable `x`, or in other words, we're asking for the address where the value of `x` (`1` in this case) is being stored. We do this because `ip` is a pointer, which stores an address, not a value. If we did `ip = x;`, that would be saying "store the value of the variable x in the variable `ip`", which would not compile since we've declared `ip` to be an integer pointer, not an integer value. + +In the next line, `y = *ip`, note that when we use the `*` operator not in a declaration, it signifies that we're want to grab the _value_ of the operand. So we're saying "set the variable `y` to be the value of the pointer `ip`". Again, since `ip` is a pointer, it stores an address. When we prepend the `*` operator in front of a pointer, we're asking for the value that that pointer points to. Put another way, we're indexing into the giant array of memory that is our computer and asking for the value at the given index. + +Next we have `*ip = 0;`. Here we're setting the value that `ip` points at to be 0. Before this, `ip` pointed to whatever `x`'s value was, because of the line `ip = &x;`. So now that we changed the value at some address, any other variables or pointers that also referenced that same address also got changed! If we were to print out the value of the `x` variable now, it would be `0`! + +Lastly, we have `ip = &z[0];`, which declaring that `ip` now points to the first element of the `z` array. Again, we use the `&` operator in order to grab the _address_, not the _value_, of `z[0]`, since `ip` is a pointer that stores an address. + +## Pointer Arithmetic + +When we index into arrays in JavaScript, we can do things like: +```javascript + const someArray = []; + + for (let i = 0; i < array.length; i++) { + someArray[i] = array[i + 1]; + } +``` +We can index into arrays by performing arithmetic on the index. With pointers in C, we can do the exact same thing! + +Let's say we have a pointer to a string like so: +```c + char *str = "Some string"; +``` +We can loop through the characters in this string by doing this: +```c + while (*str != '\0') { + printf("%c", *str); + str++; + } +``` +This loop will print out each character in the string. Indeed, this loop is pretty much analogous to iterating through an array. More precisely though, on each iteration of this while loop, we're incrementing the spot the pointer points to by one. At the beginning of the loop, `*str` points to the first character in the string, `S`. Then, on the next iteration, it gets incremented and then prints out `o`. This keeps going until the pointer points to the null character, which terminates the loop. + +Armed with this knowledge regarding pointers and pointer arithmetic, we can rewrite the `reverse_string` function from the last module to use pointers instead of allocating additional memory for the reversed string. This has the added benefit of performing the reverse in-place. +```c + void *reverse_string(char *s) + { + char temp; + int n = string_length(s); + + for (int i = 0; i < n/2; i++) { + temp = s[i]; + s[i] = s[n-i-1]; + s[n-i-1] = temp; + } + } +``` + +## Use cases of pointers + +Lastly, let's talk a bit about why pointers are useful. The number 1 most important reason as to why pointers exists, the motivation for their invention in the first place, is that the C compiler needs every type to have a known size at compile time. This is a pretty big restriction, and it's one that comes with the territory of working in a strongly-typed language. + +But there's lots of data that we won't know the size of until runtime. What if we need to accept user input? How do we know the size of that input before the user even gives it to us? What if we need to add data to some data structure at runtime? These are all valid questions, and the workaround to them is pointers. + +We can not tell the compiler the size of certain types upfront, so what we do instead is use something of a known size to refer to things of unknown size. That is exactly what pointers are. They're a type with a known size that tells us how to access something of an unknown size. + +So whenever we need to hold something like a string or a data structure whose size depends on something that can only be known at runtime, you can bet such structures will be referred to by a pointer. + +A slightly related use case is passing by reference vs. passing by value when we're talking about passing parameters to functions. You've probably at least heard of these terms used in other languages. Passing by value means that we're passing a _copy_ of the value to a function as a parameter. This results in additional work and memory overhead, but means we have a fresh copy of the data to work with, which is desirable in certain scenarios. + +On the flip side, passing by reference means we're passing a pointer to the data. In other words, the function doesn't have access to the data itself, but it is able to find that data in memory via the passed-in pointer. There's no need to copy the data, but then that also means the function doesn't have exclusive access to the data either. + + + + + +</details><details> <summary>1-projects/Intro-to-C-master/quicksort/</summary> + +### [1-projects/Intro-to-C-master/quicksort/README.md](1-projects/Intro-to-C-master/quicksort/README.md) +<!-- START doctoc generated TOC please keep comment here to allow auto update --> +<!-- DON'T EDIT THIS SECTION, INSTEAD RE-RUN doctoc TO UPDATE --> +**Table of Contents** *generated with [DocToc](https://github.com/thlorenz/doctoc)* + +- [Quicksort](#quicksort) + +<!-- END doctoc generated TOC please keep comment here to allow auto update --> + +# Quicksort + +For this module, you're going to implement a quicksort function. Feel free to reference prior implementation(s) and simply transpose the code from one language to the other. Typically this is a good way to practice new languages you're trying to learn: by transposing code you've written from one language to another. + +In case you haven't seen the quicksort algorithm before, here's a Python implementation that you can use as a reference: +```python +def quicksort(alist, begin=0, end=None): + if end is None: + end = len(alist) - 1 + if begin < end: + pivot = partition(alist, begin, end) + quicksort(alist, begin, pivot-1) + quicksort(alist, pivot+1, end) + +def partition(alist, begin, end): + pivot = begin + + for i in range(begin+1, end+1): + if alist[i] <= alist[begin]: + pivot += 1 + alist[i], alist[pivot] = alist[pivot], alist[i] + + alist[pivot], alist[begin] = alist[begin], alist[pivot] + + return pivot +``` +Keep in mind that since Python is a higher-level language than C, it provides language features and constructs that aren't available in C. For example, the swapping syntax in Python isn't going to work in C without some additional work. The `swap` that you implemented earlier in the sprint has been included in this directory in the `lib.h` header file though, so you can use it here to swap values within an array in-place. Another Python language feature that you can't replicate in C are the default function parameters. + +Navigate to the `quicksort.c` file. Implement your quicksort algorithm, then type `make tests` to check if you have all the tests passing. + + + + +</details><details> <summary>1-projects/Intro-to-C-master/</summary> + +### [1-projects/Intro-to-C-master/README.md](1-projects/Intro-to-C-master/README.md) +<!-- START doctoc generated TOC please keep comment here to allow auto update --> +<!-- DON'T EDIT THIS SECTION, INSTEAD RE-RUN doctoc TO UPDATE --> +**Table of Contents** *generated with [DocToc](https://github.com/thlorenz/doctoc)* + +- [Introduction to the C Programming Language](#introduction-to-the-c-programming-language) + - [What you'll be doing in this sprint](#what-youll-be-doing-in-this-sprint) + - [Troubleshooting](#troubleshooting) + +<!-- END doctoc generated TOC please keep comment here to allow auto update --> + +# Introduction to the C Programming Language + +Welcome to your first C sprint! + +The two main goals of this sprint are as follows. The first goal is to give +students the experience of learning a different programming language. This is +important because it is _very_ rarely the case where you are familiar and +comfortable with all of the technologies/programming languages that you'll be +using on a job as a professional developer. Being able to pick up +languages/technologies you aren't familiar with is a skill that we want to +cultivate in students during their time here at Lambda, which is why we expose +students to both C and Python during their time here. + +The second goal is to start peeling away the layers of abstraction that students +are used to from working with JavaScript and Python. Indeed, when you boil it +all down, both JavaScript and Python are implemented in C in the first place! C +supports very few of the abstractions that students are used to, because C has +you working directly with the memory on your machine. Higher level languages +abstract this fact away from you, at the cost of raw performance and control. +Essentially, you're getting exposed to the nitty-gritty seedy underbelly of your +computer's inner workings, and being in such a place for extended periods of +time is not for everybody. + +That being said, we the instructors do believe that every developer needs to get +a taste of C in order to really be able to delve into the inner workings of how +exactly software communicates and interfaces with hardware. That's not really +something JavaScript or Python will expose you to. Additionally, once you get +acclimated to C, the language provides you with unparalleled control over how +your code gets executed on your machine. Some people find the sheer amount of +control that C provides you intoxicating. + +But before any of that happens, you've gotta get your feet wet with C. So without further ado, let's get started! + +## What you'll be doing in this sprint + +If you haven't gotten your C compiler up and running, please do that first. You'll find instructions on how to do that for your specific platform here: https://github.com/LambdaSchool/CS-Wiki/wiki/Getting-Your-C-Compiler-Installed. + +This sprint is structured very much like how your introductory JavaScript sprints are structured. There are independent modules, each with their own set of exercises that you'll be tasked with implementing. There's an associated set of tests for all the exercises in each module, which you'll run against your code to check to see if it behaves and functions correctly. The order in which you should tackle these exercises is this: + + - [ ] fizzbuzz + - [ ] strings + - [ ] pointers + - [ ] malloc + - [ ] structs + + **Stretch Goal Problems** + - [ ] queue + - [ ] quicksort + - [ ] hangman + +Inside a module directory, type `make tests` (just like with the `npm install` +command needing a `package.json` file, the `make` command requires a +`Makefile`), which will do a couple of things as specified by the `Makefile`. +These include compiling your source code inside that module, linking all of the +included header files and libraries, and running the tests for that module. Once +you've gotten all of the tests to pass for that module, move on to the next one. + +The code inside the `main` functions are for if you want to compile your file +into an executable for debugging purposes. You don't need to edit any of the +code in the `main` functions. Just type `make` to compile an executable. Then +type `./NAME_OF_EXECUTABLE` (not in caps) to run it, which will execute the code +inside that program's `main` function. + +## Troubleshooting + +For things that go wrong, check out the [troubleshooting](TROUBLESHOOTING.md) doc. + + + + + +</details><details> <summary>1-projects/Intro-to-C-master/strings/</summary> + +### [1-projects/Intro-to-C-master/strings/README.md](1-projects/Intro-to-C-master/strings/README.md) +<!-- START doctoc generated TOC please keep comment here to allow auto update --> +<!-- DON'T EDIT THIS SECTION, INSTEAD RE-RUN doctoc TO UPDATE --> +**Table of Contents** *generated with [DocToc](https://github.com/thlorenz/doctoc)* + +- [Arrays in C](#arrays-in-c) +- [Strings in C](#strings-in-c) + +<!-- END doctoc generated TOC please keep comment here to allow auto update --> + +# Arrays in C + +In C, arrays are nothing more than contiguous chunks in memory that store a _single_ type of data. Additionally, arrays are static in size, at least in their most basic form. That means that we'll typically need to know the size and/or the amount of data a particular array will be storing when we initialize it. Unlike in higher-level languages, we can't just simply declare an empty array and then start pushing elements onto it willy-nilly. + +If we wanted to declare an array of integers, we might do it like so: +```c + int int_array[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9 }; +``` +Note the syntax here. We need the square brackets after the array's name to indicate that it is an array to the compiler, and when we declare the initial values of the array, we surround them with curly braces, not square brackets. + +Another way we might declare an array is the following: +```c + int another_int_array[20]; +``` +With this, we've declared a statically-sized integer array that has space for 20 integers. There's nothing in it initially, but we can now start populating it with integers (and only integers) up to it's specified capacity. +```c + int n = 20 / sizeof(int); + + for (int i = 0; i < n; i++) { + another_int_array[i] = i; + } +``` +While we allocated 20 bytes worth of space into the array, keep in mind that a single integer actually takes up more than a single byte of space in memory. To get around this, we can use the `sizeof` operator to find out exactly how many bytes a single `int` occupies on your machine, and then divide the array capacity by that to get the actual number of integers that can fit inside the array. + +If we try to add more integers than the array has capacity for, we'll get a segmentation fault error, which means we've tried to access memory we don't have permission to access. That's what happens when we go outside of an array's bounds. + +We'll talk later on about how to handle dynamically-sized data. + +# Strings in C + +So what do arrays have to do with strings? Everything, as it turns out. Strings in C are actually nothing more than arrays of characters. In fact, when declaring a string, you might do it like this: +```c + char[] = "Hello world!"; +``` +Under the hood, this declaration becomes +```c + char[] = { 'H', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd', '!', '\0' }; +``` +The `\0` character at the end represents the null character; _every_ C string is terminated with one of these, and in fact, if you wanted to write a function to find the number of characters in a string, you'd basically just loop through the character array and increment a counter until you found the `\0` character. + +IMPORTANT NOTE: So far, every language you've worked in has not differentiated between single and double quotes. In C, these actually make a difference. Single quotes delineate a single character, while double quotes delineate string literals. So for example, `"a"` is a string literal complete with a terminating null character at the end of it, as opposed to `'a'` which is just the individual character. + +The compiler _will_ yell at you if you try to store multiple characters in single quotes. + + + + + +</details><details> <summary>1-projects/Intro-to-C-master/structs/</summary> + +### [1-projects/Intro-to-C-master/structs/README.md](1-projects/Intro-to-C-master/structs/README.md) +<!-- START doctoc generated TOC please keep comment here to allow auto update --> +<!-- DON'T EDIT THIS SECTION, INSTEAD RE-RUN doctoc TO UPDATE --> +**Table of Contents** *generated with [DocToc](https://github.com/thlorenz/doctoc)* + +- [Structs](#structs) + - [Initializing structs](#initializing-structs) + - [Freeing memory](#freeing-memory) + - [The `typedef` Keyword](#the-typedef-keyword) + +<!-- END doctoc generated TOC please keep comment here to allow auto update --> + +# Structs + +Another limitation that exists in C that we haven't brought up yet is the fact that arrays in C can only hold a single type of data. Being able to stick any type of data all into the same array is a feature that you probably take for granted coming from JavaScript. Well, you can't do that in C! + +Enter structs. Structs are basically C's version of a poor man's object. We can store values of different types inside a struct, which is awesome, but we need to declare the types of the fields that the struct can hold up front. That being said, structs are instrumental when it comes to implementing data structures and more complex types in C. + +## Initializing structs + +Let's look at a simple struct definition: + +```c + struct Cat { + char *breed; + char *color; + int age; + }; +``` +This declares the shape of the Cat struct. Now we'll need to create an instance of it if we want to want to actually use it. Well, what actually defines an instance of something? + +In this case, an instance of a struct is some chunk of memory that has been initialized with the shape of said struct. So we'll need to allocate memory for our Cat struct. We can do that with this: + +```c + struct Cat *a_cat = malloc(sizeof(struct Cat)); +``` +So we're handed a pointer to a chunk of memory that holds exactly the right amount of data for a single instance of a Cat. We take that and cast it to a pointer with the type of `struct Cat` since that's the type that is being held in this chunk of memory. We'll also need to go and initialize the values of our Cat instance like so: + +```c + a_cat->breed = NULL; + a_cat->color = NULL; + a_cat->age = 0; +``` +What's with these funky arrows? Coming from JavaScript, you're used to using dot notation for accessing members of an object. Structs are poor man's objects, so shouldn't dot notation work here? + +The answer is that dot notation is a thing in C, but because in this case we have a _pointer_ to a struct, we need to perform a dereference first in order to get to the actual data the struct contains. That's what the arrow syntax does. It performs a dereference first and then accesses the struct member. + +Basically, you can think of it like this: +```c + a_cat->breed == (*a_cat).breed +``` + +Allocating memory for structs is one of the most important functions that `malloc` serves. Keep in mind though that when we declare a struct, every type in the struct needs to have a known size. Looking at the Cat struct, `char *`s and `int`s all have a known size, so the entire size of the struct can be calculated. However, we don't know the sizes of the data that the `char *`s may be pointing to. + +Let's say we have a function called `name_cat` that will assign a Cat instance with a given input name. It might look like this: + +```c + void name_cat(struct Cat *cat, char *name) + { + int name_length = string_length(name); + + cat->name = malloc(name_length); + string_copy(cat->name, name); + } +``` +That's right, we'll need to call `malloc` to allocate the appropriate amount of memory to the `cat->name` field, and then we can call `string_copy` in order to copy each character in the input `name` string to the memory that `cat->name` now points to. + +## Freeing memory + +Yet another abstraction that you're used to from higher-level languages is the garbage collector. A garbage collector is typically part of a languages runtime, and its job is to clean up memory that is used up by your programs. + +For example, after you write some JS program that has a bunch of arrays and objects, what happens to the memory that was needed to order to hold those instances? In a high-level language, a garbage collector goes through and figures out that those arrays and objects are no longer being used. It then deallocates or frees up that memory so that it can be reused by other programs. You the programmer never needs to worry about cleaning up after yourself; it's all handled for you automatically! + +C doesn't baby you around like that. It expects _you_ to handle the clean up like the grown up you are. Learning to clean up after yourself can get difficult when you're writing more advanced programs in C. For simple programs though, it can be as simple as calling the function `free` after you're done with some piece of `malloc`'d memory. + +The `free` function receives a pointer that points to a piece of `malloc`'d memory, and it deallocates it so that that memory may be re-used. As you can imagine, once some `malloc`'d memory has been `free`'d, whatever data was in that chunk of memory is gone, so make sure you're done with the data before `free`ing it! + +Let's codify this into a simple heuristic that isn't too hard to memorize: +> For every call to `malloc` there should be an accompanying call to `free`. + +A couple of common errors that arise when it comes to `free`ing memory are: +1. Forgetting to call `free` on some `malloc`'d piece of memory. This is a problem because that memory doesn't get cleaned up, and you end up with what's called a 'memory leak'. A single memory leak isn't the end of the world, but if you continually forget to `free` your memory, they'll start to pile up and waste precious memory resources that could be used by other programs that actually need that memory. +2. Calling `free` on a pointer to memory that has already been `free`'d. This is called a 'double free', and it should be avoided because it may corrupt the state of the memory manager (which is what keeps track of all of the pieces of memory that have been handed out so far), which might cause existing blocks of memory to get corrupted or for future allocations to fail in bizarre ways (for example, the same memory getting handed out on two different successive calls of malloc). + +Going back to our Cat struct, we might want to have a `Cat_destroy` function that will handle the cleaning up of a Cat instance for us. It'll free all the memory that was allocated during the Cat instance's lifetime. + +```c + void Cat_destroy(struct Cat *cat) + { + if (cat->name != NULL) { + free(cat->name); + } + + if (cat->breed != NULL) { + free(cat->breed); + } + + if (cat != NULL) { + free(cat); + } + } +``` + +## The `typedef` Keyword + +In all the previous example code, we've had to prepend every type we created with `struct`. That's because `struct` is part of the newly-created type's name, and as of now, we can't leave it out whenever we're using one of our own artificial types. C provides the `typdef` keyword which will ultimately save us some keystrokes. It will allow us to not have to prepend `struct` to any of our created types. Here's how we use it: + +```c + typedef struct Cat { + char *breed; + char *color; + int age; + } Cat; +``` + +We'll add the `typedef` keyword in front of our type definition. Then, after the closing brace of our struct, we specify the aliased type we'd like for this user-created type to have. Here we'll just keep it the same as the name of the struct itself, though you could call it something else if you wanted to. + +Now, whenever we want to use our `Cat` type, we don't need to prepend `struct` in front of it. The compiler now knows that when we just specify `Cat` that we're referring to our `struct Cat` type definition. It's a one-time cost that we pay when we define our types, but it'll save us a lot of keystrokes later on, especially if we're using our types a lot! + + + + +</details><details> <summary>1-projects/Intro-to-C-master/</summary> + +### [1-projects/Intro-to-C-master/TROUBLESHOOTING.md](1-projects/Intro-to-C-master/TROUBLESHOOTING.md) +<!-- START doctoc generated TOC please keep comment here to allow auto update --> +<!-- DON'T EDIT THIS SECTION, INSTEAD RE-RUN doctoc TO UPDATE --> +**Table of Contents** *generated with [DocToc](https://github.com/thlorenz/doctoc)* + +- [`runtests.sh: 4: Syntax error: word unexpected (expecting "do")`](#runtestssh-4-syntax-error-word-unexpected-expecting-do) +- [Mac: `malformed object` error when running `make tests`](#mac-malformed-object-error-when-running-make-tests) + +<!-- END doctoc generated TOC please keep comment here to allow auto update --> + +## `runtests.sh: 4: Syntax error: word unexpected (expecting "do")` + +_Chief. Windows_ + +If you see this error: + + ``` + Running unit tests: + : not foundtests.sh: 2: ./tests/runtests.sh: + ./tests/runtests.sh: 4: ./tests/runtests.sh: Syntax error: word unexpected (expecting "do") + ``` + + You have two options: + + 1. Open the file `tests/runtests.sh` in VS Code in whatever subproject folder + you're working in, e.g. `fizzbuzz`. Click on the lower right of the screen + where it says `CRLF`. Choose `LF`. Save the file. Then the error should go + away. + + 2. You can do this from the command line with the `tr` command: + + ``` + cd tests + cat runtests.sh | tr -d '\r' > runtests.tmp + mv runtests.tmp runtests.sh + ``` + + The root of the problem is a setting in git that causes all newlines (LF) to + be converted to carriage-return/newline (CRLF). The script `runtests.sh` is a + _bash script_ that bash runs, and bash *hates* `\r` and pukes everywhere. + + To cause git to _not_ do newline conversion for future clones, run the + following: + + ``` + git config --global core.autocrlf false + ``` + +## Mac: `malformed object` error when running `make tests` + +This is caused by an older version of the `ar` and `ranlib` packages being installed. +Sometimes these conflict with the versions installed with xcode. + +If running MacPorts: + +``` +sudo port selfupdate +sudo port upgrade cctools +``` + +If running Brew: + +``` +sudo brew update +sudo brew upgrade gcc +``` + + + + + +</details><details> <summary>1-projects/JavaScript-III-master/</summary> + +### [1-projects/JavaScript-III-master/README.md](1-projects/JavaScript-III-master/README.md) +<!-- START doctoc generated TOC please keep comment here to allow auto update --> +<!-- DON'T EDIT THIS SECTION, INSTEAD RE-RUN doctoc TO UPDATE --> +**Table of Contents** *generated with [DocToc](https://github.com/thlorenz/doctoc)* + +- [JavaScript - III](#javascript---iii) + - [Set Up The Project With Git](#set-up-the-project-with-git) + - [Assignment Set Up](#assignment-set-up) + - [The `this` keyword](#the-this-keyword) + - [Prototype](#prototype) + +<!-- END doctoc generated TOC please keep comment here to allow auto update --> + +# JavaScript - III + +This challenge focuses on using the `this` keyword as well as getting comfortable with prototypes by building out a fantasy themed video game. + +## Set Up The Project With Git + +**Follow these steps to set up and work on your project:** + +* [ ] Create a forked copy of this project. +* [ ] Add your project manager as collaborator on Github. +* [ ] Clone your OWN version of the repository (Not Lambda's by mistake!). +* [ ] Create a new branch: git checkout -b `<firstName-lastName>`. +* [ ] Implement the project on your newly created `<firstName-lastName>` branch, committing changes regularly. +* [ ] Push commits: git push origin `<firstName-lastName>`. + +**Follow these steps for completing your project.** + +* [ ] Submit a Pull-Request to merge <firstName-lastName> Branch into master (student's Repo). **Please don't merge your own pull request** +* [ ] Add your project manager as a reviewer on the pull-request +* [ ] Your project manager will count the project as complete by merging the branch back into master. + +## Assignment Set Up + +* Complete all the exercises as described inside each assignment file. +* To test your `console.log()` statements, open up the index.html file found in the assignments folder and use the developer tools to view the console. + +## The `this` keyword + +Having a solid understanding of how `this` works will give you a huge advantage when you start building with more advanced frameworks. Use the [this.js](assignments/this.js) file to traverse through a few `this` problems. + +## Prototype + +The prototype challenge will focus on building prototypes for a fantasy themed game that includes mages, swordsmen, and archers. Follow the [prototypes.js](assignments/this.js) instructions closely to create the beginnings of what could be an awesome JavaScript game. + +* Read the instructions found within the file carefully to finish the challenges. +* Remember to un-comment the objects and console logs to test your work at the bottom of the page. + + + + + +</details><details> <summary>1-projects/JS-Exercise-Classes/</summary> + +### [1-projects/JS-Exercise-Classes/README.md](1-projects/JS-Exercise-Classes/README.md) +<!-- START doctoc generated TOC please keep comment here to allow auto update --> +<!-- DON'T EDIT THIS SECTION, INSTEAD RE-RUN doctoc TO UPDATE --> +**Table of Contents** *generated with [DocToc](https://github.com/thlorenz/doctoc)* + +- [The _class_ Syntax](#the-_class_-syntax) + - [Index](#index) + - [Instructions](#instructions) + - [Get Started](#get-started) + +<!-- END doctoc generated TOC please keep comment here to allow auto update --> + +# The _class_ Syntax + +This challenge focuses on using the new for ES6 `class` syntax. + +##### Index + +* [Instructions](#instructions) +* [Get Started](#get-started) + +## Instructions + +Find the file `index.js` and complete the tasks until all of your tests pass. + +**You can use yesterday's work to help you.** However, if you struggled a lot with that assignment, it is recommended that you attempt to re-write all code without "cheating" (peeking at yesterday's code or copy-pasting it). + +**Plan to commit & push every time you get a new test passing!**. Committing often makes it SO much easier to figure out "what broke my code", and helps your TL keep track of how you're doing. + +If you run into trouble while coding, fight the good fight for 20 minutes and then get on the help channel. __Remember to formulate your help request in a professional manner__ - like you would at the job - by including error messages, screenshots, and any other pertinent information about the problem, as well as what things you have attempted already while trying to solve it. + +## Get Started + +<summary><strong>Using VSCode and the Command Line:</strong></summary> + +1. Fork repo and add TL as collaborator on Github. +1. Clone _your_ fork (not Lambda's repo by mistake!). +1. `cd` into your newly cloned repository. +1. Create a new branch by typing `git checkout -b <firstName-lastName>`. +1. Install dependencies by typing `npm install`. +1. Run tests by typing `npm run test:watch`. +1. Work on your branch, push commits and create PR as usual. + +<img alt='instructions screenshot' src='./instructions.png'> + + + + + +</details><details> <summary>1-projects/LS-Data-Structures-I-Solution-master/</summary> + +### [1-projects/LS-Data-Structures-I-Solution-master/README.md](1-projects/LS-Data-Structures-I-Solution-master/README.md) +<!-- START doctoc generated TOC please keep comment here to allow auto update --> +<!-- DON'T EDIT THIS SECTION, INSTEAD RE-RUN doctoc TO UPDATE --> +**Table of Contents** *generated with [DocToc](https://github.com/thlorenz/doctoc)* + +- [Data Structures I](#data-structures-i) + - [Stacks](#stacks) + - [Queues](#queues) + - [Linked Lists](#linked-lists) + - [Hash Tables](#hash-tables) + - [Extra Credit](#extra-credit) + +<!-- END doctoc generated TOC please keep comment here to allow auto update --> + +# Data Structures I + +Topics: + + * Big-O Notation (Complexity analysis) + * Stacks + * Queues + * Linked Lists + * Hash Tables + + + +#### Stacks + + * Should have the methods: `add`, `remove`, and a getter for the property `size` + * `add` should accept a value and place it on top of the stack. + * `remove` should remove and return the top value off of the stack. + * `size` should return how many items are on the stack. + +#### Queues + + * Should have the methods: `enqueue`, `dequeue`, and a getter for the property `size` + * `enqueue` should add an item to the back of the queue. + * `dequeue` should remove an item from the front of the queue. + * `size` should return the number of items in the queue. + +#### Linked Lists + + * Should have the methods: `addToTail`, `removeHead`, and `contains`. + * `addToTail` replaces the tail with a new value that is passed in. + * `removeHead` removes and returns the head node. + * `contains` should searth through the linked list and return true if a matching value is found. + * The `head` property is a reference to the first node and the `tail` property is a reference to the last node. These are the only two properties that you need to keep track of an infinite number of nodes. Build your nodes with objects. + +#### Hash Tables + + * Should have the methods: `insert`, `remove`, and `retrieve`. + * `insert` should take a key value pair and add the value to the hash table. + * `retrieve` should return the value associated with a key. + * `remove` should removed the given key's value from the hash table. + * Should properly handle collisions. If two keys map to the same index in the storage table then you should store a 2d array as the value. Make each key/value pair its own array that is nested inside of the array stored at that index on the table. + +### Extra Credit + + * Uncomment the final test in `hash-table.test.js` and make the hash-table rebalance. As a hash table increases in size the associated storage table will typically double in size once it reaches a certain capacity. Change the hash table so that it doubles the size of the storage table once it is 75% full. + * If you used arrays as your underlying data structure for implementing stacks, queues, and hash table buckets, convert these to use linked lists instead as the underlying data structure. If you started off with linked lists, convert these to use arrays. In order to do this, you'll need to export your linked list implementation by wrapping it inside a `module.exports`. Just comment out your initial implementation; don't delete perfectly good code! + * Make your linked list implementation a [doubly linked list](https://en.wikipedia.org/wiki/Doubly_linked_list). + + + + + +</details><details> <summary>1-projects/LS-Data-Structures-II-Solution-master/</summary> + +### [1-projects/LS-Data-Structures-II-Solution-master/README.md](1-projects/LS-Data-Structures-II-Solution-master/README.md) +<!-- START doctoc generated TOC please keep comment here to allow auto update --> +<!-- DON'T EDIT THIS SECTION, INSTEAD RE-RUN doctoc TO UPDATE --> +**Table of Contents** *generated with [DocToc](https://github.com/thlorenz/doctoc)* + +- [Data Structures II](#data-structures-ii) + - [Trees](#trees) + - [Binary Search Tree](#binary-search-tree) + - [Graphs](#graphs) + - [Extra Credit](#extra-credit) + +<!-- END doctoc generated TOC please keep comment here to allow auto update --> + +# Data Structures II + +Topics: + + * Tree + * Graph + * Binary Search Tree + + +#### Trees + + * Should have the methods: `addChild`, and `contains` + * Each node on the tree should have a `value` property and a `children` array. + * `addChild(value)` should accept a value and add it to that node's `children` array. + * `contains(value)` should return `true` if the tree or its children the given value. + * When you add nodes to the `children` array use `new Tree(value)` to create the node. + * You can instantiate the `Tree` class inside of itself. + +#### Binary Search Tree + + * Should have the methods: `insert`, `contains`, `depthFirstForEach`, and `breadthFirstForEach`. + * `insert(value)` inserts the new value at the correct location in the tree. + * `contains(value)` searches the tree and returns `true` if the the tree contains the specified value. + * `depthFirstForEach(cb)` should iterate over the tree using DFS and passes each node of the tree to the given callback function. + * `breadthFirstForEach(cb)` should iterate over the tree using BFS and passes each node of the tree to the given callback function (hint: you'll need to either re-implement or import a queue data structure for this). + +#### Graphs + + * Should have methods named `addNode`, `contains`, `removeNode`, `addEdge`, `getEdge`, and `removeEdge` + * `addNode(newNode, toNode)` should add a new item to the graph. If `toNode` is given then the new node should share an edge with an existing node `toNode`. + * `contains(value)` should return true if the graph contains the given value. + * `removeNode(value)` should remove the specified value from the graph. + * `addEdge(fromNode, toNode)` should add an edge between the two specified nodes. + * `getEdge(fromNode, toNode)` should return `true` if an edge exists between the two specified graph nodes. + * `removeEdge(fromNode, toNode)` should remove the edge between the two specified nodes. + + +### Extra Credit + + * Add a method to the `Graph` class that searches through the graph using edges. Make this search first as a depth first search and then refactor to a breadth first search. + * Read up on [heaps](https://en.wikipedia.org/wiki/Heap_(data_structure)) here. Then implement one! + * Read up on [red-black trees](https://en.wikipedia.org/wiki/Red%E2%80%93black_tree) here. Then implement one! + + + + + +</details><details> <summary>1-projects/master/</summary> + +### [1-projects/master/README.md](1-projects/master/README.md) +<!-- START doctoc generated TOC please keep comment here to allow auto update --> +<!-- DON'T EDIT THIS SECTION, INSTEAD RE-RUN doctoc TO UPDATE --> +**Table of Contents** *generated with [DocToc](https://github.com/thlorenz/doctoc)* + +- [Git for Web Development Project](#git-for-web-development-project) + - [Task 1: Set up Project](#task-1-set-up-project) + - [Task 2: MVP](#task-2-mvp) + - [Task 3: Stretch](#task-3-stretch) + +<!-- END doctoc generated TOC please keep comment here to allow auto update --> + +# Git for Web Development Project +In this project you will be using the concepts learned in the Git for Web Development lesson to fork/clone/push/and submit a PR for each project during this sprint. + +This project consists of two parts: + +## Task 1: Set up Project +You will need to follow the Lambda School Git Workflow to add a file to this project follow the steps below: + +- [ ] Create your own version of this repo - Fork +- [ ] Clone this repo +- [ ] Create a branch `git checkout -b 'firstName-lastName'` + - [ ] Add a file to the project called `yourFirstName-yourLastName`.txt. This should contain the link to your completed codepen from part 2 as well as the review questions/answers + - [ ] Run your usual git commands for adding/committing and pushing **Be sure to push to your branch!** +- [ ] Create a Pull-Request to submit your work + - [ ] Use your own student fork as the base (compare across forks, base-fork -> main). + + +## Task 2: MVP +1. fork this codepen https://codepen.io/BritHemming/pen/eYYEoPa?editors=1100 +2. You will be marking up all of the HTML and styling it to look like this: https://codepen.io/BritHemming/full/jONmxOm using CSS +* this should be review from yesterday/ extra practice +3. After you are finished please copy the review questions into your .txt file and answer them +4. don't forget to add, commit and push your changes. + + +## Task 3: Stretch +Stretch Review questions: + 1. What is the difference between an inline element and a block element? + 2. What happens when an element is positioned absolutely? + 3. How do I make an element take up only the amount of space it needs but also have the ability to give it a width? + 4. Name 3 elements that are display block by default, 2 elements that are display inline by default, and 1 element that is display inline-block by default + 5. In your own words, explain the box model. What is the fix for the box model? +Stretch Git Tasks +- [ ] While the processes learned here will set you up to be successful in most situations, they are just the tip of the iceberg in learning Git. Independently research the following topics to learn more about Git. + - [ ] Research and understand what a `merge conflict` is and how to resolve it. + - [ ] Research the Git commands `pull`, `rebase`, `merge`. These commands will allow you to bring in changes that other developers push to the main branch. + - [ ] Research the Git commands `reset `, `revert`, `clean`. These commands will allow you to go back and amends previous commits you have made. + +- [ ] Research and set up a Graphical User Interface (GUI) Git console. + +- [ ] Research and setup SSH keys with GitHub, so that you do not need to input your username/password each time you push. + + + + + + + +</details><details> <summary>1-projects/Mongo-Mini-II-Solution-master/</summary> + +### [1-projects/Mongo-Mini-II-Solution-master/README.md](1-projects/Mongo-Mini-II-Solution-master/README.md) +<!-- START doctoc generated TOC please keep comment here to allow auto update --> +<!-- DON'T EDIT THIS SECTION, INSTEAD RE-RUN doctoc TO UPDATE --> +**Table of Contents** *generated with [DocToc](https://github.com/thlorenz/doctoc)* + +- [Mongo II Mini](#mongo-ii-mini) + - [Topics To Cover](#topics-to-cover) + - [Running the Project](#running-the-project) + - [Mongoose Schema](#mongoose-schema) + - [Todos:](#todos) + - [Extra Credit:](#extra-credit) + +<!-- END doctoc generated TOC please keep comment here to allow auto update --> + +# Mongo II Mini + +## Topics To Cover +* Schema Types + * [String, Number, Buffer, Date, Boolean, Mixed, ObjectId, Array](http://mongoosejs.com/docs/schematypes.html) +* [$ne](https://docs.mongodb.com/v3.2/reference/operator/query/ne/) +* [$and](https://docs.mongodb.com/v3.2/reference/operator/query/and/index.html) +* [$or](https://docs.mongodb.com/v3.2/reference/operator/query/or/index.html) +* [$in](https://docs.mongodb.com/v3.2/reference/operator/query/in/#op._S_in) +* [$gt](https://docs.mongodb.com/v3.2/reference/operator/query/gt/) +* [$sum](https://docs.mongodb.com/v3.2/reference/operator/aggregation/sum/index.html) +* [$orderby](https://docs.mongodb.com/v3.2/reference/operator/meta/orderby/index.html) +* [count](https://docs.mongodb.com/v3.2/reference/command/count/index.html) + + +## Running the Project + +* `cd` into your project directory. +* `npm install` to receive your dependencies. +* fire up your `mongod` server from your root dir or create a `data` dir in this project to store your documents from mongo there. `mongod --dbpath data`. + +### Mongoose Schema +* When you open `models.js` you'll see we've already included your Schema. You're welcome. +* You'll also notice that this sprint comes with a `people.json` file, and a `populateDbScript.js`. this script will grab those `people` and add them into your db as long as you have your mongo server up and running. +* RUN: `node populateDbScript.js` get receive all your data. + +### Todos: +* write a `GET` request to `/users` that simply returns all the people. +* write a `GET` request to `/users/:direction` that takes the given string and returns back a list of sorted data alphebetically. + * hint direction can be `asc` or `desc` so in your `.sort()` method you'll have to conditionally check, and we are going to be sorting by user `firstName` +* write a `GET` request `/user-get-friends/:id` that returns a single users's friends. +### Extra Credit: +* lastly write a `PUT` that updates a users `firstName` `lastName` + + + + +</details><details> <summary>1-projects/nested-data-exercises-master/</summary> + +### [1-projects/nested-data-exercises-master/README.md](1-projects/nested-data-exercises-master/README.md) +<!-- START doctoc generated TOC please keep comment here to allow auto update --> +<!-- DON'T EDIT THIS SECTION, INSTEAD RE-RUN doctoc TO UPDATE --> +**Table of Contents** *generated with [DocToc](https://github.com/thlorenz/doctoc)* + +- [Nested Data Exercises](#nested-data-exercises) + - [💪 10+ Practice Challenges: Nested `Objects` & `Arrays`](#-10-practice-challenges-nested-objects--arrays) + - [Index](#index) + - [Instructions](#instructions) + - [Stretch](#stretch) + - [Get Started](#get-started) + - [Data](#data) + - [Hints](#hints) + - [Helpful tips & reminders 🔎](#helpful-tips--reminders-) + +<!-- END doctoc generated TOC please keep comment here to allow auto update --> + +# Nested Data Exercises + +### 💪 10+ Practice Challenges: Nested `Objects` & `Arrays` + +This challenge will test your ability to work with nested Objects and Arrays. + +Uses [real-world 'inspired' data.](#data) + +> If you are experienced on this topic, expand the ["💡 Challenge Yourself!" section](#stretch) (following the instructions.) + +##### Index + +* [Instructions](#instructions) +* [Get Started](#get-started) +* Preview Test [Data](#data) +* Stuck? Check [Hints](#hints) + +## Instructions + +**Task:** Complete the 10+ functions in [`index.js`](./index.js) and pass all tests specified in [`test/index.test.js`](./test/index.test.js) ✅ + +The difficulty increases as you progress. + +> Before you begin coding, review [test data below](#data) + +1. `getName(character)` -> `Luke Skywalker` +1. `getFilmCount(character)` -> 5 +1. `getFirstStarshipName(character)` -> `X-wing` +1. `getSummary(character)` -> `Luke Skywalker, 172cm, 77kg. Featured in 5 films.` +1. `getVehiclesCostInCreditsSumTotal(character)` -> 8000 +1. `getStarshipPassengerAndCrewSumTotal(character)` -> 27 +1. `getNthFilm(character, filmNumber)` filmNumber=1 -> `A New Hope` +1. `getCargoCapacityTotal(character)` -> 80124 +1. `getFastestStarshipName(character)` -> `X-wing` +1. `getLargestCargoStarshipModelName(character)` -> `Lambda-class T-4a shuttle` +1. `getSlowestVehicleOrStarshipName(character)` -> `Imperial Speeder Bike` + + +### Stretch + +<details> + <summary> 💡 Challenge Yourself! (expand for stretch tips) </summary> + +* Research & use different patterns. (Destructuring, move common code into reusable helper methods, functional programming techniques) +* Trade completed code with a peer: + * Pair program: Take turns (30-60 min.) working through a refactor. Talk through & optimize as needed. + * Trade code for feedback! (Example format: 3&1, 3 things that you liked and 1 to improve.) +* Time yourself. See if you can beat your own time *starting over.* **Speed run!** +* See how many tests you can pass/complete before Googling or asking for help. +* When you're finished, refactor & improve readability. Write up why it is improved. + +</details> + + +## Get Started + +3 options are included below. + +The CodeSandbox option is fast & highly recommended. + +**1. Fastest Option** + +[LAUNCH ON CODESANDBOX 🚀](https://codesandbox.io/s/github/justsml/nested-data-exercises?previewwindow=tests) + + +<details> + <summary>2. Local Setup Instructions: From Command Line</summary> + +1. Fork & clone to your local computer +1. `cd` into your newly cloned repository +1. Install using `npm` +1. Run test command + + +```sh +git clone <insert your git clone url here> +cd <repo folder name> +npm install +npm run test:watch +##### +### Or without fs watching: +# npm test +``` + +**NOTE:** In local development, use the file watcher command: `npm run test:watch`. + +</details> + +<details> + <summary>3. Local Setup Instructions: Run Tests in Browser</summary> + +1. Fork & clone to your local computer +1. `cd` into your newly cloned repository +1. Install and Start using `npm` + +```sh +git clone <insert your git clone url here> +cd <repo folder name> +npm install +npm start +``` + +</details> + + + +## Data + +Example data your code will be tested against. + +```js +// Complete Test Data Object (credit: https://SWAPI.co) +// Side note: Yes Star Wars 🤓 purists. It's a bit out of date. Talk to SWAPI about it. +// Focus & follow instructions above. 🤖 +{ + "name": "Luke Skywalker", + "height": "172", + "mass": "77", + "hair_color": "blond", + "skin_color": "fair", + "eye_color": "blue", + "birth_year": "19BBY", + "homeworld": "Tatooine", + "films": [ + "A New Hope", + "The Empire Strikes Back", + "Return of the Jedi", + "Revenge of the Sith", + "The Force Awakens" + ], + "species": [ + "Human" + ], + "vehicles": [ + { + "name": "Snowspeeder", + "model": "t-47 airspeeder", + "manufacturer": "Incom corporation", + "cost_in_credits": null, + "length": "4.5", + "max_atmosphering_speed": "650", + "crew": 2, + "passengers": 0, + "cargo_capacity": "10" + }, + { + "name": "Imperial Speeder Bike", + "model": "74-Z speeder bike", + "manufacturer": "Aratech Repulsor Company", + "cost_in_credits": "8000", + "length": "3", + "max_atmosphering_speed": "360", + "crew": 1, + "passengers": 1, + "cargo_capacity": "4" + } + ], + "starships": [ + { + "name": "X-wing", + "model": "T-65 X-wing", + "manufacturer": "Incom Corporation", + "cost_in_credits": 149999, + "length": "12.5", + "max_atmosphering_speed": "1050", + "crew": 1, + "passengers": 0, + "cargo_capacity": "110", + "consumables": "1 week", + "hyperdrive_rating": "1.0", + "MGLT": "100", + "starship_class": "Starfighter" + }, + { + "name": "Imperial shuttle", + "model": "Lambda-class T-4a shuttle", + "manufacturer": "Sienar Fleet Systems", + "cost_in_credits": 240000, + "length": "20", + "max_atmosphering_speed": "850", + "crew": 6, + "passengers": 20, + "cargo_capacity": "80000", + "consumables": "2 months", + "hyperdrive_rating": "1.0", + "MGLT": "50", + "starship_class": "Armed government transport" + } + ], + "created": "2014-12-09T13:50:51.644000Z", + "edited": "2014-12-20T21:17:56.891000Z", + "url": "https://swapi.co/api/people/1/" +} +``` + + + +## Hints + +#### Helpful tips & reminders 🔎 + +* **Critical:** Don't make assumptions about input data types. (Convert/handle `Numbers` & `null`) + * Convert **number strings** into **actual numbers** with built-in functions `parseInt`, `parseFloat`, `Number`, etc. +* Ensure your functions **`return somethingUseful`.** +* Make sure you understand the requirements. All the words used? Try list the steps in comments first. +* Don't forget the source data uses `snake_case` naming. +* Pay close attention to array vs. object syntax (`vehicles[0].name` vs. `character.vehicles`.) +* Some of the functions include detailed instructions. +* You might have to infer the desired fields. Carefully read the description and function name (description included above the function.) + + + + + + +</details><details> <summary>1-projects/Node-Express-Gmaps-Solution-Day-I-master/</summary> + +### [1-projects/Node-Express-Gmaps-Solution-Day-I-master/README.md](1-projects/Node-Express-Gmaps-Solution-Day-I-master/README.md) +<!-- START doctoc generated TOC please keep comment here to allow auto update --> +<!-- DON'T EDIT THIS SECTION, INSTEAD RE-RUN doctoc TO UPDATE --> +**Table of Contents** *generated with [DocToc](https://github.com/thlorenz/doctoc)* + +- [Node-Express-Gmaps](#node-express-gmaps) + - [Objectives](#objectives) + - [Beginning Project](#beginning-project) + - [Project Description](#project-description) + - [Project Requirements](#project-requirements) + - [Stretch Problem](#stretch-problem) + - [Resources](#resources) + +<!-- END doctoc generated TOC please keep comment here to allow auto update --> + +# Node-Express-Gmaps + +Topics: + * APIs + * API Documentation + * Rate Limits + * Multiple requests + +## Objectives + * Create endpoints + * Make multpile requests to third-party API + * Return result + +## Beginning Project + * You will notice there is a config file that is ignored in the .gitignore, which you will be using to store your API key. You will need to import that key into your server file. DO NOT store it anywhere that will get pushed up to your repo. + * Everything else you will start from scratch. + +## Project Description + * You will be using the Google Maps Place API to get details about any place provided by the user of your API. When the user provides you a query (example: `coffee+shops+in+Austin`) you will use that query to make a request to the `Place Search` service, and will specifically be doing a `Text Search Request`. You will use the necessary information from the data returned from that first request, and then do a request to `Place Details` service, returning the detailed information to the user of your API. + +## Project Requirements + * Create an endpoint `/place` that, provided a query, returns the detailed information about the first place that is in the array of places returned to you from `Place Search`. + * You will be using the `node-fetch` library to make your requests to the `Place Search` API. You can use its example code in its github repo as guidance for its use. + +## Stretch Problem + * Create an endpoint `/places` that, provided a query returns the detailed information about ALL places returned to you from `Place Search`. + +## Resources + * Places API: https://developers.google.com/places/web-service/ + * Place Search: https://developers.google.com/places/web-service/search + * Place Details: https://developers.google.com/places/web-service/details + * Request Library: https://github.com/bitinn/node-fetch + + + + +</details><details> <summary>1-projects/Node-Express-Gmaps-Solution-Day-II-master/</summary> + +### [1-projects/Node-Express-Gmaps-Solution-Day-II-master/README.md](1-projects/Node-Express-Gmaps-Solution-Day-II-master/README.md) +<!-- START doctoc generated TOC please keep comment here to allow auto update --> +<!-- DON'T EDIT THIS SECTION, INSTEAD RE-RUN doctoc TO UPDATE --> +**Table of Contents** *generated with [DocToc](https://github.com/thlorenz/doctoc)* + +- [Node-Express-Gmaps](#node-express-gmaps) + - [Objectives](#objectives) + - [Beginning Project](#beginning-project) +- [Day I](#day-i) + - [Project Description](#project-description) + - [Project Requirements](#project-requirements) + - [Stretch Problem](#stretch-problem) + - [Resources](#resources) +- [Day II](#day-ii) + - [Project Requirements](#project-requirements-1) + - [Project Notes](#project-notes) + - [Stretch Problem](#stretch-problem-1) + - [Resources](#resources-1) + +<!-- END doctoc generated TOC please keep comment here to allow auto update --> + +# Node-Express-Gmaps + +Topics: + * APIs + * API Documentation + * Rate Limits + * Multiple requests + +## Objectives + * Create endpoints + * Make multpile requests to third-party API + * Return result + +## Beginning Project + * You will notice there is a config file that is ignored in the .gitignore, which you will be using to store your API key. You will need to import that key into your server file. DO NOT store it anywhere that will get pushed up to your repo. + * Everything else you will start from scratch. + +# Day I + +## Project Description + * You will be using the Google Maps Place API to get details about any place provided by the user of your API. When the user provides you a query (example: `coffee+shops+in+Austin`) you will use that query to make a request to the `Place Search` service, and will specifically be doing a `Text Search Request`. You will use the necessary information from the data returned from that first request, and then do a request to `Place Details` service, returning the detailed information to the user of your API. + +## Project Requirements + * Create an endpoint `/place` that, provided a query, returns the detailed information about the first place that is in the array of places returned to you from `Place Search`. + * You will be using the `node-fetch` library to make your requests to the `Place Search` API. You can use its example code in its github repo as guidance for its use. + +## Stretch Problem + * Create an endpoint `/places` that, provided a query returns the detailed information about ALL places returned to you from `Place Search`. + +## Resources + * Places API: https://developers.google.com/places/web-service/ + * Place Search: https://developers.google.com/places/web-service/search + * Place Details: https://developers.google.com/places/web-service/details + * Request Library: https://github.com/bitinn/node-fetch + +# Day II + +## Project Requirements +* Create an enpoint called `/travel/mode` that returns the quickest method of travel given two locations, as well as the travel time. It should account for driving, walking, bicycling, and transit. + +## Project Notes +* You will need a separate key than what you've used for the Places API since it is actually a different API. +* For best results, try to pick locations that should indeed have transit available. + +## Stretch Problem +* Include this comparison information in the information your return from `/place`. + +## Resources + * Distance Matrix API: https://developers.google.com/places/web-service/ + * Travel Mode Section: https://developers.google.com/maps/documentation/distance-matrix/intro#travel_modes + + + + + +</details><details> <summary>1-projects/Python-OOP-Toy-master/</summary> + +### [1-projects/Python-OOP-Toy-master/README.md](1-projects/Python-OOP-Toy-master/README.md) +<!-- START doctoc generated TOC please keep comment here to allow auto update --> +<!-- DON'T EDIT THIS SECTION, INSTEAD RE-RUN doctoc TO UPDATE --> +**Table of Contents** *generated with [DocToc](https://github.com/thlorenz/doctoc)* + +- [Overview](#overview) +- [Python OOP Toy](#python-oop-toy) + - [In-class Demo](#in-class-demo) + - [Project Work](#project-work) + - [Stretch Goals](#stretch-goals) + - [Troubleshooting](#troubleshooting) + - [Windows](#windows) + - [Mac](#mac) + +<!-- END doctoc generated TOC please keep comment here to allow auto update --> + +**Note for Windows users: WSL won't work for this module!** + +# Overview +"Object-oriented programming (OOP) is a programming paradigm based on the concept of "objects", which may contain data, in the form of fields, often known as attributes; and code, in the form of procedures, often known as methods. A feature of objects is that an object's procedures can access and often modify the data fields of the object with which they are associated (objects have a notion of "this" or "self"). In OOP, computer programs are designed by making them out of objects that interact with one another.[1][2]" --Wikipedia + +In English, this means that in OOP, code is organized in logical and self contained parts that contain within them everything needed to create, store, and manipulate one very specific element of the program. When this element is needed, a copy of it is initialized according to the instructions within. This is called an object. + +As with all things programming, the specific vocabulary varies from language to language, or even programmer to programmer. Some Python vocabulary: + +Class: The top level organization structure in OOP. This contains all of the instructions and storage for the operations of this part of the program. A class should be self contained and all variables within the class should only be modified by methods within the class. + +Method: A function that belongs to a specific class. + +Constructor: A special method, defined with __init__() that is used to instantiate an object of this class. + +Inheritance: Perhaps the most important concept in OOP, a class may inherit from another class. This gives the child class all of the variables and methods found in the parent class, or classes, automatically. + +Override: If a child class needs to function slightly differently than objects of the parent class, this can be done by giving the child class a method with the same name as one found in the parent. This method will override the one defined in the parent class. Often, this is done to add child specific functionality to the method before calling the parent version of the method using super().foo(). This is commonly done with the __init__() method. + +Self: In Python, a class refers to class-level variables and methods with the keyword `self`. These have scope across the entire class. Variables may also be declared normally and will have scope limited to the block of code they are declared within. + +# Python OOP Toy +This project will demonstrate the core concepts of OOP by using a library called pygame to create a toy similar to early screensavers. + +For initial setup, run: + +``` +pipenv install +pipenv shell +``` + +Then to run, use: `python src/draw.py` + +## In-class Demo +Your instructor will demonstrate the above concepts by extending the `Block` class + +## Project Work +Fill out the stubs in `ball.py` to extend the functionality of the `ball` class. + +## Stretch Goals +Implement simple physics to enable balls to bounce off of one another, or off of blocks. This will be HARD. If you get it 'sort of working' in any form, consider yourself to have accomplished an impressive feat! + +## Troubleshooting + +### Windows +* If `pipenv install` is taking forever or erroring with TIMEOUT messages, disable your antivirus software. +* If `pipenv install` is puking on installing pygame: + * Don't use `pipenv` for this project. No `install`, no `shell`. + * Download the appropriate `.whl` file from [here](https://www.lfd.uci.edu/~gohlke/pythonlibs/#pygame). + * Python 3.6 use the `cp36` version. Python 3.7 use `cp37`, etc. Use `python --version` to check your version. + * Try the `win32` version first. If that doesn't work, the AMD version. + * E.g. `pygame‑1.9.3‑cp36‑cp36m‑win32.whl` + * Install it with + ``` + pip install pygame-[whatever].whl + ``` + You'll need to specify the full path, likely. + * Once it's installed, run the game from the `src/` directory with + ``` + python draw.py + ``` +### Mac +* If you're getting errors about `InvalidMarker`: + * Don't use `pipenv` for this project. No `install`, no `shell`. + * Run `pip3 install pygame` + * Once it's installed, run the game from the `src/` directory with + ``` + python3 draw.py + ``` + + + + + +</details><details> <summary>1-projects/React-Todo-Solution-master/</summary> + +### [1-projects/React-Todo-Solution-master/answers.md](1-projects/React-Todo-Solution-master/answers.md) +<!-- START doctoc generated TOC please keep comment here to allow auto update --> +<!-- DON'T EDIT THIS SECTION, INSTEAD RE-RUN doctoc TO UPDATE --> +**Table of Contents** *generated with [DocToc](https://github.com/thlorenz/doctoc)* + +- [All Answers to Partner Study should be filled out in this file.](#all-answers-to-partner-study-should-be-filled-out-in-this-file) + +<!-- END doctoc generated TOC please keep comment here to allow auto update --> + +### All Answers to Partner Study should be filled out in this file. + +1. Single Page Application + +2. Compilers + +3. Bundlers + +4. Elements + +5. Components + +6. JSX + +7. Package Mangers + +8. CDN + +9. Props and State + + + + + +### [1-projects/React-Todo-Solution-master/README.md](1-projects/React-Todo-Solution-master/README.md) + +<!-- START doctoc generated TOC please keep comment here to allow auto update --> +<!-- DON'T EDIT THIS SECTION, INSTEAD RE-RUN doctoc TO UPDATE --> +**Table of Contents** *generated with [DocToc](https://github.com/thlorenz/doctoc)* + +- [React-Todo](#react-todo) + - [Other Useful Resources](#other-useful-resources) + - [Battle Plan](#battle-plan) + - [To Get Started](#to-get-started) + - [You'll need to make sure you have the following installed.](#youll-need-to-make-sure-you-have-the-following-installed) + - [How to Tackle this Project](#how-to-tackle-this-project) + - [Tips to Keep in Mind](#tips-to-keep-in-mind) + - [Stretch Problems](#stretch-problems) + +<!-- END doctoc generated TOC please keep comment here to allow auto update --> + +# React-Todo + +### Other Useful Resources +* [API Documentation](https://reactjs.org/docs/react-api.html) +* [Documentation](https://facebook.github.io/react/docs/jsx-in-depth.html) on JSX + +### Battle Plan + * Objective: At this point you have become familiar with the DOM and have built out User Interfaces HTML and CSS and some custom components. Now we're going to dive into modern front-end JavaScript development by learning about ReactJS. + * You're going to be building a ToDo App (please hold your applause). + * We know this may seem trivial, but the best part about this assignment is that is shows off some of the strengths of React and you can also take it as far as want so don't hold back on being creative. + + * Tool requirements + * [React Dev Tools](https://chrome.google.com/webstore/detail/react-developer-tools/fmkadmapgofadopljbjfkapdkoienihi?hl=en) - *This is a MUST* you need to install this asap! + * We have everything you need for your React Developer environment in this file. We went over this in the lecture video. + +#### To Get Started +##### You'll need to make sure you have the following installed. + * node and npm + * `npm install` will pull in all the node_modules you need once you `cd` into the root directory of the project + * `npm start` will start a development server on your localhost at port 3000. + * `npm test` will run the tests that are included in the the project. Try to get as many of these passing as you can in the allotted time. + +#### How to Tackle this Project +Your job is to write the components to complete the Todo List application and getting as many of the tests to pass as you can. The tests are expecting that you have a TodoList component that renders a Todo component for each todo item. The requirements for your Todo List app is that it should have an input field that a user can type text into and submit data in the input field in order to create a new todo item. Aside from being able to add todos, you should be able to mark any todo in the list as 'complete'. In other words, a user should be able to click on any of the todos in the list and have a strikethrough go through the individual todo. This behavior should be toggle-able, i.e. a todo item that has a strikethrough through it should still be clickable in order to allow completed items to no longer be marked as 'completed'. Once you've finished your components, you'll need to have the root `App` component render your TodoList component. + +#### Tips to Keep in Mind + * All components you implement should go in the `src/components` directory. + * The components should be named `App.js`, `TodoList.js` and `Todo.js` (as those are the files being imported into the tests). + * Think of your application as an Application Tree. App is the parent, which controlls properties/data needed for the child components. This is how modern applications are built. They're modular, separate pieces of code called components that you 'compose' together to make your app. It's awesome! + * Be sure to keep your todos in an array on state. Arrays are so awesome to work with. + * When you need to iterate over a list and return React components out as elements, you'll need to include a "key" property on the element itself. `<ElementBeingRendered key={someValue} />`. Note: this is what react is doing under the hood, it needs to know how to access each element and they need to be unique so the React engine can do its thing. An example snippet that showcases this may look something like this: + ``` + this.state.todos.map((todo, i) => <AnotherComponent key={i} todo={todo} />); + ``` + Here, we're simply passing the index of each todo item as the key for the individual React component. + * Feel free to structure your "todo" data however you'd like. i.e. strings, objects etc. + * React will give you warnings in the console that urge you to squash React Anti-Patterns. But if something is completely off, you'll get stack trace errors that will force your bundle to freeze up. You can look for these in the Chrome console. + +#### Stretch Problems + * Refactor each todo to be an object instead of a just a string. For example, `todo: {'text': 'Shop for food, 'completed': false}` and when a user clicks on a todo, switch that completed flag to true. If `completed === true`, this should toggle the strikethrough on the 'completed' todo. The toggling functionality should work the same as when each todo was just a string. + * Add the ability to delete a todo. The way this would work is each todo item should have an 'x' that should be clickable and that, when clicked, should remove the todo item from the state array, which will also remove it from the rendered list of todos. + * Take your App's styles to the next level. Start implementing as much creativity here as you'd like. You can build out your styles on a component-by-component basis eg `App.js` has a file next to it in the directory tree called `App.scss` and you define all your styles in that file. Be sure to @import these styles into the `index.scss` file. + * Persist your data in `window.localStorage()` hint: you may have to pass your data to a stringifier to get it to live inside the `localStorage()` of the browser. This will cause it to persist past the page refresh. + + +</details><details> <summary>1-projects/Relational-Databases-master/</summary> + +### [1-projects/Relational-Databases-master/README.md](1-projects/Relational-Databases-master/README.md) +<!-- START doctoc generated TOC please keep comment here to allow auto update --> +<!-- DON'T EDIT THIS SECTION, INSTEAD RE-RUN doctoc TO UPDATE --> +**Table of Contents** *generated with [DocToc](https://github.com/thlorenz/doctoc)* + +- [Relational Databases and PostgreSQL](#relational-databases-and-postgresql) + - [Contents](#contents) + - [What is a relational database?](#what-is-a-relational-database) + - [Relational vs NoSQL](#relational-vs-nosql) + - [When Do You Use NoSQL Versus a Relational Database?](#when-do-you-use-nosql-versus-a-relational-database) + - [PostgreSQL](#postgresql) + - [SQL, Structured Query Language](#sql-structured-query-language) + - [Create a table with CREATE TABLE](#create-a-table-with-create-table) + - [Create a row with INSERT](#create-a-row-with-insert) + - [Read rows with SELECT](#read-rows-with-select) + - [Update rows with UPDATE](#update-rows-with-update) + - [Delete rows with DELETE](#delete-rows-with-delete) + - [Deleting entire tables with DROP](#deleting-entire-tables-with-drop) + - [The `WHERE` Clause](#the-where-clause) + - [`AND`, `OR`, and Parentheses](#and-or-and-parentheses) + - [`LIKE`](#like) + - [Column Data Types](#column-data-types) + - [ACID and CRUD](#acid-and-crud) + - [ACID](#acid) + - [CRUD](#crud) + - [NULL and NOT NULL](#null-and-not-null) + - [COUNT](#count) + - [ORDER BY](#order-by) + - [GROUP BY](#group-by) + - [Keys: Primary, Foreign, and Composite](#keys-primary-foreign-and-composite) + - [Primary Key](#primary-key) + - [Foreign Keys](#foreign-keys) + - [Composite Keys](#composite-keys) + - [Auto-increment Columns](#auto-increment-columns) + - [Joins](#joins) + - [Inner Join, The Most Common Join](#inner-join-the-most-common-join) + - [Left Outer Join](#left-outer-join) + - [Right Outer Join](#right-outer-join) + - [Full Outer Join](#full-outer-join) + - [Indexes](#indexes) + - [Transactions](#transactions) + - [The EXPLAIN Command](#the-explain-command) + - [Quick and Dirty DB Design](#quick-and-dirty-db-design) + - [Normalization and Normal Forms](#normalization-and-normal-forms) + - [Anomalies](#anomalies) + - [First Normal Form (1NF)](#first-normal-form-1nf) + - [Second Normal Form (2NF)](#second-normal-form-2nf) + - [Third Normal Form (3NF)](#third-normal-form-3nf) + - [More reading:](#more-reading) + - [Node-Postgres](#node-postgres) + - [Assignments](#assignments) + - [Security](#security) + - [PostgreSQL Password](#postgresql-password) + - [Writing Client Software](#writing-client-software) + - [Other Relational Databases](#other-relational-databases) + - [Assignment: Install PostgreSQL](#assignment-install-postgresql) + - [Mac with Homebrew](#mac-with-homebrew) + - [Windows](#windows) + - [Arch Linux](#arch-linux) + - [Assignment: Create a Table and Use It](#assignment-create-a-table-and-use-it) + - [Assignment: NodeJS Program to Create and Populate a Table](#assignment-nodejs-program-to-create-and-populate-a-table) + - [Assignment: Command-line Earthquake Query Tool](#assignment-command-line-earthquake-query-tool) + - [Assignment: RESTful Earthquake Data Server](#assignment-restful-earthquake-data-server) + +<!-- END doctoc generated TOC please keep comment here to allow auto update --> + +# Relational Databases and PostgreSQL + + +## Contents + +* [What is a relational database?](#what-is-a-relational-database) +* [Relational vs NoSQL](#relational-vs-nosql) +* [PostgreSQL](#postgresql) +* [SQL, Structured Query Language](#sql-structured-query-language) +* [Column Data Types](#column-data-types) +* [ACID and CRUD](#acid-and-crud) +* [NULL and NOT NULL](#null-and-not-null) +* [COUNT](#count) +* [ORDER BY](#order-by) +* [GROUP BY](#group-by) +* [Keys: Primary, Foreign, and Composite](#keys-primary-foreign-and-composite) +* [Auto-increment Columns](#auto-increment-columns) +* [Joins](#joins) +* [Indexes](#indexes) +* [Transactions](#transactions) +* [The EXPLAIN Command](#the-explain-command) +* [Quick and Dirty DB Design](#quick-and-dirty-db-design) +* [Normalization and Normal Forms](#normalization-and-normal-forms) +* [Node-Postgres](#node-postgres) +* [Security](#security) +* [Other Relational Databases](#other-relational-databases) +* [Assignment: Install PostgreSQL](#assignment-install-postgresql) +* [Assignment: Create a Table and Use It](#assignment-create-a-table-and-use-it) +* [Assignment: NodeJS Program to Create and Populate a Table](#assignment-nodejs-program-to-create-and-populate-a-table) +* [Assignment: Command-line Earthquake Query Tool](#assignment-command-line-earthquake-query-tool) +* [Assignment: RESTful Earthquake Data Server](#assignment-restful-earthquake-data-server) + + +## What is a relational database? + +Data stored as row records in tables. Imagine a spreadsheet with column +headers describing the contents of each column, and each row is a +record. + +A database can contain many tables. A table can contain many rows. A row +can contain many columns. + +Records are related to those in different tables through common columns +that are present in both tables. + +For example, an `Employee` table might have the following columns in +each record: + + Employee + EmployeeID FirstName LastName DepartmentID + +And a `Department` table might have the following columns in each +record: + + Department + DepartmentID DepartmentName + +Notice that both `Employee` and `Department` have a `DepartmentID` +column. This common column *relates* the two tables and can be used to +*join* them together with a *query*. + +The structure described by the table definitions is known as the +*schema*. + +Compare to NoSQL databases that work with key/value pairs or are +document stores. + +* [Relational Database at Wikipedia](https://en.wikipedia.org/wiki/Relational_database) +* [Non-relational (NoSQL) databases at Wikipedia](https://en.wikipedia.org/wiki/NoSQL) + + +## Relational vs NoSQL + +*NoSQL* is a term that refers to non-relational databases, most usually +document store databases. (Though it can apply to almost any kind of +non-relational database.) + +MongoDB is a great example of a NoSQL database. + +### When Do You Use NoSQL Versus a Relational Database? + +Unfortunately, there are no definitive rules on when to choose one or +the other. + +Do you need ACID-compliance? Consider a relational database. + +Does your schema (structure of data) change frequently? Consider NoSQL. + +Does absolute consistency in your data matter, e.g. a bank, inventory +management system, employee management, academic records, etc.? Consider +a relational database. + +Do you need easy-to-deploy high-availability? Consider NoSQL. + +Do you need transactions to happen atomically? (The ability to update +multiple records simultaneously?) Consider a relational database. + +Do you need read-only access to piles of data? Consider NoSQL. + + +## PostgreSQL + +PostgreSQL is a venerable relational database that is freely available +and world-class. + +https://www.postgresql.org/ + +* **Assignment:** [Install PostgreSQL](#assignment-install-postgresql) + + +## SQL, Structured Query Language + +SQL ("sequel") is the language that people use for interfacing with +relational databases. + +### Create a table with CREATE TABLE + +A database is made up of a number of tables. Let's create a table using +SQL in the shell. Be sure to end the command with a semicolon `;`. + +(Note: SQL commands are often capitalized by convention, but can be +lowercase.) + + + $ psql + psql (10.1) + Type "help" for help. + + dbname=> CREATE TABLE Employee (ID INT, LastName VARCHAR(20)); + +Use the `\dt` command to show which tables exist: + + dbname=> CREATE TABLE Employee (ID INT, LastName VARCHAR(20)); + CREATE TABLE + dbname=> \dt + List of relations + Schema | Name | Type | Owner + --------+----------+-------+------- + public | employee | table | beej + (1 row) + +Use the `\d` command to see what columns a table has: + + dbname=> \d Employee + Table "public.employee" + Column | Type | Collation | Nullable | Default + --------------+-----------------------+-----------+----------+--------- + id | integer | | | + lastname | character varying(20) | | | + +### Create a row with INSERT + + dbname=> INSERT INTO Employee (ID, LastName) VALUES (10, 'Tanngnjostr'); + INSERT 0 1 + +You can omit the column names if you're putting data in every column: + + dbname=> INSERT INTO Employee VALUES (10, 'Tanngnjostr'); + INSERT 0 1 + +Run some more inserts into the table: + +```sql +INSERT INTO Employee VALUES (11, 'Alice'); +INSERT INTO Employee VALUES (12, 'Bob'); +INSERT INTO Employee VALUES (13, 'Charlie'); +INSERT INTO Employee VALUES (14, 'Dave'); +INSERT INTO Employee VALUES (15, 'Eve'); +``` + +### Read rows with SELECT + +You can query the table with `SELECT`. + +Query all the rows and columnts: + + dbname=> SELECT * FROM Employee; + id | lastname + ----+------------- + 10 | Tanngnjostr + 11 | Alice + 12 | Bob + 13 | Charlie + 14 | Dave + 15 | Eve + (6 rows) + +With `SELECT`, `*` means "all columns". + +You can choose specific columns: + + dbname=> SELECT LastName FROM Employee; + lastname + ------------- + Tanngnjostr + Alice + Bob + Charlie + Dave + Eve + (6 rows) + +And you can search for specific rows with the `WHERE` clause: + + dbname=> SELECT * FROM Employee WHERE ID=12; + id | lastname + ----+---------- + 12 | Bob + (1 row) + + dbname=> SELECT * FROM Employee WHERE ID=14 OR LastName='Bob'; + id | lastname + ----+---------- + 12 | Bob + 14 | Dave + (2 rows) + +Finally, you can rename the output columns, if you wish: + +```sql +SELECT id AS Employee ID, LastName AS Name + FROM Employee + WHERE ID=14 OR LastName='Bob'; + + Employee ID | Name +-------------+---------- + 12 | Bob + 14 | Dave +``` + +### Update rows with UPDATE + +The `UPDATE` command can update one or many rows. Restrict which rows +are updated with a `WHERE` clause.` + + dbname=> UPDATE Employee SET LastName='Harvey' WHERE ID=10; + UPDATE 1 + + dbname=> SELECT * FROM Employee WHERE ID=10; + id | lastname + ----+---------- + 10 | Harvey + (1 row) + +You can update multiple columns at once: + + dbname=> UPDATE Employee SET LastName='Octothorpe', ID=99 WHERE ID=14; + UPDATE 1 + + +### Delete rows with DELETE + +Delete from a table with the `DELETE` command. Use a `WHERE` clause to +restrict the delete. + +**CAUTION!** If you don't use a `WHERE` clause, all rows will be deleted +from the table! + +Delete some rows: + + dbname=> DELETE FROM Employee WHERE ID >= 15; + DELETE 2 + +Delete **ALL** rows (*Danger, Will Robinson!*): + + dbname=> DELETE FROM Employee; + DELETE 4 + +### Deleting entire tables with DROP + +If you want to get rid of an entire table, use `DROP`. + +**WARNING!** There is no going back. Table will be completely blown +away. Destroyed ...by the Empire. + + dbname=> DROP TABLE Employee; + DROP TABLE + +* **Assignment:** [Create a Table and Use It](#assignment-create-a-table-and-use-it) + + +## The `WHERE` Clause + +You've already seen some examples of how `WHERE` affects `SELECT`, +`UPDATE`, and `DELETE`. + +Normal operators like `<`, `>`, `=`, `<=`, `>=` are available. + +For example: + +```sql +SELECT * from animals + WHERE age >= 10; +``` + +### `AND`, `OR`, and Parentheses + +You can add more boolean logic with `AND`, `OR`, and affect precedence +with parentheses: + +```sql +SELECT * from animals + WHERE age >= 10 AND type = 'goat'; +``` + +```sql +SELECT * from animals + WHERE age >= 10 AND (type = 'goat' OR type = 'antelope'); +``` + +### `LIKE` + +The `LIKE` operator can be used to do pattern matching. + +```sql +_ -- Match any single character +% -- Match any sequence of characters +``` + +To select all animals that start with `ab`: + +```sql +SELECT * from animal + WHERE name LIKE 'ab%'; +``` + + +## Column Data Types + +You probably noticed a few data types we specified with `CREATE TABLE`, +above. PostgreSQL has [a lot of data +types](https://www.postgresql.org/docs/current/static/datatype.html). + +This is an incomplete list of some of the more common types: + +```sql +VARCHAR(n) -- Variable character string of max length n +BOOLEAN -- TRUE or FALSE +INTEGER -- Integer value +INT -- Same as INTEGER +DECIMAL(p,s) -- Decimal number with p digits of precision + -- and s digits right of the decimal point +REAL -- Floating point number +DATE -- Holds a date +TIME -- Holds a time +TIMESTAMP -- Holds an instant of time (date and time) +BLOB -- Binary object +``` + +## ACID and CRUD + +These are two common database terms. + +### ACID + +Short for *Atomicity*, *Consistency*, *Isolation*, *Durability*. When +people mention "ACID-compliance", they're generally talking about the +ability of the database to accurately record transactions in the case of +crash or power failure. + +Atomicity: all transactions will be "all or nothing". + +Consistency: all transactions will leave the database in a consistent +state with all its defined rules and constraints. + +Isonlation: the results of concurrent transactions is the same as if +those transactions had been executed sequentially. + +Durability: Once a transaction is committed, it will remain committed, +despite crashes, power outages, snow, and sleet. + +### CRUD + +Short for *Create*, *Read*, *Update*, *Delete*. Describes the four basic +functions of a data store. + +In a relational database, these functions are handled by `INSERT`, +`SELECT`, `UPDATE`, and `DELETE`. + + +## NULL and NOT NULL + +Columns in records can sometimes have no data, referred to by the +special keyword as `NULL`. Sometimes it makes sense to have NULL +columns, and sometimes it doesn't. + +If you explicitly want to disallow NULL columns in your table, you can +create the columns with the `NOT NULL` constraint: + + CREATE TABLE Employee ( + ID INT NOT NULL, + LastName VARCHAR(20)); + + +## COUNT + +You can select a count of items in question with the `COUNT` operator. + +For example, count the rows filtered by the `WHERE` clause: + +```sql +SELECT COUNT(*) FROM Animals WHERE legcount >= 4; + + count +------- + 5 +``` + +Useful with [`GROUP BY`](#group-by), below. + + +## ORDER BY + +`ORDER BY` which sorts `SELECT` results for you. Use `DESC` to sort in +reverse order. + +```sql +SELECT * FROM Pets +ORDER BY age DESC; + + name | age +-----------+----- + Rover | 9 + Zaphod | 4 + Mittens | 3 +``` + + +## GROUP BY + +When used with an aggregating function like [`COUNT`](#count), can be +used to produce groups of results. + +Count all the customers in certain countries: + +```sql +SELECT COUNT(CustomerID), Country + FROM Customers + GROUP BY Country; + + COUNT(CustomerID) | Country +----------------------+----------- + 1123 | USA + 734 | Germany + etc. +``` + + +## Keys: Primary, Foreign, and Composite + +### Primary Key + +Rows in a table often have one column that is called the *primary key*. +The value in this column applies to all the rest of the data in the +record. For example, an `EmployeeID` would be a great primary key, +assuming the rest of the record held employee information. + + Employee + ID (Primary Key) LastName FirstName DepartmentID + +To create a table and specify the primary key, use the `NOT NULL` and +`PRIMARY KEY` constraints: + +```sql +CREATE TABLE Employee ( + ID INT NOT NULL PRIMARY KEY, + LastName VARCHAR(20), + FirstName VARCHAR(20), + DepartmentID INT); +``` + +You can always search quickly by primary key. + +### Foreign Keys + +If a key refers to a primary key in another table, it is called a +*foreign key* (abbreviated "FK"). You are not allowed to make changes to +the database that would cause the foreign key to refer to a non-existent +record. + +The database uses this to maintain *referential integrity*. + +Create a foreign key using the `REFERENCES` constraint. It specifies the +remote table and column the key refers to. + +```sql +CREATE TABLE Department ( + ID INT NOT NULL PRIMARY KEY, + Name VARCHAR(20)); + +CREATE TABLE Employee ( + ID INT NOT NULL PRIMARY KEY, + LastName VARCHAR(20), + FirstName VARCHAR(20), + DepartmentID INT REFERENCES Department(ID)); +``` + +In the above example, you cannot add a row to `Employee` until that +`DepartmentID` already exists in `Department`'s `ID`. + +Also, you cannot delete a row from `Department` if that row's `ID` was a +`DepartmentID` in `Employee`. + +### Composite Keys + +Keys can also consist of more than one column. *Composite keys* can be +created as follows: + +```sql +CREATE TABLE example ( + a INT, + b INT, + c INT, + PRIMARY KEY (a, c)); +``` + + +## Auto-increment Columns + +These are columns that the database manages, usually in an +ever-increasing sequence. It's perfect for generation unique, numeric +IDs for primary Keys. + +> In some databases (e.g MySQL) this is done with an `AUTO_INCREMENT` +> keyword. PostgreSQL is different. + +In PostgreSQL, use the `SERIAL` keyword to auto-generate sequential +numeric IDs for records. + +```sql +CREATE TABLE Company ( + ID SERIAL PRIMARY KEY, + Name VARCHAR(20)); +``` + +When you insert, **do not** specify the ID column. You **must** however, +give a column name list that includes the remaining column names you are +inserting data for. The ID column will be automatically generated by the +database. + +```sql +INSERT INTO Company (Name) VALUES ('My Awesome Company'); +``` + + +## Joins + +*This concept is* extremely important *to understanding how to use +relational databases!* + +When you have two (or more) tables with data you wish to retrieve from +both, you do so by using a *join*. These come in a number of varieties, +some of which are covered here. + +When you're using `SELECT` to make the join between two tables, you can +specify the tables specific columns are from by using the `.` operator. +This is especially useful when columns have the same name in the +different tables: + +```sql +SELECT Animal.name, Farm.name + FROM Animal, Farm + WHERE Animal.FarmID = Farm.ID; +``` + +Tables to use in these examples: + +```sql +CREATE TABLE Department ( + ID INT NOT NULL PRIMARY KEY, + Name VARCHAR(20)); + +CREATE TABLE Employee ( + ID INT NOT NULL PRIMARY KEY, + Name VARCHAR(20), + DepartmentID INT); + +INSERT INTO Department VALUES (10, 'Marketing'); +INSERT INTO Department VALUES (11, 'Sales'); +INSERT INTO Department VALUES (12, 'Entertainment'); + +INSERT INTO Employee VALUES (1, 'Alice', 10); +INSERT INTO Employee VALUES (2, 'Bob', 12); +INSERT INTO Employee VALUES (3, 'Charlie', 99); +``` + +**NOTE**: Importantly, department ID 11 is not referred to from +`Employee`, and department ID 99 (Charlie) does not exist in +`Department`. This is instrumental in the following examples. + + +### Inner Join, The Most Common Join + +This is the most commonly-used join, by far, and is what people mean +when they just say "join" with no further qualifiers. + +This will return only the rows that match the requirements from **both** +tables. + +For example, we don't see "Sales" or "Charlie" in the join because +neither of them match up to the other table: + + dbname=> SELECT Employee.ID, Employee.Name, Department.Name + FROM Employee, Department + WHERE Employee.DepartmentID = Department.ID; + + id | name | name + ----+-------+--------------- + 1 | Alice | Marketing + 2 | Bob | Entertainment + (2 rows) + +Above, we used a `WHERE` clause to perform the inner join. This is +absolutely the most common way to do it. + +There is an alternative syntax, below, that is barely ever used. + + dbname=> SELECT Employee.ID, Employee.Name, Department.Name + FROM Employee INNER JOIN Department + ON Employee.DepartmentID = Department.ID; + + id | name | name + ----+-------+--------------- + 1 | Alice | Marketing + 2 | Bob | Entertainment + (2 rows) + +### Left Outer Join + +This join works like an inner join, but also returns *all* the rows from +the "left" table (the one after the `FROM` clause). It puts `NULL` +in for the missing values in the "right" table (the one after the +`LEFT JOIN` clause.) + +Example: + + dbname=> SELECT Employee.ID, Employee.Name, Department.Name + FROM Employee LEFT JOIN Department + ON Employee.DepartmentID = Department.ID; + + id | name | name + ----+---------+--------------- + 1 | Alice | Marketing + 2 | Bob | Entertainment + 3 | Charlie | + (3 rows) + +Notice that even though Charlie's department isn't found in `Department`, his record is still listed with a `NULL` department name. + + +### Right Outer Join + +This join works like an inner join, but also returns *all* the rows from +the "right" table (the one after the `RIGHT JOIN` clause). It puts +`NULL` in for the missing values in the "right" table (the one after the +`FROM` clause.) + + dbname=> SELECT Employee.ID, Employee.Name, Department.Name + FROM Employee RIGHT JOIN Department + ON Employee.DepartmentID = Department.ID; + + id | name | name + ----+-------+--------------- + 1 | Alice | Marketing + 2 | Bob | Entertainment + | | Sales + (3 rows) + +Notice that even though there are no employees in the Sales department, +the Sales name is listed with a `NULL` employee name. + +### Full Outer Join + +This is a blend of a Left and Right Outer Join. All information from +both tables is selected, with `NULL` filling the gaps where necessary. + + dbname=> SELECT Employee.ID, Employee.Name, Department.Name + FROM Employee + FULL JOIN Department + ON Employee.DepartmentID = Department.ID; + + id | name | name + ----+---------+--------------- + 1 | Alice | Marketing + 2 | Bob | Entertainment + 3 | Charlie | + | | Sales + (4 rows) + +* [Join at W3Schools](https://www.w3schools.com/sql/sql_join.asp) +* [Join at Wikipedia](https://en.wikipedia.org/wiki/Join_(SQL)) + + +## Indexes + +When searching through tables, you use a `WHERE` clause to narrow things +down. For speed, the columns mentioned in the `WHERE` clause should +either be a primary key, or a column for which an *index* has been +built. + +Indexes help speed searches. In a large table, searching over an +unindexed column will be *slow*. + +Example of creating an index on the Employee table from the +[Keys](#keys-primary-and-foreign) section: + + dbname=> CREATE INDEX ON Employee (LastName); + CREATE INDEX + + dbname=> \d Employee + Table "public.employee" + Column | Type | Collation | Nullable | Default + --------------+-----------------------+-----------+----------+--------- + id | integer | | not null | + lastname | character varying(20) | | | + firstname | character varying(20) | | | + departmentid | integer | | | + Indexes: + "employee_pkey" PRIMARY KEY, btree (id) + "employee_lastname_idx" btree (lastname) + Foreign-key constraints: + "employee_departmentid_fkey" FOREIGN KEY (departmentid) REFERENCES department(id) + +* [PostgreSQL CREATE INDEX documentation](https://www.postgresql.org/docs/current/static/sql-createindex.html) + + +## Transactions + +In PostgreSQL, you can bundle a series of statements into a +*transaction*. The transaction is executed *atomically*, which means +either the entire transaction occurs, or none of the transaction occurs. +There will never be a case where a transaction partially occurs. + +Create a transaction by starting with a `BEGIN` statement, followed by +all the statements that are to be within the transaction. + +> `START TRANSACTION` is generally synonymous with `BEGIN` in SQL. + +To execute the transaction ("Let's do it!"), end with a `COMMIT` +statement. + +To abort the transaction and do nothing ("On second thought, +nevermind!") end with a `ROLLBACK` statement. *This makes it like +nothing within the transaction ever happened.* + +Usually transactions happen within a program that checks for sanity and +either commits or rolls back. + +Pseudocode making DB calls that check if a rollback is necessary: + +```javascript +db("BEGIN"); // Begin transaction + +db(`UPDATE accounts SET balance = balance - 100.00 + WHERE name = 'Alice'`); + +let balance = db("SELECT balance WHERE name = 'Alice'"); + +// Don't let the balance go below zero: +if (balance < 0) { + db("ROLLBACK"); // Never mind!! Roll it all back. +} else { + db("COMMIT"); // Plenty of cash +} +``` + +In the above example, the `UPDATE` and `SELECT` must happen at the same +time (*atomically*) or else another process could sneak in between and +withdraw too much money. Because it needs to be atomic, it's wrapped in +a transaction. + +If you just enter a single SQL statement that is not inside a `BEGIN` +transaction block, it gets automatically wrapped in a `BEGIN`/`COMMIT` +block. It is a mini transaction that is `COMMIT`ted immediately. + +Not all SQL databases support transactions, but most do. + + +## The EXPLAIN Command + +The `EXPLAIN` command will tell you how much time the database is +spending doing a query, and what it's doing in that time. + +It's a powerful command that can help tell you where you need to add +indexes, change structure, or rewrite queries. + + dbname=> EXPLAIN SELECT * FROM foo; + + QUERY PLAN + --------------------------------------------------------- + Seq Scan on foo (cost=0.00..155.00 rows=10000 width=4) + (1 row) + +For more information, see the [PostgreSQL EXPLAIN documentation](https://www.postgresql.org/docs/current/static/sql-explain.html) + + +## Quick and Dirty DB Design + +Designing a non-trivial database is a difficult, learned skill best left to +professionals. Feel free to do small databases with minimal training, but if you +get in a professional situation with a large database that needs to be designed, +you should consult with people with strong domain knowledge. + +That said, here are a couple pointers. + +* In general, all your tables should have a unique `PRIMARY KEY` for each row. + It's common to use `SERIAL` or `AUTO_INCREMENT` to make this happen. + +* Keep an eye out for commonly duplicated data. If you are duplicating text data + across several records, consider that maybe it should be in its own table and + referred to with a foreign key. + +* Watch out for unrelated data in the same record. If it's a record in the + `Employee` table but it has `Department_Address` as a column, that probably + belongs in a `Department` table, referred to by a public key. + +But if you really want to design database, read on to the [Normalization and +Normal Forms](#normalization-and-normal-forms) section. + + +## Normalization and Normal Forms + +*[This topic is very deep and this section cannot do it full justice.]* + +*Normalization* is the process of designing or refactoring your tables +for maximum consistency and minimum redundancy. + +With NoSQL databases, we're used to *denormalized* data that is stored +with speed in mind, and not so much consistency (sometimes NoSQL +databases talk about *eventual consistency*). + +Non-normalized tables are considered an anti-pattern in relational databases. + +There are many *normal forms*. We'll talk about First, Second, and Third +normal forms. + + +### Anomalies + +One of the reasons for normalizing tables is to avoid *anomalies*. + +*Insert anomaly*: When we cannot insert a row into the table because +some of the dependent information is not yet known. For example, we +cannot create a new class record in the school database, because the +record requires at least one student, and none have enrolled yet. + +*Update anomaly*: When information is duplicated in the database *and* +some rows are updated but not others. For example, say a record contains +a city and a zipcode, but then the post office changes the zipcode. If +some of the records are updated but not others, some cities will have +the old zipcodes. + +*Delete anomaly*: The opposite of an insert anomaly. When we delete some +information and other related information must also be deleted against +our will. For example, deleting the last student from a course causes +the other course information to be also deleted. + +By normalizing your tables, you can avoid these anomalies. + +### First Normal Form (1NF) + +When a database is in first normal form, there is a primary key for each +row, and there are no repeating sets of columns that should be in their +own table. + +Unnormalized (column titles on separate lines for clarity): + + Farm + ID + AnimalName1 AnimalBreed1 AnimalProducesEggs1 + AnimalName2 AnimalBreed2 AnimalProducesEggs2 + +1NF: + + Farm + ID + + Animal + ID FarmID[FK Farm(ID)] Name Breed ProducesEggs + + +Use a [*join*](#joins) to select all the animals in the farm: + +```sql +SELECT Name, Farm.ID FROM Animal, Farm WHERE Farm.ID = Animal.FarmID; +``` + +### Second Normal Form (2NF) + +To be in 2NF, a table must already be in 1NF. + +Additionally, all non-key data must fully relate to the key data in the table. + +In the farm example, above, Animal has a Name and a key FarmID, but +these two pieces of information are not related. + +We can fix this by adding a table to link the other two tables together: + +2NF: + + Farm + ID + + FarmAnimal + FarmID[FK Farm(ID)] AnimalID[FK Animal(ID)] + + Animal + ID Name Breed ProducesEggs + +Use a [*join*](#joins) to select all the animals in the farms: + +```sql +SELECT Name, Farm.ID + FROM Animal, FarmAnimal, Farm + WHERE Farm.ID = FarmAnimal.FarmID AND + Animal.ID = FarmAnimal.AnimalID; +``` + + +### Third Normal Form (3NF) + +A table in 3NF must already be in 2NF. + +Additionally, columns that relate to each other AND to the key need to +be moved into their own tables. This is known as removing *transitive +dependencies*. + +In the Farm example, the columns `Breed` and `ProducesEggs` are related. +If you know the breed, you automatically know if it produces eggs or +not. + +3NF: + + Farm + ID + + FarmAnimal + FarmID[FK Farm(ID)] AnimalID[FK Animal(ID)] + + BreedEggs + Breed ProducesEggs + + Animal + ID Name Breed[FK BreedEggs(Breed)] + +Use a [*join*](#joins) to select all the animals names that produce eggs +in the farm: + +```sql +SELECT Name, Farm.ID + FROM Animal, FarmAnimal, BreedEggs, Farm + WHERE Farm.ID = FarmAnimal.FarmID AND + Animal.ID = FarmAnimal.AnimalID AND + Animal.Breed = BreedEggs.Breed AND + BreedEggs.ProducesEggs = TRUE; +``` + + +### More reading: + +* [Database Normalization Explained in Simple English](https://www.essentialsql.com/get-ready-to-learn-sql-database-normalization-explained-in-simple-english/) + +* [Description of the database normalization basics](https://support.microsoft.com/en-us/help/283878/description-of-the-database-normalization-basics) + +* [Database Normalization, Wikipedia](https://en.wikipedia.org/wiki/Database_normalization) (Dense) + + + +## Node-Postgres + +This is a library that allows you to interface with PostgreSQL through +NodeJS. + +Its [documentation](https://node-postgres.com/) is exceptionally good. + +* [Node-Postgres on GitHub](https://github.com/brianc/node-postgres) + + +### Assignments + +* [NodeJS Program to Create and Populate a Table](#assignment-nodejs-program-to-create-and-populate-a-table) + +* [Command-line Earthquake Query Tool](#assignment-command-line-earthquake-query-tool) + +* [RESTful Earthquake Data Server](#assignment-restful-earthquake-data-server) + + +## Security + +### PostgreSQL Password + +You might have noticed that you don't need a password to access your +database that you created. This is because PostgreSQL by default uses +something called [peer authentication +mode](https://www.postgresql.org/docs/9.6/static/auth-methods.html#AUTH-PEER). + +In a nutshell, it makes sure that you are logged in as yourself before +you access your database. If a different user tries to access your +database, they will be denied. + +If you need to set up password access, see [client authentication in the +PostgreSQL +manual](https://www.postgresql.org/docs/current/static/client-authentication.html) + +### Writing Client Software + +When writing code that accesses databases, there are a few rules you +should follow to keep things safe. + +* Don't store database passwords or other sensitive information in your + code repository. Store dummy credentials instead. + +* When building SQL queries in code, use [*parameterized + queries*](https://node-postgres.com/features/queries#parameterized-query). + You build your query with parameter placeholders for where the query + arguments will go. + + This is your number-one line of defense against [SQL injection + attacks](https://en.wikipedia.org/wiki/SQL_injection). + + **It's a seriously noob move to not use parameterized queries.** + + +## Other Relational Databases + +There are tons of them by Microsoft, Oracle, etc. etc. + +Other popular open source databases in widespread use are: + +* [MySQL](https://www.mysql.com/) Multi-user, industrial class. +* [SQLite](https://www.sqlite.org/) Single-user, very fast, good for config files. + + +## Assignment: Install PostgreSQL + +**IMPORTANT!** These instructions assume you haven't already installed +PostgreSQL. If you have already installed it, skip this section or +Google for how to upgrade your installation. + +### Mac with Homebrew + +1. Open a terminal +2. Install PostgreSQL: `brew install postgresql` + + If you get install errors at this point relating to the link phase + failing or missing permissions, look back in the output and see + what file it failed to write. + + For example, if it's failing to write something in + `/usr/local/share/man`-something, try setting the ownership on + those directories to yourself. + + Example (from the command line): + + `$ sudo chown -R $(whoami) /usr/local/share/man` + + Then try to install again. + +3. Start the database process + * If you want to start it every time you log in, run: + + brew services start postgresql + + * If you want to just start it one time right now, run: + + pg_ctl -D /usr/local/var/postgres start + +4. Create a database named the same as your username: `createdb $(whoami)` + * Optionally you can call it anything you want, but the shell + defaults to looking for a database named the same as your user. + + This database will contain tables. + +Then start a shell by running `psql` and see if it works. You should see +this prompt: + + $ psql + psql (10.1) + Type "help" for help. + + dbname=> + +(Use `psql databasename` if you created the database under something +other than your username.) + +Use `\l` to get a list of databases. + +You can enter `\q` to exit the shell. + +### Windows + +Reports are that one of the easiest installs is with +[chocolatey](https://chocolatey.org/packages/postgresql). Might want to try that +first. + +You can also [download a Windows +installer](https://www.postgresql.org/download/windows/) from the +official site. + +Another option is to use the [Windows Subsystem for +Linux](https://msdn.microsoft.com/en-us/commandline/wsl/install-win10) +and follow the [Ubuntu instructions for installing +PostgreSQL](https://help.ubuntu.com/community/PostgreSQL). + + +### Arch Linux + +Arch requires a bit more hands-on, but not much more. Check this out if +you want to see a different Unix-y install procedure (or if you run +Arch). + +* [Installing PostgreSQL on Arch + Linux](https://wiki.archlinux.org/index.php/PostgreSQL) + + +## Assignment: Create a Table and Use It + +Launch the shell on your database, and create a table. + +```sql +CREATE TABLE Employee (ID INT, FirstName VARCHAR(20), LastName VARCHAR(20)); +``` + +Insert some records: + +```sql +INSERT INTO Employee VALUES (1, 'Alpha', 'Alphason'); +INSERT INTO Employee VALUES (2, 'Bravo', 'Bravoson'); +INSERT INTO Employee VALUES (3, 'Charlie', 'Charleson'); +INSERT INTO Employee VALUES (4, 'Delta', 'Deltason'); +INSERT INTO Employee VALUES (5, 'Echo', 'Ecoson'); +``` + +Select all records: + +```sql +SELECT * FROM Employee; +``` + +Select Employee #3's record: + +```sql +SELECT * FROM Employee WHERE ID=3; +``` + +Delete Employee #3's record: + +```sql +DELETE FROM Employee WHERE ID=3; +``` + +Use `SELECT` to verify the record is deleted. + +Update Employee #2's name to be "Foxtrot Foxtrotson": + +```sql +UPDATE Employee SET FirstName='Foxtrot', LastName='Foxtrotson' WHERE ID=2; +``` + +Use `SELECT` to verify the update. + + +## Assignment: NodeJS Program to Create and Populate a Table + +Using [Node-Postgres](https://node-postgres.com/), write a program that +creates a table. + +Run the following query from your JS code: + +```sql +CREATE TABLE IF NOT EXISTS Earthquake + (Name VARCHAR(20), Magnitude REAL) +``` + +Populate the table with the following data: + +```javascript +let data = [ + ["Earthquake 1", 2.2], + ["Earthquake 2", 7.0], + ["Earthquake 3", 1.8], + ["Earthquake 4", 5.2], + ["Earthquake 5", 2.9], + ["Earthquake 6", 0.6], + ["Earthquake 7", 6.6] +]; +``` + +You'll have to run an `INSERT` statement for each one. + +Open a PostgreSQL shell (`psql`) and verify the table exists: + + user-> \dt + List of relations + Schema | Name | Type | Owner + --------+------------+-------+------- + public | earthquake | table | user + (1 row) + +Also verify it is populated: + + user-> SELECT * from Earthquake; + + name | magnitude + --------------+----------- + Earthquake 1 | 2.2 + Earthquake 2 | 7 + Earthquake 3 | 1.8 + Earthquake 4 | 5.2 + Earthquake 5 | 2.9 + Earthquake 6 | 0.6 + Earthquake 7 | 6.6 + (7 rows) + +Hints: +* [CREATE TABLE](#create-a-table-with-create-table) +* [Connecting to the database](https://node-postgres.com/features/connecting) +* [Running a query](https://node-postgres.com/features/queries) + +Extra Credit: +* Add an ID column to help normalize the database. Make this column + `SERIAL` to auto-increment. +* Add Date, Lat, and Lon columns to record more information about the + event. + + +## Assignment: Command-line Earthquake Query Tool + +Write a tool that queries the database for earthquakes that are at least +a given magnitude. + + $ node earthquake 2.9 + Earthquakes with magnitudes greater than or equal to 2.9: + + Earthquake 2: 7 + Earthquake 7: 6.6 + Earthquake 4: 5.2 + Earthquake 5: 2.9 + +Use `ORDER BY Magnitude DESC` to order the results in descending order +by magnitude. + + +## Assignment: RESTful Earthquake Data Server + +Use [ExpressJS](https://expressjs.com/) and write a webserver that +implements a RESTful API to access the earthquake data. + +Endpoints: + +`/` (GET) Output usage information in HTML. + +Example results: + +```html +<html> + <body>Usage: [endpoint info]</body> +</html> +``` + +`/minmag` (GET) Output JSON list of earthquakes that are larger than the +value specified in the `mag` parameter. Use form encoding to pass the +data. + +Example results: + +```json +{ + "results": [ + { + "name": "Earthquake 2", + "magnitude": 7 + }, + { + "name": "Earthquake 4", + "magnitude": 5.2 + } + ] +} +``` + +Extra Credit: + +`/new` (POST) Add a new earthquake to the database. Use form encoding to +pass `name` and `mag`. Return a JSON status message: + +```json +{ "status": "ok" } +``` + +or + +```json +{ "status": "error", "message": "[error message]" } +``` + + +`/delete` (DELETE) Delete an earthquake from the database. Use form +encoding to pass `name`. Return status similar to `/new`, above. + + + + + + +</details><details> <summary>1-projects/solutions/</summary> + +### [1-projects/solutions/README.md](1-projects/solutions/README.md) +<!-- START doctoc generated TOC please keep comment here to allow auto update --> +<!-- DON'T EDIT THIS SECTION, INSTEAD RE-RUN doctoc TO UPDATE --> +**Table of Contents** *generated with [DocToc](https://github.com/thlorenz/doctoc)* + +- [Sample Solutions](#sample-solutions) + +<!-- END doctoc generated TOC please keep comment here to allow auto update --> + +# Sample Solutions + +1. Run `npm install` to install the prereqs. +2. Run `node maketable` to create the DB tables. +3. Run `node earthquake 2.9` to see all earthquakes larger than + magnitude 2.9. + + + + +</details><details> <summary>1-projects/Sprint-Challenge--Intro-Python-master/</summary> + +### [1-projects/Sprint-Challenge--Intro-Python-master/README.md](1-projects/Sprint-Challenge--Intro-Python-master/README.md) +<!-- START doctoc generated TOC please keep comment here to allow auto update --> +<!-- DON'T EDIT THIS SECTION, INSTEAD RE-RUN doctoc TO UPDATE --> +**Table of Contents** *generated with [DocToc](https://github.com/thlorenz/doctoc)* + +- [Sprint Challenge: Intro to Python](#sprint-challenge-intro-to-python) + - [Instructions](#instructions) + - [Commits](#commits) + - [Description](#description) + - [Testing](#testing) + - [Minimum Viable Product](#minimum-viable-product) + - [Stretch Problems](#stretch-problems) + - [Rubric](#rubric) + +<!-- END doctoc generated TOC please keep comment here to allow auto update --> + +# Sprint Challenge: Intro to Python + +In this week's Sprint you explored the Python programming language as well as object-oriented design principles. This Sprint Challenge aims to assess your comfort in both of these areas through exercises similar to the ones you worked on at the beginning of this week in Intro to Python. + +## Instructions +**Read these instructions carefully. Understand exactly what is expected _before_ starting this Sprint Challenge.** + +This is an individual assessment. All work must be your own. Your challenge score is a measure of your ability to work independently using the material covered through this sprint. You need to demonstrate proficiency in the concepts and objectives introduced and practiced in the preceding days. + +You are not allowed to collaborate during the Sprint Challenge. However, you are encouraged to follow the twenty-minute rule and seek support from your PM and Instructor in your cohort help channel on Slack. Your submitted work reflects your proficiency in the concepts and topics that were covered this week. + +You have three hours to complete this Sprint Challenge. Plan your time accordingly. + +## Commits + +Commit your code regularly and meaningfully. This helps both you (in case you ever need to return to old code for any number of reasons) and it also helps your project manager to more thoroughly assess your work. + +## Description + +Complete the programs in the `src/` directory in any order. + +* `oop/` + * `oop1.py`: class hierarchies + * `oop2.py`: subclassing and method overriding +* `comp/` + * `comp.py`: list comprehensions +* `cityreader/` + * `cityreader.py`: modules and CSV file reading + +## Testing + +Each file has its own associated test file. To test your code, run `python [name_of_test_file.py]` or `python3 [name_of_test_file.py]` if your Python 3 command is mapped to `python3`. Note: `cityreader` needs to be run from the same directory as the files or it will not be able to find the associated CSV file. + +The `cityreader` stretch goal has its own test file, `test_stretch.py`, if you want to take a stab at implementing the stretch problem. + +**_It's never a bad idea to take a look at the test files in order to see what each test is expecting._** + +## Minimum Viable Product + +In order to meet MVP requirements for this Sprint Challenge, complete all of the exercises posed in each directory by getting the tests for each exercise to pass. + +In your solution, it is essential that you follow best practices and produce clean and professional results. Schedule time to review, refine, and assess your work and perform basic professional polishing including spell-checking and grammar-checking on your work. It is better to submit a challenge that meets the MVP requirements than one that attempts too much and does not. + +## Stretch Problems + +The `cityreader` directory poses an stretch problem that builds upon the functionality you are to implement as part of the non-stretch requirements in the `cityreader` directory. + +There's a separate test file `test_stretch.py` for the stretch problem that you can run in order to test your implementation of the stretch problem. + +## Rubric +| OBJECTIVE | TASK | 1 - DOES NOT MEET Expectations | 2 - MEETS Expectations | 3 - EXCEEDS Expectations | SCORE | +| ---------- | ----- | ------- | ------- | ------- | -- | +| _Student can demonstrate applied knowledge of Python basics by producing list comprehensions in `comp.py`_ | List Comprehensions: (1 point per problem, 8 max) | 0-5 points | 6-7 points | 8 points | | +| _Student can demonstrate applied knowledge of Object-Oriented Programming by completing `oop1.py` and `oop2.py`_ | OOP: (2 points per file, 4 max) | 0 points | 2 points | 4 points | | +| _Student can demonstrate applied research and language learning by completing `cityreader.py`_ | CSV: 6 points for `cityreader()`, 1 point for `cityreader_stretch()` | 0 points | 6 points | 7 points | | +| **FINAL SCORE** | | **0-13** | **14-18** | **19** | | + + + + + +</details><details> <summary>1-projects/web-guided-project-testing-web-apps-solution-main/</summary> + +### [1-projects/web-guided-project-testing-web-apps-solution-main/README.md](1-projects/web-guided-project-testing-web-apps-solution-main/README.md) +<!-- START doctoc generated TOC please keep comment here to allow auto update --> +<!-- DON'T EDIT THIS SECTION, INSTEAD RE-RUN doctoc TO UPDATE --> +**Table of Contents** *generated with [DocToc](https://github.com/thlorenz/doctoc)* + +- [Sprint 1 - Module 4 : Integration Testing Lesson Plan](#sprint-1---module-4--integration-testing-lesson-plan) + - [Training Kit](#training-kit) + - [Previous Lesson Plan](#previous-lesson-plan) + - [Objectives](#objectives) + - [Instructor Resources](#instructor-resources) + - [Guided Project Slack Message](#guided-project-slack-message) + - [Guided Project Zoom Invitation:](#guided-project-zoom-invitation) + - [Check for Understanding Questions](#check-for-understanding-questions) + - [What kind of function is this - toBeInTheDocument?](#what-kind-of-function-is-this---tobeinthedocument) + - [What function allows you to mimic browser events in your tests?](#what-function-allows-you-to-mimic-browser-events-in-your-tests) + - [Which of the following would allow you to mimic a user typing into a text input?](#which-of-the-following-would-allow-you-to-mimic-a-user-typing-into-a-text-input) + - [Which query functions allow you to "wait" for state to be updated after an event has been fired off?](#which-query-functions-allow-you-to-wait-for-state-to-be-updated-after-an-event-has-been-fired-off) + - [Guided Project Outline](#guided-project-outline) + - [Introduce Module:](#introduce-module) + - [Discuss Automated Testing:](#discuss-automated-testing) + - [Introduce Deployment Process:](#introduce-deployment-process) + - [Types of Testing:](#types-of-testing) + - [What do integration tests test?](#what-do-integration-tests-test) + - [How will we be testing?](#how-will-we-be-testing) + - [BREAK](#break) + - [Tour our example application.](#tour-our-example-application) + - [Creating test suites.](#creating-test-suites) + - [Testing App.js](#testing-appjs) + - [Testing with case insensitivity.](#testing-with-case-insensitivity) + - [BREAK](#break-1) + - [Create tests for AnimalForm](#create-tests-for-animalform) + - [Walk through our submission test](#walk-through-our-submission-test) + - [Start to create test](#start-to-create-test) + - [Module Project Review](#module-project-review) + - [Breakout Slack Messages](#breakout-slack-messages) + - [After Class Message](#after-class-message) + +<!-- END doctoc generated TOC please keep comment here to allow auto update --> + +# Sprint 1 - Module 4 : Integration Testing Lesson Plan + +## [Training Kit](https://github.com/LambdaSchool/Full-Stack-Web-Curriculum/tree/main/03-WebApplications-II/Sprint%2001%20-%20Advanced%20React/Module%204%20-%20Testing%20Web%20Applications) + +### [Previous Lesson Plan](https://github.com/LambdaSchool/web-guided-porject-rtl-i-solution) + +---- + +## Objectives + +By the end of this module, learners should be able to: +* explain what automated testing is and its importance +* use react-testing-library for testing react components +* use react-testing-library to test user interactions with fireEvent + +---- + +## Instructor Resources +* 🐙 [Guided Project Starter](https://github.com/LambdaSchool/web-guided-project-testing-web-apps) +* 🐙 [Guided Project Solution](https://github.com/LambdaSchool/web-guided-project-testing-web-apps-solution) +* 🐙 [Module Project](https://github.com/LambdaSchool/web-module-project-testing-web-apps) +* 🐙 [Module Project Solution](https://github.com/LambdaSchool/web-module-project-testing-web-apps-solution) + +---- + +## Guided Project Slack Message +> **Welcome to Unit 3!** +> +> 1. Clone without forking the following repo: https://github.com/LambdaSchool/web-guided-project-testing-web-apps +> 2. Navigate into the root folder and run npm i to load dependences. +> +> :point_right: Technical issues spinning up the project? Please head over to the help channel! +> +> :point_right: If you fall behind during lecture and wish to catch up: +> +> `git fetch && git reset --hard origin/lecture` +> +> :point_right: Slido event: https://app.sli.do/event/msea4w8q + +---- + +## Guided Project Zoom Invitation: +> **Unit 3 | Sprint 1 | Module 4: Integration Testing For React** +> _______________________________________________________ +> Zoom Link : https://lambdaschool.zoom.us/j/3076367334 +> +> Slido: https://app.sli.do/event/msea4w8q +> +> Guided Project: https://github.com/LambdaSchool/web-guided-project-testing-web-apps +> +> Module Project: https://github.com/LambdaSchool/web-module-project-testing-web-apps + +---- + +## Check for Understanding Questions + +These are the questions used internally to check student understanding. Students will be instructed to answer these questions after the guided project. Please make sure to emphasize the concepts behind these answers. + +#### What kind of function is this - toBeInTheDocument? +* Jest function +* **Assertion function** +* Describe function +* Query function + +#### What function allows you to mimic browser events in your tests? +* fire +* eventFire +* **fireEvent** +* onClick + +#### Which of the following would allow you to mimic a user typing into a text input? +* fireEvent.click(inputButton) +* fireEvent.click(firstNameInput, { target: { value: 'Tony' } }) +* fireEvent.type(firstNameInput, { +target: { value: 'Tony' } }) +* **fireEvent.change(firstNameInput, { target: { value: 'Tony' } })** + +#### Which query functions allow you to "wait" for state to be updated after an event has been fired off? +* getBy* +* All of the Above +* **findBy*** +* queryBy + +## Guided Project Outline + +### Introduce Module: +* Present that this is the last day of the sprint. +* Remind that this is also a standalone lesson. +* Present that we will be going into integration testing in React. + +### Discuss Automated Testing: +* Helps to find bugs early in the process. +* Helps to document your code. +* Introduce the idea of Test Driven Development. +* Also testing is an important part of project deployment. + +### Introduce Deployment Process: +* Testing is a part of a larger deployment pipeline. +* Testing allows for bugs in new code pushed in multi-developer projects does not break production. +* This is a part of the DevOpps engineers job. +* Different types of tests are a part of the deployment project. +* All are needed. + +### Types of Testing: +* End to End - covers application wide paths. +* Integration - covers component or small component group paths. +* Unit Tests - covers indivisual functions, components or modules. Digs into implementation of a code. + +### What do integration tests test? +* If a user does this, this behavoir happens. +* Sepecific to behavior, not implementation. Styling is not included. How it is coded is not included. +* Think in very specific terms. +* Write in full sentences when making your list of tests. +* Give students a two minutes to create a list of intergration tests for a site. + +### How will we be testing? +* Arrange - Setup of the component being tested. +* Act - Execute the behavior we are testing. +* Assert - Extract response element and see if it is what we expect it to be. + +### BREAK + +### Tour our example application. +* Point out header element. +* Point out form element. +* Test for validation and display. +* Tour App.js +* Tour AnimalForm.js +* Tour package.json + 1. Note that testing library is added by default through create react app + 2. jest-dom holds assertions + 3. react holds virtual dom + 4. user-event holds library for interacting with user events. + 5. Note scripts and point out test script +* Run npm test. +* Show moving panel to the right in vs code. +* Note test runners. + +### Creating test suites. +* Note that our test runner automatically find each test suite in our application, finds test files and runs the test inside of them. +* Note that tests fail if they don't have tests inside them. +* Setup App.test.js + 1. import react + 2. import render from /react. + 3. create tests. +* Note how it works. +* Note how describe works. +* Note that test suites can have .test or .spec formating. +* Note that for integration tests EACH COMPONENT SHOULD HAVE IT'S OWN TEST SUITE. + +### Testing App.js +* Always test rendering of the component first. +* Note that the first pass of any test is if there is an error anywhere in the test or code. +* Setup test for the existance of the header component. + 1. Arrange - Setup the component + * render(component) + * Note that it returns a value + 2. Act - extract the part of the DOM we want to test. + * We need to query a DOM element. + * Using screen to query for items. + * const header = screen.getByText("Add New Animal"); + * Note that not finding an element results in a test failing. + * Note that there are many ways to query an element. [https://testing-library.com/docs/react-testing-library/cheatsheet/](https://testing-library.com/docs/react-testing-library/cheatsheet/) + * Note the differences between get / find and query. + * Note the types of query critria. + + 3. Assert - Test the change. + * expect() is a means to test an element along with a certain conditional. + * Note that there are many ways to test an expect [https://jestjs.io/docs/en/expect](https://jestjs.io/docs/en/expect) + * Note .not + +### Testing with case insensitivity. +* Note that changing case breaks the test. +* Discuss why this might be a problem. +* Use regular expressions to add case insensitivity. /add new animal/i + +### BREAK + +### Create tests for AnimalForm +* Create new test suite. +* Add in imports. +* Add intro render component. + +### Walk through our submission test +* Add a value to our text field +* Submit form. +* Note the output. + +### Start to create test +* render component +* Walk through Act steps: + 1. get access to form fields. + 2. add text to fields + * Query for text field using getByLabelText. + * Add userEvent for typing in values. userEvent.type(); + 3. get access to and click button. + * Query for button by role. + * Click button using userEvent.click(); +* Walk through Assert step + 1. queryByText(/canine/i); + 2. Note the difference between query, get and find. + + +### Module Project Review +* [https://github.com/LambdaSchool/web-module-project-custom-hook](https://github.com/LambdaSchool/web-module-project-custom-hook) + +## Breakout Slack Messages + +---- + +## After Class Message +Hope you all enjoyed today's guided Lesson! +A reminder if that office hours are from 2:30 - 3:30 Lambda Time. Don't forget to complete the days Check for Understanding and Pulse Checks! + +Module Project: https://github.com/LambdaSchool/web-module-project-custom-hook + +Here is a review of today's material. + +Key Terminology: +* 📝 *RTL querys* - [React Testing Library queries allow uses to select elments from the DOM for testing.](https://testing-library.com/docs/react-testing-library/cheatsheet/)[Also See](https://testing-library.com/docs/queries/about) +* 📝 *ARIA roles* - [DOM elements that have role attributes automatically assigned to them.](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Roles) +* 📝 *expect* - [expect is a jest method used to test the value of an element](https://jestjs.io/docs/en/expect.html) +* 📝 *fireEvent / userEvent* - [fireEvent is a react testing library method used to simulate user input. userEvent is a more advanced and simplified version of fireevent.](https://testing-library.com/docs/ecosystem-user-event/) +* 📝 *regular expressions* - [A regular expression (shortened as regex or regexp) is a sequence of characters that define a search pattern](https://www.youtube.com/watch?v=sXQxhojSdZM) +* 📝 *async / await* - [A javascript idea that allows for a more streamline processing of promises.](https://javascript.info/async-await) + +Key Concepts: +* 📝 *end-to-end tests* - [a testing method that involves testing an application's workflow from beginning to end. This method basically aims to replicate real user scenarios.](https://www.browserstack.com/guide/end-to-end-testing) +* 📝 *integration tests* - [A method of software testing where individual components or units of code are tested to validate user interactions.](https://www.testingxperts.com/blog/what-is-integration-testing#What%20is%20Integration%20Testing?) +* 📝 *unit tests* - [A level of software testing where individual units / components of a software are tested. The purpose is to validate that each unit of the software performs as designed.](https://softwaretestingfundamentals.com/unit-testing/) +* 📝 *react testing library* - [a light-weight solution for testing React components. ](https://testing-library.com/docs/react-testing-library/intro/) +* 📝 *test driven development* - [A programming methodology that encourages early testing and later ui development](https://www.youtube.com/watch?v=y8TcPr73Bwo) + + + + +</details><details> <summary>1-projects/webapi-ii-challenge-master/</summary> + +### [1-projects/webapi-ii-challenge-master/README.md](1-projects/webapi-ii-challenge-master/README.md) +<!-- START doctoc generated TOC please keep comment here to allow auto update --> +<!-- DON'T EDIT THIS SECTION, INSTEAD RE-RUN doctoc TO UPDATE --> +**Table of Contents** *generated with [DocToc](https://github.com/thlorenz/doctoc)* + +- [Building RESTful APIs with Express](#building-restful-apis-with-express) + - [Topics](#topics) + - [Description](#description) + - [Project Setup](#project-setup) + - [Database Persistence Helpers](#database-persistence-helpers) + - [Blog Post Schema](#blog-post-schema) + - [Comment Schema](#comment-schema) + - [Minimum Viable Product](#minimum-viable-product) + - [Endpoints](#endpoints) + - [Endpoint Specifications](#endpoint-specifications) + - [Stretch Problems](#stretch-problems) + +<!-- END doctoc generated TOC please keep comment here to allow auto update --> + +# Building RESTful APIs with Express + +## Topics + +- Express Routing +- Reading Request data from body and URL parameters +- Sub-routes +- API design and development. + +## Description + +Use `Node.js` and `Express` to build an API that performs _CRUD_ operations on `blog posts`. + +### Project Setup + +- **Fork** and **Clone** this repository. +- **CD into the folder** where you cloned the repository. +- Type `npm install` to download all dependencies. +- To start the server, type `npm run server` from the root folder (where the _package.json_ file is). The server is configured to restart automatically as you make changes. + +### Database Persistence Helpers + +The `data` folder contains a database populated with test `posts`. + +Database access will be done using the `db.js` file included inside the `data` folder. + +The `db.js` publishes the following methods: + +- `find()`: calling find returns a promise that resolves to an array of all the `posts` contained in the database. +- `findById()`: this method expects an `id` as it's only parameter and returns the post corresponding to the `id` provided or an empty array if no post with that `id` is found. +- `insert()`: calling insert passing it a `post` object will add it to the database and return an object with the `id` of the inserted post. The object looks like this: `{ id: 123 }`. +- `update()`: accepts two arguments, the first is the `id` of the post to update and the second is an object with the `changes` to apply. It returns the count of updated records. If the count is 1 it means the record was updated correctly. +- `remove()`: the remove method accepts an `id` as its first parameter and upon successfully deleting the post from the database it returns the number of records deleted. +- `findPostComments()`: the findPostComments accepts a `postId` as its first parameter and returns all comments on the post associated with the post id. +- `findCommentById()`: accepts an `id` and returns the comment associated with that id. +- `insertComment()`: calling insertComment while passing it a `comment` object will add it to the database and return an object with the `id` of the inserted comment. The object looks like this: `{ id: 123 }`. This method will throw an error if the `post_id` field in the `comment` object does not match a valid post id in the database. + +Now that we have a way to add, update, remove and retrieve data from the provided database, it is time to work on the API. + +### Blog Post Schema + +A Blog Post in the database has the following structure: + +```js +{ + title: "The post title", // String, required + contents: "The post contents", // String, required + created_at: Mon Aug 14 2017 12:50:16 GMT-0700 (PDT) // Date, defaults to current date + updated_at: Mon Aug 14 2017 12:50:16 GMT-0700 (PDT) // Date, defaults to current date +} +``` + +### Comment Schema + +A Comment in the database has the following structure: + +```js +{ + text: "The text of the comment", // String, required + post_id: "The id of the associated post", // Integer, required, must match the id of a post entry in the database + created_at: Mon Aug 14 2017 12:50:16 GMT-0700 (PDT) // Date, defaults to current date + updated_at: Mon Aug 14 2017 12:50:16 GMT-0700 (PDT) // Date, defaults to current date +} +``` + +### Minimum Viable Product + +- Add the code necessary to implement the endpoints listed below. +- Separate the endpoints that begin with `/api/posts` into a separate `Express Router`. + +### Endpoints + +Configure the API to handle to the following routes: + +| Method | Endpoint | Description | +| ------ | ----------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | +| POST | /api/posts | Creates a post using the information sent inside the `request body`. | +| POST | /api/posts/:id/comments | Creates a comment for the post with the specified id using information sent inside of the `request body`. | +| GET | /api/posts | Returns an array of all the post objects contained in the database. | +| GET | /api/posts/:id | Returns the post object with the specified id. | +| GET | /api/posts/:id/comments | Returns an array of all the comment objects associated with the post with the specified id. | +| DELETE | /api/posts/:id | Removes the post with the specified id and returns the **deleted post object**. You may need to make additional calls to the database in order to satisfy this requirement. | +| PUT | /api/posts/:id | Updates the post with the specified `id` using data from the `request body`. Returns the modified document, **NOT the original**. | + +#### Endpoint Specifications + +When the client makes a `POST` request to `/api/posts`: + +- If the request body is missing the `title` or `contents` property: + + - cancel the request. + - respond with HTTP status code `400` (Bad Request). + - return the following JSON response: `{ errorMessage: "Please provide title and contents for the post." }`. + +- If the information about the _post_ is valid: + + - save the new _post_ the the database. + - return HTTP status code `201` (Created). + - return the newly created _post_. + +- If there's an error while saving the _post_: + - cancel the request. + - respond with HTTP status code `500` (Server Error). + - return the following JSON object: `{ error: "There was an error while saving the post to the database" }`. + +When the client makes a `POST` request to `/api/posts/:id/comments`: + +- If the _post_ with the specified `id` is not found: + + - return HTTP status code `404` (Not Found). + - return the following JSON object: `{ message: "The post with the specified ID does not exist." }`. + +- If the request body is missing the `text` property: + + - cancel the request. + - respond with HTTP status code `400` (Bad Request). + - return the following JSON response: `{ errorMessage: "Please provide text for the comment." }`. + +- If the information about the _comment_ is valid: + + - save the new _comment_ the the database. + - return HTTP status code `201` (Created). + - return the newly created _comment_. + +- If there's an error while saving the _comment_: + - cancel the request. + - respond with HTTP status code `500` (Server Error). + - return the following JSON object: `{ error: "There was an error while saving the comment to the database" }`. + +When the client makes a `GET` request to `/api/posts`: + +- If there's an error in retrieving the _posts_ from the database: + - cancel the request. + - respond with HTTP status code `500`. + - return the following JSON object: `{ error: "The posts information could not be retrieved." }`. + +When the client makes a `GET` request to `/api/posts/:id`: + +- If the _post_ with the specified `id` is not found: + + - return HTTP status code `404` (Not Found). + - return the following JSON object: `{ message: "The post with the specified ID does not exist." }`. + +- If there's an error in retrieving the _post_ from the database: + - cancel the request. + - respond with HTTP status code `500`. + - return the following JSON object: `{ error: "The post information could not be retrieved." }`. + +When the client makes a `GET` request to `/api/posts/:id/comments`: + +- If the _post_ with the specified `id` is not found: + + - return HTTP status code `404` (Not Found). + - return the following JSON object: `{ message: "The post with the specified ID does not exist." }`. + +- If there's an error in retrieving the _comments_ from the database: + - cancel the request. + - respond with HTTP status code `500`. + - return the following JSON object: `{ error: "The comments information could not be retrieved." }`. + +When the client makes a `DELETE` request to `/api/posts/:id`: + +- If the _post_ with the specified `id` is not found: + + - return HTTP status code `404` (Not Found). + - return the following JSON object: `{ message: "The post with the specified ID does not exist." }`. + +- If there's an error in removing the _post_ from the database: + - cancel the request. + - respond with HTTP status code `500`. + - return the following JSON object: `{ error: "The post could not be removed" }`. + +When the client makes a `PUT` request to `/api/posts/:id`: + +- If the _post_ with the specified `id` is not found: + + - return HTTP status code `404` (Not Found). + - return the following JSON object: `{ message: "The post with the specified ID does not exist." }`. + +- If the request body is missing the `title` or `contents` property: + + - cancel the request. + - respond with HTTP status code `400` (Bad Request). + - return the following JSON response: `{ errorMessage: "Please provide title and contents for the post." }`. + +- If there's an error when updating the _post_: + + - cancel the request. + - respond with HTTP status code `500`. + - return the following JSON object: `{ error: "The post information could not be modified." }`. + +- If the post is found and the new information is valid: + + - update the post document in the database using the new information sent in the `request body`. + - return HTTP status code `200` (OK). + - return the newly updated _post_. + +## Stretch Problems + +To work on the stretch problems you'll need to enable the `cors` middleware. Follow these steps: + +- add the `cors` npm module: `npm i cors`. +- add `server.use(cors())` after `server.use(express.json())`. + +Create a new React application and connect it to your server: + +- Use `create-react-app` to create an application inside the root folder, name it `client`. +- From the React application connect to the `/api/posts` endpoint in the API and show the list of posts. +- Style the list of posts however you see fit. + + + + + +</details><details> <summary>2-resources/__CHEAT-SHEETS/All/</summary> + +### [2-resources/__CHEAT-SHEETS/All/101.md](2-resources/__CHEAT-SHEETS/All/101.md) +<!-- START doctoc generated TOC please keep comment here to allow auto update --> +<!-- DON'T EDIT THIS SECTION, INSTEAD RE-RUN doctoc TO UPDATE --> +**Table of Contents** *generated with [DocToc](https://github.com/thlorenz/doctoc)* + + - [Usage](#usage) + - [Type checking](#type-checking) +- [Objects](#objects) + - [Example](#example) + - [Update](#update) + - [Read](#read) + - [Delete](#delete) + - [Getting](#getting) + - [Setting](#setting) + - [Deleting](#deleting) + - [Keypath check](#keypath-check) + - [Get values](#get-values) +- [Functions](#functions) + - [Simple functions](#simple-functions) + - [Composition](#composition) + - [And/or](#andor) + - [Converge](#converge) +- [Arrays](#arrays) + - [Finding](#finding) + - [Grouping](#grouping) +- [Examples](#examples) + - [Function composition](#function-composition) +- [Reference](#reference) + +<!-- END doctoc generated TOC please keep comment here to allow auto update --> + +--- +title: 101 +category: JavaScript libraries +layout: 2017/sheet +updated: 2017-09-21 +intro: | + [101](https://www.npmjs.com/package/101) is a JavaScript library for dealing with immutable data in a functional manner. +--- + +### Usage + +```js +const isObject = require('101/isObject') +isObject({}) // → true +``` + +Every function is exposed as a module. + +See: [101](https://github.com/tjmehta/101) + +### Type checking + +```js +isObject({}) +isString('str') +isRegExp(/regexp/) +isBoolean(true) +isEmpty({}) +isfunction(x => x) +isInteger(10) +isNumber(10.1) +instanceOf(obj, 'string') +``` + +## Objects +{: .-three-column} + +### Example +{: .-prime} + +```js +let obj = {} +``` + +#### Update + +```js +obj = put(obj, 'user.name', 'John') +// → { user: { name: 'John' } } +``` + +#### Read + +```js +pluck(name, 'user.name') +// → 'John' +``` + +#### Delete + +```js +obj = del(obj, 'user') +// → { } +``` + +### Getting + +```js +pluck(state, 'user.profile.name') +``` + +```js +pick(state, ['user', 'ui']) +pick(state, /^_/) +``` + +`pluck` returns values, `pick` returns subsets of objects. + +See: +[pluck](https://github.com/tjmehta/101#pluck), +[pick](https://github.com/tjmehta/101#pick) + +### Setting + +```js +put(state, 'user.profile.name', 'john') +``` + +See: +[put](https://github.com/tjmehta/101#put) + +### Deleting + +```js +del(state, 'user.profile') +omit(state, ['user', 'data']) +``` + +`omit` is like `del`, but supports multiple keys to be deleted. + +See: +[omit](https://github.com/tjmehta/101#omit), +[del](https://github.com/tjmehta/101#del) + +### Keypath check + +```js +hasKeypaths(state, ['user']) +hasKeypaths(state, { 'user.profile.name': 'john' }) +``` + +See: +[hasKeypaths](https://github.com/tjmehta/101#haskeypaths) + +### Get values + +```js +values(state) +``` + +## Functions + +### Simple functions + +| `and(x, y)` | `x && y` | +| `or(x, y)` | `x || y` | +| `xor(x, y)` | `!(!x && !y) && !(x && y)` | +| `equals(x, y)` | `x === y` | +| `exists(x)` | `!!x` | +| `not(x)` | `!x` | + +Useful for function composition. + +See: +[and](https://github.com/tjmehta/101#and), +[equals](https://github.com/tjmehta/101#equals), +[exists](https://github.com/tjmehta/101#exists) + +### Composition + +```js +compose(f, g) // x => f(g(x)) +curry(f) // x => y => f(x, y) +flip(f) // f(x, y) --> f(y, x) +``` + +See: +[compose](https://github.com/tjmehta/101#compose), +[curry](https://github.com/tjmehta/101#curry), +[flip](https://github.com/tjmehta/101#flip) + +### And/or + +```js +passAll(f, g) // x => f(x) && g(x) +passAny(f, g) // x => f(x) || g(x) +``` + +See: +[passAll](https://github.com/tjmehta/101#passall), +[passAny](https://github.com/tjmehta/101#passany) + +### Converge + +```js +converge(and, [pluck('a'), pluck('b')])(x) +``` + +```js +// → and(pluck(x, 'a'), pluck(x, 'b')) +``` + +See: +[converge](https://github.com/tjmehta/101#converge) + +## Arrays + +### Finding + +```js +find(list, x => x.y === 2) +findIndex(list, x => ...) +includes(list, 'item') +last(list) +``` + +```js +find(list, hasProps('id')) +``` + +### Grouping + +```js +groupBy(list, 'id') +indexBy(list, 'id') +``` + +## Examples + +### Function composition + +```js +isFloat = passAll(isNumber, compose(isInteger, not)) +// n => isNumber(n) && not(isInteger(n)) +``` + +```js +function doStuff (object, options) { ... } + +doStuffForce = curry(flip(doStuff))({ force: true }) +``` + +## Reference + +- <https://github.com/tjmehta/101> + + + + + +### [2-resources/__CHEAT-SHEETS/All/absinthe.md](2-resources/__CHEAT-SHEETS/All/absinthe.md) + +<!-- START doctoc generated TOC please keep comment here to allow auto update --> +<!-- DON'T EDIT THIS SECTION, INSTEAD RE-RUN doctoc TO UPDATE --> +**Table of Contents** *generated with [DocToc](https://github.com/thlorenz/doctoc)* + +- [Introduction](#introduction) + - [Concepts](#concepts) + - [Plug](#plug) + - [web/router.ex](#webrouterex) +- [Main concepts](#main-concepts) + - [Schema](#schema) + - [web/schema.ex](#webschemaex) + - [Resolver](#resolver) + - [web/resolvers/post_resolver.ex](#webresolverspost_resolverex) + - [Type](#type) + - [web/schema/types.ex](#webschematypesex) +- [Schema](#schema-1) + - [Query arguments](#query-arguments) + - [GraphQL query](#graphql-query) + - [web/schema.ex](#webschemaex-1) + - [Resolver](#resolver-1) + - [Mutations](#mutations) + - [GraphQL query](#graphql-query-1) + - [web/schema.ex](#webschemaex-2) +- [References](#references) + +<!-- END doctoc generated TOC please keep comment here to allow auto update --> + +--- +title: Absinthe +category: Hidden +layout: 2017/sheet +tags: [WIP] +updated: 2017-10-10 +intro: | + [Absinthe](http://absinthe-graphql.org/) allows you to write GraphQL servers in Elixir. +--- + +## Introduction + +### Concepts + +- `Schema` - The root. Defines what queries you can do, and what types they return. +- `Resolver` - Functions that return data. +- `Type` - A type definition describing the shape of the data you'll return. + +### Plug + +#### web/router.ex + +```elixir +defmodule Blog.Web.Router do + use Phoenix.Router + + forward "/", Absinthe.Plug, + schema: Blog.Schema +end +``` +{: data-line="4,5"} + +Absinthe is a Plug, and you pass it one **Schema**. + +See: [Our first query](http://absinthe-graphql.org/tutorial/our-first-query/) + +## Main concepts +{: .-three-column} + +### Schema + +#### web/schema.ex + +```elixir +defmodule Blog.Schema do + use Absinthe.Schema + import_types Blog.Schema.Types + + query do + @desc "Get a list of blog posts" + field :posts, list_of(:post) do + resolve &Blog.PostResolver.all/2 + end + end +end +``` +{: data-line="5,6,7,8,9,10"} + +This schema will account for `{ posts { ··· } }`. It returns a **Type** of `:post`, and delegates to a **Resolver**. + +### Resolver + +#### web/resolvers/post_resolver.ex + +```elixir +defmodule Blog.PostResolver do + def all(_args, _info) do + {:ok, Blog.Repo.all(Blog.Post)} + end +end +``` +{: data-line="3"} + +This is the function that the schema delegated the `posts` query to. + +### Type + +#### web/schema/types.ex + +```elixir +defmodule Blog.Schema.Types do + use Absinthe.Schema.Notation + + @desc "A blog post" + object :post do + field :id, :id + field :title, :string + field :body, :string + end +end +``` +{: data-line="4,5,6,7,8,9"} + +This defines a type `:post`, which is used by the resolver. + +## Schema + +### Query arguments + +#### GraphQL query + +``` +{ user(id: "1") { ··· } } +``` + +#### web/schema.ex + +```elixir +query do + field :user, type: :user do + arg :id, non_null(:id) + resolve &Blog.UserResolver.find/2 + end +end +``` +{: data-line="3"} + +#### Resolver + +```elixir +def find(%{id: id} = args, _info) do + ··· +end +``` +{: data-line="1"} + +See: [Query arguments](http://absinthe-graphql.org/tutorial/query-arguments/) + +### Mutations + +#### GraphQL query + +``` +{ + mutation CreatePost { + post(title: "Hello") { id } + } +} +``` + +#### web/schema.ex + +```elixir +mutation do + @desc "Create a post" + field :post, type: :post do + arg :title, non_null(:string) + resolve &Blog.PostResolver.create/2 + end +end +``` +{: data-line="1"} + +See: [Mutations](http://absinthe-graphql.org/tutorial/mutations/) + +## References + + - [Absinthe website](http://absinthe-graphql.org/) _(absinthe-graphql.org)_ + - [GraphQL cheatsheet](./graphql) _(devhints.io)_ + + +### [2-resources/__CHEAT-SHEETS/All/activeadmin.md](2-resources/__CHEAT-SHEETS/All/activeadmin.md) + +<!-- START doctoc generated TOC please keep comment here to allow auto update --> +<!-- DON'T EDIT THIS SECTION, INSTEAD RE-RUN doctoc TO UPDATE --> +**Table of Contents** *generated with [DocToc](https://github.com/thlorenz/doctoc)* + +- [Listing scopes](#listing-scopes) +- [Sidebar filters](#sidebar-filters) +- [Custom actions](#custom-actions) + - [Make the route](#make-the-route) + - [Link it in the index](#link-it-in-the-index) + - [And link it in show/edit](#and-link-it-in-showedit) +- [Columns](#columns) +- [Other helpers](#other-helpers) +- [Disabling 'new post'](#disabling-new-post) + +<!-- END doctoc generated TOC please keep comment here to allow auto update --> + +--- +title: ActiveAdmin +category: Ruby +layout: 2017/sheet +--- + +### Listing scopes + +Allows you to filter listings by a certain scope. +{: .-setup} + +```ruby +scope :draft +scope :for_approval +``` + +```ruby +scope :public, if: ->{ current_admin_user.can?(...) } +scope "Unapproved", :pending +scope("Published") { |books| books.where(:published: true) } +``` + +### Sidebar filters + +```ruby +filter :email +filter :username +``` + +### Custom actions + +You can define custom actions for models. +{: .-setup} + +```ruby +before_filter only: [:show, :edit, :publish] do + @post = Post.find(params[:id]) +end +``` + +#### Make the route + +```ruby +member_action :publish, method: :put do + @post.publish! + redirect_to admin_posts_path, notice: "The post '#{@post}' has been published!" +end +``` + +#### Link it in the index + +```ruby +index do + column do |post| + link_to 'Publish', publish_admin_post_path(post), method: :put + end +end +``` + +#### And link it in show/edit + +```ruby +action_item only: [:edit, :show] do + @post = Post.find(params[:id]) + link_to 'Publish', publish_admin_post_path(post), method: :put +end +``` + +### Columns + +```ruby +column :foo +``` + +```ruby +column :title, sortable: :name do |post| + strong post.title +end +``` + +### Other helpers + +```ruby +status_tag "Done" # Gray +status_tag "Finished", :ok # Green +status_tag "You", :warn # Orange +status_tag "Failed", :error # Red +``` + +### Disabling 'new post' + +```ruby +ActiveAdmin.register Post do + actions :index, :edit + # or: config.clear_action_items! +end +``` + + +### [2-resources/__CHEAT-SHEETS/All/adb.md](2-resources/__CHEAT-SHEETS/All/adb.md) + +<!-- START doctoc generated TOC please keep comment here to allow auto update --> +<!-- DON'T EDIT THIS SECTION, INSTEAD RE-RUN doctoc TO UPDATE --> +**Table of Contents** *generated with [DocToc](https://github.com/thlorenz/doctoc)* + +- [Device Basics](#device-basics) + - [Examples](#examples) +- [Logcat](#logcat) + - [Examples](#examples-1) +- [File Management](#file-management) + - [Examples](#examples-2) +- [Remote Shell](#remote-shell) + +<!-- END doctoc generated TOC please keep comment here to allow auto update --> + +--- +title: adb (Android Debug Bridge) +category: CLI +layout: 2017/sheet +weight: -1 +authors: + - github: ZackNeyland +updated: 2018-03-06 +--- + +### Device Basics + +| Command | Description | +| --- | --- | +| `adb devices` | Lists connected devices | +| `adb devices -l` | Lists connected devices and kind | +| --- | --- | +| `adb root` | Restarts adbd with root permissions | +| `adb start-server` | Starts the adb server | +| `adb kill-server` | Kills the adb server | +| `adb remount` | Remounts file system with read/write access | +| `adb reboot` | Reboots the device | +| `adb reboot bootloader` | Reboots the device into fastboot | +| `adb disable-verity` | Reboots the device into fastboot | + +`wait-for-device` can be specified after `adb` to ensure that the command will run once the device is connected. + +`-s` can be used to send the commands to a specific device when multiple are connected. + +#### Examples + +``` +$ adb wait-for-device devices + List of devices attached + somedevice-1234 device + someotherdevice-1234 device +``` + +``` +$ adb -s somedevice-1234 root +``` + +### Logcat + +| Command | Description | +| --- | --- | +| `adb logcat` | Starts printing log messages to stdout | +| `adb logcat -g` | Displays current log buffer sizes | +| `adb logcat -G <size>` | Sets the buffer size (K or M) | +| `adb logcat -c` | Clears the log buffers | +| `adb logcat *:V` | Enables ALL log messages (verbose) | +| `adb logcat -f <filename>` | Dumps to specified file | + +#### Examples +``` +$ adb logcat -G 16M +$ adb logcat *:V > output.log +``` + +### File Management + +| Command | Description | +| --- | --- | +| `adb push <local> <remote>` | Copies the local to the device at remote | +| `adb pull <remote> <local>` | Copies the remote from the device to local | + +#### Examples + +``` +$ echo "This is a test" > test.txt +$ adb push test.txt /sdcard/test.txt +$ adb pull /sdcard/test.txt pulledTest.txt +``` + +### Remote Shell + +| Command | Description | +| --- | --- | +| `adb shell <command>` | Runs the specified command on device (most unix commands work here) | +| `adb shell wm size` | Displays the current screen resolution | +| `adb shell wm size WxH` | Sets the resolution to WxH | +| `adb shell pm list packages` | Lists all installed packages | +| `adb shell pm list packages -3` | Lists all installed 3rd-party packages | +| `adb shell monkey -p app.package.name` | Starts the specified package | + + +### [2-resources/__CHEAT-SHEETS/All/analytics.js.md](2-resources/__CHEAT-SHEETS/All/analytics.js.md) + +<!-- START doctoc generated TOC please keep comment here to allow auto update --> +<!-- DON'T EDIT THIS SECTION, INSTEAD RE-RUN doctoc TO UPDATE --> +**Table of Contents** *generated with [DocToc](https://github.com/thlorenz/doctoc)* + +- [Page view](#page-view) +- [Events](#events) +- [Exceptions](#exceptions) + +<!-- END doctoc generated TOC please keep comment here to allow auto update --> + +--- +title: Google Analytics's analytics.js +category: Analytics +layout: 2017/sheet +updated: 2017-10-29 +intro: | + Google Analytics's analytics.js is deprecated. +--- + +### Page view + +```js +ga('create', 'UA-XXXX-Y', 'auto') +ga('create', 'UA-XXXX-Y', { userId: 'USER_ID' }) +``` + +```js +ga('send', 'pageview') +ga('send', 'pageview', { 'dimension15': 'My custom dimension' }) +``` + +### Events + +```js +ga('send', 'event', 'button', 'click', {color: 'red'}); +``` + +```js +ga('send', 'event', 'button', 'click', 'nav buttons', 4); +/* ^category ^action ^label ^value */ +``` + +### Exceptions + +```js +ga('send', 'exception', { + exDescription: 'DatabaseError', + exFatal: false, + appName: 'myapp', + appVersion: '0.1.2' +}) +``` + + +### [2-resources/__CHEAT-SHEETS/All/analytics.md](2-resources/__CHEAT-SHEETS/All/analytics.md) + +<!-- START doctoc generated TOC please keep comment here to allow auto update --> +<!-- DON'T EDIT THIS SECTION, INSTEAD RE-RUN doctoc TO UPDATE --> +**Table of Contents** *generated with [DocToc](https://github.com/thlorenz/doctoc)* + +- [Mixpanel](#mixpanel) +- [Google Analytics's analytics.js](#google-analyticss-analyticsjs) + +<!-- END doctoc generated TOC please keep comment here to allow auto update --> + +--- +title: Analytics libraries +layout: 2017/sheet +category: Analytics +--- + +### Mixpanel + +```js +mixpanel.identify('284'); +mixpanel.people.set({ $email: 'hi@gmail.com' }); +mixpanel.register({ age: 28, gender: 'male' }); /* set common properties */ +``` + +[mixpanel](./mixpanel) +{: .-crosslink} + +### Google Analytics's analytics.js + +```js +ga('create', 'UA-XXXX-Y', 'auto'); +ga('create', 'UA-XXXX-Y', { userId: 'USER_ID' }); +``` + +```js +ga('send', 'pageview'); +ga('send', 'pageview', { 'dimension15': 'My custom dimension' }); +``` + +[analytics.js](./analytics.js) +{: .-crosslink} + + +### [2-resources/__CHEAT-SHEETS/All/angularjs.md](2-resources/__CHEAT-SHEETS/All/angularjs.md) + +<!-- START doctoc generated TOC please keep comment here to allow auto update --> +<!-- DON'T EDIT THIS SECTION, INSTEAD RE-RUN doctoc TO UPDATE --> +**Table of Contents** *generated with [DocToc](https://github.com/thlorenz/doctoc)* + +- [Lists (ng-repeat)](#lists-ng-repeat) +- [Model (ng-model)](#model-ng-model) +- [Defining a module](#defining-a-module) +- [Controller with protection from minification](#controller-with-protection-from-minification) +- [Service](#service) +- [Directive](#directive) +- [HTTP](#http) + +<!-- END doctoc generated TOC please keep comment here to allow auto update --> + +--- +title: Angular.js +category: JavaScript libraries +--- +```html + <html ng-app="nameApp"> +``` + +### Lists (ng-repeat) +```html + <ul ng-controller="MyListCtrl"> + <li ng-repeat="phone in phones"> + {{phone.name}} + </li> + </ul> +``` + +### Model (ng-model) + +```html + <select ng-model="orderProp"> + <option value="name">Alphabetical</option> + <option value="age">Newest</option> + </select> +``` + +### Defining a module +```js + App = angular.module('myApp', []); + + App.controller('MyListCtrl', function ($scope) { + $scope.phones = [ ... ]; + }); +``` + +### Controller with protection from minification +```js + App.controller('Name', [ + '$scope', + '$http', + function ($scope, $http) { + } + ]); + + a.c 'name', [ + '$scope' + '$http' + ($scope, $http) -> + ] +``` + +### Service +```js + App.service('NameService', function($http){ + return { + get: function(){ + return $http.get(url); + } + } + }); +``` +In controller you call with parameter and will use promises to return data from server. + +```js + App.controller('controllerName', + function(NameService){ + NameService.get() + .then(function(){}) + }) +``` + +### Directive +```js + App.directive('name', function(){ + return { + template: '<h1>Hello</h1>' + } + }); +``` + +In HTML will use `<name></name>` to render your template `<h1>Hello</h1>` + +### HTTP +```js + App.controller('PhoneListCtrl', function ($scope, $http) { + $http.get('/data.json').success(function (data) { + $scope.phones = data; + }) + }); +``` +References: + + * https://github.com/angular/angular-seed + * https://angularjs.org/ + + +### [2-resources/__CHEAT-SHEETS/All/animated_gif.md](2-resources/__CHEAT-SHEETS/All/animated_gif.md) + +<!-- START doctoc generated TOC please keep comment here to allow auto update --> +<!-- DON'T EDIT THIS SECTION, INSTEAD RE-RUN doctoc TO UPDATE --> +**Table of Contents** *generated with [DocToc](https://github.com/thlorenz/doctoc)* + +- [Animated GIFs](#animated-gifs) + - [Convert MP4 to GIF](#convert-mp4-to-gif) + - [A given range](#a-given-range) + +<!-- END doctoc generated TOC please keep comment here to allow auto update --> + +--- +title: Animated GIFs +category: CLI +layout: 2017/sheet +--- + +## Animated GIFs +{: .-one-column} + +### Convert MP4 to GIF + +```bash +mkdir -p gif +mplayer -ao null -vo gif89a:outdir=gif $INPUT +mogrify -format gif *.png +gifsicle --colors=256 --delay=4 --loopcount=0 --dither -O3 gif/*.gif > ${INPUT%.*}.gif +rm -rf gif +``` + +You'll need `mplayer`, `imagemagick` and `gifsicle`. This converts frames to .png, then turns them into an animated gif. + +### A given range + +```bash +mplayer -ao null -ss 0:02:06 -endpos 0:05:00 -vo gif89a:outdir=gif videofile.mp4 +``` + +See `-ss` and `-endpos`. + + +### [2-resources/__CHEAT-SHEETS/All/ansi.md](2-resources/__CHEAT-SHEETS/All/ansi.md) + +<!-- START doctoc generated TOC please keep comment here to allow auto update --> +<!-- DON'T EDIT THIS SECTION, INSTEAD RE-RUN doctoc TO UPDATE --> +**Table of Contents** *generated with [DocToc](https://github.com/thlorenz/doctoc)* + +- [Format](#format) +- [ANSI codes](#ansi-codes) +- [Colors](#colors) +- [Bash utilities](#bash-utilities) + +<!-- END doctoc generated TOC please keep comment here to allow auto update --> + +--- +title: Ansi codes +category: CLI +layout: 2017/sheet +intro: | + Quick reference to ANSI color codes. +--- + +### Format + +``` +\033[#m +``` + +### ANSI codes + +``` +0 clear +1 bold +4 underline +5 blink + +30-37 fg color +40-47 bg color + +1K clear line (to beginning of line) +2K clear line (entire line) +2J clear screen +0;0H move cursor to 0;0 + +1A move up 1 line +``` + +### Colors + +``` +0 black +1 red +2 green +3 yellow +4 blue +5 magenta +6 cyan +7 white +``` + +### Bash utilities + +```sh +hide_cursor() { printf "\e[?25l"; } +show_cursor() { printf "\e[?25h"; } +``` + + +### [2-resources/__CHEAT-SHEETS/All/ansible-examples.md](2-resources/__CHEAT-SHEETS/All/ansible-examples.md) + +<!-- START doctoc generated TOC please keep comment here to allow auto update --> +<!-- DON'T EDIT THIS SECTION, INSTEAD RE-RUN doctoc TO UPDATE --> +**Table of Contents** *generated with [DocToc](https://github.com/thlorenz/doctoc)* + +- [Examples](#examples) + +<!-- END doctoc generated TOC please keep comment here to allow auto update --> + +--- +title: Ansible examples +category: Ansible +layout: 2017/sheet +--- + +### Examples + + * [Ruby installation](https://github.com/chelsea/ansible-example-ruby/blob/master/roles/webserver/tasks/main.yml) _(github.com)_ + * [Postgres installation](https://github.com/chelsea/ansible-example-ruby/blob/master/roles/db/tasks/main.yml) _(github.com)_ + * [GitLab installation](https://github.com/tingtun/ansible-playbook-gitlab) _(github.com)_ + + +### [2-resources/__CHEAT-SHEETS/All/ansible-guide.md](2-resources/__CHEAT-SHEETS/All/ansible-guide.md) + +<!-- START doctoc generated TOC please keep comment here to allow auto update --> +<!-- DON'T EDIT THIS SECTION, INSTEAD RE-RUN doctoc TO UPDATE --> +**Table of Contents** *generated with [DocToc](https://github.com/thlorenz/doctoc)* + + - [Install Ansible](#install-ansible) + - [Start your project](#start-your-project) +- [Creating your files](#creating-your-files) + - [Inventory file](#inventory-file) + - [~/setup/hosts](#setuphosts) + - [Playbook](#playbook) + - [~/setup/playbook.yml](#setupplaybookyml) +- [Running](#running) + - [Running ansible-playbook](#running-ansible-playbook) + - [Running the playbook](#running-the-playbook) +- [Read more](#read-more) + +<!-- END doctoc generated TOC please keep comment here to allow auto update --> + +--- +title: "Ansible quickstart" +category: Ansible +layout: 2017/sheet +description: | + A quick guide to getting started with your first Ansible playbook. +--- + +### Install Ansible + +```bash +$ brew install ansible # OSX +$ [sudo] apt install ansible # elsewhere +``` + +Ansible is available as a package in most OS's. + +See: [Installation](http://docs.ansible.com/ansible/latest/intro_installation.html) + +### Start your project + +```bash +~$ mkdir setup +~$ cd setup +``` + +Make a folder for your Ansible files. + +See: [Getting started](http://docs.ansible.com/ansible/latest/intro_getting_started.html) + +## Creating your files + +### Inventory file + +#### ~/setup/hosts + +```dosini +[sites] +127.0.0.1 +192.168.0.1 +192.168.0.2 +192.168.0.3 +``` + +This is a list of hosts you want to manage, grouped into groups. (Hint: try +using `localhost ansible_connection=local` to deploy to your local machine.) + +See: [Intro to Inventory](http://docs.ansible.com/ansible/latest/intro_inventory.html) + +### Playbook + +#### ~/setup/playbook.yml + +```yaml +- hosts: 127.0.0.1 + user: root + tasks: + - name: install nginx + apt: pkg=nginx state=present + + - name: start nginx every bootup + service: name=nginx state=started enabled=yes + + - name: do something in the shell + shell: echo hello > /tmp/abc.txt + + - name: install bundler + gem: name=bundler state=latest +``` + +See: [Intro to Playbooks](http://docs.ansible.com/ansible/latest/playbooks_intro.html) + +## Running + +### Running ansible-playbook + +``` +~/setup$ ls +hosts +playbook.yml +``` + +#### Running the playbook + +``` +~/setup$ ansible-playbook -i hosts playbook.yml +PLAY [all] ******************************************************************** + +GATHERING FACTS *************************************************************** +ok: [127.0.0.1] + +TASK: [install nginx] ********************************************************* +ok: [127.0.0.1] + +TASK: start nginx every bootup] *********************************************** +ok: [127.0.0.1] +... +``` + +## Read more + +* [Getting started with Ansible](http://lowendbox.com/blog/getting-started-with-ansible/) _(lowendbox.com)_ +* [Getting started](http://docs.ansible.com/ansible/latest/intro_getting_started.html) _(docs.ansible.com)_ +* [Intro to Inventory](http://docs.ansible.com/ansible/latest/intro_inventory.html) _(docs.ansible.com)_ +* [Intro to Playbooks](http://docs.ansible.com/ansible/latest/playbooks_intro.html) _(docs.ansible.com)_ + + +### [2-resources/__CHEAT-SHEETS/All/ansible-modules.md](2-resources/__CHEAT-SHEETS/All/ansible-modules.md) + +<!-- START doctoc generated TOC please keep comment here to allow auto update --> +<!-- DON'T EDIT THIS SECTION, INSTEAD RE-RUN doctoc TO UPDATE --> +**Table of Contents** *generated with [DocToc](https://github.com/thlorenz/doctoc)* + +- [Format](#format) + - [Basic file](#basic-file) + - [Task formats](#task-formats) + - [One-line](#one-line) + - [Map](#map) + - [Foldable scalar](#foldable-scalar) +- [Modules](#modules) + - [Aptitude](#aptitude) + - [Packages](#packages) + - [Deb files](#deb-files) + - [Repositories](#repositories) + - [Repository keys](#repository-keys) + - [git](#git) + - [git_config](#git_config) + - [user](#user) + - [service](#service) +- [Shell](#shell) + - [shell](#shell) + - [Extra options](#extra-options) + - [Multiline example](#multiline-example) + - [script](#script) +- [Files](#files) + - [file](#file) + - [copy](#copy) + - [template](#template) +- [Local actions](#local-actions) + - [local_action](#local_action) + - [debug](#debug) + +<!-- END doctoc generated TOC please keep comment here to allow auto update --> + +--- +title: Ansible modules +category: Ansible +layout: 2017/sheet +prism_languages: [yaml] +updated: 2017-10-03 +--- + +{% raw %} + +## Format + +### Basic file + +```yaml +--- +- hosts: production + remote_user: root + tasks: + - ··· +``` + +Place your modules inside `tasks`. + +### Task formats + +#### One-line + +```yaml +- apt: pkg=vim state=present +``` + +#### Map + +```yaml +- apt: + pkg: vim + state: present +``` + +#### Foldable scalar + +```yaml +- apt: > + pkg=vim + state=present +``` + +Define your tasks in any of these formats. One-line format is preferred for short declarations, while maps are preferred for longer. + +## Modules + +### Aptitude + +#### Packages + +```yaml +- apt: + pkg: nodejs + state: present # absent | latest + update_cache: yes + force: no +``` + +#### Deb files + +```yaml +- apt: + deb: "https://packages.erlang-solutions.com/erlang-solutions_1.0_all.deb" +``` + +#### Repositories + +```yaml +- apt_repository: + repo: "deb https://··· raring main" + state: present +``` + +#### Repository keys + +```yaml +- apt_key: + id: AC40B2F7 + url: "http://···" + state: present +``` + +### git + +```yaml +- git: + repo: git://github.com/ + dest: /srv/checkout + version: master + depth: 10 + bare: yes +``` + +See: [git module](http://devdocs.io/ansible/git_module) + +### git_config + +```yaml +- git_config: + name: user.email + scope: global # local | system + value: hi@example.com +``` + +See: [git_config module](http://devdocs.io/ansible/git_config_module) + +### user + +```yaml +- user: + state: present + name: git + system: yes + shell: /bin/sh + groups: admin + comment: "Git Version Control" +``` + +See: [user module](http://devdocs.io/ansible/user_module) + +### service + +```yaml +- service: + name: nginx + state: started + enabled: yes # optional +``` + +See: [service module](http://devdocs.io/ansible/service_module) + +## Shell + +### shell + +```yaml +- shell: apt-get install nginx -y +``` + +#### Extra options + +```yaml +- shell: echo hello + args: + creates: /path/file # skip if this exists + removes: /path/file # skip if this is missing + chdir: /path # cd here before running +``` + +#### Multiline example + +```yaml +- shell: | + echo "hello there" + echo "multiple lines" +``` + +See: [shell module](http://devdocs.io/ansible/shell_module) + +### script + +```yaml +- script: /x/y/script.sh + args: + creates: /path/file # skip if this exists + removes: /path/file # skip if this is missing + chdir: /path # cd here before running +``` + +See: [script module](http://devdocs.io/ansible/script_module) + +## Files + +### file + +```yaml +- file: + path: /etc/dir + state: directory # file | link | hard | touch | absent + + # Optional: + owner: bin + group: wheel + mode: 0644 + recurse: yes # mkdir -p + force: yes # ln -nfs +``` + +See: [file module](http://devdocs.io/ansible/file_module) + +### copy + +```yaml +- copy: + src: /app/config/nginx.conf + dest: /etc/nginx/nginx.conf + + # Optional: + owner: user + group: user + mode: 0644 + backup: yes +``` + +See: [copy module](http://devdocs.io/ansible/copy_module) + +### template + +```yaml +- template: + src: config/redis.j2 + dest: /etc/redis.conf + + # Optional: + owner: user + group: user + mode: 0644 + backup: yes +``` + +See: [template module](http://devdocs.io/ansible/template_module) + +## Local actions + +### local_action + +```yaml +- name: do something locally + local_action: shell echo hello +``` + +### debug + +```yaml +- debug: + msg: "Hello {{ var }}" +``` + +See: [debug module](http://devdocs.io/ansible/debug_module) +{% endraw %} + + + +### [2-resources/__CHEAT-SHEETS/All/ansible-roles.md](2-resources/__CHEAT-SHEETS/All/ansible-roles.md) + +<!-- START doctoc generated TOC please keep comment here to allow auto update --> +<!-- DON'T EDIT THIS SECTION, INSTEAD RE-RUN doctoc TO UPDATE --> +**Table of Contents** *generated with [DocToc](https://github.com/thlorenz/doctoc)* + +- [Structure](#structure) +- [References](#references) + +<!-- END doctoc generated TOC please keep comment here to allow auto update --> + +--- +title: Ansible roles +category: Ansible +layout: 2017/sheet +--- + +### Structure + + roles/ + common/ + tasks/ + handlers/ + files/ # 'copy' will refer to this + templates/ # 'template' will refer to this + meta/ # Role dependencies here + vars/ + defaults/ + main.yml + +### References + + * http://www.ansibleworks.com/docs/playbooks_roles.html + + +### [2-resources/__CHEAT-SHEETS/All/ansible.md](2-resources/__CHEAT-SHEETS/All/ansible.md) + +<!-- START doctoc generated TOC please keep comment here to allow auto update --> +<!-- DON'T EDIT THIS SECTION, INSTEAD RE-RUN doctoc TO UPDATE --> +**Table of Contents** *generated with [DocToc](https://github.com/thlorenz/doctoc)* + +- [Getting started](#getting-started) + - [Hosts](#hosts) + - [Running a playbook](#running-a-playbook) +- [Tasks](#tasks) + - [Includes](#includes) +- [Handlers](#handlers) +- [Vars](#vars) +- [Roles](#roles) + - [Task: Failures](#task-failures) + - [Env vars](#env-vars) +- [References](#references) + +<!-- END doctoc generated TOC please keep comment here to allow auto update --> + +--- +title: Ansible +category: Ansible +--- + +{% raw %} + +## Getting started + +### Hosts + + $ sudo mkdir /etc/ansible + $ sudo vim /etc/ansible/hosts + + [example] + 192.0.2.101 + 192.0.2.102 + +### Running a playbook + + $ ansible-playbook playbook.yml + +## Tasks + + - hosts: all + user: root + sudo: no + vars: + aaa: bbb + tasks: + - ... + handlers: + - ... + +### Includes + + tasks: + - include: db.yml + handlers: + - include: db.yml user=timmy + +## Handlers + + handlers: + - name: start apache2 + action: service name=apache2 state=started + + tasks: + - name: install apache + action: apt pkg=apache2 state=latest + notify: + - start apache2 + +## Vars + + - host: lol + vars_files: + - vars.yml + vars: + project_root: /etc/xyz + tasks: + - name: Create the SSH directory. + file: state=directory path=${project_root}/home/.ssh/ + only_if: "$vm == 0" + +## Roles + + - host: xxx + roles: + - db + - { role:ruby, sudo_user:$user } + - web + + # Uses: + # roles/db/tasks/*.yml + # roles/db/handlers/*.yml + +### Task: Failures + + - name: my task + command: ... + register: result + failed_when: "'FAILED' in result.stderr" + + ignore_errors: yes + + changed_when: "result.rc != 2" + +### Env vars + + vars: + local_home: "{{ lookup('env','HOME') }}" + +## References + + * [Intro](http://www.ansibleworks.com/docs/intro_configuration.html) + * [Modules](http://www.ansibleworks.com/docs/modules.html) + +{% endraw %} + + +### [2-resources/__CHEAT-SHEETS/All/appcache.md](2-resources/__CHEAT-SHEETS/All/appcache.md) + +<!-- START doctoc generated TOC please keep comment here to allow auto update --> +<!-- DON'T EDIT THIS SECTION, INSTEAD RE-RUN doctoc TO UPDATE --> +**Table of Contents** *generated with [DocToc](https://github.com/thlorenz/doctoc)* + +- [Format](#format) + +<!-- END doctoc generated TOC please keep comment here to allow auto update --> + +--- +title: Appcache +category: HTML +layout: 2017/sheet +--- + +### Format + +``` +CACHE MANIFEST +# version + +CACHE: +http://www.google.com/jsapi +/assets/app.js +/assets/bg.png + +NETWORK: +* +``` + +Note that Appcache is deprecated! + +See: [Using the application cache](https://developer.mozilla.org/en-US/docs/Web/HTML/Using_the_application_cache) _(developer.mozilla.org)_ + + +### [2-resources/__CHEAT-SHEETS/All/applescript.md](2-resources/__CHEAT-SHEETS/All/applescript.md) + +<!-- START doctoc generated TOC please keep comment here to allow auto update --> +<!-- DON'T EDIT THIS SECTION, INSTEAD RE-RUN doctoc TO UPDATE --> +**Table of Contents** *generated with [DocToc](https://github.com/thlorenz/doctoc)* + +- [Running](#running) +- [Comments](#comments) +- [Say](#say) +- [Beep](#beep) +- [Delay](#delay) + +<!-- END doctoc generated TOC please keep comment here to allow auto update --> + +--- +title: AppleScript +updated: 2018-12-06 +layout: 2017/sheet +category: macOS +prism_languages: [applescript] +--- + +### Running + +```applescript +osascript -e "..." +``` + +```applescript +display notification "X" with title "Y" +``` + +### Comments + +```applescript +-- This is a single line comment +``` + +```applescript +# This is another single line comment +``` + +```applescript +(* +This is +a multi +line comment +*) +``` + +### Say + +```applescript +-- default voice +say "Hi I am a Mac" +``` + +```applescript +-- specified voice +say "Hi I am a Mac" using "Zarvox" +``` + +### Beep + +```applescript +-- beep once +beep +``` + +```applescript +-- beep 10 times +beep 10 +``` + +### Delay + +```applescript +-- delay for 5 seconds +delay 5 +``` + + +### [2-resources/__CHEAT-SHEETS/All/applinks.md](2-resources/__CHEAT-SHEETS/All/applinks.md) + +<!-- START doctoc generated TOC please keep comment here to allow auto update --> +<!-- DON'T EDIT THIS SECTION, INSTEAD RE-RUN doctoc TO UPDATE --> +**Table of Contents** *generated with [DocToc](https://github.com/thlorenz/doctoc)* + +- [Device types](#device-types) +- [Reference](#reference) + +<!-- END doctoc generated TOC please keep comment here to allow auto update --> + +--- +title: Applinks +category: HTML +--- + + + <meta property="al:ios:url" content="applinks://docs" /> + <meta property="al:ios:app_store_id" content="12345" /> + <meta property="al:ios:app_name" content="App Links" /> + + <meta property="al:android:url" content="applinks://docs" /> + <meta property="al:android:app_name" content="App Links" /> + <meta property="al:android:package" content="org.applinks" /> + + <meta property="al:web:url" content="http://applinks.org/documentation" /> + +### Device types + + * `ios` + * `ipad` + * `iphone` + * `android` + * `windows_phone` + * `web` + +### Reference + + * [applinks.org](http://applinks.org/documentation/) + + +### [2-resources/__CHEAT-SHEETS/All/arel.md](2-resources/__CHEAT-SHEETS/All/arel.md) + +<!-- START doctoc generated TOC please keep comment here to allow auto update --> +<!-- DON'T EDIT THIS SECTION, INSTEAD RE-RUN doctoc TO UPDATE --> +**Table of Contents** *generated with [DocToc](https://github.com/thlorenz/doctoc)* + + - [Tables](#tables) + - [Fields](#fields) + - [`where` (restriction)](#where-restriction) + - [`select` (projection)](#select-projection) + - [`join`](#join) + - [basic join](#basic-join) + - [join with conditions](#join-with-conditions) + - [advanced join](#advanced-join) + - [`limit` / `offset`](#limit--offset) + - [Aggregates](#aggregates) + - [`order`](#order) + - [With ActiveRecord](#with-activerecord) + - [Clean code with arel](#clean-code-with-arel) +- [Reference](#reference) + +<!-- END doctoc generated TOC please keep comment here to allow auto update --> + +--- +title: Arel +category: Rails +--- + +### Tables + +```rb +users = Arel::Table.new(:users) +users = User.arel_table # ActiveRecord model +``` + +### Fields + +```rb +users[:name] +users[:id] +``` + +### `where` (restriction) + +```rb +users.where(users[:name].eq('amy')) +# SELECT * FROM users WHERE users.name = 'amy' +``` + +### `select` (projection) + +```rb +users.project(users[:id]) +# SELECT users.id FROM users +``` + +### `join` +#### basic join +In ActiveRecord (without Arel), if `:photos` is the name of the association, use `joins` +```rb +users.joins(:photos) +``` + +In Arel, if `photos` is defined as the Arel table, +```rb +photos = Photo.arel_table +users.join(photos) +users.join(photos, Arel::Nodes::OuterJoin).on(users[:id].eq(photos[:user_id])) +``` + +#### join with conditions +```rb +users.joins(:photos).merge(Photo.where(published: true)) +``` + +If the simpler version doesn't help and you want to add more SQL statements to it: +```rb +users.join( + users.join(photos, Arel::Nodes::OuterJoin) + .on(photos[:user_id].eq(users[:id]).and(photos[:published].eq(true))) +) +``` + +#### advanced join +multiple `joins` with the same table but different meanings and/or conditions +```rb +creators = User.arel_table.alias('creators') +updaters = User.arel_table.alias('updaters') +photos = Photo.arel_table + +photos_with_credits = photos +.join(photos.join(creators, Arel::Nodes::OuterJoin).on(photos[:created_by_id].eq(creators[:id]))) +.join(photos.join(updaters, Arel::Nodes::OuterJoin).on(photos[:assigned_id].eq(updaters[:id]))) +.project(photos[:name], photos[:created_at], creators[:name].as('creator'), updaters[:name].as('editor')) + +photos_with_credits.to_sql +# => "SELECT `photos`.`name`, `photos`.`created_at`, `creators`.`name` AS creator, `updaters`.`name` AS editor FROM `photos` INNER JOIN (SELECT FROM `photos` LEFT OUTER JOIN `users` `creators` ON `photos`.`created_by_id` = `creators`.`id`) INNER JOIN (SELECT FROM `photos` LEFT OUTER JOIN `users` `updaters` ON `photos`.`updated_by_id` = `updaters`.`id`)" + +# after the request is done, you can use the attributes you named +# it's as if every Photo record you got has "creator" and "editor" fields, containing creator name and editor name +photos_with_credits.map{|x| + "#{photo.name} - copyright #{photo.created_at.year} #{photo.creator}, edited by #{photo.editor}" +}.join('; ') +``` + +### `limit` / `offset` + +```rb +users.take(5) # => SELECT * FROM users LIMIT 5 +users.skip(4) # => SELECT * FROM users OFFSET 4 +``` + +### Aggregates + +```rb +users.project(users[:age].sum) # .average .minimum .maximum +users.project(users[:id].count) +users.project(users[:id].count.as('user_count')) +``` + +### `order` + +```rb +users.order(users[:name]) +users.order(users[:name], users[:age].desc) +users.reorder(users[:age]) +``` + +### With ActiveRecord + +```rb +User.arel_table +User.where(id: 1).arel +``` + +### Clean code with arel + +Most of the clever stuff should be in scopes, e.g. the code above could become: +```rb +photos_with_credits = Photo.with_creator.with_editor +``` + +You can store requests in variables then add SQL segments: +```rb +all_time = photos_with_credits.count +this_month = photos_with_credits.where(photos[:created_at].gteq(Date.today.beginning_of_month)) +recent_photos = photos_with_credits.where(photos[:created_at].gteq(Date.today.beginning_of_month)).limit(5) +``` + +## Reference + +* <http://github.com/rails/arel> + + +### [2-resources/__CHEAT-SHEETS/All/atom.md](2-resources/__CHEAT-SHEETS/All/atom.md) + +<!-- START doctoc generated TOC please keep comment here to allow auto update --> +<!-- DON'T EDIT THIS SECTION, INSTEAD RE-RUN doctoc TO UPDATE --> +**Table of Contents** *generated with [DocToc](https://github.com/thlorenz/doctoc)* + +- [Shortcuts](#shortcuts) + - [Tree](#tree) + - [Comments](#comments) + - [View](#view) + - [Bracket matcher](#bracket-matcher) + - [Symbols view](#symbols-view) + - [Git](#git) + - [Editing](#editing) + - [Project](#project) +- [Notes](#notes) + - [⌘](#%E2%8C%98) + - [⌥](#%E2%8C%A5) + +<!-- END doctoc generated TOC please keep comment here to allow auto update --> + +--- +title: Atom +category: Apps +layout: 2017/sheet +updated: 2018-06-14 +--- + +## Shortcuts +{: .-three-column} + +### Tree + +| Shortcut | Description | +| -------- | ------------------- | +| `⌘\` | Toggle tree | +| `⌘⇧\` | Reveal current file | +{: .-shortcuts} + +### Comments + +| Shortcut | Description | +| -------- | --------------- | +| `⌘/` | Toggle comments | +{: .-shortcuts} + +### View + +| Shortcut | Description | +| -------- | ---------------------- | +| `⌘k` `←` | Split pane to the left | +| --- | --- | +| `⌘⌥=` | Grow pane | +| `⌘⌥-` | Shrink pane | +| --- | --- | +| `^⇧←` | Move tab to left | +{: .-shortcuts} + +### Bracket matcher + +| Shortcut | Description | +| -------- | ------------------------------ | +| `^m` | Go to matching bracket | +| `^]` | Remove brackets from selection | +| `^⌘m` | Select inside brackets | +| `⌥⌘.` | Close tag | +{: .-shortcuts} + +### Symbols view + +| Shortcut | Description | +| -------- | -------------------------------- | +| `^⌥↓` | Jump to declaration under cursor | +| `^⇧r` | Show tags | +{: .-shortcuts} + +Symbols view enables Ctags support for Atom. + +See: [Symbols view](https://atom.io/packages/symbols-view) + +### Git + +| `^⇧9` | Show Git pane | +| `^⇧8` | Show GitHub pane | +{: .-shortcuts} + +### Editing + +| Shortcut | Description | +| -------- | -------------- | +| `⌘d` | Select word | +| `⌘l` | Select line | +| --- | --- | +| `⌘↓` | Move line down | +| `⌘↑` | Move line up | +| --- | --- | +| `⌘⏎` | New line below | +| `⌘⇧⏎` | New line above | +| --- | --- | +| `⌘⇧k` | Delete line | +| `⌘⇧d` | Duplicate line | +{: .-shortcuts} + +### Project + +| Shortcut | Description | +| -------- | ----------------------- | +| `⌘⇧p` | Command palette | +| `⌘⇧a` | Add project folder | +| --- | --- | +| `⌘n` | New file | +| `⌘⇧n` | New window | +| --- | --- | +| `⌘f` | Find in file | +| `⌘⇧f` | Find in project | +| `⌘t` | Search files in project | +{: .-shortcuts} + +## Notes + +### ⌘ + +- For Windows and Linux, `⌘` is the `Control` key. +- For macOS, it's the `Command` key. + +### ⌥ + +- For Windows and Linux, `⌥` is the `Alt` key. +- For macOS, it's the `Option` key. + + +### [2-resources/__CHEAT-SHEETS/All/awesome-redux.md](2-resources/__CHEAT-SHEETS/All/awesome-redux.md) + +<!-- START doctoc generated TOC please keep comment here to allow auto update --> +<!-- DON'T EDIT THIS SECTION, INSTEAD RE-RUN doctoc TO UPDATE --> +**Table of Contents** *generated with [DocToc](https://github.com/thlorenz/doctoc)* + + - [redux-actions](#redux-actions) + - [flux-standard-action](#flux-standard-action) + - [redux-multi](#redux-multi) + - [reduce-reducers](#reduce-reducers) + - [redux-logger](#redux-logger) +- [Async](#async) + - [redux-promise](#redux-promise) + - [redux-promises](#redux-promises) + - [redux-effects](#redux-effects) + - [redux-thunk](#redux-thunk) + +<!-- END doctoc generated TOC please keep comment here to allow auto update --> + +--- +title: Awesome Redux +category: React +layout: 2017/sheet +updated: 2017-11-19 +--- + +### redux-actions + +Create action creators in flux standard action format. +{: .-setup} + +```js +increment = createAction('INCREMENT', amount => amount) +increment = createAction('INCREMENT') // same +``` + +```js +increment(42) === { type: 'INCREMENT', payload: 42 } +``` + +```js +// Errors are handled for you: +err = new Error() +increment(err) === { type: 'INCREMENT', payload: err, error: true } +``` + +[redux-actions](https://www.npmjs.com/package/redux-actions) +{: .-crosslink} + +### flux-standard-action + +A standard for flux action objects. An action may have an `error`, `payload` and `meta` and nothing else. +{: .-setup} + +```js +{ type: 'ADD_TODO', payload: { text: 'Work it' } } +{ type: 'ADD_TODO', payload: new Error(), error: true } +``` + +[flux-standard-action](https://github.com/acdlite/flux-standard-action) +{: .-crosslink} + +### redux-multi + +Dispatch multiple actions in one action creator. +{: .-setup} + +```js +store.dispatch([ + { type: 'INCREMENT', payload: 2 }, + { type: 'INCREMENT', payload: 3 } +]) +``` + +[redux-multi](https://github.com/ashaffer/redux-multi) +{: .-crosslink} + +### reduce-reducers +Combines reducers (like *combineReducers()*), but without namespacing magic. +{: .-setup} + +```js +re = reduceReducers( + (state, action) => state + action.number, + (state, action) => state + action.number +) + +re(10, { number: 2 }) //=> 14 +``` + +[reduce-reducers](https://www.npmjs.com/package/reduce-reducers) +{: .-crosslink} + +### redux-logger + +Logs actions to your console. +{: .-setup} + +```js +// Nothing to see here +``` + +[redux-logger](https://github.com/evgenyrodionov/redux-logger) +{: .-crosslink} + +Async +----- + +### redux-promise + +Pass promises to actions. Dispatches a flux-standard-action. +{: .-setup} + +```js +increment = createAction('INCREMENT') // redux-actions +increment(Promise.resolve(42)) +``` + +[redux-promise](https://github.com/acdlite/redux-promise) +{: .-crosslink} + +### redux-promises + +Sorta like that, too. Works by letting you pass *thunks* (functions) to `dispatch()`. Also has 'idle checking'. +{: .-setup} + +```js +fetchData = (url) => (dispatch) => { + dispatch({ type: 'FETCH_REQUEST' }) + fetch(url) + .then((data) => dispatch({ type: 'FETCH_DONE', data }) + .catch((error) => dispatch({ type: 'FETCH_ERROR', error }) +}) + +store.dispatch(fetchData('/posts')) +``` + +```js +// That's actually shorthand for: +fetchData('/posts')(store.dispatch) +``` + +[redux-promises](https://www.npmjs.com/package/redux-promises) +{: .-crosslink} + +### redux-effects + +Pass side effects declaratively to keep your actions pure. +{: .-setup} + +```js +{ + type: 'EFFECT_COMPOSE', + payload: { + type: 'FETCH' + payload: {url: '/some/thing', method: 'GET'} + }, + meta: { + steps: [ [success, failure] ] + } +} +``` + +[redux-effects](https://www.npmjs.com/package/redux-effects) +{: .-crosslink} + +### redux-thunk + +Pass "thunks" to as actions. Extremely similar to redux-promises, but has support for getState. +{: .-setup} + +```js +fetchData = (url) => (dispatch, getState) => { + dispatch({ type: 'FETCH_REQUEST' }) + fetch(url) + .then((data) => dispatch({ type: 'FETCH_DONE', data }) + .catch((error) => dispatch({ type: 'FETCH_ERROR', error }) +}) + +store.dispatch(fetchData('/posts')) +``` + +```js +// That's actually shorthand for: +fetchData('/posts')(store.dispatch, store.getState) +``` + +```js +// Optional: since fetchData returns a promise, it can be chained +// for server-side rendering +store.dispatch(fetchPosts()).then(() => { + ReactDOMServer.renderToString(<MyApp store={store} />) +}) +``` + +[redux-thunk](https://www.npmjs.com/package/redux-thunk) +{: .-crosslink} + + +### [2-resources/__CHEAT-SHEETS/All/awscli.md](2-resources/__CHEAT-SHEETS/All/awscli.md) + +<!-- START doctoc generated TOC please keep comment here to allow auto update --> +<!-- DON'T EDIT THIS SECTION, INSTEAD RE-RUN doctoc TO UPDATE --> +**Table of Contents** *generated with [DocToc](https://github.com/thlorenz/doctoc)* + + - [EC2](#ec2) + - [S3](#s3) + - [ECS](#ecs) + - [Homebrew](#homebrew) + - [Configuration profiles](#configuration-profiles) +- [Elastic Beanstalk](#elastic-beanstalk) + - [Configuration](#configuration) +- [ebextensions](#ebextensions) +- [Also see](#also-see) + +<!-- END doctoc generated TOC please keep comment here to allow auto update --> + +--- +title: AWS CLI +category: Devops +layout: 2017/sheet +--- + +### EC2 + +``` +aws ec2 describe-instances +aws ec2 start-instances --instance-ids i-12345678c +aws ec2 terminate-instances --instance-ids i-12345678c +``` + +### S3 + +``` +aws s3 ls s3://mybucket +aws s3 rm s3://mybucket/folder --recursive +aws s3 cp myfolder s3://mybucket/folder --recursive +aws s3 sync myfolder s3://mybucket/folder --exclude *.tmp +``` + +### ECS + +``` +aws ecs create-cluster + --cluster-name=NAME + --generate-cli-skeleton + +aws ecs create-service +``` + +### Homebrew + +``` +brew install awscli +aws configure +``` + +### Configuration profiles + +``` +aws configure --profile project1 +aws configure --profile project2 +``` + +## Elastic Beanstalk + +### Configuration + +* .elasticbeanstalk/config.yml - application config +* .elasticbeanstalk/dev-env.env.yml - environment config + +``` +eb config +``` + +See: <http://docs.aws.amazon.com/elasticbeanstalk/latest/dg/command-options.html> + +## ebextensions + +* <http://docs.aws.amazon.com/elasticbeanstalk/latest/dg/customize-containers.html> +* <http://docs.aws.amazon.com/elasticbeanstalk/latest/dg/customize-containers-ec2.html> + +## Also see + +* [AWS CLI](https://aws.amazon.com/cli/) +* [Documentation](http://docs.aws.amazon.com/cli/latest/userguide/cli-chap-welcome.html) +* [All commands](http://docs.aws.amazon.com/cli/latest/reference/#available-services) + + +### [2-resources/__CHEAT-SHEETS/All/backbone.md](2-resources/__CHEAT-SHEETS/All/backbone.md) + +<!-- START doctoc generated TOC please keep comment here to allow auto update --> +<!-- DON'T EDIT THIS SECTION, INSTEAD RE-RUN doctoc TO UPDATE --> +**Table of Contents** *generated with [DocToc](https://github.com/thlorenz/doctoc)* + + - [Binding events](#binding-events) + - [Unbinding events](#unbinding-events) + - [Events](#events) + - [List of events](#list-of-events) +- [Views](#views) + - [Defining](#defining) + - [Instantiating](#instantiating) + - [Methods](#methods) +- [Models](#models) + - [Defining](#defining-1) + - [Instantiating](#instantiating-1) + - [Methods](#methods-1) + - [Validation](#validation) + - [Custom URLs](#custom-urls) +- [References](#references) + +<!-- END doctoc generated TOC please keep comment here to allow auto update --> + +--- +title: Backbone.js +layout: 2017/sheet +updated: 2018-12-06 +category: JavaScript libraries +--- + +### Binding events + +```js +.on('event', callback) +.on('event', callback, context) +``` + +```js +.on({ + 'event1': callback, + 'event2': callback +}) +``` + +```js +.on('all', callback) +``` + +```js +.once('event', callback) // Only happens once +``` + +### Unbinding events + +```js +object.off('change', onChange) // just the `onChange` callback +object.off('change') // all 'change' callbacks +object.off(null, onChange) // `onChange` callback for all events +object.off(null, null, context) // all callbacks for `context` all events +object.off() // all +``` + +### Events + +```js +object.trigger('event') +``` + +```js +view.listenTo(object, event, callback) +view.stopListening() +``` + +### List of events + + * Collection: + * `add` (model, collection, options) + * `remove` (model, collection, options) + * `reset` (collection, options) + * `sort` (collection, options) + + * Model: + * `change` (model, options) + * `change:[attr]` (model, value, options) + * `destroy` (model, collection, options) + * `error` (model, xhr, options) + + * Model and collection: + * `request` (model, xhr, options) + * `sync` (model, resp, options) + + * Router: + * `route:[name]` (params) + * `route` (router, route, params) + +## Views + +### Defining + +```js +// All attributes are optional +var View = Backbone.View.extend({ + model: doc, +``` + +```js + tagName: 'div', + className: 'document-item', + id: "document-" + doc.id, + attributes: { href: '#' }, +``` + +```js + el: 'body', +``` + +```js + events: { + 'click button.save': 'save', + 'click .cancel': function() { ··· }, + 'click': 'onclick' + }, +``` + +```js + constructor: function() { ··· }, + render: function() { ··· } +}) +``` +### Instantiating + +```js +view = new View() +view = new View({ el: ··· }) +``` + +### Methods + +```js +view.$el.show() +view.$('input') +``` + +```js +view.remove() +``` + +```js +view.delegateEvents() +view.undelegateEvents() +``` + +## Models + +### Defining + +```js +// All attributes are optional +var Model = Backbone.Model.extend({ + defaults: { + 'author': 'unknown' + }, + idAttribute: '_id', + parse: function() { ··· } +}) +``` + +### Instantiating + +```js +var obj = new Model({ title: 'Lolita', author: 'Nabokov' }) +``` + +```js +var obj = new Model({ collection: ··· }) +``` + +### Methods + +```js +obj.id +obj.cid // → 'c38' (client-side ID) +``` + +```js +obj.clone() +``` + +```js +obj.hasChanged('title') +obj.changedAttributes() // false, or hash +obj.previousAttributes() // false, or hash +obj.previous('title') +``` + +```js +obj.isNew() +``` + +```js +obj.set({ title: 'A Study in Pink' }) +obj.set({ title: 'A Study in Pink' }, { validate: true, silent: true }) +obj.unset('title') +``` + +```js +obj.get('title') +obj.has('title') +obj.escape('title') /* Like .get() but HTML-escaped */ +``` + +```js +obj.clear() +obj.clear({ silent: true }) +``` + +```js +obj.save() +obj.save({ attributes }) +obj.save(null, { + silent: true, patch: true, wait: true, + success: callback, error: callback +}) +``` + +```js +obj.destroy() +obj.destroy({ + wait: true, + success: callback, error: callback +}) +``` + +```js +obj.toJSON() +``` + +```js +obj.fetch() +obj.fetch({ success: callback, error: callback }) +``` + +### Validation + +```js +var Model = Backbone.Model.extend({ + validate: function(attrs, options) { + if (attrs.end < attrs.start) { + return "Can't end before it starts" + } + } +}) +``` +{: data-line="2"} + +```js +obj.validationError //=> "Can't end before it starts" +obj.isValid() +obj.on('invalid', function (model, error) { ··· }) +``` + +```js +// Triggered on: +obj.save() +obj.set({ ··· }, { validate: true }) +``` + +### Custom URLs + +```js +var Model = Backbone.Model.extend({ + // Single URL (string or function) + url: '/account', + url: function() { return '/account' }, +``` + +```js + // Both of these two work the same way + url: function() { return '/books/' + this.id }), + urlRoot: '/books' +}) +``` + +```js +var obj = new Model({ url: ··· }) +var obj = new Model({ urlRoot: ··· }) +``` + +## References +{: .-one-column} + +- [Backbone website](http://backbonejs.org/) _(backbonejs.org)_ +- [Backbone patterns](http://ricostacruz.com/backbone-patterns/) _(ricostacruz.com)_ + + +### [2-resources/__CHEAT-SHEETS/All/badges.md](2-resources/__CHEAT-SHEETS/All/badges.md) + +<!-- START doctoc generated TOC please keep comment here to allow auto update --> +<!-- DON'T EDIT THIS SECTION, INSTEAD RE-RUN doctoc TO UPDATE --> +**Table of Contents** *generated with [DocToc](https://github.com/thlorenz/doctoc)* + +- [Badge markdown](#badge-markdown) +- [Etc](#etc) +- [Support stuff](#support-stuff) +- [Frontend js installation](#frontend-js-installation) +- [Acknowledgements](#acknowledgements) +- [Links](#links) + +<!-- END doctoc generated TOC please keep comment here to allow auto update --> + +--- +title: Code badges +--- + +Here are some badges for open source projects. + +### Badge markdown + + Travis + [![Status](https://travis-ci.org/rstacruz/REPO.svg?branch=master)](https://travis-ci.org/rstacruz/REPO) + CodeClimate (shields.io) + [![CodeClimate](http://img.shields.io/codeclimate/github/rstacruz/REPO.svg?style=flat)](https://codeclimate.com/github/rstacruz/REPO + "CodeClimate") + + Coveralls (shields.io) + [![Coveralls](http://img.shields.io/coveralls/rstacruz/REPO.svg?style=flat)](https://coveralls.io/r/rstacruz/REPO) + + Travis (shields.io) + [![Status](http://img.shields.io/travis/rstacruz/REPO/master.svg?style=flat)](https://travis-ci.org/rstacruz/REPO "See test builds") + + NPM (shields.io) + [![npm version](http://img.shields.io/npm/v/REPO.svg?style=flat)](https://npmjs.org/package/REPO "View this project on npm") + + Ruby gem (shields.io) + [![Gem](https://img.shields.io/gem/v/GEMNAME.svg?style=flat)](http://rubygems.org/gems/GEMNAME "View this project in Rubygems") + +### Etc + + Gitter chat + [![Gitter chat](https://badges.gitter.im/USER/REPO.png)](https://gitter.im/REPO/GITTERROOM "Gitter chat") + + Gitter chat (shields.io) + [![Chat](http://img.shields.io/badge/gitter-USER / REPO-blue.svg)]( https://gitter.im/USER/REPO ) + + david-dm + [![Dependencies](http://img.shields.io/david/rstacruz/REPO.svg?style=flat)](https://david-dm.org/rstacruz/REPO) + + [![MIT license](http://img.shields.io/badge/license-MIT-brightgreen.svg)](http://opensource.org/licenses/MIT) + + [![MIT license](http://img.shields.io/badge/license-MIT-brightgreen.svg)](http://opensource.org/licenses/MIT) + +### Support stuff + + Support + ------- + + __Bugs and requests__: submit them through the project's issues tracker.<br> + [![Issues](http://img.shields.io/github/issues/USER/REPO.svg)]( https://github.com/USER/REPO/issues ) + + __Questions__: ask them at StackOverflow with the tag *REPO*.<br> + [![StackOverflow](http://img.shields.io/badge/stackoverflow-REPO-blue.svg)]( http://stackoverflow.com/questions/tagged/REPO ) + + __Chat__: join us at gitter.im.<br> + [![Chat](http://img.shields.io/badge/gitter.im-USER/REPO-blue.svg)]( https://gitter.im/USER/REPO ) + +### Frontend js installation + + Installation + ------------ + + Add [nprogress.js] and [nprogress.css] to your project. + + ```html + <script src='nprogress.js'></script> + <link rel='stylesheet' href='nprogress.css'/> + ``` + + NProgress is available via [bower] and [npm]. + + $ bower install --save nprogress + $ npm install --save nprogress + + [bower]: http://bower.io/search/?q=nprogress + [npm]: https://www.npmjs.org/package/nprogress + +### Acknowledgements + + **PROJECTNAME** © 2014+, Rico Sta. Cruz. Released under the [MIT] License.<br> + Authored and maintained by Rico Sta. Cruz with help from contributors ([list][contributors]). + + > [ricostacruz.com](http://ricostacruz.com)  ·  + > GitHub [@rstacruz](https://github.com/rstacruz)  ·  + > Twitter [@rstacruz](https://twitter.com/rstacruz) + + [MIT]: http://mit-license.org/ + [contributors]: http://github.com/rstacruz/nprogress/contributors + +### Links + + * Everything: http://shields.io/ + + * Version badge (gems, npm): http://badge.fury.io/ + + * Dependencies (ruby): http://gemnasium.com/ + + * CI: http://travis-ci.org/ + + * Code quality (ruby): http://codeclimate.com/ + + * Test coverage: https://coveralls.io/ + + + +### [2-resources/__CHEAT-SHEETS/All/bash.md](2-resources/__CHEAT-SHEETS/All/bash.md) + +<!-- START doctoc generated TOC please keep comment here to allow auto update --> +<!-- DON'T EDIT THIS SECTION, INSTEAD RE-RUN doctoc TO UPDATE --> +**Table of Contents** *generated with [DocToc](https://github.com/thlorenz/doctoc)* + +- [Getting started](#getting-started) + - [Introduction](#introduction) + - [Example](#example) + - [Variables](#variables) + - [String quotes](#string-quotes) + - [Shell execution](#shell-execution) + - [Conditional execution](#conditional-execution) + - [Functions](#functions) + - [Conditionals](#conditionals) + - [Strict mode](#strict-mode) + - [Brace expansion](#brace-expansion) +- [Parameter expansions](#parameter-expansions) + - [Basics](#basics) + - [Substitution](#substitution) + - [Comments](#comments) + - [Substrings](#substrings) + - [Length](#length) + - [Manipulation](#manipulation) + - [Default values](#default-values) +- [Loops](#loops) + - [Basic for loop](#basic-for-loop) + - [C-like for loop](#c-like-for-loop) + - [Ranges](#ranges) + - [With step size](#with-step-size) + - [Reading lines](#reading-lines) + - [Forever](#forever) +- [Functions](#functions-1) + - [Defining functions](#defining-functions) + - [Returning values](#returning-values) + - [Raising errors](#raising-errors) + - [Arguments](#arguments) +- [Conditionals](#conditionals-1) + - [Conditions](#conditions) + - [More conditions](#more-conditions) + - [File conditions](#file-conditions) + - [Example](#example-1) +- [Arrays](#arrays) + - [Defining arrays](#defining-arrays) + - [Working with arrays](#working-with-arrays) + - [Operations](#operations) + - [Iteration](#iteration) +- [Dictionaries](#dictionaries) + - [Defining](#defining) + - [Working with dictionaries](#working-with-dictionaries) + - [Iteration](#iteration-1) + - [Iterate over values](#iterate-over-values) + - [Iterate over keys](#iterate-over-keys) +- [Options](#options) + - [Options](#options-1) + - [Glob options](#glob-options) +- [History](#history) + - [Commands](#commands) + - [Expansions](#expansions) + - [Operations](#operations-1) + - [Slices](#slices) +- [Miscellaneous](#miscellaneous) + - [Numeric calculations](#numeric-calculations) + - [Subshells](#subshells) + - [Redirection](#redirection) + - [Inspecting commands](#inspecting-commands) + - [Trap errors](#trap-errors) + - [Case/switch](#caseswitch) + - [Source relative](#source-relative) + - [printf](#printf) + - [Directory of script](#directory-of-script) + - [Getting options](#getting-options) + - [Heredoc](#heredoc) + - [Reading input](#reading-input) + - [Special variables](#special-variables) + - [Go to previous directory](#go-to-previous-directory) + - [Check for command's result](#check-for-commands-result) + - [Grep check](#grep-check) +- [Also see](#also-see) + +<!-- END doctoc generated TOC please keep comment here to allow auto update --> + +--- +title: Bash scripting +category: CLI +layout: 2017/sheet +tags: [Featured] +updated: 2020-07-05 +keywords: + - Variables + - Functions + - Interpolation + - Brace expansions + - Loops + - Conditional execution + - Command substitution +--- + +Getting started +--------------- +{: .-three-column} + +### Introduction +{: .-intro} + +This is a quick reference to getting started with Bash scripting. + +- [Learn bash in y minutes](https://learnxinyminutes.com/docs/bash/) _(learnxinyminutes.com)_ +- [Bash Guide](http://mywiki.wooledge.org/BashGuide) _(mywiki.wooledge.org)_ + +### Example + +```bash +#!/usr/bin/env bash + +NAME="John" +echo "Hello $NAME!" +``` + +### Variables + +```bash +NAME="John" +echo $NAME +echo "$NAME" +echo "${NAME}!" +``` + +### String quotes + +```bash +NAME="John" +echo "Hi $NAME" #=> Hi John +echo 'Hi $NAME' #=> Hi $NAME +``` + +### Shell execution + +```bash +echo "I'm in $(pwd)" +echo "I'm in `pwd`" +# Same +``` + +See [Command substitution](http://wiki.bash-hackers.org/syntax/expansion/cmdsubst) + +### Conditional execution + +```bash +git commit && git push +git commit || echo "Commit failed" +``` + +### Functions +{: id='functions-example'} + +```bash +get_name() { + echo "John" +} + +echo "You are $(get_name)" +``` + +See: [Functions](#functions) + +### Conditionals +{: id='conditionals-example'} + +```bash +if [[ -z "$string" ]]; then + echo "String is empty" +elif [[ -n "$string" ]]; then + echo "String is not empty" +fi +``` + +See: [Conditionals](#conditionals) + +### Strict mode + +```bash +set -euo pipefail +IFS=$'\n\t' +``` + +See: [Unofficial bash strict mode](http://redsymbol.net/articles/unofficial-bash-strict-mode/) + +### Brace expansion + +```bash +echo {A,B}.js +``` + +| Expression | Description | +| ---------- | ------------------- | +| `{A,B}` | Same as `A B` | +| `{A,B}.js` | Same as `A.js B.js` | +| `{1..5}` | Same as `1 2 3 4 5` | + +See: [Brace expansion](http://wiki.bash-hackers.org/syntax/expansion/brace) + + +Parameter expansions +-------------------- +{: .-three-column} + +### Basics + +```bash +name="John" +echo ${name} +echo ${name/J/j} #=> "john" (substitution) +echo ${name:0:2} #=> "Jo" (slicing) +echo ${name::2} #=> "Jo" (slicing) +echo ${name::-1} #=> "Joh" (slicing) +echo ${name:(-1)} #=> "n" (slicing from right) +echo ${name:(-2):1} #=> "h" (slicing from right) +echo ${food:-Cake} #=> $food or "Cake" +``` + +```bash +length=2 +echo ${name:0:length} #=> "Jo" +``` + +See: [Parameter expansion](http://wiki.bash-hackers.org/syntax/pe) + +```bash +STR="/path/to/foo.cpp" +echo ${STR%.cpp} # /path/to/foo +echo ${STR%.cpp}.o # /path/to/foo.o +echo ${STR%/*} # /path/to + +echo ${STR##*.} # cpp (extension) +echo ${STR##*/} # foo.cpp (basepath) + +echo ${STR#*/} # path/to/foo.cpp +echo ${STR##*/} # foo.cpp + +echo ${STR/foo/bar} # /path/to/bar.cpp +``` + +```bash +STR="Hello world" +echo ${STR:6:5} # "world" +echo ${STR: -5:5} # "world" +``` + +```bash +SRC="/path/to/foo.cpp" +BASE=${SRC##*/} #=> "foo.cpp" (basepath) +DIR=${SRC%$BASE} #=> "/path/to/" (dirpath) +``` + +### Substitution + +| Code | Description | +| ----------------- | ------------------- | +| `${FOO%suffix}` | Remove suffix | +| `${FOO#prefix}` | Remove prefix | +| --- | --- | +| `${FOO%%suffix}` | Remove long suffix | +| `${FOO##prefix}` | Remove long prefix | +| --- | --- | +| `${FOO/from/to}` | Replace first match | +| `${FOO//from/to}` | Replace all | +| --- | --- | +| `${FOO/%from/to}` | Replace suffix | +| `${FOO/#from/to}` | Replace prefix | + +### Comments + +```bash +# Single line comment +``` + +```bash +: ' +This is a +multi line +comment +' +``` + +### Substrings + +| Expression | Description | +| --------------- | ------------------------------ | +| `${FOO:0:3}` | Substring _(position, length)_ | +| `${FOO:(-3):3}` | Substring from the right | + +### Length + +| Expression | Description | +| ---------- | ---------------- | +| `${#FOO}` | Length of `$FOO` | + +### Manipulation + +```bash +STR="HELLO WORLD!" +echo ${STR,} #=> "hELLO WORLD!" (lowercase 1st letter) +echo ${STR,,} #=> "hello world!" (all lowercase) + +STR="hello world!" +echo ${STR^} #=> "Hello world!" (uppercase 1st letter) +echo ${STR^^} #=> "HELLO WORLD!" (all uppercase) +``` + +### Default values + +| Expression | Description | +| ----------------- | -------------------------------------------------------- | +| `${FOO:-val}` | `$FOO`, or `val` if unset (or null) | +| `${FOO:=val}` | Set `$FOO` to `val` if unset (or null) | +| `${FOO:+val}` | `val` if `$FOO` is set (and not null) | +| `${FOO:?message}` | Show error message and exit if `$FOO` is unset (or null) | + +Omitting the `:` removes the (non)nullity checks, e.g. `${FOO-val}` expands to `val` if unset otherwise `$FOO`. + +Loops +----- +{: .-three-column} + +### Basic for loop + +```bash +for i in /etc/rc.*; do + echo $i +done +``` + +### C-like for loop + +```bash +for ((i = 0 ; i < 100 ; i++)); do + echo $i +done +``` + +### Ranges + +```bash +for i in {1..5}; do + echo "Welcome $i" +done +``` + +#### With step size + +```bash +for i in {5..50..5}; do + echo "Welcome $i" +done +``` + +### Reading lines + +```bash +cat file.txt | while read line; do + echo $line +done +``` + +### Forever + +```bash +while true; do + ··· +done +``` + +Functions +--------- +{: .-three-column} + +### Defining functions + +```bash +myfunc() { + echo "hello $1" +} +``` + +```bash +# Same as above (alternate syntax) +function myfunc() { + echo "hello $1" +} +``` + +```bash +myfunc "John" +``` + +### Returning values + +```bash +myfunc() { + local myresult='some value' + echo $myresult +} +``` + +```bash +result="$(myfunc)" +``` + +### Raising errors + +```bash +myfunc() { + return 1 +} +``` + +```bash +if myfunc; then + echo "success" +else + echo "failure" +fi +``` + +### Arguments + +| Expression | Description | +| --- | --- | +| `$#` | Number of arguments | +| `$*` | All postional arguments (as a single word) | +| `$@` | All postitional arguments (as separate strings) | +| `$1` | First argument | +| `$_` | Last argument of the previous command | + +**Note**: `$@` and `$*` must be quoted in order to perform as described. +Otherwise, they do exactly the same thing (arguments as separate strings). + +See [Special parameters](http://wiki.bash-hackers.org/syntax/shellvars#special_parameters_and_shell_variables). + +Conditionals +------------ +{: .-three-column} + +### Conditions + +Note that `[[` is actually a command/program that returns either `0` (true) or `1` (false). Any program that obeys the same logic (like all base utils, such as `grep(1)` or `ping(1)`) can be used as condition, see examples. + +| Condition | Description | +| --- | --- | +| `[[ -z STRING ]]` | Empty string | +| `[[ -n STRING ]]` | Not empty string | +| `[[ STRING == STRING ]]` | Equal | +| `[[ STRING != STRING ]]` | Not Equal | +| --- | --- | +| `[[ NUM -eq NUM ]]` | Equal | +| `[[ NUM -ne NUM ]]` | Not equal | +| `[[ NUM -lt NUM ]]` | Less than | +| `[[ NUM -le NUM ]]` | Less than or equal | +| `[[ NUM -gt NUM ]]` | Greater than | +| `[[ NUM -ge NUM ]]` | Greater than or equal | +| --- | --- | +| `[[ STRING =~ STRING ]]` | Regexp | +| --- | --- | +| `(( NUM < NUM ))` | Numeric conditions | + +#### More conditions + +| Condition | Description | +| -------------------- | ------------------------ | +| `[[ -o noclobber ]]` | If OPTIONNAME is enabled | +| --- | --- | +| `[[ ! EXPR ]]` | Not | +| `[[ X && Y ]]` | And | +| `[[ X || Y ]]` | Or | + +### File conditions + +| Condition | Description | +| --- | --- | +| `[[ -e FILE ]]` | Exists | +| `[[ -r FILE ]]` | Readable | +| `[[ -h FILE ]]` | Symlink | +| `[[ -d FILE ]]` | Directory | +| `[[ -w FILE ]]` | Writable | +| `[[ -s FILE ]]` | Size is > 0 bytes | +| `[[ -f FILE ]]` | File | +| `[[ -x FILE ]]` | Executable | +| --- | --- | +| `[[ FILE1 -nt FILE2 ]]` | 1 is more recent than 2 | +| `[[ FILE1 -ot FILE2 ]]` | 2 is more recent than 1 | +| `[[ FILE1 -ef FILE2 ]]` | Same files | + +### Example + +```bash +# String +if [[ -z "$string" ]]; then + echo "String is empty" +elif [[ -n "$string" ]]; then + echo "String is not empty" +else + echo "This never happens" +fi +``` + +```bash +# Combinations +if [[ X && Y ]]; then + ... +fi +``` + +```bash +# Equal +if [[ "$A" == "$B" ]] +``` + +```bash +# Regex +if [[ "A" =~ . ]] +``` + +```bash +if (( $a < $b )); then + echo "$a is smaller than $b" +fi +``` + +```bash +if [[ -e "file.txt" ]]; then + echo "file exists" +fi +``` + +Arrays +------ + +### Defining arrays + +```bash +Fruits=('Apple' 'Banana' 'Orange') +``` + +```bash +Fruits[0]="Apple" +Fruits[1]="Banana" +Fruits[2]="Orange" +``` + +### Working with arrays + +```bash +echo ${Fruits[0]} # Element #0 +echo ${Fruits[-1]} # Last element +echo ${Fruits[@]} # All elements, space-separated +echo ${#Fruits[@]} # Number of elements +echo ${#Fruits} # String length of the 1st element +echo ${#Fruits[3]} # String length of the Nth element +echo ${Fruits[@]:3:2} # Range (from position 3, length 2) +echo ${!Fruits[@]} # Keys of all elements, space-separated +``` + +### Operations + +```bash +Fruits=("${Fruits[@]}" "Watermelon") # Push +Fruits+=('Watermelon') # Also Push +Fruits=( ${Fruits[@]/Ap*/} ) # Remove by regex match +unset Fruits[2] # Remove one item +Fruits=("${Fruits[@]}") # Duplicate +Fruits=("${Fruits[@]}" "${Veggies[@]}") # Concatenate +lines=(`cat "logfile"`) # Read from file +``` + +### Iteration + +```bash +for i in "${arrayName[@]}"; do + echo $i +done +``` + +Dictionaries +------------ +{: .-three-column} + +### Defining + +```bash +declare -A sounds +``` + +```bash +sounds[dog]="bark" +sounds[cow]="moo" +sounds[bird]="tweet" +sounds[wolf]="howl" +``` + +Declares `sound` as a Dictionary object (aka associative array). + +### Working with dictionaries + +```bash +echo ${sounds[dog]} # Dog's sound +echo ${sounds[@]} # All values +echo ${!sounds[@]} # All keys +echo ${#sounds[@]} # Number of elements +unset sounds[dog] # Delete dog +``` + +### Iteration + +#### Iterate over values + +```bash +for val in "${sounds[@]}"; do + echo $val +done +``` + +#### Iterate over keys + +```bash +for key in "${!sounds[@]}"; do + echo $key +done +``` + +Options +------- + +### Options + +```bash +set -o noclobber # Avoid overlay files (echo "hi" > foo) +set -o errexit # Used to exit upon error, avoiding cascading errors +set -o pipefail # Unveils hidden failures +set -o nounset # Exposes unset variables +``` + +### Glob options + +```bash +shopt -s nullglob # Non-matching globs are removed ('*.foo' => '') +shopt -s failglob # Non-matching globs throw errors +shopt -s nocaseglob # Case insensitive globs +shopt -s dotglob # Wildcards match dotfiles ("*.sh" => ".foo.sh") +shopt -s globstar # Allow ** for recursive matches ('lib/**/*.rb' => 'lib/a/b/c.rb') +``` + +Set `GLOBIGNORE` as a colon-separated list of patterns to be removed from glob +matches. + +History +------- + +### Commands + +| Command | Description | +| --------------------- | ----------------------------------------- | +| `history` | Show history | +| `shopt -s histverify` | Don't execute expanded result immediately | + +### Expansions + +| Expression | Description | +| ------------ | ---------------------------------------------------- | +| `!$` | Expand last parameter of most recent command | +| `!*` | Expand all parameters of most recent command | +| `!-n` | Expand `n`th most recent command | +| `!n` | Expand `n`th command in history | +| `!<command>` | Expand most recent invocation of command `<command>` | + +### Operations + +| Code | Description | +| -------------------- | --------------------------------------------------------------------- | +| `!!` | Execute last command again | +| `!!:s/<FROM>/<TO>/` | Replace first occurrence of `<FROM>` to `<TO>` in most recent command | +| `!!:gs/<FROM>/<TO>/` | Replace all occurrences of `<FROM>` to `<TO>` in most recent command | +| `!$:t` | Expand only basename from last parameter of most recent command | +| `!$:h` | Expand only directory from last parameter of most recent command | + +`!!` and `!$` can be replaced with any valid expansion. + +### Slices + +| Code | Description | +| -------- | ---------------------------------------------------------------------------------------- | +| `!!:n` | Expand only `n`th token from most recent command (command is `0`; first argument is `1`) | +| `!^` | Expand first argument from most recent command | +| `!$` | Expand last token from most recent command | +| `!!:n-m` | Expand range of tokens from most recent command | +| `!!:n-$` | Expand `n`th token to last from most recent command | + +`!!` can be replaced with any valid expansion i.e. `!cat`, `!-2`, `!42`, etc. + + +Miscellaneous +------------- + +### Numeric calculations + +```bash +$((a + 200)) # Add 200 to $a +``` + +```bash +$(($RANDOM%200)) # Random number 0..199 +``` + +### Subshells + +```bash +(cd somedir; echo "I'm now in $PWD") +pwd # still in first directory +``` + +### Redirection + +```bash +python hello.py > output.txt # stdout to (file) +python hello.py >> output.txt # stdout to (file), append +python hello.py 2> error.log # stderr to (file) +python hello.py 2>&1 # stderr to stdout +python hello.py 2>/dev/null # stderr to (null) +python hello.py &>/dev/null # stdout and stderr to (null) +``` + +```bash +python hello.py < foo.txt # feed foo.txt to stdin for python +``` + +### Inspecting commands + +```bash +command -V cd +#=> "cd is a function/alias/whatever" +``` + +### Trap errors + +```bash +trap 'echo Error at about $LINENO' ERR +``` + +or + +```bash +traperr() { + echo "ERROR: ${BASH_SOURCE[1]} at about ${BASH_LINENO[0]}" +} + +set -o errtrace +trap traperr ERR +``` + +### Case/switch + +```bash +case "$1" in + start | up) + vagrant up + ;; + + *) + echo "Usage: $0 {start|stop|ssh}" + ;; +esac +``` + +### Source relative + +```bash +source "${0%/*}/../share/foo.sh" +``` + +### printf + +```bash +printf "Hello %s, I'm %s" Sven Olga +#=> "Hello Sven, I'm Olga + +printf "1 + 1 = %d" 2 +#=> "1 + 1 = 2" + +printf "This is how you print a float: %f" 2 +#=> "This is how you print a float: 2.000000" +``` + +### Directory of script + +```bash +DIR="${0%/*}" +``` + +### Getting options + +```bash +while [[ "$1" =~ ^- && ! "$1" == "--" ]]; do case $1 in + -V | --version ) + echo $version + exit + ;; + -s | --string ) + shift; string=$1 + ;; + -f | --flag ) + flag=1 + ;; +esac; shift; done +if [[ "$1" == '--' ]]; then shift; fi +``` + +### Heredoc + +```sh +cat <<END +hello world +END +``` + +### Reading input + +```bash +echo -n "Proceed? [y/n]: " +read ans +echo $ans +``` + +```bash +read -n 1 ans # Just one character +``` + +### Special variables + +| Expression | Description | +| ---------- | ---------------------------- | +| `$?` | Exit status of last task | +| `$!` | PID of last background task | +| `$$` | PID of shell | +| `$0` | Filename of the shell script | + +See [Special parameters](http://wiki.bash-hackers.org/syntax/shellvars#special_parameters_and_shell_variables). + +### Go to previous directory + +```bash +pwd # /home/user/foo +cd bar/ +pwd # /home/user/foo/bar +cd - +pwd # /home/user/foo +``` + +### Check for command's result + +```bash +if ping -c 1 google.com; then + echo "It appears you have a working internet connection" +fi +``` + +### Grep check + +```bash +if grep -q 'foo' ~/.bash_history; then + echo "You appear to have typed 'foo' in the past" +fi +``` + +## Also see +{: .-one-column} + +* [Bash-hackers wiki](http://wiki.bash-hackers.org/) _(bash-hackers.org)_ +* [Shell vars](http://wiki.bash-hackers.org/syntax/shellvars) _(bash-hackers.org)_ +* [Learn bash in y minutes](https://learnxinyminutes.com/docs/bash/) _(learnxinyminutes.com)_ +* [Bash Guide](http://mywiki.wooledge.org/BashGuide) _(mywiki.wooledge.org)_ +* [ShellCheck](https://www.shellcheck.net/) _(shellcheck.net)_ + + +### [2-resources/__CHEAT-SHEETS/All/blessed.md](2-resources/__CHEAT-SHEETS/All/blessed.md) + +<!-- START doctoc generated TOC please keep comment here to allow auto update --> +<!-- DON'T EDIT THIS SECTION, INSTEAD RE-RUN doctoc TO UPDATE --> +**Table of Contents** *generated with [DocToc](https://github.com/thlorenz/doctoc)* + +- [Screen](#screen) +- [Element](#element) +- [Tags](#tags) + +<!-- END doctoc generated TOC please keep comment here to allow auto update --> + +--- +title: Blessed +category: JavaScript libraries +layout: 2017/sheet +--- + +### Screen + +```js +screen = blessed.screen({ + smartCSR: true // optimize for flickering + autoPadding: true // .. +}) + +screen.append(Element) +screen.destroy() + +screen.width +screen.height +screen.title = 'My window title' +screen.key(['escape', 'q', 'C-c'], (ch, key) => { ... }) +``` + +### Element + +```js +box = blessed.box({ + style: { fg, bg, border.fg, scrollbar.bg, focus.bg, hover.bg }, + border: { type: 'line'|'bg', bg, fg, bold, underline } + tags: true, // parse {bold}tags{/bold} + + top, left, width, height, + width: '100%', + height: '100%-1', + top: 'center' +}) +``` + +### Tags + +``` +{bold} +{right} {center} +{|} left-right separator +{#c0ff33-fg}{/} +``` + +``` +blessed.escape('...') +``` + + +### [2-resources/__CHEAT-SHEETS/All/bluebird.md](2-resources/__CHEAT-SHEETS/All/bluebird.md) + +<!-- START doctoc generated TOC please keep comment here to allow auto update --> +<!-- DON'T EDIT THIS SECTION, INSTEAD RE-RUN doctoc TO UPDATE --> +**Table of Contents** *generated with [DocToc](https://github.com/thlorenz/doctoc)* + + - [Also see](#also-see) + - [Example](#example) + - [Multiple return values](#multiple-return-values) + - [Multiple promises](#multiple-promises) + - [Multiple promises (array)](#multiple-promises-array) + - [Object](#object) + - [Chain of promises](#chain-of-promises) + - [Node-style functions](#node-style-functions) + - [Promise-returning methods](#promise-returning-methods) + - [Generators](#generators) +- [Reference](#reference) + +<!-- END doctoc generated TOC please keep comment here to allow auto update --> + +--- +title: bluebird.js +category: JavaScript libraries +layout: 2017/sheet +weight: -1 +updated: 2017-09-08 +--- + +### Also see + +Also see the [promise cheatsheet](promise.html) and [Bluebird.js API](https://github.com/petkaantonov/bluebird/blob/master/API.md) (github.com). + +### Example + +```js +promise + .then(okFn, errFn) + .spread(okFn, errFn) // * + .catch(errFn) + .catch(TypeError, errFn) // * + .finally(fn) + .map(function (e) { ··· }) // * + .each(function (e) { ··· }) // * +``` + +Those marked with `*` are non-standard Promise API that only work with Bluebird promises. + +### Multiple return values + +```js +.then(function () { + return [ 'abc', 'def' ] +}) +.spread(function (abc, def) { + ··· +}) +``` +{: data-line="4"} + +Use [Promise.spread](http://bluebirdjs.com/docs/api/promise.spread.html) + +### Multiple promises + +```js +Promise.join( + getPictures(), + getMessages(), + getTweets(), + function (pics, msgs, tweets) { + return ··· + } +) +``` +{: data-line="1"} + +Use [Promise.join](http://bluebirdjs.com/docs/api/promise.join.html) + +### Multiple promises (array) + +- [Promise.all](http://bluebirdjs.com/docs/api/promise.all.html)([p]) - expect all to pass +- [Promise.some](http://bluebirdjs.com/docs/api/promise.some.html)([p], count) - expect `count` to pass +- [Promise.any](http://bluebirdjs.com/docs/api/promise.any.html)([p]) - same as `some([p], 1)` +- [Promise.race](http://bluebirdjs.com/docs/api/promise.race.html)([p], count) - use `.any` instead +- [Promise.map](http://bluebirdjs.com/docs/api/promise.map.html)([p], fn, options) - supports concurrency + +```js +Promise.all([ promise1, promise2 ]) + .then(results => { + results[0] + results[1] + }) + +// succeeds if one succeeds first +Promise.any(promises) + .then(results => { + }) +``` +{: data-line="1,8"} + +```js +Promise.map(urls, url => fetch(url)) + .then(···) +``` +{: data-line="1"} + +Use [Promise.map](http://bluebirdjs.com/docs/api/promise.map.html) to "promisify" a list of values. + +### Object + +```js +Promise.props({ + photos: get('photos'), + posts: get('posts') +}) +.then(res => { + res.photos + res.posts +}) +``` +{: data-line="1"} + +Use [Promise.props](http://bluebirdjs.com/docs/api/promise.props.html). + +### Chain of promises + +```js +function getPhotos() { + return Promise.try(() => { + if (err) throw new Error("boo") + return result + }) +} + +getPhotos().then(···) +``` +{: data-line="2"} + +Use [Promise.try](http://bluebirdjs.com/docs/api/promise.try.html). + +### Node-style functions + +```js +var readFile = Promise.promisify(fs.readFile) +var fs = Promise.promisifyAll(require('fs')) +``` +{: data-line="2"} + +See [Promisification](http://bluebirdjs.com/docs/api/promisification.html). + +### Promise-returning methods + +```js +User.login = Promise.method((email, password) => { + if (!valid) + throw new Error("Email not valid") + + return /* promise */ +}) +``` +{: data-line="1"} + +See [Promise.method](http://bluebirdjs.com/docs/api/promise.method.html). + +### Generators + +```js +User.login = Promise.coroutine(function* (email, password) { + let user = yield User.find({email: email}).fetch() + return user +}) +``` +{: data-line="1"} + +See [Promise.coroutine](http://bluebirdjs.com/docs/api/promise.coroutine.html). + +## Reference + +<http://bluebirdjs.com/docs/api-reference.html> + + +### [2-resources/__CHEAT-SHEETS/All/bolt.md](2-resources/__CHEAT-SHEETS/All/bolt.md) + +<!-- START doctoc generated TOC please keep comment here to allow auto update --> +<!-- DON'T EDIT THIS SECTION, INSTEAD RE-RUN doctoc TO UPDATE --> +**Table of Contents** *generated with [DocToc](https://github.com/thlorenz/doctoc)* + +- [Install Bolt](#install-bolt) +- [Create a module with a task](#create-a-module-with-a-task) +- [Run Bolt](#run-bolt) + +<!-- END doctoc generated TOC please keep comment here to allow auto update --> + +--- +title: Bolt Quickstart +category: Bolt +layout: 2017/sheet +updated: 2018-12-25 +authors: + - github: lucywyman +keywords: + - Puppet + - tasks + - modules +description: | + A quick guide to getting started writing Bolt tasks +--- + +### Install Bolt + +```bash +# On MacOS +brew cask install puppetlabs/puppet/puppet-bolt +# On Windows +choco install puppet-bolt +``` + +Bolt is available as a package for most platforms. See [installing bolt](https://puppet.com/docs/bolt/latest/bolt_installing.html) + +### Create a module with a task + +```bash +mkdir -p ~/.puppetlabs/bolt/modules/mymodule/tasks +cp myscript.sh ~/.puppetlabs/bolt/modules/mymodule/tasks/ +``` + +Tasks can be written in any language your targets can run. See [writing tasks](https://puppet.com/docs/bolt/latest/writing_tasks.html) for more details. + +### Run Bolt + +```bash +bolt task run mymodule::myscript -n node1.example.com,node2.example.com --private-key ~/.ssh/id_rsa-private +``` + +See `bolt task run --help` for more information and command line options. + + +### [2-resources/__CHEAT-SHEETS/All/bookshelf-contrib.md](2-resources/__CHEAT-SHEETS/All/bookshelf-contrib.md) + +<!-- START doctoc generated TOC please keep comment here to allow auto update --> +<!-- DON'T EDIT THIS SECTION, INSTEAD RE-RUN doctoc TO UPDATE --> +**Table of Contents** *generated with [DocToc](https://github.com/thlorenz/doctoc)* + +- [bookshelf-contrib.Scopes](#bookshelf-contribscopes) +- [](#) +- [bookshelf-contrib.QueryProxy](#bookshelf-contribqueryproxy) +- [](#-1) +- [bookshelf-contrib.Migration](#bookshelf-contribmigration) + +<!-- END doctoc generated TOC please keep comment here to allow auto update --> + +# bookshelf-contrib.Scopes +# +class Books + scopes: + published: (q) -> q.where(published: true) + +Books.published().fetchAll() + + +# bookshelf-contrib.QueryProxy +# +Books.query().where(published: true) +Books.where(published: true) + +# bookshelf-contrib.Migration +class Migration + up: -> + down: -> + + + + + +### [2-resources/__CHEAT-SHEETS/All/bookshelf.md](2-resources/__CHEAT-SHEETS/All/bookshelf.md) + +<!-- START doctoc generated TOC please keep comment here to allow auto update --> +<!-- DON'T EDIT THIS SECTION, INSTEAD RE-RUN doctoc TO UPDATE --> +**Table of Contents** *generated with [DocToc](https://github.com/thlorenz/doctoc)* + +- [Model](#model) + - [Associations](#associations) + - [CRUD](#crud) + +<!-- END doctoc generated TOC please keep comment here to allow auto update --> + +--- +title: Bookshelf.js +category: JavaScript libraries +--- + +Model +----- + +```js +Summary = bookshelf.Model.extend({ + tableName: 'summaries', + hasTimestamps: true, + hasTimestamps: ['created_at', 'updated_at'], +}) +``` + +### Associations + +```js +Summary = bookshelf.Model.extend({ + book () { + return this.belongsTo(Book) + }, + author () { + return this.hasOne(Author) + } + // belongsToMany + // hasMany + // hasMany().through() +}) +``` + +### CRUD + +```js +Book.create({ title: '..' }).save() +new Book({ title: '..' }).save() + +new Book({ id: 1 }).fetch() + +Book.where({ id: 1 }).fetch() +Book.where('favorite_color', 'red').fetch() +Book.where('favorite_color', '<>', 'red').fetch() +Book + .query((q) => q.orderBy('updated_at') +``` + + +### [2-resources/__CHEAT-SHEETS/All/bootstrap.md](2-resources/__CHEAT-SHEETS/All/bootstrap.md) + +<!-- START doctoc generated TOC please keep comment here to allow auto update --> +<!-- DON'T EDIT THIS SECTION, INSTEAD RE-RUN doctoc TO UPDATE --> +**Table of Contents** *generated with [DocToc](https://github.com/thlorenz/doctoc)* + +- [Screen sizes](#screen-sizes) +- [Columns](#columns) +- [Utilities](#utilities) +- [Modal](#modal) +- [Modal via ajax (Rails)](#modal-via-ajax-rails) +- [Tooltip](#tooltip) +- [Input groups](#input-groups) + +<!-- END doctoc generated TOC please keep comment here to allow auto update --> + +--- +title: Bootstrap +layout: 2017/sheet +prism_languages: [scss, haml, html] +weight: -1 +category: CSS +description: | + .container .row .col-md-6, @screen-sm-min, .form-control, grids, .modal-content, tooltips, and other Bootstrap CSS examples. +--- + +### Screen sizes + +``` + 768 992 1200 +' ' ' ' ' ' ' ' ' +<---------^------------^------------------^---------> + xs sm md lg + (phone) (tablet) (laptop) (desktop) +``` + +Min: + +```scss +@media (min-width: @screen-sm-min) // >= 768px (small tablet) +@media (min-width: @screen-md-min) // >= 992px (medium laptop) +@media (min-width: @screen-lg-min) // >= 1200px (large desktop) +``` + +Max: + +```scss +@media (max-width: @screen-xs-max) { // < 768px (xsmall phone) +@media (max-width: @screen-sm-max) { // < 992px (small tablet) +@media (max-width: @screen-md-max) { // < 1200px (medium laptop) +``` + +### Columns + +```scss +.container +.container-fluid +``` + +```scss +.col-xs-1 +.col-sm-1 +.col-md-1 +.col-lg-1 +.col-md-offset-1 +``` + +Mixins: + +```scss +@include make-xs-column(12); +@include make-sm-column(6); +@include make-md-column(3); +@include make-lg-column(3); +``` + +```scss +@include make-sm-column-offset(1); +@include make-sm-column-push(1); +@include make-sm-column-pull(1); +``` + +### Utilities + +```scss +.pull-left +.pull-right +``` + +```scss +.hidden-{xs,sm,md,lg} +.visible-{xs,sm,md,lg} +.visible-{xs,sm,md,lg,print}-{block,inline,inline-block} +``` + +```scss +.center-block /* margin: auto */ +.clearfix +.text-{center,left,right,justify,nowrap} +.text-{lowercase,uppercase,capitalize} +``` + +```scss +.show +.hidden +``` + +### Modal + +```html +<a data-toggle='modal' data-target='#new'> +``` + +```haml +#new.modal.fade(role='dialog') + .modal-dialog // .modal-lg, .modal-sm + .modal-content + .modal-header + %h4.modal-title hello + %button.close{type: 'button', data: { dismiss: 'modal' }} + %span{'aria-hidden' => true}!= "×" + %span.sr-only Close + .modal-body + ... + .modal-footer + ... +``` + +### Modal via ajax (Rails) + +```haml +%button.btn{data: { | + toggle: 'modal', | + target: '#chooseTheme', | + remote: '/path/to/remote'} + Change Theme +``` + +```haml +.modal.fade#chooseTheme + .modal-dialog.modal-xl + .modal-content + .modal-header + %h4.modal-title Choose a theme + + .modal-body + .spinner-panel.-lg + %i +``` + +### Tooltip + +```html +<span + data-toggle='tooltip' + title='tooltip' + data-placement='left|top|bottom|right'> +``` + +```js +$(function () { + $('[data-toogle~="tooltip"]').tooltip() +}) +``` + +### Input groups + +```haml +.input-group + input.form-control(type='text') + .input-group-addon years +``` + + +### [2-resources/__CHEAT-SHEETS/All/brew.md](2-resources/__CHEAT-SHEETS/All/brew.md) + +--- +title: Homebrew +category: Hidden +redirect_to: /homebrew +--- + + +### [2-resources/__CHEAT-SHEETS/All/browser-sync.md](2-resources/__CHEAT-SHEETS/All/browser-sync.md) + +<!-- START doctoc generated TOC please keep comment here to allow auto update --> +<!-- DON'T EDIT THIS SECTION, INSTEAD RE-RUN doctoc TO UPDATE --> +**Table of Contents** *generated with [DocToc](https://github.com/thlorenz/doctoc)* + +- [Start a server](#start-a-server) +- [Options](#options) +- [Reference](#reference) + +<!-- END doctoc generated TOC please keep comment here to allow auto update --> + +--- +title: Browsersync +category: JavaScript libraries +--- + +``` +npm i -g browser-sync +``` +{:.terminal} + +### Start a server + +```sh +browser-sync start --server <path> --files='**/*.html, **/*.css' +``` + +### Options + +```sh + --port=N + --proxy="http://127.0.0.1:3000" +``` + +### Reference + +* [browsersync.io](http://browsersync.io) + + +### [2-resources/__CHEAT-SHEETS/All/browserify.md](2-resources/__CHEAT-SHEETS/All/browserify.md) + +<!-- START doctoc generated TOC please keep comment here to allow auto update --> +<!-- DON'T EDIT THIS SECTION, INSTEAD RE-RUN doctoc TO UPDATE --> +**Table of Contents** *generated with [DocToc](https://github.com/thlorenz/doctoc)* + +- [Programmatic usage](#programmatic-usage) +- [Tools](#tools) + +<!-- END doctoc generated TOC please keep comment here to allow auto update --> + +--- +title: Browserify +category: JavaScript libraries +--- + + browserify input.js + -o output.js + -t coffeeify + -t [ coffeeify --extension coffee ] + + -u react (--exclude: omit a file) + -x react (--external: reference in another bundle) + -i react (--ignore: stub a file) + -s Myapp (--standalone: generate a UMD bundle) + --debug + +### Programmatic usage + + browserify = require('browserify') + browserify() + .add('main.js') + .bundle() + .transform(coffeeify) + .transform({extensions: '.coffee'}, coffeeify) + .pipe(process.stdout) + + browserify({}) + +### Tools + + * watchify (recompiles on demand) + * beefy (http server) + * debowerify + * es6ify (es6 to es5) + +Transforms + + * coffeeify + * ractify + * reactify + * brfs + * cssify + * https://github.com/substack/node-browserify/wiki/list-of-transforms + + + +### [2-resources/__CHEAT-SHEETS/All/brunch.md](2-resources/__CHEAT-SHEETS/All/brunch.md) + +<!-- START doctoc generated TOC please keep comment here to allow auto update --> +<!-- DON'T EDIT THIS SECTION, INSTEAD RE-RUN doctoc TO UPDATE --> +**Table of Contents** *generated with [DocToc](https://github.com/thlorenz/doctoc)* + +- [Paths](#paths) +- [Config](#config) +- [Plugins](#plugins) +- [Extensions](#extensions) +- [References](#references) + +<!-- END doctoc generated TOC please keep comment here to allow auto update --> + +--- +title: Brunch +category: JavaScript libraries +--- + +## Paths + + / + app/ + assets/ + vendor/ + public/ + config.coffee + +## Config + +```js +module.exports = { + files: { + javascripts: { # or 'stylesheets' or 'templates' + order: { + before: [ 'normalize.css' ], + after: [ 'helpers.css' ], + + joinTo: 'app.js', + joinTo: { + 'js/app.js': /^app/, + 'js/vendor.js': /^vendor/ + }, + pluginHelpers: 'js/vendor.js' + } + } + + paths: { + public: 'public', # where to compile + watched: ['app','test','vendor'], # what to monitor + } + + modules: { + wrapper: 'amd', + definition: 'amd', + nameCleaner: (path) => path.replace(/^app\//, '') + } + + npm: { styles, globals } + + plugins: { + sass: { ... } + } + + // brunch w --apply testing + // BRUNCH_ENV=testing brunch build + overrides: { + production: { + optimize: true, + sourceMaps: false, + plugins: { autoReload: { enabled: false } } + } + } + + onCompile: (files, assets) => { ... } +``` + +## Plugins + + plugins: + uglify: + mangle: true + compress: + global_defs: + DEBUG: false + +## Extensions + +Compile to CSS + + * stylus-brunch + * less-brunch + * sass-brunch + +Compile to HTML + + * static-jade-brunch + +Embedded templates + + * emblem-brunch + +Etc + + * uglify-js-brunch + * jshint-brunch + * imageoptimizer-brunch + +## References + + * <https://github.com/brunch/brunch/blob/master/docs/config.md> + + +### [2-resources/__CHEAT-SHEETS/All/bulma.md](2-resources/__CHEAT-SHEETS/All/bulma.md) + +<!-- START doctoc generated TOC please keep comment here to allow auto update --> +<!-- DON'T EDIT THIS SECTION, INSTEAD RE-RUN doctoc TO UPDATE --> +**Table of Contents** *generated with [DocToc](https://github.com/thlorenz/doctoc)* + +- [Screen sizes](#screen-sizes) +- [Columns](#columns) +- [Modifiers](#modifiers) +- [Typography Helpers](#typography-helpers) +- [WYSIWYG Content](#wysiwyg-content) + +<!-- END doctoc generated TOC please keep comment here to allow auto update --> + +--- +title: Bulma +category: CSS +layout: 2017/sheet +prism_languages: [css, html] +weight: -1 +updated: 2018-11-19 +authors: + - github: benolot +description: | + Basic guide on how to use Bulma, the lightweight css flexbox framework. +--- + +### Screen sizes + +``` + 768 1024 1216 1408 +' ' ' ' ' ' ' ' ' ' ' ' +<---------^------------^------------------^-------------^-------------> + mobile tablet desktop widescreen fullhd +``` + +### Columns + +```css +.container +``` +Wrap as many `.column`'s' as you like in a `.columns` wrapper +```html +<div class="columns"> + <div class="column"></div> + <div class="column"></div> + <div class="column"></div> + <div class="column"></div> + <div class="column"></div> +</div> +``` + +### Modifiers + +The following CSS classes affect the **colour**. + +```css +.is-primary +.is-link +.is-info +.is-success +.is-warning +.is-danger +``` + +The following classes modify the **size**. +```css +.is-small +.is-medium +.is-large +``` + +The following classes modify the **state**. +```scss +.is-outlined +.is-loading +``` + +### Typography Helpers + +The following classes modify the **font-size** + +| Class | Font-size | +| --- | --- | +| `.is-size-1` | 3rem | +| `.is-size-2` | 2.5rem | +| `.is-size-3` | 2rem | +| `.is-size-4` | 1.5rem | +| `.is-size-5` | 1.25rem | +| `.is-size-6` | 1rem | +| `.is-size-7` | 0.75rem | + +The following classes **align** the text + +| Class | Alignment | +| --- | --- | +| `.has-text-centered` | Makes the text **centered** | +| `.has-text-justified` | Makes the text **justified** | +| `.has-text-left`. | Makes the text align to the **left** | +| `.has-text-right` | Makes the text align to the **right** | + +The following classes **transform** the text + +| Class | Transformation | +| --- | --- | +| `.is-capitalized` | Transforms the **first character** of each word to **uppercase** | +| `.is-lowercase` | Transforms **all** characters to **lowercase** | +| `.is-uppercase` | Transforms **all** characters to **uppercase** | + +### WYSIWYG Content + +```html +<div class="content"> + <!-- start WYSIWYG contents --> + <h1>Heading</h1> + <p>Paragraph</p> + + <ul> + <li>Item 1</li> + <li>Item 2</li> + </ul> + <!-- end WYSIWYG contents --> +</div> +``` + +To provide default stylings for commonly generated WYSIWYG contents, use the `.content` class. + + +### [2-resources/__CHEAT-SHEETS/All/bundler.md](2-resources/__CHEAT-SHEETS/All/bundler.md) + +<!-- START doctoc generated TOC please keep comment here to allow auto update --> +<!-- DON'T EDIT THIS SECTION, INSTEAD RE-RUN doctoc TO UPDATE --> +**Table of Contents** *generated with [DocToc](https://github.com/thlorenz/doctoc)* + +- [Commands](#commands) +- [Gems](#gems) +- [Github support](#github-support) +- [Grouping](#grouping) +- [Deployment](#deployment) +- [Local gem development](#local-gem-development) +- [Rake Gem tasks](#rake-gem-tasks) + +<!-- END doctoc generated TOC please keep comment here to allow auto update --> + +--- +title: Bundler +category: Ruby +--- + +### Commands + + bundle # same as bundle install + bundle install # installs gems + bundle install -j3 # faster (3 jobs) + bundle update # update all gems + bundle update --source gemname # update specified gem + + bundle outdated # show outdated gems + cd `bundle show rails` # inspect a gem's dir + + bundle gem # new gem skeleton + +### Gems + + gem 'hello' + gem 'hello', group: 'development' + +### Github support + + gem 'hello', github: 'rstacruz/hello' + gem 'hello', github: 'rstacruz/hello', 'branch: master' + +### Grouping + + group :development do + gem 'hello' + end + +### Deployment + + $ bundle install --without=test,development --deployment + +### Local gem development + +In your Gemfile, define a Git source and a branch: + + gem 'hello', github: 'rstacruz/hello', branch: 'master' + +And then: + + $ bundle config --global local.xxx ~/projects/xxx + +### Rake Gem tasks + + # Rakefile + require 'bundler/gem_tasks' + +Terminal: + + $ rake release + $ rake build + + +### [2-resources/__CHEAT-SHEETS/All/c_preprocessor.md](2-resources/__CHEAT-SHEETS/All/c_preprocessor.md) + +<!-- START doctoc generated TOC please keep comment here to allow auto update --> +<!-- DON'T EDIT THIS SECTION, INSTEAD RE-RUN doctoc TO UPDATE --> +**Table of Contents** *generated with [DocToc](https://github.com/thlorenz/doctoc)* + +- [Reference](#reference) + - [Compiling](#compiling) + - [Includes](#includes) + - [Defines](#defines) + - [If](#if) + - [Error](#error) + - [Macro](#macro) + - [Token concat](#token-concat) + - [Stringification](#stringification) + - [file and line](#file-and-line) + +<!-- END doctoc generated TOC please keep comment here to allow auto update --> + +--- +title: C Preprocessor +category: C-like +layout: 2017/sheet +intro: | + Quick reference for the [C macro preprocessor](https://en.m.wikipedia.org/wiki/C_preprocessor), which can be used independent of C/C++. +--- + +## Reference +{: .-three-column} + +### Compiling + +``` +$ cpp -P file > outfile +``` + +### Includes + +``` +#include "file" +``` + +### Defines + +``` +#define FOO +#define FOO "hello" + +#undef FOO +``` + +### If + +``` +#ifdef DEBUG + console.log('hi'); +#elif defined VERBOSE + ... +#else + ... +#endif +``` + +### Error + +``` +#if VERSION == 2.0 + #error Unsupported + #warning Not really supported +#endif +``` + +### Macro + +``` +#define DEG(x) ((x) * 57.29) +``` + +### Token concat + +``` +#define DST(name) name##_s name##_t +DST(object); #=> object_s object_t; +``` + +### Stringification + +``` +#define STR(name) #name +char * a = STR(object); #=> char * a = "object"; +``` + +### file and line + +``` +#define LOG(msg) console.log(__FILE__, __LINE__, msg) +#=> console.log("file.txt", 3, "hey") +``` + + +### [2-resources/__CHEAT-SHEETS/All/camp.md](2-resources/__CHEAT-SHEETS/All/camp.md) + +<!-- START doctoc generated TOC please keep comment here to allow auto update --> +<!-- DON'T EDIT THIS SECTION, INSTEAD RE-RUN doctoc TO UPDATE --> +**Table of Contents** *generated with [DocToc](https://github.com/thlorenz/doctoc)* + +- [Getting started](#getting-started) + - [Quick start](#quick-start) + - [app.js](#appjs) + - [web/index.html](#webindexhtml) + - [Routes](#routes) + - [Handles `/search?q=rainbows`](#handles-searchqrainbows) + - [Templates](#templates) + - [Not found](#not-found) + - [Low level handler](#low-level-handler) +- [Templates](#templates-1) + - [Basic templates](#basic-templates) + - [Implicit templates](#implicit-templates) +- [Advanced features](#advanced-features) + - [Web sockets](#web-sockets) + +<!-- END doctoc generated TOC please keep comment here to allow auto update --> + +--- +title: Camp +layout: 2017/sheet +category: JavaScript libraries +updated: 2017-09-21 +weight: -1 +intro: | + [Camp](https://github.com/espadrine/sc/) is a Node.js web server framework. This guide targets Camp v17.x. +--- + +Getting started +--------------- +{: .-three-column} + +### Quick start +{: .-prime} + +#### app.js +{: .-file} + +```js +const Camp = require('camp') +const camp = Camp.start({ port: 1234 }) +``` + +#### web/index.html +{: .-file} + +```html +<!doctype html> +<body>Hello world!</body> +``` + +Camp serves files in `web/` by default. + +### Routes + +#### Handles `/search?q=rainbows` + +```js +camp.path('/search', (req, res) => { + const q = res.query.q + res.json({ results: ··· }) +}) +``` +{: data-line="2"} + +Also available: `camp.post`, `camp.get`. + +### Templates + +```js +const tpl = Camp.template('./templates/post.html') + +camp.path('/blog/:post.html', (req, res) => { + res.template({ + text: 'Hello world' + }, tpl) +}) +``` +{: data-line="1,4"} + +See: [Templates](https://github.com/espadrine/sc/blob/master/doc/Readme.md#templates) + +### Not found + +```js +camp.notFound('/*.lol', (req, res) => { + res.file('/404.html') +}) +``` +{: data-line="1"} + +See: [Fall through](https://github.com/espadrine/sc/blob/master/doc/Readme.md#fall-through) + +### Low level handler + +```js +camp.handle((req, res, next) => { + res.setHeader('X-Hello', 'world') + next() +}) +``` +{: data-line="1"} + +See: [Handlers](https://github.com/espadrine/sc/blob/master/doc/Readme.md#handlers) + +Templates +--------- + +### Basic templates + +```js +const tpl = Camp.template('/templates/post.html') + +camp.path('/blog/:post.html', (req, res) => { + res.template({ + text: 'Hello world' + }, tpl) +}) +``` +{: data-line="1,4,5,6"} + +### Implicit templates + +```js +camp.path('blog.html') +``` + +Uses `blog.html` as a template. + +See: [Templates](https://github.com/espadrine/sc/blob/master/doc/Readme.md#templates) + +Advanced features +----------------- + +### Web sockets + +```js +camp.ws('/path', (socket) => { ··· }) +``` + +```js +camp.wsChannels[path] +``` + +```js +camp.wsBroadcast('/path', (req, res) => { +}) +``` + +Sorry I don't completely understand this yet, but check it out in their docs. + +See: [WebSocket](https://github.com/espadrine/sc/blob/master/doc/Readme.md#websocket) + + +### [2-resources/__CHEAT-SHEETS/All/canvas.md](2-resources/__CHEAT-SHEETS/All/canvas.md) + +<!-- START doctoc generated TOC please keep comment here to allow auto update --> +<!-- DON'T EDIT THIS SECTION, INSTEAD RE-RUN doctoc TO UPDATE --> +**Table of Contents** *generated with [DocToc](https://github.com/thlorenz/doctoc)* + +- [Getting the context](#getting-the-context) +- [Basic drawing](#basic-drawing) +- [Saving and restoring](#saving-and-restoring) +- [Animation](#animation) +- [Transformations](#transformations) +- [Image drawing](#image-drawing) +- [Colors, styles shadows](#colors-styles-shadows) +- [Gradients](#gradients) +- [Drawing](#drawing) +- [More resources](#more-resources) + +<!-- END doctoc generated TOC please keep comment here to allow auto update --> + +--- +title: Canvas +category: JavaScript +layout: 2017/sheet +--- + +### Getting the context + +```js +var canvas = document.getElementById('c') +var c = canvas.getContext('2d') +``` + +### Basic drawing + +```js +// x = 10, y = 20, width = 200, height = 100 +c.fillStyle = '#ff0000' +c.strokeStyle = '#ff00ff' +``` + +```js +c.lineWidth = 5 +c.lineCap = 'round' +``` + +```js +c.fillRect(10, 20, 200, 100) +``` + +```js +c.stroke() +c.fill() +``` + +### Saving and restoring + +```js +c.save() +``` + +```js +c.restore() +``` + +Saves: `strokeStyle` `fillStyle` `globalAlpha` `lineWidth` `lineCap` `lineJoin` `miterLimit` `shadowOffsetX` `shadowOffsetY` `shadowBlur` `shadowColor` +`globalCompositeOperation`, Transformations (`translate` `rotate` `scale` `transform` `setTransform`), Clipping path + + +### Animation + +```js +onframe: function() { + c.clearRect(0, 0, w, h) +} +``` + +### Transformations + +```js +c.translate(0, 0) +c.rotate(Math.PI*2/5) +c.scale(1.0, 1.0) +``` + +To rotate along origin: + +```js +c.translate(ox, oy) +c.rotate(theta) +c.translate(-ox, -oy) +``` + +To scale along origin: + +```js +c.translate(-ox*x, -oy*y) +c.scale(x, y) +c.translate(ox/x, oy/y) +``` + +See [MDN: Transformations][xform]. + +### Image drawing + +```js +c.drawImage(image, dx, dy, [dw, dh]); +/* `image` can be HTML Image/Canvas/Video */ +``` + +See [MDN: Images][images]. + +### Colors, styles shadows + +```js +c.strokeStyle = '#ff00ff'; +c.fillStyle = '#ff00ff'; +``` + +```js +c.shadowOffsetX = 0; +c.shadowOffsetY = 0; +c.shadowOffsetBlur = 3.0; +c.shadowColor = 'rgba(0,0,0,0.2)'; +``` + +See [MDN: Styles][styles] + +### Gradients + +```js +gr = c.createLinearGradient(x0,y0,x1,y1) +gr = c.createRadialGradient(x0,y0,r0,x1,y1,r1) +pat = c.createPattern(image, 'repeat-x') +``` + +```js +c.fillStyle = gr +``` + +### Drawing + +```js +c.beginPath() +c.moveTo(x,y) +c.lineTo(x,y) +c.quadraticCurveTo(cpx,cpy,x,y) +c.bezierCurveTo(cp1x,cp1y,cp2x,cp2y) +c.arcTo(...) +c.arc(...) +c.closePath() +``` + +### More resources + + * [Canvas Cheatsheet PDF][pdf] + +[pdf]: http://www.nihilogic.dk/labs/canvas_sheet/HTML5_Canvas_Cheat_Sheet.pdf +[xform]: https://developer.mozilla.org/en-US/docs/Canvas_tutorial/Transformations +[styles]: https://developer.mozilla.org/en-US/docs/Canvas_tutorial/Applying_styles_and_colors +[images]: https://developer.mozilla.org/en-US/docs/Canvas_tutorial/Using_images + + +### [2-resources/__CHEAT-SHEETS/All/capybara.md](2-resources/__CHEAT-SHEETS/All/capybara.md) + +<!-- START doctoc generated TOC please keep comment here to allow auto update --> +<!-- DON'T EDIT THIS SECTION, INSTEAD RE-RUN doctoc TO UPDATE --> +**Table of Contents** *generated with [DocToc](https://github.com/thlorenz/doctoc)* + + - [Navigating](#navigating) + - [Clicking links and buttons](#clicking-links-and-buttons) + - [Interacting with forms](#interacting-with-forms) + - [Limiting](#limiting) +- [Querying](#querying) + - [Predicates](#predicates) + - [Selectors](#selectors) + - [RSpec assertions](#rspec-assertions) + - [About negatives](#about-negatives) +- [RSpec](#rspec) + - [Matchers](#matchers) + - [Common options](#common-options) +- [Other features](#other-features) + - [Finding](#finding) + - [Scoping](#scoping) + - [Scripting](#scripting) + - [Debugging](#debugging) + - [Page](#page) + - [AJAX](#ajax) + - [Misc](#misc) + - [Page object](#page-object) + - [Poltergeist](#poltergeist) + - [Blacklist](#blacklist) + - [Debugging](#debugging-1) +- [Selenium](#selenium) + - [Accepting confirm() and alert()](#accepting-confirm-and-alert) + - [Updating session](#updating-session) +- [See also](#see-also) + +<!-- END doctoc generated TOC please keep comment here to allow auto update -->