This helps when I am stuck on some part. Can park that and move to the next important part?

Any well used protocols will do:

1. HTTP
2. TCP
3. FIX - https://en.wikipedia.org/wiki/Financial_Information_eXchange
4. OUCH - https://www.nasdaqtrader.com/Trader.aspx?id=OUCH
5. A load balancer

This will help in proving that I know the protocol. More importantly, improve my programming and system level understanding

https://gist.github.com/sanjarcode/0ecc4fc4cb281e1b061d0edf27c89b4c

• don't try to write exact phrases
• don't write down every word

https://youtu.be/ATmJb3bH2E0

I have first hand experience how "detailed" notes can become very hard to read (harder than the material they're trying to convey).

https://en.wikipedia.org/wiki/Bloom's_taxonomy

One important skill to have is to dive in a field, know which areas to (do and not do):

1. Ignore
2. What to build upon (think inheritance OOP like)

this skill + an agenda, and there's absolutely nothing to stop me.

The first helps set priorities, the second helps sets things that can be acted upon. So, decisions and actions are narrowed.

I think this should work. Just consider any topic you know. There are these two kinds of things (that fool us in the beginning, and especially beginners).

Examples:

1. (React app development) for example - how the browser works is practically not important (ignorable). We shouldn't touch eventListeners and not do DOM manipulations explicitly - what not to build upon.
2. Calculus math (12th, engg bachelor) - you don't practically need to think about limits, and finding derivatives using the first principle. Nor does one need to do integrations by summation limits.

Every topic + agenda pair has these ignorables and set-in-stone things.

If you change the agenda, the two params also change.

Any variables I'm missing?

nextL
Topic + agenda sets ignorables, base-items.

Try to create some recipie to determine these. Check if works.

By non-trivial, I mean

1. greedy algorithms
2. Cryptographic systems

The best way is to consider them as axioms, and try to apply them (of course this is a guess). Maybe I can dig deep once I see a lot of properties that becomes second nature.

• Curated list of best MOOCs
• All/most MOOC free list

https://www.youtube.com/@linkingyourthinking

It's easy to do a thing (in a course) since you're sure the concepts are something from the course - false positive and for making new stuff.

Add a section to each of the mental models, where comparison is done with other models, and comparison from other models also flow in the current model.

Learning is useless if this is not done, if the goal is to innovate, make new stuff.

This is generally not an issue if one has decided specifically the "career" they will work, since models and the "relations" have been established incrementally/historically.

why

One cannot learn everything about a app/system, but whatever you do learn, store it such that it's reusable with the least amount of revision or deliberation. "Look up and paste" should be enough. Or look up and "hire" who could do it.

The buckets

• Theory - w2h, usp, relevance examples, main principles. Theoretical gotchas. Advantages, disadvantages.
• Product - app flow, LLD, HLD patterns, UI, UX. Example: very malleable callback structures in React app
• Practical - requirements (packages), code to be copied later, gotchas (including minor)

Note:

1. When writing a note page - first write it mixes(it's fine). Second step, try to separate into 2 buckets (notes + code stuff). Finally, in step 3, try to separate into the said 2.
2. theory <-> product and product <-> practical may get blurry.
3. Why do this - distilling info like this makes delegation easy. Example: sessions (in auth) are the only way to minimize damage due to cookie stealing. Be it JWT or whatever, you need a ‘nullable’ field (i.e. DB) if you want to forcibly log out the attacker.
   1. It is important to distill this insight.
   2. Such theory is the generalizable and reusable part of engg, and can be used anywhere else.

Does this work for hardware

Maybe It does

theory - w2h
product - common gotchas
practical - parts, integration processes.

• https://www.coursera.org/learn/learning-how-to-learn-youth
• https://www.coursera.org/learn/learning-how-to-learn

The syllabus is different, apparently, so do both

sanjar-notes/.github#1

https://github.com/learn-anything
Just explore this.