You’ve learned React, mastered npm install, and can find your way around webpack.config.js. You can do just about anything as long as there’s a module for it, and there seems to be a module for everything. But what happens when you can’t find a module? Where do you go when you can’t find the answer on Stack Overflow? You feel like a solid developer, but there’s a gnawing sensation in the pit of your stomach. You don’t like to think about it, but it’s there. The truth… A lot of this is wizardry to you. If there wasn’t an example out there, in some cases you’d have no idea how to get any of this working.
Here’s what you need to do:
- Understand how different primitive types are stored in memory, down to the addresses, space allocated, and binary representation (if you haven’t run into the word mantissa you’re not far enough).
- Understand the difference between value types and reference types, and assigning values vs assigning pointers.
- Understand implicit typing, explicit typing, nominal typing, structural typing, and duck typing.
- Understand function scope, block scope, and lexical scope.
- Understand the difference between an expression and a statement, and what it means to evaluate an expression.
- Understand what happens (or doesn’t) in memory/on the call stack when an expression is evaluated, argument passed, result returned, etc. vs when a value is assigned or retrieved from a variable.
- Understand IIFE’s, modules, and namespaces. And why ES6 modules and block scope don’t fully replace IIFE’s.
- (browser) understand
- Understand which operations are more expensive and why (expensive meaning cost more processing time or memory). Are number of iterations really the most impactful on performance (typically)? What does Big O notation really tell us? Use jsperf and
performance.nowto run some tests and find out.
- Understand how bitwise operators, typed arrays, and array buffers work. Use understanding RGBA as a way to understand how to manipulate binary data.
- (browser) understanding how the in-memory DOM and layout trees are built and modified, when/how reflows/layouts, composites and repaints are triggered.
instanceof, and instances.
- Understand prototypical inheritance and the prototype chain. And how even with
- Understand the differences between
- Understand factories and classes, and how these approaches differ.
- Understand the difference between member properties and properties on the prototype.
- Understand pure functions, side effects, and state mutation.
- Understand how almost every
whileloop can be replaced with a
filter, and why.
- Understand what lambdas are (LINQ in c# as an example), and how
filter+ arrow functions change the way you think about your code.
- Understand how closures work, and how they look on the call stack.
- Understand how high order functions work, and when to use them.
- Understand recursion and how to use them to build abstract data structures.
- Understand that algorithms to solve many common problems exist, and be familiar enough with them to find the one you need on Google because nobody remembers all of them. Or even most of them.
- Understand the difference between the is a and has a relationship when it comes to inheritance, polymorphism, and code reuse.
- Understand partial functions, currying, compose, and pipe. And understand why unary functions are so useful.
There you have it. The key to demystification. Did I miss something? If so, feel free to send me a tweet: @stephenthecurt
Stuff I forgot that rock star developers pointed out:
34. Erika Ritter reminded me it’s important to understand delegates. Not only what delegation is in the context of the prototype, but delegation as it pertains to
this and understanding how
apply work. Bonus: (browser) Understand what event delegation is, and how all three uses of the term delegate are saying the same thing.