The continued or at least regular preventive maintenance, including upgrade to the newest versions, or project architecture review, are significant parts of every application’s life cycle.
From technical point of view there are two major reasons. First is to profit from the latest technologies and their advantages. Second is to have the ability to keep the existing functionality of your application, to scale it and to adjust it quickly to your current or future business needs. There are of course other motives for modernising applications and services. The latest of these, the new Microsoft long-term support policy, provides a solid and commanding argument for evaluating each application's condition and developing a modernisation/upgrade plan for the years ahead.
If we consider the benefits of such application modernisation from other perspective, it is essential to mention the human effort needed for the maintenance of, or the addition of new developments to, any existing legacy application. The maintenance of old applications present special problems when it comes to finding developers to do this work.
We have prepared a paper highlighting the business and financial benefits of regular maintenance and constant upgrading of applications throughout their lifetime. We conclude that such work is essential if application owners are to get full value for money from their investment in software. We explain our thinking in this article.
Before we dive deeply into long-term support (LTS) from Microsoft, we need to distinguish between two "dotnets". Historically there was the .NET Framework - something we refer to as a "full framework" - a windows-related set of libraries and tools used by many developers to create various kinds of application. Historically, these tools did a good job, but they brought with them many issues (the absence of multiplatform support, large size, long release cycles, just to name a few) but this .NET is now considered obsolete and won't be extended or maintained any further. Microsoft decided to continue supporting the old framework as long as it is installed on a supported version of Windows, but you cannot expect any new functionality to be added. The "long-term" support here is only to "keep things alive" and nothing more.
On the other hand, there is a brand new .NET Framework successor, called ".NET 6". Yes, Microsoft is famous for making naming things harder for all of us, so, although these two things sound nearly the same, but they are definitely not the same. The latest .NET 6, and its succeeding versions, are the future of .NET development and it's the one you should always choose when developing new features. Having much better performance, a lower memory footprint, multiplatform capabilities, and full support from Microsoft regarding adding new features, it is the ‘go-to’ platform for modern software development. Do you want to build on Linux? No problem! Do you want to run your application in a Docker container in the cloud? Sure! With many new features, APIs, and improvements also at the language level (F#, C#), .NET 6 is the release many developers have been waiting for.
However, there is always a price. One of the big changes is the Microsoft approach to LTS. Every new version of .NET is, and will be, fully supported for 3 years and then you should upgrade to a higher version. It may sound very strict, but we need to be aware of the reality of current software development: everything speeds up, new libraries appear almost daily, and Microsoft, as a .NET vendor, needs to retain the ability to follow market trends. Shorter long-term support, with a more frequent major version release cycle, is a very reasonable way to achieve this. In other words, software development and the whole IT industry is changing so fast, that you need to adjust and be ready for constant releases, improvements, and upgrades.
But the official Microsoft LTS policy is not the only reason why you should upgrade your old applications to .NET 6. One of the emerging trends these days is using Docker containers for developing and running cloud applications. You don't have to go to a developers' conference to hear talk of "dockerised, Kubernetes, containers" - these things are already very popular with many team members from developers to operations people and for very good reasons: rapid development, friendly tooling, advanced safety and full control over the application environment are only a few of these. These containers are mostly based on Linux machines, and cannot be fully used if an application is running on an old framework. This limitation means that you are blocked from the latest trends and their benefits, in addition to the more serious consequence: money and running costs in general!
Containers can be very lightweight (a few megabytes) compared to the old-fashioned way of having a dedicated machine for running applications. Smaller requirements simply mean lower running costs. And if you are an environmentalist you will also consider the impact on the planet.
To mention another big thing in cloud-based software development (and the one you cannot make use of with the old framework) we should talk about "serverless." Serverless, also referred to as Function as a Service (FaaS) is probably the most lightweight software solution you can think of. The basic idea behind it is to have the smallest possible piece of code or business logic wrapped in a function that can be triggered "somewhere in the cloud" without your team even knowing where exactly. It just runs on some servers, and you don't need to worry about scaling, traffic peaks, and so on. One of the key benefits here is that most cloud vendors, such as Azure or AWS, are providing "free invocations" - application time you don't have to pay for. So, we are in a very similar position as we were with containers - we have a cheap solution using as few resources as possible.
And it's not just about the resources you need for running your application. Don't forget about the most precious and expensive commodity in software development: human time. You most certainly do not want to spend large amounts of money on developers tackling big, outdated monolithic applications running on an unmaintained framework. Preferably, you will want them to be writing smart software that meets the requirements of modern development best practice, with many tedious tasks automated using state-of-the-art tools. If you care about being as effective as possible, you simply cannot freeze your application in 2010.
Then there is the developer’s perspective. The world is facing a major shortage of skilled IT personnel. One consequence of this, is that IT engineers are much more mobile than they were in the past and more willing to move from one project to another, from one job to another, as they seek to find more challenging and interesting work. There is no doubt that maintenance of older software is not as attractive as working with leading edge technologies. And the older the application, the less attractive maintaining it is. The reality is that the more up-to-date your applications are, the easier it is to find and motivate people to work maintaining them.
One of the keys to understanding the importance of keeping your development stack up-to-date is to think about what software development really is. Is it only about writing some code and then never touching it again? Unfortunately, not. It's actually the opposite. Software is either still evolving, or it's dead. New customers will bring new requirements, your salespeople will find new opportunities or simply you will change your priorities over time. And your application needs to adjust to that and needs to adjust quickly. Being stuck on an ancient technical stack will block you from being quick in reacting to market needs, from being elastic, and most importantly, from attracting smart and modern-thinking developers.
When a product is technically completed, it doesn't mean it will work as it was supposed to or meet customers' needs over a long period. There is always the need to improve, re-design, or keep it up-to-date. To have a solution which is easy to improve, scale or kept up-to-date, you have to stay with the latest technologies and update your product regularly.
Postponing decisions to update to a new version can save some money at the time, but, later on, can not only be very expensive, but also turn out to be almost impossible if you hold off for too long.
If you are not sure how to evaluate your applications, define a policy, and devise a plan to make your products future-proof, let us have a look at the problem for you. We are more than qualified to give you an independent opinion and recommend a course of action. Our senior developers in the Architect Chamber have years of experience, backed by success stories from which we have learned a lot, but also from failures, from which we have learned even more. This makes us stronger.
We can arrange a workshop with our best architects for you and give you an unbiased opinion, including recommending steps you can take to make sure you get the best out of the latest technologies, while ensuring you have access to the developers you will need to carry out the work.
We will act as your solution partner, guaranteeing to be open and honest and able to provide you multiple ways how to deal with this problem.
And be assured, almost every problem has a solution - let us help you to choose the best one.
Written by: Roman Provazník, Jiří Urban, Lucie Krobová