Author: John Au-Yeung

Interviews are always hard. It’s especially hard if we have to get technical and solve problems on the fly with code.

In this article, we’ll look at some tips to get good at interviews and nail them.

Get Good at Least One Language

Getting good at one language we don’t have to worry about language syntax in technical interviews.

Although many will allow pseudocode, we still have to know basic syntaxes like loops and how to create objects and hashes.

Therefore, we should just practice coding with one language until it’s muscle memory.

We should aim for solving tough practice problems from sites like LeetCode and HackerRank so that we can solve them when we’re asked those problems.

Read Books

Books like Clean Code and The Mythical Man-Month are always good reads so that we can write clean code and answer design problems that may be asked in technical interviews.

At least we’ll know enough to talk about something in them to make us sound more knowledgable.

Study Trivia Questions

There’re lots of trivia questions that interviewers may ask. They include things like functions that are in a language’s standard library and trick questions about the language.

For instance, JavaScript has lots of tricky parts in their language that were leftover from the past.

However, they still linger today, so that someone may still ask about them.

Multiple Practice Projects

We need to practice with projects so that we know what building real apps are like in a job.

They should do things like a real business app would do like calculations and saving things to a database.

There’re plenty of app ideas that we can use to build practice apps with, so we just have to start building with our favorite language and libraries and frameworks to need it.

Also, we should write some tests so that we’re familiar with writing automated tests and we can even should those off to interviewers to show how much we care about writing software.

Then we can host them all in the cloud so that people can see them when we show them off to people.

Learn About What the Company is Doing

We often get asked about what the company we’re interviewing for does. Therefore, we should know what they do before we go into an interview.

This is basic knowledge so we should definitely before going in.

Travel to Interview Early

We should go to the interview location early to reduce the chance that anything bad like traffic jams or bus delays make us late.

Then we wait until around 15 minutes before the interview starts before going into the office so that we won’t be waiting in the workplace for too long.

Start a Conversation

Nobody likes a boring person, so we should start some conversation with the interviewer so that we have a 2-way dialog.

Having silence isn’t good as it makes for an awkward presence. Keep silent doesn’t bode well for how we’ll fit on the team.

Ask Questions

If we have questions, we should ask. However, we should probably leave the pay and benefits questions until we get an offer. Since getting an offer is far from a sure thing, we should put those until we actually get an offer.

However, anything else is pretty much fair. We may ask about things like the development process, how code is managed, length of sprints, project timelines, etc.

Showcase Non-Technical Skills

Technical and non-technical skills are equally important. Soft skills is a must-have, so we should show them to our interviewers.

Also, it’s good for interviewers to know that we may potentially fit in their team.

We should think about our soft skills, in addition to our technical skills. Whether the interviewers choose us or not probably depends on both technical and soft skills.

Soft skills include things like communication and thinking, which we can show to interviewers in an interview readily.

Conclusion

Practicing our technical skills with projects and sites like LeetCode and Hackerrank is probably a good idea before an interview.

Also, we should be good at our soft skills as well. Skills like communication and thinking are great assets.

We should have lively and not awkward conversations.

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 the ways that we can get better as developers.

Build a Big Side Project

Side projects are great for practice. Bigger ones mean more practice. It’ll give us so much practice that whatever we used will become muscle memory.

We can build bigger apps like a Facebook or Reddit clone. If we’re building our own Facebook clone, then we can build all the features including chat and friends features.

If we’re going to build a Reddit clone, then we build out the subreddit and moderation capabilities.

These are examples of a big side project that’ll give us lots of practice. We can build it with the frameworks and languages that we like to learn more about and then so that we can understand them more.

Contribute to Open Source

Open source projects are everywhere and they all need help. So we should contribute to them so that we can learn and they can get help.

That way, we’ll learn about forking repositories, making pull requests, committing code, and more.

It also means that we can follow their conventions and guidelines.

Working on community packages is also different from working on a regular job so we can get different kinds of experience than a typical job.

Alternatively, we can build our own packages and reveal the source.

Look at Other People’s Code

Other people’s code provides us with wisdom that we probably don’t have. It’ll expose us to different styles of programming and show us things that we can do with a programming language, library or framework that we probably haven’t seen before.

If the code sucks, then we can also learn from them and avoid the bad practices that are exhibited in the code.

Understand Programming Design Patterns and Principles

There’re many design patterns and principles that we can look into.

Some principles include SOLID, KISS, YAGNI, MVC, and many others.

SOLID is a good one to know since it’s a good way to organize our code. It means that we divide our code into parts that do one thing.

Also, code shouldn’t open for modification but should allow for extension.

It also enforces designing code by contract by having a fixed interface while the code implemented it can change.

Abstractions are also encouraged and make high-level code independent of the low-level details.

KISS stands for keeping it simple, sweetie. It’s obvious, simple code is better than complex code if they do the same thing.

YAGNI stands for You aren’t gonna need it. It’s similar to KISS and it’s all about not adding code unless it’s necessary.

MVC is pretty much the standard pattern for back end apps with the model being the data layer, view for presentation, and a controller to connect the model and view together.

Learn High Demand Skills

This goes without saying. We can always learn high demand skills in areas that we enjoy working in so that we can get a job we like.

If it’s something we don’t like then we won’t enjoy it. And if it’s something that has no demand, then there’s no job that uses it.

So it has to be both together.

Design Skills

Design skills can be learned by anyone. We can focus on making things prettier by learning from designers and then applying when we’re developing UIs.

User Experience

We’re building things for customers, so we should always empathize with the customer and build some that have good user experience so that they’ll enjoy using it.

Simplicity, usability, consistency are all important principles with user experience.

Conclusion

Building a big side project will give us plenty of practice until what we do becomes muscle memory.

Looking at other people’s code no matter if it’s good or bad. We just need to look at them and learn lessons from them.

If it has good parts then we learn them. If it has bad parts, then we learn not to do them.

Non-development skills like design and user experience are also important and we should learn them as well.

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 better ways to learn, communicate and think like a developer.

Seizing Opportunities for Learning

Taking on personal challenges to find answers is the key to success.

There’s no better way to learn by challenging ourselves and practicing to solve problems.

The web is out there and we can search it with our fingertips.

Also, we can go the traditional route and visit the library if we like physical books.

In addition to reading books, we got to practice what’s mentioned in books or whatever material we’re looking at. This way, whatever we learn will actually stay in our minds.

There’s just a no better way to become better than by learning by getting our hands dirty and challenging ourselves.

The tough challenges are what we remember the most.

Critical Thinking

Even though books and online materials are good, we got to be mindful that not everything in books and online is good or correct.

Therefore, we should keep an open mind and think through everything before accepting whatever is in them is the right answer.

In addition, we should keep in mind that lots of things are commercialized. People that can pay for ads can put their results on top or have a bigger space than other entries in a search engine.

We should keep that in mind so that we can think about them before accepting whatever is presented.

What we read and hear aren’t always truthful or correct. Content on social media and websites are often biased or misleading, for example.

Therefore, we should think about those carefully as well.

When we see or hear something, we should as specific questions.

Then we should look for answers to the questions we raised.

We can then ask those questions privately or publically depending on our preference.

Communicate

Communicating is very important. We got to keep people up to date on what we’re doing so that we won’t step on each other’s toes.

Also, we have to clarify the requirements of what we’re working on so that we can do them properly.

Our code is also a way that we communicate. It’s communicating by explaining what we’re trying to do by listing out the operations that we’re trying to do to implement some features.

We write proposals and memos to make suggestions for solving different problems and advocate for ideas.

Since we have to communicate to get anything done as a team, we got to do this well.

We got to know to say when we’re communicating. We got to think before saying or writing anything.

Technical documents should be planned our be writing. Make sure that we didn’t miss anything in our documents so that people reading them won’t miss what we’re trying to convey.

Know Our Audience

We got to write and say things that target the audience that we’re communicating to.

For instance, we would communicate differently if we’re communicating with a technical or non-technical audience.

This way, people actually understand what we’re saying when we tell them something.

This is the same for writing. It’s not just about saying what we thinking we want to say, we also have to make sure that we have to know our audience so that they’ll understand what we’re saying or writing.

Choose Our Moment to Convey Our Message

Choosing an appropriate time to say something is important.

It’s best to choose a time when people are focusing on work to talk about work stuff for example.

No one wants to talk about non-urgent work things when they’re off. They all want a break.

We should just make sure that people that are listening to us actually want to hear what we’re saying.

Conclusion

Communication is pretty important since most of us are working on a team. We got to our best to communicate so we won’t run into issues with miscommunication later on.

Also, we should take the best moment to communicate our message.

Finally, we should take everything at face value. No matter what we hear or see, we should think about them before accepting them.

We should ask questions whenever we can.

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 learning habits we can adopt and how to adopt them.

Learn at Least One New Language Every Year

Learning one new programming language a year would help us see things from different perspectives.

We’ll see the similarities and differences between languages.

Also, we’ll learn about different paradigms that different language takes to help us write programs.

For instance, Java has a stricter object-oriented approach, whereas JavaScript takes on more of a mixed approach with a mix of functional and object-oriented programming.

Therefore, with such large differences that different programming languages have, we’ll definitely open our eyes by learning a new programming language each year.

We can learn them thanks to the wealth for free learning materials available online.

Read a Technical Book Every 2 Months

Reading technical books every 2 months will help us learn more technologies than if we just do the same thing every day.

There’re so many books out there about many topics that we can pick up a book easily and learn about everything we want.

Better yet, we can take notes and practice what they’re teaching. This applies to any technical book whether they’re about hard or soft skills.

We can always practice by using the knowledge learned from books at work or outside.

Even better, we can share our knowledge by blogging about them and making practice projects.

Read Nontechnical Books

Nontechnical books enrich our knowledge and wisdom just like technical books do.

We’re people, so we should know more about humanity so we can work with people better and see the world from a different perspective.

Participate in Online and Local Developer Groups

With the Internet being ubiquitous, we can open our eyes by joining online groups to learn more from other people.

Also, we can still join local developers like we always do to exchange our knowledge.

This way, we’ll always learn from each other and help people in ways that couldn’t just by staying at work.

It’s also a great way to find opportunities that we don’t expect to find before.

Experiment With Different Environments

We should learn how to use different operating systems and expose ourselves to different environments.

Even if we don’t use it much now doesn’t mean that we won’t have to know about them later.

Every place uses different environments, so we’ll bump into them eventually.

Therefore, if we’re using Windows a lot now, then we should consider using Mac or Linux.

We should never assume that everything will remain the same anytime or anywhere.

This applies to anything, like runtime environments like Node.js, PHP, or Ruby, or text editors like Visual Studio Code or Sublime, etc.

We can try different things to see what we like and learn a bit about each.

Staying Current on Technologies

We got to stay current on technologies since we don’t know when we’ll need to use them.

This is just a given since technologies change all the time.

We can read lots of stuff online with the proliferation of the Internet. Also, there’re tons of tutorials on free video sites like YouTube, and we can also pay for courses on sites like Udemy or Pluralsight.

The possibilities are endless, so we got lots of things to learn and practice.

Practicing is also important for internalizing knowledge. Otherwise, we probably just forget about them in no time.

Learn About the Ins and Outs of a Technology

Learning about the ins and outs of technology will pay off in dividends in the future.

We never know what we’ll like or when we’ll use them until we learn about them.

It’s the way that we find unexpected discoveries and help people in the process.

There’re many ways to learn about technologies. There’re forums like Reddit, and there’re many blogs published in the world that we can learn from.

Also, we have traditional books whether they’re available electronically or physically.

They’re both great resources for us to learn from. However, ebooks are searchable so that’s a big benefit over a physical book.

Conclusion

We should keep learning things as developers. There’re many ways to learn, including forums, blogs, books, videos, and many more ways that aren’t mentioned here.

To get a different perspective on technologies, we should learn a new programming language every year to get a different perspective on different programming paradigms.

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 newbie programmers make that we can all avoid.

Not Using Debugging Tools

Debugging tools are there for a reason. It’s there for us to look at how each step of our program is run and what variables are holding as their value.

We can just do something simple like a console.log in JavaScript to look at the value of variables in the place that we’re debugging.

Not Backing Up Our Code

Backing up our code is important. We should learn Git so that we can hold our code in both local and remote repositories.

Git is a great version control system, so be sure to commit our code regularly so we can track our changes and revert back code to good code easily.

Assume That We Know Everything

There’s no way that we can know everything or even a small part of a domain.

We all got to keep learning and learn what’s outside of what we’re doing regularly.

This way, we’ll know more, be wiser, and can use some of that stuff at work.

We can learn by reading other people’s stuff, tutorials, and may other sources from the Internet.

Assuming Expressions in “if” Need to Contain a Comparison

We definitely don’t need to have a comparison expression in our if statements.

All we need in most languages is an expression that returns a boolean value.

For instance, in JavaScript, instead of writing:

if (condition === true) {  
  //...  
}

We can just write:

if (condition) {  
  //...  
}

We don’t need to compare boolean variables in if statements.

Writing Big Functions

Big functions aren’t good. They’re hard to read since they have many things under one umbrella.

Therefore, we should split them up into smaller functions with meaningful names.

Small functions are easy to read and debug.

Also, we should make sure to name them descriptively and make them pure functions whenever possible.

Pure functions are good since they always return the same output for the same sets of inputs.

Also, they don’t commit side effects. Side effects are actions that take place outside of a function.

Half Baked Knowledge

Usually, newbies don’t know everything completely, which is normal. Unless we go learn the rest of the domain ourselves, we aren’t going to be learning everything completely.

We can’t depend on people to tell us to learn, so we’ve to go learn them ourselves.

It’ll make us more useful inside and outside of work.

Forget About Pen and Paper

We got to write stuff down sometimes so we can break down hard and complex problems.

Problem requirements and limitations got to be understood and we might have to break them down on paper.

Data structures problems are also better solved on paper.

We may also write down all the cases of a problem to make sure that we didn’t miss any edge cases.

And pseudocode always helps us with outlining the code that we’re going to write.

So we should use a pen and paper to solve our issues.

Failing to Get the Basics

The basics are always important. Therefore, we should take into account all the basics and learn them properly.

We definitely should review them so that we don’t forget about them.

Things like algorithm performance and complex are always relevant, for example. We don’t want our code to be too slow.

Also, we shouldn’t catch everything to cover up the errors in our code. Instead, we should write our code properly so that our code is more robust.

This way, users won’t be frustrated with weird behavior, slow performance, or other issues.

Trusting the User with Inputs

Trusting the user too much is definitely a mistake. This is users usually don’t input everything right.

So we should check to see if their inputs are valid. Also, any place that malicious code can get into our system should be checked and whatever we do we should do things like input sanitization from preventing any malicious code from running.

Conclusion

We shouldn’t assume that we know everything. Trusting users to input everything correctly is also a bad assumption.

Also, we should expand our current knowledge and review the basics once in a while so that we won’t forget about them.