Hi everyone. Yeah, 15 minutes is not much time for K-develop, so I concentrate on one part of it, mainly, in my opinion, one of the most important ones, the C++ language support.

And in my opinion, what makes us stand apart is that we try to understand your C++ code, which enables us to support quite a lot of nice features, making it possible to help you write C++ code in a much faster way. So let's start with quite a simple thing I would say. Syntax

highlighting is one of the most basic features every IDE and editor needs, and C++ is pretty hard to highlight because essentially what you need is to parse the code and to understand it, to do it properly, because this is something like no highlighting, of course. It's not very

good to find an overview there, right? So let's see how the normal editor does it. It just has a bunch of keywords it highlights, basically. So of course it's better already, but you still cannot really differentiate between what is what at a single glance, like what is the function,

what is the typedef, what is the namespace, what is the custom class, whatever. So take a look at how K-Develop does it. We parse the code, we understand it, we analyze it, we put lots of shiny colors on it, and they actually have a meaning. I mean, look at it. The namespaces are

red, the typedefs have a dark green, custom types have a bright green, and functions are blue, methods from the same class are yellow, and all that. So just a quick glance at the code, you can find out what is what, and this is really, really neat. And actually we can do more. If

you look at the bottom function, the variables are still all just bold and black, but if you turn on local colorization, we do magic and put the rainbow in there, and this really helps if you think about the three variables called VL, V1, and VY. If you don't have any highlighting,

they look nearly the same, but with color highlighting you can differentiate them very easily. So you can configure all that to your likings. What else do we have? Code completion, of course. Very important as well, and we hope that it just works. It does for most things, like

here I call some function which returns a something Q weak pointer-ish, and as you can see, it just parses the code, understands what is returned from the function, and offers you the

correct code completion. But you can also use macros if you want to. There are lots of frameworks I think which force you to use macros for quite a lot of functions, and it works as well. So this is for us the same as you would write ASDF and call that function directly. But we also understand template code. So Q weak pointer is the pointer of the foo class up there

with the bar in there, and bar is just a typedef to Q object, and we understand that all and show you the correct code completion in this case. And I think this is really, really neat

and helps you to write code very fast. What else do we have? Context-sensitive information. Quite a lot of that. Here it's just code completion as before, but if I press ALT or use the mouse to click into the completion model, we show more information about the function you're

about to execute. And we show you where it's defined, you can jump to the declaration, we show inline documentation. It's really neat, and this way you don't have to look at this kind of documentation in a manual or anything. It's all there when you need it.

We also show which function argument you're in right now. For example here I'm in a constructor of QLineEdit. I requested code completion with control space, and up above the normal completion list I show the three overloads for the constructor, and you can see what you

want to do, and what you should insert there as a type for the parameters. We do best matching. That means the items in the completion list that are greenish in the left column are supposed to be proper matches for the current function argument you're in.

So this way you often don't have to search in the possibly quite large list of valid completion items, but the most important ones are always at the top. This is very far code completion going through the include paths for your project,

and it just works as you would imagine. So code navigation. Similar to what I showed before in code completion with pressing alt, you can also move the cursor around in your code and press alt or hover a declaration or use or whatever with your mouse, and we will show this

little pop-up there giving you information about the symbol under the cursor. And you can click on the links in there and jump to the declaration or show the uses of that declaration and everything. It's very helpful and makes it possible to analyze new code very fast.

And we show macro definitions, which is sometimes very useful as well to see what is actually going on, especially if you write code and it shows you a pass error in line and you use the see the syntax error there, continue. Quite nice.

Includes. This is mainly useful to jump to the declaration. You could of course just control click on the include and it will open the file, but this is also good to give you a rough overview about what this include is supposed to do. The pop-up I showed before

gives you the ability to browse code. And in my opinion, browsing code is also one of the most outstanding features of KDevelop. Many other ADEs support that as well, but we really stress it and put it to the next level. And if you look at the pop-up, you can use alt keys,

for example, to browse through it and press enter, jump to the queue list concentrator, jump back, and you don't have to use anything else except KDevelop to view the source code in a good way.

And of course we have this funny toolbar at top, which enables you to use the IDE similar to a browser if you're looking at code. Like you can jump back, forwards, search, use the outline of a file, all that. It's very helpful. And as you can see here, this is just the

navigation menu. We have lots of features, lots of shortcuts, and eventually you will start to learn them and it makes you really fast in jumping around your code. And it's very important that you learn this if you want to use KDevelop in its full potential. So another thing, QuickOpen,

is also a toolbar up top, but you can use the shortcuts to open the dialog as well. And this way you are so fast to open any file, any class, or any function, or any combinations of these in your code. You just hit the shortcut, insert some pattern like, I don't know,

the foo bar, and it shows you every file which has foo bar in its path in your open projects or in your include path, however you want to configure it. I personally use this like 90% of the time and only the normal control O file open dialog in the other 10%, if at all.

So this is really a good feature as well. And what else do we have? Assistance. These are little helpers that are supposed to take the mundane tasks and do them for you.

For example, if you separate the implementation from the definition and have a function like this, and I just added the const foo stuff to the constructor, and it tells me like, do you want to update the declaration signature? And if I would now press alt 1 or

go with the mouse to the 1 and click on that, it would automatically update the different declaration up there. It's really, really neat. The same goes for renaming variables. For example, imagine it was before in my var in the class and I renamed it to my var 2, it offers me to, do you want to rename all

users of that variable? It works as you would expect. It's a new feature in KDevelop 4.2, by the way. There's a declaration assistant. You can write like an expression without the types, and it offers you, like, do you want to declare that as a local variable?

And it will add the type to that variable. And you can also declare it as a public variable in the class, and if you do that in the CPP file, it will automatically add it in the header, and it's very cool. It's also very useful if you work with iterators a lot, like you have something

queue list, const begin. You don't want to remember the long blob of type. You just write it equals list dot const begin, hit alt 1, and it will add the type in front. It's very useful. There's also a missing include assistant, like here I use the queue application without having

it included anywhere, and now KDevelop offers me, do you want to add the include for that file, because I found it in your include path, or instead do you want to use a forward declaration for this class? And this is also very neat. There is a overload assistant similar to code

completion. You write your class, inherit from a virtual class and just do control space in the body, and it tells you, like, do you want to overwrite the pure static ones marked with a little red flag? Do you have to do those? Or the other virtual functions, if you like to.

Then you switch to the CPP file, do the same control space, and assume that I just added these, like, five functions up there to the header. I can now press, like, execute this item, and it will write the function body there for me, and I can just write the real code I'm interested in.

So, do you have any other questions for me? Nothing? Too fast? So, yeah, thank you.

Yes, I'll be at the KDE booth if anyone has questions about KDevelop, or Master Visualize, or anything. So, yeah, thank me there. Thanks.