A debugger, a rebugger, and an interpreter: The new additions to Julia
Numerous reports have documented recently Julia’s incredible growth over the past few months. Today, however, we are having a look at the latest additions to Julia. If you have not yet joined the hype, maybe these updates will do the trick for you!
Recently, we have seen reports coming all around praising Julia’s growth.
Most notably, in the latest update of the RedMonk rankings, Julia has not been skyrocketing, it does, however, exhibit some slow, incremental rise jumping another two spots to the 34th place. RedMonk offers a very interesting interpretation of this growth:
While there is no technical basis for comparison, it is worth noting that three years ago in our Q1 rankings TypeScript made a similar modest jump from #33 to #31. That is not to say that Julia is destined to follow in TypeScript’s footprints, of course, but rather to serve as a reminder that while it’s uncommon languages can transition quickly from periods of slow, barely measurable growth to high, sustained growth quarter after quarter.
Today we are not looking into another of those reports but we are having a look at the latest additions to Julia. If you have not yet joined the hype, maybe these updates will do the trick for you!
Let’s take a look.
A debugger, a rebugger, and an interpreter
As each frontend is its own package, let’s first take a look at Juno which incorporates the debugger into its IDE and then check out the other packages.
Juno – Provides a rich user interface around the interpreter and allows you to set breakpoints and step through directly in the source code. The debugger REPL can execute arbitrary code in a local context and the Workspace allows you to inspect local variables.
Debugger and rebugger – Debugger offers a “step, next, continue” interface similar to debuggers like
gdb, whereas Rebugger aims to provide a console interface that is reminiscent of an IDE. Debugger has some capabilities that none of the other interfaces offer (e.g., very fine-grained control overstepping, the ability to execute the generator of generated functions, etc.), so it should be your go-to choice for particularly difficult cases.
JuliaInterpreter – It contains the logic needed to evaluate and inspect running Julia code. An interpreter lends itself naturally to step-wise code evaluation and the implementation of breakpoints. JuliaInterpreter descended from an original package ASTInterpreter2 but it was in need of updating to the many changes in Julia 1.0. Here are the latest extensions:
- Became recursive-by-default, interpreting calls all the way down to the
ccalls, intrinsic functions, and builtin functions that define Julia’s lowest levels.
- Received numerous performance enhancements, and now can run step-wise through code at roughly 50× its original speed.
- Gained the ability to interpret “top-level code”, for example, the code used to define packages and create test suites.
- Gained support for breakpoints. While not strictly a feature of interpreters, they are necessary to build a capable debugger and can be viewed as an additional form of control-flow within the interpreter itself.
LoweredCodeUtils – The most specialized and opaque of the new packages. Its purpose is to build links between multiple cooperating methods.
CodeTracking – Designed to act as a simple, lightweight “query API” for retrieving data from Revise. Essentially, LoweredCodeUtils performs analysis, Revise manages changes that occur over time, and CodeTracking informs the rest of the world.
We should also note that all these new debugging capabilities seamlessly integrate with Revise so that you can continuously analyze and modify code in a single session.
Head over to the official blog post to find out all the relevant information on these new functions.