Daniel: Behaviour, Strategy and Implementation. Weeks 13-16

[denrique-alvarez]

🥚 Analyzing Functions:

• You can analyze a function written at or near your level. This includes:
  • [x] Behavior: How would you document the function, what test cases does it pass, and how might you use it in a program
  • [x] Strategy: Roughly, how could you translate this solution to pseudo-code.
• [x] Implementation: What language features were used, and what are some alternate language features that could be used 🥚 Testing Existing Functions:
• [x] 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. 🥚 Function Design:
• [x] You can explain the function-design process and can successfully apply it to write 2+ solutions matching the behaviour 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. 🥚 Generating Documentation:
• [x] You can write a correct JSDoc for your functions and use a provided script to generate markdown documentation in a separate file. 🐣 Declarative Programming:
• [x] You can explain how Declarative Programming is different from Imperative programming
• [x] Tell which paradigm is used in a program.
• [x] Use built-in JS methods to write Declarative solutions to simple coding challenges. 🐣 Array Strategies:
• [x] 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:
• [x] 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:
• [x] You can inspect a JS value in the browser's debugger/console
• [ ] Explain how to find which methods are available for that value. 🐣 Nested Data:
  • [x] 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:
• [x] You can write basic unit tests for a problem you understand without having a solution to validate your tests.
• [x] Use your tests as a guide to develop a solution. You do not need to consider edge cases or invalid arguments. 🐣 Fuzz Testing:
• [x] 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:
  • [x] function does not modify it's reference-type arguments
  • [x] The function returns a new array/object. 🐣 ECMAScript Modules:
• [x] 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
• [ ] 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
• [ ] 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.

[denrique-alvarez]

Week 13

Check-In

I Need Help With:

Still struggling with higher-order functions and other complex stuff. It's getting harder to keep track of what's going on.

What went well?

Getting better at reading others' code thanks to the write-up exercises. Went over a couple things more than once and that helped a lot.

What went less well?

Getting all the new info in my head without pushing the old one out of it.

Lessons Learned

Functions, what can be done with arrays, a good introduction to the work around the code: understanding, monitoring, refactoring.

Sunday Prep Work

Following as much as possible of the material for the week. It's quite a lot to digest.

[gelilaa]

Let us know if it is getting too much and if we can help!

[denrique-alvarez]

Sorry for the late reply @gelilaa, I have been buried under a bunch of information lately but it's getting better now.

[denrique-alvarez]

Week 14

Check-In

I Need Help With:

Not much. I just feel like I need to take some time to let everything fall in place in my head.

What went well?

Covering the material. Finding my own pace.

What went less well?

Certain concepts are still hard to grasp. However, I think it's a matter of time.

Lessons Learned

Getting better at writing test suites and looking at functions from different angles.

Sunday Prep Work

Keep working on the material. I will try to complete all the exercises recommended and go over a couple of them again to improve my understanding.

[colevandersWands]

Getting better at writing test suites and looking at functions from different angles.

🚀

Certain concepts are still hard to grasp. However, I think it's a matter of time.

which concepts are taking the most time for you?

[denrique-alvarez]

Definitely prototype delegation. Also higher-order functions but that's much better now.

[colevandersWands]

Definitely prototype delegation

this is interesting to help understand where things like array methods come from, but you don't need to ever use it explicitly. as long as you understand array methods come from the array prototype, can show that in the debugger, and are no longer confused why everything in MDN says Array.prototype.method then you're good to go.

you only need to know it in depth if you start Object Oriented Programmging

[denrique-alvarez]

Week 15

Check-In

I Need Help With:

My VSCode has been giving errors when I try to debug code locally.

What went well?

I have been able to catch up with a lot of things from the past and the current module.

What went less well?

It still takes me a lot of time to finish one full exercise with all the files, so not many chances to do as many as I would like to.

Lessons Learned

Import, export, ECMAScript, better test cases, declarative vs. imperative programming, improving array methods and callback functions

Sunday Prep Work

Try to finish at least one more problem with all the files to send to the Code Review repo.

[colevandersWands]

It still takes me a lot of time to finish one full exercise with all the files, so not many chances to do as many as I would like to.

these exercises aren't fast, there's a lot of detail and a lot of parts. working through one from start to finish is already great practice.

you can always come back and do more when you have time later. and you'll be practicing the whole process in group projects next module