“A smart man makes a mistake, learns from it, and never makes that mistake again. But a wise man finds a smart man and learns from him how to avoid the mistake altogether.” — Roy H. Williams
No matter what industry you’re in, your website is the world’s view into your business. Whether you’re working on a redesign or building it from the ground up right now, there are a variety of things you’ll need to ensure its success.
Whether you are a newbie or an experienced web developer, you must have committed at least a few of these common web developer blunders. It just takes one silly mistake to land you in blunder when it comes to programming. So, take a look through these popular mistakes you need to keep an eye out for.
- Too Many Comments Or No Comments At All!
Comments are the wild card of the code. As mentioned earlier, anything done too much is bad. The same thing applies to comments. Adding comments about obvious things will only make your code lengthy. Not writing comments will make it difficult for you as well as other people to understand the purpose of the code.
How to Avoid: Name your functions and arguments appropriately so that there is a lesser need for the comments. Only add comments where the scope of confusion can arise and adding comments will give it clarity.
Here’s a quick tip: While writing a comment instead of “what” is this code doing, answer “why” this code.
2. Making Core Information Hard To Find Hi-tech website?
It may look cool. But what’s the point, if your users are not able to find the information that they are looking for? They have landed at your website for a reason: to learn more about the brand or to gain some information about the business. If the information is not easily accessible, they may leave your site.
How to Avoid: Display your information properly so that it’s easy for the users to find the information they need. Try to add important information from the homepage to the product or service pages, or any such page that will help the user gain some more information.
3. Time or Processor Consuming Actions in Request Handlers
Sending emails based on user action from the user request handler? This can be a mistake. For lesser requests it can be carried out easily but what happens when you scale your system and get a large number of requests sending confirmation emails. You face challenges like quota exceeded, connection timeout or your application response time reduces drastically.
How to Avoid: Having an external mailing service can be implemented for sending emails or notifications.
4. Too Much Refresh
Does your webpage need refresh action for every interaction? Every time your page is refreshed, it requires complete resetting of the page. Unnecessarily the action of downloading the page will get repeated and the user’s time will be wasted.
How to Avoid: Identify if posting back to the server is truly required. Few things can be implemented such as using client-side script where there is no dependency for server-side resources. Ajax techniques can be adopted or you can even make use of popular JavaScript libraries/frameworks that make carrying out of these methods much easier.
5. Overlooking the Nonfunctional Requirements
It’s quite common to forget about some important aspects such as security and performance while you are trying to deliver something.
How to Avoid: Prepare a checklist and keep a track of these things so that you don’t miss out on the important nonfunctional requirements.
6. Building Non-Responsive Design
Most of the users browse the websites on their mobile devices, tablets and laptops. These devices can be of any screen size. Thus, it is important to keep this factor in mind while you build the website. If your content is hard to read on their devices there are higher chances that your website visitors will give up on your site.
How to Avoid: Always keep in mind that your design should be multi-device supported. Using media query, you can build responsive website designs.
7. Copying/Pasting Code Blindly
Some or the other time, you must have blindly copied the code from the internet and pasted it, although you know it’s not right to do so. If you don’t know, let me tell you simply copying pasting will take you nowhere. When you code, you must know if something does or doesn’t work.
How to Avoid: Write code by yourself so that you’ll learn why and how it works. Even if you take help from the internet, understand the code and its logic before you make use of it. This way you will learn about the working of the code in depth.
8. Ignoring Cross-Browser Compatibility
Gone are those days when only Internet Explorer was used to browse the websites. In fact, on today’s date, there are many other browsers apart from Firefox, Chrome, Safari, etc. that users prefer for accessing sites. As a developer, it’s your responsibility to make sure that the website looks apt across all desktop/mobile browsers. If your site functions nasty in your user’s browser, they might lose interest in the site.
How to Avoid: Use cross-browser compatibility testing tools that are available. Check if any usability or functional issues are occurring in any of the browsers and debug the issues in real-time.
9. Ignoring Input Validation
User input must be validated on the client and server-side. “Do not trust user input” is what we all hear. The reason behind this is- the hackers can attack websites by submitting malicious inputs through a form.
How to Avoid: Although implementing validation may take a lot of time, but you should never ignore input validation and practice it into your code.
10. Declaring Variables Globally
Did the variable fail to initialize? That’s probably because logic flow didn’t go through the initialization code or maybe you forgot to initialize, or perhaps variable got initialized properly but then got reset by some other function to an unexpected value. A lot of possibilities, but there’s no perfect method to figure out other than executing one program section at a time while keeping a keen eye on the variable. It can be frustrating to know that the cause of the problem you’ve been running after, is your ‘global variable’ which is modifying values unexpectedly.
How to Avoid: Declare variables globally only when it’s the necessity. If you have multiple functions in your code where these variables will be used, in such cases avoid it strictly.
11. Not Taking Backups
What’s more disappointing than losing your valuable code and writing it from scratch? Spending days and nights to write your code and losing it within seconds can surely give you a heart attack! A hard disk crash is a very common cause and it happens too frequently. No doubt, with the growing technologies you may get your data recovered. But before that, you will have to reinstall your operating system and what not!
How to Avoid: Do take a backup of your files on a timely basis at least once in a week. Not on the same disk but back it up on a different disk location or on the cloud.
12. Choosing Poor Web Hosting Provider
Selecting a bad web hosting provider is a common mistake that a novice developer commits. Without thinking about the impact, it will have on the website, choosing a random web hosting provider is what one must avoid strictly. Web host plays an important role in every aspect of your website, be it website speed or SEO. Don’t just choose a web hosting provider because it is cheap.
How to Avoid: Do complete research before choosing your web hosting provider. Check out their reviews, compare their prices, features and then pick the best one.
13. Making Changes Directly On Server
At least once in a lifetime, you must have done this. When your client has asked you for a minor change and you took the quickest route and made those required changes directly on the server. This way you are free from the allotted task and the client is happy too. The problem arises when these changes are not replicated in the repository and you upload the same old files in the next deployment. Your client is surely going to get upset seeing the issue over again.
How to Avoid: Whenever there is any demand for a change first make the changes on your local file and then upload it on your server. This way you can save yourself from any rework and multiple versions of the files.
14. Not Backing Up After Website is Live
A lot of you think that once the website is live your responsibility is over. But that’s not how it should be. Your client is dependent on you for his website as he might not be aware of all the factors related to a website. It’s your duty to take care of it even after the website is deployed on the web. Especially, when it comes to web hosting. Most of the time, the web hosting account is due and the client doesn’t know. Once the hosting account gets expired all the website files are lost and if you don’t have its backup, the client is going to be furious.
How to Avoid: Keep a track of the web hosting account and do take timely backups, so that even after the hosting account is expired you don’t lose any website data.
15. Not Knowing Optimizations
Improving code quality and efficiency is what you might miss out. Or if not done right, can mess up with the functioning of your code. If you want to do flawless optimization, you need to follow a strategy that will need the experience to get it right.
How to Avoid: Optimizations cannot be learned in a jiff. You need to invest a lot of time, explore as much as possible, perform analysis and look into every system involved in the process. Discover about algorithmic complexity, protocols, how to measure general performance, database query
