Author: John Au-Yeung

If you want to become a successful developer, you have to learn more than writing code to become successful.

In this article, we’ll look at some technical skills that you need to become a successful developer.

Networking

Most apps in the world don’t work in isolation. Instead, they communicate with other computers via networks, with the Internet being most common.

To learn about internet communication, we have to learn about the HTTP protocol thoroughly.

HTTP is the main protocol for communicating over the Internet. We have to learn about GET, POST, PUT, and DELETE requests and how they’re related to database operations.

They represent read, create, update and delete operations in databases respectively.

Also, we have to learn about request and response headers and what kind of data they can contain.

Lots of times we have to make authenticated requests so we have to learn about how to make authenticated to different servers with OAuth and API tokens.

To transmit data, we often use a standardized format to do that. Oftentimes, we transmit and receive data in JSON format.

Also, we have to learn how to transmit files with other data in HTTP requests with form data.

To do real-time communication, we have to learn about WebSockets. They let us send data back and forth between different computers in real-time instead of making requests individually.

Automated Testing

We’ve to learn about automated testing so that we can write tests to make sure our program is working after we made changes to it.

There’re a few kinds of tests, including unit tests and GUI tests. Unit tests test small parts of our program in our code like individual functions or classes.

GUI tests actual test our program like a real user by manipulating our program within a browser or the operating system.

GUI tests are end to end tests that test the whole system.

There’re also integration tests that test a bigger part of a system than a unit test but smaller than the end-to-end GUI test.

Integration test tests parts of a program like unit tests but may include actions like database manipulation that’s not done with unit tests.

Tests are run in test runners like Jest for JavaScript and JUnit for Java, so we have to learn how to use them to run our tests as well.

Cross-Platform Compatibility

Cross-platform compatibility is important for any apps. For web apps, we have to make sure that they work in the most popular browsers.

Also, many apps also have to be compatible with mobile so that we should use to make sure that it looks good on mobile if our apps have to work on mobile.

To make them work on all platforms, we have to make them responsive, which means that the styles adapt to the size of the screen appropriately.

Security

We’ve to learn about security issues with apps and common attacks like code injection, cross-site scripting, cross-site request forgery, etc.

Also, we’ve to learn about cryptography so that we can store secrets securely.

Code injection is where we let attackers run code in our system by providing places for them to run malicious code.

Cross-site scripting is code injection attacks on the front end, where attacks can inject their own scripts and run them with our apps.

Cross-site request forgery is where attackers make unauthorized requests as if they’re an authorized user.

With cryptography, we have to learn about symmetric and asymmetric cryptography. With asymmetric crypto, we have to learn about how to generate private and public keys.

Software Development Life Cycle

Since we’re working on developing software, we’ve to learn about the software development life cycle so that we can get used to the development process faster. The cycle consists of the following:

1. Requirement gathering
2. Feasibility study
3. Design
4. Implementation / coding
5. Testing
6. Deployment
7. Maintenance

Conclusion

Networking is important because apps communicate with other apps and APIs via some network.

Also, we have to learn about testing so that we can make sure our apps work after our changes.

Security is also important since attackers will take any chance that they can attack our systems.

Finally, the software development lifecycle must be learned so we can get used to the process.

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.

Start With the Basics

We got to learn the good parts of JavaScript, which includes many basic building blocks that we need to build good JavaScript programs.

Now it’s a great time to learn JavaScript since a lot of the good parts are added in the last few years. We can do a lot with the good parts of JavaScript.

The basics include defining and using variables, defining and using strings, array manipulation, and functions.

Those are the building blocks of JavaScript. Since 2015, the features that are added are good.

We can declare variables with let and const . Strings are used everywhere to store text.

The basics also include the use of operators to do arithmetic and assigning values to variables.

They include operators like add, subtract, multiply, divide and assignment. String concatenation is also an important operator to learn, even though it’s been replaced by template string in a lot of cases. This means that template strings are also important since they make our code cleaner.

Arrays and Loops

Arrays are used to store lists of data. We should use to learn the array methods thoroughly and use them. This is to minimize the use of loops.

However, loops are still very useful, so we should use them. Loops let us traverse through lists of data when array methods aren’t adequate.

Objects, Constructors, and Classes

To store data in an organized way, we should use objects. This way, we can group variables as properties of an object.

We should also learn about all the ways that objects can be created. This includes object literals and constructor functions/classes.

Object literals are the process of creating objects outright without calling a constructor or a class.

Constructors are functions that returns objects that have the same members, including instance variables and methods and static methods.

There’re no private variables in JavaScript constructors right now, but they’re being planned.

Also, we should know the instance methods are properties of the prototype property of a constructor. They’re called on the object when we need to call instance methods.

A prototype is template objects that an object inherits from. Most objects inherit from objects.

If we’re going top create constructors, we should use the class syntax. It makes our constructor look more like a regular class, even though it doesn’t act like a regular class underneath.

It adds more error checking to the constructor code we create so we won’t make mistakes as easily as with the old constructor function syntax.

This part definitely trips people up if we’re used to class-based object-oriented languages.

Functional programming

Functional programming concepts are applied throughout the JavaScript language.

For instance, higher-order functions are used everywhere. They’re used in many array methods like map and reduce , which takes a callback function that’s called when we try to get new results from an existing array.

Also, callbacks are used a lot for asynchronous programming, which is required for making any nontrivial JavaScript program since they need to call callbacks so that the program won’t hold up other parts of a program from running.

We need asynchronously code a lot since JavaScript is a single-threaded language, so we callbacks to run code later in an indeterminate amount of time.

Asynchronous Programming

As we mentioned above, we use callbacks a lot for asynchronous programming. To make async programming cleaner, we use promises to avoid nesting callbacks.

To make promises cleaner, we use the async and await syntax to make things even cleaner.

Therefore, we should learn the syntax to write some clean async code.

Testing

Automated testing is important since we don’t have time to check every part of our program all the time. Therefore, we should write tests to do this for us.

To do that, we should write tests and use test runners like Jest to run them. This way, we know that our app is still working properly.

Conclusion

The basic knowledge for becoming a good developer is a lot. First, we have to learn toe basics, then we have to get to think like async programming, functional programming, and automated tests.

Practice them all and we all can become good JavaScript developers.

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.

Take Vacations

No one should feel guilty for taking a vacation. If we’re somewhat useful for our company and the company’s finance are good, we can probably stay.

Otherwise, it probably a good company to work for.

We all need a break so that we can recharge and do work with a fresh mind, which is faster and better than with a tired brain.

Take Breaks During the Day

Taking breaks during the day is important. Take walks and lunch breaks are definitely things that we should be doing during the day.

It’s just not good working the whole day without taking a break.

Track Our Progress

We’ve to get organized so that we can work faster. One way to organize ourselves is to track the progress of our tasks.

It feels good to see some progress during the day. Keeping achievements and progress visible to us is encouraging and makes us keeps going in the long term.

Don’t Be a One-Trick Pony

Learning multiple frameworks and libraries is important since we don’t how they’ll last or how long we’ll at the company that uses those frameworks or libraries.

If we learn more now, then we’ll know them before we need them in our current or next job.

Review Code

Reviewing other people’s code and letting people review our code will make us wiser.

Either way, it’ll expose us to other people’s styles and so we can learn something that we don’t know from them.

Other people that review our code will give us suggestions for us to improve. So either way, we’ll know things that we don’t before after code reviews.

Learn About Design and Marketing

Design and marketing are important parts of the business. Without marketing, there are no sales, and no sales mean no business.

Knowing design skills lets us empathize more with customers’ needs and help us do a better job when we’re working on user interfaces for users since will consider user experience before anything.

It’ll also make our user interfaces more polished than before.

Learn About Technical Skills That We Don’t Work With Regularly

At least learn a bit of the skill that we don’t work with often so we can work with them if we’re asked.

It just makes us more useful than people that don’t know the skills.

Choose the Right Technology for the Project

Choosing the right technology for the project is important even though it might not be the one that we’re most comfortable working with.

We should pick the right one for the project so that we won’t run into problems down the road if we try to fit a square peg into a round hole.

Own Our Mistakes

We should own our mistakes and not blame others for our own wrongdoing.

It just makes people like us more not to point fingers, and it also builds trust among employees.

Review Our Own Code

Reviewing our own code is important for us to improve. We should think if we’re doing things properly and what comments would other people make if they see our code.

This way, we’ll have to make fewer changes later when someone actually reviews our code. It’s much better not to have too much back and forth.

Learning From Failures

Learning from failures will help us get better. We should think of ways to improve after something failed.

Then we can do differently next time and not make the same mistake.

Stay Curious

We should keep updating ourselves on new things since the computer industry changes all the time.

People are always making new hardware and software that may help us with our work.

Also, we can ask questions if we aren’t clear about something.

Conclusion

We got to keep learning from other people’s work and suggestions so that we can improve. Also, we should learn from our mistakes and failure so that we can keep improving ourselves.

Other skills that we don’t work with should also be learned so that we can get better and use them in case we need them in the future.

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.