Author: John Au-Yeung

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.

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.

Over-Communicate

Communication is more important than being inside an office since nobody can see what we’re doing usually.

Therefore, we need to update people on what we’re doing so we won’t be stepping over each other’s toes.

Also, we should aim to be available to answer messages when we’re working so that we won’t keep people waiting.

We can answer any time since we can multitask on our computers. So we should check our messages often and answer them.

Invest in Reliable Technology

Working from home is all about being on the computer in today’s world. This is important for everyone since this is what we need to get anything done.

We should buy a fast computer so we won’t have to wait for things to load all the time and we can open more windows.

Since developers have to build and reload code and run tests all the time, we’ve to make sure that our computer does all those things as quickly as they can.

Also, as developers, we look at a million windows all the time, so we probably want a second monitor so we can look at more things side by side.

Also, we should have high-quality headphones to take conference calls.

A webcam may also be useful if we need to hold video conferences.

Comfortable keyboards and mouses are also needed since we’re going to be using them all the time.

Of course, most importantly, fast and reliable Internet is also very important since all our work is going to be done over the Internet.

Therefore, we should put money on fast and reliable Internet.

Lean On Our Community

We can still socialize while we’re working remotely. We still have communication tools to communicate online. So we can use them to socialize with people.

This way, we don’t have to stay lonely for long and be happy again.

Also, we can take a walk with our neighbors and it’s another way we’ll stay sane while working remotely.

Improve Our Workspace

We can’t control our workspace in the office since we don’t own it. However, we can do that in our own place since we can control it.

We can switch out a crappy chair for a good chair. Also, we can get a desk that fits our needs.

So instead of having a cramped cubicle or even worse, an open office, we can switch them out for something better,

If we want to work without noise and distractions, now it’s our chance. We can get whatever we need like foams, noise-canceling headphones and other things to filter out noise.

We can also work whenever we want as long as get something done, so we can get chug through our work faster.

Take Time for Self-Care

Self-care is also very important. We should make sure that we take breaks and don’t work too hard.

It might be tempting to do that since everything is on the same computer and we don’t have to go in and out of the office to do work.

We should commit to a fitness schedule so that we still get exercise even if we’re working inside.

Take walks, eat healthily, and take breaks.

Eating healthily should be even easier since we don’t have to eat unhealthy, carb-heavy food like granola bars and cereals that are stocked in the office pantry all the time.

Instead, we can have things like eggs that are healthier since they have fewer carbs to make us tired and fat.

This way, we won’t be as tired or fat even if we have to sit down and work for this whole day.

Conclusion

To make us work faster, a fast computer and Internet connection is a must.

Since everything is done over the Internet, those are needed. Developers need a fast computer to build and test code quickly. Also, since we often open lots of windows, we got to have multiple monitors. There’s no better so let us see things side by side.

Also, we should take care of ourselves. Improve our home office space by getting a better chair, desk, and filter out noise.

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.

JavaScript

JavaScript is the language of the web. It powers all web front ends and it’s increasingly used more for back end and system developer with Node.js

The language has been getting better in the last few years with modern features like modules added.

Also, there’re lots of syntactic sugar like the class syntax to hide any confusion from prototypes. The destructuring syntax lets us assign properties from objects and arrays to variables directly.

The spread operator is good for merging and copying objects. Arrow functions get rid of any confusion with this .

And let and const lets us define variables and constants that are confined within a block.

Those are all great feature that makes JavaScript development or enjoyable than ever.

Also, there’re great front end frameworks and libraries like React, Angular and Vue that make front end development even easier.

It’s also the language for making HTML5 games. It can be used with Unity as its scripting language, for example.

NPM hosts lots of useful libraries that we can install easily, and it’s a great package management system for most JavaScript apps.

Big Data

Most web apps host data. And so we need to be able to work with data so that we can make them useful for us and for our users.

Data is collected everywhere and they need to be analyzed so that we can make our decisions from them.

With the Internet, data is aggregated from anywhere. Being able to use them to make decisions is a great benefit as long as it respects people’s privacy.

We can analyze all the collected data with scripts written in Python or R, or build a full-fledged app to host apps.

Full Stack Development

Full-stack development is where we develop both the front end and back end. A bit of knowledge on both is good since they’re too tied together.

Most apps need the back end, and if we work on the back end and front end, we can build full features ourselves without waiting for other people.

Getting results faster definitely makes us an asset to other people or companies.

Back end frameworks and SQL are great to learn since they’re used together often to build apps. Frameworks like Spring, Django, and Rails are used a lot by companies and individuals to build apps.

So basic knowledge of them are useful.

On the front end, JavaScript rules and as we saw in the previous section. JavaScript has a great ecosystem and has improved a lot in the last few years.

So it’s ready for big apps.

Furthermore, JavaScript can also be used on the back end with great frameworks like NestJs, Express, Koa, and more.

It’s great for building back end apps as well.

DevOps

Sooner or later, we’ll have to put apps into production and this is where DevOps comes in.

We can deploy things and manage them ourselves if we know some DevOps.

Some AWS knowledge is helpful, and also Docker knowledge is also very useful. Docker lets us run apps in their own isolated environment so that we don’t have to worry about what we have in the host environment.

Also, we don’t have to worry about conflicting dependencies or differences in the runtime environment for each app.

Everything is done in an automated manner. Once we wrote scripts to automated our builds, we can take a break. That’s another great thing about knowing some DevOps skills.

Conclusion

Developers should learn about all that they can learn if the skills are popular. They include JavaScript since it’s the language for front end and also for many other kinds of apps.

Also, we should learn the full stack if we want to be useful to more people. It’s better than learning just one part of the stack since it’s hard to implement features ourselves if we only do part of it.

Finally, we should learn how to wrangle data so that we can use whatever data is collected to make better decisions.