JS Fatigue vs. Analysis Paralysis
JS fatigue is often linked with analysis paralysis (also called choice paralysis). JS analysis paralysis can occur because of the huge range of options when selecting a framework, tooling, testing suites, and more for a new application. Choosing the right framework or library can be challenging and occasionally even paralyzing, but having a wealth of tools at our disposal allows us to be more selective about what's best for the job at hand. In some cases, options help us to avoid fatigue by supplying an ideal solution for a specific project.
What it Means to Have JS Fatigue
We get JS fatigue when the requirements (either actual or self-imposed) for learning something are so daunting that a developer becomes exhausted and overwhelmed.
JS fatigue can refer to:
- the fear that we'll fall behind or become obsolete if we don't know and use the newest, hottest tools;
- the sense that we never become experts in anything because everything changes too quickly and the tools we're trying to learn are already being replaced;
- picking up a new framework and then becoming overwhelmed thinking we need to master everything in the toolchain in order to use it;
- the fear that we'll pick a tool that will get displaced, resulting in a lack of support and obsolete resources;
- frustration with a lack of user empathy when consulting documentation or resources while trying to learn a new framework or toolchain.
In a nutshell, JS fatigue has become a phenomenon because the JS landscape is ever-changing. Various build tools, transpilers, and syntax additions are considered par for the course. There are even dozens of entire languages that compile to JS.
How to Manage JS Fatigue
At this time, JS proliferation is not showing signs of slowing. JS fatigue doesn't have a magic bullet cure, but there are things we can do to manage and also mitigate it. The following tips are useful for overwhelmed new developers as well as experienced, fatigued JS engineers.
Pick Your Battles
The first thing to focus on is picking your battles. We get easily overwhelmed trying to follow every hot new thing that emerges. It's good to be aware of the sea of new technologies, but not to drown in it. If something starts to come up a lot, read a little about it. You'll want to know just enough to answer the following:
- What is its primary purpose?
- Is it popular enough to have a stable, growing community and easily accessible support? (Who is behind it? Who is using it?)
- Does it solve a problem I frequently run into with my current tools?
If #1 isn't practical for your use case and the answers to #2 and #3 are not both yes, don't expend precious time and effort learning this if you're already fatigued. It can be best to wait and see, or to take a pass on tools that don't serve your goals. Make peace with your focus and remember that no JS developer is an expert in every new tool that lands.
"Pick your battles: It can be best to wait and see, or to take a pass on tools that don't serve your goals."
In fact, it can make us better developers to know when to be okay with not learning some new tool. You may have heard the expression "Jack of all trades, master of none", which implies superficial knowledge in many things but expertise in none of them. Remember that you're not obligated to learn everything and you can excel at your craft without jumping on every bandwagon that rolls up to the curb.
On the other hand, if a tool has gained critical mass and will help you solve a problem you're having, it's worth further exploration. Don't feel like you have to commit to learning it right away, but it might help to find out a little more and keep an eye on it.
"Pick your battles: if a tool has gained critical mass and helps you solve a problem, it's worth exploration."
Make Something Interesting / Useful
For many developers, there are two primary ways we learn something new in a short amount of time:
- We need to learn it in order to complete a project with predefined requirements and a deadline, or:
- We build something on our own that we're interested in.
Learning anything can be arduous and tedious if we don't have a clear view of the end result or real-world practicality. On the same token, learning is much more gratifying when we're building something interesting or useful.
One good way to learn new tools and frameworks is to make the same thing (something useful that you like) using different tools. This shouldn't be the ubiquitious and tiresome TODO app. It should be something that covers many common features of modern applications, such as:
- Global header and footer
- CSS framework integration
- Responsive UI and custom styles
- Global application data
- External API
- Services and utilities
This has several advantages for learning.
- Familiarity: knowing what you're trying to achieve and not making it up as you go along makes development more straightfoward.
- Comparison: rebuilding something reveals similarities and differences as well as highlights strengths and weaknesses between frameworks.
- Iteration: you may find that each time you go through this exercise, you see things you can refine and improve.
It's important to maintain a high level of interest and/or usefulness with your learning app. Creating a robust starter project can help you quickly learn the ins and outs of setup and common features while providing a practical beginning point for future apps you build.
Be Aware of Common Concepts
Even as JS grows and changes, there are always concepts shared amongst many new frameworks and libraries. It's useful to keep an eye out for these tools and topics. For example, ES6 and TypeScript are becoming more heavily used, as well as Webpack, functional reactive programming, and web components. Knowing about common dependencies makes different frameworks feel more similar.
When you take the plunge with a new framework and toolchain, you'll learn some of the common topics. You'll be pleased to find that other modern frameworks leverage many of the same tools and concepts and are now much easier to pick up.
Many developers are fatigued by the fact that new frameworks have so many complex dependencies that it takes weeks to set up a new app. Don't be afraid to use tools if they help. If a CLI is available or the community offers starter projects, take advantage of them. Getting off the ground quickly allows you to focus on learning the core features and avoid getting discouraged by difficult setup.
It's ideal to know how and why something works so it's less magical, but that doesn't mean you need to frontload that knowledge before getting started. Don't worry if you find yourself picking it up along the way. When you hit a roadblock, work through it. Remember to take breaks if you get frustrated. "Learn as you go" is a legitimate, effective method for absorbing lots of new information over time. Once you've done the basics, the how and why reveal themselves, either in "Ah-ha!" moments or gradually with repeated use.
Aside: Use Auth0 For Authentication in JS Apps
Taking advantage of knowledge, tools, and solutions from others is extremely valuable when combating JS fatigue. Authentication can be one of the most complex, time-consuming features to build for any application. Developers who are already learning a new toolchain, library, or framework can become even more overwhelmed building secure, complicated features like authentication.
If you have a JS app that needs authentication, Auth0 can bear the load for any framework. Auth0's Single Page Application QuickStart guides and Auth0 SDK for Web provide indepth documentation for robust identity and user management in JS apps. Auth0 makes authentication straightforward, greatly reducing fatigue and cognitive burden for busy developers.
Don't be hesitant to utilize the proper tools and services that will help you do your job and do it well. We're much less fatigued by new things when we have help completing difficult tasks. If authentication is one of your primary needs, you can learn more in the Auth0 docs or sign up for a free account here.
We'll finish with an analogy. If JS is the world around you, there are a few ways to view and take it in.
If you look at the JS world through a telescope, you can see one thing very clearly. However, you're essentially blind to everything else around you. It's important to be comfortable with your focus, but not to the point that you shut out awareness of any other possibilities.
If you view the world as a panorama through a wide-angle lens, you get a vast, comprehensive picture but it's hard to know where to look. Everything in the scene competes for your attention and you can get easily distracted when trying to focus if something else catches your eye. This can be exhausting.
Now consider a normal pair of glasses. You can see everything more clearly, but still focus your attention on one (or a few) things without losing sight of what's in your periphery.