Category: Careers

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.

Know When to Get Off Work

Since we’re working at home, we don’t have to go home from the office.

Therefore, we should know when we should stop working when working remotely.

We should aim to get off work at the same time as we do in the office. This way, we can take the breaks that we need.

Embrace the Perks of Working Remotely

Working remotely is great because we can control our workplace and we can do anything we want as long we finish our stuff.

Therefore, we should aim to embrace the good side of working remotely by keeping a flexible schedule and enjoy ourselves in different ways that working in the office outside of work.

There’s so much we can do now that we aren’t confined in the office that we should enjoy it while it lasts.

Automation for Remote Work

Developers are all about making things automated. Therefore, we should make our work automated as well.

We can set automatically schedule for notifying when we’re away on most messaging systems like Slack so that we all know that we’re away from the keyboard with something like Zapier.

Also, we can send video meeting links automatically by using Zapier.

It can also greet people automatically on Slack.

We can also do the same things with IFTTT by automatically creating recipes do automatically send notifications when something happens and many more that we probably haven’t think of yet.

As developers, we can also write our own scripts to do automation, which opens up an infinite number of possibilities as long as we can use libraries and APIs to help us automate our work.

Create Our Own Water Cooler

Chatrooms are great for water cooler conversations. We can create chatrooms between different people and there’s even more private than chatting neat the water cooler in the office.

This is because we can create private or public chat rooms that are only between the people we’re chatting with.

Also, we can send GIFs around and talk about the weather online, among many other things we can chat about.

Use an Online Whiteboard

Online whiteboard are just as good as real whiteboards, if not better, for brainstorming.

Online whiteboards can be of any size, whereas a physical whiteboard can only be so big.

We can use it to write anything, uploading pictures, add links, attach files, and do much more, which adds to the conversation in ways that we can’t do with regular whiteboards.

Also, we can save a snapshot of our online whiteboard so we can go back to what we have later.

The best we can do with a regular whiteboard is to take a photo of it, which isn’t that great.

Therefore, we should take advantage of all those capabilities that aren’t available with physical whiteboards.

Brainstorm Alone

Since we’re working in our own home, we can brainstorm alone quietly instead of having to think inside a noisy open office.

It’s a great opportunity to just close our room’s door and brainstorm.

Many people brainstorm better on their own, so we can take full advantage of our home office by brainstorming alone quietly.

Decide If We Need a Meeting

We should only call a meeting if it’s really needed. If chat messages and emails are good enough, then we can just use them and not disrupt people with extra meetings.

However, if we have no meetings at all, maybe we can make an optional one so that people can socialize online.

Standup meetings can be done on chat since it’s only used to update people on our progress for example.

Record the Meeting

We can record meetings without people feeling creepy in a remote meeting since people aren’t watching a camera recording ourselves.

That’s great since we can record our meetings instead of having people take notes.

We can also go back and watch the recorded meetings at the speed we want if we want to recall some information from the meeting.

Conclusion

We should take advantage of the benefits of working remotely, like having a rich whiteboard for brainstorming and recording meetings to let recall information from them afterward.

Also, we need to set boundaries so that we can all take a break.

To be a good programmer, we should follow some easy to adopt habits to keep our programming career long-lasting.

In this article, we’ll look at some of them and how to adopt them.

Make it Work and Then Make Them Fast

If our stuff works but it’s too slow, then we have to make them fast enough so that users won’t be frustrated.

We can commit the code that works but slow, and then we optimize it what we have to make it faster.

Keep Some Social Media Profiles

Social media profiles aren’t only for chatting with friends. It also builds our brand in the online world.

There’s no better way to get opportunities now than to keep a public presence online.

As long as people see our profile and that we looking experts to the outside world, then opportunities will come online.

We got to get an audience by gaining followers and teaching people what we know.

People will appreciate the knowledge that we give even if millions of people have talked about the same topic.

Everyone has their own angle on things so we can always provide something unique to other people.

Also, we should follow people that we can learn from or are interested in looking at their insights or be entertained by what they post.

Asking Questions

Questions are always worth asking. When having something we don’t know and can’t find easily, we should ask them to get the answer faster than trying to find them ourselves.

Brainstorming Don’t Pay the Bills

We got to output things for customers to use so that they can be happy. Brainstorming isn’t going to help us much.

So we shouldn’t take too much time to do it.

Have Hobbies Outside of Software

Hobbies are a great way to take our minds outside of work, so we should have some so we can learn something outside and take our break from work.

The last thing we want to do is thinking about work every day of the week. Therefore, it’ll help us avoid burnout.

Don’t Be Opinionated on Technology Choices

We should have too much bias about what technologies or programming ideology to use.

Preaching is going to be annoying and ignorant, so we should keep an open mind and accept other people’s judgment.

Don’t Accept Bad Workplace Behavior

Bad workplace behavior like bullying, favoritism, sexism, racism, are all unacceptable.

Also, make sure that we all get paid on time. If any of those things are happening, we need to find a new place and get away from the misery caused by bad behavior.

Automated Tests

Automated tests like unit tests and end-to-end tests are very helpful to check regressions so we should have them so we don’t deploy bad code to production.

Time Management

We only got a finite amount of time in a day, so we got to manage them properly so that we can all get higher priority things done and then go down the list by priority.

Soft Skills

Soft skills are just as important as hard skills. We’ve to work with other people so we’ve to make sure that we work with them well so that we get stuff done together.

Communication is important so that everyone is can work together and not misunderstand what everyone else is doing.

Also, we may want to find new opportunities eventually, so it’ll also help if we have soft skills.

If we have a side business, then we need sales and customer skills even more. There’s just no way to get around doing that ourselves at the beginning.

Don’t Get Discouraged

Never give up on anything. We just have to change so that we can gain success in some other way.

We just find what sticks and then double down on that. Nothing about success is going to be easy.

Conclusion

We should never give up on anything until we get success. Pivoting is the way to change until we find something that sticks.

Also, we shouldn’t be opinionated in technology or accept bad behavior in workplaces.

Keeping a social media presence online will also help us in the future.

To be a good programmer, we should follow some easy to adopt habits to keep our programming career long-lasting.

In this article, we’ll look at some of them and how to adopt them.

Take Responsibility

We should take responsibility for our work. Like with any other task, we make a commitment to ensure that we write software the right way.

We have to accept the responsibility for an outcome that we’re going to produce.

Therefore, we shouldn’t make excuses or blame someone else for anything. It just doesn’t help and make us look bad.

Provide Options

When we run into problems, then we should give the stakeholders a few options on how to move forward.

It’s much better than making one or more crappy excuses that don’t help to solve our problem.

Therefore, finding an alternative way to move forward is much better than making excuses and doing nothing other than that.

Dealing With Software Entropy

The software can turn into a mess real fast if we don’t have much discipline with our code.

Then we’ll run into problems in the future when we work on it.

Entropy is chaos and disorder. And if we don’t plan and commit to making our code clean, then it’ll turn into a mess real fast.

Therefore, we got to minimize entropy so that everyone can enjoying working with the code.

We just got to clean up our code before it turns into a maintainable mess.

If We See Broken Things, Then We Should Fix It

We definitely should find out what’s broken and fix them so that people won’t be frustrated.

We don’t have to take all our time fixing broken things immediately, but we should make note of them or make a quick fix so that we can deal with them in a better way later.

This way, our code won’t turn into a dumpster that no one wants to use or work with.

Remember the Big Picture

We got to make a note of the big picture. Even though we probably won’t get to work on every part of a big system, we should still be able to see the big picture so that we can make things that work well with the rest of the system.

Without the big picture, we would have problems later on when we find out that what we changed doesn’t work with the rest of the system.

Good-Enough Software

Nothing, including software, is going to be perfect. It’s hard to make every perfect and deliver things with a reasonable timeline.

Therefore, we got to think of the trade-offs that we’ll have to make in order to deliver something.

Ideally, everything is delivered incrementally, so that we can make our stuff better and then make them better afterward.

Good enough doesn’t mean sloppy code. It means that we make things that meet users’ requirements. However, we deliver what we can within the timeline given.

To outline the requirements clearly, we got to involve stakeholders so that they’re going to be happy with what we deliver.

If we’re working on a different product, then we’ll have different constraints. We got to make sure that we outline those clearly so everyone’s on the same page.

Make Quality a Requirements Issue

Quality is definitely something that we should consider as part of the requirements.

We would never skip quality for any reason because we’ll suffer if we don’t deliver something good to customers.

Also, the code has to be good so we can continue working on it.

Therefore, this is something that we should build into the timeline so that we wouldn’t skimp on quality just to release something.

Conclusion

We got to take responsibility for our work and make what’s good in the given amount of time.

The code got to be good, and we need to find a way to move forward given changing requirements.

Also, we should clean up our code and fix issues so that they won’t become a problem for users.

Quality should always be built into our timeline so that we have time to deliver something that’s good for users and developers alike.

Blogging is a way to share what we learn with others.

In this article, we’ll look at why developers should keep a blog.

Become a Better Writer

By writing on our blogs repeatedly, we’ll become better writers. The more we write and adapt to better writing habits, we can become better writers.

Better writers are better communications and that’ll bring us more and better opportunities in the long run.

Explaining Things to Others is the Best Way to Learn

There’s no question that explaining things to others is the best way to learn.

We get to do research on our topics that we’re writing about and we have to be able to produce our own examples for any technical topic we’re writing about to explain our points.

Also, we’ve to able to explain the different aspects of the technologies ourselves.

If we learn enough to explain to others without looking through online resources, then we know that we’re proficient at what we’ve learned.

Blogging will let us internalize our knowledge by writing about it and practicing by producing examples as we explain the technologies in our blog.

Create a Discussion and Learn New Things from That

We can create a discussion based on our blog and engage with our audience.

If our blog has an audience then we’ll get a discussion going in no time.

And from the discussion, we learn new things from that. This is a win-win situation. We know that our blog has engagement from the audience, which is good.

Also, we can learn new things from the discussions that we’re raising by posting our blog posts.

Present Our Own View On a Topic

Even the topic we’re writing about already had lots of people writing on it, we can still write about it since people will appreciate new views on our existing topic.

As long as we aren’t copying someone else’s work directly, it’s fine to write on a topic that many people have written about before.

We all have our own style and we can present new angles on the same topic that people have written about before by presenting our own view on it.

Therefore, we should write our own pieces on a topic despite many people writing about them already.

Read More and More for Writing a Blog

For most blog posts that we write, we have to do research so that we can write about them.

There’s just no way that we hold enough information and insights on our heads to write stuff to put into our blogs.

Therefore, we have to do lots of lots of research if we’re going to maintain a developer blog.

This makes blogging a great way to learn about whatever we’re writing about and absorb the knowledge by explaining and writing examples.

Educate Others

Educating others is a good reason to maintain our own developer blog. With it, we can help each other learn by providing our own views and insights to help us learn, which in turn helps other people learn.

There aren’t enough resources on developer topics, so getting readers is pretty much guaranteed if we keep maintaining and promoting our blog.

People will look at our stuff and learn them even though they might not be commenting on our blogs or be engaging with us.

They’ll find our stuff when they’re looking for help and some people will stumble on our blog and they get the help they need.

Enjoyment

Blogging is a great hobby. It’s something that we can do for enjoyment. It’s a lost cost hobby as we can blog on sites like Medium or WordPress or web can pay a few bucks a month to blog in our own blog.

Both are great ways to spend time since we’ve to do lots of research and wire about stuff that we want to write about.

Conclusion

We can use blogging as a hobby. It’s a great hobby since it’s cheap or free to set up a blog.

Also, we’ll help people they don’t comment on us. If we keep our blog for long enough, someone will stumble onto our blog eventually.

Finally, we become better writers by practicing our writing skills by blogging and presenting our work in front of the audience worldwide.

To advertise a developer’s skills and services, a portfolio website is essential.

In this article, we find out how to build a portfolio website that will attract viewers and get us opportunities.

Show Off Our Projects

We should show off our projects on our portfolio website. Link to the projects that are working with a screenshot of it.

This way, viewers will know what we can build. Also, we should link to the repository with our source code.

This means that we should check it into a remote Git repository and make the repository public so that people can see our code.

We just have to make sure that our code is cleaned up and preferably have some tests in them so that we can show off clean code with test coverage.

Express Ourselves

Our portfolio should express ourselves. So we make it look and add our own stylistic flair to it.

There’s no one way to create a portfolio. We just need to add whatever we want to show to the public with our pages.

Make the Site Interactive

We can make our site interactive so that people will remember that our site exists.

Adding some buttons for them to click on and show our work, for example, maybe a good way to make our site more memorable.

Buy a Domain Name

We should host our portfolio site on our own domain name. Therefore, it shouldn’t be on someone else’s subdomain.

The domain name is part of our identity, so it shouldn’t be a subdomain or some web host.

There’re tons of domain names out there. They don’t have to end with .com. We can get many domain names cheaply from NameCheap, which seems to be cheaper than most places and there’re lots to choose from.

No Console errors

Console errors should be fixed so that people won’t find any errors in the console when they look there.

Most of them are easy to fix, so we should eliminate them.

Don’t Use a Technology Just for the Sake of it

We should just use what we need to create a nice, interactive portfolio website.

Our site shouldn’t be that complex, and we shouldn’t add extra things that we don’t need on our site.

Make Our Site Work on Mobile

Many readers will probably look at our site on a mobile device, so we should make sure that it works there.

Therefore, we should test it on the responsive view on Chrome or other browser’s development console to make sure that it’s mobile-friendly.

There definitely shouldn’t be microscopic text or UI elements when we look at them from our phones.

No Premade Templates

Sites made from the same premade templates all look the same, so we should steer clear from them.

Instead, we should build it from scratch with CSS grid, flexbox, etc. to get our site looking the way we want to.

Use it to Market Ourselves

A portfolio is a great marketing tool, so we should use it as such. It’s great for promotion.

Also, we should build a social media presence online so that we can promote it on our social media profile.

Just make sure that our social media profile has followers so that someone will actually see our site’s link.

No Broken Links

We should definitely fix broken links if we find any. If we have lots of links on our site, we may want to write a script to find all the broken links if there’re any.

Keep Our Portfolio Updated

We should update our portfolio is we have anything we want to show.

At least review every few months so that we can add or remove any projects that we want to show.

Think About Page Speed

Thinking about page speed is thinking about the user. Users don’t want to wait for anything to load, including our portfolio website.

Building a static site is probably a good bet for speed. Gatsby, Gridsome, Nuxt, Hugo, etc. are all good static site generators, so just take our pick.

Conclusion

If we can build a portfolio that’s fast and mobile-friendly, then more people are going to look at it. Our site should also be hosted in our own domain.

We should link to projects along with the code that’s in a repository.

Finally, we should promote it on our social media profile so people will see them.