There are many things that for developers can waste time in completing their projects or maintaining them in the long run. These mistakes are committed by developers of all levels of experience and are by far not exclusive to junior members of our profession. I have definitely been guilty of such mistakes myself.
1. Building a custom CMS
Building a new CMS (content management system) either as a standalone development project or as a custom CMS for a website that you are building can be a great opportunity to learn how databases are structured and how to build software for convenience.
However, building a custom CMS is also one of the most time consuming activities you can undertake as a developer and often yields very few benefits over using an existing system. The disadvantages of doing this are:
- If you build a CMS this is another piece of software you will need to maintain with new code for patches, updates and new features. A custom CMS will not carry the support of open source CMS systems such as WordPress, Drupal or Joomla which are improved upon by a large community of developers around the world.
- Security flaws are far more likely. Most of us have a good standard of web and software security. However unless you are an expert in this field (most of us are not) you will make errors or omissions that leave vulnerabilities open that an existing CMS will provide protection against because of its large community that will be in place to fix any vulnerabilities and bugs in place.
- There is almost certainly a CMS that will serve a use case for your site. No matter the use case of your website there is almost certainly a CMS that fits it already. If it does not entirely fit the use case you will also very likely be able to tweak the CMS with a custom plugin or module to cater to any additional functionality not included as standard or disable functionality you do not need. If a CMS does not exist for your use case, a framework will instead that you can likely combine with a CMS.
2. Building a custom framework
Laravel, Symfony, Vue, Django and Yii are all examples of web frameworks. They provide a template with basic functionality for you to build your own websites and web applications on top of them. As with building a custom CMS, building a custom framework can help you to understand software design concepts and how to organise code thoroughly.
However building a custom framework poses similar disadvantages:
- If you build a framework, this is another piece of software you will need to maintain with new code for patches, updates and new features. This is a disadvantage in the same way it poses a disadvantage for building a custom CMS.
- Security flaws are far more likely. As with the last point, in building a custom framework this is a disadvantage for the same reason it is for building a custom CMS.
- It will take a long time to get right. You will miss out many use cases initially and there will be lots of room for bugs to appear and will take a long time to weed them out without a large community to help.
- You will likely be “reinventing the wheel”. No matter the use case for your web application or website there will be a framework that will fit your use case.
3. Overcomplicating your codebase
A shortcoming I have too often seen in developers, particularly (though not exclusively by any means) junior developers, is feeling a need to overcomplicate or overengineer the codebase of their applications and websites to show off their skills with long, elaborate functions and many levels of abstraction. This is highly counterproductive. The best and most experienced developers understand that complication does not equal efficiency. In fact smart code is code that is written to be simplistic while maximising utility. Having said that, I am definitely guilty of having done this in the past.
The disadvantages of overengineering or overcomplicating your code base are:
- Overengineered and overcomplicated code is not efficient code. Complicated code that is too long and elaborate is more likely to harbour bugs and will be naturally much harder to debug. Additionally long functions and many layers of abstraction are not good for the efficiency of an applications. In place of this use good design patterns and a simplistic but scalable systems architecture to add new features.
- Complex code is much harder to maintain. Even if you are maintaining this code yourself you will find it is much more difficult to debug, alter or add to it if it is overcomplicated as you will undoubtedly lose your way in your codebase if there is a lack of structure or if it is too complex to make sense of it after stepping away from the project. If you then have to step back into the project you will spend too much time reaquanting yourself with the code structure and behaviour.
4. Learning too many languages/frameworks/technologies
It is a common mistake among junior developers to believe that they must learn everything about development in order to start building good software. I definitely had similar thoughts early in my career. As developers we do need to be lifelong students of our profession and be constantly learning new things and improving our own skills. However it is possible to try to learn too much to the extent where it hinders your progress.
Some disadvantages of having this attitude towards your professional development on your time and efficiency as a developer are as follows:
- You may never use all of those skills. It is impossible to know all there is to know about web and software development and no matter how much you learn, you will find as you progress throughout your career that certain technologies will be more commonly used than others.
- It is good to specialise. Although I would argue that you should know at least a few programming languages reasonably well, it is by no means a shameful thing to know only one programming language very well as many developers make very successful careers by specialising in one language or framework.
- Having too broad a skillbase can actually harm your career prospects. I know this sounds like nonsense but I believe although having several different skills in development is certainly a good thing having too many can be counter productive to your career prospects. If you did manage to pick up very many different languages and frameworks, at best employers may believe that you cannot be equally skilled at an intermediate capacity in all areas and may wonder where your real strengths lie and at worst may have trouble believing you can possibly know all of those languages and frameworks.
5. Overreliance on one framework/technology
I have seen this in many development circles. It is a big problem for efficient use of developer time as it can mean using a particular framework or technology for all use cases when other tools may be far more efficient and fitted-for-purpose. For example, WordPress could be used to build a social networking site or complex web application, but there are other tools more fit to do that job. Similarly Laravel could be used to build a blog or ecommerce solution, but again other tools may be more fitting for this use case.
Some disadvantages of relying too much on one framework or web technology for all your projects are as follows:
- No web technology or framework is built for all use cases. All web frameworks, CMS systems, and libraries are built to serve a specific purpose. This purpose is either in building specific use applications, solving specific preexisting problems in building applications, or any other case. For example WordPress provides an intuitive system for managing web content for blogs and content-heavy websites, Magento provides an enterprise-level ecommerce solution-, Laravel provides a framework for building scalable backend web applications under the Agile methodology, and Vue provides a framework for building complex single-page web applications. Although you technically can go outside of these use cases for each framework or CMS, that does not mean you should or that it will not be more difficult and cause problems.
- Although it is good to specialise, being too specialised could (not always) harm your career prospects. It is good to specialise but it is important to have other tech skills for your CV or resume. This is partly because having only one main programming language, framework or CMS that you have development experience with could imply a lack of willingness to learn and/or use new frameworks when necessary for projects. I believe a more important reason to not be too reliant on one technology is that you should have a backup in case demand for that technology is reduced or demand for another in increased.
- You may miss out on a good learning opportunity by not using a new, better suited framework for your project. Learning to use a new framework or web technology can be a fascinating and invigorating learning experience. If you insist on using one technology for all projects, not only can this be more time consuming by tweaking the technology to work outside its primary use cases, you will also miss out on potentially valuable learning.