├── [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)
PlatformsProgramming LanguagesFront-End DevelopmentBack-End DevelopmentComputer ScienceBig DataTheoryBooksEditorsGamingDevelopment EnvironmentEntertainmentDatabasesMediaLearnSecurityContent Management SystemsHardwareBusinessWorkNetworkingDecentralized SystemsHigher EducationEventsTestingMiscellaneousRelated
- Node.js - Async non-blocking event-driven JavaScript runtime built on Chrome's V8 JavaScript engine.)
- Cross-Platform - Writing cross-platform code on Node.js.)
- Frontend Development)
- iOS - Mobile operating system for Apple phones and tablets.)
- Android - Mobile operating system developed by Google.)
- IoT & Hybrid Apps)
- Electron - Cross-platform native desktop apps using JavaScript/HTML/CSS.)
- Cordova - JavaScript API for hybrid apps.)
- React Native - JavaScript framework for writing natively rendering mobile apps for iOS and Android.)
- Xamarin - Mobile app development IDE, testing, and distribution.)
- Linux)
- Containers)
- eBPF - Virtual machine that allows you to write more efficient and powerful tracing and monitoring for Linux systems.)
- Arch-based Projects - Linux distributions and projects based on Arch Linux.)
- macOS - Operating system for Apple's Mac computers.)
- watchOS - Operating system for the Apple Watch.)
- JVM)
- Salesforce)
- Amazon Web Services)
- Windows)
- IPFS - P2P hypermedia protocol.)
- Fuse - Mobile development tools.)
- Heroku - Cloud platform as a service.)
- Raspberry Pi - Credit card-sized computer aimed at teaching kids programming, but capable of a lot more.)
- Qt - Cross-platform GUI app framework.)
- WebExtensions - Cross-browser extension system.)
- RubyMotion - Write cross-platform native apps for iOS, Android, macOS, tvOS, and watchOS in Ruby.)
- Smart TV - Create apps for different TV platforms.)
- GNOME - Simple and distraction-free desktop environment for Linux.)
- KDE - A free software community dedicated to creating an open and user-friendly computing experience.)
- .NET)
- Amazon Alexa - Virtual home assistant.)
- DigitalOcean - Cloud computing platform designed for developers.)
- Flutter - Google's mobile SDK for building native iOS and Android apps from a single codebase written in Dart.)
- Home Assistant - Open source home automation that puts local control and privacy first.)
- IBM Cloud - Cloud platform for developers and companies.)
- Firebase - App development platform built on Google Cloud Platform.)
- Robot Operating System 2.0 - Set of software libraries and tools that help you build robot apps.)
- Adafruit IO - Visualize and store data from any device.)
- Cloudflare - CDN, DNS, DDoS protection, and security for your site.)
- Actions on Google - Developer platform for Google Assistant.)
- ESP - Low-cost microcontrollers with WiFi and broad IoT applications.)
- Deno - A secure runtime for JavaScript and TypeScript that uses V8 and is built in Rust.)
- DOS - Operating system for x86-based personal computers that was popular during the 1980s and early 1990s.)
- Nix - Package manager for Linux and other Unix systems that makes package management reliable and reproducible.) )
)
- JavaScript)
- Promises)
- Standard Style - Style guide and linter.)
- Must Watch Talks)
- Tips)
- Network Layer)
- Micro npm Packages)
- Mad Science npm Packages - Impossible sounding projects that exist.)
- Maintenance Modules - For npm packages.)
- npm - Package manager.)
- AVA - Test runner.)
- ESLint - Linter.)
- Functional Programming)
- Observables)
- npm scripts - Task runner.)
- 30 Seconds of Code - Code snippets you can understand in 30 seconds.)
- Ponyfills - Like polyfills but without overriding native APIs.)
- Swift - Apple's compiled programming language that is secure, modern, programmer-friendly, and fast.)
- Python - General-purpose programming language designed for readability.)
- Asyncio - Asynchronous I/O in Python 3.)
- Scientific Audio - Scientific research in audio/music.)
- CircuitPython - A version of Python for microcontrollers.)
- Data Science - Data analysis and machine learning.)
- Typing - Optional static typing for Python.)
- MicroPython - A lean and efficient implementation of Python 3 for microcontrollers.)
- Rust)
- Haskell)
- PureScript)
- Go)
- Scala)
- Scala Native - Optimizing ahead-of-time compiler for Scala based on LLVM.)
- Ruby)
- Clojure)
- ClojureScript)
- Elixir)
- Elm)
- Erlang)
- Julia - High-level dynamic programming language designed to address the needs of high-performance numerical analysis and computational science.)
- Lua)
- C)
- C/C++ - General-purpose language with a bias toward system programming and embedded, resource-constrained software.)
- R - Functional programming language and environment for statistical computing and graphics.)
- D)
- Common Lisp - Powerful dynamic multiparadigm language that facilitates iterative and interactive development.)
- Perl)
- Groovy)
- Dart)
- Java - Popular secure object-oriented language designed for flexibility to "write once, run anywhere".)
- Kotlin)
- OCaml)
- ColdFusion)
- Fortran)
- PHP - Server-side scripting language.)
- Composer - Package manager.)
- Pascal)
- AutoHotkey)
- AutoIt)
- Crystal)
- Frege - Haskell for the JVM.)
- CMake - Build, test, and package software.)
- ActionScript 3 - Object-oriented language targeting Adobe AIR.)
- Eta - Functional programming language for the JVM.)
- Idris - General purpose pure functional programming language with dependent types influenced by Haskell and ML.)
- Ada/SPARK - Modern programming language designed for large, long-lived apps where reliability and efficiency are essential.)
- Q# - Domain-specific programming language used for expressing quantum algorithms.)
- Imba - Programming language inspired by Ruby and Python and compiles to performant JavaScript.)
- Vala - Programming language designed to take full advantage of the GLib and GNOME ecosystems, while preserving the speed of C code.)
- Coq - Formal language and environment for programming and specification which facilitates interactive development of machine-checked proofs.)
- V - Simple, fast, safe, compiled language for developing maintainable software.) )
)
- ES6 Tools)
- Web Performance Optimization)
- Web Tools)
- CSS - Style sheet language that specifies how HTML elements are displayed on screen.)
- React - App framework.)
- Relay - Framework for building data-driven React apps.)
- React Hooks - A new feature that lets you use state and other React features without writing a class.)
- Web Components)
- Polymer - JavaScript library to develop Web Components.)
- Angular - App framework.)
- Backbone - App framework.)
- HTML5 - Markup language used for websites & web apps.)
- SVG - XML-based vector image format.)
- Canvas)
- KnockoutJS - JavaScript library.)
- Dojo Toolkit - JavaScript toolkit.)
- Inspiration)
- Ember - App framework.)
- Android UI)
- iOS UI)
- Meteor)
- BEM)
- Flexbox)
- Web Typography)
- Web Accessibility)
- Material Design)
- D3 - Library for producing dynamic, interactive data visualizations.)
- Emails)
- jQuery - Easy to use JavaScript library for DOM manipulation.)
- Tips)
- Web Audio)
- Offline-First)
- Static Website Services)
- Cycle.js - Functional and reactive JavaScript framework.)
- Text Editing)
- Motion UI Design)
- Vue.js - App framework.)
- Marionette.js - App framework.)
- Aurelia - App framework.)
- Charting)
- Ionic Framework 2)
- Chrome DevTools)
- PostCSS - CSS tool.)
- Draft.js - Rich text editor framework for React.)
- Service Workers)
- Progressive Web Apps)
- choo - App framework.)
- Redux - State container for JavaScript apps.)
- webpack - Module bundler.)
- Browserify - Module bundler.)
- Sass - CSS preprocessor.)
- Ant Design - Enterprise-class UI design language.)
- Less - CSS preprocessor.)
- WebGL - JavaScript API for rendering 3D graphics.)
- Preact - App framework.)
- Progressive Enhancement)
- Next.js - Framework for server-rendered React apps.)
- lit-html - HTML templating library for JavaScript.)
- JAMstack - Modern web development architecture based on client-side JavaScript, reusable APIs, and prebuilt markup.)
- WordPress-Gatsby - Web development technology stack with WordPress as a back end and Gatsby as a front end.)
- Mobile Web Development - Creating a great mobile web experience.)
- Storybook - Development environment for UI components.)
- Blazor - .NET web framework using C#/Razor and HTML that runs in the browser with WebAssembly.)
- PageSpeed Metrics - Metrics to help understand page speed and user experience.)
- Tailwind CSS - Utility-first CSS framework for rapid UI development.)
- Seed - Rust framework for creating web apps running in WebAssembly.)
- Web Performance Budget - Techniques to ensure certain performance metrics for a website.)
- Web Animation - Animations in the browser with JavaScript, CSS, SVG, etc.)
- Yew - Rust framework inspired by Elm and React for creating multi-threaded frontend web apps with WebAssembly.)
- Material-UI - Material Design React components for faster and easier web development.)
- Building Blocks for Web Apps - Standalone features to be integrated into web apps.)
- Svelte - App framework.)
- Design systems - Collection of reusable components, guided by rules that ensure consistency and speed.) )
)
- Flask - Python framework.)
- Docker)
- Vagrant - Automation virtual machine environment.)
- Pyramid - Python framework.)
- Play1 Framework)
- CakePHP - PHP framework.)
- Symfony - PHP framework.)
- Laravel - PHP framework.)
- Education)
- TALL Stack - Full-stack development solution featuring libraries built by the Laravel community.)
- Rails - Web app framework for Ruby.)
- Gems - Packages.)
- Phalcon - PHP framework.)
- Useful
.htaccessSnippets) - nginx - Web server.)
- Dropwizard - Java framework.)
- Kubernetes - Open-source platform that automates Linux container operations.)
- Lumen - PHP micro-framework.)
- Serverless Framework - Serverless computing and serverless architectures.)
- Apache Wicket - Java web app framework.)
- Vert.x - Toolkit for building reactive apps on the JVM.)
- Terraform - Tool for building, changing, and versioning infrastructure.)
- Vapor - Server-side development in Swift.)
- Dash - Python web app framework.)
- FastAPI - Python web app framework.)
- CDK - Open-source software development framework for defining cloud infrastructure in code.)
- IAM - User accounts, authentication and authorization.) )
)
- University Courses)
- Data Science)
- Machine Learning)
- Tutorials)
- ML with Ruby - Learning, implementing, and applying Machine Learning using Ruby.)
- Core ML Models - Models for Apple's machine learning framework.)
- H2O - Open source distributed machine learning platform written in Java with APIs in R, Python, and Scala.)
- Software Engineering for Machine Learning - From experiment to production-level machine learning.)
- AI in Finance - Solving problems in finance with machine learning.)
- JAX - Automatic differentiation and XLA compilation brought together for high-performance machine learning research.)
- Speech and Natural Language Processing)
- Spanish)
- NLP with Ruby)
- Question Answering - The science of asking and answering in natural language with a machine.)
- Natural Language Generation - Generation of text used in data to text, conversational agents, and narrative generation applications.)
- Linguistics)
- Cryptography)
- Papers - Theory basics for using cryptography by non-cryptographers.)
- Computer Vision)
- Deep Learning - Neural networks.)
- TensorFlow - Library for machine intelligence.)
- TensorFlow.js - WebGL-accelerated machine learning JavaScript library for training and deploying models.)
- TensorFlow Lite - Framework that optimizes TensorFlow models for on-device machine learning.)
- Papers - The most cited deep learning papers.)
- Education)
- Deep Vision)
- Open Source Society University)
- Functional Programming)
- Empirical Software Engineering - Evidence-based research on software systems.)
- Static Analysis & Code Quality)
- Information Retrieval - Learn to develop your own search engine.)
- Quantum Computing - Computing which utilizes quantum mechanics and qubits on quantum computers.) )
)
- Big Data)
- Public Datasets)
- Hadoop - Framework for distributed storage and processing of very large data sets.)
- Data Engineering)
- Streaming)
- Apache Spark - Unified engine for large-scale data processing.)
- Qlik - Business intelligence platform for data visualization, analytics, and reporting apps.)
- Splunk - Platform for searching, monitoring, and analyzing structured and unstructured machine-generated big data in real-time.) )
)
- Papers We Love)
- Talks)
- Algorithms)
- Education - Learning and practicing.)
- Algorithm Visualizations)
- Artificial Intelligence)
- Search Engine Optimization)
- Competitive Programming)
- Math)
- Recursion Schemes - Traversing nested data structures.) )
)
)
- Sublime Text)
- Vim)
- Emacs)
- Atom - Open-source and hackable text editor.)
- Visual Studio Code - Cross-platform open-source text editor.) )
)
- Game Development)
- Game Talks)
- Godot - Game engine.)
- Open Source Games)
- Unity - Game engine.)
- Chess)
- LÖVE - Game engine.)
- PICO-8 - Fantasy console.)
- Game Boy Development)
- Construct 2 - Game engine.)
- Gideros - Game engine.)
- Minecraft - Sandbox video game.)
- Game Datasets - Materials and datasets for Artificial Intelligence in games.)
- Haxe Game Development - A high-level strongly typed programming language used to produce cross-platform native code.)
- libGDX - Java game framework.)
- PlayCanvas - Game engine.)
- Game Remakes - Actively maintained open-source game remakes.)
- Flame - Game engine for Flutter.)
- Discord Communities - Chat with friends and communities.)
- CHIP-8 - Virtual computer game machine from the 70s.)
- Games of Coding - Learn a programming language by making games.) )
)
- Quick Look Plugins - For macOS.)
- Dev Env)
- Dotfiles)
- Shell)
- Fish - User-friendly shell.)
- Command-Line Apps)
- ZSH Plugins)
- GitHub - Hosting service for Git repositories.)
- Browser Extensions)
- Cheat Sheet)
- Pinned Gists - Dynamic pinned gists for your GitHub profile.)
- Git Cheat Sheet & Git Flow)
- Git Tips)
- Git Add-ons - Enhance the
gitCLI.) - Git Hooks - Scripts for automating tasks during
gitworkflows.) - SSH)
- FOSS for Developers)
- Hyper - Cross-platform terminal app built on web technologies.)
- PowerShell - Cross-platform object-oriented shell.)
- Alfred Workflows - Productivity app for macOS.)
- Terminals Are Sexy)
- GitHub Actions - Create tasks to automate your workflow and share them with others on GitHub.) )
)
- Science Fiction - Scifi.)
- Fantasy)
- Podcasts)
- Email Newsletters)
- IT Quotes) )
)
- Database)
- MySQL)
- SQLAlchemy)
- InfluxDB)
- Neo4j)
- MongoDB - NoSQL database.)
- RethinkDB)
- TinkerPop - Graph computing framework.)
- PostgreSQL - Object-relational database.)
- CouchDB - Document-oriented NoSQL database.)
- HBase - Distributed, scalable, big data store.)
- NoSQL Guides - Help on using non-relational, distributed, open-source, and horizontally scalable databases.)
- Contexture - Abstracts queries/filters and results/aggregations from different backing data stores like ElasticSearch and MongoDB.)
- Database Tools - Everything that makes working with databases easier.)
- Grakn - Logical database to organize large and complex networks of data as one body of knowledge.) )
)
- Creative Commons Media)
- Fonts)
- Codeface - Text editor fonts.)
- Stock Resources)
- GIF - Image format known for animated images.)
- Music)
- Open Source Documents)
- Audio Visualization)
- Broadcasting)
- Pixel Art - Pixel-level digital art.)
- FFmpeg - Cross-platform solution to record, convert and stream audio and video.)
- Icons - Downloadable SVG/PNG/font icon projects.)
- Audiovisual - Lighting, audio and video in professional environments.) )
)
- CLI Workshoppers - Interactive tutorials.)
- Learn to Program)
- Speaking)
- Tech Videos)
- Dive into Machine Learning)
- Computer History)
- Programming for Kids)
- Educational Games - Learn while playing.)
- JavaScript Learning)
- CSS Learning - Mainly about CSS - the language and the modules.)
- Product Management - Learn how to be a better product manager.)
- Roadmaps - Gives you a clear route to improve your knowledge and skills.)
- YouTubers - Watch video tutorials from YouTubers that teach you about technology.) )
)
- Application Security)
- Security)
- CTF - Capture The Flag.)
- Malware Analysis)
- Android Security)
- Hacking)
- Honeypots - Deception trap, designed to entice an attacker into attempting to compromise the information systems in an organization.)
- Incident Response)
- Vehicle Security and Car Hacking)
- Web Security - Security of web apps & services.)
- Lockpicking - The art of unlocking a lock by manipulating its components without the key.)
- Cybersecurity Blue Team - Groups of individuals who identify security flaws in information technology systems.)
- Fuzzing - Automated software testing technique that involves feeding pseudo-randomly generated input data.)
- Embedded and IoT Security)
- GDPR - Regulation on data protection and privacy for all individuals within EU.)
- DevSecOps - Integration of security practices into DevOps.) )
)
- Umbraco)
- Refinery CMS - Ruby on Rails CMS.)
- Wagtail - Django CMS focused on flexibility and user experience.)
- Textpattern - Lightweight PHP-based CMS.)
- Drupal - Extensible PHP-based CMS.)
- Craft CMS - Content-first CMS.)
- Sitecore - .NET digital marketing platform that combines CMS with tools for managing multiple websites.)
- Silverstripe CMS - PHP MVC framework that serves as a classic or headless CMS.) )
)
- Robotics)
- Internet of Things)
- Electronics - For electronic engineers and hobbyists.)
- Bluetooth Beacons)
- Electric Guitar Specifications - Checklist for building your own electric guitar.)
- Plotters - Computer-controlled drawing machines and other visual art robots.)
- Robotic Tooling - Free and open tools for professional robotic development.)
- LIDAR - Sensor for measuring distances by illuminating the target with laser light.) )
)
- Open Companies)
- Places to Post Your Startup)
- OKR Methodology - Goal setting & communication best practices.)
- Leading and Managing - Leading people and being a manager in a technology company/environment.)
- Indie - Independent developer businesses.)
- Tools of the Trade - Tools used by companies on Hacker News.)
- Clean Tech - Fighting climate change with technology.)
- Wardley Maps - Provides high situational awareness to help improve strategic planning and decision making.)
- Social Enterprise - Building an organization primarily focused on social impact that is at least partially self-funded.)
- Engineering Team Management - How to transition from software development to engineering management.)
- Developer-First Products - Products that target developers as the user.) )
)
- Slack - Team collaboration.)
- Remote Jobs)
- Productivity)
- Niche Job Boards)
- Programming Interviews)
- Code Review - Reviewing code.)
- Creative Technology - Businesses & groups that specialize in combining computing, design, art, and user experience.) )
)
- Software-Defined Networking)
- Network Analysis)
- PCAPTools)
- Real-Time Communications - Network protocols for near simultaneous exchange of media and data.) )
)
- Bitcoin - Bitcoin services and tools for software developers.)
- Ripple - Open source distributed settlement network.)
- Non-Financial Blockchain - Non-financial blockchain applications.)
- Mastodon - Open source decentralized microblogging network.)
- Ethereum - Distributed computing platform for smart contract development.)
- Blockchain AI - Blockchain projects for artificial intelligence and machine learning.)
- EOSIO - A decentralized operating system supporting industrial-scale apps.)
- Corda - Open source blockchain platform designed for business.)
- Waves - Open source blockchain platform and development toolset for Web 3.0 apps and decentralized solutions.)
- Substrate - Framework for writing scalable, upgradeable blockchains in Rust.) )
)
- Computational Neuroscience - A multidisciplinary science which uses computational approaches to study the nervous system.)
- Digital History - Computer-aided scientific investigation of history.)
- Scientific Writing - Distraction-free scientific writing with Markdown, reStructuredText and Jupyter notebooks.) )
)
- Creative Tech Events - Events around the globe for creative coding, tech, design, music, arts and cool stuff.)
- Events in Italy - Tech-related events in Italy.)
- Events in the Netherlands - Tech-related events in the Netherlands.) )
)
- Testing - Software testing.)
- Visual Regression Testing - Ensures changes did not break the functionality or style.)
- Selenium - Open-source browser automation framework and ecosystem.)
- Appium - Test automation tool for apps.)
- TAP - Test Anything Protocol.)
- JMeter - Load testing and performance measurement tool.)
- k6 - Open-source, developer-centric performance monitoring and load testing solution.)
- Playwright - Node.js library to automate Chromium, Firefox and WebKit with a single API.)
- Quality Assurance Roadmap - How to start & build a career in software testing.) )
)
- JSON - Text based data interchange format.)
- CSV - A text file format that stores tabular data and uses a comma to separate values.)
- Discounts for Student Developers)
- Radio)
- Awesome - Recursion illustrated.)
- Analytics)
- REST)
- Continuous Integration and Continuous Delivery)
- Services Engineering)
- Free for Developers)
- Answers - Stack Overflow, Quora, etc.)
- Sketch - Design app for macOS.)
- Boilerplate Projects)
- Readme)
- Design and Development Guides)
- Software Engineering Blogs)
- Self Hosted)
- FOSS Production Apps)
- Gulp - Task runner.)
- AMA - Ask Me Anything.)
- Open Source Photography)
- OpenGL - Cross-platform API for rendering 2D and 3D graphics.)
- GraphQL)
- Transit)
- Research Tools)
- Data Visualization)
- Social Media Share Links)
- Microservices)
- Unicode - Unicode standards, quirks, packages and resources.)
- Beginner-Friendly Projects)
- Katas)
- Tools for Activism)
- Citizen Science - For community-based and non-institutional scientists.)
- MQTT - "Internet of Things" connectivity protocol.)
- Hacking Spots)
- For Girls)
- Vorpal - Node.js CLI framework.)
- Vulkan - Low-overhead, cross-platform 3D graphics and compute API.)
- LaTeX - Typesetting language.)
- Economics - An economist's starter kit.)
- Funny Markov Chains)
- Bioinformatics)
- Cheminformatics - Informatics techniques applied to problems in chemistry.)
- Colorful - Choose your next color scheme.)
- Steam - Digital distribution platform.)
- Bots - Building bots.)
- Site Reliability Engineering)
- Empathy in Engineering - Building and promoting more compassionate engineering cultures.)
- DTrace - Dynamic tracing framework.)
- Userscripts - Enhance your browsing experience.)
- Pokémon - Pokémon and Pokémon GO.)
- ChatOps - Managing technical and business operations through a chat.)
- Falsehood - Falsehoods programmers believe in.)
- Domain-Driven Design - Software development approach for complex needs by connecting the implementation to an evolving model.)
- Quantified Self - Self-tracking through technology.)
- SaltStack - Python-based config management system.)
- Web Design - For digital designers.)
- Creative Coding - Programming something expressive instead of something functional.)
- No-Login Web Apps - Web apps that work without login.)
- Free Software - Free as in freedom.)
- Framer - Prototyping interactive UI designs.)
- Markdown - Markup language.)
- Dev Fun - Funny developer projects.)
- Healthcare - Open source healthcare software for facilities, providers, developers, policy experts, and researchers.)
- Magento 2 - Open Source eCommerce built with PHP.)
- TikZ - Graph drawing packages for TeX/LaTeX/ConTeXt.)
- Neuroscience - Study of the nervous system and brain.)
- Ad-Free - Ad-free alternatives.)
- Esolangs - Programming languages designed for experimentation or as jokes rather than actual use.)
- Prometheus - Open-source monitoring system.)
- Homematic - Smart home devices.)
- Ledger - Double-entry accounting on the command-line.)
- Web Monetization - A free open web standard service that allows you to send money directly in your browser.)
- Uncopyright - Public domain works.)
- Crypto Currency Tools & Algorithms - Digital currency where encryption is used to regulate the generation of units and verify transfers.)
- Diversity - Creating a more inclusive and diverse tech community.)
- Open Source Supporters - Companies that offer their tools and services for free to open source projects.)
- Design Principles - Create better and more consistent designs and experiences.)
- Theravada - Teachings from the Theravada Buddhist tradition.)
- inspectIT - Open source Java app performance management tool.)
- Open Source Maintainers - The experience of being an open source maintainer.)
- Calculators - Calculators for every platform.)
- Captcha - A type of challenge-response test used in computing to determine whether or not the user is human.)
- Jupyter - Create and share documents that contain code, equations, visualizations and narrative text.)
- FIRST Robotics Competition - International high school robotics championship.)
- Humane Technology - Open source projects that help improve society.)
- Speakers - Conference and meetup speakers in the programming and design community.)
- Board Games - Table-top gaming fun for all.)
- Software Patreons - Fund individual programmers or the development of open source projects.)
- Parasite - Parasites and host-pathogen interactions.)
- Food - Food-related projects on GitHub.)
- Mental Health - Mental health awareness and self-care in the software industry.)
- Bitcoin Payment Processors - Start accepting Bitcoin.)
- Scientific Computing - Solving complex scientific problems using computers.)
- Amazon Sellers)
- Agriculture - Open source technology for farming and gardening.)
- Product Design - Design a product from the initial concept to production.)
- Prisma - Turn your database into a GraphQL API.)
- Software Architecture - The discipline of designing and building software.)
- Connectivity Data and Reports - Better understand who has access to telecommunication and internet infrastructure and on what terms.)
- Stacks - Tech stacks for building different apps and features.)
- Cytodata - Image-based profiling of biological phenotypes for computational biologists.)
- IRC - Open source messaging protocol.)
- Advertising - Advertising and programmatic media for websites.)
- Earth - Find ways to resolve the climate crisis.)
- Naming - Naming things in computer science done right.)
- Biomedical Information Extraction - How to extract information from unstructured biomedical data and text.)
- Web Archiving - An effort to preserve the Web for future generations.)
- WP-CLI - Command-line interface for WordPress.)
- Credit Modeling - Methods for classifying credit applicants into risk classes.)
- Ansible - A Python-based, open source IT configuration management and automation platform.)
- Biological Visualizations - Interactive visualization of biological data on the web.)
- QR Code - A type of matrix barcode that can be used to store and share a small amount of information.)
- Veganism - Making the plant-based lifestyle easy and accessible.)
- Translations - The transfer of the meaning of a text from one language to another.) )
)
- All Awesome Lists - All the Awesome lists on GitHub.)
- Awesome Indexed - Search the Awesome dataset.)
- Awesome Search - Quick search for Awesome lists.)
- StumbleUponAwesome - Discover random pages from the Awesome dataset using a browser extension.)
- Awesome CLI - A simple command-line tool to dive into Awesome lists.)
- Awesome Viewer - A visualizer for all of the above Awesome lists.) ) Created 1 minute ago | Updated 58 seconds ago) )
1-projects/Atomic-Design-Solution-master/dogs/
Table of Contents generated with DocToc
- Table of Contents
- Updating to New Releases
- Sending Feedback
- Folder Structure
- Available Scripts
- Supported Browsers
- Supported Language Features and Polyfills
- Syntax Highlighting in the Editor
- Displaying Lint Output in the Editor
- Debugging in the Editor
- Formatting Code Automatically
- Changing the Page
<title> - Installing a Dependency
- Importing a Component
- Code Splitting
- Adding a Stylesheet
- Post-Processing CSS
- Adding a CSS Preprocessor (Sass, Less etc.)
- Adding Images, Fonts, and Files
- Using the
publicFolder - Using Global Variables
- Adding Bootstrap
- Adding Flow
- Adding a Router
- Adding Custom Environment Variables
- Can I Use Decorators?
- Fetching Data with AJAX Requests
- Integrating with an API Backend
- Proxying API Requests in Development
- Using HTTPS in Development
- Generating Dynamic
<meta>Tags on the Server - Pre-Rendering into Static HTML Files
- Injecting Data from the Server into the Page
- Running Tests
- Filename Conventions
- Command Line Interface
- Version Control Integration
- Writing Tests
- Testing Components
- Using Third Party Assertion Libraries
- Initializing Test Environment
- Focusing and Excluding Tests
- Coverage Reporting
- Continuous Integration
- On CI servers
- On your own environment
- Disabling jsdom
- Snapshot Testing
- Editor Integration
- Debugging Tests
- Developing Components in Isolation
- Publishing Components to npm
- Making a Progressive Web App
- Analyzing the Bundle Size
- Deployment
- Advanced Configuration
- Troubleshooting
- Alternatives to Ejecting
- Something Missing?
1-projects/Atomic-Design-Solution-master/
Table of Contents generated with DocToc
- Routing with React Router
- Axios for making HTTP requests
- JavaScript Promises
- Atomic Design
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.
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
SubBreedpage 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
filterBreedsor 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
- Dog Breed API: https://dog.ceo/dog-api/
- Atomic Design: http://bradfrost.com/blog/post/atomic-web-design/
- 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
1-projects/Basic-JavaScript-master/
Table of Contents generated with DocToc
- ES6
- Const vs Let vs Var
- Lambda/Arrow functions
- Object Destructuring
- 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!
- Fork and clone this repo.
cdinto this project and Run the commandnpm ito install needed node packages.- Run the command
npm testto 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.
1-projects/Client-Auth-Solution-master/
Table of Contents generated with DocToc
redux-thunkcors
- Redux Thunk
- localStorage
- axios's config object
- http headers
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 corsconst cors = require('cors');app.use(cors());
1-projects/Components-BEM-Solution-master/
Table of Contents generated with DocToc
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.
BEM: http://getbem.com/naming/
Constructors (and factory function): https://medium.com/javascript-scene/javascript-factory-functions-vs-constructor-functions-vs-classes-2f22ceddf33e
1-projects/Components-Constructors-Solution-master/
Table of Contents generated with DocToc
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.
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.
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
1-projects/Data-Structures-master/
Table of Contents generated with DocToc
Answer the following questions for each of the data structures you implemented as part of this project.
-
What is the runtime complexity of
pushusing a list? -
What is the runtime complexity of
pushusing a linked list? -
What is the runtime complexity of
popusing a list? -
What is the runtime complexity of
popusing a linked list? -
What is the runtime complexity of
lenusing a list? -
What is the runtime complexity of
lenusing a linked list?
-
What is the runtime complexity of
enqueueusing a list? -
What is the runtime complexity of
enqueueusing a linked list? -
What is the runtime complexity of
dequeueusing a list? -
What is the runtime complexity of
dequeueusing a linked list? -
What is the runtime complexity of
lenusing a list? -
What is the runtime complexity of
lenusing a linked list?
-
What is the runtime complexity of
ListNode.insert_after? -
What is the runtime complexity of
ListNode.insert_before? -
What is the runtime complexity of
ListNode.delete? -
What is the runtime complexity of
DoublyLinkedList.add_to_head? -
What is the runtime complexity of
DoublyLinkedList.remove_from_head? -
What is the runtime complexity of
DoublyLinkedList.add_to_tail? -
What is the runtime complexity of
DoublyLinkedList.remove_from_tail? -
What is the runtime complexity of
DoublyLinkedList.move_to_front? -
What is the runtime complexity of
DoublyLinkedList.move_to_end? -
What is the runtime complexity of
DoublyLinkedList.delete?a. Compare the runtime of the doubly linked list's
deletemethod with the worst-case runtime of the JSArray.splicemethod. Which method generally performs better?
-
What is the runtime complexity of
insert? -
What is the runtime complexity of
contains? -
What is the runtime complexity of
get_max? -
What is the runtime complexity of
for_each?
-
What is the runtime complexity of
_bubble_up? -
What is the runtime complexity of
_sift_down? -
What is the runtime complexity of
insert? -
What is the runtime complexity of
delete? -
What is the runtime complexity of
get_max?
Table of Contents generated with DocToc
- Data Structures FAQ
- Contents
- General
- My imports aren't working, help!
- 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 Linked List data structure?
- 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?
- What are real-world use-cases for a 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?
- 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 a Search and a Traversal?
- General
- Contents
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.
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.
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.
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.
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.
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.
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.
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, 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.
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.
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.
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.
1-projects/Data-Structures-master/heap/
Table of Contents generated with DocToc
- Should have the methods
insert,delete,get_max,_bubble_up, and_sift_down.insertadds the input value into the heap; this method should ensure that the inserted value is in the correct spot in the heapdeleteremoves 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_maxreturns the maximum value in the heap in constant time.get_sizereturns the number of elements stored in the heap._bubble_upmoves 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_downgrabs 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.
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.
1-projects/Data-Structures-master/
Table of Contents generated with DocToc
Topics:
- Singly Linked Lists
- Queues and Stacks
- Doubly Linked Lists
- Binary Search Trees
- Related Code Challenge Problems
Stretch Goals:
- LRU Cache
- Heaps
- AVL Trees
- 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.
- Should have the methods:
push,pop, andlen.pushadds an item to the top of the stack.popremoves and returns the element at the top of the stacklenreturns the number of elements in the stack.
- Has the methods:
enqueue,dequeue, andlen.enqueueadds an element to the back of the queue.dequeueremoves and returns the element at the front of the queue.lenreturns the number of elements in the queue.
- The
ListNodeclass, 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
DoublyLinkedListclass itself should have the methods:add_to_head,add_to_tail,remove_from_head,remove_from_tail,move_to_front,move_to_end,delete, andget_max.add_to_headreplaces the head of the list with a new value that is passed in.add_to_tailreplaces the tail of the list with a new value that is passed in.remove_from_headremoves the head node and returns the value stored in it.remove_from_tailremoves the tail node and returns the value stored in it.move_to_fronttakes 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_endtakes a reference to a node in the list and moves it to the end of the list, shifting all other list nodes up.deletetakes a reference to a node in the list and removes it from the list. The deleted node'spreviousandnextpointers should point to each afterwards.get_maxreturns the maximum value in the list.
- The
headproperty is a reference to the first node and thetailproperty is a reference to the last node.
- Should have the methods
insert,contains,get_max.insertadds the input value to the binary search tree, adhering to the rules of the ordering of elements in a binary search tree.containssearches the binary search tree for the input value, returning a boolean indicating whether the value exists in the tree or not.get_maxreturns the maximum value in the binary search tree.for_eachperforms 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.
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?
An LRU (Least Recently Used) cache is an in-memory storage structure that adheres to the Least Recently Used 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.
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.
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?
1-projects/DOM-JavaScript-mini-Solution-master/
1-projects/HTML-CSS-mini-Solution-master/
Table of Contents generated with DocToc
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.
Box Model Study Guide
- Make your Box Model solution responsive to browser resizing using media queries. Media Query Min & Max Width Quick Reference
1-projects/Intro-Python-I-master/
Table of Contents generated with DocToc
- FAQ
- Contents
- Questions
- 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?
- 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? - 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?
- What version of Python do I need?
- Do I need to use pipenv?
- How do I get out of the Python REPL?
- What does "REPL" mean?
- I'm on a Mac and when I run Python it says I'm on version 2.7. Why?
- Does Python use tabs or spaces?
- How do I convert an iterator into a list?
- Does Python have hoisting?
- 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 use boolean shortcut assignments?
- Can you do anonymous functions?
- Is a dict like a JavaScript object?
- What are all those method names with double underscores around them?
- How do I get a value from a dict?
- When do we run pipenv shell?
- How do I get out of the pipenv shell?
- How do I install additional packages from pipenv?
- Is it possible to use system-wide packages from inside the virtual environment?
- Where are good Python docs?
- Which linter?
- Can you dynamically add new methods/properties to class through other functions? Or must all properties/methods 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?
- 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?
- Why use tuples instead of lists?
- What's the difference between repr and str?
- How does
sys.argvwork? - How do I concatenate two arrays into a single array?
- What are some ways to learn a new language?
- Why test code frequently?
- Why isn't official documentation more helpful than Stack Overflow?
- During an interview, what do I do if I can't remember the exact syntax?
- What are some things we can do to prepare for CS?
- What are some ways to learn a new language?
- Why test code frequently?
- Why isn't official documentation more helpful than Stack Overflow?
- During an interview, what do I do if I can't remember the exact syntax?
- 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? - 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?
- What version of Python do I need?
- How do I get out of the Python REPL?
- What does "REPL" mean?
- I'm on a Mac and when I run Python it says I'm on version 2.7. Why?
- Does Python use tabs or spaces?
- Can you use boolean shortcut assignments?
- Can you do anonymous functions?
- What are all those method names with double underscores around them?
- Where are good Python docs?
- Which linter?
- What's the difference between repr and str?
- How does
sys.argvwork?
- Do I need to use pipenv?
- When do we run pipenv shell?
- How do I get out of the pipenv shell?
- How do I install additional packages from pipenv?
- Is it possible to use system-wide packages from inside the virtual environment?
- Why is there such a debate between OOP and functional programming, and why should we care?
- 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?
- Can you dynamically add new methods/properties to class through other functions? Or must all properties/methods be declared at once?
- 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?
- Does Python have hoisting?
- 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 do anonymous functions?
- How do I convert an iterator into a list?
- Is a dict like a JavaScript object?
- How do I get a value from a dict?
- Why use tuples instead of lists?
- How do I concatenate two arrays into a single array?
- CS Wiki
- Polya's Problem Solving Techniques
- Solving Programming Problems
- CS Reading List
- How to Google effectively
- How to read specs and code
- Command line primer
- Coding style guidelines
There are a lot of programming paradigms 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.
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().
Hit q for "quit".
It's a common command in Unix "pagers" (programs that show documents a page at a time).
If you're running in PowerShell or cmd, use:
py
If in bash, use python or python3.
You should have version 3.7 or higher. Test with:
python --versionYou should. Good Python devs know how.
Hit CTRL-D. This is the way End-Of-File is signified in Unix-likes.
Read, Evaluate, Print Loop.
It reads your input, evaluates it, and prints the result. And loops.
Macs come with version 2.7 by default. You'll need to install version 3.
And preferable use pipenv after that.
PEP 8 says four spaces.
Cast it:
list(range(5))produces:
[0, 1, 2, 3, 4]No.
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.
Yes. Functions are first-class citizens.
Yes, you can. This is common in Perl and JavaScript, but it's not particularly idiomatic in Python.
x = SomethingFalsey or 5You can use lambda for simple functions:
adder = lambda x, y: x + y
adder(4, 5) # 9
do_some_math(4, 5, lambda x, y: y - x)Sort of.
The syntax is different, though. In Python you must use [] notation to access elements. And you must use " around the key names.
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
d = {
"a": 2,
"b": 3
}
print(d["a"])You don't use dot notation.
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.
Type exit.
pipenv install packagenameThis is not recommended.
- Official documentation tutorial and library reference.
The official docs might be hard to read at first, but you'll get used to them quickly
Pylint or Flake8. The latter seems to be a bit more popular.
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:
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.
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.
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:
-
Lots of devs and shops frown on multiple inheritance, so maybe just don't do it. (Discussion)
-
As for the order in which methods of the same name are resolved, check out the MRO Algorithm which is what Python uses.
class Base1:
pass
class Base2:
pass
class Derived(Base1, Base2): # Multiple inheritance
passSometimes 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) and opt for other solutions, like composition.
- 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
dictkeys.
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.
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:
>>> 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)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:
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:
$ python foo.py
Argument #0 is: foo.py
$ 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:
import sys
for i in range(int(sys.argv[1])):
print(i+1)Example runs:
$ python foo.py 2
1
2
$ python foo.py 4
1
2
3
4
Use extend().
a = [1, 2, 3]
b = [4, 5, 6]
a.extend(b)
print(a) # [ 1, 2, 3, 4, 5, 6 ]- 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.
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.
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.
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.)
Table of Contents generated with DocToc
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.
-
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.
- Installing Python 3
- JavaScript<->Python cheatsheet
- How to read Specs and Code
- Python 3 standard library
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.
- Learn the basic syntax and structure of Python
- Implement a number of tiny Python programs that demonstrate Python syntax and language concepts.
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 worldbignum-- Print some big numbersdatatypes-- Experiment with type conversionmodules-- Learn to import from modulesprinting-- Formatted print outputlists-- Python's version of arraystuples-- Immutable lists typically for heterogenous dataslices-- Accessing parts of listscomprehensions-- List comprehensionsdictionaries-- Dictionariesfunctions-- Functionsargs-- Arguments and Keyword Argumentsscopes-- Global, Local, and Non-Local scopefile_io-- Read and write from filescal-- Experiment with module imports and implement a text-based calendarclasses-- Classes and objects
-
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. 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). Try installing one for your editor!
-
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!
-
Write a program to determine if a number, given on the command line, is prime.
- How can you optimize this program?
- Implement The Sieve of Eratosthenes, one of the oldest algorithms known (ca. 200 BC).
1-projects/Intro-Python-II-master/
Table of Contents generated with DocToc
Refer to the FAQ in Intro-Python-I.
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_toplayer.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.
Table of Contents generated with DocToc
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.
.gif){kind=link}
-
Put your Python basics into practice by implementing a text adventure game
-
Practice writing code that conforms to a specification
- Create the input command parser in
adv.pywhich 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.pyandroom.py
- 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]anddrop [ITEM_NAME]commands to the parser
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.pythat 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,eandwwhich 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.pybased on what you see inadv.py.-
The room should have
nameanddescriptionattributes. -
The room should also have
n_to,s_to,e_to, andw_toattributes which point to the room in that respective direction.
-
-
Put the Player class in
player.py.- Players should have a
nameandcurrent_roomattributes
- Players should have a
-
Create a file called
item.pyand add anItemclass in there.-
The item should have
nameanddescriptionattributes.- 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
Roomclass should be extended with alistthat holds theItems 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
Items to the player's inventory. The inventory can also be alistof items "in" the player, similar to howItems can be in aRoom. -
Add a new type of sentence the parser can understand: two words.
-
Until now, the parser could just understand one sentence form:
verbsuch as "n" or "q".
-
But now we want to add the form:
verbobjectsuch 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
getfollowed by anItemname. This will be used to pick upItems.-
If the user enters
getortakefollowed by anItemname, look at the contents of the currentRoomto see if the item is there.-
If it is there, remove it from the
Roomcontents, and add it to thePlayercontents. -
If it's not there, print an error message telling the user so.
-
Add an
on_takemethod toItem.-
Call this method when the
Itemis picked up by the player. -
on_takeshould print out "You have picked up [NAME]" when you pick up an item. -
The
Itemcan use this to run additional code when it is picked up.
-
-
Add an
on_dropmethod toItem. Implement it similar toon_take.
-
-
-
Implement support for the verb
dropfollowed by anItemname. This is the opposite ofget/take. -
Add the
iandinventorycommands that both show a list of items currently carried by the player.
In arbitrary order:
-
Add more rooms
-
Add scoring
-
Subclass items into treasures
-
Add a subclass to
ItemcalledLightSource.-
During world creation, add a
lampLightSourceto a convenientRoom. -
Override
on_dropinLightSourcethat 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
Roomcalledis_lightthat isTrueif theRoomis naturally illuminated, orFalseif aLightSourceis required to see what is in the room. -
Modify the main loop to test if there is light in the
Room(i.e. ifis_lightisTrueor there is aLightSourceitem in theRoom's contents or if there is aLightSourceitem in thePlayer'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:
isinstancemight help you figure out if there's aLightSourceamong all the nearbyItems. -
Modify the
get/takecode to print "Good luck finding that in the dark!" if the user tries to pick up anItemin 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
Itemmentioned and substitute that if the user types "it" later, e.g.take sword drop it -
Add
Items 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_taketo check the return value. Ifon_takereturnsFalse, 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_taketo code things like "don't allow the user to pick up the dirt unless they're holding the shovel.
- This enables you to add logic to
-
Add monsters.
-
Add the
attackverb that allows you to specify a monster to attack. -
Add an
on_attackmethod to the monster class. -
Similar to the
on_takereturn value modification, above, haveon_attackprevent the attack from succeeding unless the user possesses asworditem. -
Come up with more stretch goals! The sky's the limit!
1-projects/Intro-to-C-master/
Table of Contents generated with DocToc
- Intro to C FAQ
- Contents
- Questions
runtests.sh: $'\r': command not foundorSyntax error: word unexpected (expecting "do")runtests.sh: 3: 56059 Segmentation fault: 11 $VALGRIND- Mac:
malformed objecterror when runningmake tests - Should I bother fixing compiler warnings?
- Can I accidentally destroy my computer running C code?
- Is a
structcomparable to something in Python or JS? Is it like a class? - Can you have default parameters in the structs?
- Why does unsigned char type accept a number when it's 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 ?
- 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?
- When do I need a pointer to a pointer?
- Do other languages use pointers?
- What's the difference between "
int *x" and "int* x"? - What does the "implicit declaration of function" warning mean?
- What's the difference between
puts(),fprintf(), andprintf()? - Why does
025 == 21? - What is the "true dev workflow" in C?
- Does C have garbage collection?
- Why is C code faster than other languages?
- 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's the difference between a
floatand adouble, or between anintand along? - Can you use
+to concatenate two strings? - Are variables automatically initialized to zero when I declare them?
- What type should I use to hold numbers bigger than an
intcan hold? - What VS Code plugins are good for C development?
- What are some additional C resources?
- How do I get the debugger working?
- How do I print a pointer with
printf? - Does C have closures?
- 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******? - What's the
incompatible integer to pointer conversionerror? - 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? - Is the C stack like the stack data structure?
- Is the C heap like a binary heap data structure?
- What are
stdin,stdout, andstderr? - How do I know which header files to
#includefor any particular function? - When do I have to explicitly cast a type to another type?
- Is
realloc()the same as callingmalloc(), copying the data over, then callingfree()on the original pointer? - What happens if I
free()aNULLpointer? - What are bits, bytes, kilobytes, megabytes, and all that?
- In C, can we assume an
intis 32 bits? - What's the difference between
#includewith double quotes and#includewith angle brackets? - Should I declare a pointer to a thing, or just declare the thing?
- Is there a difference between
exit()andreturn? - Why does
strcmp()return0when strings match? Since0means "false" in C, that seems backwards. - What is "undefined behavior" in C?
- When you free a pointer, does it get set to
NULLautomatically? - How do I write preprocessor macros with
#define? - What is an
undefined symbollinker error? - How do I make my own header files and what do I put in them?
- How do I make my own Makefile?
- 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 does
main()return0? What does the return value mean? - Do we have to have a
main()? Can there be more than one? - Can
main()returnvoid? What aboutmain()with no parameters? - 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
structs? - If variables are stored in memory, where are pointers stored?
runtests.sh: $'\r': command not foundorSyntax error: word unexpected (expecting "do")runtests.sh: 56059 Segmentation fault: 11 $VALGRIND- Mac:
malformed objecterror when runningmake tests - What does the "implicit declaration of function" warning mean?
- What is a segmentation fault and how do I stop it?
- What's the
incompatible integer to pointer conversionerror? - What is an
undefined symbollinker error? - What is "undefined behavior" in C?
- Should I bother fixing compiler warnings?
- Can I accidentally destroy my computer running C code?
- Why do we subtract '0' from a char to convert it from ASCII to a numeric value?
- What's the difference between
puts(),fprintf(), andprintf()? - Why does
025 == 21? - What is the "true dev workflow" in C?
- Does C have garbage collection?
- Why is C code faster than other languages?
- Are variables automatically initialized to zero when I declare them?
- What VS Code plugins are good for C development?
- What are some additional C resources?
- How do I get the debugger working?
- Does C have closures?
- If I look at an uninitialized variable, will the garbage in it ever be leftover data from another process?
- What are
stdin,stdout, andstderr? - How do I know which header files to
#includefor any particular function? - What are bits, bytes, kilobytes, megabytes, and all that?
- What's the difference between
#includewith double quotes and#includewith angle brackets? - Why does
main()return0? What does the return value mean? - Is there a difference between
exit()andreturn? - What is "undefined behavior" in C?
- How do I write preprocessor macros with
#define? - How do I make my own header files and what do I put in them?
- How do I make my own Makefile?
- 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? - Do we have to have a
main()? Can there be more than one? - Can
main()returnvoid? What aboutmain()with no parameters? - Do we need a semicolon at the end of every line?
- Can you use
+to concatenate two strings? - For string literals like
"Hello", are those stored on the stack or heap? - Why does
strcmp()return0when strings match? Since0means "false" in C, that seems backwards.
- Is a
structcomparable to something in Python or JS? Is it like a class? - Can you have default parameters in the structs?
- Why do functions tend to return pointers to structs, and not just copies of the struct?
- Why does unsigned char type accept a number when it's clearly referring to a character?
- What's the difference between a
floatand adouble, or between anintand along? - What type should I use to hold numbers bigger than an
intcan hold? - When do I have to explicitly cast a type to another type?
- In C, can we assume an
intis 32 bits?
- 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?
- When do I need a pointer to a pointer?
- Do other languages use pointers?
- What's the difference between "
int *x" and "int* x"? - How do I print a pointer with
printf? - How many levels of indirection can you have with pointers?
int******? - What's the
incompatible integer to pointer conversionerror? - Should I declare a pointer to a thing, or just declare the thing?
- When you free a pointer, does it get set to
NULLautomatically? - Can a pointer pointer to more than one thing? What about to arrays and
structs? - If variables are stored in memory, where are pointers stored?
- What happens if my program exits but I forgot to
free()some memory I allocated? - Are there any other ways besides
malloc()to store things on the heap? - Is the C stack like the stack data structure?
- Is the C heap like a binary heap data structure?
- Is
realloc()the same as callingmalloc(), copying the data over, then callingfree()on the original pointer? - What happens if I
free()aNULLpointer? - When you free a pointer, does it get set to
NULLautomatically?
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:
-
Open the file
tests/runtests.shin VS Code in whatever subproject folder you're working in, e.g.fizzbuzz. Click on the lower right of the screen where it saysCRLF. ChooseLF. Save the file. Then the error should go away. -
You can do this from the command line with the
trcommand:
cd tests
cat runtests.sh | tr -d '\r' > runtests.tmp
mv runtests.tmp runtests.shThe 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
This means you got a segfault in your program. See What is a segmentation fault and how do I stop it?
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
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:
void foo(int a)
{
(void)a; // Do nothing, but at least the compiler will be quietNope! 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.
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:
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!
}No. The best you can do is have a helper function set the defaults.
void foo_default(struct foo *f)
{
f->a = 10; // Set defaults
f->b = 20;
f->c = 30;
}struct foo x;
foo_default(&x); // Set defaults
x.a = 99; // Override defaultWhen you declare a struct, you can also use an initializer to set the field
values:
struct foo x = { .a = 10, .b = 20, .c = 30 };Deep down, computers just deal in numbers (1s and 0s). 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 encoding, or its modern superset 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?
unsigned char c = 'A';
printf("%c\n", c); // Prints "A"
printf("%d\n", c); // Prints 65unsigned char c = 'A';
int x = c + 10;
printf("%d", x); // Prints 75, since 'A' == 65In 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 ints
as they are with chars, people just use ints.)
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.
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:
void foo(int *a)void foo(int a[])void foo(int a[1])void foo(int a[2000])void foo(int a[999999999])and it treats them all as if you'd used:
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.
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.
It's possible to do this:
struct foo my_func(void)
{
struct foo f;
f.x = 10;
return f; // Return a copy of f
}as opposed to:
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:
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.
The code typically looks like this:
char c = '2'; // ASCII '2'
int v = c - '0'; // Convert into numeric value 2
printf("%d\n", v); // prints decimal 2Remember 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 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.
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.
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.
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:
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 **!
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!
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:
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:
#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).
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:
int* x, y;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:
int y, *x; // Also equivalent to the previous two examplesIt's idiomatic to keep the asterisk tucked up next to the variable that's the pointer.
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:
#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():
#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:
#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.
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.
// 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.
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.
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:
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:
if (argc != 2) {
fprintf(stderr, "You must specify a command line argument!\n");
exit(1);
}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.
There is none.
Initially, it was in a Unix-like system probably using Makefiles 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 or CMake.
But dev for specific platforms like Windows probably happens in Visual
Studio instead of using
make and the rest of it.
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()andfree()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.
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.
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.
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.
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.
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.
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
staticstorage 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.
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. It does arbitrary precision arithmetic to as much precision as you have RAM.
"C/C++ IntelliSense, debugging, and code browsing" by Microsoft is a good one.
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.
A good, comprehensive FAQ is the comp.lang.c FAQ.
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.
The commonly-used debugger is called gdb (GNU Debugger).
Lambda's own Brian Ruff got it working on the Mac, and made a video covering it.
These instructions are reported good for WSL on Windows.
The CS Wiki page might help, but it's slightly outdated since VS Code is in heavy development.
This video is reported good, as well.
If you're not seeing program output in the Output tab, try adding this to your
launch.json:
"externalConsole": trueWe recommend Googling for vscode gdb setup macos, substituting whatever
platform you're on for macos and setting the search date range to be recent.
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.
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.
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.
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.
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?
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
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:
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:
char *s = "Hello!";
*s = 'B'; // segfault!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!)
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.
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.)
Check the man page for the function in question. It'll show it in the Synopsis section.
Example for printf():
SYNOPSIS
#include <stdio.h>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:
man 3 printfAnd section 2 for the mkdir() syscall:
man 2 mkdirBarely ever.
C is pretty good about conversions, and you should be able to build almost everything without casting.
What if you need constant types?
// 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?
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:
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");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.
Nothing. It's a no-op.
Basically, inside the library code for free(), there's something that looks
like this:
void free(void *ptr)
{
if (ptr == NULL) {
return;
}According to the C99 spec section 7.20.3.2p2:
The
freefunction causes the space pointed to byptrto be deallocated, that is, made available for further allocation. Ifptris a null pointer, no action occurs. Otherwise, if the argument does not match a pointer earlier returned by thecalloc,malloc, orreallocfunction, or if the space has been deallocated by a call tofreeorrealloc, the behavior is undefined.
A bit 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 210.)
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, 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, 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.
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 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.
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:
#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.
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:
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:
int a = 12; // here's an existing thingSo the answer to the first part of the question is yes. And do we want a pointer to it? Sure, why not?
int *p = &a; // and there's a pointer to itIf 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.
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:
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.
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, and if you look in the C99 Language Specification, Annex J.2 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
NULLpointer. - 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.
No.
Furthermore, free() can't do that even if it wanted to.
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.
int *p = malloc(100 * sizeof(int));
free(p);
p = NULL; // NOW p is NULL(Note that it's undefined behavior to dereference a pointer after
you've free()d it. But it's still OK to change that pointer's value.)
You've probably already seen simple cases of #define like this:
#define antelopes 10
int main(void)
{
printf("Antelopes: %d\n", antelopes); // prints 10What's actually happening here is the preprocessor runs through the code before the compiler ever sees it. It manipulates the above code to read:
int main(void)
{
printf("Antelopes: %d\n", 10); // prints 10and 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:
#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:
int main(void)
{
printf("9 squared is %d\n", 9 * 9);It just substitutes the parameters in as-is.
Another example:
#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:
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:
3 + 2 * 3 + 2when what we really wanted was:
(3 + 2) * (3 + 2)For this reason, you should always put extra parentheses around the macro body, and around every parameter in the body:
#define square(x) ((x) * (x))And now the expansion of our line will be:
((3 + 2) * (3 + 2))That will work in all expected cases.
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.
If you have a .c file and you want to be able to use functions, #defines, or
globals from that file in another file, you'll need to make a header file
(.h file) to hold the function prototypes, #defines, and references to any
globals.
Example:
// 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:
// square.h
#ifndef SQUARE_H // Prevent multiple #includes
#define SQUARE_H
// Function prototypes
extern long square(long x);
#endifThe #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.
#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
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.
myexecutable: mysource1.c mysource2.c
gcc -Wall -Wextra -o myexecutable mysource1.c mysource2.cThe 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:
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:
SRCS=mysource1.c mysource2.c
TARGET=myexecutable
$(TARGET): $(SRCS)
gcc -Wall -Wextra -o $@ $^You can have multiple recipes per Makefile:
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:
$ make target1
gcc -Wall -Wextra -o target1 source1.c
$ make target2
gcc -Wall -Wextra -o target2 source2.cIf 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.
# 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: allThat .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.
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 specifiedFILE*instead of tostdout.sprintf(): "string printf"; print to a string instead of tostdout.snprintf(): "string printf, with a limited count"; print to a string instead of tostdout, and also specify the maximum number of characters thatsnprintf()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 usesprintf(), preferringsnprintf()instead.vprintf(): "variadic printf"; anything that starts with avinprintfland has to do with variadic functions, i.e. functions with argument lists of variable lengths. These are out of scope at Lambda.- etc.
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.
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 echoing
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:
$ 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 $?
0At the OS level, fork() is used to create a new process, and wait() is used
to get the exit status back from that process.
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 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 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.
No. The function signature for main() must be one of the following:
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:
int main(void) // OK
int main() // ObsoleteYes.
Or, more technically, at the end of every statement or expression.
C won't fill them in automatically like JavaScript will.
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 structs, it points to the first byte of the
0th struct in that array.
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.
1-projects/Intro-to-C-master/fizzbuzz/
Table of Contents generated with DocToc
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
To reiterate, you might declare a function in C like this:
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:
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.
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.
1-projects/Intro-to-C-master/hangman/
Table of Contents generated with DocToc
Write a program that allows you play a game of Hangman. All of your code can be written in the hangman.c file.
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.
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
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.
1-projects/Intro-to-C-master/malloc/
Table of Contents generated with DocToc
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:
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:
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 chars each fit within a single byte, so 51 bytes will hold 51 chars, 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 mallocd 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.
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:
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:
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.
1-projects/Intro-to-C-master/pointers/
Table of Contents generated with DocToc
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:
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.
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:
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:
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.
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.
/* 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.
When we index into arrays in JavaScript, we can do things like:
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:
char *str = "Some string";We can loop through the characters in this string by doing this:
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.
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;
}
}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.
1-projects/Intro-to-C-master/quicksort/
Table of Contents generated with DocToc
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:
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 pivotKeep 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.
1-projects/Intro-to-C-master/
Table of Contents generated with DocToc
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!
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.
For things that go wrong, check out the troubleshooting doc.
1-projects/Intro-to-C-master/strings/
Table of Contents generated with DocToc
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:
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:
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.
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.
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:
char[] = "Hello world!";Under the hood, this declaration becomes
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.
1-projects/Intro-to-C-master/structs/
Table of Contents generated with DocToc
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.
Let's look at a simple struct definition:
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:
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:
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:
a_cat->breed == (*a_cat).breedAllocating 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 ints 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:
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.
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 freeing it!
Let's codify this into a simple heuristic that isn't too hard to memorize:
For every call to
mallocthere should be an accompanying call tofree.
A couple of common errors that arise when it comes to freeing memory are:
- Forgetting to call
freeon somemalloc'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 tofreeyour memory, they'll start to pile up and waste precious memory resources that could be used by other programs that actually need that memory. - Calling
freeon a pointer to memory that has already beenfree'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.
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);
}
}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:
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!
1-projects/Intro-to-C-master/
Table of Contents generated with DocToc
runtests.sh: 4: Syntax error: word unexpected (expecting "do")- Mac:
malformed objecterror when runningmake tests
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:
-
Open the file
tests/runtests.shin VS Code in whatever subproject folder you're working in, e.g.fizzbuzz. Click on the lower right of the screen where it saysCRLF. ChooseLF. Save the file. Then the error should go away. -
You can do this from the command line with the
trcommand:
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
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
1-projects/JavaScript-III-master/
Table of Contents generated with DocToc
This challenge focuses on using the this keyword as well as getting comfortable with prototypes by building out a fantasy themed video game.
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 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.
- 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.
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 file to traverse through a few this problems.
The prototype challenge will focus on building prototypes for a fantasy themed game that includes mages, swordsmen, and archers. Follow the prototypes.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.
1-projects/JS-Exercise-Classes/
Table of Contents generated with DocToc
This challenge focuses on using the new for ES6 class syntax.
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.
Using VSCode and the Command Line:
- Fork repo and add TL as collaborator on Github.
- Clone your fork (not Lambda's repo by mistake!).
cdinto your newly cloned repository.- Create a new branch by typing
git checkout -b <firstName-lastName>. - Install dependencies by typing
npm install. - Run tests by typing
npm run test:watch. - Work on your branch, push commits and create PR as usual.
1-projects/LS-Data-Structures-I-Solution-master/
Table of Contents generated with DocToc
Topics:
- Big-O Notation (Complexity analysis)
- Stacks
- Queues
- Linked Lists
- Hash Tables
- Should have the methods:
add,remove, and a getter for the propertysize addshould accept a value and place it on top of the stack.removeshould remove and return the top value off of the stack.sizeshould return how many items are on the stack.
- Should have the methods:
enqueue,dequeue, and a getter for the propertysize enqueueshould add an item to the back of the queue.dequeueshould remove an item from the front of the queue.sizeshould return the number of items in the queue.
- Should have the methods:
addToTail,removeHead, andcontains. addToTailreplaces the tail with a new value that is passed in.removeHeadremoves and returns the head node.containsshould searth through the linked list and return true if a matching value is found.- The
headproperty is a reference to the first node and thetailproperty 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.
- Should have the methods:
insert,remove, andretrieve. insertshould take a key value pair and add the value to the hash table.retrieveshould return the value associated with a key.removeshould 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.
- Uncomment the final test in
hash-table.test.jsand 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.
1-projects/LS-Data-Structures-II-Solution-master/
Table of Contents generated with DocToc
Topics:
- Tree
- Graph
- Binary Search Tree
- Should have the methods:
addChild, andcontains - Each node on the tree should have a
valueproperty and achildrenarray. addChild(value)should accept a value and add it to that node'schildrenarray.contains(value)should returntrueif the tree or its children the given value.- When you add nodes to the
childrenarray usenew Tree(value)to create the node. - You can instantiate the
Treeclass inside of itself.
- Should have the methods:
insert,contains,depthFirstForEach, andbreadthFirstForEach. insert(value)inserts the new value at the correct location in the tree.contains(value)searches the tree and returnstrueif 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).
- Should have methods named
addNode,contains,removeNode,addEdge,getEdge, andremoveEdge addNode(newNode, toNode)should add a new item to the graph. IftoNodeis given then the new node should share an edge with an existing nodetoNode.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 returntrueif an edge exists between the two specified graph nodes.removeEdge(fromNode, toNode)should remove the edge between the two specified nodes.
- Add a method to the
Graphclass 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 here. Then implement one!
- Read up on red-black trees here. Then implement one!
1-projects/master/
Table of Contents generated with DocToc
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:
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!
- Add a file to the project called
- Create a Pull-Request to submit your work
- Use your own student fork as the base (compare across forks, base-fork -> main).
- fork this codepen https://codepen.io/BritHemming/pen/eYYEoPa?editors=1100
- 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
- After you are finished please copy the review questions into your .txt file and answer them
- don't forget to add, commit and push your changes.
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 conflictis 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 understand what a
-
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.
1-projects/Mongo-Mini-II-Solution-master/
Table of Contents generated with DocToc
cdinto your project directory.npm installto receive your dependencies.- fire up your
mongodserver from your root dir or create adatadir in this project to store your documents from mongo there.mongod --dbpath data.
- When you open
models.jsyou'll see we've already included your Schema. You're welcome. - You'll also notice that this sprint comes with a
people.jsonfile, and apopulateDbScript.js. this script will grab thosepeopleand add them into your db as long as you have your mongo server up and running. - RUN:
node populateDbScript.jsget receive all your data.
- write a
GETrequest to/usersthat simply returns all the people. - write a
GETrequest to/users/:directionthat takes the given string and returns back a list of sorted data alphebetically.- hint direction can be
ascordescso in your.sort()method you'll have to conditionally check, and we are going to be sorting by userfirstName
- hint direction can be
- write a
GETrequest/user-get-friends/:idthat returns a single users's friends.
- lastly write a
PUTthat updates a usersfirstNamelastName
1-projects/nested-data-exercises-master/
Table of Contents generated with DocToc
This challenge will test your ability to work with nested Objects and Arrays.
Uses real-world 'inspired' data.
If you are experienced on this topic, expand the "💡 Challenge Yourself!" section (following the instructions.)
- Instructions
- Get Started
- Preview Test Data
- Stuck? Check Hints
Task: Complete the 10+ functions in index.js and pass all tests specified in test/index.test.js ✅
The difficulty increases as you progress.
Before you begin coding, review test data below
getName(character)->Luke SkywalkergetFilmCount(character)-> 5getFirstStarshipName(character)->X-winggetSummary(character)->Luke Skywalker, 172cm, 77kg. Featured in 5 films.getVehiclesCostInCreditsSumTotal(character)-> 8000getStarshipPassengerAndCrewSumTotal(character)-> 27getNthFilm(character, filmNumber)filmNumber=1 ->A New HopegetCargoCapacityTotal(character)-> 80124getFastestStarshipName(character)->X-winggetLargestCargoStarshipModelName(character)->Lambda-class T-4a shuttlegetSlowestVehicleOrStarshipName(character)->Imperial Speeder Bike
💡 Challenge Yourself! (expand for stretch tips)
- 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.
3 options are included below.
The CodeSandbox option is fast & highly recommended.
1. Fastest Option
2. Local Setup Instructions: From Command Line
- Fork & clone to your local computer
cdinto your newly cloned repository- Install using
npm - Run test command
git clone <insert your git clone url here>
cd <repo folder name>
npm install
npm run test:watch
#####
### Or without fs watching:
# npm testNOTE: In local development, use the file watcher command: npm run test:watch.
3. Local Setup Instructions: Run Tests in Browser
- Fork & clone to your local computer
cdinto your newly cloned repository- Install and Start using
npm
git clone <insert your git clone url here>
cd <repo folder name>
npm install
npm startExample data your code will be tested against.
// 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 Co