Will JavaScript type annotations kill TypeScript?
The creators of Svelte and Turbo 8 both dropped TS recently saying that "it's not worth it".
Yes: If JavaScript gets type annotations then there's no reason for TypeScript to exist.
No: TypeScript remains the best language for structuring large enterprise applications.
TBD: The existing user base and its corpensource owner means that TypeScript isn’t likely to reach EOL without a putting up a fight.
I hope they both die. I mean, if you really need strong types in the browser then you could leverage WASM and use a real programming language.
I don’t know and I don’t care.
Microservices / Observability

Why Legacy Apps Need Your Monitoring Love, Too

This article will list some special considerations when monitoring legacy apps. In addition, some of the low-hanging fruit for aspects to monitor.
Dec 19th, 2018 6:00am by
Featued image for: Why Legacy Apps Need Your Monitoring Love, Too

Raygun sponsored this post.

Dave Farinelli
Dave is a writer for, a senior software engineer with over eight years of experience. His specialty is in providing both DevOps and implementation solutions across the financial, healthcare and insurance domains, with a focus on bettering process and delivery.

Legacy applications are usually the main drivers for a business, consisting of the majority of the software used to assist businesses in revenue. Even if they’re ailing and running into problems, their importance cannot be overstated. Needless to says, it’s important to make sure legacy systems are running at their best.

A good starting point is to collect hard data in the performance of the application, giving an idea of the overall experience for customers. The good news is this process can be easy to adopt.

For example, Raygun provides a suite of applications that easily add monitoring to any application, both new and old. Especially if you’re working in an environment with both greenfield and brownfield applications, having tools to combine reporting in both environments can save a lot of effort in implementing monitoring across new and old.

Let’s look at some things to consider when monitoring legacy apps.

Defining Legacy Apps and Special Considerations

First, let’s define what a legacy app is. If you’ve been working in the industry for a few years, you’ve likely supported a legacy app. A general definition of a legacy application is one that runs in production on either outdated technology or outdated infrastructure. These applications usually drive a large part of the business and can account for a large part of the software team’s budget.

However, there are plenty of issues that make working in legacy apps a nightmare over time. Some of those reasons include the following:

  • Poor code quality or application architecture dictated by a number of reasons (deadlines, lack of capability, etc.) that cause difficulty in making changes to the legacy application over time;
  • Lack of good documentation over time, making large sections of the codebase nearly impossible to understand;
  • Lack of automated testing that can cause regression issues. This can be especially frustrating, as fixing something breaks another place, and trust is lost in the bug-fixing process;
  • Lack of a robust deployment process, including many manual processes for creating and deploying a build. This causes a lack of trust in deploying builds (e.g., “what’s going to break when we deploy?”).

With all of these special considerations for a legacy application, it’s clear that having a strategy for monitoring a legacy application is important.

Legacy Applications: Things to Monitor

Now that we’ve defined what a legacy application is, let’s look at the aspects to monitor. There are three major things to test for when considering monitoring legacy apps.

Crash reporting

First, let’s talk about arguably the most important aspect of monitoring — reporting crashes in the application. These are cases where the application stops performing as expected. Knowing where this is happening is critical because nonfunctioning software can make the difference between a successful project and a failing product. For example, let’s say we’re monitoring an e-commerce platform. When a user tries to place an order, the application crashes, and they cannot complete their order. This equates to a business being unable to sell products through the e-commerce platform, which represents an obvious disaster for this type of enterprise.

The worst-case scenario, in this case, is the issue remaining unnoticed until a customer vocalizes the problem. By this time, there could be plenty of orders going unfulfilled. Instead, a better practice is to use monitoring to check the crash as soon as it occurs. A product like Raygun’s crash reporting tool allows for an easy way to add crash reporting to multiple applications in multiple tech stacks.

Adding crash reporting to a legacy application is key since, in many cases, legacy applications are a minefield of problems that aren’t understood by the IT team. There can be many problems existing in the deployed applications that just haven’t been reported by users. Adding crash reporting will bring light to these issues, giving developers more information on failures in the application and a means to fix issues.

Application Performance Monitoring

Next, let’s talk about application performance monitoring (APM). Application performance monitoring is just like it sounds: the monitoring of the overall performance of the application. This includes both overall availability (such as uptime) and performance (speed of the application for users). Application performance monitoring tends to focus on server-side issues and trying to determine any issues that may be in place. If there are issues in particular processes on the server, adding application performance monitoring will help identify them.

Going back to the e-commerce example from earlier, let’s look at a process such as calculating shipping for an order. This is a process that may call multiple external services or perform calculations on the server. If this process is exceptionally slow, it would cause issues that propagate back to the front end, giving a poor user experience.

In a legacy application, there’s a chance there are already issues in performance on the server side. Bringing these issues to light provides data when considering processes to improve the application. In addition, this provides data if a discussion occurs on the performance of the application. If you have someone saying “the site seems slow,” having application performance monitoring in place will objectify or disprove those statements.

In terms of solutions to implementing application performance monitoring into an application, take a look at Raygun’s APM offering. A benefit of Raygun’s solution over others is that purchasing the product allows for APM across multiple environments. This works well for having both greenfield and brownfield environments in place.

User Monitoring

Finally, the third aspect of a legacy application to monitor is real user monitoring. User monitoring is similar to application performance monitoring but focuses more on the actual user experience. This makes for a great way to determine slowness in an application from a user perspective and gives hard data on the speed of a website. In addition, good user monitoring solutions can provide a means of reporting the cause and effect of slowness. Even better is when it can provide a solution for you.

For an easy example, let’s say the legacy e-commerce application we’re using above is just slower than other shopping websites. When you consider that half of the users leave a site after three seconds, it becomes clear that having a performant application is key. Having user monitoring in place gives a good indication of slow pages, alongside the overall performance of the website from a user perspective.

Raygun comes through again with its real user monitoring offering. It provides a dashboard to understand the data being provided, and solutions on how to fix slowness issues that are occurring in your applications, both legacy and greenfield.

Improving Your Legacy Monitoring Game

Hopefully, this guide provides an overview of important things to monitor in the legacy apps you support. Remember, the things that are measured often get improved, and the first step to success is the simple act of measuring. By adding these monitoring aspects to your legacy codebase, you should be on the path to improve the experience of the legacy applications you support.

Feature image via Pixabay.

Group Created with Sketch.
THE NEW STACK UPDATE A newsletter digest of the week’s most important stories & analyses.