CppCast - CLion

Episode Date: June 1, 2016

Rob and Jason are joined by Anastasia Kazakova to discuss new features of JetBrains' Clion IDE. A C/C++ fan since university, Anastasia has been creating real-time *nix-based systems and pushing them to production for 8 years. She has a passion for networking algorithms (especially congestion problems and network management protocols) and embedded programming, and believes in good tooling. Now she is a part of the JetBrains team working as a Product Marketing Manager for CLion, a cross-platform C/C++ IDE. News Bjarne Stroustrup C++ Today Fibonacci: You're also doing it wrong In response to: C++ Weekly - Ep 13 Fibonacci: You're Doing It Wrong C++ for Games: Performance. Allocations and Data Locality C++ Tutor - Visualize C++ code execution Anastasia Kazakova @anastasiak2512 Links CLion IDE CLion on Twitter CLion Blog

This episode of CppCast is sponsored by JetBrains, maker of excellent C++ developer tools including CLion, ReSharper for C++, and AppCode. Start your free evaluation today at jetbrains.com slash cppcast dash cpp. CppCast is also sponsored by CppCon, the annual week-long face-to-face gathering for the entire C++ community. Get your ticket now during early bird registration until July 1st. Episode 58 of CppCast with guest Anastasia Kazakova recorded June 1st, 2016. In this episode, we talk about doing Fibonacci wrong and visualizing your C++ code. Then we talk to Anastasia Kazakova from JetBrains. Anastasia talks to us about the latest changes to the CLion IDE. Welcome to episode 58 of CppCast, the only podcast for C++ developers by C++ developers.

I'm your host, Rob Irving, joined by my co-host, Jason Turner. Jason, how are you doing today? Pretty good, Rob. How about you? Doing pretty good. No real news from me this week. You? Still recovering from C++ now? Yeah, and thinking about... Actually, I'm going to be speaking at the microsoft uh denver developer days which is on june 24th okay is that like i haven't mentioned

that yet it's like a code camp or what is that exactly it's a single day single day conference that's in the denver tech center okay so you're just doing kind of an overview of C++ stuff? Yeah. Yeah? Yeah, I think I'm one of the very few C++ MVPs in Denver. So I volunteered to give a talk on just like how C++ has changed in the last five years for people who haven't been paying attention. Nice. Very good.

Yeah. That should be interesting and good for the Microsoft community there. At the top of every episode, I like to read a piece of feedback. This week, Paul wrote in, and he's got some guest suggestions. He says perhaps one or more of these individuals would be interested in joining you. The first one is Jonathan Mueller, who we're actually going to be having on the show next week. Right, Jason? Sounds right.

And the other one, I don't think I've heard of, Bob Nystrom. He says he wrote an excellent book for intermediate programmers, game programming patterns, but relevant in more than game programming. And he's author of the Wren scripting language and has the website stuffwithstuff.com. So I've not heard of Bob, but we'll have to check him out to see if he would be a good guest for the show. And he also wrote, I'm sure you have no shortage of ideas, but I'll throw these into the hat.

Thank you for all the CppCast efforts and all the other contributions you both make benefiting the C++ community. So thank you so much, Paul. As I said, we're going to have Jonathan on the show next week, and we'll look into Bob and see if we can reach out to him as well. We'd love to hear your thoughts about the show as well. You can always reach out to us on Facebook, Twitter, or email us at feedback at cppcast.com and don't forget to leave us reviews on iTunes.

Joining us today again is Anastasia Kazakova. Being a C++ fan since university, Anastasia has been creating real-time Starnex-based systems and pushing them to production for eight years. She has a passion for networking algorithms, especially congestion problems and network management protocols and embedded programming, and believes in good tooling. Now she's a part of

the JetBrains team, working as a product marketing manager for CLion, the upcoming or now out cross-platform C++ IDE. Anastasia, welcome to the show. Yeah, I am. Thank you for having me here. Yeah, it's great to have you on again. We need to update your bio for next time. Sure. So you know how this works. You've been on before.

We have a couple articles to go through, and then we'll start talking to you about the latest stuff from JetBrains. Yeah. So this first one is a YouTube video that's available. It's from a talk that Bjarne Stroustrup just did at the University of Cambridge. And it was mostly just an overview

of C++ and the core guidelines. So kind of similar to stuff you would have seen from him at CppCon. But he also does go into C++17 a little bit at the end, and you can see how he was definitely not happy with how things went at the late last ISO meeting. Was he hoping more things got approved, less things?

Yes. Was it clear? He was pretty clear that he was disappointed that more things like concepts were not making it into C++17. Okay. Yeah. Anastasia, did you watch the whole video? Yeah, actually I did.

And I was actually expecting him to start talking about CPP Core guidelines, which he finally did. So since it was a major topic for CPPCon last year with a very huge interest from the community and lots of talks at the conference, and even remember him saying in September that we need tools. And I should say I definitely agree that we need tools to guarantee the principles.

Otherwise, I believe no one will follow them, like the tools that will enforce the guidelines. And I fully support the idea as a C++ developer myself and surely as a person working for the tools vendor. And by the way, person working for the tools vendor. So, yeah. And by the way, if talking about the tools, so I should add that we do consider supporting the guidelines in the static analysis that run in our tools.

So you probably know that C-Line runs the static analysis on the fly. So we do consider these things. And for me, the major part here will be the quick fixes because if you don't suggest a fix, why to outline a problem at all? But of course it will require big work from our side, so I can't promise you anything exactly or estimate or whatever. Okay, that could be very interesting. Just to dig into that a little bit more,

you have plans maybe to implement the core guidelines in your analysis, but they're not there yet? I actually created the feature request while listening to the talk in september so uh yeah and i was pinging the guys like saying yes look it's very interesting so hopefully we'll come with something sooner or later but just not at this very point it's too early for now but maybe a bit later okay you're starting to see the core guidelines start to pop up in little places. The latest version of Clang's static analyzer has four or five different core guideline checks.

Not a ton, but some. It's interesting to see it kind of bubbling up. Yeah, that's true. Okay, so Jason, maybe we can have you go into this next article. It's a response to one of your C++ weekly episodes. Yes. So on Monday, I published a C++ weekly that was Fibonacci.

You are doing it wrong. And this stemmed from a frustration of seeing people specifically trying to bench Chai script using Fibonacci and, and they always do a recursive implementation, which is the least efficient way you can possibly calculate Fibonacci. And so I just published this quick video saying there are other options, including Binet's algorithm. And so I go through Binet's algorithm.

It turns out Binet's algorithm, which is a linear way of calculating Fibonacci, a constant time version. It has some floating point error possibilities depending on what CPU architecture you're using and what compile flags you're using, and sometimes you'll get the wrong results. And so I got a well-written response back

about how I am also doing Fibonacci wrong. And a linear algebra approach, or even just an end time approaches is better, more accurate. Right? Yeah, what I get out of this is you should never title something, whether it's a video or a blog post saying you're doing something wrong, because there's always gonna be someone to disagree with you. I knew it would get someone riled up but and it didn't get anyone riled up in the ways that i assumed it would so i mean i learned something new and that's cool and now we've got people talking about um analysis of algorithms and it's fun yeah okay uh this next one is an article about c++ games performance, and I guess it comes from this book,

Development and Deployment of Multiplayer Online Games. And it's a pretty good article, mostly going over performance, like the 90-10 rule. Is there anything specific you wanted to call out in this one, Jason? Well, I noticed a couple. I mean, it's got a ton of really great details in it about hardware architecture and stuff and there's one comment here that uh back in the day on like our z80s and whatever when when when cpu speeds were like three megahertz or

one megahertz or whatever it was approximately it took about the same amount of time to access RAM as it took to access a register because RAM could run at the same speed as the CPU. But today it's like a hundred times slower to access main memory compared to the CPU. And there's an interesting little tidbit in here that he points out that the average register to register instruction that is executed in a cpu today actually takes less than one clock cycle to execute because of pipelining right anyhow i i liked that detail from it personally but it's there's a lot of info in this article yeah do. Do you have any thoughts on this one, Anastasia? Yeah, I agree. There are quite a lot of interesting things in the era. But I don't find anything special to look game dev,

maybe because I just spend years in real-time networking. So for me, most of the things are quite obvious, but maybe that's just because of the experience I have. So for me, it's like, yeah, you should do so. Right. Okay, and this last one is a new way to visualize your C++ code. Jason, do you want to go over this one? Yeah, this guy apparently has been developing for a while now, like six years, Python tutor, you can put in Python and just step through it line by line. And he just added C and C++ support to it.

I think it's awesome. For me, personally, I was kind of abusing it and putting in templates and auto and that kind of thing. And then looking to see, it gives you an awesome visualization of what types the compiler deduced for auto and for your template parameters. So does it handle it pretty well, the template parameters and everything?

Mostly. Long double, it was breaking well, the template parameters and everything? Mostly. Long double, it was breaking on. He knows. He's got some bug reports now to go through for it. But it's pretty neat. Yeah, I was also playing for a while yesterday, actually, with the tool. It really looks nice. And I should say that as a person who was teaching school children programming,

I really like it. I think it's a good way of just showing things to them. It looks cool. Why not to play? Why not to try breaking things? Good exercise. So do you still teach children programming? Actually, no.

I just stopped, I believe, a year ago. But yeah, I have quite a big experience. That's interesting. Maybe we should talk about that at some point. Yeah, just out of curiosity, what age range were you teaching? It was like the from age, I believe, from 12 and

to the last grades of school. So it's actually the special math classes. So the guys are actually quite cool there. So I like teaching them because they always ask something. They don't have an exact answer and that's really cool like you have to think about it for a while and that's cool

I like when they do such things yeah that's fun okay well it's been a little over a year since I first had you on the show I looked back and you were a guest on episode 5 and we talked about Sea Lion back when it was a 1.0 product.

Can you tell us about some of the changes that have been made since then? Yeah, sure. So first, thank you for having me back here. I really enjoy listening to CppCast episodes and it's a great pleasure to talk here again. So we've started Sea Lion first official release a year ago, April 14, and it was a long year. So let's take some look back at all the events, changes and trends and I'll give a short overview here for you. So since the release time we've got actually more than 400,000 downloads for the stable versions, so that's not counting the EAP builds. And as we see around 40% of our users are using C-Line on Linux, and the rest is shared

equally between Mac and Windows. And it had been a general trend since the very first AP build, I should say, and it's confirmed by the number of downloads from our site and usage statistics. So for me, it's no surprise that C-Line is more popular on Linux than on either Windows or Mac because there is Visual Studio on Windows, there is xScout on Mac and many developers consider them to be a defector standard and on Linux this situation actually differs. So

talking about like Linuxes so Ubuntu 14 is dominating among C-Line Linux users so that's something nice and And besides, we're aware about the Arch Linux packet for CLion built by the community and many other interesting Linuxes that we just see in our statistics. So on Windows, we're a bit struggling with the toolchain problems. This is the main reason for

actually uninstalling CLion on Windows. The problem is that we still rely on GCC based toolchain, so you have to use MinGW, MenGW64 or SIGWIN and that could be tricky to configure. So recently we've prepared a tutorial on how to start with CLion on Windows, including all the toolchain's configuration details, so it's located in our webhub and we finally do hope it helps so if to look back and check what big features came to the product there will be quite many i should say so variadic template support and tons of other language improvements so our c++ parser really improved during this year and now handles correctly many tricky code pieces in C++. And you know that it can be tricky, since you can write two pieces in C++ that will look the same,

however the semantic value will differ, and it's great when the parser in the IDE can handle this correctly. Thus, IDE can apply all the code completion, code generation, navigation stuff, and code refactoring to such pieces in a valid way. So, from the other features, auto-import for STL symbols. So when you start using a symbol that is not yet imported, C-Line will search and suggest adding the corresponding include or even add it automatically when you just complete the code.

So it was a bit of broken in the beginning, so we encourage you to try again. We hopefully fixed all the stuff so we added ldb on mac in addition to gdb on all the platforms and so currently we are actually introducing a huge overhaul in both drivers ldb and gdb so you could expect great performance improvements in the upcoming ep builds and hopefully we fix the quite well-known currently common timeout problem for our debugger. Attached to process if talking about the debugger like attaching to the process running locally on your machine for debugging and I do hope for attached to remote process appear before end of this

year that will lead us to remote debug as well. Predefined code style By the way, this is a great thing that grew out of a hackathon project in JetBrains last summer. So you can read some more details in our blog. So we were posting about this. So actually, the project allowed us to extract several popular code styles from the formatted code. So like Google, Qt, GNU, and braces-only styles like Alman and Kerrigan-Ritchie. And we've just published an EAP build with LLVM and LLDB code styles added, so you can try this as well. So from the other things, there is a Google test support with the building test runner and specific code generation actions, which is

really cool since it allows you to generate test stuff that is later converted automatically to the appropriate macro from Google Test, like test F or test B or something else. So then it's live templates and completion for CMake. And here we continue making CMake more pleasant to use inside of CLion with some coding assistance. And there is also Python support added. We are plugging Swift plugin and actually much more. And it's interesting to check how the users are actually using product features, how they are using them during the year that passed.

So at the beginning of this year, we actually collected and analyzed all the feature usage statistics that reports around 14% of our customers. There is a special mechanism built in the IDE, so you can enable and send us anonymous statistics, and we're really thankful to those who do so. And the results were quite expected from one side and very interesting from another, so I will share some here. Like analyzing the most popular features in each aspect of the IDE usage, we find out that the top four features for navigation across the project were GoToDeclaration, which

is 60%, ViewTypeHierarchies, which is 40%, and GoToClass by its name, which is 40% and go to class by its name which is 20%. Refactorings that are the essential part of all JetBrains tools, the list is pretty much the same and then changed since the very first release. However, we continuously working on the quality to make them just reliable and safe. So still the one-way leader is the rename refactoring and it's been used nearly by 50% by the end of 2015. And the runner-up refactoring was extract function with just 8%, I believe. So you can see that rename refactoring is the total winner here. But we do encourage all our users to try others.

I personally think that inline and pull members up, push members down, and corresponding extract super and subclass refactorings are the most helpful, especially because they can update all the corresponding context usages and track the classes hierarchy. There is, of course, a quick fix

with usage has grown up to 50% during 2015. It helps you apply a fix for a problem found in your code. And you probably know that CLI runs the code analysis on the fly, including the data flow analysis. And yeah, by the way, it was a happy test of CLI code analysis at CppCon, so at Neil's Macintosh talk.

So I was just tweeting some of his examples, which CLion captured successfully just on the fly. So that was pretty cool. There is also a bunch of plugins for CLion that became quite popular. So I can divide them into probably two groups, languages and all the rest. Among languages, plugins, there are Go and YAML and WebLanguages plugins, many of which are just bundled into the distribution package.

Python, Swift that joined the family in 2016.1 release that happened just in March. And I'll share some insights. So we also hope Rust plugin will start working for C-Line quite soon. However, it will still need CMake,

so this could be some problem. How do the language plugins work? If I add a language plugin, is it a natural experience inside of C-Line? Because we have the open source platform, there is quite a useful API, so you could just add a plugin for your own language to C-Line.

So you could just give it a try. There is a documentation of a site, and there are some samples, so you could just find it all and give it a try and see how it works. So not all the plugins were actually implemented by the team. So there are quite a lot of plugins by the third-party offers. So the repository is quite big, I should say, right now. It's the plugins.jetbrains.com. So among the second group talking about non-languages plugins,

the Vim Bindings plugin is a total winner. So, and I was actually expecting this. I'm a Vim fan totally. So, yeah, it was a total winner. So quite a lot of people are using it and that's really cool it's all for you jason yeah i might have to try that yes and talking about the first c-line year there were lots of interesting conferences that we've visited like cbp coin and meeting c++ and c++ russia and game development conference in Europe and the same edition in the United States.

ACCU, we visited it twice already and C++ Now. And the plan for next year's NIL is the same, so feel free to catch us at any of these events. We've even handled our own C++ event. We started the C++ Night

in St. Petersburg in our office in Russia. And there was lots of fun and great chats started the C++ night in St. Petersburg in our office in Russia. And there was lots of fun and great chats with the C++ developers, so it was really cool. I haven't heard of C++ Rush. Is that a Russian conference? Yeah, it's grown from the C++ user

group Russia. They have a conference now once per year. So this year it was the second edition. So last time it was in Moscow, this year it was the second edition so last time it was in moscow this year it was in st petersburg and i should say they're growing pretty fast since they're gathering all the c++ developers from russia at one event and it's really cool they have they actually had a bunch of great great speakers so i believe they will expand more is that conference mostly held in Russian, I assume?

Yeah, so just because it's C++ Russia, so we started it as... Well, I know that the conference in Berlin... Yeah, meeting C++, a lot of the talks are in English, so I just thought I'd ask. Yeah, so I should say that C++ Russia user group has started as a branch of meeting C++ Europe,

so with their help and support. And so they started the user group quite a long time ago, and they were gathering in different cities across the whole country, and then they decided to start a conference. And so the year before it was the first edition, and this year it was the second. And I really see how they are growing. So it's a really good event for Russian developers. That's amazing.

Yeah, so we really support it. So besides the conference, we've prepared tons of C++-related content in the webinar format. And C++ Annotated Blast, by the way, which we started. So C++ Annotated from JetBrains is a collection of news events and some interesting links from the whole C++ world prepared by our team. So it's published in our blog every three months, and you can easily subscribe to be just the first to get it via the email. By the way, the spring edition was published just today,

and there were lots of links to CppCast episodes which I find interesting. I saw that, yeah. Yeah, so you can find the new edition. It's just already there. Cool. Very interesting. I'm curious about the user base.

I was not surprised at all that Linux was the most popular platform for CLion, but I was actually surprised that the Windows and Mac user bases were as large as they were. Yeah, they are. So many people are doing the cross-platform development, so they come to CLion on Windows and Mac as well, so not only staying in Visual Studio or Xcode, and I believe by some more reasons. So as I've already said, we've got more than 400,000 downloads for all the stable versions. And it was calculated approximately that we have around 60,000 unique users starting

CLion every month now. And the number is constantly growing. So I can't share the number of licenses sold for sure, but we are quite satisfied with the numbers compared to how our ideas started in JetBrains. So, if talking about the customers, you can find some names on our site. For example, there is a set of licenses used by NASA and Airbnb. So, I can't name many other famous companies here who are also using C-Lines in the special agreements signed with them. But in general, I can say that as we've

expected, the majority of our customers are from the financial markets. Mostly it's traders, developers who do trading software, banks and other financial institutions. So this was expected because of our research we've made before starting the idea a couple of years ago. And as a result, we've got three biggest areas for C++ development, which are financial market, embedded development, and game development. So apart from the financial market, we are considering embedded for sure,

but we believe C-Line is still missing some features for developers there, which they are expecting, actually. Like, for example, remote debug and even remote toolchain support. So currently we are performing the big changes to improve debugger performance, and hopefully then we could move forward to remote debug as well. So, by the way, talking about debug, there is AndoDB,

which you probably heard about. I believe, yes, because you have the greclord the podcast as well so this is the set of tools which allow to record rewind and replay your cnc plus plus application so recently they were working on a plugin for c-line as well and we hope to announce it actually shortly so we're just testing it currently so it looks pretty impressive so talking about the third area like the game development there is not that much unfortunately we can't suggest them right now just apart from the code id itself i mean we don't have something specific for them however some members from the team contributes to

the unreal engine cmake support so they just ported the unreal engine to cmake to start it inside the c line we've also made some testing with the Augray engine and CryEngine as well so you could try it as well. We've managed to run it in CLion perfectly so you could do it. And there were some problems with Unreal Engine projects in CLion and those who maybe experienced it with some line macros that were not supported properly, but we fixed it, I believe, somewhere in winter, so you could try it as well.

I'm curious. You said one of the pain points for users on Windows was setting up the GCC toolchain. Is there any plans to support Visual Studio's toolchain from CLion? We actually have such a plan, but it's not the plan that is common in the nearest future. There are some reasons why

we couldn't do it easily. We would like to, but we're just limited in resources. We have a big track of features on top. The Visual C++ compiler is also on top, but not that top. The Visual C++ compiler is also on top, but not that top. Right. It seems like Microsoft probably made it easier for you recently, because now you can

download and install just the compiler without any Visual Studio. Yeah, but the problem is there that we need some things from the compiler, which Visual C++ doesn't support, and we need to find a way how to live without it. And we need some resources to do that, actually. Right. So what is on the near-term roadmap, then? We actually published a roadmap for the next release on our compliance pages, so you can find it there. It's open for everyone.

So for upcoming 2016.2 it's also there and the All Access program has already started, I believe, two or three weeks ago. So Doxygen support is already there and it includes not only the nice viewer for the Doxygen commands in the QuickDoc, the quick documentation pop-up, but also some typing assistance with the completion for parameters names and even rename refactoring so if you rename the function parameter the corresponding parameter name and the doxygen command will be updated as well and also if you type slash star star or slash star exclamation mark and then press enter in case your function has parameters returns a value or frozen exception you'll get a stub generated to fill with the documentation text so you In case your function has parameters, returns a value or throws an exception,

you'll get a stub generated to fill with the documentation text, so you can just generate some commands for your code. We plan actually even more and consider even some kind of change signature refactoring aligned with Doxygen support and other nice features. So they are still in plans and of course just feel free to suggest any to us around Oxygen or whatever. So we've also added complete statement. Complete statement, it made its way to the EAP build recently as well. So this feature allows you to insert parentheses, braces, semicolons, quotes automatically and move it.

It moves in the caret for you getting in position to start typing the next statement. So you don't have to spend time on this. We actually plan more exciting changes and some are on the way already, like debugger overhaul. So we had some problems with it for quite a long time. So it's quite a hot topic for us. Like there were step-in problems there were performance issues common timeout happened constantly and so on so finally we performed many changes in both drivers and these changes made it quicker in many places in hundred times i should say so i'm just

currently i'm just preparing the announcement for this belt and just trying to gather all the calculations and it really looks like it became much quicker and the common timeout problems hopefully have come and the step-in performs much better so works with big structures which includes lots of children child items and so on and so forth so uh i'm not sure about remote debark if it's going to come to this release or the next one so hopefully we can have it before the end of the year. So we'll see how it goes with all this debugger overhaul and all this stuff. And remote debugging would be for connecting to an IoT device or just some other machine?

So first of all, we'll start with just... So we've already implemented Attach to the local process. Then we're going to go forward with Attach to remote process. And then we can find out, just think about something more profound for embedded development. So we have a couple of free quests describing various behavior and how the people do expect it to find in the C line. But currently, we first need to find these big drivers overhaul because otherwise it will be just pointless. Yeah, so there is also some work around CMake, like save, delete, and CMake output messages

that need to be shown to the users. Quite a popular request in our track around CMake and quite a long list of various parts of resolve improvements. So if to mention some language improvements, there is a problem with some specific includes that we are trying to solve now that affects juice libraries users

and some Clang developers. And we are like investigating the problem currently. So hopefully we can have some fix for them shortly and so there is also a big list of issues that need to be verified after introducing variadic template support so you know around 100 of issues were fixed with this change however some regressions were introduced and some problems are still not verified as fixed so we need to finish this work as well before the release. And so, of course, we have a lot of big changes we'd like to introduce.

Like we are already working on some but can't estimate and just give any promises. But for sure, we would like to have LLDB on Linux. We would like to have Valgrind support and we'd like to add some testing frameworks. We for sure would like to consider Visual C++ compiler and maybe even Objective-C and C++ support in C-Line, but that's just the plans and not anything we're just working on currently just because of the lack of it. So you've mentioned other languages a few times now, and we've got Python and Swift,

and you said there's a Rust plugin made by the community, Go. When you're using them in CLion, I assume you don't have the same kind of refactoring capability and stuff that you do with C++? You have actually quite a lot of refactorings there, and the code analysis is also working. So for Python, it works, and you can just try it out. The rename refactoring for Swift is also working, So for Python, it works, and you can just try it out. The rename refactoring for Swift is also working,

just because we... Actually, this is the big job done by the AppCare team for the Swift support. We just extracted it into the separate plugin for C-Line to run it on Linux. So the rename refactoring is already working there. And all the web stuff that we have, like bundled into C-Line,

like XML or HTML or JavaScript, the refactoring, code generation, code analysis, all the things are working there as well. Oh, that's cool. So C-Line currently works with the CMake build system, and Jivni plans for adding additional build systems? Yeah, that's a very popular question, I believe. Really very popular, maybe the most popular. But seriously speaking, we actually have been trying to start adding Makefile support for half a year already.

At least we were discussing it with the team, but it's still not there. Just to understand why, let me first explain how do we use CMake project model inside CLion. So CLion actually provides you with all these smart features like refactoring, self-accomplition, code navigation, code generation, and so on. And it does it knowing the context correctly. For example, let's take rename refactoring. It checks the real context usages, not the text usages.

And, you know, as I i said before with c++ it could be tricky because some constructs may look the same but have different semantics or another example when cogeneration is working we check the feature availability in the compiler like the override directive so c-line will suggest you this tick only in case the compiler with all the options set in your CMake supports it. That means C++11 at least and the compiler version that should support it. So to be able to do all these things, CLion needs to know quite a lot about your code. And it depends on many things like source code of the project, headers included and header search paths, compiler flags, toolchain and platform used,

compiler predefined macros and some more. So C-Line analyzes your CMake project model to get all this information out of there and then uses it for parsing, resolving and various intelligent features. So that means C-Line has full infrastructure for getting this kind of information. We even have some API that is not yet final, mainly because with one build system support it cannot be final at all. So after a day more, at least one more will consider opening this API

and I believe it's absolutely necessary for those who have their custom build system, otherwise they won't be able to start with CLI. If we open the API, they will be able to write a plugin and to have their build system support inside the CLI. So this could be a great possibility for the plugin writers to add other build system support. So still, this all should start with us adding at least one more

project model support and finalizing the API that keeps currently changing quite noticeably. And to start with it, we need to fix some major issues in CMake support, because first you have our current customers using CMake, and they report some problems that are quite important and require some resources. And second, or maybe it should be first, I don't know, if we keep some issues, they will come to the second build system support as well. So probably it's better to fix them beforehand. So now we're still with CMake only, but trying to be ready for the next build system to fix all the issues.

And hopefully soon we'll be able to start adding more. Okay. So you are still using your own parser, right? You guys are not using libclang and CLion for handling your C++ stuff? Yeah, I believe. Yeah, so we're still using our own parser right you guys are not using libclang and clion for handling your c++ stuff yeah i believe yeah so we're still using our parser and i believe i answered about why not using the libclang weekly or even daily and so there are reasons of course why community keeps asking us why we're not using clang and do still do our own parser. There are many ideas using Clang, so why we can't or don't want to do the same. So I'll skip here all the historical and architectural reasons,

so you can find them in the blog post I did that's called Long Journey of C-Line article. So I won't be talking about the platform we already have for more than 16 years and need to integrate with and even won't mention app code where the C++ parser actually started. But all these difficulties can be handled in some reasonable time with the expected results. Now, of course, this will require a lot of efforts from our side. So let's here assume for a while that we are in the position when we don't have it all or

we don't need to think about it at all. So let's summarize our requirements or what we'd like to get in the IDE from the user perspective. So we need correct code that shouldn't be read. So we need no false positives in code analysis. We need no freezes, and this is crucial, so everything should be really real-time. So quick code completion, quick code highlighting here. So quick completion, quick code highlighting here. So quick means as quick as you type. I think you agree that if you have your code highlighted correctly after some time, and here you maybe can wait,

but if you have to wait for a completion list to drop down for more than half a minute, you most likely won't use it. So just useless. And so correct refactorings and all the smart features working for the whole project, not just one open file. So all these requirements, they lead us to the stage when we need, from the parser itself, we need first of all the incremental parsing, we need laziness, so do not resolve the symbol before it's used, and we need project-wide symbols cache. And from what we see now in Clang there is some

incrementality in the precompiled header support, but no project-wide symbols cache still. So we were investigating it for a while and actually this is not correct that we don't want and can't use Clang, however in its current state it doesn't make much sense for us and requires a lot of work from us that could still lead to some undefined future. So mainly because we maybe won't get the acceptable performance level. And this is somehow confirmed, but what we see in other IDEs using Clang, there are issues with reparsing

files on every opening or relying on it partially, some completion performance issues, and so on. So many IDEs like rely for refactoring still on their own parsers, not on Clang, while highlighting the code with Clang. And I don't think it will be good

if we solve the problem with the red code, but instead get a huge performance degradation for all the features to completely break the refactoring correctness. So to be honest, we are still considering some work in this direction. So we still hope we could use Clang or something very similar

because it will make our work much easier and we could once even come with some kind of project-wide cache for Clang or something. And I believe there is work in that direction considered in other C++ IDEs teams. So yes, if once we are sure that we can make it, we'll move there. And as for now, we're improving our solution. And in the background, playing with all other options, trying to find something that will work as good

as we want it so maybe it will be clang but not for now okay uh how about resharper plus plus is that also using the same parser as sea lion uh no so we actually have different parsers and it's funny but it happened mostly because of the different architectures for IntelliJ and ReSharper platforms. So because we started parser from scratch in both tools, and the architecture leads us to some things that we couldn't do the same in both tools. So I don't think we can simply merge them. However, currently we do work together, both teams, and we have several goals. So first is to unify the experience CLI and ReSharper C++ users get in terms of feature set, how the particular features behave, and so on.

And second, we, of course, share all these experiments that we were talking before with Clang and other parser options. So we do continue our common research in the background here, doing our best not to affect our current users in a bad way, so just for both of us. Alright. Looks like CLI and ReSharper++

both currently support Google Test. Do you have any plans for adding more test frameworks like Catch or CTest? So we actually, yeah, we do support Google Test and we add quite a lot of smart stuff there like not only the building test runner but some special configuration that are just detected and created automatically from your project some test generation options i were talking before and so

i hope we could add more so maybe we could add CBP unit or maybe catch, why not? Maybe boost test. So we have plenty of options. They are all locked into our tracker. But even DC test, I believe, is already locked there as well. So if you just want to affect the decision, just upload the corresponding request in the tracker. So the only reason we're currently not pushing it

is the lack of resources. So I believe a bit later, we'll go for more TDD and select the second unit testing framework that will come to C-Line. Okay. So it looks like you've got some licensing options for open source developers and other student-free options for these tools. Is that right? Yeah, that's true, indeed so. In a nutshell, we support open-source developers with free licenses,

as well as provide free licenses to students. So we also sponsor user groups with free licenses that they can raffle at the meetups. So if you are a user group organizer, just feel free to contact me directly and I'll assist. And, you know, many people asked us about the community edition for c-line the short answer is that we are not planning it at least in the nearest future and the long answer will include the fact that we have free licenses for all these groups and i'd like to add that we in the 2015 about 60% of all licenses issued for C-Line were shared for free.

So we're doing it really actively. And so 10% of all C-Line licenses went to the open source project. So you could find some famous among them, like CMake team and Kitware, like some Mozilla committers and LDB committers, some Cinder committers and many other open source projects. And above 50% went to various universities as classroom licenses and also students licenses that we're sharing for free.

Cool. Okay. Is there anything else you want to go over before we let you go today, Anastasia? I think no, if you don't have any more questions. Yeah, I think we covered everything pretty well.

Just what are your thoughts on the latest C++17? Are you happy with everything? I'm not that happy. I won't be not that happy as Bjorn was in this video. But yeah, I was expecting much more.

That's true. So model is could be really a good addition we were actually hoping to have them just as a tool vendor because it would make our lives much easier you know but we'll see how it goes so maybe it will come hopefully sooner or later hopefully okay well where can people find you online and find more information about C-Line? Yeah, so you could just go through the usual links. Like, you could go to jetbrains.com slash C-Line. You could just join our Twitter. That is C-Line ID.

You could join me, so I will provide all the links so you could just share it in the podcast page. Okay, great. Thanks again for coming back on the show, Anastasia. Yeah, thanks for having me again. And thanks for joining us. Bye. Thanks so much for listening as we chat about C++. I'd love to hear what you think of the podcast.

Please let me know if we're discussing the stuff you're interested in or if you have a suggestion for a topic. I'd love to hear that also. You can email all your thoughts to feedback at cppcast.com. I'd also appreciate if you can follow CppCast on Twitter and like CppCast on Facebook. And of course, you can find all that info and the show notes on the podcast website at cppcast.com. Theme music for this episode is provided by podcastthemes.com.