Category: Careers

Watching video tutorials and reading books give us some understanding of what we watched.

However, if we just watch and read tutorials, we’ll never become a real developer.

In this article, we’ll look at what it takes to go from watching and reading tutorials to becoming a real developer.

Stop Looking at Tutorials

We got to stop looking at tutorials and reading the books. Just close all of them.

Then we have to resist the urge to go back to them again. We definitely don’t want to be copying code from those if we want to become a real developer.

Practice

After we close all the tutorials, then it’s time to start practicing writing code on our own.

We got to start with whatever we know and start practicing them from that. The easiest way to practice is to find some practice app ideas and then go ahead and start writing code to make those app ideas into reality.

It’s fine for them to be crappy. At first, we just want to get them to work. Then we can clean them up later.

This is where version control systems come in. We would want to set up Git repositories to hold our projects.

Then we have to learn how to commit code and revert if necessary. We can also see the full history of what we committed, so that makes tracking and reverting things easier since we can find them.

Next, we have to pick some app ideas. There’re many of them online. Some of the app ideas include chat apps, forums, payment trackers, and many, many more along those lines.

Just pick one and then start coding. Pick the languages, libraries, and frameworks that we know and then start building the project.

Whatever we do, don’t take too long thinking about what to build. It probably takes 15 minutes is enough.

Be sure to commit code along the way so we can revert if something goes wrong.

If we’re stuck along the way, then find help online. We can search in the search engine of our choice to find what we want.

There’re also chatrooms and forums like Reddit to ask for help. However, we shouldn’t go back and copy stuff from tutorials and books that we’ve watched and read before.

If we got everything working, then we should clean up our code by following some clean code principles like dividing things into small pieces and renaming things to meaningful names.

Also, we can enhance the user experience of our app by streamlining user workflows and making our app look better with some styling.

Why Do We Need to Practice By Building Apps?

We need to practice by building apps because this is what developers do a lot. They think of solutions based on problems and they solve those problems with code.

We should write code to solve problems ourselves to learn along the way. If we can write our own app from scratch by just looking up stuff online, then we’re a proficient developer.

At this stage, at least we got something to work. Next, we have to clean up our code that’s working so that we can write a clean code that everyone can understand.

Once we practice writing and cleaning up stuff, then we understand a lot more than if we’re just watching video tutorials and reading books.

They already give us examples, so reading them and copying from them isn’t going to us any good since copying from them don’t go through our brains too much.

We also get a feel for various parts of app building, including front end and back end development, and UI/UX design.

If we build a whole app from scratch, we’re forced to understand a bit of all those things. This will then become muscle memory if we worked on them enough.

Conclusion

To go from watching tutorials to becoming a real developer, we’ve to practice building apps.

We just pick an idea and build something from it. If we get stuck, we don’t give up. Instead, we search for help online until we solve our problems.

Most ideas are simple CRUD apps, so finding help for them shouldn’t be too hard.

Being a developer is hard. Not only we have to know technical skills, but we also have lots of soft skills that we’ve to get good at.

In this article, we’ll look at some ways that we can all become greater programmers.

Problem Solving

Developers, like many kinds of occupations, are there’re to help people solve some problems.

Therefore, we should hone our problem-solving skills all the time so that w can solve them quickly and elegantly.

Strong problem-solving skills can help us solve any problem that we have at hand.

Pair Program

Pair programming is a great way for knowledge to be exchanged between people.

It’s much better than sitting alone and trying to figure something out without any help.

Also, it gives us a chance to chat with other people, which is nice. Otherwise, the work would be very boring.

Meet Like-Minded People

Like-minded people are people that we can talk to when we want to chat.

They understand us and what we’re doing, so we should meet more like-minded people so we won’t be so lonely. Also, we can ask them for help.

Delete Dead Branches in Our Repos

Dead branches just clutter up our repositories and slow us down when we try to check out code. Therefore, we should remove them so that we can get some speed again when we have repositories.

Learning Every Day

Computer things and software all change fast. Therefore, we need to be ahead of the curve so that we can use new useful things before anyone else.

That makes us more valuable than the competition since we know more than they do.

If we become experts in something, then the opportunities will come. Everyone needs computer and software experts nowadays that can help them.

Get Clear Requirements Before Starting Something

To avoid doing useless work, we should get clear requirements on everything before starting work on something.

This way, we won’t have issues to deal with. It’s just much easier not to have to do all the things we did and then have to throw them away and do them again.

It’s just not a pleasant experience at all.

Don’t Quit

We shouldn’t give up problems easily since most problems have some difficulty associated with it.

We’ll figure out the solution eventually with some help. We shouldn’t give up too easily.

Have Expert Knowledge in What We Do Regularly

We should know what we’re doing regularly as a developer inside out so we can solve problems more easily.

Also, we should be incrementally learning new things so that we can be ahead of the competition when it comes to gaining knowledge and using them.

The tools in our brains will help us so that we can work without looking things up all the time.

Listen to Constructive Criticism

Constructive criticism is good. They help us get ahead by giving us wisdom from people that give us the criticism,

They help us be wiser and grow faster.

Also, we should be open-minded and try different things. Don’t resist new things. Instead, we should learn them.

Nowadays, most of the things that are released are incremental changes from the previous ones since the great leaps forward are already in the past.

Now lots of technologies have matured and don’t need to change as frequently or as big as they did before.

So learning new things shouldn’t be as hard.

Present Things

More often than not, we have to present things sometimes. We have to learn how to present things well.

Keep our presentations short and to the point so that we won’t bore people.

Also, speak confidently and look at our audience so that we’re actually talking to them.

Our presentation slides shouldn’t be filled with lots of words. Instead, just put in a few words and put them in some pictures. Don’t overdo transition and animation effects.

Conclusion

We should learn to clean up our code. Also, we should always strive to become wiser by taking constructive criticisms to heart. This way, we’ll learn and become an expert faster.

Also, to win an audience, presenting things is the best opportunity to do it.

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.

Being a One Trick Pony

Being a one-trick pony if definitely a bad idea. If we only know one thing, then we’re only useful at doing one thing.

That’s just not good since computer and software changes so fast, our skills will be useless in no time.

Therefore, we should learn whatever is popular if we want to continue to work as a developer.

It’s easy to learn new things if we build on our skills.

Trusting Customers to Know What They Want

Not all customers know what they really want. Therefore, we should get more feedback than from a single customer before adding, changing or removing any feature from our product.

Communication is essential to implement a feature that people use. We should also implement it in small pieces and test them with customers along the way so that we can make sure that customers actually like it.

It’s much better than working hard for a long time and having something that no one wants.

Requirements change all the time, so we should prepare for that. Being defensive is no good even though some developers do take that stance. We should help make our products better.

Winging It

We shouldn’t wing it as a developer. That means we should only do things if we know what we’re doing and why we’re doing them.

For instance, we shouldn’t try random things until something works to fix a bug without knowing why we’re trying something. We should know how the code works before trying something.

Also, we should think about all the ways that something can break. This includes edge cases, invalid inputs, bad formatting, etc.

We should have useful unit tests, version control systems, good methodology, and maintainable code.

Unit tests are useful for catching regressions. Version control systems let us revert our code if we messed them up.

A good development methodology will prevent us from doing useless things.

Maintainable code will be easier to change and fix in the future. The code should be built with clear architecture planned before it.

Wrong Person in the Wrong Team

Being in a team that fits us is important. Working in a team that doesn’t fit our skillset or personality is going to be unpleasant.

With respect to skills, we should make sure that we can actually do what’s required in the team so that we can actually produce something.

Also, team fit is also important. Fit reduces conflict and having people with similar personality make other teammates understand us better. This means more empathy.

Frustration, anxiety, and depression may result. This will make anyone’s life miserable. Therefore, we should find a team that fits our skills and personality.

Not Backing Up

Backing up is very important. We should always be prepared to use our backups to recover data.

Cloud systems and our own hardware are all fragile, so we should always be prepared for the worst.

This means having backups in multiple places so that we’ll always have them somewhere.

Ar least one backup should be in a remote location and some should be within our reach.

Also, we should make sure that data that’s backed up is only available to authorized parties.

Not Testing Our Code

Skipping testing is a bad idea since our stuff often doesn’t work out the way we expect.

This is especially apparent with code. We should prepare for code to fail.

Testing can be automated to take the burden off our backs, so we should also do that. However, that’s mainly good for regression tests.

If we’re writing new stuff then we’ve to test them ourselves and write the test to test for regression.

Trusting Other Developers’ Code

Trusting other people’s code may be a bad idea. Everyone can be careless, so we probably shouldn’t trust them too much,

That means we should always review other people’s code and solutions to check if there’re any issues with it.

Duplicating Features

If there’s already a feature available in our code that we can use. We should use it instead of reinventing the wheel.

It’s better to use time-tested code than writing new code that does the same thing but may have more bugs.

Conclusion

We should only write code when we know what we’re doing and why we’re writing it.

Also, reviewing other people’s solutions to check them for flaws. In addition, we shouldn’t duplicate features and use time-tested code.

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.

Commit to Doing More

Since we have extra time because we skipped the commute and don’t have to do anything other than work and have meetings, we should commit to doing more.

This way, we’ll convince everyone that we’re good workers even if we aren’t inside the office.

With all the extra time, we can do more and take more breaks.

Therefore, for developers, this means that we can take on more tasks and work harder than if we’re in the office.

This is also important since nobody can see if we’re working or not, so we got to get more stuff done so that people will be happy with us working from home.

Work When We’re the Most Productive

One great benefit of remote work is that we can take advantage of working at different times as long as we get stuff done.

Therefore, we should take advantage of that so that we can maximize our work throughput.

If we do have a time where we solve things a lot faster, then we should take advantage of that.

Save Calls for the Afternoon

The afternoon is good for calls since our brains can use a break after working hard in the morning when our brains are freshest.

Taking calls and meetings let us take a break since we don’t have to think as hard as when we’re debugging and looking at all sorts of weird issues that come up all the time.

This is especially useful for getting through the afternoon lull where we had lunch and we’re more tired than in the morning.

Plan Out What We’ll Be Working On Ahead of Time

We should plan out what we’ll be working on ahead of time since we don’t have anyone to guide us on what we’re working on.

Therefore, we should be planning this out ahead of time so that we can do them soon.

However, we can change the priorities so that we can do different things at different times.

This way, we won’t forget this and we can do them as soon as we planned them.

Listen to Music

We can play music while we work so that our environment won’t be too silent.

While we work, we can get the playlist that we can want and then play it so that it won’t be too quiet.

Communicate Expectations With Any Stakeholder

Since we’re working remotely and can’t see each other, we got to communicate everything clearly with us.

This includes the tasks that we need to get done so that they’ll know the progress of it.

If we don’t communicate, then no one knows what we’re doing, which isn’t good since we’re probably invisible to them even if we’re actually doing the work.

We don’t want to be invisible if we’re working remotely so that people will actually appreciate our existence.

Therefore, we got to know that we’re giving results by communicating that we’re doing something.

Prepare Meals

If we want to save money, we got to cook ourselves. We can make time to cook at home since we’re already at home.

Therefore, it’s a great idea to save money if we prepare our meals at home.

This is another great thing that we can do if we’re working from home.

Pick a Definitive Finishing Time

At the end of the workday, we got to cut off any work things from our lives for the next few hours until we go to sleep and wake up again.

This way, we have actual times for breaks and then we can do something else like hobbies and anything else that we want to do.

Keep the TV On In the Background

TV shouldn’t come in the foreground until we’re getting off work. TVs are distracting and it’s especially bad if we’re doing hard things like debugging and running things in production.

Therefore, we should turn it off and just focus on work.

Conclusion

We should focus on doing work and remove all distractions. Also, we should save money by preparing meals and plan out what we have to do ahead of time so we don’t forget about that stuff.

Also, TV isn’t very useful for most people, so turn it off and, finish our work, and then turn it back on.

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 back end developers make.

Deploy on a Friday

If we don’t want to fix problems on the weekend, then we shouldn’t deploy on Friday.

Any deployment is risky and we should always think twice before doing if it’s not an emergency.

Things never go the way that we expect. And we definitely don’t want to ignore anything bad that comes up on the weekend and have angry customers to deal with on Monday.

Bad Input Validation

Server-side input validation is important. They serve 2 purposes. We need them to ensure security and also to prevent corrupt data from being saved.

We have to prevent SQL injection issues so that attackers can’t run malicious code to do whatever they want in our databases.

Also, we should validate input data to make sure that the data is in the proper format that we’re looking for.

If we don’t, then we’ll probably run into problems in some other places.

Most back end frameworks should be able to do both out of the box so that we don’t have to write all the code from scratch to do all that validation.

Authentication and Authorization

Authentication and authorization are 2 different things. People may not be aware of that.

Authentication is just checking for the ability to be able to log into a system with valid credentials. Authorization is the privileges that we give users.

We should make sure that users aren’t authorized to do more than they should.

For instance, if they’re a regular user, then they shouldn’t be able to view other user’s private profile. That’s an authorization.

Authentication is just making sure that a username and password or anything else that we have to enter is valid so that we can log into a system.

Ignoring Performance and Scaling

Performance and scaling are always important things to consider in the back end. We don’t want our systems to time out when we’re dealing with too much data.

Therefore, we should consider caching, doing long-running jobs in the background, pagination, etc. These are things that’ll help us prevent overloading our servers.

It’s bad if our app is overloaded since it’ll fail before it can do what customers want.

Not Running Resource-Intensive Processes in the Background

Resource intensive jobs like report generation, sending mass emails, etc. should all be done in the background. They’re all resource-intensive and it’s hard to do them synchronously without holding up our app for a long time.

Users will be frustrated if they’re left waiting for a long time when we have jobs running in the foreground and keeping users waiting.

Therefore, we should create background jobs for these resource-intensive tasks and batch them so that they won’t overload our servers.

Also, we should move these tasks to run on their own servers so it won’t overwhelm the main app.

Not Optimizing Bandwidth Usage

We should minimize bandwidth usage in all communications. For instance, we may be sending large chunks of data or images between multiple remote servers.

To make the transfer process more efficient, we should compress everything before sending it to save bandwidth. Then they can be decompressed on the receiving server.

Using RESTful Anti-Patterns

REST API should follow some basic best practices. For instance, the HTTP verbs to match the database operations that they’re doing.

GET should retrieve data, POST should create data, PUT and PATCH should update data, and DELETE should delete data.

This way, no one will be confused as to what our code is doing.

Also, our endpoints have to send the right HTTP status codes. 200 series is for successful operations. 400 series for errors coming from client-side and 500 series errors for errors occurring on the server-side.

For instance, 401 is for unauthorized, 403 means that we’re forbidden to access a resource because of a lack of privileges, 404 for not found, 502 for timeout errors.

Conclusion

We should stop ourselves before committing these mistakes if we’re doing back end development.

We should think about performance, scaling, validating inputs, and returning errors with the right status code.