Category: Careers

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.

Be Prepared to Change Code We Write

Changing the code we write is just part of software development. It’s normal that someone asks for changes. Requirements change and we can also change things in code review.

Code also have their own lifecycle so they may have to change if they’re no longer useful.

Have Our Team’s Back

Most of us work in a team. And it’s much better if we all have each other’s back rather than pointing fingers at each or fighting about things.

This way, we all have more positive feelings towards each other instead of pitting everyone against each other, which doesn’t make a very functional team.

Also, we can try new things without fear if we actually have each other’s back.

Place Value in Our Work

Our work always has value. Otherwise, the company won’t need us and we won’t have a job anymore.

Therefore, we should give it the value that it deserves.

Remove All Distractions

Distractions are annoying so they should be eliminated. Useless text messages, emails, social media, are all distracting and removes focus from our work at hand.

We’ll probably think about things more clearly if we have fewer distractions. Responding a bit slower is probably OK.

Test Our code

Testing our code is important since they probably don’t work the first try.

In addition, we should have automated tests like unit tests, integration tests, end to end tests, and more.

Then we’ll have fewer defects in our code.

Be Helpful

Being helpful to others is always important. Since most of us are working in teams, it doesn’t help if we don’t help each other.

Otherwise, it’s not a team. Rather we’re just a bunch of individuals working on the same thing.

Plan Before Doing Anything

Planning first is important so that we have a clear roadmap of whatever we’re doing.

If a feature we’re working on is complex, we probably also have to plan it out with other people so that we won’t run into problems in the future.

Write Pseudocode

Writing pseudocode is part of planning. It’ll help us with thinking about a solution to our problems.

It’ll also help us map out the cases that we’ll have to consider to implement the solution.

Also, it makes implementing the actual solution easier since we already have the pseudocode in front of us.

Learn the Fundamentals

This should be the first thing to do before being a developer. Also, we need to refresh fundamental knowledge once in a while.

Basic data structures like lists, arrays, and trees are worth reviewing since they’re used often.

Algorithms like sorting and searching are also used a lot, so we should keep those fresh in our minds.

It’s also good in case we ever need to look for a new job.

Choose Long-Lasting Technologies

Technologies that are mature and maintainable are probably good. This way, we won’t be faced with breaking changes for too long.

Also, we should make sure that they’re still being maintained before we’re using it.

Keep Track of Achievements

Achievements are the things that keep us going. Small wins are just as important as the big ones if not more important.

Small wins are the ones that can be achieved quickly and keep us going. Many of them together add up to big achievements.

This is one more reason to break things down into small pieces.

Learn Design Patterns

Design patterns are always useful since they’re standard solutions that have been tested with time.

We should learn basic ones like the factory pattern, facade pattern, and more so that we can use them readily when implementing solutions.

Eliminate Ambiguity

Ambiguous code is bad code. Therefore, we should eliminate them. Naming things with descriptive names help.

Also, we should break things down into small pieces like functions and classes and that we all can read and understand them easily.

Conclusion

Planning and test are important processes for developers. They help us develop good solutions by thinking everything through before doing them.

Also, testing is important so that we don’t break anything or introduce any issues to our code.

Keep track of small wins keeps us going in the long term.

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.

Think of Different Cases and Solutions Before Implementation

We should think about different ways to implement a problem, their risks, and what ways they can fail before we start implementing a solution.

This way, we won’t run into problems down the road when we forgot to think about some edge cases or something else that we didn’t think of.

We should also consult other people’s opinion in case we’re fixated on anything and we didn’t know it.

This will make our lives easier down the road even though it’s slower at the beginning.

Find Our Niche

No one is good at everything. Therefore, we should get good at a few things and then do them better than anyone else.

This way, we can beat the competition and give ourselves better opportunities.

People like consulting experts for their opinions and so we should become one so people can consult us or ask us for help.

Having Discipline

We all need discipline so that we can keep to our schedules and don’t give up when times are tough.

These times will come eventually, so we should be persistent and let our discipline guide to have good habits.

Also, when we promise somebody something, we should fulfill it. When we’re busy, then we should remove all distractions so that we can focus.

Debugging is a Valuable Skill

More often than not, our code or someone else’s code won’t work the way we expect them to.

Therefore, we should learn how to debug our own or someone else’s code so that we can fix them.

A debugger would help. But the most important is to view what’s being assigned to variables at the moment that some piece of code is run.

We should learn the most effective way to do that so that we can save a lot of time debugging. Also, we’ll know exactly what’s going on so that we don’t have to guess and test.

Keep Our Current Skills Sharp

Keeping our current skills sharp is very important. If we don’t use our skills, then we’ll forget them in no time.

Therefore, we should keep our skills sharp so that we can keep them fresh in our brains.

Also, we should update the skills that we already have with new knowledge so that we can do things better.

Understand Why

Why is a very important question to answer. If we can’t understand why that means we didn’t understand anything.

Therefore, we should find out why something is the way it is.

This helps with our rational thinking and problem-solving skills which are both very important.

Know What We’re Worth

If we’re a capable person, then we should be paid appropriately. We shouldn’t let anyone get in the way of being compensated for what we’re worth.

After all, a day job takes most of the day, and most of us are solving problems and taxing our brains at work solving things that many people don’t want to or can’t solve. So we should be paid what we’re worth.

Otherwise, either find someone that pays us what we’re worth or find an easier job that pays the same.

Ask For Help

Asking for help is always important. If we’re stuck for a while and we’ve no clue how to proceed, we should ask for help.

This way, we won’t be stuck for as long as if we just try things for days. It’s just much easier to ask for help, solve the problem, and get it over with.

Learn in the Way The Suits Us the Most

We should learn in ways that suit us the best. Everyone learns differently. And we have to find the learning method that suits us the best.

In today’s world, we’re overloaded with information, we can learn from books, video, audio, and so on.

But nothing really beats practice in the software development world. So that’s one thing that we should do regardless of where we found our information in the first place.

Conclusion

It’s time to change our mindset and become a good developer. Learning effectively is one change we can all make.

Also, we should think of the risks involved in different solutions before proceeding to save us from misery later.

Finally, we should always stay sharp and find our own niche.

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.