KDE

With 15.10 successfully released we’re sorry to announce that Jonathan Riddell, the founder of Kubuntu, has decided to step down as release manager. “Making Kubuntu over the last 10 years has been a fantastic journey. Even since I first heard about a ... [More] spaceman making a Linux distro using Debian but faster release cycles I’ve known this would be something important and wanted KDE to be part of it. Bringing together KDE and Ubuntu has created the best operating system we can and the best community to work on it. The life of an international freedom fighter is a fun one, I’ve traveled the world on private jet to meet extraordinary people and see amazing places. I watched monkeys swing from the network cables of Bengaluru and raced motorcycles through the slums of Kano. I was a a bit put out to be attacked by pirates in the Carribean but the help of the Kubuntu community and wider Ubuntu community helped me come back. Community made open source software needs people to be able to take out what they’ve put in. Ubuntu’s licences and policies enforce this. However for the last three years Ubuntu’s main sponsor Canonical has had a policy contrary to this and after much effort to try to rectify this it’s clear that isn’t going to happen. The Ubuntu leadership seems compliant with this so I find myself unable to continue helping a project that won’t obey its own community rules and I need to move on. I won’t be going far, I’ll be helping out in KDE more, the original and best end-user free software community who have always been wonderful.” You can see his full announcement here: https://lists.ubuntu.com/archives/kubuntu-devel/2015-October/010014.html [Less]

With 15.10 successfully released I’m standing down as release manager of Kubuntu. Making Kubuntu over the last 10 years has been a fantastic journey. Even since I first heard about a spaceman making a Linux distro using Debian but faster release ... [More] cycles I’ve known this would be something important and wanted KDE to be part of it. Bringing together KDE and Ubuntu has created the best operating system we can and the best community to work on it. The life of an international freedom fighter is a fun one, I’ve traveled the world on private jet to meet extraordinary people and see amazing places. I watched monkeys swing from the network cables of Bengaluru and raced motorcycles through the slums of Kano. I was a a bit put out to be attacked by pirates in the Carribean but the help of the Kubuntu community and wider Ubuntu community helped me come back. Community made open source software needs people to be able to take out what they’ve put in. Ubuntu’s licences and policies enforce this. However for the last three years Ubuntu’s main sponsor Canonical has had a policy contrary to this and after much effort to try to rectify this it’s clear that isn’t going to happen. The Ubuntu leadership seems compliant with this so I find myself unable to continue helping a project that won’t obey its own community rules and I need to move on. I won’t be going far, I’ll be helping out in KDE more, the original and best end-user free software community who have always been wonderful. In Friendship Jonathan [Less]

It is now official: KDE will be present again at FOSDEM in the 2016 edition, on the 30th and 31st of January, 2016. Talks will take place at the Desktops DevRoom, on Sunday the 31st, but not exclusively: in past years, there were Qt and KDE-related ... [More] talks at the mobile devroom, lightning talks, distributions, open document editors and more. KDE will be sharing the room with other desktop environments, as usual: Gnome, Unity, Enlightenment, Razor, etc. Representatives from those communities will be helping me in managing and organizing the devroom: Christophe Fergeau, Michael Zanetti, Philippe Caseiro and Jérome Leclanche. I would like to extend the invitation to any other free/open source desktop environment and/or related stuff. Check last year’s schedule for an example. Closed-source shops (Microsoft, Apple, Oracle, etc) are ALSO invited, provided that you will talk about something related to open source. We will publish the Call for Talks for the Desktops DevRoom 2016 soon. Stay tuned. In the meanwhile, you can subscribe to the Desktops DevRoom mailing list to be informed of important and useful information, and talk about FOSDEM and specific issues of the Desktops DevRoom. [Less]

A few weeks ago, I went to the Qt World Summit 2015. Qt World Summit I had two reasons to ... [More] be there. One was that I was giving a talk on the (functional) reactive programming with Qt. The second was to help a bit with the organization - to help people minding the KDE booth, and to chair a session. It was a nice opportunity to see some KDE friends I haven’t seen for a while, since I missed the aKademy this year. Board dinner For me, the trip started a few days before the conference, so I was there in time to join the KDE e.V. board dinner. We went to a nice place (one of my favourites) in Tiergarten. As you can see in the picture above, we left a mark on the wall of the place. I wasn’t inspired to actually draw anything more involved than a simple KDE logo, but it shows we were there. Now, while it is always nice to see other KDE people in-person, my main reason for being there was the talk. Strangely enough, even though quite a few people told me that they have no idea what “reactive” means, the room was packed. This time I wasn’t really in my element, was overly tired, but I think it went fine. I’ve had a few people contact me afterwards with further inquiries about the topic. Unfortunately, I had to skip Milian’s talk because of that. Open the video on YouTube → The main mistake I kept making this time is not to repeat the audience questions. I completely forgot that there was no microphone for the audience. I hope you’ll be able to follow the talk with all the cut-outs of audience talking. :) Read more... [Less]

Kubuntu 15.10 is available for upgrade or install. Getting Kubuntu 15.10 Upgrading from 15.04 Download a Disk Image To upgrade to Kubuntu 15.10 run Muon Update Manager and update your current system, then click on Upgrade. Full ... [More] instructions to upgrade from 15.04. Download a bootable image and put it onto a USB drive or DVD Plasma 5 slick desktop Plasma 5, the next generation of KDE’s desktop has been rewritten to make it smoother to use while retaining the familiar setup. The fourth set of updates to Plasma 5 (current release, including the fixpack) is the default in this version of Kubuntu. KDE Applications 15.08 Kubuntu comes with KDE Applications 15.08 containing all your favorite apps from KDE, including Dolphin. This is the first stability update, and contains bugfixes and translation updates. 107 applications have been ported to KDE Frameworks 5 but those which aren’t should fit in seamlessly. Non-KDE applications include LibreOffice 5.0 and Firefox 41. Known Problems Bugs tagged Kubuntu 15.10 (1413521) desktop folderview needs to be added on first boot on oem installs (1439720) Port kubuntu_langpack_desktop_files.diff for .desktop gettext support (1442512) Apport-kde crash when reporting bugs (1449265) accounts kcm can not change user’s password because kdepasswd is missing (1451728) kde-config-telepathy-accounts package install error (1490618) Ship qtdeclarative5-xmllistmodel-plugin and libqt5qml-graphicaleffects by default Feedback Development of Kubuntu 15.10, the Wily Werewolf, is ongoing and bugs are fixed every day. Before reporting bugs, please ensure your system is up to date. You can give us feedback on Google + or Facebook or Twitter or Linkedin . [Less]

Oh my, how time flies by! One month ago, I had the pleasure to travel to Bellevue, Washington, to attend CppCon 2015. It was a blast, and as a C++ developer, easily the best conference I ever attended. Below, I try to summarize my personal highlights ... [More] of the talks I attended live. Note however that there where up to six sessions running in parallel, meaning I missed most of the conference. Thankfully, nearly all sessions were recorded in high quality and are already accessible online. So, be sure to not only look at the small selection of my personal highlights below, but also look at the ton of other high-quality talks that I missed! C++ Core Guidelines This year’s biggest announcement for the C++ community at large was in my opinion the release of the C++ Core Guidelines. There were two keynotes on that topic, one by Bjarne Stroustrup on Writing Good C++14 and the other one by Herb Sutter on Writing Good C++14… By Default. These guidelines are aiming at advocating a “smaller, simpler, safer language” subset of C++. Potentially this effort can fix a whole plethora of common bugs found in C++ code. Note however, that the hundreds of rules are not meant to be read like a book cover to  cover. But they will be useful for cross-referencing from within code reviews, tools and real books. One astonishing example of how they can be applied to produce safer code is the Guideline Support Library (GSL). Together with static code analysis tools, currently developed by Microsoft, they give a foundation to prevent stack overflows, resource leaks and more, and that at close to no runtime overhead. If you want to dig deeper, there have been more talks on this topic which I sadly missed to see live: Marshall Clow on string_view Neil MacIntosh on Evolving array_view and string_view for safe C++ code Gabriel Dos Reis on Large Scale C++ with Modules: What You Should Know Gabriel Dos Reis on Contracts for Dependable C++ To me, it is interesting to see how much Microsoft is investing in that area, and I really welcome that they plan to open source their static code analysis tool which will be released in the coming weeks for Visual Studio 2015. See Neil MacIntosh’s talk on Static Analysis and C++: More Than Lint for more information. I’m really looking forward how the guidelines will evolve over time, and hope to be able to try them out soon on non-Windows platforms with Clang and/or GCC. Furthermore, it will be interesting to see how we can apply the rules to Qt. Other Highlights The other keynotes of CppCon were also all of very high quality. I’m a big fan of Sean Parent’s previous talks on Better Code. As such, it comes without surprise that his keynote on Better Code: Data Structures was again truly inspirational. Similarly, the elegance of the solution Eric Niebler’s presentation on Ranges for the Standard Library proposes for a specific problem again took me by surprise. Coming up with ideas on how to improve Qt to allow similar code, e.g. by wrapping it within reactive frameworks such as RxCpp, sounds again like an interesting research project for the future. Then, as a big fan of the Linux perf subsystem and accompanying tools, it was a pleasure for me to listen to Chandler Carruth talking about Tuning C++: Benchmarks, and CPUs, and Compilers! Oh My!. This talk, together with Bryce Adelstein-Lelbach on Benchmarking C++ Code, give a very good overview of what to keep in mind when benchmarking C++ code, and how to do it correctly. Oh, and while talking about performance analysis, I also want to point out the very interesting presentation by Scott Wardle on Memory and C++ debugging at Electronic Arts, where he presents their in-house Delta Viewer application that is not only used for debugging, but also for improving the performance of AAA games at EA. I’d love to see some similar UI tool for Qt and perf in the future… My personal prize for most entertaining talk(s) goes without thinking to Andrei Alexandrescu. His two sessions, one on Declarative Control Flow, the other on std::allocator is to Allocation what std::vector is to Vexation, more resembled a stand up comedy show from the laughs he triggered in the audience. Nonetheless, the content he delivered was once again superb and thought provoking. I can wholeheartedly recommend watching these two talks. Conceptually related, but not nearly as entertaining, was Howard Hinnant’s presentation of his C++14 approach to dates and times. I deeply respect both persons for their experience and knowledge when it comes to designing good API for complex problems, resulting in easy and fast solutions. Wrap Up To close with this summary of my CppCon 2015, I can only repeat that this is but a fraction of what was shown at CppCon 2015. I invite you to look at the schedule and to watch the recordings of every talk that is of interest to you. Similarly, if you haven’t done so already, look at past year’s recordings, which are just as educational! Finally, if you are interested to see my own talk at this year’s CppCon on Modern User Interfaces for C++, go watch it. In hindsight, I’d have liked to go more in-depth: My talk gave an overview about Qt and what you can do with it, and I still think that it was good to have. But during my conversations with various people attending the conference, it became clear that there is also high demand for in-depth sessions on Qt, i.e. similar to what we do every year at Qt Developer Days or Qt World Summit. For that purpose, I did a short 10 minute talk about CppCon at this year’s Qt World Summit, and explicitly asked for more people to hand in Qt related sessions for next year. As such, I’m looking forward to CppCon 2016 – with hopefully more Qt related content! About KDAB KDAB is a consulting company dedicated to C++ and offering a wide variety of services and providing training courses in: C++11/C++14 Qt OpenGL KDAB believes that it is critical for our business to invest into C++, Qt and OpenGL in general, to keep pushing these technologies forward and to ensure they remain competitive. The post Highlights of CppCon 2015 appeared first on KDAB. [Less]

The Qt World Summit was a rocking blast! More than 800 delegates, two days packed with sessions (and an additional training day presented by KDAB). Many old faces, lots of new ones, and a packed programme of sessions with terrific technical content. ... [More] Yours truly also happened to give a talk, “Integrating OpenGL with Qt Quick 2 applications”. In my session I showed different ways of integrating custom OpenGL code within a Qt Quick 2 application. This is a use case for which there’s more and more demand from the industry. Think for instance, of putting some fancy Qt Quick controls (buttons, sliders, etc.) overlaid on top of a 3D scene, rendered using an existing OpenGL-based solution. My session was very well received by the audience, and for that reason, instead of simply publishing my slides, I have decided to turn my session into a series of blog posts. Here we go! The Qt Quick 2 renderer In order to understand how we can hook our OpenGL code into Qt Quick, let’s take a step back and discuss how Qt Quick 2 renders a scene. The renderer subsystem of Qt Quick 2 is in fact quite a complex piece of machinery. Qt Quick 2 Rendering Qt Quick 2 leverages OpenGL and a dedicated render thread to render Qt Quick elements. First and foremost, it leverages OpenGL to render Qt Quick elements. This was a profound design decision, driven by the fact that virtually every user device these days has an OpenGL-capable GPU. Furthermore, OpenGL-based rendering is necessary if one wants to achieve drawing at a stable 60 frames per second, add special effects (drop shadows, particles, blur, etc.), have smooth animations, and so on. Hence, all of your visible elements in a scene are rendered by means of points, lines, triangles and shaders. This decision makes it also possible to easily integrate your custom, existing OpenGL within the Qt Quick renderer. Second, it was decided that the renderer may use a dedicated render thread, different from the main thread (that is, the thread that runs main()). There are two ideas behind using a separate thread for rendering: It allows the rendering to proceed (and keep animations going at 60fps) and your UI not to look stuck even if your CPU is somehow busy doing calculations, or your main thread is in some blocking function call, etc.; Symmetrically, it allows the main thread not to get stuck by the GPU, in case by accident the GPU is being too slow at rendering a scene. This dedicated thread is used on basically all the platforms supported by Qt 5.6 (excluding only ANGLE on Windows). Even if your platform isn’t supported today, chances are it will be in a future version of Qt, hence you should always take threading into account when integrating custom code with the Qt Quick renderer. The scene graph and the synchronization round But how does the renderer actually render a scene? The renderer uses a specialized data structure called a scene graph. The name “scene graph” is actually very common in the topic of 3D rendering; it refers to any data structure that can be used to analyze and optimize certain tasks (not just rendering, but also handling things such as physics simulations, path finding, etc.). I will not go in depth about how the to use the scene graph to build custom Qt Quick elements, as the purpose of this blog series is how to integrate your existing OpenGL code, so I will just show the bits relevant to this discussion. In Qt Quick’s world, the scene graph is used for rendering purposes only; and it contains all the visual information that is used to draw a scene. Keep this in mind — all the non-visual information is lost in the process. For instance, in order to draw a rectangular button, the scene graph does not know that it reacts to clicks in some way: all that it knows is that in order to draw that button, one needs first to draw a quadrilateral (actually two triangles) with certain per-vertex colors to simulate a background gradient, and draw on top a smaller quadrilateral with a texture (i.e. an image) that represents button’s text. The Qt Quick scene graph is implemented as a tree of nodes. Each node type (subclass of QSGNode, where SG stands indeed for scene graph) implements a piece of functionality, such as altering the transformation for the children, or the opacity, or holding a piece of geometry (some vertex buffers), shaders and textures for something that needs to be drawn. You can see some of the Qt Quick scene graph classes in this diagram: The scene graph is built by iterating over the QML elements. Each Qt Quick visual element type (like Rectangle, Image, Text…) builds a small tree of nodes in its override of the QQuickItem::updatePaintNode function, and returns them to the renderer. The renderer can then take these trees, analyze them and decide what’s the best strategy to paint them. “Wait a second”, the careful reader should be saying right now. How does the render thread exactly build the scene graph data structure from the QML elements, which live in the main thread? Of course, with multiple threads comes the problem of synchronization. The render thread can’t just walk over the item tree if the main thread is also modifying the elements at the same time. While one might think of starting to add locks all around but this quickly gets expensive. The solution chosen by Qt Quick is more drastic and removes the problems of handling locking explicitly. The render thread and the main thread will synchronize by pausing the main thread and therefore allowing the render thread to safely call the QQuickItem::updatePaintNode function on all the visual elements in the scene. (So, yes, updatePaintNode gets actually called from another thread). Once the render thread has done this, the main thread gets unlocked and it is free to go again. The render thread has now gathered all the information it needs to draw the scene on screen, and it will proceed to analyze the scene graph and render it. Sometimes pictures speak louder than words; this is the small dance of the main thread and the render thread synchronizing (picture taken from the Qt documentation): This is what happens every time a new frame gets requested, for instance, because a visual item in the scene has been marked as dirty (because some property changed) or because the QQuickWindow::update function gets called. This picture actually reveals something else: that during the synchronization round, the render thread will emit signals. Our first way of integrating OpenGL with Qt Quick 2 uses those signals. We can connect slots to these signals, and call OpenGL functions from those slots, therefore mixing custom OpenGL code within Qt Quick 2’s rendering, which is exactly what we wanted to do! What now? Now that we know how the Qt Quick 2 renderer works, in the subsequent posts we are going to investigate three different ways of integrating OpenGL within a Qt Quick 2 application: OpenGL underlays and overlays Custom OpenGL-based elements Manually controlling the Qt Quick rendering Stay tuned for the next blog post! About KDAB KDAB is a consulting company dedicated to Qt and offering a wide variety of services and providing training courses in: Qt OpenGL C++11/C++14 Squish. KDAB believes that it is critical for our business to invest into Qt3D and Qt, in general, to keep pushing the technology forward and to ensure it remains competitive. The post How to integrate OpenGL code with Qt Quick 2 applications (part 1) appeared first on KDAB. [Less]