Category: Careers

As a back end developer, we have a big job. We make apps that manage people’s data and we can make code that does many things to them whether they’re good or not.

In this article, we’ll look at some best practices to take note of when we’re developing back end apps.

Make Sure That We Have Backups

We got to make sure that we have backups in case we screw up any data with any manual operations or bugs in our apps.

Having backups is not enough. We got to check that actually work. This way, we can restore them if we have any issues with them.

Backups should be in multiple locations, for instance, we have some onsite and some in the cloud.

Have Scripts to Copy Data

If we’re copying the same things over and over again, we should have scripts to automate that for us.

This way, we don’t have to type in the same commands over and over again. Also, we avoid screwing things up when we type commands.

Scripts are always the same, but humans are not.

Plan Before Rolling Out Updates

If we’re in charge of managing servers, then we’ve to make sure that we plan for applying updates.

This is something that we may have to do once in a while.

Hopefully, the downtime is minimal so that we don’t have to work off-hours to apply them.

It’s also probably a good idea to apply them to non-production environments first before trying to apply the same updates to a production server.

Have Plans to Scale Up Persistence Solution

We got to have some plans in place to scale up databases if needed. If they run out of capacity, then we have to scale up disk space, memory, or both for example.

We may also do things like sharding to divide data into multiple database servers.

Managing Schema Changes

Schema changes also needed to be managed. We should make sure that they always go smoothly before running the same schema migrations in production.

Fortunately, most frameworks and ORMs have their own schema migration capabilities so that we don’t have to deal with them ourselves.

Otherwise, we’ll have to write our own scripts to do the same thing.

Add Monitoring to Verify the Health of the Persistence Solution

We got to have some way to check that our databases are working. This way, we can actually make sure that our database server is working.

If they go down or have any other issues, then we got to know about them right away.

Most web or cloud hosts have their own solutions, so we should use them.

Photo by Christiann Koepke on Unsplash

Choosing the Best Hosting Solution For Our Apps

We got to choose a good hosting solution for our apps right from the start so that we don’t have to think about migrating to a different host when the one we have isn’t good.

There’re 3 choices. We can use the software as a service, self-hosted in the cloud, or self-hosted in our own hardware.

Software as a service solution would like a web host like Siteground or Bluehost where we just click a few buttons to get things going.

This is good for simple, low traffic apps since they’re mostly shared hosting and don’t have much processing capacity.

If it’s self-hosted, then we can create our own server and change the hardware the way we like. That applies to both the cloud and our own hardware.

With cloud hosting, we use virtual servers hosted on their own hardware to host.

If it’s our own hardware, then we host the virtual servers on our own machine to do the hosting.

Of course, the most flexible is hosting our own hardware. However, that has the most responsibility and there’s no support from anyone unless we pay for someone to manage it.

All in all, we’ve to choose one that suits us. However, more and more businesses are hosting their apps on cloud-based servers because of their balance of convenience and flexibility.

Conclusion

We’ve to deal with lots of issues if we’re working on the back end. Not only do we have to deal with developing the apps, but we also have to deal with backups and servers for hosting our stuff.

This means that we actually have some server and web host knowledge as well in addition to the ability to develop back end apps.

Being a good remote worker takes a lot of discipline. We have to do everything ourselves without anyone watching.

In this article, we’ll look at some habits we can adopt to become a good remote developer.

Practice Good Meeting Etiquette

Good meeting etiquette is very important. Since we’re starting at our screen for meetings and don’t have to go to a physical meeting room, it’s all on us to be a practice good meeting etiquette.

We should have everyone on separate screens. Our face should be on video if we’re participating.

Also, we have to pay attention and don’t get distracted by random things around us.

If we don’t have anything urgent, then we should do other things.

Being on the computer, it’s easy to take notes, so we should do it.

Also, we should probably wear work attire if we turn on video so that we won’t embarrass ourselves if we stand up and have underwear on.

Experiment With What Makes Us the Most Productive

Since we aren’t using only office equipment and staying in the office, we can experiment with our home office setup to see what works for us.

We can wear whatever makes us comfortable as long it’s not underwear or any non-business clothing.

Also, we can shift our start and end times a bit as long we don’t miss any meetings.

The type of work that we do during the day can also change according to our schedule since no one is watching and micromanaging what we’re doing.

We can listen to whatever we want and sit anywhere that makes us more comfortable.

Also, we probably don’t have any set lunch hour. That’s nice since that means we can adjust our lunch schedule the way we wish.

Clear Communication

Since we don’t see each other in person, we can’t read people’s body language to get what they mean when they type a message or talk.

Therefore, we should make sure that everything is clear and that people understand what we want to convey.

Dealing with different time zones and different mediums of communication also makes things harder for us.

Therefore, to make everyone’s lives easier, we should outline our ideas clearly and type out actionable steps.

Meeting notes are more important since we aren’t sitting beside each other to ask questions.

Instead of using a real whiteboard, we have to use a virtual one.

If we have to pair program, we have to talk and share our screens.

Also, no one will know how we feel over the Internet, so we should convey those clearly.

If we need help, we’ve to ask around since not everyone may answer.

Also, we should check our notifications so that we’ll answer people when we see them. People are waiting for our answers and this is more important since no one is around us to answer urgent questions if we need to.

Create Boundaries Between Work and Life

If we’re working 9 to 5 at the office, then we got to set similar boundaries even if we’re working at the office.

There’s just no way that we can work 24 hours a day and not burn out and be tired.

Therefore, we should set some boundaries so that we cut off work the same way that we go home at the end of the day.

At the end of the day, turn off work notifications, close all our work stuff and relax. Also, we should take breaks like we do when we’re in the office.

We got to walk around and clear our minds. Also, lunch breaks are equally important, so we should have them.

Conclusion

Even though we’re working remotely, we got to set our boundaries like we do when we’re working at the office.

The difference is that we have to make sure that we check our notifications more frequently during work hours so that we can answer people’s questions.

Also, we should make sure that we convey everything clearly so that we can be sure that everyone understands us.

Finally, to collaborate, we have to use share screens and use video conference software.

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.