These examples represent situations where remote debugging can bring surprising value, making the process simpler and faster, most significantly in cases where regular debugging is impossible.Ī more classic case where this can be seen is with a web application that has a problem on mobile phones. This with the addition of monitoring and testing clearly points back to a lack of proper tooling. The downside in microservices is that developers who are working in normal conditions aren’t able to run their processes and can’t debug their serverless applications on their IDE or local environment.Ī 2018 community survey of the biggest serverless challenges showed that the most notable one to be debugging. Function levels are single-purpose, programmatic functions that are hosted on managed infrastructure. Thus meaning, we decouple our application at function level. The underlying premise of serverless is that it works by default abstraction of underlying infrastructure and abilities related to it. Serverless, comparatively to microservices, is a much more distributed architecture. So yes, we understand why you try to avoid debugging microservices like the plague.
This process is not only time-consuming but it also requires more practice and patience. If you are going to attempt production debugging of such an architecture, you will have to access and sift through many log files and write often necessary additional logs, after which you’d need to redeploy and restart your application, just to get additional data. On top of this, logging is decentralized and harder to analyze. At its core, this technique is defined by the following principle: divide a big application into smaller parts that are easier to manage, and distribute the workload among developers.Īs you can see in the below scenario, the application is distributed, thus making it much more difficult to reproduce a bug, due to the simple fact that it’s difficult to trace it back to the source. Let’s take a look at microservices, given that this method has been used by developers for a longer time than the serverless approach.Īs we know, microservices came into place as a solution, as well as a substitute for monolithic applications.
Crazy? Not so much.įor a deeper understanding, let’s look at the problem with the old way of troubleshooting the code for modern software architecture. Remote debugging becomes crucial at some point for you, whether it’s because of difficulties you’ve encountered with classic debugging or the simple fact that the classic debugging method has become near impossible to use.īelieve it or not, there are high chances that at one point you used the technique of remote debugging without even realizing it. Even more, you understand that while classic debugging might be yielding results now, remote debugging – when done right- can save you a significant amount of headache and time. If you are a developer or an executive (or both), you know that debugging is crucial. Intrigued but also a little terrified? We get it, but don’t run just yet.
This is usually done by connecting the remotely running application with your development environment. In simple terms, remote debugging is debugging an application that runs in a place other than your local environment.
This change necessitates taking a leap of faith to try and adopt new means to work the bugs out of the system. With the rise of new software techniques such as microservices or serverless, not only has the way we write code changed, but also the way we debug it. Service architecture has become increasingly complex and the old days of monolithic applications are behind us (well, not entirely, but that’s another discussion for another time). While this may be a tried and true method, the future of debugging is here and, you’ve guessed correctly, it comes in a remote form (cue heart palpitations). This scenario and these feelings are common to devs everywhere, where many opt to take the trusted path of debugging on their *own* machines. Palms sweaty, knees weak, and arms ready (to code) they dive into what they’re sure will end in much pain and possibly a few broken pieces of code. Nowadays, the term ‘remote debugging’ instills fear into even the bravest of dev hearts.