Magento Patch Management Versus Core Code Change: Which One Is Preferable?
Magento is amongst the most dynamic eCommerce software platform that is in kvogue currently. The downloadable version is fine for many cases, however, you might need to alter the core functionality or extend it in order the improve the way it works for your eCommerce store.
Nevertheless, you could hit a problem once you decide you need to make a change even in one single line in the middle of a method that extends hundreds of lines. Things can get really hideous and nasty when you realize that you have several hundred lines of core code in the class that you have just created, whereas you wanted just one line of change.
The crux of the problem
However, this introduces a number of violations (such as PHPCS and PHPMD violations) that were present in the core code. There are several options to overcome these, but you will face unique issues with each of the options.
- One of the biggest issues that you will face is related to broken windows, which in brief is that if you allow a small state of disrepair to exist within the project, you could quickly reach a stage where the entire project becomes irrecoverable.
- In case you decide you want to suppress your analysis tools with annotation, this could lead to the same problem, as your class consists of the documentation that indicates issues exist.
- Similarly, you might not want to alter your configuration to allow complex code, as complex code with multiple paths performs with lesser efficiency.
Therefore, fixing the core code can be a major trap. You could end up breaking an unnoticed core functionality especially when you break up the code in an attempt to resolve complexity issues. You can also face a maintainability issue if you have rewritten the core file beyond recognition.
Therefore, occasionally, Magento releases patches, which are usually shell scripts that can be executed against your code base so that bugs can be fixed or security holes can be taken care of, without the need to update the entire core version. Patches can be created by the developers themselves by using the version control tools that are most commonly available.
To enumerate, Magento patches are small pieces of code that will update or fix some of the existing problems with your Magento Enterprise or Community Edition. Magento patches have routinely covered bug fixing and even improving various aspects of usability or performance of the Magento system. Hence, effective patch management in Magento is a better way out than going in for a core file change.
Here, patch management can be defined as a process that utilizes the best strategy as well as plan about which patches need to be applied and when. Hence, Magento Patch Management is of crucial importance.
Safely Changing Core
The main reason why core changes are forbidden in Magento is because when a framework update is applied, the changes made are at a risk of being overwritten. Magento especially is prone to this vulnerability. The recommended approach is to begin with a vanilla copy and then add customizations. You can create patch files of your changes, and by doing so, you are only protecting yourself.
This is because upon updating Magento, it is possible to go through your patch list, then update themselves one at a time. It is not essential that all patches apply themselves cleanly. Some patches may require work, hence you should be prepared for this eventuality to get Magento working normally again.
The Disadvantages of Changing Core
In case the core is changed, the risk involved is changing the behavior of the application in many unexpected ways. Therefore, if you do change the core, the changes should be as low-key and subdued as they can. The only two methods to change your Magento Core that can be possibly applied are:
a. dispatch an event
b. creating a place holder method.
Either of these two methods will ensure that when the Magento core is patched, the Magento core will behave as it did before. Actually, these changes are trivial. Therefore, in order that the behavior of the application changes, the code needs to make use of the modification to the core, hence it needs to be written in the local code-pool.
If the Magento code needs to be of a manageable quality, with respect to readability as well as maintainability, it should be understood that any changes to the framework core should not be taken lightly. However, with the correct tools available and maintaining proper discipline, it could become a viable option.