Author: John Au-Yeung

If you want to become a JavaScript developer, we just have to do a few simple steps.

They’re simple, but that doesn’t mean they’re easy. In this article, we’ll look at how we can all become good JavaScript developers by learning some extra knowledge.

Use Typescript

TypeScript is good because it adds some data type annotations and data type checking to our JavaScript so that we know what we’re working with.

It doesn’t modify the JavaScript. Rather, it makes the types of our objects and values clearer so that we don’t have to search for the value everywhere.

The extra type annotations get us the type information from objects so that we can use them to get autocomplete in IDEs and text editors so we don’t have to search for the original definition of the object ourselves.

It also checks if the data types are valid and stop building the code when it finds errors.

Linting

A linter has sets of rules to check if our code meets the standard for clean and easy to read code.

This way, everyone will have an easier time working with our code.

This check is important for big apps since lots of people will work on it.

We just need some standards to follow so that we can get our code clean and clear.

It also checks for old constructors which we shouldn’t use, which is good. Just because they’re there doesn’t mean that we should use them.

DOM Manipulation

If we want to be a front end developer, then learning about DOM manipulation and event handling of elements are must learn knowledge.

We should know about how HTML is parsed in the browser and how the parsed objects can be manipulated.

So we should learn how to add and remove new items from the DOM.

Once we do that, we can learn new front end frameworks with ease.

Frameworks

Once we’re developing apps that are beyond simple practice apps, we need some way to make developing them easier.

This means that we may use some frameworks like Angular and Vue, or React cobbled together with other libraries like React Router to make our own app framework.

Either way, we have to learn them eventually to create complex apps that are maintainable.

They enforce some structure and gives us syntactic sugar to simplify our own code.

Picking the Right Tool

The right tool for the job is important. With JavaScript development, we can just use a good text editor like Visual Studio Code to develop our app.

Visual Studio Code to extend the app so we can do more with it.

Also, we can use a bigger IDE like WebStorm if we wish. Those are all up to us since the project structure doesn’t depend on what program we use to write our code unlike projects in other languages like Java.

Learn New Things

Learning new things is always important. In the last few years, JavaScript has improved a lot, so we have a lot to learn.

We should learn new JavaScript features since they either replace bad old features or add new features that we can use to write cleaner code.

For instance, there’re new array and string methods added in the last few years to help us write cleaner code.

The array’s flat method helps us flatten nested arrays, string’s padStart lets us add extra spaces to the current string to match a certain length.

There’re many things like these and more, so it’s time to learn new things.

Advanced Topics

Advanced topics like iterators and generators are great bonus knowledge to learn. It lets us understand more about arrays and array-like objects and how we can use them with the spread operator and the for...of loop.

In the process, we would also learn about symbols, which is a special primitive data type used for identifiers for methods. Symbol.iterator is a symbol identifier for a special method in iterable objects to return data for the iterable.

Do More Practice

The more we practice, the better that we’ll get and the faster we’ll learn. So we should start writing practice apps to practice our skills until we know what we want to learn inside out.

Conclusion

Beyond the basics, we should learn about things like TypeScript for better type checking.

Also, DOM manipulation is important for front end developers. Front end frameworks like Angular, Vue, and something based on React can be learned easily once DOM manipulation is learned.

As a bonus, advanced knowledge like iterators and generators all can be learned.

Finally, do more practice and we can learn a lot more faster.

Being a developer is hard. Not only we have to know technical skills, but we also have lots of soft skills that we have to get good at.

In this article, we’ll look at some ways that we can all lower the risks for us when working as developers.

Clear Technical Debt

Technical debts are bad solutions that are added to speed up the development process.

Therefore, when we have time, we should clear the out by cleaning up our code.

Clean up anything with bad names, spaghetti code, multiple levels of nesting, and anything else that are hard to read and maintain.

Working with them is a pain and they’re fragile, so working with them is riskier and harder.

Ship Code Often

Delivering things in small pieces makes delivery less risky. Also, it feels good to have small wins that we can achieve in a short time rather than writing a lot of code that no customer sees for a long time.

Big bugs and breaking changes are also less likely with small changes, which makes them even better,

It’s also good for getting feedback early on so we can improve according to feedback.

Commit Early and Often

When we got something to work, we should commit them right away. This way, we won’t be at risk of losing them or ruining them with bad changes in the future.

Once they’re committed, then we can revert to them and we know they’ll be the last good changes.

It also reduces the chance of reverting the hard work that we’ve done.

Asking for Help

Asking for help helps all of us move faster since getting stuck on a problem for a long time means no progress.

Therefore, if we’re stuck, then ask for help.

Get Feedback on Unfinished Work

Getting feedback on unfinished work can steer us in the right direction before the work is done.

This way, we don’t have to throw out as much work since we’ve been steered in the right direction from the feedback that we obtained.

Try Things

If we don’t try different things, then we may not know that there’s a solution that we can use.

There are no risks so we should try it.

Read Documentation

We can learn how to use a lot of things with documentation, so we should read them before trying anything to avoid going down the wrong path and waste our time using anything improperly.

Don’t Overlook the Details

Details are important. If we screw up the details or miss them, then we may screw up some of our work.

So we shouldn’t ignore them.

Don’t Start for Scale

Build with scalability in the future in mind, but we shouldn’t overengineer our product by building it for scale when we don’t need it yet.

We just waste our time with overengineering and it doesn’t do us any good right now other than wasting our time.

However, we should make scaling easy to do by making our code prepared for scaling.

Think About Performance Implications

Performance is important since no one wants to wait for something to load. Worse yet, our code may run so long that it times out.

We should think about performance so that we get adequate performance in our apps so no one will be frustrated when using our app.

If our solution takes a great performance hit, then we should think again before doing anything.

Apply For Jobs We Are Qualified For

Ideally, we should at least know some of the stuff on the job description before applying. Never lie in our resume about our qualifications.

It’s easy to find out in interviews and even if we get in, we probably can’t do the work that we ask for. And we can’t do anything, we probably won’t last long.

So we probably should make sure at least we know some of the stuff listed before applying.

Modularize Our Code

We should divide our code into small modules so that we can all read, maintain, and test them more easily.

Long files are hard to read and unmaintainable.

Conclusion

We should divide our code into small pieces and don’t overengineer our code. Deliveries should also be small.

Cleaning technical debt and committing code often also reduce risks of making changes in the future.

If we’re applying to jobs, at least we should know some of the things in there. Otherwise, even if we get hired, we won’t last long.

Being a developer is hard. Not only we have to know technical skills, but we also have lots of soft skills that we’ve to get good at.

In this article, we’ll look at the ways that we can get better as developers.

Ask Specific Questions

Asking specific questions is more likely to get the answers that we’re looking for.

Otherwise, we may get some generic answers that don’t help us much.

Speak Up in Meetings If We Have Useful Things to Say

We should say something in meetings if we have something to contribute. Otherwise, we don’t want to waste other people’s time by saying things that don’t contribute much to the conversation.

Useful things also help people learn more.

Cross-Team Collaboration

It couldn’t hurt to collaborate cross-team so that we can learn things from other teams that we won’t be exposed to otherwise.

Cross-team collaboration is a great opportunity that we won’t get often, so it couldn’t hurt to do it.

Have Passion Projects

Outside of our work, we should do something that we like so that we can take our mind off work.

It also allows us to learn things that aren’t used at work, so that’s also a good thing.

Define Career Goals

We should have a target for our careers. This doesn’t have to be inside our company that we’re working for.

It can also be outside the company like starting a small business. We shouldn’t confine ourselves to our day jobs since they change often and we can’t assume that the company that we’re working for now will want us tomorrow.

Therefore, whatever we do, it should be a general goal rather than thinking about what we can do within the company.

Get Involved in the Conversation

Getting involved online is a great way to help others and promote ourselves in the process. If others know that we can help with their problems, then opportunities will come.

Also, we’ll learn more things than just being a lurker or a bystander.

Prioritize Tasks

We can’t do everything at once, so we got to prioritize our tasks so that we can finish them when we have time.

Of course, we should finish urgent issues first, and then do the less urgent ones later.

Trust Our Teammates

We should trust them to do their jobs. If they’re still our teammates, then they’re probably useful for something.

This also means that we should learn to delegate things to other people in our team so that we won’t be overwhelmed with our own work.

Don’t Compare Ourselves to Others

Comparison is the destroyer of joy. Therefore, we shouldn’t compare ourselves to others.

We just look at how good everyone has it and be miserable ourselves, which doesn’t help us much other than that it makes us sad.

Surround Yourselves With Allies

We always got to have allies that can help us since we can’t do too much ourselves.

Therefore, we need allies so that they can have our back when we need help. They also encourage us to keep going on our jobs.

Don’t Discriminate Against New Ideas

New technologies and ideas are worth a try. They’re always worth considering. We only use them if they suit our needs.

Also, we shouldn’t discriminate against other people since everyone deserves our respect.

Don’t Copy and Paste Without Thinking

Copying and pasting without thinking is a bad idea. We have to think about why it might work before we copy something from a website.

This is an important step that we can’t miss. We got to think if something already exists to solve our problem.

And we have to think if the code we’re copying and pasting is actually good.

Create an Inspiring Environment

We should create an environment where everyone is motivated to do their best. This means lots of encouragement and people aren’t worried about retribution if they make mistakes.

Remain Optimistic

We got to be optimistic about what we’re doing. It just makes us feel a lot better. Reality is the same but our perception is different. That makes a big difference in our day.

We rather feel good than feel bad. See the good side and we’ll get good outcomes in reality in no time.

Conclusion

We should be optimistic and create an inspiring environment.

Also, we should build trust and respect for others. Side projects and careers should also come side by side.

Watching video tutorials and reading books give us some understanding of what we watched.

However, if we just watch and read tutorials, we’ll never become a real developer.

In this article, we’ll look at what it takes to go from watching and reading tutorials to becoming a real developer.

Stop Looking at Tutorials

We got to stop looking at tutorials and reading the books. Just close all of them.

Then we have to resist the urge to go back to them again. We definitely don’t want to be copying code from those if we want to become a real developer.

Practice

After we close all the tutorials, then it’s time to start practicing writing code on our own.

We got to start with whatever we know and start practicing them from that. The easiest way to practice is to find some practice app ideas and then go ahead and start writing code to make those app ideas into reality.

It’s fine for them to be crappy. At first, we just want to get them to work. Then we can clean them up later.

This is where version control systems come in. We would want to set up Git repositories to hold our projects.

Then we have to learn how to commit code and revert if necessary. We can also see the full history of what we committed, so that makes tracking and reverting things easier since we can find them.

Next, we have to pick some app ideas. There’re many of them online. Some of the app ideas include chat apps, forums, payment trackers, and many, many more along those lines.

Just pick one and then start coding. Pick the languages, libraries, and frameworks that we know and then start building the project.

Whatever we do, don’t take too long thinking about what to build. It probably takes 15 minutes is enough.

Be sure to commit code along the way so we can revert if something goes wrong.

If we’re stuck along the way, then find help online. We can search in the search engine of our choice to find what we want.

There’re also chatrooms and forums like Reddit to ask for help. However, we shouldn’t go back and copy stuff from tutorials and books that we’ve watched and read before.

If we got everything working, then we should clean up our code by following some clean code principles like dividing things into small pieces and renaming things to meaningful names.

Also, we can enhance the user experience of our app by streamlining user workflows and making our app look better with some styling.

Why Do We Need to Practice By Building Apps?

We need to practice by building apps because this is what developers do a lot. They think of solutions based on problems and they solve those problems with code.

We should write code to solve problems ourselves to learn along the way. If we can write our own app from scratch by just looking up stuff online, then we’re a proficient developer.

At this stage, at least we got something to work. Next, we have to clean up our code that’s working so that we can write a clean code that everyone can understand.

Once we practice writing and cleaning up stuff, then we understand a lot more than if we’re just watching video tutorials and reading books.

They already give us examples, so reading them and copying from them isn’t going to us any good since copying from them don’t go through our brains too much.

We also get a feel for various parts of app building, including front end and back end development, and UI/UX design.

If we build a whole app from scratch, we’re forced to understand a bit of all those things. This will then become muscle memory if we worked on them enough.

Conclusion

To go from watching tutorials to becoming a real developer, we’ve to practice building apps.

We just pick an idea and build something from it. If we get stuck, we don’t give up. Instead, we search for help online until we solve our problems.

Most ideas are simple CRUD apps, so finding help for them shouldn’t be too hard.

Being a developer is hard. Not only we have to know technical skills, but we also have lots of soft skills that we’ve to get good at.

In this article, we’ll look at some ways that we can all become greater programmers.

Problem Solving

Developers, like many kinds of occupations, are there’re to help people solve some problems.

Therefore, we should hone our problem-solving skills all the time so that w can solve them quickly and elegantly.

Strong problem-solving skills can help us solve any problem that we have at hand.

Pair Program

Pair programming is a great way for knowledge to be exchanged between people.

It’s much better than sitting alone and trying to figure something out without any help.

Also, it gives us a chance to chat with other people, which is nice. Otherwise, the work would be very boring.

Meet Like-Minded People

Like-minded people are people that we can talk to when we want to chat.

They understand us and what we’re doing, so we should meet more like-minded people so we won’t be so lonely. Also, we can ask them for help.

Delete Dead Branches in Our Repos

Dead branches just clutter up our repositories and slow us down when we try to check out code. Therefore, we should remove them so that we can get some speed again when we have repositories.

Learning Every Day

Computer things and software all change fast. Therefore, we need to be ahead of the curve so that we can use new useful things before anyone else.

That makes us more valuable than the competition since we know more than they do.

If we become experts in something, then the opportunities will come. Everyone needs computer and software experts nowadays that can help them.

Get Clear Requirements Before Starting Something

To avoid doing useless work, we should get clear requirements on everything before starting work on something.

This way, we won’t have issues to deal with. It’s just much easier not to have to do all the things we did and then have to throw them away and do them again.

It’s just not a pleasant experience at all.

Don’t Quit

We shouldn’t give up problems easily since most problems have some difficulty associated with it.

We’ll figure out the solution eventually with some help. We shouldn’t give up too easily.

Have Expert Knowledge in What We Do Regularly

We should know what we’re doing regularly as a developer inside out so we can solve problems more easily.

Also, we should be incrementally learning new things so that we can be ahead of the competition when it comes to gaining knowledge and using them.

The tools in our brains will help us so that we can work without looking things up all the time.

Listen to Constructive Criticism

Constructive criticism is good. They help us get ahead by giving us wisdom from people that give us the criticism,

They help us be wiser and grow faster.

Also, we should be open-minded and try different things. Don’t resist new things. Instead, we should learn them.

Nowadays, most of the things that are released are incremental changes from the previous ones since the great leaps forward are already in the past.

Now lots of technologies have matured and don’t need to change as frequently or as big as they did before.

So learning new things shouldn’t be as hard.

Present Things

More often than not, we have to present things sometimes. We have to learn how to present things well.

Keep our presentations short and to the point so that we won’t bore people.

Also, speak confidently and look at our audience so that we’re actually talking to them.

Our presentation slides shouldn’t be filled with lots of words. Instead, just put in a few words and put them in some pictures. Don’t overdo transition and animation effects.

Conclusion

We should learn to clean up our code. Also, we should always strive to become wiser by taking constructive criticisms to heart. This way, we’ll learn and become an expert faster.

Also, to win an audience, presenting things is the best opportunity to do it.