When something is supposedly outdated but still works, you could say it’s not outdated after all, right? It’s one of those “if it’s not broken, don’t fix it” scenarios. And in many cases, it actually might be a successful strategy.
But in the world of software development, this kind of approach comes with many risks. Using outdated technology, such as JSF (JavaServer Faces) with JSP (JavaServer Pages), becomes more and more troublesome each year and eventually might cause you to lose money instead of saving it on a tech update.
So, let’s talk about the risks of using outdated technology using the example of JSF and JSP. And it’s worth noting that the two solutions are officially depreciated.
Why are JSF with JSP outdated?
Before we move on to the risks, let us explain why we still use such technologies and what’s so problematic about them.
The most common reason is that many solutions built with old tech stack are good enough, at least for the time being. Even if they aren’t as easy to tweak and update, companies are used to the old ways that allowed them to thrive for many years. Especially because the transition to modern, much more popular technologies comes with a very high cost. We’re often talking about rebuilding massive systems that took many years to build. Of course, that’s perfectly understandable if we don’t account for the risks. But let’s not get ahead of ourselves.
It’s fair to say that the many issues of JSP and JSF are very characteristic of the entire “outdated tech” problem. It all starts with the technical issues and the fact that throughout the years, the world of technology evolved in a major way while those solutions lagged behind. In a lot of ways, staying attached to the old technologies is like refusing to change your old car with 750 000+ mileage, even though it requires a monthly visit to the mechanic and burns 3x the fuel compared to new ones.
So, in short, let’s talk about the most significant shortcomings of the JavaServer Faces.
1. Quick development is cheap development, while JSF makes straightforward tasks difficult.
2. It’s relatively difficult to learn, so it’s hard to extend the team if there’s a need to do so quickly.
3. It’s incompatible with a number of standard Java technologies
4. It makes testing difficult compared to other more modern alternatives.
5. The front and back end are tightly coupled, which results in longer and more expensive development time and requires full-stack developers to do the job.
6. It’s a designated user interface standard for Java EE 8, which went final on 17th April 2017.
7. It’s prone to performance issues.
8. JSP and JSF mean server-side rendered pages, which are clunky and inefficient.
9. And much more.
The consequences of those issues go from higher and longer development time to the inability to load websites due to server overload. What’s even more tricky, JSF doesn’t give devs proper tools to fix many of those issues.
Why is sticking to the outdated tech stack risky?
There are many challenges that developers have to face when dealing with an outdated tech stack, but to truly understand the problem, we need to look at it from a broader perspective. So let’s take a look at some of the most significant risks of working with outdated, and sometimes even dying technologies.
The growing cost of maintenance and development
COBOL is a programming language that was first designed in 1959. Over the years, its many versions have been widely utilized by financial institutions, governments and businesses. Right now, there’s absolutely no chance you would hear about it in a serious conversation about modern software. And even though it truly is an outdated technology, it’s still very much in action in many established enterprises, most notably in banking. So, where’s the problem?
Well, it’s insanely expensive.
Nowadays, young developers don’t learn this language, and experienced ones are often closer to retirement than looking for a new job, so it’s very difficult to find people to maintain COBOL-based systems. And if they are somehow available, they expect much higher salaries than the market average. We have already noticed a very similar process happening with JSF and JSP, putting companies in a tough position.
The shortcomings of outdated systems and the expectations of modern users (and developers)
One of the most significant challenges for companies in the new era is to create future-proof software. That means it’s easily accessible for any type of user, no matter the device, which, of course, includes portable gaming consoles, fridges, and robot vacuums. Users expect that universal accessibility and JSF-based platforms can’t even be RESTful. Of course, that’s an extreme example. Most applications built in JSF won’t require such features, but it’s just one example of many limitations that come with development using outdated technologies.
In addition to that, they’re simply unattractive to developers who seek challenges and want to build trailblazing software. They also don’t see it as a reasonable career path because it’s not the way of the future. The world of tech will move on, and their skill will become unwanted.
What’s the alternative?
The growing risk and the development issues that come with using JSP are perfectly reflected in the statistics of tech popularity. In the current era of software development, there’s no reason to pick JSF if we’re building something from the ground up. And at the same time, more and more businesses make the hard decision to update their stack to meet the requirements of modern users and devices. According to the recent JVM survey, 58% of JVM-run applications utilize Spring Boot, while only 8% utilize JSF, and the difference increases each year.
Whether it’s Spring Boot or Spring MVC, modern frameworks address a vast majority of the age-driven issues that come with JSF. On the same note, frameworks like Angular and Vue.js successfully replace JSP. Of course, they solve more than only those technical ones. There are much more developers available on the market, which allows for much faster project launch and easier team extension. That also means we’re getting super active communities that support each other and share ready-to-go solutions and extensions. As a result, development becomes cheaper and faster, and we’re receiving much better software at the same time.
How difficult is it to transition to more modern technologies?
It’s a trick question because, in most cases, it’s not about the difficulty or even cost, but about necessity. More and more often, deciding on moving forward from outdated technologies is about survival. Of course, the decision is never easy. It’s always a challenging task that requires analysis, commitment, time and budget. But those risks we’ve mentioned aren’t going away anywhere. On the contrary, each year brings technologies like JSF closer to becoming a part of software development history, rather than modern software engineering.
Of course, each individual software requires proper analysis. Not always the radical decision of entirely changing the tech is the correct one, but just considering it is a great start. And if you feel like saying goodbye to the long-lasting tech stack might be a good turn for your business, let us know, and we’ll help you make the right choice for your business.