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 soft skills to learn in order to become a successful developer. Like any job, soft skills are also pretty important given that we can do the technical work.

Being Approachable

Being approachable is very important since most developers work in a team.

It means that we’re ready and willing to help people if the need arises.

When someone asks us something, we should be available for help if we can.

It just makes us more useful in the team, which contributes to our continued success in any environment.

Patience

In software development, we run into problems all the time. We just have to be patient in any way we can.

We should listen to there people patiently and be open-minded.

Also, we should be helpful to other people and explain things to non-technical things in simple ways that they can understand.

We should also be patient without teammates and be aware that they’re probably pretty busy and don’t always have to fulfill our requests.

Open-Mindedness

We should be open-minded about feedback and take them so we can adapt to them. This way, people will like us since they won’t be frustrated with us by being stubborn.

Also, constructive feedback is also important if we create our own product to sell since we want people to buy our stuff.

Therefore, we should listen to customers and clients that give us money and so we should take any reasonable feedback from the seriously.

Problem Solving

The core of software development is problem-solving. We’re just solving problems with software and programming instead of using other methods.

This means that we should get good at problem-solving so that we can be useful to people like teammates, customers, and clients.

To solve problems we have to step into the shoes of people that have the problem at hand. We have to know what they want.

Also, we have to dig deep and find the root cause of the problem before solving it. It doesn’t help us much to just try random things and hope that something sticks.

As developers, we have to solve problems with logic and reason.

We also have to learn to work with other people within and outside our teams to solve problems together. This may include things like pair programming.

Creativity

We have to be creative when solving problems. If we’re fixated on one thing when we’re solving problems, then we may never find the right solution since the solution is probably outside of what we’re thinking.

We should try different ways to solve problems until we find the best way to do it. Creativity can also come from other people’s suggestions rather than what comes out of our own brain.

Reading other people’s stuff and trying different things helps us get creative.

Accountability

Accountability is all about taking ownership of everything good and bad. We have to admit to mistakes and fix them.

Also, we have to deliver results and update people at least once in a while so that others know what we’re doing to avoid any duplicate work.

Photo by noor Younis on Unsplash

Time Management

Time management is important if we want to deliver things on a schedule, which is probably most developers’ jobs are in essence.

We can use things like kanban boards to keep things organized and keep track of their status. It’s a good way to visualize tasks and keep everything readable so we know what we’re ahead or behind on.

This is important since most of us probably have a lot to do so having something to keep us on track is important.

Also, we should divide our work in a way so that they can get done easily. This means dividing projects into small, manageable pieces instead of trying to attack everything at the same time.

Conclusion

We should manage our time by dividing our tasks into small pieces and track them.

Also, we should be open-minded and creative so that we can solve our problems faster by not fixating on the way we solve problems.

Being approachable for help is also important since teammates should help each other.

Finally, being patient when dealing with clients, teammates and other stakeholders is also important.

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 soft skills to learn in order to become a successful developer. Like any job, soft skills are also important given that we can do the technical work.

Diversify

We have to be open-minded about different things. Being able to learn different things and unlearn outdated or bad knowledge is a must.

Therefore, it’s important to learn things outside of our jobs in case we need them. So if we’re working on Rails now, we should also learn about Node and Express, for example.

This also goes with general principles like learning functional programming when we’re using object-oriented languages mostly. They aren’t mutually exclusive.

For instance, JavaScript has both functional concepts like higher-order functions included in the language and also object-oriented concepts like objects, prototypes and inheritance included.

This way, we can be useful to more people and it also adds different perspectives to enrich how we think about different things.

We won’t be as narrow-minded if we learn different ways to do things.

Computer things change fast, so we must adapt so we won’t be useless and unemployable in the near future.

Be Agile

Being agile means that we should be prepared for changing requirements or projects at any time.

Our minds can’t be fixated in anywhere so that we can understand users’ use cases for a software product.

Also, we got to be understanding to customers and incorporate their feedback into our product.

Therefore it’s best to just do a small piece of a product at a time. This way even is feature changes, we won’t have to go back to everything over again.

It also makes implementing anything more manageable since we won’t be overwhelmed with anything.

Empathy

Having empathy is important. Since most software projects are teamwork-based and software is used to serve customers, it’s best if we have empathy for users since they pay for the software that we write.

Any feedback should be incorporated into the product if they make sense and lots of customers request them.

We should also have empathy for our teammates since they work hard and will probably touch each other’s code at some point.

This means that we should write clean code and communicate changes. We should take a teammate’s suggestions if they make sense.

Always, try to see things from their point of view and why they want us to make changes their way.

Communication

Communication is both verbal and written. Verbal communication includes things like giving updates verbally and pair programming for example.

If we speak, we should speak clearly and with confidence. Also, we should listen more than we speak and don’t interrupt people.

These are just some basic etiquette that we should follow so that everyone has their chance to speak and be listened to.

Also, we should never dominate any conversation so that everyone has their chance to speak.

For written communication, we should write everything down. Things like updating the status and description of tasks are important.

Also, documenting instructions for how to set things and run when run things are also important.

In our code, we should write them so that that they’re self-documenting. So variable names should convey their meaning. This also goes for other things like functions, classes, or anything that has names.

Each function should be simple enough so that they only do one thing as indicated by their name.

Teamwork

Teamwork is important since most software projects are worked on by teams.

There’s just no way around it. It’s not only developers that we’re working with, but also designers, and different project teams.

We have to work with others well to become successful. Working well with others makes work a lot more pleasant then if we don’t.

Conclusion

Having a diverse and open-minded mindset is important if we want to become or continue to be successful as a developer.

Software things change all the time so we have to adapt to them. We should also be open to other things outside of what we do at what or at previous jobs.

Teamwork is important since most developers work in teams. So working well with others makes work more pleasant than if we don’t.

Finally, communication is important since we have to update and help each other in teams. Also, it’s important to be good at both verbal and written communication.

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 become better programmers.

Master Our Google Search Skills

We have to master our Google search skills. Every problem that we run into can found Google to get a solution.

Then we’ll have to sort through all the websites that are in the results to find the right solution that’s for us.

We can use the allintitle option to search for results that have all the search keywords you entered in the results.

Also, we can use the allintext option to search for all the results that have all the keywords you entered in the text of a document.

We should also include the version number of the library or framework that we’re using so that we get the relevant results for them.

This is will reduce a lot of irrelevant results for different versions of whatever we’re looking for.

Under Promise and Over Deliver

Under promising is an important thing to do since we don’t want to disappoint our stakeholders, clients, or customers.

We should keep their expectation low enough so that we can finish whatever we’re tasked with within a short period of time.

This way, people will be very happy if we went beyond what we originally promised our stakeholders and customers.

When people are happy with our work, then trust is developed, and everyone is happy.

Designers are Our Friends

Designers are our friends because we need to work with them to make their designs into reality.

If we don’t have a good relationship with them, then we’ll suffer in the end.

They know about aesthetics and user experience more than most developers, so we definitely need their help.

Be Helpful

We should be helpful to other people. Most people will reciprocate if we help them.

It’s very hard to do everything alone. And it’s also not as fun even if we can. Therefore, we should help them whenever we can.

Write Useful Comments

Comments should explain why we’re doing something. The code will tell us what it’s doing, so we don’t have to comment about what it’s doing.

If our code doesn’t tell what it’s doing, then our naming or code structure probably isn’t very good.

Name Variables and Functions Appropriately

This goes with the previous point. We should name things in a descriptive manner so that other people can know what we’re doing when they read our code.

Therefore, functions, variables, classes, and anything else that has to be named has to be clear.

This way everyone understands what something is from the names.

For instance, instead of naming variables with letters like x, we should name them with a descriptive name like numApples.

Likewise, we do the same with functions, classes, or any other entities that have to be named.

Photo by Daria Nepriakhina on Unsplash

Take a Break

We all need to take a break so that we can rest. Without adequate rest, we’ll make more mistakes, and they’ll definitely slow us down.

Everyone will be happier if we deliver things without flaws.

Delete Dead Code

Dead code has no reason to be in a program, so they should be gone. They just take up space and do nothing.

Reading Code

Reading code is important since we all have to do it before we start working on them.

Also, we have to know how other systems work even if we don’t work on them so we can interact with them.

If we don’t know how to read code, then we won’t know what we’re doing if we don’t understand the code, to begin with.

No Useless Meetings

Useless meetings are a great time sink. They’re usually long and we can’t contribute much to them.

Therefore, we should cancel all useless meetings and replace them with asynchronous methods of communication like chat or email.

Conclusion

We should keep in mind all these things when we’re working as a developer. This way we keep our code hygiene clean. Also, we’re better communicators in the end, which helps everyone including ourselves get better.

Being a software developer is one of the highest paying jobs in the world. Therefore, you may want to become a software developer. JavaScript is one of the most popular and versatile programming languages in the world, so it makes sense to learn that first.

In this article, we’ll look at how you can become a successful JavaScript developer.

Learning How to Solve Problems

Software development is all about solving problems. So we have to get good at that.

JavaScript language, frameworks, and libraries are just ways to solve problems. We’re just using JavaScript to solve our problems if we’re a JavaScript developer.

Therefore, we should learn how to solve problems before we learn JavaScript. Learn some basic algorithms and data structures like lists and arrays. Also, brush up on basic math so that we can use them later.

Geeks for Geeks is a good site to look at learning algorithms and data structure as there’re many problems on those topics, from beginner to advanced levels.

Just look at the general principles for now until you learn some programming languages.

Learn JavaScript Basics

After learning how to solve problems, it’s time to learn how to solve them with JavaScript.

To do that, we can read books, take courses, or watch videos from YouTube. There’re courses of sites like edX and Coursera that are free if we’re just auditing them.

Therefore, they’re probably worth a try to see if it’s a bit. There’re also courses offline of course in schools.

The most important thing is that plenty of practice is required. Whatever you do, you have to practice solving problems you found in books and online

The basics include JavaScript variables and functions. Once you learn that, then learn about objects, classes, and methods.

These are all for storing data. You also need to learn about JavaScript operators so you can do something with the data in variables and objects.

Then learn about arrays and loops which lets us store data in a list.

Also, you need to learn about strings to know how to store text data.

Be sure to learn the latest JavaScript syntax since they’re better than the old syntax in most cases. They include things like spread operator, destructuring, let and const and more.

Learn the JavaScript Standard Library

After learning the basics, you should learn about things that help make our lives easier.

There’re lots of methods in the standard library that helps us like array and string manipulation methods.

Also, handling dates is also important. JavaScript has a built-in Date constructor to help us do that.

Learn About HTML, CSS, and DOM Manipulation

HTML and CSS let us put items on a web page and style them respectively. Therefore, it’s important to learn that if you’re going to become a JavaScript developer.

Once you know that, then you can learn how to manipulate HTML and CSS with JavaScript.

The browser parses HTML and CSS into by putting everything in a document object model (DOM) tree, which is a tree of all the parent and child elements.

This is important for front end development since DOM manipulation is the most basic operation of front end development. To learn DOM manipulation, you’ve to learn how to add and remove objects from the DOM tree.

Also, you’ve to learn how to style things dynamically with JavaScript.

If you’re proficient at this, then learning front end frameworks would be a breeze.

Photo by Kelly Sikkema on Unsplash

Node.js

Node.js is a runtime environment for running Node.js code on the server. It’s used for back end development and anything else other than web front end development.

Therefore, it’s also important to learn about Node.js. For back end development, Express is a simple web framework that’s popular. It’s simple enough that simple apps can be built without much effort.

To build a server-side app, it’s also important to know things like how to manipulate files on the server with the standard fs module, and how to save stuff to a database.

Conclusion

Becoming a JavaScript developer can be done for free as long as you have the aptitude and drive to learn all the basic knowledge. Also, plenty of practice is required to get good at JavaScript development so that’s also important.

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.

Data Structure and Algorithms

Most of the time, developers are thinking about how to solve problems, and data structures and algorithms are the basic building blocks of solving problems with code.

They’re also needed to pass interviews if you ever want to get a job, where you may need to solve some data structure and algorithms on the fly.

Therefore, we all need to know about basic data structures like linked lists, arrays, and trees.

Basic algorithms like sorting, recursion, and iteration are also must learn skills.

To practice them, go to Geeks for Geeks or LeetCode for plenty of problems to solve.

Popular Programming Languages

Learn some popular programming languages so that you can start using them anywhere. They’re popular because they’re used by companies to develop their software, so it’s time to learn them by practicing at home.

You may also be asked some trivial questions about them in interviews, so it couldn’t hurt to learn them.

Popular languages like JavaScript and SQL are used by web apps a lot, and Python is used for data science.

JavaScript is the only programming language for front-end development and SQL is the most popular query language for databases.

Java is popular for enterprise apps. So at least those are worth learning somewhat.

Source Control

Source control is needed to keep track of changes in codebases so that we can revert bad changes and merge everyone’s changes together.

Git is probably the most popular version control system. It’s a decentralized version control system so that the code repositories are distributed in people’s computers.

With decentralized version control systems, we have to learn how to check-in and check out code. Also, we have to learn how to push and pull code from remote repositories.

Also, we have to learn how to fork and make pull requests to make a copy of other people’s repositories and to ask others for review before merging code respectively.

Text Editors

Text editors are used for editor source code. Many projects can be written with just text editors alone.

Projects that are written in interpreted languages can be written with text editors, while ones that are compiled like Java may need an IDE.

Learning keyboard shortcuts for them is also important for speeding up development with text editors.

Popular text editors include Notepd++, Visual Studio Code, Sublime, Atom, etc. So take your pick and see which one is right for you.

Integrated Development Environments

Integrated development environments (IDEs) lets us create and modify code projects and files. We can also run and debug code with it.

They provide all the tools to write, debug, and compile code all in one program. They are especially useful for projects that are done with compiled languages like Java and C#.

Popular IDEs include Visual Studio, Netbeans, and IntelliJ.

Databases

Most programs have to save data. And a lot of data are saved in databases. We have to learn databases to save data and then update them.

SQL is the most popular query language for creating, updating, reading, and deleting data.

Therefore, we should learn them fast. To make our job easier, we should learn about SQL queries, including nested queries, grouping, etc.

Popular database management systems include MySQL, PostgreSQL, etc.

NoSQL database is also used in some situations like caching. They may save data as JSON or key-value pairs. Popular ones in this category include MongoDB and Redis.

Operating System

Whether we’re working with operating systems in a job or not, we’ve to know some basic things about operating systems like CPU usage, memory allocation, threading, etc.

We also have to learn how to write programs that are efficient on resources so that users won’t be frustrated with our programs.

Also, we’ve to learn about operating system shortcuts for our favorite operating system like Windows, Mac OS, Linux, etc. so that we can work faster.

Conclusion

These are some basic technical skills to learn. It’ll take lots of time to practice and learn them.

If we want to be successful, we’ve to learn them all and practice everything.