Cling: An Interactive C++ interpreter

https://root.cern.ch/cling

by indatawetrust • 10 years ago

202 50 10 years ago

root.cern.ch

jokoon2• 10 years ago

That must have been pretty hard to build.

dguest4• 10 years ago

It was a replacement for the old C++ interpreter, CINT, which was already a central part of a lot of CERN code. Building Cling was probably easier than maintaining CINT.

jokoon2• 10 years ago

Still, since C++ is a statically compiled language by design, doesn't that make it difficult to make it run as an interpreted language ?

kensai• 10 years ago

"Cling is capable to parse everything that Clang can do. In addition, Cling can parse some interpreter-specific C++ extensions."

Punchline!

Bromskloss• 10 years ago

Kling och Klang!

wojciem• 10 years ago

I guess this will finally allow to build full-fledged IDE for C++

stephengillie• 10 years ago

It allows for the same "IDE" that works great for me with Powershell - a console window on one side, and N++ on the other side of the screen. N++ Autosave plugin is invaluably rapid here, letting you write some code, then just click/tab to the console and test the module.

stevedonovan2• 10 years ago

Eclipse CDT has gotten pretty good in the last few years. Its code scanner is practically a full C++ front-end, and if I pay attention to the red ink I practically never break my builds. That being said, _instant_ C++ is a fantastic thing

optforfon2• 10 years ago

Last time I tried Eclipse (2-3 months ago) it wasn't usable on high DPI screens. Have they fixed tat?

pjmlp3• 10 years ago

Like Lucid Energize C++ in 1993 ?

https://www.youtube.com/watch?v=pQQTScuApWk

Or C++ Builder or C Set++ for OS/2 (might have the name wrong).

If it wasn't for tool vendors having switched their focus from C++ to Java and .NET, until LLVM and clang got created showing everyone what was wrong with their approaches, C++ IDEs might have been much more advanced already, in spite of technical issues with language.

golergka• 10 years ago

Apart from all the awesomeness, it'll be so great to troll people who take language holywars seriously with this.

userbinator• 10 years ago

You mean those who claim C or C++ are always compiled and not interpreted? This has been around for a long time:

https://root.cern.ch/cint

rjsw• 10 years ago

There was also the Sabre C interpreter, early releases of X11 and X10R4 came with the scripts to run it, it didn't do C++ though.

trendnet• 10 years ago

Wasn't some of that available in LLDB for a year or two?

wrp• 10 years ago

Windows is unfortunately not yet supported and so far it doesn't look like they are even thinking about it. A few people have managed to build on Windows, but with considerable difficulty.

CyberDildonics• 10 years ago

Does this work with windows? I'm still not clear where Clang stands.

ausjke• 10 years ago

Tried to build it and git is asking for username/password

    git clone https://root.cern.ch/git/root.git src
    Username for 'https://root.cern.ch': 
    Password for 'https://root.cern.ch': 
    fatal: Authentication failed for 'https://root.cern.ch/git/root.git/'

indatawetrust2• 10 years ago

https://root.cern.ch/download/cling/

amadio• 10 years ago

There's a GitHub mirror of it here: https://github.com/root-mirror/root

indatawetrust2• 10 years ago

for download : https://root.cern.ch/download/cling/

radarsat1• 10 years ago

I want to see something like this available from gdb. Following code that uses shared_ptr in gdb is still awful. It would be great to be able to explore the stack frame properly, looking at STL containers without hassle and calling functions and everything.

stevedonovan2• 10 years ago

Modern gdb does have Python plug-ins, and e.g. I'll get "std::vector of length 3, capacity 4 = {10, 20, 30}" when printing a vector, and "std::shared_ptr (count 1, weak 0) 0x8059e10" when printing a shared ptr. But oh yes, it could be so much better. For instance, often you cannot call methods on template stuff (that is, everything) because 'it may be inlined'

microcolonel• 10 years ago

"May" ought to be translated as "must". Templated C++ is incredibly sluggish without inlining. People are comfortable debugging C programs with more advanced optimizations turned off because performance will still be decent. In C++, the optimizations are the only reason it ever performs reasonably.

pvnick3• 10 years ago

Can somebody please shine some light on why such an endeavor was undertaken by CERN? What was so important about JIT C++ that they had to write such a sophisticated piece of software?

detaro• 10 years ago

If you look at the root of the domain (https://root.cern.ch/) it seems to be part of work on a scientific computing framework in C++. And having a nice REPL is important for this kind of thing, and if it is in C++ you can look deeper into it? (instead of using one of the bindings to Python/... for the REPL, where you can't inspect what is going on inside the C++ code)

pjmlp3• 10 years ago

Interactive programming is very developer friendly workflow, something that was already possible at Xerox PARC in their Smalltalk, Interlisp-D and Mesa/CEDAR environments.

Actually there was an early attempt to provide C++ repls back in the early 90's with Lucid Energize C++, after they pivoted from Lisp Machines and applied their knowledge to C++.

https://www.youtube.com/watch?v=pQQTScuApWk

Also the majority of CERN code is written in a mix of Fortran and C++, and not all teams like to use Python. So they rather use something that provides interactivity to research their algorithms and speed at the same time.

pvnick3• 10 years ago

Wow, that's interesting. Interactive python a la jupyter notebook revolutionized my workflow; I guess it makes sense to allow the same for a codebase written largely in c++

hellofunk• 10 years ago

JIT compilation opens up a lot of new features and workflows in a language, from interactive development at a REPL to in some cases very powerful abilities to generate, compile and run code all at runtime (i.e. "eval" in lisps).

coliveira• 10 years ago

This is called systems research, a lost art in the US, but still very important if you want to write complex systems as as they do in CERN. By the way, that's why C++ was designed in the first place.

sklogic2• 10 years ago

It is a replacement for an older C++ interpreter, Cint. Which, in turn, is a replacement for an even older Fortran interpreter (see CERNLIB).

dguest4• 10 years ago

What a lot of people aren't mentioning is the legacy factor.

We had a "C++ interpreter" called CINT for a long time, which the ROOT data analysis framework was built around. It was, to put it bluntly, a mess: it had inconsistent scoping and syntax with C++, gave worthless debugging messages, and couldn't handle a lot of standard C++ code.

It was also the way that a lot of physicists at CERN ran their analysis code. We needed an interactive language to make graphs and histograms and to fit our data, and when CINT was conceived the only other solutions were proprietary packages like MATLAB. So CERN went with a homegrown solution and wrote a C++ interpreter many years ago.

Flash forward 15 years. "Big data" is all the rage. Python, R, and the huge list of packages built around around them would easily solve the problems CINT was designed for. But the codebase for the larger experiments at CERN is maintained by physics graduate students, a good fraction of whom had no programming experience before grad school. We don't have the time or the resources to rewrite our existing code in scipy, and the older generation doesn't have the experience to supervise such a transition.

Given that so many physicists are still using CINT, the ROOT developers had to make a choice: they could continue to maintain CINT, which would have been nearly impossible with their resources and the evolution of C++, or they could rewrite something that did almost the same thing using more modern tools. They opted for the later.

Create2• 10 years ago

actually, there was another choice besides llvm/clng: python.

cint (M. G.) was in maintenance-mode for a long time by then.

ph-sft group was more for python (P. M.), and fnal wanted llvm/c++ (P.C.).

fnal then put down the money for an IC contract (A.N.) at ph-sft for the llvm/c++ based implementation and joined the iso body.

cling is almost orthogonal to the whole ROOT mess (graphics, histogramming, partially the analysis etc.)

pvnick3• 10 years ago

That's interesting. Thank you for the history lesson and for the glimpse into the culture at CERN.

optforfon2• 10 years ago

Cool, but I'm having trouble imagining how I'd use it in my workflow.. Is there a demo or something?

I've only used interpreters in MATLAB/R where you have to write one-liners to massage data into the format you need - which seems pretty orthogonal to the way you work in C++

a3n• 10 years ago

I use the python shell in two ways: to try/explore things in isolation, without having to muck with the larger thing I'm working on; and similarly, just learning things in general without a focus on a particular project.

And now with the ipython notebook (jupyter) I use the shell in a third way, to repeatably explore and demonstrate larger, less isolated things that are still sort of one-offs.

That said, I think the fact that there is a significant handful of C++ compiler/implementations in use, and some latitude in behavior for each, means that a C++ user is very much a user of the compiler as much as the language. Play but verify, I guess.

sklogic2• 10 years ago

See how it is used in ROOT.

sly010• 10 years ago

As an aside, I wonder if browser vendors could agree to just use something like the LLVM intermediate representation instead of javascript as a common denominator. Everyone agrees that LLVM is awesome and everyone compiles their personal favorite language to whatever browsers eat anyway.

kr7• 10 years ago

WebAssembly is essentially that.

https://en.wikipedia.org/wiki/WebAssembly

happyslobro• 10 years ago

I suspect that sandboxing LLVM IR would not be easy. Mind you, now that browser JS runtimes grant access to GPU shaders and the ability to accept connections through webRTC, keeping JS in the sandbox isn't going to be so easy anymore.

firethief• 10 years ago

Like WebAssembly without sandboxing or portability to different hardware platforms?

Mr_P• 10 years ago

Google's Native Client was exactly this, but it never caught on. PNaCl is a proper subset of LLVM bytecode.

netheril96• 10 years ago

Any homebrew formula?

ramgorur• 10 years ago

Very interesting project. I am not that into clang/llvm, neither I don't have it on my machine nor know anything about clang/llvm. But a c++ interpreter is something I always wanted to use, how do I make it work for g++ 4.8.4 ?

Cling: An Interactive C++ interpreter

Related Stories