Category: Careers

Developers are always busy. There’re always things that come up like bugs and new features that we have to spend working on.

In this article, we’ll look at all the useless ways that we can spend our time as developers.

Social Media

A lot of social media is a big time sink. There’re always cat and dog pictures, and pictures of people going on vacation that we can stare at for a long time.

They don’t help us too much, and looking at photos of people on the beach while we’re working is downright depressing.

Therefore, we should get off social media and finish our work so that we can go on vacation ourselves.

Long and Useless Meetings

Many meetings that we’re asked to attend are long and useless. However, we’re stuck with it since somebody with power asked us to attend.

These are definitely productivity killers and the time we spend in these long and useless are times that we’ll never get back.

We should keep our meetings short and only attend the ones that we need to attend.

If they’re long and aren’t that useful, or if we have nothing useful to contribute, then find a way to get out. Most people are happier than we’re delivering things that sitting around doing nothing in useless meetings.

The shorter they’re the better.

Reinventing the Wheel

If there’re off-the-shelf solutions for whatever we’re doing, then we should use that.

There’re many libraries and frameworks in the world and they can probably do whatever we need already.

For instance, we probably shouldn’t be implementing our own lists or sorting algorithms for example.

A good sorting algorithm like quicksort takes specialized knowledge to implement properly, so we should probably leave it to the experts to implement it and then use their solutions.

Likewise, most data structures that we need have already been implemented by other people so we can just use them if needed.

This also goes for anything that has existing code written for it. Time-tested code is better than new code that hasn’t been tested for bugs.

We can implement something that we have implemented before from scratch to understand them more. But if we’re doing something for work, then we probably should just use existing solutions.

Fixing Spaghetti Code

Spaghetti code is bad because we don’t know what they’re doing. It’s a complete chaos and probably too complex and messy for us to comprehend.

If we have to deal with spaghetti code, then they probably just going to make our brains fry.

That’s not good at all since we can better use that time to implement new features to help customers or we can help other people that are stuck or behind on their work.

Therefore, if we have to deal with spaghetti code, we should replace them with new clean code, or find another place or team that doesn’t have spaghetti code in their codebase because this is bad code that tortures people’s brains.

Not Asking For Help When Stuck on a Problem

When we’re stuck for a while, we should ask for help. More likely, than not, someone can get us in the right direction.

Therefore, instead of trying things to get unstuck ourselves, we should find other people that can help us get unstuck faster.

Premature Optimization

If we don’t need to optimize something now, then don’t do it. We know that we don’t need it if we don’t run into problems in our own performance tests.

We can leave that stuff for later. However, it’s important to make our code easy to change so that we can do any optimizations that are needed when required.

Perfectionism

There’s no such thing as something that’s perfect. Therefore, striving for perfectionism isn’t a very good goal.

All we need is a good solution that works for our users. Of course, we should still think of the use cases that users go through when they use our app, but we don’t need to be obsessed with perfectionism.

We need to deliver our stuff and that’s much more important than writing perfect code.

Conclusion

Long and useless meetings don’t do us any good. It’s time that we can use to deliver things. Instead, make them short and useful or skip them.

Social media can be a big time-sink. We shouldn’t look at them if we have work to do.

Spaghetti code should be thrown out and replaced with some clean code. They’re just too hard to work.

Also, we should stay stuck on anything, including perfectionism.

Once they’re all eliminated, we’ll have free time to enjoy ourselves.

It’s easy for developers to make mistakes, but we can prevent them if we know them beforehand.

In this article, we’ll look at mistakes that developers make.

Trusting User’s Input

We should never trust users’ input into any software. Instead, we should assume that they’ll enter invalid data.

Letting them enter invalid data will contribute to corrupted data in our systems and we’ll run into problems later on.

Therefore, we should never trust them and validate any data that are entered by users.

This includes both client-side and server-side validation. Client-side validation is used to tell users that what they entered is invalid. But we also need server-side validation to prevent bad data from being saved to our systems since bad data can be entered easily.

Manual Tests

Manual tests should be minimized since they take so much time. It’s just annoying to test all features of our apps manually.

It takes a long time and it’s boring and repetitive. Computers are good at doing repetitive tasks. Therefore, we should let them do it.

We should write unit tests to test small parts of a system like functions and classes.

Also, we should write some end-to-end tests to test the behavior of the full system to see if they work well.

Skipping Documentation

Without documentation, no one would know how to do anything. We have to write documentation so that people will know how to do things like setting up a project locally.

Also, we need documentation for our product so that people know what it’s supposed to do.

More importantly, we should make sure that documentation is up to date so people won’t be misled by outdated documentation.

Skipping Logging

We got to log activities that are done by our systems so that we know what it’s doing and we can find out what things are causing issues when things go wrong.

With error logging, we can check for recurring errors and fix them faster.

Also, we need an audit trail so that we know what users are doing is what we expect and no malicious activity is going.

Being Careless as a Privileged User

Any privileged user has more power to do things. An admin makes have the power to mess up databases by modifying or deleting data.

Therefore, we should always think twice before doing that. Even if we have backups, it’ll be a pain to fix issues with data after we screw them up.

Also, we should be careful with any server operations. Even though many apps are hosted in sandboxed containers, we may still mess things up if we aren’t careful or if we don’t know what we’re doing.

Scattered Configuration

Configuration files should be in one centralized location so that we don’t have to look for them everywhere.

This way, we can find them easily and keep track of them easily. Making changes will also be easier if they’re in one place.

It’s also easier to safeguard things if there’s only one place to safeguard our configuration.

Hard Coding Values

We shouldn’t hard code values that are constants. So we shouldn’t have values written in our code as magic numbers.

Instead, we should put them in as constants so that we know what they’re for.

Burnout

To prevent burnout, we should always take breaks. Taking breaks lets us recharge and think about things in a different way.

We always need a vacation and they’ll be more productive than working nonstop since it’s easy to screw up if we work too long.

Not Learning More

Computer and software change all the time. We should learn more things so that we can use them later.

Sooner or later, we’ll have to learn them so we should just take the plunge now. Learning it fast will be a lot harder and more stressful since there’re probably deadlines.

Without deadlines, learning things is more comfortable, since we can learn at our own pace.

Conclusion

We shouldn’t make mistakes about when developers. If we’re too fixated at our jobs, then we’ll make these mistakes fast.

They’ll stifle our success since they’ll affect us negatively in one way or another. For instance, messing up user’s data is definitely bad and we can’t let that happen.

Letting our skills get outdated is also bad since we may become unemployable in the future.

Being a good developer is hard, but being a bad one is easy. There’re many ways to make ourselves a bad developer.

In this article, we’ll look at some ways that we can become a bad developer.

Assume There Are No Bugs in Our Code

Assuming that there are no bugs in our code is always a big mistake. It’s just impossible to have no bugs in our code unless the app it’s a very simple app.

Otherwise, we’re making a very bad assumption since it’s very hard to write any code.

Every line can do something that we may not expect. If we don’t think hard enough and take into account all the cases that something can go wrong, then something will go wrong.

Most apps are at least thousands of lines if they’re used by people in production and people are paying for it, so we better look at everything line and think of all the edge cases and risks that can arise from our code.

Computers are dumb. They just run the code that’s in our programs, so we shouldn’t assume that there’re no bugs since every line can go wrong and computers can’t read our minds.

Write Code Without Reasoning

Before we put code into a file, we should make sure that the code makes sense before we put it in.

We can’t just try random things and hope that something works. Doing that definitely makes us a bad developer since we’ll probably end up with something that doesn’t work.

Also, the code we put in must serve a purpose. Otherwise, the code is useless and they don’t help anyone.

Take Pleasure in Writing More Code

We shouldn’t write any more code than we need to. The desire to write more code should be stopped.

Writing useless code just makes our code more complex and long and annoys other people reading the code.

The more code there is the more mistakes that we make. Each extra line of code adds more risk for bugs and undesirable behavior.

Therefore, the more code there is, the more ways we can screw up. More code also adds more burden of testing, code reviews, and many more tasks that we can do less of if we have less code.

Writing Code for Machines Rather Than Humans

Writing code for machines will get us trouble eventually. Code with names that we don’t understand or badly formatted code will get us eventually.

No one including the write will understand it given enough time.

Another way to write code for machines is spaghetti code. Spaghetti code is just code that has messy workflows, branching, and whatever other ways we can think of to make a mess.

That’s just not acceptable by any means since they are impossible to change because of the mess that the code had turned to.

By writing very long functions and classes, we’re also writing code for machines. We don’t want that since again, only a machine can get it.

No human can read long functions and classes and understand it completely. Therefore, it’s one more thing that we should avoid.

Instead, we should look at the principles of Clean Code and write our code based on that. The first half of the book applies to any programming language, so focus on the first half.

Thinks Emotionally

Thinking emotionally definitely makes us a bad developer. We shouldn’t take constructive criticism personally.

They help us improve our code. Also, we shouldn’t let our egos get in the way of rational thinking. We should take useful suggestions and apply them if the way we did things were deficient.

Also, we shouldn’t just code by feeling. We should test our stuff so that we can be sure that stuff works the way that we expect them to.

Conclusion

There’re many ways to become a bad developer. We can assume that our code never has bugs.

Also, we can let our egos and feelings get in our way of rational thinking.

Furthermore, we can write code that machines can read with bad formatting and non-descriptive names.

Finally, we can just put code that’s useless or has no reason to be there.

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.

Know When to Stop

We can’t just keep writing code forever. We got to take breaks and deliver something eventually.

Therefore, we should know when to stop and consider our work to be done.

We got to step back and look at what we have critically. If it’s not good, then we’ll replace it with something good.

Also, we should add extra things that aren’t needed in our code. This way, we don’t do unnecessary work that’s not needed.

Investment in Knowledge

Investing in learning can never go wrong. Technologies are updated all the time, so we should always be learning things so that we’ll keep getting better and wiser.

This way, we’ll become better than the competition and we can get things done faster and better.

If we stick to our old ways, then we may be sticking to habits that may not produce the best result or be the most efficient way to do something.

Therefore, if we keep learning, then we’ll keep getting better and finding new ways to do things better and faster.

Also, old knowledge may get out of date and becomes useless, so we must also stay up to date for that reason.

Otherwise, we may end up being no help for anyone and that means no work for us.

Our Knowledge Portfolio

A knowledge portfolio is the assortment of knowledge that we’ve learned over time.

It’s like an investment portfolio, but instead of investing with money, we invest by spending time to learn things.

We got to invest regularly to see our knowledge grow. This should be made a habit.

Diversification is a key to success just like an investment portfolio. Never put our eggs in one basket since we don’t know when something will become useless.

This ensures that we maintain long term success.

We should hedge against risk by balancing our knowledge portfolio by investing in low-risk investments to mitigate the risk of high-risk, high-reward investments.

Now, there’s nothing that’s really risky with investing in learning knowledge as we do by investing our hard-earned money on our financial investment portfolios, but we should prepare for things to go out of date.

Once they go out of date, then we have to learn things all over again.

Building Our Knowledge Portfolio

We build our knowledge portfolio just like we do with our financial investment portfolio.

We’ve to put money on it regularly. A small amount still helps, and a bigger amount is even better. We spend time learning and understanding new things.

Diversification is slow important since technology changes a lot, so we’ve thought about that and learn new things to hedge the risk of old knowledge going outdated.

Nowadays, technologies are maturing so everything moves more slowly, so it shouldn’t be too hard to learn things incrementally.

Diversification is a way for us to manage risk. We should think about how to manage risk by balancing high risk, high reward items and low risk, low reward knowledge.

We should never put everything in on basket.

Learning New Technologies Before it Becomes Popular

Learning new technologies before they become popular will let us reap great rewards.

This is how we get opportunities before anyone else. If we learn emerging technologies before anyone else, then we’ll get a chance to help people in no time.

This is because the demand for people that need help with these kinds of technologies is increasing, but the people that know how to work with them is few and far between,

Therefore, this is our chance to shine. It’s a great reason to stay up to update more than anyone else.

Review and Rebalance

Like a real financial investment portfolio, we got to review the performance of the investments in our portfolio and change them out the investments that aren’t doing so well and try other items that may perform better.

It’s not as risky as an investment portfolio, so we can just keep learning things until something sticks and we can help people with it.

We just got to keep learning and focus on different technologies at different times.

Conclusion

We should treat learning new knowledge as we do with our financial investment portfolio.

They’re both investments and they’ll both pay off if we keep track of their performance and keep everything up to date.

With a learning portfolio, we just keep learning and find out what people need.

We keep doing that until we get the opportunities that we want.

Also, we should know when to stop so that we can deliver something in a reasonable timeline.

Being a good remote worker takes a lot of discipline. We’ve 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.

Keeping Regular Office Hours

Keeping regular office hours important to control the amount of work that we’re doing regularly.

This lets us take breaks sometimes and work at other times.

Interruptions can be kept to a minimum by working when there’re no meetings scheduled.

All we have to do is to keep a block of time aside to work for a few hours as if we’re in the office.

Plan and Structure Our Workday

Since organizing our schedule is mostly on when we’re working remotely, we’ve to structure it so that we can get stuff done without forgetting to do things.

This means we got to keep our mind sharp and our memory is more important than ever since we’ve to remember when meetings take place since nobody will walk by us to tell us to go to meetings like if we’re working in an office.

If our memory isn’t the sharpest, then we have to write everything down and give us plenty of reminders.

Dress Up

We still got to dress up so that it feels like we’re doing work even if we’re working at home.

It makes us feel like work if we’re wearing work clothes.

Set Aside a Designated Work Area

A designated work area is definitely something that we need. We should at the same spot every day to have a routine.

It’s should be a quiet place where people can’t walk in and out. We don’t want to have people walking in and out in meetings.

Take Breaks

We should schedule a time for breaks throughout the day. This way, we’ll stay sane while working on tasks at home.

There’s just no way that we can work without breaks. We still need to walk off for lunch breaks and toilet breaks as if we’re working at the office.

Eating while working isn’t healthy. It also distracts us from working so we may make mistakes.

Avoid Distractions

This is another reason to have a quiet place to work at home. We got to remove those distractions.

There’s no excuse to have any distractions since we can completely control our environment.

Therefore, when we’re working, we should have a computer with work stuff like our text editors, IDEs, and terminal windows open.

Close all the things that distract us like social media, YouTube, and everything else and just get to work.

If we’re done with our work early, then we can take a break earlier. That’s one thing that we should take advantage of. The faster that we work, the more breaks we can take.

We won’t look lazy if we’re taking too many breaks at home since we got all our stuff done and no one can watch us taking breaks.

Get Started Early

The earlier we start, then the earlier that we can take a break. That’s one good reason to get started earlier.

Also, since we don’t have a commute, we can work a few hours before we have any meetings when our mind is freshest and we don’t have any meetings.

Early morning is a great time to work if we work from home since we can actually use that time to work instead of waiting for the bus or being stuck in traffic.

Don’t Stay at Home

In addition to working from home, we can also work from other places like coffee shops, libraries, and other places with wifi if they’re open.

The change of environment is less boring and it lets us go anywhere we want to work, which is nice.

Make it Harder for Ourselves to Mess Around on Social Media

Since no one is watching us work, it might be tempting to be messing around with social media during work hours.

However, that’s a bad idea since it slows down our work and removes the focus that we all need.

Developers already have so many windows and browser tabs open, we don’t need more of them to distract us.

Therefore, leave them for when they’re done.

Conclusion

We should keep our focus by removing distractions and don’t mess around with anything other than work.

Keeping office regular office hours and working early is good since our mind is fresh and we don’t have any meetings.