Jesper K. Pedersen

Disclaimer: This reflects CLion at the time of recording. New versions might be different.

One of the things CLion really excels in, is interactive rebase.

This video will show you how it works.

Functional programming isn’t just for Haskell or Lisp — many of its ideas have been part of C++ for years, and modern features like lambdas, std::function, ranges, and std::variant make those ideas easier to use than ever.

In this episode of 'The Curious Developer', Jesper Pedersen talks with Ivan Čukić about how to apply functional programming techniques in everyday C++ without switching languages. Ivan explains what “functional programming in C++” really means, how higher‑order functions show up in the standard algorithms, and how concepts like immutability and sum types can make code safer and easier to reason about.

C++ is still widely used in embedded systems, automotive software, and other performance-critical domains, but the language has changed significantly with modern standards. In this episode of 'The Curious Developer', Jesper Pedersen (KDAB) talks with Frances Buontempo about how to approach modern C++ in a practical, realistic way.

They discuss how C++ has evolved, why it remains relevant despite alternatives such as Rust and Java, and how developers who once used C++ full-time can catch up without reading thousand-page tomes. Frances explains why she wrote her book essentially for herself and for programmers who feel left behind by newer language features, and how focusing on a useful subset of C++ can help regain confidence.

Once you have made some changes to your files, you likely want to commit them to Git. However, you better read through your changes to ensure they are good, and do not contain debug lines or the like. This episode shows you a good workflow for exactly that.

Wouldn't it be useful if you can apply edits in your code to multiple lines, columns or even specific parts of your code at once? In this video Jesper shows various ways to block edit your code in CLion.

CLion almost has a “Go to Next Error” key binding — but it doesn’t work like Qt Creator, where F6 jumps to the next compilation error. In this video, we’ll look at how it works and how to configure it to behave the same way as Qt Creator.

This final episode of Jesper and Nicolai Josuttis talking about what’s new in C++26 and what’s coming in C++29 covers the feature freeze, minor fixes, and the debated Contracts feature, while highlighting Reflection as a game-changing addition.

CLion (with Qt Creator shortcuts) are missing a simple way to move up and down the stack in a debugging session. This episode will help you resolve that problem.

In this second of three conversations with Nicolai Josuttis, Jesper and Nicolai dive into the controversial design of Filter View in C++20, C++23, and the upcoming C++26.

In Nicolai's view, safety and usability are seriously challenged by flaws in Filter View that could have been avoided.

In this episode of The Curious Developer, Jesper Pedersen (KDAB) sits down with bestselling C++ author and long‑time standards committee member Nicolai Josuttis to talk about how C++ standards actually evolve, why C++23 is so hard to cover, and how years of teaching shape his “complete guide” books for both beginners and experts.

Wouldn't it be cool if you could easily navigate around the Qt sources, when you are doing your own development? Well, you can.

In this episode Jesper reveals two tricks for setting up your Qt Creator locator to help you.

F1 does not get you to the help for a given Qt class in CLion as it does in Qt Creator, so how do you get there?

This episode will tell you how to configure keybindings and how to tell what function is on a given key.

Should helper functions go in C++ files rather than as private member functions? Peppe provides a thorough answer beyond yes/no, explaining why you should use anonymous namespaces and static keywords for such functions. He also demonstrates an interesting bug that occurs when classes declared in cpp files aren't placed in anonymous namespaces, illustrating the practical importance of proper scoping.

With the release of Qt 6.11, Jesper Pedersen meets with Qt Group's Maycon Stamboroski to talk, among other things, about improvements including QCanvasPainter in Qt Quick, QRangeModelAdapter in QRangeModel and the benefits of the new TaskTree. What we can expect in Qt 6:12 is also discussed.

CLion comes with its own code formatter: Should you use that or clang-format?

And if you chose clang-format, how do you set that up?

Disclaimer:

This reflects CLion at the time of recording. New versions might be different.

For Qt Creator users accustomed to kits, CLion's toolchains and CMake profiles can feel opaque. Jesper Pedersen explains how CLion discovers Qt via qmake in PATH, how to define separate toolchains loading environment settings from setup files for each Qt version, and how to create CMake profiles like "Debug-6.9" to switch Qt versions like Qt Creator kits - including disabling unused profiles to avoid constant rebuilds.

Qt Designer integration in CLion is nowhere near as smooth as in Qt Creator, but you can still make working with .ui files reasonably convenient.

In this episode, Jesper Pedersen shows how to configure an External Tool for Qt Designer that always opens the matching .ui file next to your current .cpp, and then bind it to the familiar Shift+F4 shortcut so you can jump from code into the form editor with a single keystroke – plus a quick bonus on re‑binding “Open tab in new window” to Ctrl+E,4 to better mimic Qt Creator’s window handling.

In this short episode, Jesper Pedersen shows Qt Creator users how to feel at home in CLion by re‑creating their beloved Ctrl+K locator workflow. You’ll learn how CLion’s “Search Everywhere” (Shift+Shift) works, how to quickly jump between symbols, files, actions and text, and how to bind it to Ctrl+K so you stop accidentally typing into the current editor instead of switching files.

Switching IDEs is challenging - muscle memory and familiar workflows are hard to overcome. Jesper Pedersen explores JetBrains' CLion after a decade with Qt Creator, demonstrating what works well for Qt/CMake projects and what feels rough for Qt Creator users. This intro covers trying CLion safely, switching to Qt Creator keymaps, configuring existing projects, creating Qt Widgets projects, and exploring debugging and Git integration.