Here are my brief incomplete thoughts on becoming a 10x developer writing JavaScript. In summary, become comfortable with how the technology actually works. H

Here are my brief incomplete thoughts on becoming a 10x developer writing JavaScript. In summary, become comfortable with how the technology actually works. Hoping something else will solve your problems for you makes you less productive (I've heard all the excuses). * Understand that super productive people likely do things that aren't the popular way of doing things. If the super productive way of doing things were the most popular way of doing things then everybody would be more productive. Be critical about why a productive person intentionally does something in defiance of popularity. * Become comfortable reading code. Frameworks, unit tests, processes, and tools are not there to make sense of the code for you. You cannot be a 10x developer if you are intimidated by reading code or expect something else to do it for you. * Learn to organize to the scope model before adopting any other convention. This will reduce the amount of code in a given application. In many cases it will also greatly increase code performance. In JavaScript OOP concepts and inheritance are conventions that can be avoided, but not scope. Scope is always present and not hidden behind a code convention that can be avoided. Don't be afraid to nest functions and try to declare references as locally as possible and share where necessary as this greatly increases maintenance speed. * Write original code. In JavaScript invented here syndrome is exceedingly common. In many cases it is faster to write original code for a given problem and in many cases that original code will execute orders of magnitude faster than misunderstood dependencies downloaded from NPM. If writing code is intimidating you will always be less productive. If you want to write clean maintainable code solve a given problem as directly as possible and then later, after clearing your mind, refactor the code to achieve simplicity. Simplicity almost always takes extra effort, but reduces maintenance time down the road. * Master the DOM. The DOM is still the ultimate backbone that glues all things together in the browser. The DOM is not some strange React fiction. It is a language agnostic standard. Learn the standard DOM methods and node relationships. The DOM methods execute thousands of times faster than query selectors and faster to maintain for code where sections of the page are in flux. https://dom.spec.whatwg.org/ https://dom.spec.whatwg.org/ * Become comfortable with callbacks. Node is callback driven. If you cannot figure out callbacks or passing by reference your code will be a struggle to write and look like spaghetti. * Learn to write your own tools. It is nice to increase your own performance because you have learned to automate part of your daily tasks or parts of your job away. This isn't something that comes naturally and it does take practice to become efficient write quick tools on the fly that doesn't burn up all your time. * Take ownership of test automation. Some developers want to test everything because people have told them testing is somehow important but have never learned what is important about testing. Tests are a form of debt that. Test what your application claims to do opposed to what it literally says. Test features, options, and output. Test that collisions of features do not produce unexpected results. If you are confused about what to test ask for guidance from your QA team. Ensure your tests automation executes as quickly as possible so that it isn't a swamp holding back the productivity of your team. Slow test automation is worse than unnecessary unit tests. * Most importantly accept that you are fallible and that you are probably wrong more than you are right. Learn to appreciate negative feedback and criticism as gifts of guidance. If you drink your own Cool-Aid believe you are too good for improvement you aren't improving. The soft-skills are perhaps the most important part of becoming more productive.