8 Habits For Beginning and Mid Level JavaScript Developers That Sabotage Your Future
Tags: javascript, webdev, node, productivity
Published: 2019-07-17 12:49:36


Find me on [medium](https://medium.com/@jsmanifest)

It is truly an amazing time to be a JavaScript developer as they increasingly become higher in demand in the job market. The quick and consistent releases in frameworks, libraries, etc. is what makes it a blessing to be alive in this era - especially when we can be apart of all of that with everything being open sourced. So much to the point where we begin to put so much of our time and energy into JavaScript related tasks in our everyday lives.

But there's a good chance that you might be devoting so much of your time and energy into your daily JavaScript tasks that you might end up causing a catastrophe for yourself and your future without even knowing it. I suffered from some of the points listed in this article in the past, so my goal is to help _you_ from making these mistakes so that you don't end up in misery.

Here are 8 habits for JavaScript developers that sabotage your future:

## 1. Using jQuery

jQuery played a huge part in the growth of the JavaScript ecosystem.

For one, JavaScript was mainly just used to run slideshows and cute little widgets like date pickers and image galleries that appeared in pages. There were issues with browsers providing different behaviors and jQuery helped standardize things with its implementation of abstraction layers, and taking care of all of the workarounds with common issues in things like DOM manipulation. It helped simplify AJAX and the issues with cross-browser differences.

The thing is however, that today those issues aren't as relevant as before anymore. Some of jQuery's best features were standardized to the browser like [fetch](https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API) and the [selectors api](https://flaviocopes.com/selectors-api/).

Modern libraries like React solve problems that jQuery aims to solve, in addition to solving problems that jQuery currently has like state management.

In jQuery, you end up doing weird things like using DOM elements to be _current states_ or _data_ and writing ridiculously complex code to figure out what the previous, current, and next state of the DOM will be in addition to providing ways to appropriately transition to the upcoming states!

Read more on some of the modern alternatives people today are using and the benefits they bring to your web applications: [React](https://reactjs.org/), [Vue](https://vuejs.org/), [Angular](https://angular.io/).

## 2. Not Exercising

![not exercising](https://jsmanifest.s3-us-west-1.amazonaws.com/posts/8-habits-for-beginning-mid-javascript-developers-that-sabotage-your-future/1.jpg)

Something I haven't really mentioned much in my previous articles was staying fit. Now i'm not some professional trainer or anything, but I watched my body transform throughout the years and I witnessed first hand experience some of the terrible outcomes you can make happen if you ignore your health.

So what were some of these experiences? Well, I've been planning to make a very long post about how I managed to secure my first web developer job--shortly making my way to a front end team lead (And let me tell you this--my journey was a huge rocky landscape in many ways) which will include lots of juicy, emotional and inspirational details especially for those who are self-teaching JavaScript for themselves, but I will say just this one line of it: I gained 32 pounds in a single year back then as a result of learning JavaScript alone. How does that happen to someone?

If you don't exercise, you risk developing many disturbing things that can happen to your body when you [gain weight](https://healthfulinspired.com/15-disturbing-things-that-can-happen-when-you-gain-weight-07-13-2018).

Some of these include:

1. Changes to your DNA by [altering gene expression](https://www.sciencedaily.com/releases/2016/12/161222094841.htm).
2. The extra calories you gain over time starts converting to fat.
3. [Increases your risk of developing migraines](https://americanmigrainefoundation.org/understanding-migraine/the-skinny-on-obesity-and-migraine/) (including chronic ones).
4. Your blood pressure starts to rise as weight gain can start to put extra stress on your heart which can possibly lead to excessive amounts in high blood pressure.

The list is endless.

## 3. Socially Isolating Yourself

![socially isolating yourself away from family and loved ones because of javascript](https://jsmanifest.s3-us-west-1.amazonaws.com/posts/8-habits-for-beginning-mid-javascript-developers-that-sabotage-your-future/social_isolation.jpg)

Your family and loved ones are important.

When you isolate yourself away from your social life while learning JavaScript you are undermining your mental and physical health in ways such as [increased risk of depression and anxiety, difficulty sleeping, weight loss, and feeling more tired or lack of motivation](https://www.bupa.com.au/healthlink/mind-and-body/healthy-ageing/keeping-connected/social-life/why-your-social-life-is-more-important-than-you-think).

## 4. Not Writing Tests

I often see people skipping unit tests for their web apps and that's perfectly fine--until an unexpected error happens to crash the app at some point. And that's when it becomes a huge problem because time and money can be at loss.

Having that said, just because your code is able to continue compiling without errors or just because the app works without the console complaining, it doesn't necessarily mean that the app should be ready for formal use.

The absence of any sort of tests might be fine for small apps, but when the app gets bigger and becomes harder to maintain, tests start to become increasingly important to integrate to the app because any changes you or other people make to the existing code _can break another part of the app_.

Want to save time in the future for huge projects? Integrating [tests](https://medium.com/welldone-software/an-overview-of-javascript-testing-in-2018-f68950900bc3) will help immensely.

## 5. Learning Frameworks Before JavaScript

I know and understand the temptations to start developing web apps immediately using the most popular libraries and frameworks like React, Vue, or Angular.

I used to say "Learn JavaScript before you learn frameworks!", but my opinion has somewhat changed. Instead of going straight to learning these tools as a newcomer, the best approach is to _learn them while your learning JavaScript_. The JavaScript ecosystem is moving at a ridiculously fast pace, and if you want to sell yourself in the market you have to have at least _some_ experience in tools like React, Angular, and Vue.

For example, I did one search on indeed for "_javascript_", and here is the first result that came up:

![jquery and javascript job requirements](https://jsmanifest.s3-us-west-1.amazonaws.com/posts/8-habits-for-beginning-mid-javascript-developers-that-sabotage-your-future/jquery_javascript1.jpg)

The job description says that they _require you to have jQuery and JavaScript_ experience. For this company, jQuery is equally as important as JavaScript.

A separate job description requires these following "_basic_" requirements:

![basic qualifications for front end web developer on indeed](https://jsmanifest.s3-us-west-1.amazonaws.com/posts/8-habits-for-beginning-mid-javascript-developers-that-sabotage-your-future/basic_requirements_react_vue_angular_jquery1.JPG)

I clicked on two out of four job postings, and _50%_ of them requires not only knowledge in JavaScript but knowledge in the tools built on top of it as well. I wouldn't quite recommend splitting half of your time into JavaScript and the other half into some library of your choice however. The ratio should be more along the lines of 65% JavaScript and 35% on a front end library or framework that you went with.

Splitting up your time this way is very convenient in a way you still benefit from learning "_true_" JavaScript while still learning a popular front end framework to improve your knowledge in building front end web applications. You'll also find yourself a little at ease for joining the discussions about hot topics like React or Vue.

But what does it mean to allocate 65% of your focus on learning true JavaScript and the rest on popular tools you wanted to immediately start with? How does that work out?

What _worked_ for me on knowing the JavaScript language _extremely well_ was reading through the free online ebook [You Don't Know JS](https://github.com/getify/You-Dont-Know-JS) by Kyle Simpson (reading) and trying your absolute hardest to breeze through the online coding courses at [FreeCodeCamp](https://www.freecodecamp.org/) (hands-on). You benefit from two learning perspectives. The book You Don't Know JS does such a good job ingraining the ins and outs of JavaScript to your mind to the point where random parts of the book _still pops up in my head today_. And that has been _huge_ to me in interviews!

## 6. Not Learning Clean Code Practices Earlier

Writing clean code is what every developer must know and do in order to call themselves a professional developer. But it's also very convenient to start learning clean code practices early in your career. The earlier you start exposing yourself to these practices, the earlier you can develop the skills to write cleaner and more maintainable code.

Learning how to write cleaner code is one of those skills that _doesn't really benefit_ starting later into your career as much as "_learning JavaScript before a framework_" does. You don't _have_ to experience writing ugly code in the beginning to "learn the ways" of a JavaScript developer if you can just train yourself to write clean code. Your experience will come later when reading other people's ugly code and becoming frustrated. There's your experience.

## 7. Starting on Big Projects Too Soon

![stressed from starting on big projects too soon in javascript](https://jsmanifest.s3-us-west-1.amazonaws.com/posts/8-habits-for-beginning-mid-javascript-developers-that-sabotage-your-future/stressed.jpg)

One of the biggest mistakes I made in my career was getting started with projects that was planned to be _big_.

"What's wrong with that", you ask?

For one, if you're not a mid to senior level developer there's a pretty good chance you won't be able to finish this "big" project you have going on anytime soon. There's so many things to consider especially for apps to be stable if you aren't exposed to the best practices in writing cleaner code, writing tests, scalable architecture, etc. _especially_ if you're still in the beginning stages.

So what happens when you're transitioning into your mid-level developer phase and realized that a lot of the code you had written needs to be refactored because you realized that the app isn't written correctly? The job market starts to become at ease for mid level developers, but you haven't gotten the chance to put any good projects to your portfolio yet because you've been keeping yourself too busy with this big project you planned awhile ago. Then you start to think to yourself if it is even worth it to continue with it while other developers are taking your glory in these job interviews. My recommended approach is to start with a bunch of small projects so that you can _put them on paper!_. Have something to show on your portfolio _as soon as possible_, you never know when an opportunity arrives.

Another problem with starting with big projects too soon is that if you aren't exposed to best practices and the right design patterns to build your features, you'll just end up writing a lot of code that you have to refactor or abandon when the time comes. At that point, it's probably best to just re-write the entire thing instead of having to go back and re-wire the mess you created. You might choose to just abandon it and put the current code on your resume or portfolio anyways. But they're going to look at the code and make some unpleasant judgments.

## 8. Not Learning Data Structures And Algorithms

It's a long going debate on _when_ you should start learning about data structures and algorithms into your career. Some suggest learning them _before_ you start learning JavaScript, and some suggest learning them afterwards.

I personally think that learning them isn't really required in order to get your foot in the door into your career, but its good to expose yourself to _some_ algorithms so you can have some understanding with computer programs and computation. Algorithms are the integral part of any kind of computation or computer program. In fact, these computer programs are just a bunch of algorithms that get combined with some fancy structured data, that's _all_ ;)

## Conclusion

And that concludes the end of this post! I hope you got something out of it and look out for more posts from me in the future!

Find me on [medium](https://medium.com/@jsmanifest)