Darin-Hamouda
commented
2 years ago Chapter 1
Check-In
I Need Help With:
everything is good.
What went well?
Studying functions
What went less well?
I had no time this week to cover a lot.
Lessons Learned
Group studying helps.
Learning Objectives
[x] 🥚 Analyzing Functions: You can analyze a function written at or near your level. This includes:
[x] 🥚 Testing Existing Functions: You can write unit tests for a working function using the describe/it/expect().toEqual() syntax. This includes grouping test cases into logical test suites.
[x] 🥚 Function Design: You can explain the function-design process and can successfully apply it to write 2+ solutions matching the behavior of a given function (assuming the behavior is at your level). The solutions do not need to implement different strategies, consider edge cases, or check for invalid arguments.
[x] 🥚 Generating Documentation: You can write a correct JSDoc for your functions and use a provided script to generate markdown documentation in a separate file.
[ ] 🐣 Declarative Programming: You can explain how Declarative Programming is different from Imperative programming, and can tell which paradigm is used in a program. You can also use built-in JS methods to write Declarative solutions to simple coding challenges.
[ ] 🐣 Array Strategies: You can determine which of the primary array strategies (map, filter, reduce, every, some) are helpful for a specific problem at your level.
[ ] 🐣 Higher-Order Functions in Array Methods: You can explain how a higher order function works, and write a callback for use in the primary array methods (for a problem at your level).
[ ] 🐣 Prototype Delegation: You can inspect a JS value in the browser's debugger/console and explain how to find which methods are available for that value.
[ ] 🐣 Nested Data: Given a nested data structure containing arrays, objects and primitive values, you can 1) access a given value 2) update a given entry 3) filter the data
[ ] 🐣 Test-Driven Development: You can write basic unit tests for a problem you understand without having a solution to validate your tests. You can use your tests as a guide to develop a solution. You do not need to consider edge cases or invalid arguments.
[ ] 🐣 Fuzz Testing: You can interpret random test cases for a challenge to guide your development of a solution.
[ ] 🐣 Testing Side-Effects: You can write a suite of unit tests to ensure that; 1) a function does not modify it's reference-type arguments, 2) the function returns a new array/object.
[ ] 🐣 ECMAScript Modules: You can use export const functionName = () => {}; and import { functionName } from './file-name.js' syntax to separate unit tests from the function definition.
[ ] 🐣 Continuous Integration: You can check CI scripts locally to ensure your code will pass CI checks when it is pushed, and can read CI results when conducting a code review.
[ ] 🐣 Code Review: You can use a provided checklist and passing/failing CI checks to review a classmate's function (given the solution is at your level).
[ ] 🐥 Code Coverage: You can explain what code coverage is, why it's important, and can write unit tests for a code challenge with 100% coverage.
[ ] 🐥 Testing Edge Cases: You can identify and write unit tests for tricky edge cases.
[ ] 🐔 Writing Guards: You can write guards for your function parameters that enforce the function's documented parameter types.
[ ] 🐔 Testing Guards: You can use expect(() => ).toThrow() to unit-test your guards' error type and message.